dilithium

.githooks/pre-commit

@@ -1,12 +0,0 @@
-#!/bin/bash
-
-# Pre-commit hook that runs the suspicious patterns check on staged files
-
-# Get the repository's root directory
-repo_root=$(git rev-parse --show-toplevel)
-
-# Run the suspicious patterns script in pre-commit mode
-"$repo_root/suspicious_patterns.sh" --pre-commit
-
-# Exit with the same code as the script
-exit $?

.githooks/setup.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-
-echo "Configuring git to use .githooks directory..."
-git config core.hooksPath .githooks

.github/actions/xahau-ga-build/action.yml

@@ -59,6 +59,7 @@ runs:
           ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-${{ inputs.main_branch }}
           ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ inputs.configuration }}-
           ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-
+          ${{ runner.os }}-ccache-v${{ inputs.cache_version }}-
 
     - name: Configure project
       shell: bash

.github/actions/xahau-ga-dependencies/action.yml

@@ -54,12 +54,13 @@ runs:
         restore-keys: |
           ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-${{ hashFiles('**/conanfile.txt', '**/conanfile.py') }}-
           ${{ runner.os }}-conan-v${{ inputs.cache_version }}-${{ inputs.compiler-id }}-
+          ${{ runner.os }}-conan-v${{ inputs.cache_version }}-
 
     - name: Export custom recipes
       shell: bash
       run: |
-        conan export external/snappy snappy/1.1.10@xahaud/stable
-        conan export external/soci soci/4.0.3@xahaud/stable
+        conan export external/snappy snappy/1.1.9@
+        conan export external/soci soci/4.0.3@
 
     - name: Install dependencies
       shell: bash
@@ -82,4 +83,4 @@ runs:
         path: |
           ~/.conan
           ~/.conan2
-        key: ${{ steps.cache-restore-conan.outputs.cache-primary-key }}
+        key: ${{ steps.cache-restore-conan.outputs.cache-primary-key }}

.github/workflows/build-in-docker.yml

@@ -32,9 +32,19 @@ jobs:
           clean: true
           fetch-depth: 2 # Only get the last 2 commits, to avoid fetching all history
 
+  checkpatterns:
+    runs-on: [self-hosted, vanity]
+    needs: checkout
+    defaults:
+      run:
+        working-directory: ${{ needs.checkout.outputs.checkout_path }}
+    steps:
+      - name: Check for suspicious patterns
+        run: /bin/bash suspicious_patterns.sh
+
   build:
     runs-on: [self-hosted, vanity]
-    needs: [checkout]
+    needs: [checkpatterns, checkout]
     defaults:
       run:
         working-directory: ${{ needs.checkout.outputs.checkout_path }}

.github/workflows/checkpatterns.yml

@@ -0,0 +1,20 @@
+name: checkpatterns
+
+on: [push, pull_request]
+
+jobs:
+  checkpatterns:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Check for suspicious patterns
+        run: |
+          if [ -f "suspicious_patterns.sh" ]; then
+            bash suspicious_patterns.sh
+          else
+            echo "Warning: suspicious_patterns.sh not found, skipping check"
+            # Still exit with success for compatibility with dependent jobs
+            exit 0
+          fi

.github/workflows/xahau-ga-nix.yml

@@ -22,14 +22,13 @@ jobs:
         configuration: [Debug]
         include:
           - compiler: gcc
-            cc: gcc-13
-            cxx: g++-13
-            compiler_id: gcc-13
-            compiler_version: 13
+            cc: gcc-11
+            cxx: g++-11
+            compiler_id: gcc-11
     env:
       build_dir: .build
       # Bump this number to invalidate all caches globally.
-      CACHE_VERSION: 2
+      CACHE_VERSION: 1
       MAIN_BRANCH_NAME: dev
     steps:
       - name: Checkout
@@ -59,8 +58,12 @@ jobs:
           conan profile update env.CXX=/usr/bin/${{ matrix.cxx }} default
           conan profile update conf.tools.build:compiler_executables='{"c": "/usr/bin/${{ matrix.cc }}", "cpp": "/usr/bin/${{ matrix.cxx }}"}' default
 
-          # Set compiler version from matrix
-          conan profile update settings.compiler.version=${{ matrix.compiler_version }} default
+          # Set correct compiler version based on matrix.compiler
+          if [ "${{ matrix.compiler }}" = "gcc" ]; then
+            conan profile update settings.compiler.version=11 default
+          elif [ "${{ matrix.compiler }}" = "clang" ]; then
+            conan profile update settings.compiler.version=14 default
+          fi
           # Display profile for verification
           conan profile show default
 
@@ -117,4 +120,4 @@ jobs:
           else
              echo "Error: rippled executable not found in ${{ env.build_dir }}"
              exit 1
-          fi
+          fi

.gitignore

@@ -24,11 +24,6 @@ bin/project-cache.jam
 
 build/docker
 
-# Ignore release builder files
-.env
-release-build
-cmake-*.tar.gz
-
 # Ignore object files.
 *.o
 build

BUILD.md

@@ -117,14 +117,14 @@ can't build earlier Boost versions.
    which allows you to statically link it with GCC, if you want.
 
    ```
-   conan export external/snappy snappy/1.1.10@xahaud/stable
+   conan export external/snappy snappy/1.1.9@
    ```
 
 5. Export our [Conan recipe for SOCI](./external/soci).
    It patches their CMake to correctly import its dependencies.
 
    ```
-   conan export external/soci soci/4.0.3@xahaud/stable
+   conan export external/soci soci/4.0.3@
    ```
 
 ### Build and Test

Builds/CMake/RippledCore.cmake

@@ -153,6 +153,7 @@ target_link_libraries (xrpl_core
     Ripple::syslibs
     secp256k1::secp256k1
     ed25519::ed25519
+    NIH::dilithium2_ref
     date::date
     Ripple::opts)
 #[=================================[
@@ -440,7 +441,6 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/CashCheck.cpp
   src/ripple/app/tx/impl/Change.cpp
   src/ripple/app/tx/impl/ClaimReward.cpp
-  src/ripple/app/tx/impl/Clawback.cpp
   src/ripple/app/tx/impl/CreateCheck.cpp
   src/ripple/app/tx/impl/CreateOffer.cpp
   src/ripple/app/tx/impl/CreateTicket.cpp
@@ -548,6 +548,7 @@ target_sources (rippled PRIVATE
   src/ripple/nodestore/backend/CassandraFactory.cpp
   src/ripple/nodestore/backend/RWDBFactory.cpp
   src/ripple/nodestore/backend/MemoryFactory.cpp
+  src/ripple/nodestore/backend/FlatmapFactory.cpp
   src/ripple/nodestore/backend/NuDBFactory.cpp
   src/ripple/nodestore/backend/NullFactory.cpp
   src/ripple/nodestore/backend/RocksDBFactory.cpp
@@ -721,7 +722,6 @@ if (tests)
     src/test/app/BaseFee_test.cpp
     src/test/app/Check_test.cpp
     src/test/app/ClaimReward_test.cpp
-    src/test/app/Clawback_test.cpp
     src/test/app/CrossingLimits_test.cpp
     src/test/app/DeliverMin_test.cpp
     src/test/app/DepositAuth_test.cpp
@@ -752,7 +752,6 @@ if (tests)
     src/test/app/Path_test.cpp
     src/test/app/PayChan_test.cpp
     src/test/app/PayStrand_test.cpp
-    src/test/app/PreviousTxn_test.cpp
     src/test/app/PseudoTx_test.cpp
     src/test/app/RCLCensorshipDetector_test.cpp
     src/test/app/RCLValidations_test.cpp
@@ -915,7 +914,6 @@ if (tests)
     src/test/jtx/impl/seq.cpp
     src/test/jtx/impl/sig.cpp
     src/test/jtx/impl/tag.cpp
-    src/test/jtx/impl/TestHelpers.cpp
     src/test/jtx/impl/ticket.cpp
     src/test/jtx/impl/token.cpp
     src/test/jtx/impl/trust.cpp
@@ -994,11 +992,6 @@ if (tests)
          subdir: resource
     #]===============================]
     src/test/resource/Logic_test.cpp
-    #[===============================[
-       test sources:
-         subdir: rdb
-    #]===============================]
-    src/test/rdb/RelationalDatabase_test.cpp
     #[===============================[
        test sources:
          subdir: rpc
@@ -1072,11 +1065,6 @@ target_link_libraries (rippled
   Ripple::opts
   Ripple::libs
   Ripple::xrpl_core
-  # Workaround for a Conan 1.x bug that prevents static linking of libstdc++
-  # when a dependency (snappy) modifies system_libs. See the comment in
-  # external/snappy/conanfile.py for a full explanation.
-  # This is likely not strictly necessary, but listed explicitly as a good practice.
-  m
   )
 exclude_if_included (rippled)
 # define a macro for tests that might need to

Builds/CMake/RippledNIH.cmake

@@ -0,0 +1,33 @@
+#[===================================================================[
+   NIH prefix path..this is where we will download
+   and build any ExternalProjects, and they will hopefully
+   survive across build directory deletion (manual cleans)
+#]===================================================================]
+
+string (REGEX REPLACE "[ \\/%]+" "_" gen_for_path ${CMAKE_GENERATOR})
+string (TOLOWER ${gen_for_path} gen_for_path)
+# HACK: trying to shorten paths for windows CI (which hits 260 MAXPATH easily)
+# @see:  https://issues.jenkins-ci.org/browse/JENKINS-38706?focusedCommentId=339847
+string (REPLACE "visual_studio" "vs" gen_for_path ${gen_for_path})
+if (NOT DEFINED NIH_CACHE_ROOT)
+  if (DEFINED ENV{NIH_CACHE_ROOT})
+    set (NIH_CACHE_ROOT $ENV{NIH_CACHE_ROOT})
+  else ()
+    set (NIH_CACHE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/.nih_c")
+  endif ()
+endif ()
+set (nih_cache_path
+  "${NIH_CACHE_ROOT}/${gen_for_path}/${CMAKE_CXX_COMPILER_ID}_${CMAKE_CXX_COMPILER_VERSION}")
+if (NOT is_multiconfig)
+  set (nih_cache_path "${nih_cache_path}/${CMAKE_BUILD_TYPE}")
+endif ()
+file(TO_CMAKE_PATH "${nih_cache_path}" nih_cache_path)
+message (STATUS "NIH-EP cache path: ${nih_cache_path}")
+## two convenience variables:
+set (ep_lib_prefix ${CMAKE_STATIC_LIBRARY_PREFIX})
+set (ep_lib_suffix ${CMAKE_STATIC_LIBRARY_SUFFIX})
+
+# this is a setting for FetchContent and needs to be
+# a cache variable
+# https://cmake.org/cmake/help/latest/module/FetchContent.html#populating-the-content
+set (FETCHCONTENT_BASE_DIR ${nih_cache_path} CACHE STRING "" FORCE)

Builds/CMake/conan/Boost.cmake

@@ -0,0 +1,52 @@
+find_package(Boost 1.83 REQUIRED
+  COMPONENTS
+    chrono
+    container
+    context
+    coroutine
+    date_time
+    filesystem
+    program_options
+    regex
+    system
+    thread
+)
+
+add_library(ripple_boost INTERFACE)
+add_library(Ripple::boost ALIAS ripple_boost)
+if(XCODE)
+  target_include_directories(ripple_boost BEFORE INTERFACE ${Boost_INCLUDE_DIRS})
+  target_compile_options(ripple_boost INTERFACE --system-header-prefix="boost/")
+else()
+  target_include_directories(ripple_boost SYSTEM BEFORE INTERFACE ${Boost_INCLUDE_DIRS})
+endif()
+
+target_link_libraries(ripple_boost
+  INTERFACE
+    Boost::boost
+    Boost::chrono
+    Boost::container
+    Boost::coroutine
+    Boost::date_time
+    Boost::filesystem
+    Boost::program_options
+    Boost::regex
+    Boost::system
+    Boost::iostreams
+    Boost::thread)
+if(Boost_COMPILER)
+  target_link_libraries(ripple_boost INTERFACE Boost::disable_autolinking)
+endif()
+if(san AND is_clang)
+  # TODO: gcc does not support -fsanitize-blacklist...can we do something else
+  # for gcc ?
+  if(NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
+    get_target_property(Boost_INCLUDE_DIRS Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
+  endif()
+  message(STATUS "Adding [${Boost_INCLUDE_DIRS}] to sanitizer blacklist")
+  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt "src:${Boost_INCLUDE_DIRS}/*")
+  target_compile_options(opts
+    INTERFACE
+      # ignore boost headers for sanitizing
+      -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
+endif()

Builds/CMake/conan/Protobuf.cmake

@@ -0,0 +1,22 @@
+find_package(Protobuf 3.8)
+
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/proto_gen)
+set(ccbd ${CMAKE_CURRENT_BINARY_DIR})
+set(CMAKE_CURRENT_BINARY_DIR ${CMAKE_BINARY_DIR}/proto_gen)
+protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS src/ripple/proto/ripple.proto)
+set(CMAKE_CURRENT_BINARY_DIR ${ccbd})
+
+add_library(pbufs STATIC ${PROTO_SRCS} ${PROTO_HDRS})
+target_include_directories(pbufs SYSTEM PUBLIC
+  ${CMAKE_BINARY_DIR}/proto_gen
+  ${CMAKE_BINARY_DIR}/proto_gen/src/ripple/proto
+)
+target_link_libraries(pbufs protobuf::libprotobuf)
+target_compile_options(pbufs
+  PUBLIC
+    $<$<BOOL:${XCODE}>:
+      --system-header-prefix="google/protobuf"
+      -Wno-deprecated-dynamic-exception-spec
+    >
+)
+add_library(Ripple::pbufs ALIAS pbufs)

Builds/CMake/conan/gRPC.cmake

@@ -0,0 +1,62 @@
+find_package(gRPC 1.23)
+
+#[=================================[
+   generate protobuf sources for
+   grpc defs and bundle into a
+   static lib
+#]=================================]
+set(GRPC_GEN_DIR "${CMAKE_BINARY_DIR}/proto_gen_grpc")
+file(MAKE_DIRECTORY ${GRPC_GEN_DIR})
+set(GRPC_PROTO_SRCS)
+set(GRPC_PROTO_HDRS)
+set(GRPC_PROTO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/proto/org")
+file(GLOB_RECURSE GRPC_DEFINITION_FILES LIST_DIRECTORIES false "${GRPC_PROTO_ROOT}/*.proto")
+foreach(file ${GRPC_DEFINITION_FILES})
+  get_filename_component(_abs_file ${file} ABSOLUTE)
+  get_filename_component(_abs_dir ${_abs_file} DIRECTORY)
+  get_filename_component(_basename ${file} NAME_WE)
+  get_filename_component(_proto_inc ${GRPC_PROTO_ROOT} DIRECTORY) # updir one level
+  file(RELATIVE_PATH _rel_root_file ${_proto_inc} ${_abs_file})
+  get_filename_component(_rel_root_dir ${_rel_root_file} DIRECTORY)
+  file(RELATIVE_PATH _rel_dir ${CMAKE_CURRENT_SOURCE_DIR} ${_abs_dir})
+
+  set(src_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.cc")
+  set(src_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.cc")
+  set(hdr_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.h")
+  set(hdr_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.h")
+  add_custom_command(
+    OUTPUT ${src_1} ${src_2} ${hdr_1} ${hdr_2}
+    COMMAND protobuf::protoc
+    ARGS --grpc_out=${GRPC_GEN_DIR}
+         --cpp_out=${GRPC_GEN_DIR}
+         --plugin=protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
+         -I ${_proto_inc} -I ${_rel_dir}
+         ${_abs_file}
+    DEPENDS ${_abs_file} protobuf::protoc gRPC::grpc_cpp_plugin
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Running gRPC C++ protocol buffer compiler on ${file}"
+    VERBATIM)
+    set_source_files_properties(${src_1} ${src_2} ${hdr_1} ${hdr_2} PROPERTIES GENERATED TRUE)
+    list(APPEND GRPC_PROTO_SRCS ${src_1} ${src_2})
+    list(APPEND GRPC_PROTO_HDRS ${hdr_1} ${hdr_2})
+endforeach()
+
+add_library(grpc_pbufs STATIC ${GRPC_PROTO_SRCS} ${GRPC_PROTO_HDRS})
+#target_include_directories(grpc_pbufs PRIVATE src)
+target_include_directories(grpc_pbufs SYSTEM PUBLIC ${GRPC_GEN_DIR})
+target_link_libraries(grpc_pbufs
+  "gRPC::grpc++"
+  # libgrpc is missing references.
+  absl::random_random
+)
+target_compile_options(grpc_pbufs
+  PRIVATE
+    $<$<BOOL:${MSVC}>:-wd4065>
+    $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
+  PUBLIC
+    $<$<BOOL:${MSVC}>:-wd4996>
+    $<$<BOOL:${XCODE}>:
+      --system-header-prefix="google/protobuf"
+      -Wno-deprecated-dynamic-exception-spec
+    >)
+add_library(Ripple::grpc_pbufs ALIAS grpc_pbufs)

Builds/CMake/deps/Boost.cmake

@@ -1,3 +1,51 @@
+#[===================================================================[
+   NIH dep: boost
+#]===================================================================]
+if((NOT DEFINED BOOST_ROOT) AND(DEFINED ENV{BOOST_ROOT}))
+  set(BOOST_ROOT $ENV{BOOST_ROOT})
+endif()
+if((NOT DEFINED BOOST_LIBRARYDIR) AND(DEFINED ENV{BOOST_LIBRARYDIR}))
+  set(BOOST_LIBRARYDIR $ENV{BOOST_LIBRARYDIR})
+endif()
+file(TO_CMAKE_PATH "${BOOST_ROOT}" BOOST_ROOT)
+if(WIN32 OR CYGWIN)
+  # Workaround for MSVC having two boost versions - x86 and x64 on same PC in stage folders
+  if((NOT DEFINED BOOST_LIBRARYDIR) AND (DEFINED BOOST_ROOT))
+    if(IS_DIRECTORY ${BOOST_ROOT}/stage64/lib)
+      set(BOOST_LIBRARYDIR ${BOOST_ROOT}/stage64/lib)
+    elseif(IS_DIRECTORY ${BOOST_ROOT}/stage/lib)
+      set(BOOST_LIBRARYDIR ${BOOST_ROOT}/stage/lib)
+    elseif(IS_DIRECTORY ${BOOST_ROOT}/lib)
+      set(BOOST_LIBRARYDIR ${BOOST_ROOT}/lib)
+    else()
+      message(WARNING "Did not find expected boost library dir. "
+        "Defaulting to ${BOOST_ROOT}")
+      set(BOOST_LIBRARYDIR ${BOOST_ROOT})
+    endif()
+  endif()
+endif()
+message(STATUS "BOOST_ROOT: ${BOOST_ROOT}")
+message(STATUS "BOOST_LIBRARYDIR: ${BOOST_LIBRARYDIR}")
+
+# uncomment the following as needed to debug FindBoost issues:
+#set(Boost_DEBUG ON)
+
+#[=========================================================[
+   boost dynamic libraries don't trivially support @rpath
+   linking right now (cmake's default), so just force
+   static linking for macos, or if requested on linux by flag
+#]=========================================================]
+if(static)
+  set(Boost_USE_STATIC_LIBS ON)
+endif()
+set(Boost_USE_MULTITHREADED ON)
+if(static AND NOT APPLE)
+  set(Boost_USE_STATIC_RUNTIME ON)
+else()
+  set(Boost_USE_STATIC_RUNTIME OFF)
+endif()
+# TBD:
+# Boost_USE_DEBUG_RUNTIME:  When ON, uses Boost libraries linked against the
 find_package(Boost 1.86 REQUIRED
   COMPONENTS
     chrono
@@ -9,12 +57,12 @@ find_package(Boost 1.86 REQUIRED
     program_options
     regex
     system
-    thread
-)
+    iostreams
+    thread)
 
 add_library(ripple_boost INTERFACE)
 add_library(Ripple::boost ALIAS ripple_boost)
-if(XCODE)
+if(is_xcode)
   target_include_directories(ripple_boost BEFORE INTERFACE ${Boost_INCLUDE_DIRS})
   target_compile_options(ripple_boost INTERFACE --system-header-prefix="boost/")
 else()
@@ -29,10 +77,10 @@ target_link_libraries(ripple_boost
     Boost::coroutine
     Boost::date_time
     Boost::filesystem
+    Boost::iostreams
     Boost::program_options
     Boost::regex
     Boost::system
-    Boost::iostreams
     Boost::thread)
 if(Boost_COMPILER)
   target_link_libraries(ripple_boost INTERFACE Boost::disable_autolinking)

Builds/CMake/deps/Ed25519-donna.cmake

@@ -0,0 +1,28 @@
+#[===================================================================[
+   NIH dep: ed25519-donna
+#]===================================================================]
+
+add_library (ed25519-donna STATIC
+  src/ed25519-donna/ed25519.c)
+target_include_directories (ed25519-donna
+  PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+    $<INSTALL_INTERFACE:include>
+  PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/ed25519-donna)
+#[=========================================================[
+   NOTE for macos:
+   https://github.com/floodyberry/ed25519-donna/issues/29
+   our source for ed25519-donna-portable.h has been
+   patched to workaround this.
+#]=========================================================]
+target_link_libraries (ed25519-donna PUBLIC OpenSSL::SSL)
+add_library (NIH::ed25519-donna ALIAS ed25519-donna)
+target_link_libraries (ripple_libs INTERFACE NIH::ed25519-donna)
+#[===========================[
+   headers installation
+#]===========================]
+install (
+  FILES
+    src/ed25519-donna/ed25519.h
+  DESTINATION include/ed25519-donna)

Builds/CMake/deps/Findjemalloc.cmake

@@ -0,0 +1,47 @@
+# - Try to find jemalloc
+# Once done this will define
+#  JEMALLOC_FOUND - System has jemalloc
+#  JEMALLOC_INCLUDE_DIRS - The jemalloc include directories
+#  JEMALLOC_LIBRARIES - The libraries needed to use jemalloc
+
+if(NOT USE_BUNDLED_JEMALLOC)
+  find_package(PkgConfig)
+  if (PKG_CONFIG_FOUND)
+    pkg_check_modules(PC_JEMALLOC QUIET jemalloc)
+  endif()
+else()
+  set(PC_JEMALLOC_INCLUDEDIR)
+  set(PC_JEMALLOC_INCLUDE_DIRS)
+  set(PC_JEMALLOC_LIBDIR)
+  set(PC_JEMALLOC_LIBRARY_DIRS)
+  set(LIMIT_SEARCH NO_DEFAULT_PATH)
+endif()
+
+set(JEMALLOC_DEFINITIONS ${PC_JEMALLOC_CFLAGS_OTHER})
+
+find_path(JEMALLOC_INCLUDE_DIR jemalloc/jemalloc.h
+          PATHS ${PC_JEMALLOC_INCLUDEDIR} ${PC_JEMALLOC_INCLUDE_DIRS}
+          ${LIMIT_SEARCH})
+
+# If we're asked to use static linkage, add libjemalloc.a as a preferred library name.
+if(JEMALLOC_USE_STATIC)
+  list(APPEND JEMALLOC_NAMES
+    "${CMAKE_STATIC_LIBRARY_PREFIX}jemalloc${CMAKE_STATIC_LIBRARY_SUFFIX}")
+endif()
+
+list(APPEND JEMALLOC_NAMES jemalloc)
+
+find_library(JEMALLOC_LIBRARY NAMES ${JEMALLOC_NAMES}
+  HINTS ${PC_JEMALLOC_LIBDIR} ${PC_JEMALLOC_LIBRARY_DIRS}
+  ${LIMIT_SEARCH})
+
+set(JEMALLOC_LIBRARIES ${JEMALLOC_LIBRARY})
+set(JEMALLOC_INCLUDE_DIRS ${JEMALLOC_INCLUDE_DIR})
+
+include(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set JEMALLOC_FOUND to TRUE
+# if all listed variables are TRUE
+find_package_handle_standard_args(JeMalloc DEFAULT_MSG
+  JEMALLOC_LIBRARY JEMALLOC_INCLUDE_DIR)
+
+mark_as_advanced(JEMALLOC_INCLUDE_DIR JEMALLOC_LIBRARY)

Builds/CMake/deps/Findlibarchive_pc.cmake

@@ -0,0 +1,22 @@
+find_package (PkgConfig REQUIRED)
+pkg_search_module (libarchive_PC QUIET libarchive>=3.4.3)
+
+if(static)
+  set(LIBARCHIVE_LIB libarchive.a)
+else()
+  set(LIBARCHIVE_LIB archive)
+endif()
+
+find_library (archive
+  NAMES ${LIBARCHIVE_LIB}
+  HINTS
+    ${libarchive_PC_LIBDIR}
+    ${libarchive_PC_LIBRARY_DIRS}
+  NO_DEFAULT_PATH)
+
+find_path (LIBARCHIVE_INCLUDE_DIR
+  NAMES archive.h
+  HINTS
+    ${libarchive_PC_INCLUDEDIR}
+    ${libarchive_PC_INCLUDEDIRS}
+  NO_DEFAULT_PATH)

Builds/CMake/deps/Findlz4.cmake

@@ -0,0 +1,24 @@
+find_package (PkgConfig)
+if (PKG_CONFIG_FOUND)
+  pkg_search_module (lz4_PC QUIET liblz4>=1.9)
+endif ()
+
+if(static)
+  set(LZ4_LIB liblz4.a)
+else()
+  set(LZ4_LIB lz4.so)
+endif()
+
+find_library (lz4
+  NAMES ${LZ4_LIB}
+  HINTS
+    ${lz4_PC_LIBDIR}
+    ${lz4_PC_LIBRARY_DIRS}
+  NO_DEFAULT_PATH)
+
+find_path (LZ4_INCLUDE_DIR
+  NAMES lz4.h
+  HINTS
+    ${lz4_PC_INCLUDEDIR}
+    ${lz4_PC_INCLUDEDIRS}
+  NO_DEFAULT_PATH)

Builds/CMake/deps/Findsecp256k1.cmake

@@ -0,0 +1,24 @@
+find_package (PkgConfig)
+if (PKG_CONFIG_FOUND)
+  pkg_search_module (secp256k1_PC QUIET libsecp256k1)
+endif ()
+
+if(static)
+  set(SECP256K1_LIB libsecp256k1.a)
+else()
+  set(SECP256K1_LIB secp256k1)
+endif()
+
+find_library(secp256k1
+  NAMES ${SECP256K1_LIB}
+  HINTS
+    ${secp256k1_PC_LIBDIR}
+    ${secp256k1_PC_LIBRARY_PATHS}
+  NO_DEFAULT_PATH)
+
+find_path (SECP256K1_INCLUDE_DIR
+  NAMES secp256k1.h
+  HINTS
+    ${secp256k1_PC_INCLUDEDIR}
+    ${secp256k1_PC_INCLUDEDIRS}
+  NO_DEFAULT_PATH)

Builds/CMake/deps/Findsnappy.cmake

@@ -0,0 +1,24 @@
+find_package (PkgConfig)
+if (PKG_CONFIG_FOUND)
+  pkg_search_module (snappy_PC QUIET snappy>=1.1.7)
+endif ()
+
+if(static)
+  set(SNAPPY_LIB libsnappy.a)
+else()
+  set(SNAPPY_LIB libsnappy.so)
+endif()
+
+find_library (snappy
+  NAMES ${SNAPPY_LIB}
+  HINTS
+    ${snappy_PC_LIBDIR}
+    ${snappy_PC_LIBRARY_DIRS}
+  NO_DEFAULT_PATH)
+
+find_path (SNAPPY_INCLUDE_DIR
+  NAMES snappy.h
+  HINTS
+    ${snappy_PC_INCLUDEDIR}
+    ${snappy_PC_INCLUDEDIRS}
+  NO_DEFAULT_PATH)

Builds/CMake/deps/Findsoci.cmake

@@ -0,0 +1,19 @@
+find_package (PkgConfig)
+if (PKG_CONFIG_FOUND)
+  # TBD - currently no soci pkgconfig
+  #pkg_search_module (soci_PC QUIET libsoci_core>=3.2)
+endif ()
+
+if(static)
+  set(SOCI_LIB libsoci.a)
+else()
+  set(SOCI_LIB libsoci_core.so)
+endif()
+
+find_library (soci
+  NAMES ${SOCI_LIB})
+
+find_path (SOCI_INCLUDE_DIR
+  NAMES soci/soci.h)
+
+message("SOCI FOUND AT: ${SOCI_LIB}")

Builds/CMake/deps/Findsqlite.cmake

@@ -0,0 +1,24 @@
+find_package (PkgConfig)
+if (PKG_CONFIG_FOUND)
+  pkg_search_module (sqlite_PC QUIET sqlite3>=3.26.0)
+endif ()
+
+if(static)
+  set(SQLITE_LIB libsqlite3.a)
+else()
+  set(SQLITE_LIB sqlite3.so)
+endif()
+
+find_library (sqlite3
+  NAMES ${SQLITE_LIB}
+  HINTS
+    ${sqlite_PC_LIBDIR}
+    ${sqlite_PC_LIBRARY_DIRS}
+  NO_DEFAULT_PATH)
+
+find_path (SQLITE_INCLUDE_DIR
+  NAMES sqlite3.h
+  HINTS
+    ${sqlite_PC_INCLUDEDIR}
+    ${sqlite_PC_INCLUDEDIRS}
+  NO_DEFAULT_PATH)

Builds/CMake/deps/Libarchive.cmake

@@ -0,0 +1,163 @@
+#[===================================================================[
+   NIH dep: libarchive
+#]===================================================================]
+
+option (local_libarchive "use local build of libarchive." OFF)
+add_library (archive_lib UNKNOWN IMPORTED GLOBAL)
+
+if (NOT local_libarchive)
+  if (NOT WIN32)
+    find_package(libarchive_pc REQUIRED)
+  endif ()
+  if (archive)
+    message (STATUS "Found libarchive using pkg-config. Using ${archive}.")
+    set_target_properties (archive_lib PROPERTIES
+      IMPORTED_LOCATION_DEBUG
+        ${archive}
+      IMPORTED_LOCATION_RELEASE
+        ${archive}
+      INTERFACE_INCLUDE_DIRECTORIES
+        ${LIBARCHIVE_INCLUDE_DIR})
+      # pkg-config can return extra info for static lib linking
+      # this is probably needed/useful generally, but apply
+      # to APPLE for now (mostly for homebrew)
+      if (APPLE AND static AND libarchive_PC_STATIC_LIBRARIES)
+        message(STATUS "NOTE: libarchive static libs: ${libarchive_PC_STATIC_LIBRARIES}")
+        # also, APPLE seems to need iconv...maybe linux does too (TBD)
+        target_link_libraries (archive_lib
+          INTERFACE iconv ${libarchive_PC_STATIC_LIBRARIES})
+      endif ()
+  else ()
+    ## now try searching using the minimal find module that cmake provides
+    find_package(LibArchive 3.4.3 QUIET)
+    if (LibArchive_FOUND)
+      if (static)
+        # find module doesn't find static libs currently, so we re-search
+        get_filename_component(_loc ${LibArchive_LIBRARY} DIRECTORY)
+        find_library(_la_static
+          NAMES libarchive.a archive_static.lib archive.lib
+          PATHS ${_loc})
+        if (_la_static)
+          set (_la_lib ${_la_static})
+        else ()
+          message (WARNING "unable to find libarchive static lib - switching to local build")
+          set (local_libarchive ON CACHE BOOL "" FORCE)
+        endif ()
+      else ()
+        set (_la_lib ${LibArchive_LIBRARY})
+      endif ()
+      if (NOT local_libarchive)
+        message (STATUS "Found libarchive using module/config. Using ${_la_lib}.")
+        set_target_properties (archive_lib PROPERTIES
+          IMPORTED_LOCATION_DEBUG
+            ${_la_lib}
+          IMPORTED_LOCATION_RELEASE
+            ${_la_lib}
+          INTERFACE_INCLUDE_DIRECTORIES
+            ${LibArchive_INCLUDE_DIRS})
+      endif ()
+    else ()
+      set (local_libarchive ON CACHE BOOL "" FORCE)
+    endif ()
+  endif ()
+endif()
+
+if (local_libarchive)
+  set (lib_post "")
+  if (MSVC)
+    set (lib_post "_static")
+  endif ()
+  ExternalProject_Add (libarchive
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/libarchive/libarchive.git
+    GIT_TAG v3.4.3
+    CMAKE_ARGS
+      # passing the compiler seems to be needed for windows CI, sadly
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      -DENABLE_LZ4=ON
+      -ULZ4_*
+      -DLZ4_INCLUDE_DIR=$<JOIN:$<TARGET_PROPERTY:lz4_lib,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      # because we are building a static lib, this lz4 library doesn't
+      # actually matter since you can't generally link static libs to other static
+      # libs. The include files are needed, but the library itself is not (until
+      # we link our application, at which point we use the lz4 we built above).
+      # nonetheless, we need to provide a library to libarchive else it will
+      # NOT include lz4 support when configuring
+      -DLZ4_LIBRARY=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:lz4_lib,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:lz4_lib,IMPORTED_LOCATION_RELEASE>>
+      -DENABLE_WERROR=OFF
+      -DENABLE_TAR=OFF
+      -DENABLE_TAR_SHARED=OFF
+      -DENABLE_INSTALL=ON
+      -DENABLE_NETTLE=OFF
+      -DENABLE_OPENSSL=OFF
+      -DENABLE_LZO=OFF
+      -DENABLE_LZMA=OFF
+      -DENABLE_ZLIB=OFF
+      -DENABLE_BZip2=OFF
+      -DENABLE_LIBXML2=OFF
+      -DENABLE_EXPAT=OFF
+      -DENABLE_PCREPOSIX=OFF
+      -DENABLE_LibGCC=OFF
+      -DENABLE_CNG=OFF
+      -DENABLE_CPIO=OFF
+      -DENABLE_CPIO_SHARED=OFF
+      -DENABLE_CAT=OFF
+      -DENABLE_CAT_SHARED=OFF
+      -DENABLE_XATTR=OFF
+      -DENABLE_ACL=OFF
+      -DENABLE_ICONV=OFF
+      -DENABLE_TEST=OFF
+      -DENABLE_COVERAGE=OFF
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+        "-DCMAKE_C_FLAGS_DEBUG=-MTd"
+        "-DCMAKE_C_FLAGS_RELEASE=-MT"
+      >
+    LIST_SEPARATOR ::
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --target archive_static
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+            <BINARY_DIR>/libarchive/$<CONFIG>/${ep_lib_prefix}archive${lib_post}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>/libarchive
+        >
+    TEST_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS lz4_lib
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/libarchive/${ep_lib_prefix}archive${lib_post}${ep_lib_suffix}
+      <BINARY_DIR>/libarchive/${ep_lib_prefix}archive${lib_post}_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (libarchive BINARY_DIR)
+  ExternalProject_Get_Property (libarchive SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (libarchive)
+  endif ()
+  file (MAKE_DIRECTORY ${SOURCE_DIR}/libarchive)
+  set_target_properties (archive_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/libarchive/${ep_lib_prefix}archive${lib_post}_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/libarchive/${ep_lib_prefix}archive${lib_post}${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SOURCE_DIR}/libarchive
+    INTERFACE_COMPILE_DEFINITIONS
+      LIBARCHIVE_STATIC)
+endif()
+
+add_dependencies (archive_lib libarchive)
+target_link_libraries (archive_lib INTERFACE lz4_lib)
+target_link_libraries (ripple_libs INTERFACE archive_lib)
+exclude_if_included (libarchive)
+exclude_if_included (archive_lib)

Builds/CMake/deps/Lz4.cmake

@@ -0,0 +1,79 @@
+#[===================================================================[
+   NIH dep: lz4
+#]===================================================================]
+
+add_library (lz4_lib STATIC IMPORTED GLOBAL)
+
+if (NOT WIN32)
+  find_package(lz4)
+endif()
+
+if(lz4)
+  set_target_properties (lz4_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${lz4}
+    IMPORTED_LOCATION_RELEASE
+      ${lz4}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${LZ4_INCLUDE_DIR})
+
+else()
+  ExternalProject_Add (lz4
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/lz4/lz4.git
+    GIT_TAG v1.9.2
+    SOURCE_SUBDIR contrib/cmake_unofficial
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      -DBUILD_STATIC_LIBS=ON
+      -DBUILD_SHARED_LIBS=OFF
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+        "-DCMAKE_C_FLAGS_DEBUG=-MTd"
+        "-DCMAKE_C_FLAGS_RELEASE=-MT"
+      >
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --target lz4_static
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+          <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}lz4$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>
+        >
+    TEST_COMMAND ""
+    INSTALL_COMMAND ""
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/${ep_lib_prefix}lz4${ep_lib_suffix}
+      <BINARY_DIR>/${ep_lib_prefix}lz4_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (lz4 BINARY_DIR)
+  ExternalProject_Get_Property (lz4 SOURCE_DIR)
+
+  file (MAKE_DIRECTORY ${SOURCE_DIR}/lz4)
+  set_target_properties (lz4_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/${ep_lib_prefix}lz4_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/${ep_lib_prefix}lz4${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SOURCE_DIR}/lib)
+
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (lz4)
+  endif ()
+  add_dependencies (lz4_lib lz4)
+  target_link_libraries (ripple_libs INTERFACE lz4_lib)
+  exclude_if_included (lz4)
+endif()
+
+exclude_if_included (lz4_lib)

Builds/CMake/deps/Nudb.cmake

@@ -0,0 +1,31 @@
+#[===================================================================[
+   NIH dep: nudb
+
+   NuDB is header-only, thus is an INTERFACE lib in CMake.
+   TODO: move the library definition into NuDB repo and add
+   proper targets and export/install
+#]===================================================================]
+
+if (is_root_project) # NuDB not needed in the case of xrpl_core inclusion build
+  add_library (nudb INTERFACE)
+  FetchContent_Declare(
+    nudb_src
+    GIT_REPOSITORY https://github.com/CPPAlliance/NuDB.git
+    GIT_TAG        2.0.5
+  )
+  FetchContent_GetProperties(nudb_src)
+  if(NOT nudb_src_POPULATED)
+    message (STATUS "Pausing to download NuDB...")
+    FetchContent_Populate(nudb_src)
+  endif()
+
+  file(TO_CMAKE_PATH "${nudb_src_SOURCE_DIR}" nudb_src_SOURCE_DIR)
+  # specify as system includes so as to avoid warnings
+  target_include_directories (nudb SYSTEM INTERFACE ${nudb_src_SOURCE_DIR}/include)
+  target_link_libraries (nudb
+    INTERFACE
+      Boost::thread
+      Boost::system)
+  add_library (NIH::nudb ALIAS nudb)
+  target_link_libraries (ripple_libs INTERFACE NIH::nudb)
+endif ()

Builds/CMake/deps/OpenSSL.cmake

@@ -0,0 +1,48 @@
+#[===================================================================[
+   NIH dep: openssl
+#]===================================================================]
+
+#[===============================================[
+  OPENSSL_ROOT_DIR is the only variable that
+  FindOpenSSL honors for locating, so convert any
+  OPENSSL_ROOT vars to this
+#]===============================================]
+if (NOT DEFINED OPENSSL_ROOT_DIR)
+  if (DEFINED ENV{OPENSSL_ROOT})
+    set (OPENSSL_ROOT_DIR $ENV{OPENSSL_ROOT})
+  elseif (HOMEBREW)
+    execute_process (COMMAND ${HOMEBREW} --prefix openssl
+      OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+  endif ()
+  file (TO_CMAKE_PATH "${OPENSSL_ROOT_DIR}" OPENSSL_ROOT_DIR)
+endif ()
+
+if (static)
+  set (OPENSSL_USE_STATIC_LIBS ON)
+endif ()
+set (OPENSSL_MSVC_STATIC_RT ON)
+find_package (OpenSSL 1.1.1 REQUIRED)
+target_link_libraries (ripple_libs
+  INTERFACE
+    OpenSSL::SSL
+    OpenSSL::Crypto)
+# disable SSLv2...this can also be done when building/configuring OpenSSL
+set_target_properties(OpenSSL::SSL PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2)
+#[=========================================================[
+   https://gitlab.kitware.com/cmake/cmake/issues/16885
+   depending on how openssl is built, it might depend
+   on zlib. In fact, the openssl find package should
+   figure this out for us, but it does not currently...
+   so let's add zlib ourselves to the lib list
+   TODO: investigate linking to static zlib for static
+   build option
+#]=========================================================]
+find_package (ZLIB)
+set (has_zlib FALSE)
+if (TARGET ZLIB::ZLIB)
+  set_target_properties(OpenSSL::Crypto PROPERTIES
+    INTERFACE_LINK_LIBRARIES ZLIB::ZLIB)
+  set (has_zlib TRUE)
+endif ()

Builds/CMake/deps/Postgres.cmake

@@ -0,0 +1,70 @@
+if(reporting)
+    find_package(PostgreSQL)
+    if(NOT PostgreSQL_FOUND)
+        message("find_package did not find postgres")
+        find_library(postgres NAMES pq libpq libpq-dev pq-dev postgresql-devel)
+        find_path(libpq-fe NAMES libpq-fe.h PATH_SUFFIXES postgresql pgsql include)
+
+        if(NOT libpq-fe_FOUND OR NOT postgres_FOUND)
+            message("No system installed Postgres found. Will build")
+            add_library(postgres SHARED IMPORTED GLOBAL)
+            add_library(pgport SHARED IMPORTED GLOBAL)
+            add_library(pgcommon SHARED IMPORTED GLOBAL)
+            ExternalProject_Add(postgres_src
+                PREFIX ${nih_cache_path}
+                GIT_REPOSITORY https://github.com/postgres/postgres.git
+                GIT_TAG REL_14_5
+                CONFIGURE_COMMAND ./configure --without-readline > /dev/null
+                BUILD_COMMAND ${CMAKE_COMMAND} -E env --unset=MAKELEVEL make
+                UPDATE_COMMAND ""
+                BUILD_IN_SOURCE 1
+                INSTALL_COMMAND ""
+                BUILD_BYPRODUCTS
+                    <BINARY_DIR>/src/interfaces/libpq/${ep_lib_prefix}pq.a
+                    <BINARY_DIR>/src/common/${ep_lib_prefix}pgcommon.a
+                    <BINARY_DIR>/src/port/${ep_lib_prefix}pgport.a
+                LOG_BUILD TRUE
+                )
+            ExternalProject_Get_Property (postgres_src SOURCE_DIR)
+            ExternalProject_Get_Property (postgres_src BINARY_DIR)
+
+            set (postgres_src_SOURCE_DIR "${SOURCE_DIR}")
+            file (MAKE_DIRECTORY ${postgres_src_SOURCE_DIR})
+            list(APPEND INCLUDE_DIRS
+                ${SOURCE_DIR}/src/include
+                ${SOURCE_DIR}/src/interfaces/libpq
+                )
+            set_target_properties(postgres PROPERTIES
+                IMPORTED_LOCATION
+                    ${BINARY_DIR}/src/interfaces/libpq/${ep_lib_prefix}pq.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                    "${INCLUDE_DIRS}"
+                )
+            set_target_properties(pgcommon PROPERTIES
+                IMPORTED_LOCATION
+                    ${BINARY_DIR}/src/common/${ep_lib_prefix}pgcommon.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                    "${INCLUDE_DIRS}"
+                )
+            set_target_properties(pgport PROPERTIES
+                IMPORTED_LOCATION
+                    ${BINARY_DIR}/src/port/${ep_lib_prefix}pgport.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                    "${INCLUDE_DIRS}"
+                )
+            add_dependencies(postgres postgres_src)
+            add_dependencies(pgcommon postgres_src)
+            add_dependencies(pgport postgres_src)
+            file(TO_CMAKE_PATH "${postgres_src_SOURCE_DIR}" postgres_src_SOURCE_DIR)
+            target_link_libraries(ripple_libs INTERFACE postgres pgcommon pgport)
+        else()
+            message("Found system installed Postgres via find_libary")
+            target_include_directories(ripple_libs INTERFACE ${libpq-fe})
+            target_link_libraries(ripple_libs INTERFACE ${postgres})
+        endif()
+    else()
+        message("Found system installed Postgres via find_package")
+        target_include_directories(ripple_libs INTERFACE ${PostgreSQL_INCLUDE_DIRS})
+        target_link_libraries(ripple_libs INTERFACE ${PostgreSQL_LIBRARIES})
+    endif()
+endif()

Builds/CMake/deps/Protobuf.cmake

@@ -1,22 +1,155 @@
-find_package(Protobuf 3.8)
+#[===================================================================[
+   import protobuf (lib and compiler) and create a lib
+   from our proto message definitions. If the system protobuf
+   is not found, fallback on EP to download and build a version
+   from official source.
+#]===================================================================]
 
-file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/proto_gen)
-set(ccbd ${CMAKE_CURRENT_BINARY_DIR})
-set(CMAKE_CURRENT_BINARY_DIR ${CMAKE_BINARY_DIR}/proto_gen)
-protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS src/ripple/proto/ripple.proto)
-set(CMAKE_CURRENT_BINARY_DIR ${ccbd})
+if (static)
+  set (Protobuf_USE_STATIC_LIBS ON)
+endif ()
+find_package (Protobuf 3.8)
+if (is_multiconfig)
+    set(protobuf_protoc_lib ${Protobuf_PROTOC_LIBRARIES})
+else ()
+    string(TOUPPER ${CMAKE_BUILD_TYPE} upper_cmake_build_type)
+    set(protobuf_protoc_lib ${Protobuf_PROTOC_LIBRARY_${upper_cmake_build_type}})
+endif ()
+if (local_protobuf OR NOT (Protobuf_FOUND AND Protobuf_PROTOC_EXECUTABLE AND protobuf_protoc_lib))
+  include (GNUInstallDirs)
+  message (STATUS "using local protobuf build.")
+  set(protobuf_reqs Protobuf_PROTOC_EXECUTABLE protobuf_protoc_lib)
+  foreach(lib ${protobuf_reqs})
+    if(NOT ${lib})
+      message(STATUS "Couldn't find ${lib}")
+    endif()
+  endforeach()
+  if (WIN32)
+    # protobuf prepends lib even on windows
+    set (pbuf_lib_pre "lib")
+  else ()
+    set (pbuf_lib_pre ${ep_lib_prefix})
+  endif ()
+  # for the external project build of protobuf, we currently ignore the
+  # static option and always build static libs here. This is consistent
+  # with our other EP builds. Dynamic libs in an EP would add complexity
+  # because we'd need to get them into the runtime path, and probably
+  # install them.
+  ExternalProject_Add (protobuf_src
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/protocolbuffers/protobuf.git
+    GIT_TAG v3.8.0
+    SOURCE_SUBDIR cmake
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      -DCMAKE_INSTALL_PREFIX=<BINARY_DIR>/_installed_
+      -Dprotobuf_BUILD_TESTS=OFF
+      -Dprotobuf_BUILD_EXAMPLES=OFF
+      -Dprotobuf_BUILD_PROTOC_BINARIES=ON
+      -Dprotobuf_MSVC_STATIC_RUNTIME=ON
+      -DBUILD_SHARED_LIBS=OFF
+      -Dprotobuf_BUILD_SHARED_LIBS=OFF
+      -DCMAKE_DEBUG_POSTFIX=_d
+      -Dprotobuf_DEBUG_POSTFIX=_d
+      -Dprotobuf_WITH_ZLIB=$<IF:$<BOOL:${has_zlib}>,ON,OFF>
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      $<$<BOOL:${unity}>:-DCMAKE_UNITY_BUILD=ON}>
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      $<$<BOOL:${MSVC}>:
+	"-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -EHa -MP"
+      >
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --parallel ${ep_procs}
+    TEST_COMMAND ""
+    INSTALL_COMMAND
+      ${CMAKE_COMMAND} -E env --unset=DESTDIR ${CMAKE_COMMAND} --build . --config $<CONFIG> --target install
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protobuf${ep_lib_suffix}
+      <BINARY_DIR>/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protobuf_d${ep_lib_suffix}
+      <BINARY_DIR>/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protoc${ep_lib_suffix}
+      <BINARY_DIR>/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protoc_d${ep_lib_suffix}
+      <BINARY_DIR>/_installed_/bin/protoc${CMAKE_EXECUTABLE_SUFFIX}
+  )
+  ExternalProject_Get_Property (protobuf_src BINARY_DIR)
+  ExternalProject_Get_Property (protobuf_src SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (protobuf_src)
+  endif ()
+  exclude_if_included (protobuf_src)
 
-add_library(pbufs STATIC ${PROTO_SRCS} ${PROTO_HDRS})
-target_include_directories(pbufs SYSTEM PUBLIC
-  ${CMAKE_BINARY_DIR}/proto_gen
-  ${CMAKE_BINARY_DIR}/proto_gen/src/ripple/proto
-)
-target_link_libraries(pbufs protobuf::libprotobuf)
-target_compile_options(pbufs
+  if (NOT TARGET protobuf::libprotobuf)
+    add_library (protobuf::libprotobuf STATIC IMPORTED GLOBAL)
+  endif ()
+  file (MAKE_DIRECTORY ${BINARY_DIR}/_installed_/include)
+  set_target_properties (protobuf::libprotobuf PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protobuf_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protobuf${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${BINARY_DIR}/_installed_/include)
+  add_dependencies (protobuf::libprotobuf protobuf_src)
+  exclude_if_included (protobuf::libprotobuf)
+
+  if (NOT TARGET protobuf::libprotoc)
+    add_library (protobuf::libprotoc STATIC IMPORTED GLOBAL)
+  endif ()
+  set_target_properties (protobuf::libprotoc PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protoc_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/_installed_/${CMAKE_INSTALL_LIBDIR}/${pbuf_lib_pre}protoc${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${BINARY_DIR}/_installed_/include)
+  add_dependencies (protobuf::libprotoc protobuf_src)
+  exclude_if_included (protobuf::libprotoc)
+
+  if (NOT TARGET protobuf::protoc)
+    add_executable (protobuf::protoc IMPORTED)
+    exclude_if_included (protobuf::protoc)
+  endif ()
+  set_target_properties (protobuf::protoc PROPERTIES
+    IMPORTED_LOCATION "${BINARY_DIR}/_installed_/bin/protoc${CMAKE_EXECUTABLE_SUFFIX}")
+  add_dependencies (protobuf::protoc protobuf_src)
+else ()
+  if (NOT TARGET protobuf::protoc)
+    if (EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
+      add_executable (protobuf::protoc IMPORTED)
+      set_target_properties (protobuf::protoc PROPERTIES
+        IMPORTED_LOCATION "${Protobuf_PROTOC_EXECUTABLE}")
+    else ()
+      message (FATAL_ERROR "Protobuf import failed")
+    endif ()
+  endif ()
+endif ()
+
+file (MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/proto_gen)
+set (save_CBD ${CMAKE_CURRENT_BINARY_DIR})
+set (CMAKE_CURRENT_BINARY_DIR ${CMAKE_BINARY_DIR}/proto_gen)
+protobuf_generate_cpp (
+  PROTO_SRCS
+  PROTO_HDRS
+  src/ripple/proto/ripple.proto)
+set (CMAKE_CURRENT_BINARY_DIR ${save_CBD})
+
+add_library (pbufs STATIC ${PROTO_SRCS} ${PROTO_HDRS})
+
+target_include_directories (pbufs PRIVATE src)
+target_include_directories (pbufs
+  SYSTEM PUBLIC ${CMAKE_BINARY_DIR}/proto_gen)
+target_link_libraries (pbufs protobuf::libprotobuf)
+target_compile_options (pbufs
   PUBLIC
-    $<$<BOOL:${XCODE}>:
+    $<$<BOOL:${is_xcode}>:
       --system-header-prefix="google/protobuf"
       -Wno-deprecated-dynamic-exception-spec
-    >
-)
-add_library(Ripple::pbufs ALIAS pbufs)
+    >)
+add_library (Ripple::pbufs ALIAS pbufs)
+target_link_libraries (ripple_libs INTERFACE Ripple::pbufs)
+exclude_if_included (pbufs)

Builds/CMake/deps/Rocksdb.cmake

@@ -0,0 +1,177 @@
+#[===================================================================[
+   NIH dep: rocksdb
+#]===================================================================]
+
+add_library (rocksdb_lib UNKNOWN IMPORTED GLOBAL)
+set_target_properties (rocksdb_lib
+  PROPERTIES INTERFACE_COMPILE_DEFINITIONS RIPPLE_ROCKSDB_AVAILABLE=1)
+
+option (local_rocksdb "use local build of rocksdb." OFF)
+if (NOT local_rocksdb)
+  find_package (RocksDB 6.27 QUIET CONFIG)
+  if (TARGET RocksDB::rocksdb)
+    message (STATUS "Found RocksDB using config.")
+    get_target_property (_rockslib_l RocksDB::rocksdb IMPORTED_LOCATION_DEBUG)
+    if (_rockslib_l)
+      set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION_DEBUG ${_rockslib_l})
+    endif ()
+    get_target_property (_rockslib_l RocksDB::rocksdb IMPORTED_LOCATION_RELEASE)
+    if (_rockslib_l)
+      set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION_RELEASE ${_rockslib_l})
+    endif ()
+    get_target_property (_rockslib_l RocksDB::rocksdb IMPORTED_LOCATION)
+    if (_rockslib_l)
+      set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION ${_rockslib_l})
+    endif ()
+    get_target_property (_rockslib_i RocksDB::rocksdb INTERFACE_INCLUDE_DIRECTORIES)
+    if (_rockslib_i)
+      set_target_properties (rocksdb_lib PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${_rockslib_i})
+    endif ()
+    target_link_libraries (ripple_libs INTERFACE RocksDB::rocksdb)
+  else ()
+    # using a find module with rocksdb is difficult because
+    # you have no idea how it was configured (transitive dependencies).
+    # the code below will generally find rocksdb using the module, but
+    # will then result in linker errors for static linkage since the
+    # transitive dependencies are unknown. force local build here for now, but leave the code as
+    # a placeholder for future investigation.
+    if (static)
+      set (local_rocksdb ON CACHE BOOL "" FORCE)
+      # TBD if there is some way to extract transitive deps..then:
+      #set (RocksDB_USE_STATIC ON)
+    else ()
+      find_package (RocksDB 6.27 MODULE)
+      if (ROCKSDB_FOUND)
+        if (RocksDB_LIBRARY_DEBUG)
+          set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION_DEBUG ${RocksDB_LIBRARY_DEBUG})
+        endif ()
+        set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION_RELEASE ${RocksDB_LIBRARIES})
+        set_target_properties (rocksdb_lib PROPERTIES IMPORTED_LOCATION ${RocksDB_LIBRARIES})
+        set_target_properties (rocksdb_lib PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${RocksDB_INCLUDE_DIRS})
+      else ()
+        set (local_rocksdb ON CACHE BOOL "" FORCE)
+      endif ()
+    endif ()
+  endif ()
+endif ()
+
+if (local_rocksdb)
+  message (STATUS "Using local build of RocksDB.")
+  ExternalProject_Add (rocksdb
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/facebook/rocksdb.git
+    GIT_TAG v6.27.3
+    PATCH_COMMAND
+      # only used by windows build
+      ${CMAKE_COMMAND} -E copy_if_different
+      ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/rocks_thirdparty.inc
+      <SOURCE_DIR>/thirdparty.inc
+    COMMAND
+      # fixup their build version file to keep the values
+      # from changing always
+      ${CMAKE_COMMAND} -E copy_if_different
+      ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/rocksdb_build_version.cc.in
+      <SOURCE_DIR>/util/build_version.cc.in
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      $<$<BOOL:${unity}>:-DCMAKE_UNITY_BUILD=ON}>
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      -DBUILD_SHARED_LIBS=OFF
+      -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+      -DWITH_JEMALLOC=$<IF:$<BOOL:${jemalloc}>,ON,OFF>
+      -DWITH_SNAPPY=ON
+      -DWITH_LZ4=ON
+      -DWITH_ZLIB=OFF
+      -DUSE_RTTI=ON
+      -DWITH_ZSTD=OFF
+      -DWITH_GFLAGS=OFF
+      -DWITH_BZ2=OFF
+      -ULZ4_*
+      -Ulz4_*
+      -Dlz4_INCLUDE_DIRS=$<JOIN:$<TARGET_PROPERTY:lz4_lib,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      -Dlz4_LIBRARIES=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:lz4_lib,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:lz4_lib,IMPORTED_LOCATION_RELEASE>>
+      -Dlz4_FOUND=ON
+      -USNAPPY_*
+      -Usnappy_*
+      -USnappy_*
+      -Dsnappy_INCLUDE_DIRS=$<JOIN:$<TARGET_PROPERTY:snappy_lib,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      -Dsnappy_LIBRARIES=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:snappy_lib,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:snappy_lib,IMPORTED_LOCATION_RELEASE>>
+      -Dsnappy_FOUND=ON
+      -DSnappy_INCLUDE_DIRS=$<JOIN:$<TARGET_PROPERTY:snappy_lib,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      -DSnappy_LIBRARIES=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:snappy_lib,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:snappy_lib,IMPORTED_LOCATION_RELEASE>>
+      -DSnappy_FOUND=ON
+      -DWITH_MD_LIBRARY=OFF
+      -DWITH_RUNTIME_DEBUG=$<IF:$<CONFIG:Debug>,ON,OFF>
+      -DFAIL_ON_WARNINGS=OFF
+      -DWITH_ASAN=OFF
+      -DWITH_TSAN=OFF
+      -DWITH_UBSAN=OFF
+      -DWITH_NUMA=OFF
+      -DWITH_TBB=OFF
+      -DWITH_WINDOWS_UTF8_FILENAMES=OFF
+      -DWITH_XPRESS=OFF
+      -DPORTABLE=ON
+      -DFORCE_SSE42=OFF
+      -DDISABLE_STALL_NOTIF=OFF
+      -DOPTDBG=ON
+      -DROCKSDB_LITE=OFF
+      -DWITH_FALLOCATE=ON
+      -DWITH_LIBRADOS=OFF
+      -DWITH_JNI=OFF
+      -DROCKSDB_INSTALL_ON_WINDOWS=OFF
+      -DWITH_TESTS=OFF
+      -DWITH_TOOLS=OFF
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -MP /DNDEBUG"
+      >
+      $<$<NOT:$<BOOL:${MSVC}>>:
+        "-DCMAKE_CXX_FLAGS=-DNDEBUG"
+      >
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+          <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}rocksdb$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>
+        >
+    LIST_SEPARATOR ::
+    TEST_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS snappy_lib lz4_lib
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/${ep_lib_prefix}rocksdb${ep_lib_suffix}
+      <BINARY_DIR>/${ep_lib_prefix}rocksdb_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (rocksdb BINARY_DIR)
+  ExternalProject_Get_Property (rocksdb SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (rocksdb)
+  endif ()
+  file (MAKE_DIRECTORY ${SOURCE_DIR}/include)
+  set_target_properties (rocksdb_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/${ep_lib_prefix}rocksdb_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/${ep_lib_prefix}rocksdb${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SOURCE_DIR}/include)
+  add_dependencies (rocksdb_lib rocksdb)
+  exclude_if_included (rocksdb)
+endif ()
+
+target_link_libraries (rocksdb_lib
+  INTERFACE
+    snappy_lib
+    lz4_lib
+    $<$<BOOL:${MSVC}>:rpcrt4>)
+exclude_if_included (rocksdb_lib)
+target_link_libraries (ripple_libs INTERFACE rocksdb_lib)

Builds/CMake/deps/Secp256k1.cmake

@@ -0,0 +1,58 @@
+#[===================================================================[
+   NIH dep: secp256k1
+#]===================================================================]
+
+add_library (secp256k1_lib STATIC IMPORTED GLOBAL)
+
+if (NOT WIN32)
+  find_package(secp256k1)
+endif()
+
+if(secp256k1)
+  set_target_properties (secp256k1_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${secp256k1}
+    IMPORTED_LOCATION_RELEASE
+      ${secp256k1}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SECP256K1_INCLUDE_DIR})
+
+  add_library (secp256k1 ALIAS secp256k1_lib)
+  add_library (NIH::secp256k1 ALIAS secp256k1_lib)
+
+else()
+  set(INSTALL_SECP256K1 true)
+
+  add_library (secp256k1 STATIC
+    src/secp256k1/src/secp256k1.c)
+  target_compile_definitions (secp256k1
+    PRIVATE
+      USE_NUM_NONE
+      USE_FIELD_10X26
+      USE_FIELD_INV_BUILTIN
+      USE_SCALAR_8X32
+      USE_SCALAR_INV_BUILTIN)
+  target_include_directories (secp256k1
+    PUBLIC
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+      $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src/secp256k1)
+  target_compile_options (secp256k1
+    PRIVATE
+      $<$<BOOL:${MSVC}>:-wd4319>
+      $<$<NOT:$<BOOL:${MSVC}>>:
+        -Wno-deprecated-declarations
+        -Wno-unused-function
+      >
+      $<$<BOOL:${is_gcc}>:-Wno-nonnull-compare>)
+  target_link_libraries (ripple_libs INTERFACE NIH::secp256k1)
+#[===========================[
+     headers installation
+#]===========================]
+  install (
+    FILES
+      src/secp256k1/include/secp256k1.h
+  DESTINATION include/secp256k1/include)
+
+  add_library (NIH::secp256k1 ALIAS secp256k1)
+endif()

Builds/CMake/deps/Snappy.cmake

@@ -0,0 +1,77 @@
+#[===================================================================[
+   NIH dep: snappy
+#]===================================================================]
+
+add_library (snappy_lib STATIC IMPORTED GLOBAL)
+
+if (NOT WIN32)
+  find_package(snappy)
+endif()
+
+if(snappy)
+  set_target_properties (snappy_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${snappy}
+    IMPORTED_LOCATION_RELEASE
+      ${snappy}
+    INTERFACE_INCLUDE_DIRECTORIES
+    ${SNAPPY_INCLUDE_DIR})
+
+else()
+  ExternalProject_Add (snappy
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/google/snappy.git
+    GIT_TAG 1.1.7
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      -DBUILD_SHARED_LIBS=OFF
+      -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+      -DSNAPPY_BUILD_TESTS=OFF
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -EHa -MP"
+        "-DCMAKE_CXX_FLAGS_DEBUG=-MTd"
+        "-DCMAKE_CXX_FLAGS_RELEASE=-MT"
+      >
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+          <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}snappy$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>
+        >
+    TEST_COMMAND ""
+    INSTALL_COMMAND
+      ${CMAKE_COMMAND} -E copy_if_different <BINARY_DIR>/config.h <BINARY_DIR>/snappy-stubs-public.h <SOURCE_DIR>
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/${ep_lib_prefix}snappy${ep_lib_suffix}
+      <BINARY_DIR>/${ep_lib_prefix}snappy_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (snappy BINARY_DIR)
+  ExternalProject_Get_Property (snappy SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (snappy)
+  endif ()
+  file (MAKE_DIRECTORY ${SOURCE_DIR}/snappy)
+  set_target_properties (snappy_lib PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/${ep_lib_prefix}snappy_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/${ep_lib_prefix}snappy${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SOURCE_DIR})
+endif()
+
+add_dependencies (snappy_lib snappy)
+target_link_libraries (ripple_libs INTERFACE snappy_lib)
+exclude_if_included (snappy)
+exclude_if_included (snappy_lib)

Builds/CMake/deps/Soci.cmake

@@ -0,0 +1,165 @@
+#[===================================================================[
+   NIH dep: soci
+#]===================================================================]
+
+foreach (_comp core empty sqlite3)
+  add_library ("soci_${_comp}" STATIC IMPORTED GLOBAL)
+endforeach ()
+
+if (NOT WIN32)
+  find_package(soci)
+endif()
+
+if (soci)
+  foreach (_comp core empty sqlite3)
+    set_target_properties ("soci_${_comp}" PROPERTIES
+      IMPORTED_LOCATION_DEBUG
+        ${soci}
+      IMPORTED_LOCATION_RELEASE
+        ${soci}
+      INTERFACE_INCLUDE_DIRECTORIES
+        ${SOCI_INCLUDE_DIR})
+  endforeach ()
+
+else()
+  set (soci_lib_pre ${ep_lib_prefix})
+  set (soci_lib_post "")
+  if (WIN32)
+    # for some reason soci on windows still prepends lib (non-standard)
+    set (soci_lib_pre lib)
+    # this version in the name might change if/when we change versions of soci
+    set (soci_lib_post "_4_0")
+  endif ()
+  get_target_property (_boost_incs Boost::date_time INTERFACE_INCLUDE_DIRECTORIES)
+  get_target_property (_boost_dt Boost::date_time IMPORTED_LOCATION)
+  if (NOT _boost_dt)
+    get_target_property (_boost_dt Boost::date_time IMPORTED_LOCATION_RELEASE)
+  endif ()
+  if (NOT _boost_dt)
+    get_target_property (_boost_dt Boost::date_time IMPORTED_LOCATION_DEBUG)
+  endif ()
+
+  ExternalProject_Add (soci
+    PREFIX ${nih_cache_path}
+    GIT_REPOSITORY https://github.com/SOCI/soci.git
+    GIT_TAG 04e1870294918d20761736743bb6136314c42dd5
+    # We had an issue with soci integer range checking for boost::optional
+    # and needed to remove the exception that SOCI throws in this case.
+    # This is *probably* a bug in SOCI, but has never been investigated more
+    # nor reported to the maintainers.
+    # This cmake script comments out the lines in question.
+    # This patch process is likely fragile and should be reviewed carefully
+    # whenever we update the GIT_TAG above.
+    PATCH_COMMAND
+      ${CMAKE_COMMAND} -D RIPPLED_SOURCE=${CMAKE_CURRENT_SOURCE_DIR}
+        -P ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/soci_patch.cmake
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      $<$<BOOL:${CMAKE_TOOLCHAIN_FILE}>:-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}>
+      $<$<BOOL:${VCPKG_TARGET_TRIPLET}>:-DVCPKG_TARGET_TRIPLET=${VCPKG_TARGET_TRIPLET}>
+      $<$<BOOL:${unity}>:-DCMAKE_UNITY_BUILD=ON}>
+      -DCMAKE_PREFIX_PATH=${CMAKE_BINARY_DIR}/sqlite3
+      -DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake
+      -DCMAKE_INCLUDE_PATH=$<JOIN:$<TARGET_PROPERTY:sqlite,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      -DCMAKE_LIBRARY_PATH=${sqlite_BINARY_DIR}
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      -DSOCI_CXX_C11=ON
+      -DSOCI_STATIC=ON
+      -DSOCI_LIBDIR=lib
+      -DSOCI_SHARED=OFF
+      -DSOCI_TESTS=OFF
+      # hacks to workaround the fact that soci doesn't currently use
+      # boost imported targets in its cmake. If they switch to
+      # proper imported targets, this next line can be removed
+      # (as well as the get_property above that sets _boost_incs)
+      -DBoost_INCLUDE_DIRS=$<JOIN:${_boost_incs},::>
+      -DBoost_INCLUDE_DIR=$<JOIN:${_boost_incs},::>
+      -DBOOST_ROOT=${BOOST_ROOT}
+      -DWITH_BOOST=ON
+      -DBoost_FOUND=ON
+      -DBoost_NO_BOOST_CMAKE=ON
+      -DBoost_DATE_TIME_FOUND=ON
+      -DSOCI_HAVE_BOOST=ON
+      -DSOCI_HAVE_BOOST_DATE_TIME=ON
+      -DBoost_DATE_TIME_LIBRARY=${_boost_dt}
+      -DSOCI_DB2=OFF
+      -DSOCI_FIREBIRD=OFF
+      -DSOCI_MYSQL=OFF
+      -DSOCI_ODBC=OFF
+      -DSOCI_ORACLE=OFF
+      -DSOCI_POSTGRESQL=OFF
+      -DSOCI_SQLITE3=ON
+      -DSQLITE3_INCLUDE_DIR=$<JOIN:$<TARGET_PROPERTY:sqlite,INTERFACE_INCLUDE_DIRECTORIES>,::>
+      -DSQLITE3_LIBRARY=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:sqlite,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:sqlite,IMPORTED_LOCATION_RELEASE>>
+      $<$<BOOL:${APPLE}>:-DCMAKE_FIND_FRAMEWORK=LAST>
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -EHa -MP"
+        "-DCMAKE_CXX_FLAGS_DEBUG=-MTd"
+        "-DCMAKE_CXX_FLAGS_RELEASE=-MT"
+      >
+      $<$<NOT:$<BOOL:${MSVC}>>:
+        "-DCMAKE_CXX_FLAGS=-Wno-deprecated-declarations"
+      >
+      # SEE: https://github.com/SOCI/soci/issues/640
+      $<$<AND:$<BOOL:${is_gcc}>,$<VERSION_GREATER_EQUAL:${CMAKE_CXX_COMPILER_VERSION},8>>:
+        "-DCMAKE_CXX_FLAGS=-Wno-deprecated-declarations -Wno-error=format-overflow -Wno-format-overflow -Wno-error=format-truncation"
+      >
+    LIST_SEPARATOR ::
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+          <BINARY_DIR>/lib/$<CONFIG>/${soci_lib_pre}soci_core${soci_lib_post}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>/lib/$<CONFIG>/${soci_lib_pre}soci_empty${soci_lib_post}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>/lib/$<CONFIG>/${soci_lib_pre}soci_sqlite3${soci_lib_post}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+          <BINARY_DIR>/lib
+        >
+    TEST_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS sqlite
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_core${soci_lib_post}${ep_lib_suffix}
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_core${soci_lib_post}_d${ep_lib_suffix}
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_empty${soci_lib_post}${ep_lib_suffix}
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_empty${soci_lib_post}_d${ep_lib_suffix}
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_sqlite3${soci_lib_post}${ep_lib_suffix}
+      <BINARY_DIR>/lib/${soci_lib_pre}soci_sqlite3${soci_lib_post}_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (soci BINARY_DIR)
+  ExternalProject_Get_Property (soci SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (soci)
+  endif ()
+  file (MAKE_DIRECTORY ${SOURCE_DIR}/include)
+  file (MAKE_DIRECTORY ${BINARY_DIR}/include)
+  foreach (_comp core empty sqlite3)
+    set_target_properties ("soci_${_comp}" PROPERTIES
+      IMPORTED_LOCATION_DEBUG
+        ${BINARY_DIR}/lib/${soci_lib_pre}soci_${_comp}${soci_lib_post}_d${ep_lib_suffix}
+      IMPORTED_LOCATION_RELEASE
+        ${BINARY_DIR}/lib/${soci_lib_pre}soci_${_comp}${soci_lib_post}${ep_lib_suffix}
+      INTERFACE_INCLUDE_DIRECTORIES
+        "${SOURCE_DIR}/include;${BINARY_DIR}/include")
+    add_dependencies ("soci_${_comp}" soci) # something has to depend on the ExternalProject to trigger it
+    target_link_libraries (ripple_libs INTERFACE "soci_${_comp}")
+    if (NOT _comp STREQUAL "core")
+      target_link_libraries ("soci_${_comp}" INTERFACE soci_core)
+    endif ()
+  endforeach ()
+endif()
+
+foreach (_comp core empty sqlite3)
+  exclude_if_included ("soci_${_comp}")
+endforeach ()
+
+
+exclude_if_included (soci)

Builds/CMake/deps/Sqlite.cmake

@@ -0,0 +1,93 @@
+#[===================================================================[
+   NIH dep: sqlite
+#]===================================================================]
+
+add_library (sqlite STATIC IMPORTED GLOBAL)
+
+if (NOT WIN32)
+  find_package(sqlite)
+endif()
+
+
+if(sqlite3)
+  set_target_properties (sqlite PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${sqlite3}
+    IMPORTED_LOCATION_RELEASE
+      ${sqlite3}
+    INTERFACE_INCLUDE_DIRECTORIES
+    ${SQLITE_INCLUDE_DIR})
+
+else()
+  ExternalProject_Add (sqlite3
+    PREFIX ${nih_cache_path}
+    # sqlite doesn't use git, but it provides versioned tarballs
+    URL https://www.sqlite.org/2018/sqlite-amalgamation-3260000.zip
+      http://www.sqlite.org/2018/sqlite-amalgamation-3260000.zip
+      https://www2.sqlite.org/2018/sqlite-amalgamation-3260000.zip
+      http://www2.sqlite.org/2018/sqlite-amalgamation-3260000.zip
+    # ^^^ version is apparent in the URL:  3260000 => 3.26.0
+    URL_HASH SHA256=de5dcab133aa339a4cf9e97c40aa6062570086d6085d8f9ad7bc6ddf8a52096e
+    # Don't need to worry about MITM attacks too much because the download
+    # is checked against a strong hash
+    TLS_VERIFY false
+    # we wrote a very simple CMake file to build sqlite
+    # so that's what we copy here so that we can build with
+    # CMake. sqlite doesn't generally provided a build system
+    # for the single amalgamation source file.
+    PATCH_COMMAND
+      ${CMAKE_COMMAND} -E copy_if_different
+      ${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/CMake_sqlite3.txt
+      <SOURCE_DIR>/CMakeLists.txt
+    CMAKE_ARGS
+      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+      -DCMAKE_DEBUG_POSTFIX=_d
+      $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+      $<$<BOOL:${MSVC}>:
+        "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+        "-DCMAKE_C_FLAGS_DEBUG=-MTd"
+        "-DCMAKE_C_FLAGS_RELEASE=-MT"
+      >
+    LOG_BUILD ON
+    LOG_CONFIGURE ON
+    BUILD_COMMAND
+      ${CMAKE_COMMAND}
+      --build .
+      --config $<CONFIG>
+      --parallel ${ep_procs}
+      $<$<BOOL:${is_multiconfig}>:
+        COMMAND
+          ${CMAKE_COMMAND} -E copy
+            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}sqlite3$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>
+        >
+    TEST_COMMAND ""
+    INSTALL_COMMAND ""
+    BUILD_BYPRODUCTS
+      <BINARY_DIR>/${ep_lib_prefix}sqlite3${ep_lib_suffix}
+      <BINARY_DIR>/${ep_lib_prefix}sqlite3_d${ep_lib_suffix}
+  )
+  ExternalProject_Get_Property (sqlite3 BINARY_DIR)
+  ExternalProject_Get_Property (sqlite3 SOURCE_DIR)
+  if (CMAKE_VERBOSE_MAKEFILE)
+    print_ep_logs (sqlite3)
+  endif ()
+
+  set_target_properties (sqlite PROPERTIES
+    IMPORTED_LOCATION_DEBUG
+      ${BINARY_DIR}/${ep_lib_prefix}sqlite3_d${ep_lib_suffix}
+    IMPORTED_LOCATION_RELEASE
+      ${BINARY_DIR}/${ep_lib_prefix}sqlite3${ep_lib_suffix}
+    INTERFACE_INCLUDE_DIRECTORIES
+      ${SOURCE_DIR})
+
+  add_dependencies (sqlite sqlite3)
+  exclude_if_included (sqlite3)
+endif()
+
+target_link_libraries (sqlite INTERFACE $<$<NOT:$<BOOL:${MSVC}>>:dl>)
+target_link_libraries (ripple_libs INTERFACE sqlite)
+exclude_if_included (sqlite)
+set(sqlite_BINARY_DIR ${BINARY_DIR})

Builds/CMake/deps/WasmEdge.cmake

@@ -1 +1,84 @@
-find_package(wasmedge REQUIRED)
+#[===================================================================[
+ NIH dep: wasmedge: web assembly runtime for hooks.
+#]===================================================================]
+
+find_package(Curses)
+if(CURSES_FOUND)
+  include_directories(${CURSES_INCLUDE_DIR})
+  target_link_libraries(ripple_libs INTERFACE ${CURSES_LIBRARY})
+else()
+  message(WARNING "CURSES library not found... (only important for mac builds)")
+endif()
+
+
+find_package(LLVM REQUIRED CONFIG)
+message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
+message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
+ExternalProject_Add (wasmedge_src
+  PREFIX ${nih_cache_path}
+  GIT_REPOSITORY https://github.com/WasmEdge/WasmEdge.git
+  GIT_TAG 0.11.2
+  CMAKE_ARGS
+    -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+    -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+    $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+    -DCMAKE_DEBUG_POSTFIX=_d
+    -DWASMEDGE_BUILD_SHARED_LIB=OFF
+    -DWASMEDGE_BUILD_STATIC_LIB=ON
+    -DWASMEDGE_BUILD_AOT_RUNTIME=ON
+    -DWASMEDGE_FORCE_DISABLE_LTO=ON
+    -DWASMEDGE_LINK_LLVM_STATIC=ON
+    -DWASMEDGE_LINK_TOOLS_STATIC=ON
+    -DWASMEDGE_BUILD_PLUGINS=OFF
+    -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+    -DLLVM_DIR=${LLVM_DIR}
+    -DLLVM_LIBRARY_DIR=${LLVM_LIBRARY_DIR}
+    -DLLVM_ENABLE_TERMINFO=OFF
+    $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+    $<$<BOOL:${MSVC}>:
+      "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP -march=native"
+      "-DCMAKE_C_FLAGS_DEBUG=-MTd"
+      "-DCMAKE_C_FLAGS_RELEASE=-MT"
+    >  
+  LOG_CONFIGURE ON
+  LOG_BUILD ON
+  LOG_CONFIGURE ON
+  COMMAND
+    pwd
+  BUILD_COMMAND
+    ${CMAKE_COMMAND}
+    --build .
+    --config $<CONFIG>
+    $<$<VERSION_GREATER_EQUAL:${CMAKE_VERSION},3.12>:--parallel ${ep_procs}>
+  TEST_COMMAND ""
+  INSTALL_COMMAND ""
+  BUILD_BYPRODUCTS
+      <BINARY_DIR>/lib/api/libwasmedge.a
+)
+add_library (wasmedge STATIC IMPORTED GLOBAL)
+ExternalProject_Get_Property (wasmedge_src BINARY_DIR)
+ExternalProject_Get_Property (wasmedge_src SOURCE_DIR)
+set (wasmedge_src_BINARY_DIR "${BINARY_DIR}")
+add_dependencies (wasmedge wasmedge_src)
+execute_process(
+    COMMAND
+        mkdir -p "${wasmedge_src_BINARY_DIR}/include/api"
+)
+set_target_properties (wasmedge PROPERTIES
+  IMPORTED_LOCATION_DEBUG
+    "${wasmedge_src_BINARY_DIR}/lib/api/libwasmedge.a"
+  IMPORTED_LOCATION_RELEASE
+    "${wasmedge_src_BINARY_DIR}/lib/api/libwasmedge.a"
+  INTERFACE_INCLUDE_DIRECTORIES
+    "${wasmedge_src_BINARY_DIR}/include/api/"
+)
+target_link_libraries (ripple_libs INTERFACE wasmedge)
+#RH NOTE: some compilers / versions of some libraries need these, most don't
+
+find_library(XAR_LIBRARY NAMES xar)
+if(XAR_LIBRARY)
+  target_link_libraries(ripple_libs INTERFACE ${XAR_LIBRARY})
+else()
+  message(WARNING "xar library not found... (only important for mac builds)")
+endif()
+add_library (wasmedge::wasmedge ALIAS wasmedge)

Builds/CMake/deps/cassandra.cmake

@@ -0,0 +1,167 @@
+if(reporting)
+    find_library(cassandra NAMES cassandra)
+    if(NOT cassandra)
+
+        message("System installed Cassandra cpp driver not found. Will build")
+
+        find_library(zlib NAMES zlib1g-dev zlib-devel zlib z)
+        if(NOT zlib)
+            message("zlib not found. will build")
+            add_library(zlib STATIC IMPORTED GLOBAL)
+            ExternalProject_Add(zlib_src
+                PREFIX ${nih_cache_path}
+                GIT_REPOSITORY https://github.com/madler/zlib.git
+                GIT_TAG v1.2.12
+                INSTALL_COMMAND ""
+                BUILD_BYPRODUCTS <BINARY_DIR>/${ep_lib_prefix}z.a
+                LOG_BUILD TRUE
+                LOG_CONFIGURE TRUE
+                )
+
+
+            ExternalProject_Get_Property (zlib_src SOURCE_DIR)
+            ExternalProject_Get_Property (zlib_src BINARY_DIR)
+            set (zlib_src_SOURCE_DIR "${SOURCE_DIR}")
+            file (MAKE_DIRECTORY ${zlib_src_SOURCE_DIR}/include)
+
+            set_target_properties (zlib PROPERTIES
+                IMPORTED_LOCATION
+                ${BINARY_DIR}/${ep_lib_prefix}z.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                ${SOURCE_DIR}/include)
+            add_dependencies(zlib zlib_src)
+
+            file(TO_CMAKE_PATH "${zlib_src_SOURCE_DIR}" zlib_src_SOURCE_DIR)
+        endif()
+
+
+
+
+        find_library(krb5 NAMES krb5-dev libkrb5-dev)
+
+        if(NOT krb5)
+            message("krb5 not found. will build")
+            add_library(krb5 STATIC IMPORTED GLOBAL)
+            ExternalProject_Add(krb5_src
+                PREFIX ${nih_cache_path}
+                GIT_REPOSITORY https://github.com/krb5/krb5.git
+                GIT_TAG krb5-1.20-final
+                UPDATE_COMMAND ""
+                CONFIGURE_COMMAND autoreconf src && CFLAGS=-fcommon ./src/configure --enable-static --disable-shared > /dev/null
+                BUILD_IN_SOURCE 1
+                BUILD_COMMAND make
+                INSTALL_COMMAND ""
+                BUILD_BYPRODUCTS <SOURCE_DIR>/lib/${ep_lib_prefix}krb5.a
+                LOG_BUILD TRUE
+                )
+
+            ExternalProject_Get_Property (krb5_src SOURCE_DIR)
+            ExternalProject_Get_Property (krb5_src BINARY_DIR)
+            set (krb5_src_SOURCE_DIR "${SOURCE_DIR}")
+            file (MAKE_DIRECTORY ${krb5_src_SOURCE_DIR}/include)
+
+            set_target_properties (krb5 PROPERTIES
+                IMPORTED_LOCATION
+                ${BINARY_DIR}/lib/${ep_lib_prefix}krb5.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                ${SOURCE_DIR}/include)
+            add_dependencies(krb5 krb5_src)
+
+            file(TO_CMAKE_PATH "${krb5_src_SOURCE_DIR}" krb5_src_SOURCE_DIR)
+        endif()
+
+
+        find_library(libuv1 NAMES uv1 libuv1 liubuv1-dev libuv1:amd64)
+
+
+        if(NOT libuv1)
+            message("libuv1 not found, will build")
+            add_library(libuv1 STATIC IMPORTED GLOBAL)
+            ExternalProject_Add(libuv_src
+                PREFIX ${nih_cache_path}
+                GIT_REPOSITORY https://github.com/libuv/libuv.git
+                GIT_TAG v1.44.2
+                INSTALL_COMMAND ""
+                BUILD_BYPRODUCTS <BINARY_DIR>/${ep_lib_prefix}uv_a.a
+                LOG_BUILD TRUE
+                LOG_CONFIGURE TRUE
+                )
+
+            ExternalProject_Get_Property (libuv_src SOURCE_DIR)
+            ExternalProject_Get_Property (libuv_src BINARY_DIR)
+            set (libuv_src_SOURCE_DIR "${SOURCE_DIR}")
+            file (MAKE_DIRECTORY ${libuv_src_SOURCE_DIR}/include)
+
+            set_target_properties (libuv1 PROPERTIES
+                IMPORTED_LOCATION
+                ${BINARY_DIR}/${ep_lib_prefix}uv_a.a
+                INTERFACE_INCLUDE_DIRECTORIES
+                ${SOURCE_DIR}/include)
+            add_dependencies(libuv1 libuv_src)
+
+            file(TO_CMAKE_PATH "${libuv_src_SOURCE_DIR}" libuv_src_SOURCE_DIR)
+        endif()
+
+        add_library (cassandra STATIC IMPORTED GLOBAL)
+        ExternalProject_Add(cassandra_src
+            PREFIX ${nih_cache_path}
+            GIT_REPOSITORY https://github.com/datastax/cpp-driver.git
+            GIT_TAG 2.16.2
+            CMAKE_ARGS
+            -DLIBUV_ROOT_DIR=${BINARY_DIR}
+            -DLIBUV_LIBARY=${BINARY_DIR}/libuv_a.a
+            -DLIBUV_INCLUDE_DIR=${SOURCE_DIR}/include
+            -DCASS_BUILD_STATIC=ON
+            -DCASS_BUILD_SHARED=OFF
+            -DOPENSSL_ROOT_DIR=/opt/local/openssl
+            INSTALL_COMMAND ""
+            BUILD_BYPRODUCTS <BINARY_DIR>/${ep_lib_prefix}cassandra_static.a
+            LOG_BUILD TRUE
+            LOG_CONFIGURE TRUE
+            )
+
+        ExternalProject_Get_Property (cassandra_src SOURCE_DIR)
+        ExternalProject_Get_Property (cassandra_src BINARY_DIR)
+        set (cassandra_src_SOURCE_DIR "${SOURCE_DIR}")
+        file (MAKE_DIRECTORY ${cassandra_src_SOURCE_DIR}/include)
+
+        set_target_properties (cassandra PROPERTIES
+            IMPORTED_LOCATION
+            ${BINARY_DIR}/${ep_lib_prefix}cassandra_static.a
+            INTERFACE_INCLUDE_DIRECTORIES
+            ${SOURCE_DIR}/include)
+        add_dependencies(cassandra cassandra_src)
+
+        if(NOT libuv1)
+            ExternalProject_Add_StepDependencies(cassandra_src build libuv1)
+            target_link_libraries(cassandra INTERFACE libuv1)
+        else()
+            target_link_libraries(cassandra INTERFACE ${libuv1})
+        endif()
+        if(NOT krb5)
+
+            ExternalProject_Add_StepDependencies(cassandra_src build krb5)
+            target_link_libraries(cassandra INTERFACE krb5)
+        else()
+            target_link_libraries(cassandra INTERFACE ${krb5})
+        endif()
+
+        if(NOT zlib)
+            ExternalProject_Add_StepDependencies(cassandra_src build zlib)
+            target_link_libraries(cassandra INTERFACE zlib)
+        else()
+            target_link_libraries(cassandra INTERFACE ${zlib})
+        endif()
+
+        file(TO_CMAKE_PATH "${cassandra_src_SOURCE_DIR}" cassandra_src_SOURCE_DIR)
+        target_link_libraries(ripple_libs INTERFACE cassandra)
+    else()
+        message("Found system installed cassandra cpp driver")
+
+        find_path(cassandra_includes NAMES cassandra.h REQUIRED)
+        target_link_libraries (ripple_libs INTERFACE ${cassandra})
+        target_include_directories(ripple_libs INTERFACE ${cassandra_includes})
+    endif()
+
+    exclude_if_included (cassandra)
+endif()

Builds/CMake/deps/date.cmake

@@ -0,0 +1,18 @@
+#[===================================================================[
+   NIH dep: date
+
+   the main library is header-only, thus is an INTERFACE lib in CMake.
+
+   NOTE: this has been accepted into c++20 so can likely be replaced
+   when we update to that standard
+#]===================================================================]
+
+find_package (date QUIET)
+if (NOT TARGET date::date)
+  FetchContent_Declare(
+    hh_date_src
+    GIT_REPOSITORY https://github.com/HowardHinnant/date.git
+    GIT_TAG        fc4cf092f9674f2670fb9177edcdee870399b829
+  )
+  FetchContent_MakeAvailable(hh_date_src)
+endif ()

Builds/CMake/deps/dilithium.cmake

@@ -0,0 +1,84 @@
+include(FetchContent)
+
+ExternalProject_Add(
+  dilithium_src
+  PREFIX ${nih_cache_path}
+  GIT_REPOSITORY https://github.com/pq-crystals/dilithium.git
+  GIT_TAG v3.1
+  CMAKE_ARGS
+    -DDILITHIUM_MODE=2 
+    -DDILITHIUM_RANDOMIZED_SIGNING=ON 
+    -DDILITHIUM_USE_AES=ON
+  LOG_BUILD ON
+  LOG_CONFIGURE ON
+  COMMAND
+    pwd
+  BUILD_COMMAND
+    ${CMAKE_COMMAND}
+    --build .
+    --config $<CONFIG>
+    $<$<VERSION_GREATER_EQUAL:${CMAKE_VERSION},3.12>:--parallel ${ep_procs}>
+  INSTALL_COMMAND ""
+  BUILD_BYPRODUCTS
+      <BINARY_DIR>/ref/libdilithium2_ref.a
+      <BINARY_DIR>/ref/libdilithium2aes_ref.a
+      <BINARY_DIR>/ref/libfips202_ref.a
+)
+
+ExternalProject_Get_Property(dilithium_src BINARY_DIR)
+ExternalProject_Get_Property(dilithium_src SOURCE_DIR)
+set(dilithium_src_SOURCE_DIR "${SOURCE_DIR}")
+set(dilithium_src_BINARY_DIR "${BINARY_DIR}")
+
+# Check if the api.h file exists
+include_directories("${dilithium_src_SOURCE_DIR}/ref")
+
+# Create imported targets for each static library
+add_library(dilithium::dilithium2_ref STATIC IMPORTED GLOBAL)
+set_target_properties(dilithium::dilithium2_ref PROPERTIES
+  IMPORTED_LOCATION "${dilithium_src_BINARY_DIR}/ref/libdilithium2_ref.a"
+  INTERFACE_INCLUDE_DIRECTORIES "${dilithium_src_SOURCE_DIR}/ref/"
+)
+
+add_library(dilithium::dilithium2aes_ref STATIC IMPORTED GLOBAL)
+set_target_properties(dilithium::dilithium2aes_ref PROPERTIES
+  IMPORTED_LOCATION "${dilithium_src_BINARY_DIR}/ref/libdilithium2aes_ref.a"
+  INTERFACE_INCLUDE_DIRECTORIES "${dilithium_src_SOURCE_DIR}/ref/"
+)
+
+add_library(dilithium::libfips202_ref STATIC IMPORTED GLOBAL)
+set_target_properties(dilithium::libfips202_ref PROPERTIES
+  IMPORTED_LOCATION "${dilithium_src_BINARY_DIR}/ref/libfips202_ref.a"
+  INTERFACE_INCLUDE_DIRECTORIES "${dilithium_src_SOURCE_DIR}/ref/"
+)
+
+add_dependencies(dilithium::dilithium2_ref dilithium_src)
+add_dependencies(dilithium::dilithium2aes_ref dilithium_src)
+add_dependencies(dilithium::libfips202_ref dilithium_src)
+
+# Add a custom command to generate randombytes.c
+add_custom_command(
+  OUTPUT "${dilithium_src_BINARY_DIR}/ref/randombytes.c"
+  COMMAND ${CMAKE_COMMAND} -E copy "${dilithium_src_SOURCE_DIR}/ref/randombytes.c" "${dilithium_src_BINARY_DIR}/ref/randombytes.c"
+  DEPENDS dilithium_src
+)
+
+# Add the randombytes_ref library
+add_library(randombytes_ref STATIC "${dilithium_src_BINARY_DIR}/ref/randombytes.c")
+
+# Include the Dilithium ref directory for headers
+target_include_directories(randombytes_ref PUBLIC "${dilithium_src_SOURCE_DIR}/ref")
+
+# Ensure that randombytes_ref depends on the Dilithium source so it's built after
+add_dependencies(randombytes_ref dilithium_src)
+
+# Create an interface library that links to both
+target_link_libraries(ripple_libs INTERFACE
+  randombytes_ref
+  dilithium::dilithium2_ref
+  dilithium::dilithium2aes_ref
+  dilithium::libfips202_ref
+)
+
+# Link the Dilithium library to your target
+add_library(NIH::dilithium2_ref ALIAS dilithium::dilithium2_ref)

Builds/CMake/deps/gRPC.cmake

@@ -1,15 +1,324 @@
-find_package(gRPC 1.23)
+
+# currently linking to unsecure versions...if we switch, we'll
+# need to add ssl as a link dependency to the grpc targets
+option (use_secure_grpc "use TLS version of grpc libs." OFF)
+if (use_secure_grpc)
+  set (grpc_suffix "")
+else ()
+  set (grpc_suffix "_unsecure")
+endif ()
+
+find_package (gRPC 1.23 CONFIG QUIET)
+if (TARGET gRPC::gpr AND NOT local_grpc)
+  get_target_property (_grpc_l gRPC::gpr IMPORTED_LOCATION_DEBUG)
+  if (NOT _grpc_l)
+    get_target_property (_grpc_l gRPC::gpr IMPORTED_LOCATION_RELEASE)
+  endif ()
+  if (NOT _grpc_l)
+    get_target_property (_grpc_l gRPC::gpr IMPORTED_LOCATION)
+  endif ()
+  message (STATUS "Found cmake config for gRPC. Using ${_grpc_l}.")
+else ()
+  find_package (PkgConfig QUIET)
+  if (PKG_CONFIG_FOUND)
+    pkg_check_modules (grpc QUIET "grpc${grpc_suffix}>=1.25" "grpc++${grpc_suffix}" gpr)
+  endif ()
+
+  if (grpc_FOUND)
+    message (STATUS "Found gRPC using pkg-config. Using ${grpc_gpr_PREFIX}.")
+  endif ()
+
+  add_executable (gRPC::grpc_cpp_plugin IMPORTED)
+  exclude_if_included (gRPC::grpc_cpp_plugin)
+
+  if (grpc_FOUND AND NOT local_grpc)
+    # use installed grpc (via pkg-config)
+    macro (add_imported_grpc libname_)
+      if (static)
+        set (_search "${CMAKE_STATIC_LIBRARY_PREFIX}${libname_}${CMAKE_STATIC_LIBRARY_SUFFIX}")
+      else ()
+        set (_search "${CMAKE_SHARED_LIBRARY_PREFIX}${libname_}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+      endif()
+      find_library(_found_${libname_}
+        NAMES ${_search}
+        HINTS ${grpc_LIBRARY_DIRS})
+      if (_found_${libname_})
+        message (STATUS "importing ${libname_} as ${_found_${libname_}}")
+      else ()
+        message (FATAL_ERROR "using pkg-config for grpc, can't find ${_search}")
+      endif ()
+      add_library ("gRPC::${libname_}" STATIC IMPORTED GLOBAL)
+      set_target_properties ("gRPC::${libname_}" PROPERTIES IMPORTED_LOCATION ${_found_${libname_}})
+      if (grpc_INCLUDE_DIRS)
+        set_target_properties ("gRPC::${libname_}" PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${grpc_INCLUDE_DIRS})
+      endif ()
+      target_link_libraries (ripple_libs INTERFACE "gRPC::${libname_}")
+      exclude_if_included ("gRPC::${libname_}")
+    endmacro ()
+
+    set_target_properties (gRPC::grpc_cpp_plugin PROPERTIES
+        IMPORTED_LOCATION "${grpc_gpr_PREFIX}/bin/grpc_cpp_plugin${CMAKE_EXECUTABLE_SUFFIX}")
+
+    pkg_check_modules (cares QUIET libcares)
+    if (cares_FOUND)
+      if (static)
+        set (_search "${CMAKE_STATIC_LIBRARY_PREFIX}cares${CMAKE_STATIC_LIBRARY_SUFFIX}")
+        set (_prefix cares_STATIC)
+        set (_static STATIC)
+      else ()
+        set (_search "${CMAKE_SHARED_LIBRARY_PREFIX}cares${CMAKE_SHARED_LIBRARY_SUFFIX}")
+        set (_prefix cares)
+        set (_static)
+      endif()
+      find_library(_location NAMES ${_search} HINTS ${cares_LIBRARY_DIRS})
+      if (NOT _location)
+        message (FATAL_ERROR "using pkg-config for grpc, can't find c-ares")
+      endif ()
+      if(${_location} MATCHES "\\.a$")
+        add_library(c-ares::cares STATIC IMPORTED GLOBAL)
+      else()
+        add_library(c-ares::cares SHARED IMPORTED GLOBAL)
+      endif()      
+      set_target_properties (c-ares::cares PROPERTIES
+        IMPORTED_LOCATION ${_location}
+        INTERFACE_INCLUDE_DIRECTORIES "${${_prefix}_INCLUDE_DIRS}"
+        INTERFACE_LINK_OPTIONS "${${_prefix}_LDFLAGS}"
+      )
+      exclude_if_included (c-ares::cares)
+    else ()
+      message (FATAL_ERROR "using pkg-config for grpc, can't find c-ares")
+    endif ()
+  else ()
+    #[===========================[
+       c-ares (grpc requires)
+    #]===========================]
+    ExternalProject_Add (c-ares_src
+      PREFIX ${nih_cache_path}
+      GIT_REPOSITORY https://github.com/c-ares/c-ares.git
+      GIT_TAG cares-1_15_0
+      CMAKE_ARGS
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+        -DCMAKE_DEBUG_POSTFIX=_d
+        $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+        -DCMAKE_INSTALL_PREFIX=<BINARY_DIR>/_installed_
+        -DCARES_SHARED=OFF
+        -DCARES_STATIC=ON
+        -DCARES_STATIC_PIC=ON
+        -DCARES_INSTALL=ON
+        -DCARES_MSVC_STATIC_RUNTIME=ON
+        $<$<BOOL:${MSVC}>:
+          "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+        >
+      LOG_BUILD ON
+      LOG_CONFIGURE ON
+      BUILD_COMMAND
+        ${CMAKE_COMMAND}
+          --build .
+          --config $<CONFIG>
+          --parallel ${ep_procs}
+      TEST_COMMAND ""
+      INSTALL_COMMAND
+        ${CMAKE_COMMAND} -E env --unset=DESTDIR ${CMAKE_COMMAND} --build . --config $<CONFIG> --target install
+      BUILD_BYPRODUCTS
+        <BINARY_DIR>/_installed_/lib/${ep_lib_prefix}cares${ep_lib_suffix}
+        <BINARY_DIR>/_installed_/lib/${ep_lib_prefix}cares_d${ep_lib_suffix}
+    )
+    exclude_if_included (c-ares_src)
+    ExternalProject_Get_Property (c-ares_src BINARY_DIR)
+    set (cares_binary_dir "${BINARY_DIR}")
+
+    add_library (c-ares::cares STATIC IMPORTED GLOBAL)
+    file (MAKE_DIRECTORY ${BINARY_DIR}/_installed_/include)
+    set_target_properties (c-ares::cares PROPERTIES
+      IMPORTED_LOCATION_DEBUG
+        ${BINARY_DIR}/_installed_/lib/${ep_lib_prefix}cares_d${ep_lib_suffix}
+      IMPORTED_LOCATION_RELEASE
+        ${BINARY_DIR}/_installed_/lib/${ep_lib_prefix}cares${ep_lib_suffix}
+      INTERFACE_INCLUDE_DIRECTORIES
+        ${BINARY_DIR}/_installed_/include)
+    add_dependencies (c-ares::cares c-ares_src)
+    exclude_if_included (c-ares::cares)
+
+    if (NOT has_zlib)
+      #[===========================[
+         zlib (grpc requires)
+      #]===========================]
+      if (MSVC)
+        set (zlib_debug_postfix "d") # zlib cmake sets this internally for MSVC, so we really don't have a choice
+        set (zlib_base "zlibstatic")
+      else ()
+        set (zlib_debug_postfix "_d")
+        set (zlib_base "z")
+      endif ()
+      ExternalProject_Add (zlib_src
+        PREFIX ${nih_cache_path}
+        GIT_REPOSITORY https://github.com/madler/zlib.git
+        GIT_TAG v1.2.11
+        CMAKE_ARGS
+          -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+          $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+          -DCMAKE_DEBUG_POSTFIX=${zlib_debug_postfix}
+          $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+          -DCMAKE_INSTALL_PREFIX=<BINARY_DIR>/_installed_
+          -DBUILD_SHARED_LIBS=OFF
+          $<$<BOOL:${MSVC}>:
+            "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+            "-DCMAKE_C_FLAGS_DEBUG=-MTd"
+            "-DCMAKE_C_FLAGS_RELEASE=-MT"
+          >
+        LOG_BUILD ON
+        LOG_CONFIGURE ON
+        BUILD_COMMAND
+          ${CMAKE_COMMAND}
+            --build .
+            --config $<CONFIG>
+            --parallel ${ep_procs}
+        TEST_COMMAND ""
+        INSTALL_COMMAND
+          ${CMAKE_COMMAND} -E env --unset=DESTDIR ${CMAKE_COMMAND} --build . --config $<CONFIG> --target install
+        BUILD_BYPRODUCTS
+          <BINARY_DIR>/_installed_/lib/${ep_lib_prefix}${zlib_base}${ep_lib_suffix}
+          <BINARY_DIR>/_installed_/lib/${ep_lib_prefix}${zlib_base}${zlib_debug_postfix}${ep_lib_suffix}
+      )
+      exclude_if_included (zlib_src)
+      ExternalProject_Get_Property (zlib_src BINARY_DIR)
+      set (zlib_binary_dir "${BINARY_DIR}")
+
+      add_library (ZLIB::ZLIB STATIC IMPORTED GLOBAL)
+      file (MAKE_DIRECTORY ${BINARY_DIR}/_installed_/include)
+      set_target_properties (ZLIB::ZLIB PROPERTIES
+        IMPORTED_LOCATION_DEBUG
+          ${BINARY_DIR}/_installed_/lib/${ep_lib_prefix}${zlib_base}${zlib_debug_postfix}${ep_lib_suffix}
+        IMPORTED_LOCATION_RELEASE
+          ${BINARY_DIR}/_installed_/lib/${ep_lib_prefix}${zlib_base}${ep_lib_suffix}
+        INTERFACE_INCLUDE_DIRECTORIES
+          ${BINARY_DIR}/_installed_/include)
+      add_dependencies (ZLIB::ZLIB zlib_src)
+      exclude_if_included (ZLIB::ZLIB)
+    endif ()
+
+    #[===========================[
+       grpc
+    #]===========================]
+    ExternalProject_Add (grpc_src
+      PREFIX ${nih_cache_path}
+      GIT_REPOSITORY https://github.com/grpc/grpc.git
+      GIT_TAG v1.25.0
+      CMAKE_ARGS
+        -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_STANDARD=17
+        $<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:-DCMAKE_VERBOSE_MAKEFILE=ON>
+        $<$<BOOL:${CMAKE_TOOLCHAIN_FILE}>:-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}>
+        $<$<BOOL:${VCPKG_TARGET_TRIPLET}>:-DVCPKG_TARGET_TRIPLET=${VCPKG_TARGET_TRIPLET}>
+        $<$<BOOL:${unity}>:-DCMAKE_UNITY_BUILD=ON}>
+        -DCMAKE_DEBUG_POSTFIX=_d
+        $<$<NOT:$<BOOL:${is_multiconfig}>>:-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}>
+        -DgRPC_BUILD_TESTS=OFF
+        -DgRPC_BENCHMARK_PROVIDER=""
+        -DgRPC_BUILD_CSHARP_EXT=OFF
+        -DgRPC_MSVC_STATIC_RUNTIME=ON
+        -DgRPC_INSTALL=OFF
+        -DgRPC_CARES_PROVIDER=package
+        -Dc-ares_DIR=${cares_binary_dir}/_installed_/lib/cmake/c-ares
+        -DgRPC_SSL_PROVIDER=package
+        -DOPENSSL_ROOT_DIR=${OPENSSL_ROOT_DIR}
+        -DgRPC_PROTOBUF_PROVIDER=package
+        -DProtobuf_USE_STATIC_LIBS=$<IF:$<AND:$<BOOL:${Protobuf_FOUND}>,$<NOT:$<BOOL:${static}>>>,OFF,ON>
+        -DProtobuf_INCLUDE_DIR=$<JOIN:$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>,:_:>
+        -DProtobuf_LIBRARY=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:protobuf::libprotobuf,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:protobuf::libprotobuf,IMPORTED_LOCATION_RELEASE>>
+        -DProtobuf_PROTOC_LIBRARY=$<IF:$<CONFIG:Debug>,$<TARGET_PROPERTY:protobuf::libprotoc,IMPORTED_LOCATION_DEBUG>,$<TARGET_PROPERTY:protobuf::libprotoc,IMPORTED_LOCATION_RELEASE>>
+        -DProtobuf_PROTOC_EXECUTABLE=$<TARGET_PROPERTY:protobuf::protoc,IMPORTED_LOCATION>
+        -DgRPC_ZLIB_PROVIDER=package
+        $<$<NOT:$<BOOL:${has_zlib}>>:-DZLIB_ROOT=${zlib_binary_dir}/_installed_>
+        $<$<BOOL:${MSVC}>:
+          "-DCMAKE_CXX_FLAGS=-GR -Gd -fp:precise -FS -EHa -MP"
+          "-DCMAKE_C_FLAGS=-GR -Gd -fp:precise -FS -MP"
+        >
+      LOG_BUILD ON
+      LOG_CONFIGURE ON
+      BUILD_COMMAND
+        ${CMAKE_COMMAND}
+        --build .
+        --config $<CONFIG>
+        --parallel ${ep_procs}
+        $<$<BOOL:${is_multiconfig}>:
+          COMMAND
+            ${CMAKE_COMMAND} -E copy
+            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}grpc${grpc_suffix}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}grpc++${grpc_suffix}$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}address_sorting$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>/$<CONFIG>/${ep_lib_prefix}gpr$<$<CONFIG:Debug>:_d>${ep_lib_suffix}
+            <BINARY_DIR>/$<CONFIG>/grpc_cpp_plugin${CMAKE_EXECUTABLE_SUFFIX}
+            <BINARY_DIR>
+          >
+      LIST_SEPARATOR :_:
+      TEST_COMMAND ""
+      INSTALL_COMMAND ""
+      DEPENDS c-ares_src
+      BUILD_BYPRODUCTS
+        <BINARY_DIR>/${ep_lib_prefix}grpc${grpc_suffix}${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}grpc${grpc_suffix}_d${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}grpc++${grpc_suffix}${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}grpc++${grpc_suffix}_d${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}address_sorting${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}address_sorting_d${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}gpr${ep_lib_suffix}
+        <BINARY_DIR>/${ep_lib_prefix}gpr_d${ep_lib_suffix}
+        <BINARY_DIR>/grpc_cpp_plugin${CMAKE_EXECUTABLE_SUFFIX}
+    )
+    if (TARGET protobuf_src)
+      ExternalProject_Add_StepDependencies(grpc_src build protobuf_src)
+    endif ()
+    exclude_if_included (grpc_src)
+    ExternalProject_Get_Property (grpc_src BINARY_DIR)
+    ExternalProject_Get_Property (grpc_src SOURCE_DIR)
+    set (grpc_binary_dir "${BINARY_DIR}")
+    set (grpc_source_dir "${SOURCE_DIR}")
+    if (CMAKE_VERBOSE_MAKEFILE)
+      print_ep_logs (grpc_src)
+    endif ()
+    file (MAKE_DIRECTORY ${SOURCE_DIR}/include)
+
+    macro (add_imported_grpc libname_)
+      add_library ("gRPC::${libname_}" STATIC IMPORTED GLOBAL)
+      set_target_properties ("gRPC::${libname_}" PROPERTIES
+        IMPORTED_LOCATION_DEBUG
+          ${grpc_binary_dir}/${ep_lib_prefix}${libname_}_d${ep_lib_suffix}
+        IMPORTED_LOCATION_RELEASE
+          ${grpc_binary_dir}/${ep_lib_prefix}${libname_}${ep_lib_suffix}
+        INTERFACE_INCLUDE_DIRECTORIES
+          ${grpc_source_dir}/include)
+      add_dependencies ("gRPC::${libname_}" grpc_src)
+      target_link_libraries (ripple_libs INTERFACE "gRPC::${libname_}")
+      exclude_if_included ("gRPC::${libname_}")
+    endmacro ()
+
+    set_target_properties (gRPC::grpc_cpp_plugin PROPERTIES
+        IMPORTED_LOCATION "${grpc_binary_dir}/grpc_cpp_plugin${CMAKE_EXECUTABLE_SUFFIX}")
+    add_dependencies (gRPC::grpc_cpp_plugin grpc_src)
+  endif ()
+
+  add_imported_grpc (gpr)
+  add_imported_grpc ("grpc${grpc_suffix}")
+  add_imported_grpc ("grpc++${grpc_suffix}")
+  add_imported_grpc (address_sorting)
+
+  target_link_libraries ("gRPC::grpc${grpc_suffix}" INTERFACE c-ares::cares gRPC::gpr gRPC::address_sorting ZLIB::ZLIB)
+  target_link_libraries ("gRPC::grpc++${grpc_suffix}" INTERFACE "gRPC::grpc${grpc_suffix}" gRPC::gpr)
+endif ()
 
 #[=================================[
    generate protobuf sources for
    grpc defs and bundle into a
    static lib
 #]=================================]
-set(GRPC_GEN_DIR "${CMAKE_BINARY_DIR}/proto_gen_grpc")
-file(MAKE_DIRECTORY ${GRPC_GEN_DIR})
-set(GRPC_PROTO_SRCS)
-set(GRPC_PROTO_HDRS)
-set(GRPC_PROTO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/proto/org")
+set (GRPC_GEN_DIR "${CMAKE_BINARY_DIR}/proto_gen_grpc")
+file (MAKE_DIRECTORY ${GRPC_GEN_DIR})
+set (GRPC_PROTO_SRCS)
+set (GRPC_PROTO_HDRS)
+set (GRPC_PROTO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/proto/org")
 file(GLOB_RECURSE GRPC_DEFINITION_FILES LIST_DIRECTORIES false "${GRPC_PROTO_ROOT}/*.proto")
 foreach(file ${GRPC_DEFINITION_FILES})
   get_filename_component(_abs_file ${file} ABSOLUTE)
@@ -20,10 +329,10 @@ foreach(file ${GRPC_DEFINITION_FILES})
   get_filename_component(_rel_root_dir ${_rel_root_file} DIRECTORY)
   file(RELATIVE_PATH _rel_dir ${CMAKE_CURRENT_SOURCE_DIR} ${_abs_dir})
 
-  set(src_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.cc")
-  set(src_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.cc")
-  set(hdr_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.h")
-  set(hdr_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.h")
+  set (src_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.cc")
+  set (src_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.cc")
+  set (hdr_1 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.grpc.pb.h")
+  set (hdr_2 "${GRPC_GEN_DIR}/${_rel_root_dir}/${_basename}.pb.h")
   add_custom_command(
     OUTPUT ${src_1} ${src_2} ${hdr_1} ${hdr_2}
     COMMAND protobuf::protoc
@@ -41,22 +350,20 @@ foreach(file ${GRPC_DEFINITION_FILES})
     list(APPEND GRPC_PROTO_HDRS ${hdr_1} ${hdr_2})
 endforeach()
 
-add_library(grpc_pbufs STATIC ${GRPC_PROTO_SRCS} ${GRPC_PROTO_HDRS})
-#target_include_directories(grpc_pbufs PRIVATE src)
-target_include_directories(grpc_pbufs SYSTEM PUBLIC ${GRPC_GEN_DIR})
-target_link_libraries(grpc_pbufs
-  "gRPC::grpc++"
-  # libgrpc is missing references.
-  absl::random_random
-)
-target_compile_options(grpc_pbufs
+add_library (grpc_pbufs STATIC ${GRPC_PROTO_SRCS} ${GRPC_PROTO_HDRS})
+#target_include_directories (grpc_pbufs PRIVATE src)
+target_include_directories (grpc_pbufs SYSTEM PUBLIC ${GRPC_GEN_DIR})
+target_link_libraries (grpc_pbufs protobuf::libprotobuf "gRPC::grpc++${grpc_suffix}")
+target_compile_options (grpc_pbufs
   PRIVATE
     $<$<BOOL:${MSVC}>:-wd4065>
     $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
   PUBLIC
     $<$<BOOL:${MSVC}>:-wd4996>
-    $<$<BOOL:${XCODE}>:
+    $<$<BOOL:${is_xcode}>:
       --system-header-prefix="google/protobuf"
       -Wno-deprecated-dynamic-exception-spec
     >)
-add_library(Ripple::grpc_pbufs ALIAS grpc_pbufs)
+add_library (Ripple::grpc_pbufs ALIAS grpc_pbufs)
+target_link_libraries (ripple_libs INTERFACE Ripple::grpc_pbufs)
+exclude_if_included (grpc_pbufs)

Builds/levelization/results/ordering.txt

@@ -186,10 +186,6 @@ test.protocol > ripple.crypto
 test.protocol > ripple.json
 test.protocol > ripple.protocol
 test.protocol > test.toplevel
-test.rdb > ripple.app
-test.rdb > ripple.core
-test.rdb > test.jtx
-test.rdb > test.toplevel
 test.resource > ripple.basics
 test.resource > ripple.beast
 test.resource > ripple.resource

CMakeLists.txt

@@ -50,6 +50,11 @@ if(CMAKE_TOOLCHAIN_FILE)
   endif()
 endif()
 
+if (NOT USE_CONAN)
+  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake")
+  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Builds/CMake/deps")
+endif()
+
 include (CheckCXXCompilerFlag)
 include (FetchContent)
 include (ExternalProject)
@@ -62,7 +67,9 @@ endif ()
 include(RippledSanity)
 include(RippledVersion)
 include(RippledSettings)
-
+if (NOT USE_CONAN)
+  include(RippledNIH)
+endif()
 # this check has to remain in the top-level cmake
 # because of the early return statement
 if (packages_only)
@@ -74,64 +81,87 @@ endif ()
 include(RippledCompiler)
 include(RippledInterface)
 
-include(deps/Boost)
-find_package(OpenSSL 1.1.1 REQUIRED)
-set_target_properties(OpenSSL::SSL PROPERTIES
-  INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
-)
-add_subdirectory(src/secp256k1)
-add_subdirectory(src/ed25519-donna)
-find_package(lz4 REQUIRED)
-# Target names with :: are not allowed in a generator expression.
-# We need to pull the include directories and imported location properties
-# from separate targets.
-find_package(LibArchive REQUIRED)
-find_package(SOCI REQUIRED)
-find_package(SQLite3 REQUIRED)
-find_package(Snappy REQUIRED)
-# find_package(wasmedge REQUIRED)
-option(rocksdb "Enable RocksDB" ON)
-if(rocksdb)
-  find_package(RocksDB REQUIRED)
-  set_target_properties(RocksDB::rocksdb PROPERTIES
-    INTERFACE_COMPILE_DEFINITIONS RIPPLE_ROCKSDB_AVAILABLE=1
-  )
-  target_link_libraries(ripple_libs INTERFACE RocksDB::rocksdb)
-endif()
-find_package(nudb REQUIRED)
-find_package(date REQUIRED)
-include(deps/Protobuf)
-include(deps/gRPC)
-include(deps/WasmEdge) 
-  if(TARGET nudb::core)
-  set(nudb nudb::core)
-elseif(TARGET NuDB::nudb)
-  set(nudb NuDB::nudb)
+include(deps/dilithium)
+###
+if (NOT USE_CONAN)
+  add_subdirectory(src/secp256k1)
+  add_subdirectory(src/ed25519-donna)
+  include(deps/Boost)
+  include(deps/OpenSSL)
+  # include(deps/Secp256k1)
+  # include(deps/Ed25519-donna)
+  include(deps/Lz4)
+  include(deps/Libarchive)
+  include(deps/Sqlite)
+  include(deps/Soci)
+  include(deps/Snappy)
+  include(deps/Rocksdb)
+  include(deps/Nudb)
+  include(deps/date)
+  include(deps/Protobuf)
+  include(deps/gRPC)
+  include(deps/cassandra)
+  include(deps/Postgres)
+  include(deps/WasmEdge)
 else()
-  message(FATAL_ERROR "unknown nudb target")
-endif()
-target_link_libraries(ripple_libs INTERFACE ${nudb})
+  include(conan/Boost)
+  find_package(OpenSSL 1.1.1 REQUIRED)
+  set_target_properties(OpenSSL::SSL PROPERTIES
+    INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
+  )
+  add_subdirectory(src/secp256k1)
+  add_subdirectory(src/ed25519-donna)
+  find_package(lz4 REQUIRED)
+  # Target names with :: are not allowed in a generator expression.
+  # We need to pull the include directories and imported location properties
+  # from separate targets.
+  find_package(LibArchive REQUIRED)
+  find_package(SOCI REQUIRED)
+  find_package(SQLite3 REQUIRED)
+  find_package(Snappy REQUIRED)
+  find_package(wasmedge REQUIRED)
+  option(rocksdb "Enable RocksDB" ON)
+  if(rocksdb)
+    find_package(RocksDB REQUIRED)
+    set_target_properties(RocksDB::rocksdb PROPERTIES
+      INTERFACE_COMPILE_DEFINITIONS RIPPLE_ROCKSDB_AVAILABLE=1
+    )
+    target_link_libraries(ripple_libs INTERFACE RocksDB::rocksdb)
+  endif()
+  find_package(nudb REQUIRED)
+  find_package(date REQUIRED)
+  include(conan/Protobuf)
+  include(conan/gRPC)
+    if(TARGET nudb::core)
+    set(nudb nudb::core)
+  elseif(TARGET NuDB::nudb)
+    set(nudb NuDB::nudb)
+  else()
+    message(FATAL_ERROR "unknown nudb target")
+  endif()
+  target_link_libraries(ripple_libs INTERFACE ${nudb})
 
-if(reporting)
-  find_package(cassandra-cpp-driver REQUIRED)
-  find_package(PostgreSQL REQUIRED)
+  if(reporting)
+    find_package(cassandra-cpp-driver REQUIRED)
+    find_package(PostgreSQL REQUIRED)
+    target_link_libraries(ripple_libs INTERFACE
+      cassandra-cpp-driver::cassandra-cpp-driver
+      PostgreSQL::PostgreSQL
+    )
+  endif()
   target_link_libraries(ripple_libs INTERFACE
-    cassandra-cpp-driver::cassandra-cpp-driver
-    PostgreSQL::PostgreSQL
+    ed25519::ed25519
+    LibArchive::LibArchive
+    lz4::lz4
+    OpenSSL::Crypto
+    OpenSSL::SSL
+    Ripple::grpc_pbufs
+    Ripple::pbufs
+    secp256k1::secp256k1
+    soci::soci
+    SQLite::SQLite3
   )
 endif()
-target_link_libraries(ripple_libs INTERFACE
-  ed25519::ed25519
-  LibArchive::LibArchive
-  lz4::lz4
-  OpenSSL::Crypto
-  OpenSSL::SSL
-  Ripple::grpc_pbufs
-  Ripple::pbufs
-  secp256k1::secp256k1
-  soci::soci
-  SQLite::SQLite3
-)
 
 ###
 

build-core.sh

@@ -5,6 +5,8 @@
 # debugging.
 set -ex
 
+set -e
+
 echo "START INSIDE CONTAINER - CORE"
 
 echo "-- BUILD CORES:       $3"
@@ -25,8 +27,7 @@ if [[ "$?" -ne "0" ]]; then
   exit 127
 fi
 
-BUILD_TYPE=Release
-
+perl -i -pe "s/^(\\s*)-DBUILD_SHARED_LIBS=OFF/\\1-DBUILD_SHARED_LIBS=OFF\\n\\1-DROCKSDB_BUILD_SHARED=OFF/g" Builds/CMake/deps/Rocksdb.cmake &&
 mv Builds/CMake/deps/WasmEdge.cmake Builds/CMake/deps/WasmEdge.old &&
 echo "find_package(LLVM REQUIRED CONFIG)
 message(STATUS \"Found LLVM \${LLVM_PACKAGE_VERSION}\")
@@ -37,30 +38,13 @@ target_link_libraries (ripple_libs INTERFACE wasmedge)
 add_library (wasmedge::wasmedge ALIAS wasmedge)
 message(\"WasmEdge DONE\")
 " > Builds/CMake/deps/WasmEdge.cmake &&
-
-export LDFLAGS="-static-libstdc++"
-
-git config --global --add safe.directory /io &&
 git checkout src/ripple/protocol/impl/BuildInfo.cpp &&
-sed -i s/\"0.0.0\"/\"$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)$(if [ -n "$4" ]; then echo "+$4"; fi)\"/g src/ripple/protocol/impl/BuildInfo.cpp &&
-conan export external/snappy snappy/1.1.10@xahaud/stable &&
-conan export external/soci soci/4.0.3@xahaud/stable &&
+sed -i s/\"0.0.0\"/\"$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4\"/g src/ripple/protocol/impl/BuildInfo.cpp &&
 cd release-build &&
-conan install .. --output-folder . --build missing --settings build_type=$BUILD_TYPE &&
-cmake .. -G Ninja \
-  -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
-  -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
-  -DCMAKE_EXE_LINKER_FLAGS="-static-libstdc++" \
-  -DLLVM_DIR=$LLVM_DIR \
-  -DWasmEdge_LIB=$WasmEdge_LIB \
-  -Dxrpld=TRUE \
-  -Dtests=TRUE &&
-ccache -z &&
-ninja -j $3 &&
-ccache -s &&
-strip -s rippled &&	
+cmake .. -DCMAKE_BUILD_TYPE=Release -DBoost_NO_BOOST_CMAKE=ON -DLLVM_DIR=/usr/lib64/llvm13/lib/cmake/llvm/ -DLLVM_LIBRARY_DIR=/usr/lib64/llvm13/lib/ -DWasmEdge_LIB=/usr/local/lib64/libwasmedge.a &&
+make -j$3 VERBOSE=1 &&
+strip -s rippled &&
 mv rippled xahaud &&
-libcheck xahaud &&
 echo "Build host: `hostname`" > release.info &&
 echo "Build date: `date`" >> release.info &&
 echo "Build md5: `md5sum xahaud`" >> release.info &&
@@ -85,8 +69,8 @@ fi
 cd ..;
 
 mv src/ripple/net/impl/RegisterSSLCerts.cpp.old src/ripple/net/impl/RegisterSSLCerts.cpp;
+mv Builds/CMake/deps/Rocksdb.cmake.old Builds/CMake/deps/Rocksdb.cmake;
 mv Builds/CMake/deps/WasmEdge.old Builds/CMake/deps/WasmEdge.cmake;
-rm src/certs/certbundle.h;
-git checkout src/ripple/protocol/impl/BuildInfo.cpp;
+
 
 echo "END INSIDE CONTAINER - CORE"

build-full.sh

@@ -3,6 +3,8 @@
 # processes launched or upon any unbound variable.
 # We use set -x to print commands before running them to help with
 # debugging.
+set -ex
+
 set -e
 
 echo "START INSIDE CONTAINER - FULL"
@@ -14,6 +16,13 @@ echo "-- GITHUB_RUN_NUMBER: $4"
 
 umask 0000;
 
+echo "Fixing CentOS 7 EOL"
+
+sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
+sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
+yum clean all
+yum-config-manager --disable centos-sclo-sclo
+
 ####
 
 cd /io;
@@ -64,15 +73,92 @@ then
     #endif/g" src/ripple/net/impl/RegisterSSLCerts.cpp &&
     sed -i "s/#include <ripple\/net\/RegisterSSLCerts.h>/\0\n#include <certs\/certbundle.h>/g" src/ripple/net/impl/RegisterSSLCerts.cpp
 fi
-# Environment setup moved to Dockerfile in release-builder.sh
-source /opt/rh/gcc-toolset-11/enable
-export PATH=/usr/local/bin:$PATH
-export CC='ccache gcc' &&
-export CXX='ccache g++' &&
+mkdir -p .nih_c;
+mkdir -p .nih_toolchain;
+cd .nih_toolchain &&
+yum install -y wget lz4 lz4-devel git llvm13-static.x86_64 llvm13-devel.x86_64 devtoolset-10-binutils zlib-static ncurses-static -y \
+  devtoolset-7-gcc-c++ \
+  devtoolset-9-gcc-c++ \
+  devtoolset-10-gcc-c++ \
+  snappy snappy-devel \
+  zlib zlib-devel \
+  lz4-devel \
+  libasan &&
+export PATH=`echo $PATH | sed -E "s/devtoolset-9/devtoolset-7/g"` &&
+echo "-- Install ZStd 1.1.3 --" &&
+yum install epel-release -y &&
+ZSTD_VERSION="1.1.3" &&
+( wget -nc -q -O zstd-${ZSTD_VERSION}.tar.gz https://github.com/facebook/zstd/archive/v${ZSTD_VERSION}.tar.gz; echo "" ) &&
+tar xzvf zstd-${ZSTD_VERSION}.tar.gz &&
+cd zstd-${ZSTD_VERSION} &&
+make -j$3 install &&
+cd .. &&
+echo "-- Install Cmake 3.23.1 --" &&
+pwd &&
+( wget -nc -q https://github.com/Kitware/CMake/releases/download/v3.23.1/cmake-3.23.1-linux-x86_64.tar.gz; echo "" ) &&
+tar -xzf cmake-3.23.1-linux-x86_64.tar.gz -C /hbb/ &&
+echo "-- Install Boost 1.86.0 --" &&
+pwd &&
+( wget -nc -q https://archives.boost.io/release/1.86.0/source/boost_1_86_0.tar.gz; echo "" ) &&
+tar -xzf boost_1_86_0.tar.gz &&
+cd boost_1_86_0 && ./bootstrap.sh && ./b2  link=static -j$3 && ./b2 install &&
+cd ../ &&
+echo "-- Install Protobuf 3.20.0 --" &&
+pwd &&
+( wget -nc -q https://github.com/protocolbuffers/protobuf/releases/download/v3.20.0/protobuf-all-3.20.0.tar.gz; echo "" ) &&
+tar -xzf protobuf-all-3.20.0.tar.gz &&
+cd protobuf-3.20.0/ &&
+./autogen.sh && ./configure --prefix=/usr --disable-shared link=static && make -j$3 && make install &&
+cd .. &&
+echo "-- Build LLD --" &&
+pwd &&
+ln /usr/bin/llvm-config-13 /usr/bin/llvm-config &&
+mv /opt/rh/devtoolset-9/root/usr/bin/ar /opt/rh/devtoolset-9/root/usr/bin/ar-9 &&
+ln /opt/rh/devtoolset-10/root/usr/bin/ar  /opt/rh/devtoolset-9/root/usr/bin/ar &&
+( wget -nc -q https://github.com/llvm/llvm-project/releases/download/llvmorg-13.0.1/lld-13.0.1.src.tar.xz; echo "" ) &&
+( wget -nc -q https://github.com/llvm/llvm-project/releases/download/llvmorg-13.0.1/libunwind-13.0.1.src.tar.xz; echo "" ) &&
+tar -xf lld-13.0.1.src.tar.xz &&
+tar -xf libunwind-13.0.1.src.tar.xz &&
+cp -r libunwind-13.0.1.src/include libunwind-13.0.1.src/src lld-13.0.1.src/ &&
+cd lld-13.0.1.src &&
+rm -rf build CMakeCache.txt &&
+mkdir -p build &&
+cd build &&
+cmake .. -DLLVM_LIBRARY_DIR=/usr/lib64/llvm13/lib/ -DCMAKE_INSTALL_PREFIX=/usr/lib64/llvm13/ -DCMAKE_BUILD_TYPE=Release &&
+make -j$3 install &&
+ln -s /usr/lib64/llvm13/lib/include/lld /usr/include/lld &&
+cp /usr/lib64/llvm13/lib/liblld*.a /usr/local/lib/ &&
+cd ../../ &&
+echo "-- Build WasmEdge --" &&
+( wget -nc -q https://github.com/WasmEdge/WasmEdge/archive/refs/tags/0.11.2.zip; unzip -o 0.11.2.zip; ) &&
+cd WasmEdge-0.11.2 &&
+( mkdir -p build; echo "" ) &&
+cd build &&
+export BOOST_ROOT="/usr/local/src/boost_1_86_0" &&
+export Boost_LIBRARY_DIRS="/usr/local/lib" &&
+export BOOST_INCLUDEDIR="/usr/local/src/boost_1_86_0" &&
+export PATH=`echo $PATH | sed -E "s/devtoolset-7/devtoolset-9/g"` &&
+cmake .. \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DWASMEDGE_BUILD_SHARED_LIB=OFF \
+    -DWASMEDGE_BUILD_STATIC_LIB=ON \
+    -DWASMEDGE_BUILD_AOT_RUNTIME=ON \
+    -DWASMEDGE_FORCE_DISABLE_LTO=ON \
+    -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+    -DWASMEDGE_LINK_LLVM_STATIC=ON \
+    -DWASMEDGE_BUILD_PLUGINS=OFF \
+    -DWASMEDGE_LINK_TOOLS_STATIC=ON \
+    -DBoost_NO_BOOST_CMAKE=ON -DLLVM_DIR=/usr/lib64/llvm13/lib/cmake/llvm/ -DLLVM_LIBRARY_DIR=/usr/lib64/llvm13/lib/ &&
+make -j$3 install &&
+export PATH=`echo $PATH | sed -E "s/devtoolset-9/devtoolset-10/g"` &&
+cp -r include/api/wasmedge /usr/include/ &&
+cd /io/ &&
 echo "-- Build Rippled --" &&
 pwd &&
+cp Builds/CMake/deps/Rocksdb.cmake Builds/CMake/deps/Rocksdb.cmake.old &&
 
-echo "MOVING TO [ build-core.sh ]";
+echo "MOVING TO [ build-core.sh ]"
+cd /io;
 
 printenv > .env.temp;
 cat .env.temp | grep '=' | sed s/\\\(^[^=]\\+=\\\)/\\1\\\"/g|sed s/\$/\\\"/g > .env;

cfg/rippled-example.cfg

@@ -1063,16 +1063,14 @@
 #       RWDB is recommended for Validator and Peer nodes that are not required to 
 #       store history.
 #
-#   Required keys for NuDB and RocksDB:
+#       RWDB maintains its high speed regardless of the amount of history
+#       stored. Online delete should NOT be used instead RWDB will use the 
+#       ledger_history config value to determine how many ledgers to keep in memory.
+#
+#   Required keys for NuDB, RWDB and RocksDB:
 #
 #       path                Location to store the database
 #
-#   Required keys for RWDB:
-#
-#       online_delete       Required. RWDB stores data in memory and will
-#                           grow unbounded without online_delete. See the
-#                           online_delete section below.
-#
 #   Required keys for Cassandra:
 #
 #      contact_points       IP of a node in the Cassandra cluster
@@ -1112,17 +1110,7 @@
 #                           if sufficient IOPS capacity is available.
 #                           Default 0.
 #
-#   online_delete for RWDB, NuDB and RocksDB:
-#
-#       online_delete       Minimum value of 256. Enable automatic purging
-#                           of older ledger information. Maintain at least this
-#                           number of ledger records online. Must be greater
-#                           than or equal to ledger_history.
-#
-#                           REQUIRED for RWDB to prevent out-of-memory errors.
-#                           Optional for NuDB and RocksDB.
-#
-#   Optional keys for NuDB and RocksDB:
+#   Optional keys for NuDB or RocksDB:
 #
 #       earliest_seq        The default is 32570 to match the XRP ledger
 #                           network's earliest allowed sequence. Alternate
@@ -1132,7 +1120,12 @@
 #                           it must be defined with the same value in both
 #                           sections.
 #
-
+#       online_delete       Minimum value of 256. Enable automatic purging
+#                           of older ledger information. Maintain at least this
+#                           number of ledger records online. Must be greater
+#                           than or equal to ledger_history. If using RWDB 
+#                           this value is ignored.
+#
 #       These keys modify the behavior of online_delete, and thus are only
 #       relevant if online_delete is defined and non-zero:
 #

conanfile.py

@@ -32,8 +32,8 @@ class Xrpl(ConanFile):
         'nudb/2.0.8',
         'openssl/1.1.1u',
         'protobuf/3.21.9',
-        'snappy/1.1.10@xahaud/stable',
-        'soci/4.0.3@xahaud/stable',
+        'snappy/1.1.10',
+        'soci/4.0.3',
         'sqlite3/3.42.0',
         'zlib/1.2.13',
         'wasmedge/0.11.2',

docker-unit-tests.sh

@@ -8,4 +8,4 @@ if [[ "$GITHUB_REPOSITORY" == "" ]]; then
 fi
 
 echo "Mounting $(pwd)/io in ubuntu and running unit tests"
-docker run --rm -i -v $(pwd):/io --platform=linux/amd64 -e BUILD_CORES=$BUILD_CORES ubuntu sh -c '/io/release-build/xahaud --unittest-jobs $BUILD_CORES -u'
+docker run --rm -i -v $(pwd):/io -e BUILD_CORES=$BUILD_CORES ubuntu sh -c '/io/release-build/xahaud --unittest-jobs $BUILD_CORES -u'

external/snappy/conanfile.py

@@ -77,14 +77,9 @@ class SnappyConan(ConanFile):
         self.cpp_info.set_property("cmake_target_name", "Snappy::snappy")
         # TODO: back to global scope in conan v2 once cmake_find_package* generators removed
         self.cpp_info.components["snappylib"].libs = ["snappy"]
-        # The following block is commented out as a workaround for a bug in the
-        # Conan 1.x CMakeDeps generator. Including system_libs ("m") here
-        # incorrectly triggers a heuristic that adds a dynamic link to `stdc++`
-        # (-lstdc++), preventing a fully static build.
-        # This behavior is expected to be corrected in Conan 2.
-        # if not self.options.shared:
-        #     if self.settings.os in ["Linux", "FreeBSD"]:
-        #         self.cpp_info.components["snappylib"].system_libs.append("m")
+        if not self.options.shared:
+            if self.settings.os in ["Linux", "FreeBSD"]:
+                self.cpp_info.components["snappylib"].system_libs.append("m")
 
         # TODO: to remove in conan v2 once cmake_find_package* generators removed
         self.cpp_info.names["cmake_find_package"] = "Snappy"

external/soci/conanfile.py

@@ -154,7 +154,7 @@ class SociConan(ConanFile):
         self.cpp_info.components["soci_core"].set_property("cmake_target_name", "SOCI::soci_core{}".format(target_suffix))
         self.cpp_info.components["soci_core"].libs = ["{}soci_core{}".format(lib_prefix, lib_suffix)]
         if self.options.with_boost:
-            self.cpp_info.components["soci_core"].requires.append("boost::headers")
+            self.cpp_info.components["soci_core"].requires.append("boost::boost")
 
         # soci_empty
         if self.options.empty:

hook/genesis/govern.c

@@ -637,55 +637,43 @@ int64_t hook(uint32_t r)
             {
                 previous_member[0] = 'V';
 
-                for (int tbl = 1; GUARD(2), tbl <= 2; ++tbl)
+                for (int i = 1; GUARD(32), i < 32; ++i)
                 {
-                    for (int i = 0; GUARD(66), i < 32; ++i)
+                    previous_member[1] = i < 2 ? 'R' : i < 12 ? 'H' : 'S';
+                    previous_member[2] = 
+                        i == 0 ? 'R' :
+                        i == 1 ? 'D' :
+                        i < 12 ? i - 2 :
+                        i - 12;
+
+                    uint8_t vote_key[32];
+                    if (state(SBUF(vote_key), SBUF(previous_member)) == 32)
                     {
-                        previous_member[1] = i < 2 ? 'R' : i < 12 ? 'H' : 'S';
-                        previous_member[2] = 
-                            i == 0 ? 'R' :
-                            i == 1 ? 'D' :
-                            i < 12 ? i - 2 :
-                            i - 12;
-                        previous_member[3] = tbl;
+                        uint8_t vote_count = 0;
 
-                        uint8_t vote_key[32] = {};
-                        uint8_t ts = 
-                            previous_member[1] == 'H' ? 32 :      // hook topics are a 32 byte hook hash
-                            previous_member[1] == 'S' ? 20 :      // account topics are a 20 byte account ID
-                            8;                        // reward topics are an 8 byte le xfl
-                        
-                        uint8_t padding = 32 - ts;
-
-                        if (state(vote_key + padding, ts, SBUF(previous_member)) == ts)
+                        // find and decrement the vote counter
+                        vote_key[0] = 'C';
+                        vote_key[1] = previous_member[1];
+                        vote_key[2] = previous_member[2];
+                        if (state(&vote_count, 1, SBUF(vote_key)) == 1)
                         {
-                            uint8_t vote_count = 0;
-
-                            // find and decrement the vote counter
-                            vote_key[0] = 'C';
-                            vote_key[1] = previous_member[1];
-                            vote_key[2] = previous_member[2];
-                            vote_key[3] = tbl;
-                            if (state(&vote_count, 1, SBUF(vote_key)) == 1)
+                            // if we're down to 1 vote then delete state
+                            if (vote_count <= 1)
                             {
-                                // if we're down to 1 vote then delete state
-                                if (vote_count <= 1)
-                                {
-                                    ASSERT(state_set(0,0, SBUF(vote_key)) == 0);
-                                    trace_num(SBUF("Decrement vote count deleted"), vote_count);
-                                }
-                                else    // otherwise decrement
-                                {
-                                    vote_count--;
-                                    ASSERT(state_set(&vote_count, 1, SBUF(vote_key)) == 1);
-                                    trace_num(SBUF("Decrement vote count to"), vote_count);
-                                }
+                                ASSERT(state_set(0,0, SBUF(vote_key)) == 0);
+                                trace_num(SBUF("Decrement vote count deleted"), vote_count);
+                            }
+                            else    // otherwise decrement
+                            {
+                                vote_count--;
+                                ASSERT(state_set(&vote_count, 1, SBUF(vote_key)) == 1);
+                                trace_num(SBUF("Decrement vote count to"), vote_count);
                             }
-
-                            // delete the vote entry
-                            ASSERT(state_set(0,0, SBUF(previous_member)) == 0);
-                            trace(SBUF("Vote entry deleted"), vote_key, 32, 1);
                         }
+
+                        // delete the vote entry
+                        ASSERT(state_set(0,0, SBUF(previous_member)) == 0);
+                        trace(SBUF("Vote entry deleted"), vote_key, 32, 1);
                     }
                 }
 

release-builder.sh

@@ -1,8 +1,9 @@
-#!/bin/bash 
+#!/bin/bash -u
 # We use set -e and bash with -u to bail on first non zero exit code of any
 # processes launched or upon any unbound variable.
 # We use set -x to print commands before running them to help with
 # debugging.
+set -ex
 
 echo "START BUILDING (HOST)"
 
@@ -13,7 +14,7 @@ BUILD_CORES=$(echo "scale=0 ; `nproc` / 1.337" | bc)
 
 if [[ "$GITHUB_REPOSITORY" == "" ]]; then
   #Default
-  BUILD_CORES=${BUILD_CORES:-8} 
+  BUILD_CORES=8
 fi
 
 # Ensure still works outside of GH Actions by setting these to /dev/null
@@ -45,166 +46,29 @@ fi
 
 STATIC_CONTAINER=$(docker ps -a | grep $CONTAINER_NAME |wc -l)
 
-CACHE_VOLUME_NAME="xahau-release-builder-cache"
-
 # if [[ "$STATIC_CONTAINER" -gt "0" && "$GITHUB_REPOSITORY" != "" ]]; then
 if false; then
   echo "Static container, execute in static container to have max. cache"
   docker start $CONTAINER_NAME
-  docker exec -i $CONTAINER_NAME /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-core.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
+  docker exec -i $CONTAINER_NAME /hbb_exe/activate-exec bash -x /io/build-core.sh "$GITHUB_REPOSITORY" "$GITHUB_SHA" "$BUILD_CORES" "$GITHUB_RUN_NUMBER"
   docker stop $CONTAINER_NAME
 else
   echo "No static container, build on temp container"
   rm -rf release-build;
   mkdir -p release-build;
 
-  docker volume create $CACHE_VOLUME_NAME
-
-  # Create inline Dockerfile with environment setup for build-full.sh
-  DOCKERFILE_CONTENT=$(cat <<'DOCKERFILE_EOF'
-FROM ghcr.io/phusion/holy-build-box:4.0.1-amd64
-
-ARG BUILD_CORES=8
-
-# Enable repositories and install dependencies
-RUN /hbb_exe/activate-exec bash -c "dnf install -y epel-release && \
-    dnf config-manager --set-enabled powertools || dnf config-manager --set-enabled crb && \
-    dnf install -y --enablerepo=devel \
-        wget git \
-        gcc-toolset-11-gcc-c++ gcc-toolset-11-binutils gcc-toolset-11-libatomic-devel \
-        lz4 lz4-devel \
-        ncurses-static ncurses-devel \
-        snappy snappy-devel \
-        zlib zlib-devel zlib-static \
-        libasan \
-        python3 python3-pip \
-        ccache \
-        ninja-build \
-        patch \
-        glibc-devel glibc-static \
-        libxml2-devel \
-        autoconf \
-        automake \
-        texinfo \
-        libtool \
-        llvm14-static llvm14-devel && \
-    dnf clean all"
-
-# Install Conan and CMake
-RUN /hbb_exe/activate-exec pip3 install "conan==1.66.0" && \
-    /hbb_exe/activate-exec wget -q https://github.com/Kitware/CMake/releases/download/v3.23.1/cmake-3.23.1-linux-x86_64.tar.gz -O cmake.tar.gz && \
-    mkdir cmake && \
-    tar -xzf cmake.tar.gz --strip-components=1 -C cmake && \
-    rm cmake.tar.gz
-
-# Install Boost 1.86.0
-RUN /hbb_exe/activate-exec bash -c "cd /tmp && \
-    wget -q https://archives.boost.io/release/1.86.0/source/boost_1_86_0.tar.gz -O boost.tar.gz && \
-    mkdir boost && \
-    tar -xzf boost.tar.gz --strip-components=1 -C boost && \
-    cd boost && \
-    ./bootstrap.sh && \
-    ./b2 link=static -j${BUILD_CORES} && \
-    ./b2 install && \
-    cd /tmp && \
-    rm -rf boost boost.tar.gz"
-
-ENV BOOST_ROOT=/usr/local/src/boost_1_86_0
-ENV Boost_LIBRARY_DIRS=/usr/local/lib
-ENV BOOST_INCLUDEDIR=/usr/local/src/boost_1_86_0
-
-ENV CMAKE_EXE_LINKER_FLAGS="-static-libstdc++"
-
-ENV LLVM_DIR=/usr/lib64/llvm14/lib/cmake/llvm
-ENV WasmEdge_LIB=/usr/local/lib64/libwasmedge.a
-
-ENV CC='ccache gcc'
-ENV CXX='ccache g++'
-
-# Install LLD
-RUN /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && \
-    cd /tmp && \
-    wget -q https://github.com/llvm/llvm-project/releases/download/llvmorg-14.0.3/lld-14.0.3.src.tar.xz && \
-    wget -q https://github.com/llvm/llvm-project/releases/download/llvmorg-14.0.3/libunwind-14.0.3.src.tar.xz && \
-    tar -xf lld-14.0.3.src.tar.xz && \
-    tar -xf libunwind-14.0.3.src.tar.xz && \
-    cp -r libunwind-14.0.3.src/include libunwind-14.0.3.src/src lld-14.0.3.src/ && \
-    cd lld-14.0.3.src && \
-    mkdir -p build && cd build && \
-    cmake .. \
-        -DLLVM_LIBRARY_DIR=/usr/lib64/llvm14/lib/ \
-        -DCMAKE_INSTALL_PREFIX=/usr/lib64/llvm14/ \
-        -DCMAKE_BUILD_TYPE=Release \
-        -DCMAKE_EXE_LINKER_FLAGS=\"\$CMAKE_EXE_LINKER_FLAGS\" && \
-    make -j${BUILD_CORES} install && \
-    ln -s /usr/lib64/llvm14/lib/include/lld /usr/include/lld && \
-    cp /usr/lib64/llvm14/lib/liblld*.a /usr/local/lib/ && \
-    cd /tmp && rm -rf lld-* libunwind-*"
-
-# Build and install WasmEdge (static version)
-# Note: Conan only provides WasmEdge with shared library linking.
-# For a fully static build, we need to manually install:
-# * Boost: Static C++ libraries for filesystem and system operations (built from source above)
-# * LLVM: Static LLVM libraries for WebAssembly compilation (installed via llvm14-static package)
-# * LLD: Static linker to produce the final static binary (built from source above)
-# These were installed above to enable WASMEDGE_LINK_LLVM_STATIC=ON
-RUN cd /tmp && \
-    ( wget -nc -q https://github.com/WasmEdge/WasmEdge/archive/refs/tags/0.11.2.zip; unzip -o 0.11.2.zip; ) && \
-    cd WasmEdge-0.11.2 && \
-    ( mkdir -p build; echo "" ) && \
-    cd build && \
-    /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && \
-    ln -sf /opt/rh/gcc-toolset-11/root/usr/bin/ar /usr/bin/ar && \
-    cmake .. \
-        -DCMAKE_BUILD_TYPE=Release \
-        -DCMAKE_INSTALL_PREFIX=/usr/local \
-        -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
-        -DWASMEDGE_BUILD_SHARED_LIB=OFF \
-        -DWASMEDGE_BUILD_STATIC_LIB=ON \
-        -DWASMEDGE_BUILD_AOT_RUNTIME=ON \
-        -DWASMEDGE_FORCE_DISABLE_LTO=ON \
-        -DWASMEDGE_LINK_LLVM_STATIC=ON \
-        -DWASMEDGE_BUILD_PLUGINS=OFF \
-        -DWASMEDGE_LINK_TOOLS_STATIC=ON \
-        -DBoost_NO_BOOST_CMAKE=ON \
-        -DCMAKE_EXE_LINKER_FLAGS=\"\$CMAKE_EXE_LINKER_FLAGS\" \
-        && \
-    make -j${BUILD_CORES} install" && \
-    cp -r include/api/wasmedge /usr/include/ && \
-    cd /tmp && rm -rf WasmEdge* 0.11.2.zip
-
-# Set environment variables
-ENV PATH=/usr/local/bin:$PATH
-
-# Configure ccache and Conan
-RUN /hbb_exe/activate-exec bash -c "ccache -M 10G && \
-    ccache -o cache_dir=/cache/ccache && \
-    ccache -o compiler_check=content && \
-    conan config set storage.path=/cache/conan && \
-    (conan profile new default --detect || true) && \
-    conan profile update settings.compiler.libcxx=libstdc++11 default && \
-    conan profile update settings.compiler.cppstd=20 default"
-
-DOCKERFILE_EOF
-)
-
-  # Build custom Docker image
-  IMAGE_NAME="xahaud-builder:latest"
-  echo "Building custom Docker image with dependencies..."
-  echo "$DOCKERFILE_CONTENT" | docker build --build-arg BUILD_CORES="$BUILD_CORES" -t "$IMAGE_NAME" - || exit 1
-
   if [[ "$GITHUB_REPOSITORY" == "" ]]; then
     # Non GH, local building
     echo "Non-GH runner, local building, temp container"
-    docker run -i --user 0:$(id -g) --rm -v /data/builds:/data/builds -v `pwd`:/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
+    docker run -i --user 0:$(id -g) --rm -v /data/builds:/data/builds -v `pwd`:/io --network host ghcr.io/foobarwidget/holy-build-box-x64 /hbb_exe/activate-exec bash -x /io/build-full.sh "$GITHUB_REPOSITORY" "$GITHUB_SHA" "$BUILD_CORES" "$GITHUB_RUN_NUMBER"
   else
     # GH Action, runner
     echo "GH Action, runner, clean & re-create create persistent container"
     docker rm -f $CONTAINER_NAME
     echo "echo 'Stopping container: $CONTAINER_NAME'" >> "$JOB_CLEANUP_SCRIPT"
     echo "docker stop --time=15 \"$CONTAINER_NAME\" || echo 'Failed to stop container or container not running'" >> "$JOB_CLEANUP_SCRIPT"
-    docker run -di --user 0:$(id -g) --name $CONTAINER_NAME -v /data/builds:/data/builds -v `pwd`:/io -v "$CACHE_VOLUME_NAME":/cache --network host "$IMAGE_NAME" /hbb_exe/activate-exec bash
-    docker exec -i $CONTAINER_NAME /hbb_exe/activate-exec bash -c "source /opt/rh/gcc-toolset-11/enable && bash -x /io/build-full.sh '$GITHUB_REPOSITORY' '$GITHUB_SHA' '$BUILD_CORES' '$GITHUB_RUN_NUMBER'"
+    docker run -di --user 0:$(id -g) --name $CONTAINER_NAME -v /data/builds:/data/builds -v `pwd`:/io --network host ghcr.io/foobarwidget/holy-build-box-x64 /hbb_exe/activate-exec bash
+    docker exec -i $CONTAINER_NAME /hbb_exe/activate-exec bash -x /io/build-full.sh "$GITHUB_REPOSITORY" "$GITHUB_SHA" "$BUILD_CORES" "$GITHUB_RUN_NUMBER"
     docker stop $CONTAINER_NAME
   fi
 fi

src/ripple/app/hook/Enum.h

@@ -1,4 +1,3 @@
-#include <cstdint>
 #include <map>
 #include <set>
 #include <string>

src/ripple/app/hook/impl/applyHook.cpp

@@ -342,7 +342,8 @@ getTransactionalStakeHolders(STTx const& tx, ReadView const& rv)
         case ttOFFER_CANCEL:
         case ttTICKET_CREATE:
         case ttHOOK_SET:
-        case ttOFFER_CREATE: {
+        case ttOFFER_CREATE:  // this is handled seperately
+        {
             break;
         }
 
@@ -495,12 +496,6 @@ getTransactionalStakeHolders(STTx const& tx, ReadView const& rv)
             break;
         }
 
-        case ttCLAWBACK: {
-            auto const amount = tx.getFieldAmount(sfAmount);
-            ADD_TSH(amount.getIssuer(), tshWEAK);
-            break;
-        }
-
         default:
             return {};
     }

src/ripple/app/paths/TrustLine.h

@@ -139,13 +139,6 @@ public:
         return mFlags & (mViewLowest ? lsfLowFreeze : lsfHighFreeze);
     }
 
-    /** Have we set the deep freeze flag on our peer */
-    bool
-    getDeepFreeze() const
-    {
-        return mFlags & (mViewLowest ? lsfLowDeepFreeze : lsfHighDeepFreeze);
-    }
-
     /** Has the peer set the freeze flag on us */
     bool
     getFreezePeer() const
@@ -153,13 +146,6 @@ public:
         return mFlags & (!mViewLowest ? lsfLowFreeze : lsfHighFreeze);
     }
 
-    /** Has the peer set the deep freeze flag on us */
-    bool
-    getDeepFreezePeer() const
-    {
-        return mFlags & (!mViewLowest ? lsfLowDeepFreeze : lsfHighDeepFreeze);
-    }
-
     STAmount const&
     getBalance() const
     {

src/ripple/app/paths/impl/StepChecks.h

@@ -52,12 +52,6 @@ checkFreeze(
         {
             return terNO_LINE;
         }
-        // Unlike normal freeze, a deep frozen trust line acts the same
-        // regardless of which side froze it
-        if (sle->isFlag(lsfHighDeepFreeze) || sle->isFlag(lsfLowDeepFreeze))
-        {
-            return terNO_LINE;
-        }
     }
 
     return tesSUCCESS;

src/ripple/app/rdb/backend/FlatmapDatabase.h

@@ -0,0 +1,851 @@
+#ifndef RIPPLE_APP_RDB_BACKEND_FLATMAPDATABASE_H_INCLUDED
+#define RIPPLE_APP_RDB_BACKEND_FLATMAPDATABASE_H_INCLUDED
+
+#include <ripple/app/ledger/AcceptedLedger.h>
+#include <ripple/app/ledger/LedgerMaster.h>
+#include <ripple/app/ledger/TransactionMaster.h>
+#include <ripple/app/rdb/backend/SQLiteDatabase.h>
+#include <algorithm>
+#include <map>
+#include <mutex>
+#include <optional>
+#include <shared_mutex>
+#include <vector>
+
+#include <boost/unordered/concurrent_flat_map.hpp>
+
+namespace ripple {
+
+struct base_uint_hasher
+{
+    using result_type = std::size_t;
+
+    result_type
+    operator()(base_uint<256> const& value) const
+    {
+        return hardened_hash<>{}(value);
+    }
+
+    result_type
+    operator()(AccountID const& value) const
+    {
+        return hardened_hash<>{}(value);
+    }
+};
+
+class FlatmapDatabase : public SQLiteDatabase
+{
+private:
+    struct LedgerData
+    {
+        LedgerInfo info;
+        boost::unordered::
+            concurrent_flat_map<uint256, AccountTx, base_uint_hasher>
+                transactions;
+    };
+
+    struct AccountTxData
+    {
+        boost::unordered::
+            concurrent_flat_map<std::pair<uint32_t, uint32_t>, AccountTx>
+                transactions;
+    };
+
+    Application& app_;
+
+    boost::unordered::concurrent_flat_map<LedgerIndex, LedgerData> ledgers_;
+    boost::unordered::
+        concurrent_flat_map<uint256, LedgerIndex, base_uint_hasher>
+            ledgerHashToSeq_;
+    boost::unordered::concurrent_flat_map<uint256, AccountTx, base_uint_hasher>
+        transactionMap_;
+    boost::unordered::
+        concurrent_flat_map<AccountID, AccountTxData, base_uint_hasher>
+            accountTxMap_;
+
+public:
+    FlatmapDatabase(Application& app, Config const& config, JobQueue& jobQueue)
+        : app_(app)
+    {
+    }
+
+    std::optional<LedgerIndex>
+    getMinLedgerSeq() override
+    {
+        std::optional<LedgerIndex> minSeq;
+        ledgers_.visit_all([&minSeq](auto const& pair) {
+            if (!minSeq || pair.first < *minSeq)
+            {
+                minSeq = pair.first;
+            }
+        });
+        return minSeq;
+    }
+
+    std::optional<LedgerIndex>
+    getTransactionsMinLedgerSeq() override
+    {
+        std::optional<LedgerIndex> minSeq;
+        transactionMap_.visit_all([&minSeq](auto const& pair) {
+            LedgerIndex seq = pair.second.second->getLgrSeq();
+            if (!minSeq || seq < *minSeq)
+            {
+                minSeq = seq;
+            }
+        });
+        return minSeq;
+    }
+
+    std::optional<LedgerIndex>
+    getAccountTransactionsMinLedgerSeq() override
+    {
+        std::optional<LedgerIndex> minSeq;
+        accountTxMap_.visit_all([&minSeq](auto const& pair) {
+            pair.second.transactions.visit_all([&minSeq](auto const& tx) {
+                if (!minSeq || tx.first.first < *minSeq)
+                {
+                    minSeq = tx.first.first;
+                }
+            });
+        });
+        return minSeq;
+    }
+
+    std::optional<LedgerIndex>
+    getMaxLedgerSeq() override
+    {
+        std::optional<LedgerIndex> maxSeq;
+        ledgers_.visit_all([&maxSeq](auto const& pair) {
+            if (!maxSeq || pair.first > *maxSeq)
+            {
+                maxSeq = pair.first;
+            }
+        });
+        return maxSeq;
+    }
+    void
+    deleteTransactionByLedgerSeq(LedgerIndex ledgerSeq) override
+    {
+        ledgers_.visit(ledgerSeq, [this](auto& item) {
+            item.second.transactions.visit_all([this](auto const& txPair) {
+                transactionMap_.erase(txPair.first);
+            });
+            item.second.transactions.clear();
+        });
+
+        accountTxMap_.visit_all([ledgerSeq](auto& item) {
+            item.second.transactions.erase_if([ledgerSeq](auto const& tx) {
+                return tx.first.first == ledgerSeq;
+            });
+        });
+    }
+
+    void
+    deleteBeforeLedgerSeq(LedgerIndex ledgerSeq) override
+    {
+        ledgers_.erase_if([this, ledgerSeq](auto const& item) {
+            if (item.first < ledgerSeq)
+            {
+                item.second.transactions.visit_all([this](auto const& txPair) {
+                    transactionMap_.erase(txPair.first);
+                });
+                ledgerHashToSeq_.erase(item.second.info.hash);
+                return true;
+            }
+            return false;
+        });
+
+        accountTxMap_.visit_all([ledgerSeq](auto& item) {
+            item.second.transactions.erase_if([ledgerSeq](auto const& tx) {
+                return tx.first.first < ledgerSeq;
+            });
+        });
+    }
+
+    void
+    deleteTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) override
+    {
+        ledgers_.visit_all([this, ledgerSeq](auto& item) {
+            if (item.first < ledgerSeq)
+            {
+                item.second.transactions.visit_all([this](auto const& txPair) {
+                    transactionMap_.erase(txPair.first);
+                });
+                item.second.transactions.clear();
+            }
+        });
+
+        accountTxMap_.visit_all([ledgerSeq](auto& item) {
+            item.second.transactions.erase_if([ledgerSeq](auto const& tx) {
+                return tx.first.first < ledgerSeq;
+            });
+        });
+    }
+
+    void
+    deleteAccountTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) override
+    {
+        accountTxMap_.visit_all([ledgerSeq](auto& item) {
+            item.second.transactions.erase_if([ledgerSeq](auto const& tx) {
+                return tx.first.first < ledgerSeq;
+            });
+        });
+    }
+    std::size_t
+    getTransactionCount() override
+    {
+        return transactionMap_.size();
+    }
+
+    std::size_t
+    getAccountTransactionCount() override
+    {
+        std::size_t count = 0;
+        accountTxMap_.visit_all([&count](auto const& item) {
+            count += item.second.transactions.size();
+        });
+        return count;
+    }
+
+    CountMinMax
+    getLedgerCountMinMax() override
+    {
+        CountMinMax result{0, 0, 0};
+        ledgers_.visit_all([&result](auto const& item) {
+            result.numberOfRows++;
+            if (result.minLedgerSequence == 0 ||
+                item.first < result.minLedgerSequence)
+            {
+                result.minLedgerSequence = item.first;
+            }
+            if (item.first > result.maxLedgerSequence)
+            {
+                result.maxLedgerSequence = item.first;
+            }
+        });
+        return result;
+    }
+
+    bool
+    saveValidatedLedger(
+        std::shared_ptr<Ledger const> const& ledger,
+        bool current) override
+    {
+        try
+        {
+            LedgerData ledgerData;
+            ledgerData.info = ledger->info();
+
+            auto aLedger = std::make_shared<AcceptedLedger>(ledger, app_);
+            for (auto const& acceptedLedgerTx : *aLedger)
+            {
+                auto const& txn = acceptedLedgerTx->getTxn();
+                auto const& meta = acceptedLedgerTx->getMeta();
+                auto const& id = txn->getTransactionID();
+
+                std::string reason;
+                auto accTx = std::make_pair(
+                    std::make_shared<ripple::Transaction>(txn, reason, app_),
+                    std::make_shared<ripple::TxMeta>(meta));
+
+                ledgerData.transactions.emplace(id, accTx);
+                transactionMap_.emplace(id, accTx);
+
+                for (auto const& account : meta.getAffectedAccounts())
+                {
+                    accountTxMap_.visit(account, [&](auto& data) {
+                        data.second.transactions.emplace(
+                            std::make_pair(
+                                ledger->info().seq,
+                                acceptedLedgerTx->getTxnSeq()),
+                            accTx);
+                    });
+                }
+            }
+
+            ledgers_.emplace(ledger->info().seq, std::move(ledgerData));
+            ledgerHashToSeq_.emplace(ledger->info().hash, ledger->info().seq);
+
+            if (current)
+            {
+                auto const cutoffSeq =
+                    ledger->info().seq > app_.config().LEDGER_HISTORY
+                    ? ledger->info().seq - app_.config().LEDGER_HISTORY
+                    : 0;
+
+                if (cutoffSeq > 0)
+                {
+                    const std::size_t BATCH_SIZE = 128;
+                    std::size_t deleted = 0;
+
+                    ledgers_.erase_if([&](auto const& item) {
+                        if (deleted >= BATCH_SIZE)
+                            return false;
+
+                        if (item.first < cutoffSeq)
+                        {
+                            item.second.transactions.visit_all(
+                                [this](auto const& txPair) {
+                                    transactionMap_.erase(txPair.first);
+                                });
+                            ledgerHashToSeq_.erase(item.second.info.hash);
+                            deleted++;
+                            return true;
+                        }
+                        return false;
+                    });
+
+                    if (deleted > 0)
+                    {
+                        accountTxMap_.visit_all([cutoffSeq](auto& item) {
+                            item.second.transactions.erase_if(
+                                [cutoffSeq](auto const& tx) {
+                                    return tx.first.first < cutoffSeq;
+                                });
+                        });
+                    }
+
+                    app_.getLedgerMaster().clearPriorLedgers(cutoffSeq);
+                }
+            }
+
+            return true;
+        }
+        catch (std::exception const&)
+        {
+            deleteTransactionByLedgerSeq(ledger->info().seq);
+            return false;
+        }
+    }
+
+    std::optional<LedgerInfo>
+    getLedgerInfoByIndex(LedgerIndex ledgerSeq) override
+    {
+        std::optional<LedgerInfo> result;
+        ledgers_.visit(ledgerSeq, [&result](auto const& item) {
+            result = item.second.info;
+        });
+        return result;
+    }
+
+    std::optional<LedgerInfo>
+    getNewestLedgerInfo() override
+    {
+        std::optional<LedgerInfo> result;
+        ledgers_.visit_all([&result](auto const& item) {
+            if (!result || item.second.info.seq > result->seq)
+            {
+                result = item.second.info;
+            }
+        });
+        return result;
+    }
+
+    std::optional<LedgerInfo>
+    getLimitedOldestLedgerInfo(LedgerIndex ledgerFirstIndex) override
+    {
+        std::optional<LedgerInfo> result;
+        ledgers_.visit_all([&](auto const& item) {
+            if (item.first >= ledgerFirstIndex &&
+                (!result || item.first < result->seq))
+            {
+                result = item.second.info;
+            }
+        });
+        return result;
+    }
+
+    std::optional<LedgerInfo>
+    getLimitedNewestLedgerInfo(LedgerIndex ledgerFirstIndex) override
+    {
+        std::optional<LedgerInfo> result;
+        ledgers_.visit_all([&](auto const& item) {
+            if (item.first >= ledgerFirstIndex &&
+                (!result || item.first > result->seq))
+            {
+                result = item.second.info;
+            }
+        });
+        return result;
+    }
+
+    std::optional<LedgerInfo>
+    getLedgerInfoByHash(uint256 const& ledgerHash) override
+    {
+        std::optional<LedgerInfo> result;
+        ledgerHashToSeq_.visit(ledgerHash, [this, &result](auto const& item) {
+            ledgers_.visit(item.second, [&result](auto const& item) {
+                result = item.second.info;
+            });
+        });
+        return result;
+    }
+    uint256
+    getHashByIndex(LedgerIndex ledgerIndex) override
+    {
+        uint256 result;
+        ledgers_.visit(ledgerIndex, [&result](auto const& item) {
+            result = item.second.info.hash;
+        });
+        return result;
+    }
+
+    std::optional<LedgerHashPair>
+    getHashesByIndex(LedgerIndex ledgerIndex) override
+    {
+        std::optional<LedgerHashPair> result;
+        ledgers_.visit(ledgerIndex, [&result](auto const& item) {
+            result = LedgerHashPair{
+                item.second.info.hash, item.second.info.parentHash};
+        });
+        return result;
+    }
+
+    std::map<LedgerIndex, LedgerHashPair>
+    getHashesByIndex(LedgerIndex minSeq, LedgerIndex maxSeq) override
+    {
+        std::map<LedgerIndex, LedgerHashPair> result;
+        ledgers_.visit_all([&](auto const& item) {
+            if (item.first >= minSeq && item.first <= maxSeq)
+            {
+                result[item.first] = LedgerHashPair{
+                    item.second.info.hash, item.second.info.parentHash};
+            }
+        });
+        return result;
+    }
+
+    std::variant<AccountTx, TxSearched>
+    getTransaction(
+        uint256 const& id,
+        std::optional<ClosedInterval<std::uint32_t>> const& range,
+        error_code_i& ec) override
+    {
+        std::variant<AccountTx, TxSearched> result = TxSearched::unknown;
+        transactionMap_.visit(id, [&](auto const& item) {
+            auto const& tx = item.second;
+            if (!range ||
+                (range->lower() <= tx.second->getLgrSeq() &&
+                 tx.second->getLgrSeq() <= range->upper()))
+            {
+                result = tx;
+            }
+            else
+            {
+                result = TxSearched::all;
+            }
+        });
+        return result;
+    }
+
+    bool
+    ledgerDbHasSpace(Config const& config) override
+    {
+        return true;  // In-memory database always has space
+    }
+
+    bool
+    transactionDbHasSpace(Config const& config) override
+    {
+        return true;  // In-memory database always has space
+    }
+
+    std::uint32_t
+    getKBUsedAll() override
+    {
+        std::uint32_t size = sizeof(*this);
+        size += ledgers_.size() * (sizeof(LedgerIndex) + sizeof(LedgerData));
+        size +=
+            ledgerHashToSeq_.size() * (sizeof(uint256) + sizeof(LedgerIndex));
+        size += transactionMap_.size() * (sizeof(uint256) + sizeof(AccountTx));
+        accountTxMap_.visit_all([&size](auto const& item) {
+            size += sizeof(AccountID) + sizeof(AccountTxData);
+            size += item.second.transactions.size() * sizeof(AccountTx);
+        });
+        return size / 1024;  // Convert to KB
+    }
+
+    std::uint32_t
+    getKBUsedLedger() override
+    {
+        std::uint32_t size =
+            ledgers_.size() * (sizeof(LedgerIndex) + sizeof(LedgerData));
+        size +=
+            ledgerHashToSeq_.size() * (sizeof(uint256) + sizeof(LedgerIndex));
+        return size / 1024;
+    }
+
+    std::uint32_t
+    getKBUsedTransaction() override
+    {
+        std::uint32_t size =
+            transactionMap_.size() * (sizeof(uint256) + sizeof(AccountTx));
+        accountTxMap_.visit_all([&size](auto const& item) {
+            size += sizeof(AccountID) + sizeof(AccountTxData);
+            size += item.second.transactions.size() * sizeof(AccountTx);
+        });
+        return size / 1024;
+    }
+
+    void
+    closeLedgerDB() override
+    {
+        // No-op for in-memory database
+    }
+
+    void
+    closeTransactionDB() override
+    {
+        // No-op for in-memory database
+    }
+
+    ~FlatmapDatabase()
+    {
+        // Concurrent maps need visit_all
+        accountTxMap_.visit_all(
+            [](auto& pair) { pair.second.transactions.clear(); });
+        accountTxMap_.clear();
+
+        transactionMap_.clear();
+
+        ledgers_.visit_all(
+            [](auto& pair) { pair.second.transactions.clear(); });
+        ledgers_.clear();
+
+        ledgerHashToSeq_.clear();
+    }
+
+    std::vector<std::shared_ptr<Transaction>>
+    getTxHistory(LedgerIndex startIndex) override
+    {
+        std::vector<std::shared_ptr<Transaction>> result;
+        transactionMap_.visit_all([&](auto const& item) {
+            if (item.second.second->getLgrSeq() >= startIndex)
+            {
+                result.push_back(item.second.first);
+            }
+        });
+        std::sort(
+            result.begin(), result.end(), [](auto const& a, auto const& b) {
+                return a->getLedger() > b->getLedger();
+            });
+        if (result.size() > 20)
+        {
+            result.resize(20);
+        }
+        return result;
+    }
+    // Helper function to handle limits
+    template <typename Container>
+    void
+    applyLimit(Container& container, std::size_t limit, bool bUnlimited)
+    {
+        if (!bUnlimited && limit > 0 && container.size() > limit)
+        {
+            container.resize(limit);
+        }
+    }
+
+    AccountTxs
+    getOldestAccountTxs(AccountTxOptions const& options) override
+    {
+        AccountTxs result;
+        accountTxMap_.visit(options.account, [&](auto const& item) {
+            item.second.transactions.visit_all([&](auto const& tx) {
+                if (tx.first.first >= options.minLedger &&
+                    tx.first.first <= options.maxLedger)
+                {
+                    result.push_back(tx.second);
+                }
+            });
+        });
+        std::sort(
+            result.begin(), result.end(), [](auto const& a, auto const& b) {
+                return a.second->getLgrSeq() < b.second->getLgrSeq();
+            });
+        applyLimit(result, options.limit, options.bUnlimited);
+        return result;
+    }
+
+    AccountTxs
+    getNewestAccountTxs(AccountTxOptions const& options) override
+    {
+        AccountTxs result;
+        accountTxMap_.visit(options.account, [&](auto const& item) {
+            item.second.transactions.visit_all([&](auto const& tx) {
+                if (tx.first.first >= options.minLedger &&
+                    tx.first.first <= options.maxLedger)
+                {
+                    result.push_back(tx.second);
+                }
+            });
+        });
+        std::sort(
+            result.begin(), result.end(), [](auto const& a, auto const& b) {
+                return a.second->getLgrSeq() > b.second->getLgrSeq();
+            });
+        applyLimit(result, options.limit, options.bUnlimited);
+        return result;
+    }
+
+    MetaTxsList
+    getOldestAccountTxsB(AccountTxOptions const& options) override
+    {
+        MetaTxsList result;
+        accountTxMap_.visit(options.account, [&](auto const& item) {
+            item.second.transactions.visit_all([&](auto const& tx) {
+                if (tx.first.first >= options.minLedger &&
+                    tx.first.first <= options.maxLedger)
+                {
+                    result.emplace_back(
+                        tx.second.first->getSTransaction()
+                            ->getSerializer()
+                            .peekData(),
+                        tx.second.second->getAsObject()
+                            .getSerializer()
+                            .peekData(),
+                        tx.first.first);
+                }
+            });
+        });
+        std::sort(
+            result.begin(), result.end(), [](auto const& a, auto const& b) {
+                return std::get<2>(a) < std::get<2>(b);
+            });
+        applyLimit(result, options.limit, options.bUnlimited);
+        return result;
+    }
+
+    MetaTxsList
+    getNewestAccountTxsB(AccountTxOptions const& options) override
+    {
+        MetaTxsList result;
+        accountTxMap_.visit(options.account, [&](auto const& item) {
+            item.second.transactions.visit_all([&](auto const& tx) {
+                if (tx.first.first >= options.minLedger &&
+                    tx.first.first <= options.maxLedger)
+                {
+                    result.emplace_back(
+                        tx.second.first->getSTransaction()
+                            ->getSerializer()
+                            .peekData(),
+                        tx.second.second->getAsObject()
+                            .getSerializer()
+                            .peekData(),
+                        tx.first.first);
+                }
+            });
+        });
+        std::sort(
+            result.begin(), result.end(), [](auto const& a, auto const& b) {
+                return std::get<2>(a) > std::get<2>(b);
+            });
+        applyLimit(result, options.limit, options.bUnlimited);
+        return result;
+    }
+    std::pair<AccountTxs, std::optional<AccountTxMarker>>
+    oldestAccountTxPage(AccountTxPageOptions const& options) override
+    {
+        AccountTxs result;
+        std::optional<AccountTxMarker> marker;
+
+        accountTxMap_.visit(options.account, [&](auto const& item) {
+            std::vector<std::pair<std::pair<uint32_t, uint32_t>, AccountTx>>
+                txs;
+            item.second.transactions.visit_all([&](auto const& tx) {
+                if (tx.first.first >= options.minLedger &&
+                    tx.first.first <= options.maxLedger)
+                {
+                    txs.emplace_back(tx);
+                }
+            });
+
+            std::sort(txs.begin(), txs.end(), [](auto const& a, auto const& b) {
+                return a.first < b.first;
+            });
+
+            auto it = txs.begin();
+            if (options.marker)
+            {
+                it = std::find_if(txs.begin(), txs.end(), [&](auto const& tx) {
+                    return tx.first.first == options.marker->ledgerSeq &&
+                        tx.first.second == options.marker->txnSeq;
+                });
+                if (it != txs.end())
+                    ++it;
+            }
+
+            for (; it != txs.end() &&
+                 (options.limit == 0 || result.size() < options.limit);
+                 ++it)
+            {
+                result.push_back(it->second);
+            }
+
+            if (it != txs.end())
+            {
+                marker = AccountTxMarker{it->first.first, it->first.second};
+            }
+        });
+
+        return {result, marker};
+    }
+
+    std::pair<AccountTxs, std::optional<AccountTxMarker>>
+    newestAccountTxPage(AccountTxPageOptions const& options) override
+    {
+        AccountTxs result;
+        std::optional<AccountTxMarker> marker;
+
+        accountTxMap_.visit(options.account, [&](auto const& item) {
+            std::vector<std::pair<std::pair<uint32_t, uint32_t>, AccountTx>>
+                txs;
+            item.second.transactions.visit_all([&](auto const& tx) {
+                if (tx.first.first >= options.minLedger &&
+                    tx.first.first <= options.maxLedger)
+                {
+                    txs.emplace_back(tx);
+                }
+            });
+
+            std::sort(txs.begin(), txs.end(), [](auto const& a, auto const& b) {
+                return a.first > b.first;
+            });
+
+            auto it = txs.begin();
+            if (options.marker)
+            {
+                it = std::find_if(txs.begin(), txs.end(), [&](auto const& tx) {
+                    return tx.first.first == options.marker->ledgerSeq &&
+                        tx.first.second == options.marker->txnSeq;
+                });
+                if (it != txs.end())
+                    ++it;
+            }
+
+            for (; it != txs.end() &&
+                 (options.limit == 0 || result.size() < options.limit);
+                 ++it)
+            {
+                result.push_back(it->second);
+            }
+
+            if (it != txs.end())
+            {
+                marker = AccountTxMarker{it->first.first, it->first.second};
+            }
+        });
+
+        return {result, marker};
+    }
+
+    std::pair<MetaTxsList, std::optional<AccountTxMarker>>
+    oldestAccountTxPageB(AccountTxPageOptions const& options) override
+    {
+        MetaTxsList result;
+        std::optional<AccountTxMarker> marker;
+
+        accountTxMap_.visit(options.account, [&](auto const& item) {
+            std::vector<std::tuple<uint32_t, uint32_t, AccountTx>> txs;
+            item.second.transactions.visit_all([&](auto const& tx) {
+                if (tx.first.first >= options.minLedger &&
+                    tx.first.first <= options.maxLedger)
+                {
+                    txs.emplace_back(
+                        tx.first.first, tx.first.second, tx.second);
+                }
+            });
+
+            std::sort(txs.begin(), txs.end());
+
+            auto it = txs.begin();
+            if (options.marker)
+            {
+                it = std::find_if(txs.begin(), txs.end(), [&](auto const& tx) {
+                    return std::get<0>(tx) == options.marker->ledgerSeq &&
+                        std::get<1>(tx) == options.marker->txnSeq;
+                });
+                if (it != txs.end())
+                    ++it;
+            }
+
+            for (; it != txs.end() &&
+                 (options.limit == 0 || result.size() < options.limit);
+                 ++it)
+            {
+                const auto& [_, __, tx] = *it;
+                result.emplace_back(
+                    tx.first->getSTransaction()->getSerializer().peekData(),
+                    tx.second->getAsObject().getSerializer().peekData(),
+                    std::get<0>(*it));
+            }
+
+            if (it != txs.end())
+            {
+                marker = AccountTxMarker{std::get<0>(*it), std::get<1>(*it)};
+            }
+        });
+
+        return {result, marker};
+    }
+
+    std::pair<MetaTxsList, std::optional<AccountTxMarker>>
+    newestAccountTxPageB(AccountTxPageOptions const& options) override
+    {
+        MetaTxsList result;
+        std::optional<AccountTxMarker> marker;
+
+        accountTxMap_.visit(options.account, [&](auto const& item) {
+            std::vector<std::tuple<uint32_t, uint32_t, AccountTx>> txs;
+            item.second.transactions.visit_all([&](auto const& tx) {
+                if (tx.first.first >= options.minLedger &&
+                    tx.first.first <= options.maxLedger)
+                {
+                    txs.emplace_back(
+                        tx.first.first, tx.first.second, tx.second);
+                }
+            });
+
+            std::sort(txs.begin(), txs.end(), std::greater<>());
+
+            auto it = txs.begin();
+            if (options.marker)
+            {
+                it = std::find_if(txs.begin(), txs.end(), [&](auto const& tx) {
+                    return std::get<0>(tx) == options.marker->ledgerSeq &&
+                        std::get<1>(tx) == options.marker->txnSeq;
+                });
+                if (it != txs.end())
+                    ++it;
+            }
+
+            for (; it != txs.end() &&
+                 (options.limit == 0 || result.size() < options.limit);
+                 ++it)
+            {
+                const auto& [_, __, tx] = *it;
+                result.emplace_back(
+                    tx.first->getSTransaction()->getSerializer().peekData(),
+                    tx.second->getAsObject().getSerializer().peekData(),
+                    std::get<0>(*it));
+            }
+
+            if (it != txs.end())
+            {
+                marker = AccountTxMarker{std::get<0>(*it), std::get<1>(*it)};
+            }
+        });
+
+        return {result, marker};
+    }
+};
+
+// Factory function
+std::unique_ptr<SQLiteDatabase>
+getFlatmapDatabase(Application& app, Config const& config, JobQueue& jobQueue)
+{
+    return std::make_unique<FlatmapDatabase>(app, config, jobQueue);
+}
+
+}  // namespace ripple
+#endif  // RIPPLE_APP_RDB_BACKEND_FLATMAPDATABASE_H_INCLUDED

src/ripple/app/rdb/backend/RWDBDatabase.h

@@ -28,8 +28,9 @@ private:
 
     struct AccountTxData
     {
-        std::map<uint32_t, std::vector<AccountTx>>
-            ledgerTxMap;  // ledgerSeq -> vector of transactions
+        AccountTxs transactions;
+        std::map<uint32_t, std::map<uint32_t, size_t>>
+            ledgerTxMap;  // ledgerSeq -> txSeq -> index in transactions
     };
 
     Application& app_;
@@ -64,12 +65,9 @@ public:
             return {};
 
         std::shared_lock<std::shared_mutex> lock(mutex_);
-        for (const auto& [ledgerSeq, ledgerData] : ledgers_)
-        {
-            if (!ledgerData.transactions.empty())
-                return ledgerSeq;
-        }
-        return std::nullopt;
+        if (transactionMap_.empty())
+            return std::nullopt;
+        return transactionMap_.begin()->second.second->getLgrSeq();
     }
 
     std::optional<LedgerIndex>
@@ -165,6 +163,14 @@ public:
             {
                 txIt = accountData.ledgerTxMap.erase(txIt);
             }
+            accountData.transactions.erase(
+                std::remove_if(
+                    accountData.transactions.begin(),
+                    accountData.transactions.end(),
+                    [ledgerSeq](const AccountTx& tx) {
+                        return tx.second->getLgrSeq() < ledgerSeq;
+                    }),
+                accountData.transactions.end());
         }
     }
     std::size_t
@@ -187,10 +193,7 @@ public:
         std::size_t count = 0;
         for (const auto& [_, accountData] : accountTxMap_)
         {
-            for (const auto& [_, txVector] : accountData.ledgerTxMap)
-            {
-                count += txVector.size();
-            }
+            count += accountData.transactions.size();
         }
         return count;
     }
@@ -290,7 +293,10 @@ public:
                         accountTxMap_[account] = AccountTxData();
 
                     auto& accountData = accountTxMap_[account];
-                    accountData.ledgerTxMap[seq].push_back(accTx);
+                    accountData.transactions.push_back(accTx);
+                    accountData
+                        .ledgerTxMap[seq][acceptedLedgerTx->getTxnSeq()] =
+                        accountData.transactions.size() - 1;
                 }
 
                 app_.getMasterTransaction().inLedger(
@@ -445,108 +451,59 @@ public:
         return true;  // In-memory database always has space
     }
 
-    // Red-black tree node overhead per map entry
-    static constexpr size_t MAP_NODE_OVERHEAD = 40;
-
-private:
-    std::uint64_t
-    getBytesUsedLedger_unlocked() const
-    {
-        std::uint64_t size = 0;
-
-        // Count structural overhead of ledger storage including map node
-        // overhead Note: sizeof(LedgerData) includes the map container for
-        // transactions, but not the actual transaction data
-        size += ledgers_.size() *
-            (sizeof(LedgerIndex) + sizeof(LedgerData) + MAP_NODE_OVERHEAD);
-
-        // Add the transaction map nodes inside each ledger (ledger's view of
-        // its transactions)
-        for (const auto& [_, ledgerData] : ledgers_)
-        {
-            size += ledgerData.transactions.size() *
-                (sizeof(uint256) + sizeof(AccountTx) + MAP_NODE_OVERHEAD);
-        }
-
-        // Count the ledger hash to sequence lookup map
-        size += ledgerHashToSeq_.size() *
-            (sizeof(uint256) + sizeof(LedgerIndex) + MAP_NODE_OVERHEAD);
-
-        return size;
-    }
-
-    std::uint64_t
-    getBytesUsedTransaction_unlocked() const
-    {
-        if (!useTxTables_)
-            return 0;
-
-        std::uint64_t size = 0;
-
-        // Count structural overhead of transaction map
-        // sizeof(AccountTx) is just the size of two shared_ptrs (~32 bytes)
-        size += transactionMap_.size() *
-            (sizeof(uint256) + sizeof(AccountTx) + MAP_NODE_OVERHEAD);
-
-        // Add actual transaction and metadata data sizes
-        for (const auto& [_, accountTx] : transactionMap_)
-        {
-            if (accountTx.first)
-                size += accountTx.first->getSTransaction()
-                            ->getSerializer()
-                            .peekData()
-                            .size();
-            if (accountTx.second)
-                size += accountTx.second->getAsObject()
-                            .getSerializer()
-                            .peekData()
-                            .size();
-        }
-
-        // Count structural overhead of account transaction index
-        // The actual transaction data is already counted above from
-        // transactionMap_
-        for (const auto& [accountId, accountData] : accountTxMap_)
-        {
-            size +=
-                sizeof(accountId) + sizeof(AccountTxData) + MAP_NODE_OVERHEAD;
-            for (const auto& [ledgerSeq, txVector] : accountData.ledgerTxMap)
-            {
-                // Use capacity() to account for actual allocated memory
-                size += sizeof(ledgerSeq) + MAP_NODE_OVERHEAD;
-                size += txVector.capacity() * sizeof(AccountTx);
-            }
-        }
-
-        return size;
-    }
-
-public:
     std::uint32_t
     getKBUsedAll() override
     {
         std::shared_lock<std::shared_mutex> lock(mutex_);
-
-        // Total = base object + ledger infrastructure + transaction data
-        std::uint64_t size = sizeof(*this) + getBytesUsedLedger_unlocked() +
-            getBytesUsedTransaction_unlocked();
-
-        return static_cast<std::uint32_t>(size / 1024);
+        std::uint32_t size = sizeof(*this);
+        size += ledgers_.size() * (sizeof(LedgerIndex) + sizeof(LedgerData));
+        size +=
+            ledgerHashToSeq_.size() * (sizeof(uint256) + sizeof(LedgerIndex));
+        size += transactionMap_.size() * (sizeof(uint256) + sizeof(AccountTx));
+        for (const auto& [_, accountData] : accountTxMap_)
+        {
+            size += sizeof(AccountID) + sizeof(AccountTxData);
+            size += accountData.transactions.size() * sizeof(AccountTx);
+            for (const auto& [_, innerMap] : accountData.ledgerTxMap)
+            {
+                size += sizeof(uint32_t) +
+                    innerMap.size() * (sizeof(uint32_t) + sizeof(size_t));
+            }
+        }
+        return size / 1024;
     }
 
     std::uint32_t
     getKBUsedLedger() override
     {
         std::shared_lock<std::shared_mutex> lock(mutex_);
-        return static_cast<std::uint32_t>(getBytesUsedLedger_unlocked() / 1024);
+        std::uint32_t size = 0;
+        size += ledgers_.size() * (sizeof(LedgerIndex) + sizeof(LedgerData));
+        size +=
+            ledgerHashToSeq_.size() * (sizeof(uint256) + sizeof(LedgerIndex));
+        return size / 1024;
     }
 
     std::uint32_t
     getKBUsedTransaction() override
     {
+        if (!useTxTables_)
+            return 0;
+
         std::shared_lock<std::shared_mutex> lock(mutex_);
-        return static_cast<std::uint32_t>(
-            getBytesUsedTransaction_unlocked() / 1024);
+        std::uint32_t size = 0;
+        size += transactionMap_.size() * (sizeof(uint256) + sizeof(AccountTx));
+        for (const auto& [_, accountData] : accountTxMap_)
+        {
+            size += sizeof(AccountID) + sizeof(AccountTxData);
+            size += accountData.transactions.size() * sizeof(AccountTx);
+            for (const auto& [_, innerMap] : accountData.ledgerTxMap)
+            {
+                size += sizeof(uint32_t) +
+                    innerMap.size() * (sizeof(uint32_t) + sizeof(size_t));
+            }
+        }
+        return size / 1024;
     }
 
     void
@@ -648,13 +605,14 @@ public:
              (options.bUnlimited || result.size() < options.limit);
              ++txIt)
         {
-            for (const auto& accountTx : txIt->second)
+            for (const auto& [txSeq, txIndex] : txIt->second)
             {
                 if (skipped < options.offset)
                 {
                     ++skipped;
                     continue;
                 }
+                AccountTx const accountTx = accountData.transactions[txIndex];
                 std::uint32_t const inLedger = rangeCheckedCast<std::uint32_t>(
                     accountTx.second->getLgrSeq());
                 accountTx.first->setStatus(COMMITTED);
@@ -699,7 +657,8 @@ public:
                     ++skipped;
                     continue;
                 }
-                AccountTx const accountTx = *innerRIt;
+                AccountTx const accountTx =
+                    accountData.transactions[innerRIt->second];
                 std::uint32_t const inLedger = rangeCheckedCast<std::uint32_t>(
                     accountTx.second->getLgrSeq());
                 accountTx.first->setLedger(inLedger);
@@ -733,14 +692,14 @@ public:
              (options.bUnlimited || result.size() < options.limit);
              ++txIt)
         {
-            for (const auto& accountTx : txIt->second)
+            for (const auto& [txSeq, txIndex] : txIt->second)
             {
                 if (skipped < options.offset)
                 {
                     ++skipped;
                     continue;
                 }
-                const auto& [txn, txMeta] = accountTx;
+                const auto& [txn, txMeta] = accountData.transactions[txIndex];
                 result.emplace_back(
                     txn->getSTransaction()->getSerializer().peekData(),
                     txMeta->getAsObject().getSerializer().peekData(),
@@ -784,7 +743,8 @@ public:
                     ++skipped;
                     continue;
                 }
-                const auto& [txn, txMeta] = *innerRIt;
+                const auto& [txn, txMeta] =
+                    accountData.transactions[innerRIt->second];
                 result.emplace_back(
                     txn->getSTransaction()->getSerializer().peekData(),
                     txMeta->getAsObject().getSerializer().peekData(),
@@ -856,9 +816,11 @@ public:
             for (; txIt != txEnd; ++txIt)
             {
                 std::uint32_t const ledgerSeq = txIt->first;
-                std::uint32_t txnSeq = 0;
-                for (const auto& accountTx : txIt->second)
+                for (auto seqIt = txIt->second.begin();
+                     seqIt != txIt->second.end();
+                     ++seqIt)
                 {
+                    const auto& [txnSeq, index] = *seqIt;
                     if (lookingForMarker)
                     {
                         if (findLedger == ledgerSeq && findSeq == txnSeq)
@@ -866,10 +828,7 @@ public:
                             lookingForMarker = false;
                         }
                         else
-                        {
-                            ++txnSeq;
                             continue;
-                        }
                     }
                     else if (numberOfResults == 0)
                     {
@@ -878,10 +837,12 @@ public:
                         return {newmarker, total};
                     }
 
-                    Blob rawTxn = accountTx.first->getSTransaction()
+                    Blob rawTxn = accountData.transactions[index]
+                                      .first->getSTransaction()
                                       ->getSerializer()
                                       .peekData();
-                    Blob rawMeta = accountTx.second->getAsObject()
+                    Blob rawMeta = accountData.transactions[index]
+                                       .second->getAsObject()
                                        .getSerializer()
                                        .peekData();
 
@@ -895,7 +856,6 @@ public:
                         std::move(rawMeta));
                     --numberOfResults;
                     ++total;
-                    ++txnSeq;
                 }
             }
         }
@@ -911,11 +871,11 @@ public:
             for (; rtxIt != rtxEnd; ++rtxIt)
             {
                 std::uint32_t const ledgerSeq = rtxIt->first;
-                std::uint32_t txnSeq = rtxIt->second.size() - 1;
                 for (auto innerRIt = rtxIt->second.rbegin();
                      innerRIt != rtxIt->second.rend();
                      ++innerRIt)
                 {
+                    const auto& [txnSeq, index] = *innerRIt;
                     if (lookingForMarker)
                     {
                         if (findLedger == ledgerSeq && findSeq == txnSeq)
@@ -923,10 +883,7 @@ public:
                             lookingForMarker = false;
                         }
                         else
-                        {
-                            --txnSeq;
                             continue;
-                        }
                     }
                     else if (numberOfResults == 0)
                     {
@@ -935,11 +892,12 @@ public:
                         return {newmarker, total};
                     }
 
-                    const auto& accountTx = *innerRIt;
-                    Blob rawTxn = accountTx.first->getSTransaction()
+                    Blob rawTxn = accountData.transactions[index]
+                                      .first->getSTransaction()
                                       ->getSerializer()
                                       .peekData();
-                    Blob rawMeta = accountTx.second->getAsObject()
+                    Blob rawMeta = accountData.transactions[index]
+                                       .second->getAsObject()
                                        .getSerializer()
                                        .peekData();
 
@@ -953,7 +911,6 @@ public:
                         std::move(rawMeta));
                     --numberOfResults;
                     ++total;
-                    --txnSeq;
                 }
             }
         }

src/ripple/app/rdb/impl/RelationalDatabase.cpp

@@ -19,6 +19,7 @@
 
 #include <ripple/app/main/Application.h>
 #include <ripple/app/rdb/RelationalDatabase.h>
+#include <ripple/app/rdb/backend/FlatmapDatabase.h>
 #include <ripple/app/rdb/backend/RWDBDatabase.h>
 #include <ripple/core/ConfigSections.h>
 #include <ripple/nodestore/DatabaseShard.h>
@@ -40,6 +41,7 @@ RelationalDatabase::init(
     bool use_sqlite = false;
     bool use_postgres = false;
     bool use_rwdb = false;
+    bool use_flatmap = false;
 
     if (config.reporting())
     {
@@ -58,6 +60,10 @@ RelationalDatabase::init(
             {
                 use_rwdb = true;
             }
+            else if (boost::iequals(get(rdb_section, "backend"), "flatmap"))
+            {
+                use_flatmap = true;
+            }
             else
             {
                 Throw<std::runtime_error>(
@@ -83,6 +89,10 @@ RelationalDatabase::init(
     {
         return getRWDBDatabase(app, config, jobQueue);
     }
+    else if (use_flatmap)
+    {
+        return getFlatmapDatabase(app, config, jobQueue);
+    }
 
     return std::unique_ptr<RelationalDatabase>();
 }

src/ripple/app/tx/impl/CashCheck.cpp

@@ -392,7 +392,6 @@ CashCheck::doApply()
                         false,                          // authorize account
                         (sleDst->getFlags() & lsfDefaultRipple) == 0,
                         false,                          // freeze trust line
-                        false,                          // deep freeze trust line
                         initialBalance,                 // zero initial balance
                         Issue(currency, account_),      // limit of zero
                         0,                              // quality in

src/ripple/app/tx/impl/Clawback.cpp

@@ -1,140 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-  This file is part of rippled: https://github.com/ripple/rippled
-  Copyright (c) 2023 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.
-*/
-//==============================================================================
-
-#include <ripple/app/tx/impl/Clawback.h>
-#include <ripple/ledger/View.h>
-#include <ripple/protocol/Feature.h>
-#include <ripple/protocol/Indexes.h>
-#include <ripple/protocol/Protocol.h>
-#include <ripple/protocol/TxFlags.h>
-#include <ripple/protocol/st.h>
-
-namespace ripple {
-
-NotTEC
-Clawback::preflight(PreflightContext const& ctx)
-{
-    if (!ctx.rules.enabled(featureClawback))
-        return temDISABLED;
-
-    if (auto const ret = preflight1(ctx); !isTesSuccess(ret))
-        return ret;
-
-    if (ctx.tx.getFlags() & tfClawbackMask)
-        return temINVALID_FLAG;
-
-    AccountID const issuer = ctx.tx[sfAccount];
-    STAmount const clawAmount = ctx.tx[sfAmount];
-
-    // The issuer field is used for the token holder instead
-    AccountID const& holder = clawAmount.getIssuer();
-
-    if (issuer == holder || isXRP(clawAmount) || clawAmount <= beast::zero)
-        return temBAD_AMOUNT;
-
-    return preflight2(ctx);
-}
-
-TER
-Clawback::preclaim(PreclaimContext const& ctx)
-{
-    AccountID const issuer = ctx.tx[sfAccount];
-    STAmount const clawAmount = ctx.tx[sfAmount];
-    AccountID const& holder = clawAmount.getIssuer();
-
-    auto const sleIssuer = ctx.view.read(keylet::account(issuer));
-    auto const sleHolder = ctx.view.read(keylet::account(holder));
-    if (!sleIssuer || !sleHolder)
-        return terNO_ACCOUNT;
-
-    std::uint32_t const issuerFlagsIn = sleIssuer->getFieldU32(sfFlags);
-
-    // If AllowTrustLineClawback is not set or NoFreeze is set, return no
-    // permission
-    if (!(issuerFlagsIn & lsfAllowTrustLineClawback) ||
-        (issuerFlagsIn & lsfNoFreeze))
-        return tecNO_PERMISSION;
-
-    auto const sleRippleState =
-        ctx.view.read(keylet::line(holder, issuer, clawAmount.getCurrency()));
-    if (!sleRippleState)
-        return tecNO_LINE;
-
-    STAmount const balance = (*sleRippleState)[sfBalance];
-
-    // If balance is positive, issuer must have higher address than holder
-    if (balance > beast::zero && issuer < holder)
-        return tecNO_PERMISSION;
-
-    // If balance is negative, issuer must have lower address than holder
-    if (balance < beast::zero && issuer > holder)
-        return tecNO_PERMISSION;
-
-    // At this point, we know that issuer and holder accounts
-    // are correct and a trustline exists between them.
-    //
-    // Must now explicitly check the balance to make sure
-    // available balance is non-zero.
-    //
-    // We can't directly check the balance of trustline because
-    // the available balance of a trustline is prone to new changes (eg.
-    // XLS-34). So we must use `accountHolds`.
-    if (accountHolds(
-            ctx.view,
-            holder,
-            clawAmount.getCurrency(),
-            issuer,
-            fhIGNORE_FREEZE,
-            ctx.j) <= beast::zero)
-        return tecINSUFFICIENT_FUNDS;
-
-    return tesSUCCESS;
-}
-
-TER
-Clawback::doApply()
-{
-    AccountID const& issuer = account_;
-    STAmount clawAmount = ctx_.tx[sfAmount];
-    AccountID const holder = clawAmount.getIssuer();  // cannot be reference
-
-    // Replace the `issuer` field with issuer's account
-    clawAmount.setIssuer(issuer);
-    if (holder == issuer)
-        return tecINTERNAL;
-
-    // Get the spendable balance. Must use `accountHolds`.
-    STAmount const spendableAmount = accountHolds(
-        view(),
-        holder,
-        clawAmount.getCurrency(),
-        clawAmount.getIssuer(),
-        fhIGNORE_FREEZE,
-        j_);
-
-    return rippleCredit(
-        view(),
-        holder,
-        issuer,
-        std::min(spendableAmount, clawAmount),
-        true,
-        j_);
-}
-
-}  // namespace ripple

src/ripple/app/tx/impl/Clawback.h

@@ -1,48 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-  This file is part of rippled: https://github.com/ripple/rippled
-  Copyright (c) 2023 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_TX_CLAWBACK_H_INCLUDED
-#define RIPPLE_TX_CLAWBACK_H_INCLUDED
-
-#include <ripple/app/tx/impl/Transactor.h>
-
-namespace ripple {
-
-class Clawback : public Transactor
-{
-public:
-    static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
-
-    explicit Clawback(ApplyContext& ctx) : Transactor(ctx)
-    {
-    }
-
-    static NotTEC
-    preflight(PreflightContext const& ctx);
-
-    static TER
-    preclaim(PreclaimContext const& ctx);
-
-    TER
-    doApply() override;
-};
-
-}  // namespace ripple
-
-#endif

src/ripple/app/tx/impl/CreateOffer.cpp

@@ -275,32 +275,6 @@ CreateOffer::checkAcceptAsset(
         }
     }
 
-    // An account can not create a trustline to itself, so no line can exist
-    // to be frozen. Additionally, an issuer can always accept its own
-    // issuance.
-    if (issue.account == id)
-    {
-        return tesSUCCESS;
-    }
-
-    auto const trustLine =
-        view.read(keylet::line(id, issue.account, issue.currency));
-
-    if (!trustLine)
-    {
-        return tesSUCCESS;
-    }
-
-    // There's no difference which side enacted deep freeze, accepting
-    // tokens shouldn't be possible.
-    bool const deepFrozen =
-        (*trustLine)[sfFlags] & (lsfLowDeepFreeze | lsfHighDeepFreeze);
-
-    if (deepFrozen)
-    {
-        return tecFROZEN;
-    }
-
     return tesSUCCESS;
 }
 
@@ -1277,8 +1251,7 @@ CreateOffer::doApply()
     if (result.second)
     {
         sb.apply(ctx_.rawView());
-        if (!view().rules().enabled(featureIOUIssuerWeakTSH))
-            addWeakTSHFromBalanceChanges(sb);
+        addWeakTSHFromSandbox(sb);
     }
     else
         sbCancel.apply(ctx_.rawView());

src/ripple/app/tx/impl/Escrow.cpp

@@ -240,8 +240,7 @@ EscrowCreate::doApply()
             ctx_.view(),
             {account, ctx_.tx[sfDestination]},
             amount.issue(),
-            ctx_.journal,
-            lhLOCKING);
+            ctx_.journal);
 
         JLOG(ctx_.journal.trace())
             << "EscrowCreate::doApply trustTransferAllowed result=" << result;

src/ripple/app/tx/impl/InvariantCheck.cpp

@@ -24,7 +24,6 @@
 #include <ripple/basics/FeeUnits.h>
 #include <ripple/basics/Log.h>
 #include <ripple/ledger/ReadView.h>
-#include <ripple/ledger/View.h>
 #include <ripple/protocol/Feature.h>
 #include <ripple/protocol/STArray.h>
 #include <ripple/protocol/SystemParameters.h>
@@ -561,303 +560,6 @@ NoXRPTrustLines::finalize(
 
 //------------------------------------------------------------------------------
 
-void
-NoDeepFreezeTrustLinesWithoutFreeze::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const&,
-    std::shared_ptr<SLE const> const& after)
-{
-    if (after && after->getType() == ltRIPPLE_STATE)
-    {
-        std::uint32_t const uFlags = after->getFieldU32(sfFlags);
-        bool const lowFreeze = uFlags & lsfLowFreeze;
-        bool const lowDeepFreeze = uFlags & lsfLowDeepFreeze;
-
-        bool const highFreeze = uFlags & lsfHighFreeze;
-        bool const highDeepFreeze = uFlags & lsfHighDeepFreeze;
-
-        deepFreezeWithoutFreeze_ =
-            (lowDeepFreeze && !lowFreeze) || (highDeepFreeze && !highFreeze);
-    }
-}
-
-bool
-NoDeepFreezeTrustLinesWithoutFreeze::finalize(
-    STTx const&,
-    TER const,
-    XRPAmount const,
-    ReadView const&,
-    beast::Journal const& j)
-{
-    if (!deepFreezeWithoutFreeze_)
-        return true;
-
-    JLOG(j.fatal()) << "Invariant failed: a trust line with deep freeze flag "
-                       "without normal freeze was created";
-    return false;
-}
-
-//------------------------------------------------------------------------------
-
-void
-TransfersNotFrozen::visitEntry(
-    bool isDelete,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    /*
-     * A trust line freeze state alone doesn't determine if a transfer is
-     * frozen. The transfer must be examined "end-to-end" because both sides of
-     * the transfer may have different freeze states and freeze impact depends
-     * on the transfer direction. This is why first we need to track the
-     * transfers using IssuerChanges senders/receivers.
-     *
-     * Only in validateIssuerChanges, after we collected all changes can we
-     * determine if the transfer is valid.
-     */
-    if (!isValidEntry(before, after))
-    {
-        return;
-    }
-
-    auto const balanceChange = calculateBalanceChange(before, after, isDelete);
-    if (balanceChange.signum() == 0)
-    {
-        return;
-    }
-
-    recordBalanceChanges(after, balanceChange);
-}
-
-bool
-TransfersNotFrozen::finalize(
-    STTx const& tx,
-    TER const ter,
-    XRPAmount const fee,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    /*
-     * We check this invariant regardless of deep freeze amendment status,
-     * allowing for detection and logging of potential issues even when the
-     * amendment is disabled.
-     *
-     * If an exploit that allows moving frozen assets is discovered,
-     * we can alert operators who monitor fatal messages and trigger assert in
-     * debug builds for an early warning.
-     *
-     * In an unlikely event that an exploit is found, this early detection
-     * enables encouraging the UNL to expedite deep freeze amendment activation
-     * or deploy hotfixes via new amendments. In case of a new amendment, we'd
-     * only have to change this line setting 'enforce' variable.
-     * enforce = view.rules().enabled(featureDeepFreeze) ||
-     *           view.rules().enabled(fixFreezeExploit);
-     */
-    [[maybe_unused]] bool const enforce =
-        view.rules().enabled(featureDeepFreeze);
-
-    for (auto const& [issue, changes] : balanceChanges_)
-    {
-        auto const issuerSle = findIssuer(issue.account, view);
-        // It should be impossible for the issuer to not be found, but check
-        // just in case so rippled doesn't crash in release.
-        if (!issuerSle)
-        {
-            assert(enforce);
-            if (enforce)
-            {
-                return false;
-            }
-            continue;
-        }
-
-        if (!validateIssuerChanges(issuerSle, changes, tx, j, enforce))
-        {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool
-TransfersNotFrozen::isValidEntry(
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after)
-{
-    // `after` can never be null, even if the trust line is deleted.
-    assert(after);
-    if (!after)
-    {
-        return false;
-    }
-
-    if (after->getType() == ltACCOUNT_ROOT)
-    {
-        possibleIssuers_.emplace(after->getAccountID(sfAccount), after);
-        return false;
-    }
-
-    /* While LedgerEntryTypesMatch invariant also checks types, all invariants
-     * are processed regardless of previous failures.
-     *
-     * This type check is still necessary here because it prevents potential
-     * issues in subsequent processing.
-     */
-    return after->getType() == ltRIPPLE_STATE &&
-        (!before || before->getType() == ltRIPPLE_STATE);
-}
-
-STAmount
-TransfersNotFrozen::calculateBalanceChange(
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const& after,
-    bool isDelete)
-{
-    auto const getBalance = [](auto const& line, auto const& other, bool zero) {
-        STAmount amt = line ? line->getFieldAmount(sfBalance)
-                            : other->getFieldAmount(sfBalance).zeroed();
-        return zero ? amt.zeroed() : amt;
-    };
-
-    /* Trust lines can be created dynamically by other transactions such as
-     * Payment and OfferCreate that cross offers. Such trust line won't be
-     * created frozen, but the sender might be, so the starting balance must be
-     * treated as zero.
-     */
-    auto const balanceBefore = getBalance(before, after, false);
-
-    /* Same as above, trust lines can be dynamically deleted, and for frozen
-     * trust lines, payments not involving the issuer must be blocked. This is
-     * achieved by treating the final balance as zero when isDelete=true to
-     * ensure frozen line restrictions are enforced even during deletion.
-     */
-    auto const balanceAfter = getBalance(after, before, isDelete);
-
-    return balanceAfter - balanceBefore;
-}
-
-void
-TransfersNotFrozen::recordBalance(Issue const& issue, BalanceChange change)
-{
-    assert(change.balanceChangeSign);
-    auto& changes = balanceChanges_[issue];
-    if (change.balanceChangeSign < 0)
-        changes.senders.emplace_back(std::move(change));
-    else
-        changes.receivers.emplace_back(std::move(change));
-}
-
-void
-TransfersNotFrozen::recordBalanceChanges(
-    std::shared_ptr<SLE const> const& after,
-    STAmount const& balanceChange)
-{
-    auto const balanceChangeSign = balanceChange.signum();
-    auto const currency = after->getFieldAmount(sfBalance).getCurrency();
-
-    // Change from low account's perspective, which is trust line default
-    recordBalance(
-        {currency, after->getFieldAmount(sfHighLimit).getIssuer()},
-        {after, balanceChangeSign});
-
-    // Change from high account's perspective, which reverses the sign.
-    recordBalance(
-        {currency, after->getFieldAmount(sfLowLimit).getIssuer()},
-        {after, -balanceChangeSign});
-}
-
-std::shared_ptr<SLE const>
-TransfersNotFrozen::findIssuer(AccountID const& issuerID, ReadView const& view)
-{
-    if (auto it = possibleIssuers_.find(issuerID); it != possibleIssuers_.end())
-    {
-        return it->second;
-    }
-
-    return view.read(keylet::account(issuerID));
-}
-
-bool
-TransfersNotFrozen::validateIssuerChanges(
-    std::shared_ptr<SLE const> const& issuer,
-    IssuerChanges const& changes,
-    STTx const& tx,
-    beast::Journal const& j,
-    bool enforce)
-{
-    if (!issuer)
-    {
-        return false;
-    }
-
-    bool const globalFreeze = issuer->isFlag(lsfGlobalFreeze);
-    if (changes.receivers.empty() || changes.senders.empty())
-    {
-        /* If there are no receivers, then the holder(s) are returning
-         * their tokens to the issuer. Likewise, if there are no
-         * senders, then the issuer is issuing tokens to the holder(s).
-         * This is allowed regardless of the issuer's freeze flags. (The
-         * holder may have contradicting freeze flags, but that will be
-         * checked when the holder is treated as issuer.)
-         */
-        return true;
-    }
-
-    for (auto const& actors : {changes.senders, changes.receivers})
-    {
-        for (auto const& change : actors)
-        {
-            bool const high =
-                change.line->getFieldAmount(sfLowLimit).getIssuer() ==
-                issuer->getAccountID(sfAccount);
-
-            if (!validateFrozenState(
-                    change, high, tx, j, enforce, globalFreeze))
-            {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-bool
-TransfersNotFrozen::validateFrozenState(
-    BalanceChange const& change,
-    bool high,
-    STTx const& tx,
-    beast::Journal const& j,
-    bool enforce,
-    bool globalFreeze)
-{
-    bool const freeze = change.balanceChangeSign < 0 &&
-        change.line->isFlag(high ? lsfLowFreeze : lsfHighFreeze);
-    bool const deepFreeze =
-        change.line->isFlag(high ? lsfLowDeepFreeze : lsfHighDeepFreeze);
-    bool const frozen = globalFreeze || deepFreeze || freeze;
-
-    // bool const isAMMLine = change.line->isFlag(lsfAMMNode);
-
-    if (!frozen)
-    {
-        return true;
-    }
-
-    JLOG(j.fatal()) << "Invariant failed: Attempting to move frozen funds for "
-                    << tx.getTransactionID();
-    assert(enforce);
-
-    if (enforce)
-    {
-        return false;
-    }
-
-    return true;
-}
-
-//------------------------------------------------------------------------------
-
 void
 ValidNewAccountRoot::visitEntry(
     bool,
@@ -1145,62 +847,4 @@ NFTokenCountTracking::finalize(
     return true;
 }
 
-//------------------------------------------------------------------------------
-
-void
-ValidClawback::visitEntry(
-    bool,
-    std::shared_ptr<SLE const> const& before,
-    std::shared_ptr<SLE const> const&)
-{
-    if (before && before->getType() == ltRIPPLE_STATE)
-        trustlinesChanged++;
-}
-
-bool
-ValidClawback::finalize(
-    STTx const& tx,
-    TER const result,
-    XRPAmount const,
-    ReadView const& view,
-    beast::Journal const& j)
-{
-    if (tx.getTxnType() != ttCLAWBACK)
-        return true;
-
-    if (result == tesSUCCESS)
-    {
-        if (trustlinesChanged > 1)
-        {
-            JLOG(j.fatal())
-                << "Invariant failed: more than one trustline changed.";
-            return false;
-        }
-
-        AccountID const issuer = tx.getAccountID(sfAccount);
-        STAmount const amount = tx.getFieldAmount(sfAmount);
-        AccountID const& holder = amount.getIssuer();
-        STAmount const holderBalance = accountHolds(
-            view, holder, amount.getCurrency(), issuer, fhIGNORE_FREEZE, j);
-
-        if (holderBalance.signum() < 0)
-        {
-            JLOG(j.fatal())
-                << "Invariant failed: trustline balance is negative";
-            return false;
-        }
-    }
-    else
-    {
-        if (trustlinesChanged != 0)
-        {
-            JLOG(j.fatal()) << "Invariant failed: some trustlines were changed "
-                               "despite failure of the transaction.";
-            return false;
-        }
-    }
-
-    return true;
-}
-
 }  // namespace ripple

src/ripple/app/tx/impl/InvariantCheck.h

@@ -242,114 +242,6 @@ public:
         beast::Journal const&);
 };
 
-/**
- * @brief Invariant: Trust lines with deep freeze flag are not allowed if normal
- * freeze flag is not set.
- *
- * We iterate all the trust lines created by this transaction and ensure
- * that they don't have deep freeze flag set without normal freeze flag set.
- */
-class NoDeepFreezeTrustLinesWithoutFreeze
-{
-    bool deepFreezeWithoutFreeze_ = false;
-
-public:
-    void
-    visitEntry(
-        bool,
-        std::shared_ptr<SLE const> const&,
-        std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(
-        STTx const&,
-        TER const,
-        XRPAmount const,
-        ReadView const&,
-        beast::Journal const&);
-};
-
-/**
- * @brief Invariant: frozen trust line balance change is not allowed.
- *
- * We iterate all affected trust lines and ensure that they don't have
- * unexpected change of balance if they're frozen.
- */
-class TransfersNotFrozen
-{
-    struct BalanceChange
-    {
-        std::shared_ptr<SLE const> const line;
-        int const balanceChangeSign;
-    };
-
-    struct IssuerChanges
-    {
-        std::vector<BalanceChange> senders;
-        std::vector<BalanceChange> receivers;
-    };
-
-    using ByIssuer = std::map<Issue, IssuerChanges>;
-    ByIssuer balanceChanges_;
-
-    std::map<AccountID, std::shared_ptr<SLE const> const> possibleIssuers_;
-
-public:
-    void
-    visitEntry(
-        bool,
-        std::shared_ptr<SLE const> const&,
-        std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(
-        STTx const&,
-        TER const,
-        XRPAmount const,
-        ReadView const&,
-        beast::Journal const&);
-
-private:
-    bool
-    isValidEntry(
-        std::shared_ptr<SLE const> const& before,
-        std::shared_ptr<SLE const> const& after);
-
-    STAmount
-    calculateBalanceChange(
-        std::shared_ptr<SLE const> const& before,
-        std::shared_ptr<SLE const> const& after,
-        bool isDelete);
-
-    void
-    recordBalance(Issue const& issue, BalanceChange change);
-
-    void
-    recordBalanceChanges(
-        std::shared_ptr<SLE const> const& after,
-        STAmount const& balanceChange);
-
-    std::shared_ptr<SLE const>
-    findIssuer(AccountID const& issuerID, ReadView const& view);
-
-    bool
-    validateIssuerChanges(
-        std::shared_ptr<SLE const> const& issuer,
-        IssuerChanges const& changes,
-        STTx const& tx,
-        beast::Journal const& j,
-        bool enforce);
-
-    bool
-    validateFrozenState(
-        BalanceChange const& change,
-        bool high,
-        STTx const& tx,
-        beast::Journal const& j,
-        bool enforce,
-        bool globalFreeze);
-};
-
 /**
  * @brief Invariant: offers should be for non-negative amounts and must not
  *                   be XRP to XRP.
@@ -498,34 +390,6 @@ public:
         beast::Journal const&);
 };
 
-/**
- * @brief Invariant: Token holder's trustline balance cannot be negative after
- * Clawback.
- *
- * We iterate all the trust lines affected by this transaction and ensure
- * that no more than one trustline is modified, and also holder's balance is
- * non-negative.
- */
-class ValidClawback
-{
-    std::uint32_t trustlinesChanged = 0;
-
-public:
-    void
-    visitEntry(
-        bool,
-        std::shared_ptr<SLE const> const&,
-        std::shared_ptr<SLE const> const&);
-
-    bool
-    finalize(
-        STTx const&,
-        TER const,
-        XRPAmount const,
-        ReadView const&,
-        beast::Journal const&);
-};
-
 // additional invariant checks can be declared above and then added to this
 // tuple
 using InvariantChecks = std::tuple<
@@ -535,14 +399,11 @@ using InvariantChecks = std::tuple<
     XRPBalanceChecks,
     XRPNotCreated,
     NoXRPTrustLines,
-    NoDeepFreezeTrustLinesWithoutFreeze,
-    TransfersNotFrozen,
     NoBadOffers,
     NoZeroEscrow,
     ValidNewAccountRoot,
     ValidNFTokenPage,
-    NFTokenCountTracking,
-    ValidClawback>;
+    NFTokenCountTracking>;
 
 /**
  * @brief get a tuple of all invariant checks

src/ripple/app/tx/impl/NFTokenAcceptOffer.cpp

@@ -268,16 +268,6 @@ NFTokenAcceptOffer::preclaim(PreclaimContext const& ctx)
                     ctx.j) < needed)
                 return tecINSUFFICIENT_FUNDS;
         }
-
-        // Make sure that we are allowed to hold what the taker will pay us.
-        // This is a similar approach taken by usual offers.
-        if (!needed.native())
-        {
-            auto const result = checkAcceptAsset(
-                ctx.view, ctx.flags, (*so)[sfOwner], ctx.j, needed.issue());
-            if (result != tesSUCCESS)
-                return result;
-        }
     }
 
     return tesSUCCESS;
@@ -463,60 +453,4 @@ NFTokenAcceptOffer::doApply()
     return tecINTERNAL;
 }
 
-TER
-NFTokenAcceptOffer::checkAcceptAsset(
-    ReadView const& view,
-    ApplyFlags const flags,
-    AccountID const id,
-    beast::Journal const j,
-    Issue const& issue)
-{
-    // Only valid for custom currencies
-
-    if (!view.rules().enabled(featureDeepFreeze))
-    {
-        return tesSUCCESS;
-    }
-
-    assert(!isXRP(issue.currency));
-    auto const issuerAccount = view.read(keylet::account(issue.account));
-
-    if (!issuerAccount)
-    {
-        JLOG(j.debug())
-            << "delay: can't receive IOUs from non-existent issuer: "
-            << to_string(issue.account);
-
-        return tecNO_ISSUER;
-    }
-
-    // An account can not create a trustline to itself, so no line can exist
-    // to be frozen. Additionally, an issuer can always accept its own
-    // issuance.
-    if (issue.account == id)
-    {
-        return tesSUCCESS;
-    }
-
-    auto const trustLine =
-        view.read(keylet::line(id, issue.account, issue.currency));
-
-    if (!trustLine)
-    {
-        return tesSUCCESS;
-    }
-
-    // There's no difference which side enacted deep freeze, accepting
-    // tokens shouldn't be possible.
-    bool const deepFrozen =
-        (*trustLine)[sfFlags] & (lsfLowDeepFreeze | lsfHighDeepFreeze);
-
-    if (deepFrozen)
-    {
-        return tecFROZEN;
-    }
-
-    return tesSUCCESS;
-}
-
 }  // namespace ripple

src/ripple/app/tx/impl/NFTokenAcceptOffer.h

@@ -38,14 +38,6 @@ private:
         std::shared_ptr<SLE> const& buy,
         std::shared_ptr<SLE> const& sell);
 
-    static TER
-    checkAcceptAsset(
-        ReadView const& view,
-        ApplyFlags const flags,
-        AccountID const id,
-        beast::Journal const j,
-        Issue const& issue);
-
 public:
     static constexpr ConsequencesFactoryType ConsequencesFactory{Normal};
 

src/ripple/app/tx/impl/OfferStream.cpp

@@ -256,20 +256,6 @@ TOfferStreamBase<TIn, TOut>::step()
             continue;
         }
 
-        bool const deepFrozen = isDeepFrozen(
-            view_,
-            offer_.owner(),
-            offer_.issueIn().currency,
-            offer_.issueIn().account);
-        if (deepFrozen)
-        {
-            JLOG(j_.trace())
-                << "Removing deep frozen unfunded offer " << entry->key();
-            permRmOffer(entry->key());
-            offer_ = TOffer<TIn, TOut>{};
-            continue;
-        }
-
         // Calculate owner funds
         ownerFunds_ = accountFundsHelper(
             view_,

src/ripple/app/tx/impl/PayChan.cpp

@@ -273,8 +273,7 @@ PayChanCreate::preclaim(PreclaimContext const& ctx)
         // between these accounts for this asset
         {
             TER const result = trustTransferAllowed(
-                ctx.view, {account, dst}, amount.issue(), ctx.j, lhLOCKING);
-
+                ctx.view, {account, dst}, amount.issue(), ctx.j);
             JLOG(ctx.j.trace())
                 << "PayChanCreate::preclaim trustTransferAllowed result="
                 << result;

src/ripple/app/tx/impl/Payment.cpp

@@ -425,8 +425,7 @@ Payment::doApply()
             //             on the TER. But always applying *should*
             //             be safe.
             pv.apply(ctx_.rawView());
-            if (!view().rules().enabled(featureIOUIssuerWeakTSH))
-                addWeakTSHFromBalanceChanges(pv);
+            addWeakTSHFromSandbox(pv);
         }
 
         // TODO: is this right?  If the amount is the correct amount, was

src/ripple/app/tx/impl/SetAccount.cpp

@@ -218,37 +218,6 @@ SetAccount::preclaim(PreclaimContext const& ctx)
         }
     }
 
-    //
-    // Clawback
-    //
-    if (ctx.view.rules().enabled(featureClawback))
-    {
-        if (uSetFlag == asfAllowTrustLineClawback)
-        {
-            if (uFlagsIn & lsfNoFreeze)
-            {
-                JLOG(ctx.j.trace()) << "Can't set Clawback if NoFreeze is set";
-                return tecNO_PERMISSION;
-            }
-
-            if (!dirIsEmpty(ctx.view, keylet::ownerDir(id)))
-            {
-                JLOG(ctx.j.trace()) << "Owner directory not empty.";
-                return tecOWNERS;
-            }
-        }
-        else if (uSetFlag == asfNoFreeze)
-        {
-            // Cannot set NoFreeze if clawback is enabled
-            if (uFlagsIn & lsfAllowTrustLineClawback)
-            {
-                JLOG(ctx.j.trace())
-                    << "Can't set NoFreeze if clawback is enabled";
-                return tecNO_PERMISSION;
-            }
-        }
-    }
-
     return tesSUCCESS;
 }
 
@@ -618,12 +587,21 @@ SetAccount::doApply()
         }
     }
 
-    // Set flag for clawback
-    if (ctx_.view().rules().enabled(featureClawback) &&
-        uSetFlag == asfAllowTrustLineClawback)
+    //
+    // QuantumSignature
+    //
+    if (ctx_.view().rules().enabled(featureQuantumSigning))
     {
-        JLOG(j_.trace()) << "set allow clawback";
-        uFlagsOut |= lsfAllowTrustLineClawback;
+        if (uSetFlag == asfForceQuantum)
+        {
+            JLOG(j_.trace()) << "Set lsfForceQuantum.";
+            uFlagsOut |= lsfForceQuantum;
+        }
+        else if (uClearFlag == asfForceQuantum)
+        {
+            JLOG(j_.trace()) << "Clear lsfForceQuantum.";
+            uFlagsOut &= ~lsfForceQuantum;
+        }
     }
 
     if (uFlagsIn != uFlagsOut)

src/ripple/app/tx/impl/SetTrust.cpp

@@ -25,42 +25,6 @@
 #include <ripple/protocol/Quality.h>
 #include <ripple/protocol/st.h>
 
-namespace {
-
-uint32_t
-computeFreezeFlags(
-    uint32_t uFlags,
-    bool bHigh,
-    bool bNoFreeze,
-    bool bSetFreeze,
-    bool bClearFreeze,
-    bool bSetDeepFreeze,
-    bool bClearDeepFreeze)
-{
-    if (bSetFreeze && !bClearFreeze && !bNoFreeze)
-    {
-        uFlags |= (bHigh ? ripple::lsfHighFreeze : ripple::lsfLowFreeze);
-    }
-    else if (bClearFreeze && !bSetFreeze)
-    {
-        uFlags &= ~(bHigh ? ripple::lsfHighFreeze : ripple::lsfLowFreeze);
-    }
-    if (bSetDeepFreeze && !bClearDeepFreeze && !bNoFreeze)
-    {
-        uFlags |=
-            (bHigh ? ripple::lsfHighDeepFreeze : ripple::lsfLowDeepFreeze);
-    }
-    else if (bClearDeepFreeze && !bSetDeepFreeze)
-    {
-        uFlags &=
-            ~(bHigh ? ripple::lsfHighDeepFreeze : ripple::lsfLowDeepFreeze);
-    }
-
-    return uFlags;
-}
-
-}  // namespace
-
 namespace ripple {
 
 NotTEC
@@ -80,16 +44,6 @@ SetTrust::preflight(PreflightContext const& ctx)
         return temINVALID_FLAG;
     }
 
-    if (!ctx.rules.enabled(featureDeepFreeze))
-    {
-        // Even though the deep freeze flags are included in the
-        // `tfTrustSetMask`, they are not valid if the amendment is not enabled.
-        if (uTxFlags & (tfSetDeepFreeze | tfClearDeepFreeze))
-        {
-            return temINVALID_FLAG;
-        }
-    }
-
     STAmount const saLimitAmount(tx.getFieldAmount(sfLimitAmount));
 
     if (!isLegalNet(saLimitAmount))
@@ -188,58 +142,6 @@ SetTrust::preclaim(PreclaimContext const& ctx)
             return tecNO_PERMISSION;
     }
 
-    // Checking all freeze/deep freeze flag invariants.
-    if (ctx.view.rules().enabled(featureDeepFreeze))
-    {
-        bool const bNoFreeze = sle->isFlag(lsfNoFreeze);
-        bool const bSetFreeze = (uTxFlags & tfSetFreeze);
-        bool const bSetDeepFreeze = (uTxFlags & tfSetDeepFreeze);
-
-        if (bNoFreeze && (bSetFreeze || bSetDeepFreeze))
-        {
-            // Cannot freeze the trust line if NoFreeze is set
-            return tecNO_PERMISSION;
-        }
-
-        bool const bClearFreeze = (uTxFlags & tfClearFreeze);
-        bool const bClearDeepFreeze = (uTxFlags & tfClearDeepFreeze);
-        if ((bSetFreeze || bSetDeepFreeze) &&
-            (bClearFreeze || bClearDeepFreeze))
-        {
-            // Freezing and unfreezing in the same transaction should be
-            // illegal
-            return tecNO_PERMISSION;
-        }
-
-        bool const bHigh = id > uDstAccountID;
-        // Fetching current state of trust line
-        auto const sleRippleState =
-            ctx.view.read(keylet::line(id, uDstAccountID, currency));
-        std::uint32_t uFlags =
-            sleRippleState ? sleRippleState->getFieldU32(sfFlags) : 0u;
-        // Computing expected trust line state
-        uFlags = computeFreezeFlags(
-            uFlags,
-            bHigh,
-            bNoFreeze,
-            bSetFreeze,
-            bClearFreeze,
-            bSetDeepFreeze,
-            bClearDeepFreeze);
-
-        auto const frozen = uFlags & (bHigh ? lsfHighFreeze : lsfLowFreeze);
-        auto const deepFrozen =
-            uFlags & (bHigh ? lsfHighDeepFreeze : lsfLowDeepFreeze);
-
-        // Trying to set deep freeze on not already frozen trust line must
-        // fail. This also checks that clearing normal freeze while deep
-        // frozen must not work
-        if (deepFrozen && !frozen)
-        {
-            return tecNO_PERMISSION;
-        }
-    }
-
     return tesSUCCESS;
 }
 
@@ -255,7 +157,7 @@ SetTrust::doApply()
     Currency const currency(saLimitAmount.getCurrency());
     AccountID uDstAccountID(saLimitAmount.getIssuer());
 
-    // true, if current is high account.
+    // true, iff current is high account.
     bool const bHigh = account_ > uDstAccountID;
 
     auto const sle = view().peek(keylet::account(account_));
@@ -300,15 +202,13 @@ SetTrust::doApply()
     bool const bClearNoRipple = (uTxFlags & tfClearNoRipple);
     bool const bSetFreeze = (uTxFlags & tfSetFreeze);
     bool const bClearFreeze = (uTxFlags & tfClearFreeze);
-    bool const bSetDeepFreeze = (uTxFlags & tfSetDeepFreeze);
-    bool const bClearDeepFreeze = (uTxFlags & tfClearDeepFreeze);
 
     auto viewJ = ctx_.app.journal("View");
 
-    // Trust lines to self are impossible but because of the old bug there
-    // are two on 19-02-2022. This code was here to allow those trust lines
-    // to be deleted. The fixTrustLinesToSelf fix amendment will remove them
-    // when it enables so this code will no longer be needed.
+    // Trust lines to self are impossible but because of the old bug there are
+    // two on 19-02-2022. This code was here to allow those trust lines to be
+    // deleted. The fixTrustLinesToSelf fix amendment will remove them when it
+    // enables so this code will no longer be needed.
     if (!view().rules().enabled(fixTrustLinesToSelf) &&
         account_ == uDstAccountID)
     {
@@ -468,16 +368,14 @@ SetTrust::doApply()
             uFlagsOut &= ~(bHigh ? lsfHighNoRipple : lsfLowNoRipple);
         }
 
-        // Have to use lsfNoFreeze to maintain pre-deep freeze behavior
-        bool const bNoFreeze = sle->isFlag(lsfNoFreeze);
-        uFlagsOut = computeFreezeFlags(
-            uFlagsOut,
-            bHigh,
-            bNoFreeze,
-            bSetFreeze,
-            bClearFreeze,
-            bSetDeepFreeze,
-            bClearDeepFreeze);
+        if (bSetFreeze && !bClearFreeze && !sle->isFlag(lsfNoFreeze))
+        {
+            uFlagsOut |= (bHigh ? lsfHighFreeze : lsfLowFreeze);
+        }
+        else if (bClearFreeze && !bSetFreeze)
+        {
+            uFlagsOut &= ~(bHigh ? lsfHighFreeze : lsfLowFreeze);
+        }
 
         if (QUALITY_ONE == uLowQualityOut)
             uLowQualityOut = 0;
@@ -561,7 +459,7 @@ SetTrust::doApply()
         else if (bReserveIncrease && mPriorBalance < reserveCreate)
         {
             JLOG(j_.trace())
-                << "Delay transaction: Insufficient reserve to add trust line.";
+                << "Delay transaction: Insufficent reserve to add trust line.";
 
             // Another transaction could provide XRP to the account and then
             // this transaction would succeed.
@@ -577,10 +475,10 @@ SetTrust::doApply()
     // Line does not exist.
     else if (
         !saLimitAmount &&                  // Setting default limit.
-        (!bQualityIn || !uQualityIn) &&    // Not setting quality in or
-                                           // setting default quality in.
-        (!bQualityOut || !uQualityOut) &&  // Not setting quality out or
-                                           // setting default quality out.
+        (!bQualityIn || !uQualityIn) &&    // Not setting quality in or setting
+                                           // default quality in.
+        (!bQualityOut || !uQualityOut) &&  // Not setting quality out or setting
+                                           // default quality out.
         (!bSetAuth))
     {
         JLOG(j_.trace())
@@ -617,7 +515,6 @@ SetTrust::doApply()
             bSetAuth,
             bSetNoRipple && !bClearNoRipple,
             bSetFreeze && !bClearFreeze,
-            bSetDeepFreeze,
             saBalance,
             saLimitAllow,  // Limit for who is being charged.
             uQualityIn,

src/ripple/app/tx/impl/Transactor.cpp

@@ -40,6 +40,13 @@
 #include <ripple/protocol/UintTypes.h>
 #include <limits>
 #include <set>
+extern "C" {
+#include "api.h"
+}
+
+#ifndef DILITHIUM_PK_SIZE
+#define DILITHIUM_PK_SIZE pqcrystals_dilithium2_PUBLICKEYBYTES 
+#endif
 
 namespace ripple {
 
@@ -857,13 +864,18 @@ Transactor::checkSingleSign(PreclaimContext const& ctx)
     }
 
     // Look up the account.
-    auto const idSigner = calcAccountID(PublicKey(makeSlice(pkSigner)));
+    PublicKey pubKey = PublicKey(makeSlice(pkSigner));
+    auto const idSigner = calcAccountID(pubKey);
     auto const idAccount = ctx.tx.getAccountID(sfAccount);
     auto const sleAccount = ctx.view.read(keylet::account(idAccount));
 
     if (!sleAccount)
         return terNO_ACCOUNT;
 
+    if (ctx.view.rules().enabled(featureQuantumSigning) &&
+        sleAccount->isFlag(lsfForceQuantum) && pubKey.size() != DILITHIUM_PK_SIZE)
+        return telBAD_PUBLIC_KEY;
+
     bool const isMasterDisabled = sleAccount->isFlag(lsfDisableMaster);
 
     if (ctx.view.rules().enabled(fixMasterKeyAsRegularKey))
@@ -1477,15 +1489,15 @@ Transactor::doHookCallback(
 }
 
 void
-Transactor::addWeakTSHFromBalanceChanges(detail::ApplyViewBase const& pv)
+Transactor::addWeakTSHFromSandbox(detail::ApplyViewBase const& pv)
 {
     // If Hooks are enabled then non-issuers who have their TL balance
-    // modified by the execution of the transaction have the opportunity to have
-    // their weak hooks executed.
+    // modified by the execution of the path have the opportunity to have their
+    // weak hooks executed.
     if (ctx_.view().rules().enabled(featureHooks))
     {
-        // anyone whose balance changed as a result of transaction processing is
-        // a weak TSH
+        // anyone whose balance changed as a result of this Pathing is a weak
+        // TSH
         auto bc = pv.balanceChanges(view());
 
         for (auto const& entry : bc)
@@ -1506,13 +1518,15 @@ Transactor::addWeakTSHFromBalanceChanges(detail::ApplyViewBase const& pv)
 TER
 Transactor::doTSH(
     bool strong,  // only strong iff true, only weak iff false
-    std::vector<std::pair<AccountID, bool>> tsh,
     hook::HookStateMap& stateMap,
     std::vector<hook::HookResult>& results,
     std::shared_ptr<STObject const> const& provisionalMeta)
 {
     auto& view = ctx_.view();
 
+    std::vector<std::pair<AccountID, bool>> tsh =
+        hook::getTransactionalStakeHolders(ctx_.tx, view);
+
     // add the extra TSH marked out by the specific transactor (if applicable)
     if (!strong)
         for (auto& weakTsh : additionalWeakTSH_)
@@ -1770,9 +1784,6 @@ Transactor::operator()()
     // application to the ledger
     std::map<AccountID, std::set<uint256>> aawMap;
 
-    std::vector<std::pair<AccountID, bool>> tsh =
-        hook::getTransactionalStakeHolders(ctx_.tx, ctx_.view());
-
     // Pre-application (Strong TSH) Hooks are executed here
     // These TSH have the right to rollback.
     // Weak TSH and callback are executed post-application.
@@ -1801,7 +1812,7 @@ Transactor::operator()()
             // (who have the right to rollback the txn), any weak TSH will be
             // executed after doApply has been successful (callback as well)
 
-            result = doTSH(true, tsh, stateMap, hookResults, {});
+            result = doTSH(true, stateMap, hookResults, {});
         }
 
         // write state if all chains executed successfully
@@ -2055,23 +2066,7 @@ Transactor::operator()()
         hook::HookStateMap stateMap;
         std::vector<hook::HookResult> weakResults;
 
-        if (view().rules().enabled(featureIOUIssuerWeakTSH))
-        {
-            // Regardless of the transaction type, if the result changes the
-            // trust line balance, add high and low accounts to weakTSH.
-            ApplyViewImpl& avi = dynamic_cast<ApplyViewImpl&>(ctx_.view());
-            addWeakTSHFromBalanceChanges(avi);
-        }
-
-        if (!view().rules().enabled(featureIOUIssuerWeakTSH))
-        {
-            // before amendment enabled, we need to get TSHs after txn basic
-            // processing If the object is deleted in cancen txn, it may not
-            // be possible to obtain the appropriate TSH.
-            tsh = hook::getTransactionalStakeHolders(ctx_.tx, ctx_.view());
-        }
-
-        doTSH(false, tsh, stateMap, weakResults, proMeta);
+        doTSH(false, stateMap, weakResults, proMeta);
 
         // execute any hooks that nominated for 'again as weak'
         for (auto const& [accID, hookHashes] : aawMap)

src/ripple/app/tx/impl/Transactor.h

@@ -188,7 +188,6 @@ protected:
     TER
     doTSH(
         bool strong,  // only do strong TSH iff true, otheriwse only weak
-        std::vector<std::pair<AccountID, bool>> tsh,
         hook::HookStateMap& stateMap,
         std::vector<hook::HookResult>& result,
         std::shared_ptr<STObject const> const& provisionalMeta);
@@ -214,7 +213,7 @@ protected:
         std::shared_ptr<STObject const> const& provisionalMeta);
 
     void
-    addWeakTSHFromBalanceChanges(detail::ApplyViewBase const& pv);
+    addWeakTSHFromSandbox(detail::ApplyViewBase const& pv);
 
     // hooks amendment fields, these are unpopulated and unused unless
     // featureHooks is enabled

src/ripple/app/tx/impl/URIToken.cpp

@@ -832,7 +832,6 @@ URIToken::doApply()
                             false,                          // authorize account
                             (sleOwner->getFlags() & lsfDefaultRipple) == 0,
                             false,                          // freeze trust line
-                            false,                          // deepfreeze trust line
                             *dstAmt,                        // initial balance zero
                             Issue(
                                 purchaseAmount.getCurrency(), 

src/ripple/app/tx/impl/applySteps.cpp

@@ -24,7 +24,6 @@
 #include <ripple/app/tx/impl/CashCheck.h>
 #include <ripple/app/tx/impl/Change.h>
 #include <ripple/app/tx/impl/ClaimReward.h>
-#include <ripple/app/tx/impl/Clawback.h>
 #include <ripple/app/tx/impl/CreateCheck.h>
 #include <ripple/app/tx/impl/CreateOffer.h>
 #include <ripple/app/tx/impl/CreateTicket.h>
@@ -109,8 +108,6 @@ invoke_preflight(PreflightContext const& ctx)
             return invoke_preflight_helper<DeleteAccount>(ctx);
         case ttACCOUNT_SET:
             return invoke_preflight_helper<SetAccount>(ctx);
-        case ttCLAWBACK:
-            return invoke_preflight_helper<Clawback>(ctx);
         case ttCHECK_CANCEL:
             return invoke_preflight_helper<CancelCheck>(ctx);
         case ttCHECK_CASH:
@@ -234,8 +231,6 @@ invoke_preclaim(PreclaimContext const& ctx)
             return invoke_preclaim<DeleteAccount>(ctx);
         case ttACCOUNT_SET:
             return invoke_preclaim<SetAccount>(ctx);
-        case ttCLAWBACK:
-            return invoke_preclaim<Clawback>(ctx);
         case ttCHECK_CANCEL:
             return invoke_preclaim<CancelCheck>(ctx);
         case ttCHECK_CASH:
@@ -321,8 +316,6 @@ invoke_calculateBaseFee(ReadView const& view, STTx const& tx)
             return DeleteAccount::calculateBaseFee(view, tx);
         case ttACCOUNT_SET:
             return SetAccount::calculateBaseFee(view, tx);
-        case ttCLAWBACK:
-            return Clawback::calculateBaseFee(view, tx);
         case ttCHECK_CANCEL:
             return CancelCheck::calculateBaseFee(view, tx);
         case ttCHECK_CASH:
@@ -450,10 +443,6 @@ invoke_apply(ApplyContext& ctx)
             SetAccount p(ctx);
             return p();
         }
-        case ttCLAWBACK: {
-            Clawback p(ctx);
-            return p();
-        }
         case ttCHECK_CANCEL: {
             CancelCheck p(ctx);
             return p();

src/ripple/beast/unit_test/match.hpp

@@ -94,14 +94,6 @@ selector::operator()(suite_info const& s)
             return ! s.manual();
         }
 
-        // check start of name
-        if (s.name().starts_with(pat_) || s.full_name().starts_with(pat_))
-        {
-            // Don't change the mode so that the partial pattern can match
-            // more than once
-            return !s.manual();
-        }
-
         return false;
 
     case suite:

src/ripple/core/Config.h

@@ -361,7 +361,9 @@ public:
              boost::beast::iequals(
                  get(section(SECTION_RELATIONAL_DB), "backend"), "rwdb")) ||
             (!section("node_db").empty() &&
-             boost::beast::iequals(get(section("node_db"), "type"), "rwdb"));
+             (boost::beast::iequals(get(section("node_db"), "type"), "rwdb") ||
+              boost::beast::iequals(
+                  get(section("node_db"), "type"), "flatmap")));
         // RHNOTE: memory type is not selected for here because it breaks
         // tests
         return isMem;

src/ripple/core/impl/Config.cpp

@@ -45,6 +45,7 @@
 
 namespace ripple {
 namespace detail {
+
 [[nodiscard]] std::uint64_t
 getMemorySize()
 {
@@ -53,6 +54,7 @@ getMemorySize()
 
     return 0;
 }
+
 }  // namespace detail
 }  // namespace ripple
 #endif
@@ -62,6 +64,7 @@ getMemorySize()
 
 namespace ripple {
 namespace detail {
+
 [[nodiscard]] std::uint64_t
 getMemorySize()
 {
@@ -70,6 +73,7 @@ getMemorySize()
 
     return 0;
 }
+
 }  // namespace detail
 }  // namespace ripple
 
@@ -81,6 +85,7 @@ getMemorySize()
 
 namespace ripple {
 namespace detail {
+
 [[nodiscard]] std::uint64_t
 getMemorySize()
 {
@@ -93,11 +98,13 @@ getMemorySize()
 
     return 0;
 }
+
 }  // namespace detail
 }  // namespace ripple
 #endif
 
 namespace ripple {
+
 // clang-format off
 // The configurable node sizes are "tiny", "small", "medium", "large", "huge"
 inline constexpr std::array<std::pair<SizedItem, std::array<int, 5>>, 13>
@@ -1000,23 +1007,6 @@ Config::loadFromString(std::string const& fileContents)
                 "the maximum number of allowed peers (peers_max)");
         }
     }
-
-    if (!RUN_STANDALONE)
-    {
-        auto db_section = section(ConfigSection::nodeDatabase());
-        if (auto type = get(db_section, "type", ""); type == "rwdb")
-        {
-            if (auto delete_interval = get(db_section, "online_delete", 0);
-                delete_interval == 0)
-            {
-                Throw<std::runtime_error>(
-                    "RWDB (in-memory backend) requires online_delete to "
-                    "prevent OOM "
-                    "Exception: standalone mode (used by tests) doesn't need "
-                    "online_delete");
-            }
-        }
-    }
 }
 
 boost::filesystem::path
@@ -1081,4 +1071,5 @@ setup_FeeVote(Section const& section)
     }
     return setup;
 }
+
 }  // namespace ripple

src/ripple/ledger/View.h

@@ -78,9 +78,6 @@ hasExpired(ReadView const& view, std::optional<std::uint32_t> const& exp);
 /** Controls the treatment of frozen account balances */
 enum FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
 
-/** Controls the treatment of locked balances */
-enum LockHandling { lhLOCKING, lhUNLOCKING_RETURN, lhUNLOCKING_FORWARD };
-
 [[nodiscard]] bool
 isGlobalFrozen(ReadView const& view, AccountID const& issuer);
 
@@ -91,13 +88,6 @@ isFrozen(
     Currency const& currency,
     AccountID const& issuer);
 
-[[nodiscard]] bool
-isDeepFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Currency const& currency,
-    AccountID const& issuer);
-
 // Returns the amount an account can spend without going into debt.
 //
 // <-- saAmount: amount of currency held by account. May be negative.
@@ -353,7 +343,6 @@ trustCreate(
     const bool bAuth,           // --> authorize account.
     const bool bNoRipple,       // --> others cannot ripple through
     const bool bFreeze,         // --> funds cannot leave
-    bool bDeepFreeze,           // --> can neither receive nor send funds
     STAmount const& saBalance,  // --> balance of account being set.
                                 // Issuer should be noAccount()
     STAmount const& saLimit,    // --> limit for account being set.
@@ -532,12 +521,8 @@ trustAdjustLockedBalance(
 
     // check for freezes & auth
     {
-        TER const result = trustTransferAllowed(
-            view,
-            parties,
-            deltaAmt.issue(),
-            j,
-            deltaLockCount == 1 ? lhLOCKING : lhUNLOCKING_RETURN);
+        TER const result =
+            trustTransferAllowed(view, parties, deltaAmt.issue(), j);
 
         JLOG(j.trace())
             << "trustAdjustLockedBalance: trustTransferAllowed result="
@@ -640,8 +625,7 @@ trustTransferAllowed(
     V& view,
     std::vector<AccountID> const& parties,
     Issue const& issue,
-    beast::Journal const& j,
-    LockHandling lockHandling = lhUNLOCKING_FORWARD)
+    beast::Journal const& j)
 {
     static_assert(
         std::is_same<V, ReadView const>::value ||
@@ -670,12 +654,6 @@ trustTransferAllowed(
 
     uint32_t issuerFlags = sleIssuerAcc->getFieldU32(sfFlags);
 
-    // reject the creation of a locked balance (lhLOCKING) if the
-    // issuer has enabled clawback
-    if (lockHandling == lhLOCKING && view.rules().enabled(featureClawback) &&
-        issuerFlags & lsfAllowTrustLineClawback)
-        return tecNO_PERMISSION;
-
     bool requireAuth = issuerFlags & lsfRequireAuth;
 
     for (AccountID const& p : parties)
@@ -683,16 +661,6 @@ trustTransferAllowed(
         if (p == issue.account)
             continue;
 
-        if (lockHandling != lhUNLOCKING_RETURN &&
-            isDeepFrozen(view, p, issue.currency, issue.account))
-        {
-            JLOG(j.trace()) << "trustTransferAllowed: "
-                            // << "parties=[" << parties << "], "
-                            << "issuer: " << issue.account << " "
-                            << "has deep freeze on party: " << p;
-            return tecFROZEN;
-        }
-
         auto const line =
             view.read(keylet::line(p, issue.account, issue.currency));
         if (!line)
@@ -1003,7 +971,6 @@ trustTransferLockedBalance(
                         false,                          // authorize account
                         (sleDstAcc->getFlags() & lsfDefaultRipple) == 0,
                         false,                          // freeze trust line
-                        false,                          // deep freeze trust line
                         dstAmt,                         // initial balance
                         Issue(currency, dstAccID),      // limit of zero
                         0,                              // quality in

src/ripple/ledger/detail/ApplyStateTable.h

@@ -25,7 +25,6 @@
 #include <ripple/ledger/OpenView.h>
 #include <ripple/ledger/RawView.h>
 #include <ripple/ledger/ReadView.h>
-#include <ripple/protocol/Rules.h>
 #include <ripple/protocol/TER.h>
 #include <ripple/protocol/TxMeta.h>
 #include <memory>
@@ -54,18 +53,6 @@ private:
     items_t items_;
     XRPAmount dropsDestroyed_{0};
 
-    // Track original PreviousTxnID/LgrSeq values to restore after provisional
-    // metadata. This map is populated during provisional metadata generation
-    // and consumed during final metadata generation. It is not cleared as
-    // the ApplyStateTable instance is single-use per transaction.
-    struct ThreadingState
-    {
-        uint256 prevTxnID;
-        uint32_t prevTxnLgrSeq;
-        bool hasPrevTxnID;
-    };
-    mutable std::map<key_type, ThreadingState> originalThreadingState_;
-
 public:
     ApplyStateTable() = default;
     ApplyStateTable(ApplyStateTable&&) = default;
@@ -86,8 +73,7 @@ public:
         std::optional<STAmount> const& deliver,
         std::vector<STObject> const& hookExecution,
         std::vector<STObject> const& hookEmission,
-        beast::Journal j,
-        bool isProvisional = false);
+        beast::Journal j);
 
     void
     apply(
@@ -152,11 +138,8 @@ public:
     }
 
 private:
-    void
-    threadItem(
-        TxMeta& meta,
-        std::shared_ptr<SLE> const& to,
-        Rules const& rules);
+    static void
+    threadItem(TxMeta& meta, std::shared_ptr<SLE> const& to);
 
     std::shared_ptr<SLE>
     getForMod(

src/ripple/ledger/impl/ApplyStateTable.cpp

@@ -118,8 +118,7 @@ ApplyStateTable::generateTxMeta(
     std::optional<STAmount> const& deliver,
     std::vector<STObject> const& hookExecution,
     std::vector<STObject> const& hookEmission,
-    beast::Journal j,
-    bool isProvisional)
+    beast::Journal j)
 {
     TxMeta meta(tx.getTransactionID(), to.seq());
     if (deliver)
@@ -197,7 +196,7 @@ ApplyStateTable::generateTxMeta(
 
             if (curNode->isThreadedType())  // thread transaction to node
                                             // item modified
-                threadItem(meta, curNode, to.rules());
+                threadItem(meta, curNode);
 
             STObject prevs(sfPreviousFields);
             for (auto const& obj : *origNode)
@@ -230,7 +229,7 @@ ApplyStateTable::generateTxMeta(
             threadOwners(to, meta, curNode, newMod, j);
 
             if (curNode->isThreadedType())  // always thread to self
-                threadItem(meta, curNode, to.rules());
+                threadItem(meta, curNode);
 
             STObject news(sfNewFields);
             for (auto const& obj : *curNode)
@@ -255,34 +254,6 @@ ApplyStateTable::generateTxMeta(
         }
     }
 
-    // After provisional metadata generation, restore the original PreviousTxnID
-    // values to prevent contamination of the "before" state used for final
-    // metadata comparison. This ensures PreviousTxnID appears correctly in
-    // ModifiedNode metadata.
-    if (isProvisional && to.rules().enabled(fixProvisionalDoubleThreading))
-    {
-        for (auto const& [key, state] : originalThreadingState_)
-        {
-            auto iter = items_.find(key);
-            if (iter != items_.end())
-            {
-                auto sle = iter->second.second;
-                if (state.hasPrevTxnID)
-                {
-                    sle->setFieldH256(sfPreviousTxnID, state.prevTxnID);
-                    sle->setFieldU32(sfPreviousTxnLgrSeq, state.prevTxnLgrSeq);
-                    // Restored to original PreviousTxnID
-                }
-                else
-                {
-                    sle->makeFieldAbsent(sfPreviousTxnID);
-                    sle->makeFieldAbsent(sfPreviousTxnLgrSeq);
-                    // Restored to no PreviousTxnID
-                }
-            }
-        }
-    }
-
     return {meta, newMod};
 }
 
@@ -316,8 +287,6 @@ ApplyStateTable::apply(
         // VFALCO For diagnostics do we want to show
         //        metadata even when the base view is open?
         JLOG(j.trace()) << "metadata " << meta.getJson(JsonOptions::none);
-
-        // Metadata has been generated
     }
     to.rawTxInsert(tx.getTransactionID(), sTx, sMeta);
     apply(to);
@@ -580,51 +549,9 @@ ApplyStateTable::destroyXRP(XRPAmount const& fee)
 //------------------------------------------------------------------------------
 
 // Insert this transaction to the SLE's threading list
-//
-// This method is called during metadata generation to update the
-// PreviousTxnID/PreviousTxnLgrSeq fields on SLEs. However, it's called
-// twice for each transaction:
-// 1. During provisional metadata generation (for hooks to see)
-// 2. During final metadata generation (for the actual ledger)
-//
-// The fixProvisionalDoubleThreading amendment fixes a bug where the
-// provisional threading would contaminate the "original" state used
-// for metadata comparison, causing PreviousTxnID to be missing from
-// the final metadata.
-//
-// The fix works by:
-// - Saving the original PreviousTxnID state for an SLE the first time it's
-//   threaded during the provisional pass.
-// - Restoring the original state for all affected SLEs in a single batch
-//   after the entire provisional metadata generation is complete.
-//
-// This batch-restore is critical because threadItem() can be called on the
-// same SLE multiple times within one metadata pass. Restoring immediately
-// would be incorrect. This approach ensures the final metadata comparison
-// starts from the correct, uncontaminated "before" state.
 void
-ApplyStateTable::threadItem(
-    TxMeta& meta,
-    std::shared_ptr<SLE> const& sle,
-    const Rules& rules)
+ApplyStateTable::threadItem(TxMeta& meta, std::shared_ptr<SLE> const& sle)
 {
-    if (rules.enabled(fixProvisionalDoubleThreading))
-    {
-        auto const key = sle->key();
-        if (originalThreadingState_.find(key) == originalThreadingState_.end())
-        {
-            // First time (provisional metadata) - save the original state
-            ThreadingState state;
-            state.hasPrevTxnID = sle->isFieldPresent(sfPreviousTxnID);
-            if (state.hasPrevTxnID)
-            {
-                state.prevTxnID = sle->getFieldH256(sfPreviousTxnID);
-                state.prevTxnLgrSeq = sle->getFieldU32(sfPreviousTxnLgrSeq);
-            }
-            originalThreadingState_[key] = state;
-        }
-    }
-
     key_type prevTxID;
     LedgerIndex prevLgrID;
 
@@ -640,11 +567,6 @@ ApplyStateTable::threadItem(
             assert(node.getFieldIndex(sfPreviousTxnLgrSeq) == -1);
             node.setFieldH256(sfPreviousTxnID, prevTxID);
             node.setFieldU32(sfPreviousTxnLgrSeq, prevLgrID);
-            // Added PreviousTxnID to metadata
-        }
-        else
-        {
-            // PreviousTxnID already present in metadata
         }
 
         assert(node.getFieldH256(sfPreviousTxnID) == prevTxID);
@@ -718,7 +640,7 @@ ApplyStateTable::threadTx(
         JLOG(j.warn()) << "Threading to non-existent account: " << toBase58(to);
         return;
     }
-    threadItem(meta, sle, base.rules());
+    threadItem(meta, sle);
 }
 
 void

src/ripple/ledger/impl/ApplyViewImpl.cpp

@@ -41,13 +41,8 @@ ApplyViewImpl::generateProvisionalMeta(
     beast::Journal j)
 {
     auto [meta, _] = items_.generateTxMeta(
-        to,
-        tx,
-        deliver_,
-        hookExecution_,
-        hookEmission_,
-        j,
-        true);  // isProvisional = true
+        to, tx, deliver_, hookExecution_, hookEmission_, j);
+
     return meta;
 }
 

src/ripple/ledger/impl/View.cpp

@@ -219,26 +219,6 @@ isFrozen(
     return false;
 }
 
-bool
-isDeepFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Currency const& currency,
-    AccountID const& issuer)
-{
-    if (isXRP(currency))
-        return false;
-
-    if (issuer == account)
-        return false;
-
-    auto const sle = view.read(keylet::line(account, issuer, currency));
-    if (!sle)
-        return false;
-
-    return sle->isFlag(lsfHighDeepFreeze) || sle->isFlag(lsfLowDeepFreeze);
-}
-
 STAmount
 accountHolds(
     ReadView const& view,
@@ -256,22 +236,17 @@ accountHolds(
 
     // IOU: Return balance on trust line modulo freeze
     auto const sle = view.read(keylet::line(account, issuer, currency));
-    auto const allowBalance = [&]() {
-        if (!sle)
-            return false;
-
-        if (zeroIfFrozen == fhZERO_IF_FROZEN)
-        {
-            if (isFrozen(view, account, currency, issuer) ||
-                isDeepFrozen(view, account, currency, issuer))
-            {
-                return false;
-            }
-        }
-        return true;
-    }();
-
-    if (allowBalance)
+    if (!sle)
+    {
+        amount.clear({currency, issuer});
+    }
+    else if (
+        (zeroIfFrozen == fhZERO_IF_FROZEN) &&
+        isFrozen(view, account, currency, issuer))
+    {
+        amount.clear(Issue(currency, issuer));
+    }
+    else
     {
         amount = sle->getFieldAmount(sfBalance);
         if (account > issuer)
@@ -304,10 +279,6 @@ accountHolds(
 
         amount.setIssuer(issuer);
     }
-    else
-    {
-        amount.clear(Issue{currency, issuer});
-    }
     JLOG(j.trace()) << "accountHolds:"
                     << " account=" << to_string(account)
                     << " amount=" << amount.getFullText();
@@ -798,7 +769,6 @@ trustCreate(
     const bool bAuth,           // --> authorize account.
     const bool bNoRipple,       // --> others cannot ripple through
     const bool bFreeze,         // --> funds cannot leave
-    const bool bDeepFreeze,     // --> can neither receive nor send funds
     STAmount const& saBalance,  // --> balance of account being set.
                                 // Issuer should be noAccount()
     STAmount const& saLimit,    // --> limit for account being set.
@@ -880,11 +850,7 @@ trustCreate(
     }
     if (bFreeze)
     {
-        uFlags |= (bSetHigh ? lsfHighFreeze : lsfLowFreeze);
-    }
-    if (bDeepFreeze)
-    {
-        uFlags |= (bSetHigh ? lsfHighDeepFreeze : lsfLowDeepFreeze);
+        uFlags |= (!bSetHigh ? lsfLowFreeze : lsfHighFreeze);
     }
 
     if ((slePeer->getFlags() & lsfDefaultRipple) == 0)
@@ -1174,7 +1140,6 @@ rippleCredit(
         false,
         noRipple,
         false,
-        false,
         saBalance,
         saReceiverLimit,
         0,
@@ -1499,7 +1464,6 @@ issueIOU(
         false,
         noRipple,
         false,
-        false,
         final_balance,
         limit,
         0,

src/ripple/nodestore/backend/FlatmapFactory.cpp

@@ -0,0 +1,235 @@
+#include <ripple/basics/contract.h>
+#include <ripple/nodestore/Factory.h>
+#include <ripple/nodestore/Manager.h>
+#include <ripple/nodestore/impl/DecodedBlob.h>
+#include <ripple/nodestore/impl/EncodedBlob.h>
+#include <ripple/nodestore/impl/codec.h>
+#include <boost/beast/core/string.hpp>
+#include <boost/core/ignore_unused.hpp>
+#include <boost/unordered/concurrent_flat_map.hpp>
+#include <memory>
+#include <mutex>
+
+namespace ripple {
+namespace NodeStore {
+
+class FlatmapBackend : public Backend
+{
+private:
+    std::string name_;
+    beast::Journal journal_;
+    bool isOpen_{false};
+
+    struct base_uint_hasher
+    {
+        using result_type = std::size_t;
+
+        result_type
+        operator()(base_uint<256> const& value) const
+        {
+            return hardened_hash<>{}(value);
+        }
+    };
+
+    using DataStore = boost::unordered::concurrent_flat_map<
+        uint256,
+        std::vector<std::uint8_t>,  // Store compressed blob data
+        base_uint_hasher>;
+
+    DataStore table_;
+
+public:
+    FlatmapBackend(
+        size_t keyBytes,
+        Section const& keyValues,
+        beast::Journal journal)
+        : name_(get(keyValues, "path")), journal_(journal)
+    {
+        boost::ignore_unused(journal_);
+        if (name_.empty())
+            name_ = "node_db";
+    }
+
+    ~FlatmapBackend() override
+    {
+        close();
+    }
+
+    std::string
+    getName() override
+    {
+        return name_;
+    }
+
+    void
+    open(bool createIfMissing) override
+    {
+        if (isOpen_)
+            Throw<std::runtime_error>("already open");
+        isOpen_ = true;
+    }
+
+    bool
+    isOpen() override
+    {
+        return isOpen_;
+    }
+
+    void
+    close() override
+    {
+        table_.clear();
+        isOpen_ = false;
+    }
+
+    Status
+    fetch(void const* key, std::shared_ptr<NodeObject>* pObject) override
+    {
+        if (!isOpen_)
+            return notFound;
+
+        uint256 const hash(uint256::fromVoid(key));
+
+        bool found = table_.visit(hash, [&](const auto& key_value_pair) {
+            nudb::detail::buffer bf;
+            auto const result = nodeobject_decompress(
+                key_value_pair.second.data(), key_value_pair.second.size(), bf);
+            DecodedBlob decoded(hash.data(), result.first, result.second);
+            if (!decoded.wasOk())
+            {
+                *pObject = nullptr;
+                return;
+            }
+            *pObject = decoded.createObject();
+        });
+        return found ? (*pObject ? ok : dataCorrupt) : notFound;
+    }
+
+    std::pair<std::vector<std::shared_ptr<NodeObject>>, Status>
+    fetchBatch(std::vector<uint256 const*> const& hashes) override
+    {
+        std::vector<std::shared_ptr<NodeObject>> results;
+        results.reserve(hashes.size());
+        for (auto const& h : hashes)
+        {
+            std::shared_ptr<NodeObject> nObj;
+            Status status = fetch(h->begin(), &nObj);
+            if (status != ok)
+                results.push_back({});
+            else
+                results.push_back(nObj);
+        }
+        return {results, ok};
+    }
+
+    void
+    store(std::shared_ptr<NodeObject> const& object) override
+    {
+        if (!isOpen_)
+            return;
+
+        if (!object)
+            return;
+
+        EncodedBlob encoded(object);
+        nudb::detail::buffer bf;
+        auto const result =
+            nodeobject_compress(encoded.getData(), encoded.getSize(), bf);
+
+        std::vector<std::uint8_t> compressed(
+            static_cast<const std::uint8_t*>(result.first),
+            static_cast<const std::uint8_t*>(result.first) + result.second);
+
+        table_.insert_or_assign(object->getHash(), std::move(compressed));
+    }
+
+    void
+    storeBatch(Batch const& batch) override
+    {
+        for (auto const& e : batch)
+            store(e);
+    }
+
+    void
+    sync() override
+    {
+    }
+
+    void
+    for_each(std::function<void(std::shared_ptr<NodeObject>)> f) override
+    {
+        if (!isOpen_)
+            return;
+
+        table_.visit_all([&f](const auto& entry) {
+            nudb::detail::buffer bf;
+            auto const result = nodeobject_decompress(
+                entry.second.data(), entry.second.size(), bf);
+            DecodedBlob decoded(
+                entry.first.data(), result.first, result.second);
+            if (decoded.wasOk())
+                f(decoded.createObject());
+        });
+    }
+
+    int
+    getWriteLoad() override
+    {
+        return 0;
+    }
+
+    void
+    setDeletePath() override
+    {
+        close();
+    }
+
+    int
+    fdRequired() const override
+    {
+        return 0;
+    }
+
+private:
+    size_t
+    size() const
+    {
+        return table_.size();
+    }
+};
+
+class FlatmapFactory : public Factory
+{
+public:
+    FlatmapFactory()
+    {
+        Manager::instance().insert(*this);
+    }
+
+    ~FlatmapFactory() override
+    {
+        Manager::instance().erase(*this);
+    }
+
+    std::string
+    getName() const override
+    {
+        return "Flatmap";
+    }
+
+    std::unique_ptr<Backend>
+    createInstance(
+        size_t keyBytes,
+        Section const& keyValues,
+        std::size_t burstSize,
+        Scheduler& scheduler,
+        beast::Journal journal) override
+    {
+        return std::make_unique<FlatmapBackend>(keyBytes, keyValues, journal);
+    }
+};
+
+static FlatmapFactory flatmapFactory;
+
+}  // namespace NodeStore
+}  // namespace ripple

src/ripple/protocol/Feature.h

@@ -74,7 +74,7 @@ namespace detail {
 // Feature.cpp. Because it's only used to reserve storage, and determine how
 // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than
 // the actual number of amendments. A LogicError on startup will verify this.
-static constexpr std::size_t numFeatures = 85;
+static constexpr std::size_t numFeatures = 82;
 
 /** Amendments that this server supports and the default voting behavior.
    Whether they are enabled depends on the Rules defined in the validated
@@ -369,10 +369,7 @@ extern uint256 const fixXahauV3;
 extern uint256 const fix20250131;
 extern uint256 const featureHookCanEmit;
 extern uint256 const fixRewardClaimFlags;
-extern uint256 const fixProvisionalDoubleThreading;
-extern uint256 const featureClawback;
-extern uint256 const featureDeepFreeze;
-extern uint256 const featureIOUIssuerWeakTSH;
+extern uint256 const featureQuantumSigning;
 
 }  // namespace ripple
 

src/ripple/protocol/KeyType.h

@@ -28,6 +28,7 @@ namespace ripple {
 enum class KeyType {
     secp256k1 = 0,
     ed25519 = 1,
+    dilithium = 2,
 };
 
 inline std::optional<KeyType>
@@ -39,6 +40,9 @@ keyTypeFromString(std::string const& s)
     if (s == "ed25519")
         return KeyType::ed25519;
 
+    if (s == "dilithium")
+        return KeyType::dilithium;
+
     return {};
 }
 
@@ -50,6 +54,9 @@ to_string(KeyType type)
 
     if (type == KeyType::ed25519)
         return "ed25519";
+    
+    if (type == KeyType::dilithium)
+        return "dilithium";
 
     return "INVALID";
 }

src/ripple/protocol/LedgerFormats.h

@@ -275,6 +275,7 @@ enum LedgerSpecificFlags {
         0x00800000,                 // True, trust lines allow rippling by default
     lsfDepositAuth = 0x01000000,    // True, all deposits require authorization
     lsfTshCollect = 0x02000000,     // True, allow TSH collect-calls to acc hooks
+    lsfForceQuantum = 0x04000000, // True, force quantum-resistant signature
     lsfDisallowIncomingNFTokenOffer =
         0x04000000,               // True, reject new incoming NFT offers
     lsfDisallowIncomingCheck =
@@ -287,8 +288,6 @@ enum LedgerSpecificFlags {
         0x40000000,               // True, has minted tokens in the past
     lsfDisallowIncomingRemit =    // True, no remits allowed to this account
         0x80000000,
-    lsfAllowTrustLineClawback = 
-        0x00001000,               // True, enable clawback 
 
     // ltOFFER
     lsfPassive = 0x00010000,
@@ -301,10 +300,8 @@ enum LedgerSpecificFlags {
     lsfHighAuth = 0x00080000,
     lsfLowNoRipple = 0x00100000,
     lsfHighNoRipple = 0x00200000,
-    lsfLowFreeze = 0x00400000,      // True, low side has set freeze flag
-    lsfHighFreeze = 0x00800000,     // True, high side has set freeze flag
-    lsfLowDeepFreeze = 0x02000000,  // True, low side has set deep freeze flag
-    lsfHighDeepFreeze = 0x04000000, // True, high side has set deep freeze flag
+    lsfLowFreeze = 0x00400000,   // True, low side has set freeze flag
+    lsfHighFreeze = 0x00800000,  // True, high side has set freeze flag
 
     // ltSIGNER_LIST
     lsfOneOwnerCount = 0x00010000,  // True, uses only one OwnerCount

src/ripple/protocol/PublicKey.h

@@ -43,10 +43,11 @@ namespace ripple {
     information needed to determine the cryptosystem
     parameters used is stored inside the key.
 
-    As of this writing two systems are supported:
+    As of this writing three systems are supported:
 
         secp256k1
         ed25519
+        dilithium
 
     secp256k1 public keys consist of a 33 byte
     compressed public key, with the lead byte equal
@@ -55,12 +56,14 @@ namespace ripple {
     The ed25519 public keys consist of a 1 byte
     prefix constant 0xED, followed by 32 bytes of
     public key data.
+
+    The dilithium public keys will have their own specific format.
 */
 class PublicKey
 {
 protected:
+    std::uint8_t buf_[1312];
     std::size_t size_ = 0;
-    std::uint8_t buf_[33];  // should be large enough
 
 public:
     using const_iterator = std::uint8_t const*;

src/ripple/protocol/SecretKey.h

@@ -36,7 +36,8 @@ namespace ripple {
 class SecretKey
 {
 private:
-    std::uint8_t buf_[32];
+    std::uint8_t buf_[2528];
+    std::size_t size_ = 0;
 
 public:
     using const_iterator = std::uint8_t const*;
@@ -49,6 +50,7 @@ public:
     ~SecretKey();
 
     SecretKey(std::array<std::uint8_t, 32> const& data);
+    SecretKey(std::array<std::uint8_t, 2528> const& data);
     SecretKey(Slice const& slice);
 
     std::uint8_t const*
@@ -60,7 +62,7 @@ public:
     std::size_t
     size() const
     {
-        return sizeof(buf_);
+        return size_;
     }
 
     /** Convert the secret key to a hexadecimal string.
@@ -86,13 +88,13 @@ public:
     const_iterator
     end() const noexcept
     {
-        return buf_ + sizeof(buf_);
+        return buf_ + size_;
     }
 
     const_iterator
     cend() const noexcept
     {
-        return buf_ + sizeof(buf_);
+        return buf_ + size_;
     }
 };
 
@@ -126,6 +128,10 @@ toBase58(TokenType type, SecretKey const& sk)
 SecretKey
 randomSecretKey();
 
+/** Create a secret key using secure random numbers. */
+SecretKey
+randomSecretKey(KeyType type);
+
 /** Generate a new secret key deterministically. */
 SecretKey
 generateSecretKey(KeyType type, Seed const& seed);

src/ripple/protocol/TxFlags.h

@@ -92,7 +92,7 @@ enum AccountFlags : uint32_t {
     asfDisallowIncomingPayChan = 14,
     asfDisallowIncomingTrustline = 15,
     asfDisallowIncomingRemit = 16,
-    asfAllowTrustLineClawback = 17,
+    asfForceQuantum = 17,
 };
 
 // OfferCreate flags:
@@ -121,12 +121,10 @@ enum TrustSetFlags : uint32_t {
     tfClearNoRipple = 0x00040000,
     tfSetFreeze = 0x00100000,
     tfClearFreeze = 0x00200000,
-    tfSetDeepFreeze = 0x00400000,
-    tfClearDeepFreeze = 0x00800000
 };
 constexpr std::uint32_t tfTrustSetMask =
     ~(tfUniversal | tfSetfAuth | tfSetNoRipple | tfClearNoRipple | tfSetFreeze |
-      tfClearFreeze | tfSetDeepFreeze | tfClearDeepFreeze);
+      tfClearFreeze);
 
 // EnableAmendment flags:
 enum EnableAmendmentFlags : std::uint32_t {
@@ -197,9 +195,6 @@ constexpr std::uint32_t const tfClaimRewardMask = ~(tfUniversal | tfOptOut);
 // Remarks flags:
 constexpr std::uint32_t const tfImmutable = 1;
 
-// Clawback flags:
-constexpr std::uint32_t const tfClawbackMask = ~tfUniversal;
-
 // clang-format on
 
 }  // namespace ripple

src/ripple/protocol/TxFormats.h

@@ -139,9 +139,6 @@ enum TxType : std::uint16_t
     /** This transaction accepts an existing offer to buy or sell an existing  NFT. */
     ttNFTOKEN_ACCEPT_OFFER = 29,
 
-    /** This transaction claws back issued tokens. */
-    ttCLAWBACK = 30,
-
     /** This transaction mints/burns/buys/sells a URI TOKEN */
     ttURITOKEN_MINT = 45,
     ttURITOKEN_BURN = 46,

src/ripple/protocol/impl/Feature.cpp

@@ -475,10 +475,7 @@ REGISTER_FIX    (fixXahauV3,                    Supported::yes, VoteBehavior::De
 REGISTER_FIX    (fix20250131,                   Supported::yes, VoteBehavior::DefaultYes);
 REGISTER_FEATURE(HookCanEmit,                   Supported::yes, VoteBehavior::DefaultNo);
 REGISTER_FIX    (fixRewardClaimFlags,           Supported::yes, VoteBehavior::DefaultYes);
-REGISTER_FEATURE(Clawback,                      Supported::yes, VoteBehavior::DefaultNo);
-REGISTER_FIX    (fixProvisionalDoubleThreading, Supported::yes, VoteBehavior::DefaultYes);
-REGISTER_FEATURE(DeepFreeze,                    Supported::yes, VoteBehavior::DefaultNo);
-REGISTER_FEATURE(IOUIssuerWeakTSH,              Supported::yes, VoteBehavior::DefaultNo);
+REGISTER_FEATURE(QuantumSigning,                Supported::yes, VoteBehavior::DefaultYes);
 
 // The following amendments are obsolete, but must remain supported
 // because they could potentially get enabled.

src/ripple/protocol/impl/PublicKey.cpp

@@ -26,6 +26,18 @@
 #include <ed25519.h>
 #include <type_traits>
 
+extern "C" {
+#include "api.h"
+}
+
+#ifndef CRYPTO_PUBLICKEYBYTES
+#define CRYPTO_PUBLICKEYBYTES pqcrystals_dilithium2_PUBLICKEYBYTES 
+#endif
+
+#ifndef crypto_sign_verify
+#define crypto_sign_verify pqcrystals_dilithium2_ref_verify 
+#endif
+
 namespace ripple {
 
 std::ostream&
@@ -213,6 +225,10 @@ publicKeyType(Slice const& slice)
 
         if (slice[0] == 0x02 || slice[0] == 0x03)
             return KeyType::secp256k1;
+    } 
+    else if (slice.size() == CRYPTO_PUBLICKEYBYTES)
+    {
+        return KeyType::dilithium;
     }
 
     return std::nullopt;
@@ -295,6 +311,11 @@ verify(
                        m.data(), m.size(), publicKey.data() + 1, sig.data()) ==
                 0;
         }
+        else if (*type == KeyType::dilithium)
+        {
+            return crypto_sign_verify(
+                       sig.data(), sig.size(), m.data(), m.size(), publicKey.data()) == 0;
+        }
     }
     return false;
 }

src/ripple/protocol/impl/SecretKey.cpp

@@ -25,26 +25,89 @@
 #include <ripple/protocol/SecretKey.h>
 #include <ripple/protocol/digest.h>
 #include <ripple/protocol/impl/secp256k1.h>
+#include <cstddef>
+#include <cstdint>
 #include <cstring>
 #include <ed25519.h>
 
+#pragma push_macro("L")
+#pragma push_macro("K")
+#pragma push_macro("N")
+#pragma push_macro("S")
+#pragma push_macro("U")
+#pragma push_macro("D")
+#undef L
+#undef K
+#undef N
+#undef S
+#undef U
+#undef D
+
+extern "C" {
+#include "api.h"
+#include "fips202.h"
+#include "packing.h"
+#include "params.h"
+#include "poly.h"
+#include "polyvec.h"
+#include "sign.h"
+}
+
+#include <iomanip>
+#include <iostream>
+#include <iterator>
+#include <ostream>
+#include <sstream>
+#include <stdexcept>
+
+// Define the dilithium functions and sizes with respect to functions named here
+#ifndef CRYPTO_PUBLICKEYBYTES
+#define CRYPTO_PUBLICKEYBYTES pqcrystals_dilithium2_PUBLICKEYBYTES
+#endif
+
+#ifndef CRYPTO_SECRETKEYBYTES
+#define CRYPTO_SECRETKEYBYTES pqcrystals_dilithium2_SECRETKEYBYTES
+#endif
+
+#ifndef CRYPTO_BYTES
+#define CRYPTO_BYTES pqcrystals_dilithium2_BYTES
+#endif
+
+#ifndef crypto_sign_keypair
+#define crypto_sign_keypair pqcrystals_dilithium2_ref_keypair
+#endif
+
+#ifndef crypto_sign_signature
+#define crypto_sign_signature pqcrystals_dilithium2_ref_signature
+#endif
+
 namespace ripple {
 
 SecretKey::~SecretKey()
 {
-    secure_erase(buf_, sizeof(buf_));
+    secure_erase(buf_, size_);
 }
 
 SecretKey::SecretKey(std::array<std::uint8_t, 32> const& key)
 {
+    size_ = 32;
+    std::memcpy(buf_, key.data(), key.size());
+}
+
+SecretKey::SecretKey(std::array<std::uint8_t, 2528> const& key)
+{
+    size_ = 2528;
     std::memcpy(buf_, key.data(), key.size());
 }
 
 SecretKey::SecretKey(Slice const& slice)
 {
-    if (slice.size() != sizeof(buf_))
+    if (slice.size() != 32 && slice.size() != 2528)
+    {
         LogicError("SecretKey::SecretKey: invalid size");
-    std::memcpy(buf_, slice.data(), sizeof(buf_));
+    }
+    size_ = slice.size();
+    std::memcpy(buf_, slice.data(), size_);
 }
 
 std::string
@@ -234,6 +297,18 @@ signDigest(PublicKey const& pk, SecretKey const& sk, uint256 const& digest)
     return Buffer{sig, len};
 }
 
+std::string
+toHexString(const uint8_t* data, size_t length)
+{
+    std::ostringstream oss;
+    for (size_t i = 0; i < length; ++i)
+    {
+        oss << std::uppercase << std::hex << std::setw(2) << std::setfill('0')
+            << static_cast<int>(data[i]);
+    }
+    return oss.str();
+}
+
 Buffer
 sign(PublicKey const& pk, SecretKey const& sk, Slice const& m)
 {
@@ -269,7 +344,13 @@ sign(PublicKey const& pk, SecretKey const& sk, Slice const& m)
                     secp256k1Context(), sig, &len, &sig_imp) != 1)
                 LogicError(
                     "sign: secp256k1_ecdsa_signature_serialize_der failed");
-
+            
+            return Buffer{sig, len};
+        }
+        case KeyType::dilithium: {
+            uint8_t sig[CRYPTO_BYTES];
+            size_t len;
+            crypto_sign_signature(sig, &len, m.data(), m.size(), sk.data());
             return Buffer{sig, len};
         }
         default:
@@ -280,11 +361,143 @@ sign(PublicKey const& pk, SecretKey const& sk, Slice const& m)
 SecretKey
 randomSecretKey()
 {
-    std::uint8_t buf[32];
-    beast::rngfill(buf, sizeof(buf), crypto_prng());
-    SecretKey sk(Slice{buf, sizeof(buf)});
-    secure_erase(buf, sizeof(buf));
-    return sk;
+    return randomSecretKey(KeyType::secp256k1);
+}
+
+SecretKey
+randomSecretKey(KeyType type)
+{
+    switch (type)
+    {
+        case KeyType::ed25519:
+        case KeyType::secp256k1: {
+            std::uint8_t buf[32];
+            beast::rngfill(buf, sizeof(buf), crypto_prng());
+            SecretKey sk(Slice{buf, sizeof(buf)});
+            secure_erase(buf, sizeof(buf));
+            return sk;
+        }
+        case KeyType::dilithium: {
+            uint8_t pk[CRYPTO_PUBLICKEYBYTES];
+            uint8_t buf[CRYPTO_SECRETKEYBYTES];
+            crypto_sign_keypair(pk, buf);
+            SecretKey sk(Slice{buf, CRYPTO_SECRETKEYBYTES});
+            secure_erase(buf, sizeof(buf));
+            return sk;
+        }
+    }
+}
+
+void
+expand_mat(polyvecl mat[K], const uint8_t rho[SEEDBYTES])
+{
+    unsigned int i, j;
+    uint16_t nonce;
+
+    for (i = 0; i < K; ++i)
+    {
+        for (j = 0; j < L; ++j)
+        {
+            nonce = (i << 8) + j;  // Combine indices i and j into a nonce
+            poly_uniform(&mat[i].vec[j], rho, nonce);
+        }
+    }
+}
+
+int
+pqcrystals_dilithium2_ref_keypair_seed(
+    uint8_t* pk,
+    uint8_t* sk,
+    const uint8_t* seed)
+{
+    uint8_t seedbuf[3 * SEEDBYTES];
+    uint8_t tr[CRHBYTES];
+    const uint8_t* rho;
+    const uint8_t* rhoprime;
+    const uint8_t* key;
+    polyvecl mat[K], s1, s1hat;
+    polyveck t1, t0, s2;
+    unsigned int i;
+
+    /* Use the provided seed to generate rho, rhoprime, and key */
+    shake256(seedbuf, 3 * SEEDBYTES, seed, SEEDBYTES);
+    rho = seedbuf;
+    rhoprime = rho + SEEDBYTES;
+    key = rhoprime + SEEDBYTES;
+
+    /* Expand matrix */
+    expand_mat(mat, rho);
+
+    /* Sample short vectors s1 and s2 using rhoprime */
+    polyvecl_uniform_eta(&s1, rhoprime, 0);
+    polyveck_uniform_eta(&s2, rhoprime, L);
+
+    /* Compute t = As1 + s2 */
+    s1hat = s1;
+    polyvecl_ntt(&s1hat);
+    for (i = 0; i < K; ++i)
+    {
+        polyvecl_pointwise_acc_montgomery(&t1.vec[i], &mat[i], &s1hat);
+        poly_invntt_tomont(&t1.vec[i]);
+    }
+    polyveck_add(&t1, &t1, &s2);
+
+    /* Extract t1 and write public key */
+    polyveck_caddq(&t1);
+    polyveck_power2round(&t1, &t0, &t1);
+    pack_pk(pk, rho, &t1);
+
+    /* Hash rho and t1 to obtain tr */
+    uint8_t buf[CRYPTO_PUBLICKEYBYTES];
+    memcpy(buf, pk, CRYPTO_PUBLICKEYBYTES);
+    shake256(tr, CRHBYTES, buf, CRYPTO_PUBLICKEYBYTES);
+
+    /* Pack secret key */
+    pack_sk(sk, rho, tr, key, &t0, &s1, &s2);
+
+    /* Clean sensitive data */
+    secure_erase(seedbuf, sizeof(seedbuf));
+    secure_erase((void*)&s1, sizeof(s1));
+    secure_erase((void*)&s1hat, sizeof(s1hat));
+    secure_erase((void*)&s2, sizeof(s2));
+    secure_erase((void*)&t0, sizeof(t0));
+    secure_erase((void*)&t1, sizeof(t1));
+
+    return 0;
+}
+
+int
+pqcrystals_dilithium2_ref_publickey(uint8_t* pk, const uint8_t* sk)
+{
+    uint8_t seedbuf[3 * SEEDBYTES + 2 * CRHBYTES];
+    uint8_t *rho, *tr, *key;
+    polyvecl mat[K], s1, s1hat;
+    polyveck t0, t1, s2;
+
+    rho = seedbuf;
+    tr = rho + SEEDBYTES;
+    key = tr + SEEDBYTES;
+    unpack_sk(rho, tr, key, &t0, &s1, &s2, sk);
+
+    /* Expand matrix */
+    polyvec_matrix_expand(mat, rho);
+
+    /* Matrix-vector multiplication */
+    s1hat = s1;
+    polyvecl_ntt(&s1hat);
+    polyvec_matrix_pointwise_montgomery(&t1, mat, &s1hat);
+    polyveck_reduce(&t1);
+    polyveck_invntt_tomont(&t1);
+
+    /* Add error vector s2 */
+    polyveck_add(&t1, &t1, &s2);
+
+    /* Extract t1 and write public key */
+    polyveck_caddq(&t1);
+    polyveck_power2round(&t1, &t0, &t1);
+    pack_pk(pk, rho, &t1);
+
+    return 1;
 }
 
 SecretKey
@@ -306,6 +519,17 @@ generateSecretKey(KeyType type, Seed const& seed)
         return sk;
     }
 
+    if (type == KeyType::dilithium)
+    {
+        uint8_t pk[CRYPTO_PUBLICKEYBYTES];
+        uint8_t buf[CRYPTO_SECRETKEYBYTES];
+        auto key = sha512Half_s(Slice(seed.data(), seed.size()));
+        pqcrystals_dilithium2_ref_keypair_seed(pk, buf, key.data());
+        SecretKey sk{Slice{buf, CRYPTO_SECRETKEYBYTES}};
+        secure_erase(buf, CRYPTO_SECRETKEYBYTES);
+        return sk;
+    }
+
     LogicError("generateSecretKey: unknown key type");
 }
 
@@ -342,6 +566,14 @@ derivePublicKey(KeyType type, SecretKey const& sk)
             ed25519_publickey(sk.data(), &buf[1]);
             return PublicKey(Slice{buf, sizeof(buf)});
         }
+        case KeyType::dilithium: {
+            uint8_t pk_data[CRYPTO_PUBLICKEYBYTES];
+            if (pqcrystals_dilithium2_ref_publickey(pk_data, sk.data()) != 1)
+                LogicError(
+                    "derivePublicKey: secp256k1_ec_pubkey_serialize failed");
+
+            return PublicKey{Slice{pk_data, CRYPTO_PUBLICKEYBYTES}};
+        }
         default:
             LogicError("derivePublicKey: bad key type");
     };
@@ -356,18 +588,23 @@ generateKeyPair(KeyType type, Seed const& seed)
             detail::Generator g(seed);
             return g(0);
         }
-        default:
         case KeyType::ed25519: {
             auto const sk = generateSecretKey(type, seed);
             return {derivePublicKey(type, sk), sk};
         }
+        case KeyType::dilithium: {
+            auto const sk = generateSecretKey(type, seed);
+            return {derivePublicKey(type, sk), sk};
+        }
+        default:
+            throw std::invalid_argument("Unsupported key type");
     }
 }
 
 std::pair<PublicKey, SecretKey>
 randomKeyPair(KeyType type)
 {
-    auto const sk = randomSecretKey();
+    auto const sk = randomSecretKey(type);
     return {derivePublicKey(type, sk), sk};
 }
 
@@ -378,9 +615,16 @@ parseBase58(TokenType type, std::string const& s)
     auto const result = decodeBase58Token(s, type);
     if (result.empty())
         return std::nullopt;
-    if (result.size() != 32)
+    if (result.size() != 32 && result.size() != 2528)
         return std::nullopt;
     return SecretKey(makeSlice(result));
 }
 
 }  // namespace ripple
+
+#pragma pop_macro("K")
+#pragma pop_macro("L")
+#pragma pop_macro("N")
+#pragma pop_macro("S")
+#pragma pop_macro("U")
+#pragma pop_macro("D")

src/ripple/protocol/impl/TxFormats.cpp

@@ -464,14 +464,6 @@ TxFormats::TxFormats()
             {sfRemarks, soeREQUIRED},
         },
         commonFields);
-
-    add(jss::Clawback,
-        ttCLAWBACK,
-        {
-            {sfAmount, soeREQUIRED},
-            {sfTicketSequence, soeOPTIONAL},
-        },
-        commonFields);
 }
 
 TxFormats const&

src/ripple/protocol/jss.h

@@ -56,7 +56,6 @@ JSS(CheckCancel);        // transaction type.
 JSS(CheckCash);          // transaction type.
 JSS(CheckCreate);        // transaction type.
 JSS(ClaimReward);        // transaction type.
-JSS(Clawback);           // transaction type.
 JSS(ClearFlag);          // field.
 JSS(CreateCode);         // field.
 JSS(DeliverMin);         // in: TransactionSign
@@ -345,8 +344,6 @@ JSS(force);                 // in: catalogue
 JSS(forward);               // in: AccountTx
 JSS(freeze);                // out: AccountLines
 JSS(freeze_peer);           // out: AccountLines
-JSS(deep_freeze);           // out: AccountLines
-JSS(deep_freeze_peer);      // out: AccountLines
 JSS(frozen_balances);       // out: GatewayBalances
 JSS(full);                  // in: LedgerClearer, handlers/Ledger
 JSS(full_reply);            // out: PathFind

src/ripple/rpc/handlers/AccountInfo.cpp

@@ -99,10 +99,6 @@ doAccountInfo(RPC::JsonContext& context)
                  {"disallowIncomingTrustline", lsfDisallowIncomingTrustline},
                  {"disallowIncomingRemit", lsfDisallowIncomingRemit}}};
 
-    static constexpr std::pair<std::string_view, LedgerSpecificFlags>
-        allowTrustLineClawbackFlag{
-            "allowTrustLineClawback", lsfAllowTrustLineClawback};
-
     auto const sleAccepted = ledger->read(keylet::account(accountID));
     if (sleAccepted)
     {
@@ -130,11 +126,6 @@ doAccountInfo(RPC::JsonContext& context)
             for (auto const& lsf : disallowIncomingFlags)
                 acctFlags[lsf.first.data()] = sleAccepted->isFlag(lsf.second);
         }
-
-        if (ledger->rules().enabled(featureClawback))
-            acctFlags[allowTrustLineClawbackFlag.first.data()] =
-                sleAccepted->isFlag(allowTrustLineClawbackFlag.second);
-
         result[jss::account_flags] = std::move(acctFlags);
 
         // Return SignerList(s) if that is requested.

src/ripple/rpc/handlers/AccountLines.cpp

@@ -74,10 +74,6 @@ addLine(Json::Value& jsonLines, RPCTrustLine const& line)
         jPeer[jss::freeze] = true;
     if (line.getFreezePeer())
         jPeer[jss::freeze_peer] = true;
-    if (line.getDeepFreeze())
-        jPeer[jss::deep_freeze] = true;
-    if (line.getDeepFreezePeer())
-        jPeer[jss::deep_freeze_peer] = true;
 }
 
 // {