Merge pull request 'wownero rebase v0.11' (#462) from wowario/wownero:wow-v0.11 into master

Reviewed-on: https://git.wownero.com/wownero/wownero/pulls/462

.github/workflows/build.yml

@@ -27,10 +27,10 @@ jobs:
     env:
       CCACHE_TEMPDIR: /tmp/.ccache-temp
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v1
       with:
         submodules: recursive
-    - uses: actions/cache@v3
+    - uses: actions/cache@v2
       with:
         path: /Users/runner/Library/Caches/ccache
         key: ccache-${{ runner.os }}-build-${{ github.sha }}
@@ -51,15 +51,15 @@ jobs:
       run:
         shell: msys2 {0}
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v1
       with:
         submodules: recursive
-    - uses: actions/cache@v3
+    - uses: actions/cache@v2
       with:
         path: C:\Users\runneradmin\.ccache
         key: ccache-${{ runner.os }}-build-${{ github.sha }}
         restore-keys: ccache-${{ runner.os }}-build-
-    - uses: msys2/setup-msys2@v2
+    - uses: eine/setup-msys2@v2
       with:
         update: true
         install: mingw-w64-x86_64-toolchain make mingw-w64-x86_64-cmake mingw-w64-x86_64-ccache mingw-w64-x86_64-boost mingw-w64-x86_64-openssl mingw-w64-x86_64-zeromq mingw-w64-x86_64-libsodium mingw-w64-x86_64-hidapi mingw-w64-x86_64-protobuf-c mingw-w64-x86_64-libusb mingw-w64-x86_64-unbound git
@@ -79,10 +79,10 @@ jobs:
       matrix:
         os: [ubuntu-22.04, ubuntu-20.04]
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v1
       with:
         submodules: recursive
-    - uses: actions/cache@v3
+    - uses: actions/cache@v2
       with:
         path: ~/.ccache
         key: ccache-${{ runner.os }}-build-${{ matrix.os }}-${{ github.sha }}
@@ -105,10 +105,10 @@ jobs:
     env:
       CCACHE_TEMPDIR: /tmp/.ccache-temp
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v1
       with:
         submodules: recursive
-    - uses: actions/cache@v3
+    - uses: actions/cache@v2
       with:
         path: ~/.ccache
         key: ccache-${{ runner.os }}-libwallet-${{ github.sha }}
@@ -133,11 +133,11 @@ jobs:
     env:
       CCACHE_TEMPDIR: /tmp/.ccache-temp
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v1
       with:
         submodules: recursive
     - name: ccache
-      uses: actions/cache@v3
+      uses: actions/cache@v2
       with:
         path: ~/.ccache
         key: ccache-${{ runner.os }}-build-ubuntu-latest-${{ github.sha }}
@@ -151,7 +151,7 @@ jobs:
     - name: install monero dependencies
       run: ${{env.APT_INSTALL_LINUX}}
     - name: install Python dependencies
-      run: pip install requests psutil monotonic zmq deepdiff
+      run: pip install requests psutil monotonic zmq
     - name: tests
       env:
         CTEST_OUTPUT_ON_FAILURE: ON
@@ -167,9 +167,8 @@ jobs:
   source-archive:
     runs-on: ubuntu-20.04
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v1
       with:
-        fetch-depth: 0
         submodules: recursive
     - name: archive
       run: |
@@ -178,7 +177,7 @@ jobs:
         export OUTPUT="$VERSION.tar"
         echo "OUTPUT=$OUTPUT" >> $GITHUB_ENV
         /home/runner/.local/bin/git-archive-all --prefix "$VERSION/" --force-submodules "$OUTPUT"
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v2
       with:
         name: ${{ env.OUTPUT }}
         path: /home/runner/work/monero/monero/${{ env.OUTPUT }}

.github/workflows/depends.yml

@@ -57,20 +57,19 @@ jobs:
             packages: "clang-8 gperf cmake python3-zmq libdbus-1-dev libharfbuzz-dev"
     name: ${{ matrix.toolchain.name }}
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v1
       with:
-        fetch-depth: 0
         submodules: recursive
 # Most volatile cache
     - name: ccache
-      uses: actions/cache@v3
+      uses: actions/cache@v2
       with:
         path: ~/.ccache
         key: ccache-${{ matrix.toolchain.host }}-${{ github.sha }}
         restore-keys: ccache-${{ matrix.toolchain.host }}-
 # Less volatile cache
     - name: depends cache
-      uses: actions/cache@v3
+      uses: actions/cache@v2
       with:
         path: contrib/depends/built
         key: depends-${{ matrix.toolchain.host }}-${{ hashFiles('contrib/depends/packages/*') }}
@@ -79,7 +78,7 @@ jobs:
           depends-${{ matrix.toolchain.host }}-
 # Static cache
     - name: OSX SDK cache
-      uses: actions/cache@v3
+      uses: actions/cache@v2
       with:
         path: contrib/depends/sdk-sources
         key: sdk-${{ matrix.toolchain.host }}-${{ matrix.toolchain.osx_sdk }}
@@ -97,7 +96,7 @@ jobs:
       run: |
         ${{env.CCACHE_SETTINGS}}
         make depends target=${{ matrix.toolchain.host }} -j2
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v2
       if: ${{ matrix.toolchain.host == 'x86_64-w64-mingw32' || matrix.toolchain.host == 'x86_64-apple-darwin11' || matrix.toolchain.host == 'x86_64-unknown-linux-gnu' }}
       with:
         name: ${{ matrix.toolchain.name }}

.github/workflows/gitian.yml

@@ -42,7 +42,7 @@ jobs:
         echo \`\`\` >> $GITHUB_STEP_SUMMARY
         shasum -a256 * >> $GITHUB_STEP_SUMMARY
         echo \`\`\` >> $GITHUB_STEP_SUMMARY
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v3.1.0
       with:
         name: ${{ matrix.operating-system.name }}
         path: |

.gitmodules

@@ -1,12 +1,19 @@
+[submodule "external/miniupnp"]
+	path = external/miniupnp
+	url = https://github.com/miniupnp/miniupnp
+[submodule "external/rapidjson"]
+	path = external/rapidjson
+	url = https://github.com/Tencent/rapidjson
 [submodule "external/trezor-common"]
 	active = false
 	path = external/trezor-common
 	url = https://github.com/trezor/trezor-common.git
 [submodule "external/supercop"]
 	path = external/supercop
-	url = https://git.wownero.com/dsc/supercop.git
-    branch = cmake-rewrite
+	url = https://github.com/monero-project/supercop
+	branch = monero
 [submodule "external/randomwow"]
 	path = external/randomwow
-	url = https://git.wownero.com/dsc/randomwow.git
-    branch = cmake-rewrite
+	url = https://git.wownero.com/wownero/RandomWOW
+        branch = 1.1.10-wow
+

README.md

@@ -96,7 +96,7 @@ Dates are provided in the format YYYY-MM-DD.
 | -                             | 2020-06-28 | Hallucinogenic Hypnotoad  | v0.8.0.0                | v0.8.0.2                    | Dandelion++ support
 | 253,999                       | 2020-10-09 | Illiterate Illuminati  | v0.9.0.0                | v0.9.3.3                    | Dynamic coinbase unlock (up to 1 mo.), Deterministic unlock times, Enforce maximum coinbase amount, show_qr_code wallet command, CLSAG
 | 331,170                       | 2021-07-04 | Junkie Jeff  | v0.10.0.0               | v0.10.2.0                   | Bulletproofs+, Miner Block Header Signing, Vote by Block, Change coinbase unlock time to 1 day, Reset difficulty and switch back to Monero's difficulty algorithm
-| 514,000                       | 2023-04-01 | Kunty Karen  | v0.11.0.0               | v0.11.1.0                   | View tags, fee changes, adjusted dynamic block weight algorithm, multisig security fixes, RPC broadcast node donation sub-address, Limit tx_extra max size to ~1kb, 12-hour difficulty adjustment window
+| 514,000                       | 2023-04-01 | Kunty Karen  | v0.11.0.0               | v0.11.0.0                   | View tags, fee changes, adjusted dynamic block weight algorithm, multisig security fixes, RPC broadcast node donation sub-address, Limit tx_extra max size to ~1kb, 12-hour difficulty adjustment window
 
 X's indicate that these details have not been determined as of commit date.
 

cmake/CheckLinkerFlag.c

@@ -0,0 +1,14 @@
+#ifdef __CLASSIC_C__
+int main()
+{
+  int ac;
+  char* av[];
+#else
+int main(int ac, char* av[])
+{
+#endif
+  if (ac > 1000) {
+    return *av[0];
+  }
+  return 0;
+}

cmake/CheckLinkerFlag.cmake

@@ -0,0 +1,48 @@
+include(CheckCCompilerFlag)
+
+macro(CHECK_LINKER_FLAG flag VARIABLE)
+  if(NOT DEFINED "${VARIABLE}")
+    if(NOT CMAKE_REQUIRED_QUIET)
+      message(STATUS "Looking for ${flag} linker flag")
+    endif()
+
+    set(_cle_source ${CMAKE_SOURCE_DIR}/cmake/CheckLinkerFlag.c)
+
+    set(saved_CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
+    set(CMAKE_C_FLAGS "${flag}")
+    try_compile(${VARIABLE}
+      ${CMAKE_BINARY_DIR}
+      ${_cle_source}
+      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} ${flag}
+      CMAKE_FLAGS
+      "-DCMAKE_EXE_LINKER_FLAGS=${flag}"
+      OUTPUT_VARIABLE OUTPUT)
+    unset(_cle_source)
+    set(CMAKE_C_FLAGS ${saved_CMAKE_C_FLAGS})
+    unset(saved_CMAKE_C_FLAGS)
+
+    if ("${OUTPUT}" MATCHES "warning.*ignored")
+      set(${VARIABLE} 0)
+    endif()
+
+    if(${VARIABLE})
+      if(NOT CMAKE_REQUIRED_QUIET)
+        message(STATUS "Looking for ${flag} linker flag - found")
+      endif()
+      set(${VARIABLE} 1 CACHE INTERNAL "Have linker flag ${flag}")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        "Determining if the ${flag} linker flag is supported "
+        "passed with the following output:\n"
+        "${OUTPUT}\n\n")
+    else()
+      if(NOT CMAKE_REQUIRED_QUIET)
+        message(STATUS "Looking for ${flag} linker flag - not found")
+      endif()
+      set(${VARIABLE} "" CACHE INTERNAL "Have linker flag ${flag}")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Determining if the ${flag} linker flag is supported "
+        "failed with the following output:\n"
+        "${OUTPUT}\n\n")
+    endif()
+  endif()
+endmacro()

cmake/CheckTrezor.cmake

@@ -0,0 +1,181 @@
+OPTION(USE_DEVICE_TREZOR "Trezor support compilation" ON)
+OPTION(USE_DEVICE_TREZOR_LIBUSB "Trezor LibUSB compilation" ON)
+OPTION(USE_DEVICE_TREZOR_UDP_RELEASE "Trezor UdpTransport in release mode" OFF)
+OPTION(USE_DEVICE_TREZOR_DEBUG "Trezor Debugging enabled" OFF)
+OPTION(TREZOR_DEBUG "Main trezor debugging switch" OFF)
+
+# Helper function to fix cmake < 3.6.0 FindProtobuf variables
+function(_trezor_protobuf_fix_vars)
+    if(${CMAKE_VERSION} VERSION_LESS "3.6.0")
+        foreach(UPPER
+                PROTOBUF_SRC_ROOT_FOLDER
+                PROTOBUF_IMPORT_DIRS
+                PROTOBUF_DEBUG
+                PROTOBUF_LIBRARY
+                PROTOBUF_PROTOC_LIBRARY
+                PROTOBUF_INCLUDE_DIR
+                PROTOBUF_PROTOC_EXECUTABLE
+                PROTOBUF_LIBRARY_DEBUG
+                PROTOBUF_PROTOC_LIBRARY_DEBUG
+                PROTOBUF_LITE_LIBRARY
+                PROTOBUF_LITE_LIBRARY_DEBUG
+                )
+            if (DEFINED ${UPPER})
+                string(REPLACE "PROTOBUF_" "Protobuf_" Camel ${UPPER})
+                if (NOT DEFINED ${Camel})
+                    set(${Camel} ${${UPPER}} PARENT_SCOPE)
+                endif()
+            endif()
+        endforeach()
+    endif()
+endfunction()
+
+# Use Trezor master switch
+if (USE_DEVICE_TREZOR)
+    # Protobuf is required to build protobuf messages for Trezor
+    include(FindProtobuf OPTIONAL)
+    find_package(Protobuf)
+    _trezor_protobuf_fix_vars()
+
+    # Protobuf handling the cache variables set in docker.
+    if(NOT Protobuf_FOUND AND NOT Protobuf_LIBRARY AND NOT Protobuf_PROTOC_EXECUTABLE AND NOT Protobuf_INCLUDE_DIR)
+        message(STATUS "Could not find Protobuf")
+    elseif(NOT Protobuf_LIBRARY OR NOT EXISTS "${Protobuf_LIBRARY}")
+        message(STATUS "Protobuf library not found: ${Protobuf_LIBRARY}")
+        unset(Protobuf_FOUND)
+    elseif(NOT Protobuf_PROTOC_EXECUTABLE OR NOT EXISTS "${Protobuf_PROTOC_EXECUTABLE}")
+        message(STATUS "Protobuf executable not found: ${Protobuf_PROTOC_EXECUTABLE}")
+        unset(Protobuf_FOUND)
+    elseif(NOT Protobuf_INCLUDE_DIR OR NOT EXISTS "${Protobuf_INCLUDE_DIR}")
+        message(STATUS "Protobuf include dir not found: ${Protobuf_INCLUDE_DIR}")
+        unset(Protobuf_FOUND)
+    else()
+        message(STATUS "Protobuf lib: ${Protobuf_LIBRARY}, inc: ${Protobuf_INCLUDE_DIR}, protoc: ${Protobuf_PROTOC_EXECUTABLE}")
+        set(Protobuf_INCLUDE_DIRS ${Protobuf_INCLUDE_DIR})
+        set(Protobuf_FOUND 1)  # override found if all rquired info was provided by variables
+    endif()
+
+    if(TREZOR_DEBUG)
+        set(USE_DEVICE_TREZOR_DEBUG 1)
+    endif()
+
+    # Compile debugging support (for tests)
+    if (USE_DEVICE_TREZOR_DEBUG)
+        add_definitions(-DWITH_TREZOR_DEBUGGING=1)
+    endif()
+else()
+    message(STATUS "Trezor support disabled by USE_DEVICE_TREZOR")
+endif()
+
+if(Protobuf_FOUND AND USE_DEVICE_TREZOR)
+    if (NOT "$ENV{TREZOR_PYTHON}" STREQUAL "")
+        set(TREZOR_PYTHON "$ENV{TREZOR_PYTHON}" CACHE INTERNAL "Copied from environment variable TREZOR_PYTHON")
+    else()
+        find_package(Python QUIET COMPONENTS Interpreter)  # cmake 3.12+
+        if(Python_Interpreter_FOUND)
+            set(TREZOR_PYTHON "${Python_EXECUTABLE}")
+        endif()
+    endif()
+
+    if(NOT TREZOR_PYTHON)
+        find_package(PythonInterp)
+        if(PYTHONINTERP_FOUND AND PYTHON_EXECUTABLE)
+            set(TREZOR_PYTHON "${PYTHON_EXECUTABLE}")
+        endif()
+    endif()
+
+    if(NOT TREZOR_PYTHON)
+        message(STATUS "Trezor: Python not found")
+    endif()
+endif()
+
+# Protobuf compilation test
+if(Protobuf_FOUND AND USE_DEVICE_TREZOR AND TREZOR_PYTHON)
+    execute_process(COMMAND ${Protobuf_PROTOC_EXECUTABLE} -I "${CMAKE_CURRENT_LIST_DIR}" -I "${Protobuf_INCLUDE_DIR}" "${CMAKE_CURRENT_LIST_DIR}/test-protobuf.proto" --cpp_out ${CMAKE_BINARY_DIR} RESULT_VARIABLE RET OUTPUT_VARIABLE OUT ERROR_VARIABLE ERR)
+    if(RET)
+        message(STATUS "Protobuf test generation failed: ${OUT} ${ERR}")
+    endif()
+
+    try_compile(Protobuf_COMPILE_TEST_PASSED
+        "${CMAKE_BINARY_DIR}"
+        SOURCES
+        "${CMAKE_BINARY_DIR}/test-protobuf.pb.cc"
+        "${CMAKE_CURRENT_LIST_DIR}/test-protobuf.cpp"
+        CMAKE_FLAGS
+        "-DINCLUDE_DIRECTORIES=${Protobuf_INCLUDE_DIR};${CMAKE_BINARY_DIR}"
+        "-DCMAKE_CXX_STANDARD=11"
+        LINK_LIBRARIES ${Protobuf_LIBRARY}
+        OUTPUT_VARIABLE OUTPUT
+    )
+    if(NOT Protobuf_COMPILE_TEST_PASSED)
+        message(STATUS "Protobuf Compilation test failed: ${OUTPUT}.")
+    endif()
+endif()
+
+# Try to build protobuf messages
+if(Protobuf_FOUND AND USE_DEVICE_TREZOR AND TREZOR_PYTHON AND Protobuf_COMPILE_TEST_PASSED)
+    set(ENV{PROTOBUF_INCLUDE_DIRS} "${Protobuf_INCLUDE_DIR}")
+    set(ENV{PROTOBUF_PROTOC_EXECUTABLE} "${Protobuf_PROTOC_EXECUTABLE}")
+    set(TREZOR_PROTOBUF_PARAMS "")
+    if (USE_DEVICE_TREZOR_DEBUG)
+        set(TREZOR_PROTOBUF_PARAMS "--debug")
+    endif()
+    
+    execute_process(COMMAND ${TREZOR_PYTHON} tools/build_protob.py ${TREZOR_PROTOBUF_PARAMS} WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/../src/device_trezor/trezor RESULT_VARIABLE RET OUTPUT_VARIABLE OUT ERROR_VARIABLE ERR)
+    if(RET)
+        message(WARNING "Trezor protobuf messages could not be regenerated (err=${RET}, python ${PYTHON})."
+                "OUT: ${OUT}, ERR: ${ERR}."
+                "Please read src/device_trezor/trezor/tools/README.md")
+    else()
+        message(STATUS "Trezor protobuf messages regenerated out: \"${OUT}.\"")
+        set(DEVICE_TREZOR_READY 1)
+        add_definitions(-DDEVICE_TREZOR_READY=1)
+        add_definitions(-DPROTOBUF_INLINE_NOT_IN_HEADERS=0)
+
+        if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+            add_definitions(-DTREZOR_DEBUG=1)
+        endif()
+
+        if(USE_DEVICE_TREZOR_UDP_RELEASE)
+            add_definitions(-DUSE_DEVICE_TREZOR_UDP_RELEASE=1)
+        endif()
+
+        if (Protobuf_INCLUDE_DIR)
+            include_directories(${Protobuf_INCLUDE_DIR})
+        endif()
+
+        # LibUSB support, check for particular version
+        # Include support only if compilation test passes
+        if (USE_DEVICE_TREZOR_LIBUSB)
+            find_package(LibUSB)
+        endif()
+
+        if (LibUSB_COMPILE_TEST_PASSED)
+            add_definitions(-DHAVE_TREZOR_LIBUSB=1)
+            if(LibUSB_INCLUDE_DIRS)
+                include_directories(${LibUSB_INCLUDE_DIRS})
+            endif()
+        endif()
+
+        set(TREZOR_LIBUSB_LIBRARIES "")
+        if(LibUSB_COMPILE_TEST_PASSED)
+            list(APPEND TREZOR_LIBUSB_LIBRARIES ${LibUSB_LIBRARIES} ${LIBUSB_DEP_LINKER})
+            message(STATUS "Trezor compatible LibUSB found at: ${LibUSB_INCLUDE_DIRS}")
+        endif()
+
+        if (BUILD_GUI_DEPS)
+            set(TREZOR_DEP_LIBS "")
+            set(TREZOR_DEP_LINKER "")
+
+            if (Protobuf_LIBRARY)
+                list(APPEND TREZOR_DEP_LIBS ${Protobuf_LIBRARY})
+                string(APPEND TREZOR_DEP_LINKER " -lprotobuf")
+            endif()
+
+            if (TREZOR_LIBUSB_LIBRARIES)
+                list(APPEND TREZOR_DEP_LIBS ${TREZOR_LIBUSB_LIBRARIES})
+                string(APPEND TREZOR_DEP_LINKER " -lusb-1.0 ${LIBUSB_DEP_LINKER}")
+            endif()
+        endif()
+    endif()
+endif()

cmake/Doxygen.extra.css.in

@@ -0,0 +1,14 @@
+/* increase vertical space */
+#titlearea, #nav-path {
+    display: none;
+    height: 0px;
+}
+
+
+/* uncomment these lines for some extra vertical space */
+
+/*
+.tablist li {
+    line-height: 26px;
+}
+*/

cmake/FindLibunbound.cmake

@@ -1,104 +0,0 @@
-#[=======================================================================[.rst:
-FindLibunbound
---------------
-
-Find the Libunbound library
-
-Imported targets
-^^^^^^^^^^^^^^^^
-
-This module defines the following :prop_tgt:`IMPORTED` targets:
-
-``Libunbound::Libunbound``
-  The Libunbound library, if found.
-
-Result variables
-^^^^^^^^^^^^^^^^
-
-This module will set the following variables in your project:
-
-``Libunbound_FOUND``
-  If false, do not try to use Libunbound.
-``LIBUNBOUND_INCLUDE_DIR``
-  where to find libunbound headers.
-``LIBUNBOUND_LIBRARIES``
-  the libraries needed to use Libunbound.
-``LIBUNBOUND_VERSION``
-  the version of the Libunbound library found
-
-#]=======================================================================]
-
-find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-  pkg_check_modules(PkgLibunbound IMPORTED_TARGET GLOBAL QUIET libunbound)
-endif ()
-
-if (PkgLibunbound_FOUND)
-  set(LIBUNBOUND_INCLUDE_DIR ${PkgLibunbound_INCLUDE_DIRS} CACHE FILEPATH "libunbound include path")
-  set(LIBUNBOUND_LIBRARIES ${PkgLibunbound_LIBRARIES} CACHE STRING "libunbound libraries")
-  set(LIBUNBOUND_VERSION ${PkgLibunbound_VERSION})
-  add_library(Libunbound::Libunbound ALIAS PkgConfig::PkgLibunbound)
-  set(Libunbound_FOUND ON)
-else ()
-  find_path(LIBUNBOUND_INCLUDE_DIR unbound.h
-    HINTS
-    "${LIBUNBOUND_DIR}"
-    "${LIBUNBOUND_DIR}/include"
-  )
-
-  find_library(LIBUNBOUND_LIBRARY NAMES unbound
-    HINTS
-    "${LIBUNBOUND_DIR}"
-    "${LIBUNBOUND_DIR}/lib"
-  )
-
-  set(_LIBUNBOUND_LIBRARIES "")
-
-  if (UNIX)
-    find_package(Threads REQUIRED)
-    find_package(OpenSSL REQUIRED)
-
-    list(APPEND _LIBUNBOUND_LIBRARIES "${CMAKE_THREAD_LIBS_INIT}")
-    list(APPEND _LIBUNBOUND_LIBRARIES "${OPENSSL_LIBRARIES}")
-  endif()
-
-  if (LIBUNBOUND_INCLUDE_DIR AND LIBUNBOUND_LIBRARY)
-    if (NOT TARGET Libunbound::Libunbound)
-      add_library(Libunbound::Libunbound UNKNOWN IMPORTED)
-      set_target_properties(Libunbound::Libunbound PROPERTIES
-        INTERFACE_INCLUDE_DIRECTORIES "${LIBUNBOUND_INCLUDE_DIR}"
-        IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-        IMPORTED_LOCATION "${LIBUNBOUND_LIBRARY}"
-        )
-
-      if(UNIX AND TARGET Threads::Threads)
-        set_property(TARGET Libunbound::Libunbound APPEND PROPERTY
-          INTERFACE_LINK_LIBRARIES Threads::Threads)
-      endif ()
-      if(UNIX AND TARGET OpenSSL::SSL)
-        set_property(TARGET Libunbound::Libunbound APPEND PROPERTY
-          INTERFACE_LINK_LIBRARIES OpenSSL::SSL)
-      endif ()
-      if(UNIX AND TARGET OpenSSL::Crypto)
-        set_property(TARGET Libunbound::Libunbound APPEND PROPERTY
-          INTERFACE_LINK_LIBRARIES OpenSSL::Crypto)
-      endif ()
-    endif ()
-
-    if (NOT LIBUNBOUND_VERSION AND LIBUNBOUND_INCLUDE_DIR AND EXISTS "${LIBUNBOUND_INCLUDE_DIR}/unbound.h")
-      file(STRINGS "${LIBUNBOUND_INCLUDE_DIR}/unbound.h" LIBUNBOUND_H REGEX "^#define UNBOUND_VERSION_M[A-Z]+")
-      string(REGEX REPLACE "^.*MAJOR ([0-9]+).*MINOR ([0-9]+).*MICRO ([0-9]+).*$" "\\1.\\2.\\3" LIBUNBOUND_VERSION "${LIBUNBOUND_H}")
-    endif ()
-  endif ()
-
-  list(APPEND _LIBUNBOUND_LIBRARIES "${LIBUNBOUND_LIBRARY}")
-  set(LIBUNBOUND_LIBRARIES ${_LIBUNBOUND_LIBRARIES} CACHE STRING "libunbound libraries")
-
-  include(FindPackageHandleStandardArgs)
-  find_package_handle_standard_args(Libunbound
-    REQUIRED_VARS LIBUNBOUND_LIBRARIES LIBUNBOUND_INCLUDE_DIR
-    VERSION_VAR LIBUNBOUND_VERSION
-    )
-endif ()
-
-mark_as_advanced(LIBUNBOUND_INCLUDE_DIR LIBUNBOUND_LIBRARIES LIBUNBOUND_LIBRARY)

cmake/FindUnbound.cmake

@@ -0,0 +1,40 @@
+# Copyright (c) 2014-2022, The Monero Project
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without modification, are
+# permitted provided that the following conditions are met:
+# 
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+# 
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other
+#    materials provided with the distribution.
+# 
+# 3. Neither the name of the copyright holder nor the names of its contributors may be
+#    used to endorse or promote products derived from this software without specific
+#    prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+# THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+MESSAGE(STATUS "Looking for libunbound")
+
+FIND_PATH(UNBOUND_INCLUDE_DIR
+  NAMES unbound.h
+  PATH_SUFFIXES include/ include/unbound/
+  PATHS "${PROJECT_SOURCE_DIR}"
+  ${UNBOUND_ROOT}
+  $ENV{UNBOUND_ROOT}
+  /usr/local/
+  /usr/
+)
+
+find_library(UNBOUND_LIBRARIES unbound)

cmake/FindZMQ.cmake

@@ -1,17 +0,0 @@
-# - Try to find ZMQ
-# Once done this will define
-# ZMQ_FOUND - System has ZMQ
-# ZMQ_INCLUDE_DIRS - The ZMQ include directories
-# ZMQ_LIBRARIES - The libraries needed to use ZMQ
-# ZMQ_DEFINITIONS - Compiler switches required for using ZMQ
-
-find_path ( ZMQ_INCLUDE_DIR zmq.h )
-find_library ( ZMQ_LIBRARY NAMES zmq )
-
-set ( ZMQ_LIBRARIES ${ZMQ_LIBRARY} )
-set ( ZMQ_INCLUDE_DIRS ${ZMQ_INCLUDE_DIR} )
-
-include ( FindPackageHandleStandardArgs )
-# handle the QUIETLY and REQUIRED arguments and set ZMQ_FOUND to TRUE
-# if all listed variables are TRUE
-find_package_handle_standard_args ( ZMQ DEFAULT_MSG ZMQ_LIBRARY ZMQ_INCLUDE_DIR )

cmake/Findsodium.cmake

@@ -1,291 +0,0 @@
-# Written in 2016 by Henrik Steffen Gaßmann <henrik@gassmann.onl>
-#
-# To the extent possible under law, the author(s) have dedicated all copyright
-# and related and neighboring rights to this software to the public domain
-# worldwide. This software is distributed without any warranty.
-#
-# You should have received a copy of the CC0 Public Domain Dedication along with
-# this software. If not, see
-#
-# http://creativecommons.org/publicdomain/zero/1.0/
-#
-# ##############################################################################
-# Tries to find the local libsodium installation.
-#
-# On Windows the sodium_DIR environment variable is used as a default hint which
-# can be overridden by setting the corresponding cmake variable.
-#
-# Once done the following variables will be defined:
-#
-# sodium_FOUND sodium_INCLUDE_DIR sodium_LIBRARY_DEBUG sodium_LIBRARY_RELEASE
-# sodium_VERSION_STRING
-#
-# Furthermore an imported "sodium" target is created.
-#
-
-if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
-    set(_GCC_COMPATIBLE 1)
-endif()
-
-# static library option
-if(NOT DEFINED sodium_USE_STATIC_LIBS)
-    option(sodium_USE_STATIC_LIBS "enable to statically link against sodium" OFF)
-endif()
-if(NOT (sodium_USE_STATIC_LIBS EQUAL sodium_USE_STATIC_LIBS_LAST))
-    unset(sodium_LIBRARY CACHE)
-    unset(sodium_LIBRARY_DEBUG CACHE)
-    unset(sodium_LIBRARY_RELEASE CACHE)
-    unset(sodium_DLL_DEBUG CACHE)
-    unset(sodium_DLL_RELEASE CACHE)
-    set(sodium_USE_STATIC_LIBS_LAST
-            ${sodium_USE_STATIC_LIBS}
-            CACHE INTERNAL "internal change tracking variable")
-endif()
-
-# ##############################################################################
-# UNIX
-if(UNIX)
-    # import pkg-config
-    find_package(PkgConfig QUIET)
-    if(PKG_CONFIG_FOUND)
-        pkg_check_modules(sodium_PKG QUIET libsodium)
-    endif()
-
-    if(sodium_USE_STATIC_LIBS)
-        if(sodium_PKG_STATIC_LIBRARIES)
-            foreach(_libname ${sodium_PKG_STATIC_LIBRARIES})
-                if(NOT _libname MATCHES "^lib.*\\.a$") # ignore strings already ending
-                    # with .a
-                    list(INSERT sodium_PKG_STATIC_LIBRARIES 0 "lib${_libname}.a")
-                endif()
-            endforeach()
-            list(REMOVE_DUPLICATES sodium_PKG_STATIC_LIBRARIES)
-        else()
-            # if pkgconfig for libsodium doesn't provide static lib info, then
-            # override PKG_STATIC here..
-            set(sodium_PKG_STATIC_LIBRARIES libsodium.a)
-        endif()
-
-        set(XPREFIX sodium_PKG_STATIC)
-    else()
-        if(sodium_PKG_LIBRARIES STREQUAL "")
-            set(sodium_PKG_LIBRARIES sodium)
-        endif()
-
-        set(XPREFIX sodium_PKG)
-    endif()
-
-    find_path(sodium_INCLUDE_DIR sodium.h HINTS ${${XPREFIX}_INCLUDE_DIRS})
-    find_library(sodium_LIBRARY_DEBUG
-            NAMES ${${XPREFIX}_LIBRARIES}
-            HINTS ${${XPREFIX}_LIBRARY_DIRS})
-    find_library(sodium_LIBRARY_RELEASE
-            NAMES ${${XPREFIX}_LIBRARIES}
-            HINTS ${${XPREFIX}_LIBRARY_DIRS})
-
-    # ############################################################################
-    # Windows
-elseif(WIN32)
-    set(sodium_DIR "$ENV{sodium_DIR}" CACHE FILEPATH "sodium install directory")
-    mark_as_advanced(sodium_DIR)
-
-    find_path(sodium_INCLUDE_DIR sodium.h
-            HINTS ${sodium_DIR}
-            PATH_SUFFIXES include)
-
-    if(MSVC)
-        # detect target architecture
-        file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/arch.c" [=[
-            #if defined _M_IX86
-            #error ARCH_VALUE x86_32
-            #elif defined _M_X64
-            #error ARCH_VALUE x86_64
-            #endif
-            #error ARCH_VALUE unknown
-        ]=])
-        try_compile(_UNUSED_VAR "${CMAKE_CURRENT_BINARY_DIR}"
-                "${CMAKE_CURRENT_BINARY_DIR}/arch.c"
-                OUTPUT_VARIABLE _COMPILATION_LOG)
-        string(REGEX
-                REPLACE ".*ARCH_VALUE ([a-zA-Z0-9_]+).*"
-                "\\1"
-                _TARGET_ARCH
-                "${_COMPILATION_LOG}")
-
-        # construct library path
-        if(_TARGET_ARCH STREQUAL "x86_32")
-            string(APPEND _PLATFORM_PATH "Win32")
-        elseif(_TARGET_ARCH STREQUAL "x86_64")
-            string(APPEND _PLATFORM_PATH "x64")
-        else()
-            message(
-                    FATAL_ERROR
-                    "the ${_TARGET_ARCH} architecture is not supported by Findsodium.cmake."
-            )
-        endif()
-        string(APPEND _PLATFORM_PATH "/$$CONFIG$$")
-
-        if(MSVC_VERSION LESS 1900)
-            math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 60")
-        else()
-            math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 50")
-        endif()
-        string(APPEND _PLATFORM_PATH "/v${_VS_VERSION}")
-
-        if(sodium_USE_STATIC_LIBS)
-            string(APPEND _PLATFORM_PATH "/static")
-        else()
-            string(APPEND _PLATFORM_PATH "/dynamic")
-        endif()
-
-        string(REPLACE "$$CONFIG$$"
-                "Debug"
-                _DEBUG_PATH_SUFFIX
-                "${_PLATFORM_PATH}")
-        string(REPLACE "$$CONFIG$$"
-                "Release"
-                _RELEASE_PATH_SUFFIX
-                "${_PLATFORM_PATH}")
-
-        find_library(sodium_LIBRARY_DEBUG libsodium.lib
-                HINTS ${sodium_DIR}
-                PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX})
-        find_library(sodium_LIBRARY_RELEASE libsodium.lib
-                HINTS ${sodium_DIR}
-                PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX})
-        if(NOT sodium_USE_STATIC_LIBS)
-            set(CMAKE_FIND_LIBRARY_SUFFIXES_BCK ${CMAKE_FIND_LIBRARY_SUFFIXES})
-            set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll")
-            find_library(sodium_DLL_DEBUG libsodium
-                    HINTS ${sodium_DIR}
-                    PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX})
-            find_library(sodium_DLL_RELEASE libsodium
-                    HINTS ${sodium_DIR}
-                    PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX})
-            set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_BCK})
-        endif()
-
-    elseif(_GCC_COMPATIBLE)
-        if(sodium_USE_STATIC_LIBS)
-            find_library(sodium_LIBRARY_DEBUG libsodium.a
-                    HINTS ${sodium_DIR}
-                    PATH_SUFFIXES lib)
-            find_library(sodium_LIBRARY_RELEASE libsodium.a
-                    HINTS ${sodium_DIR}
-                    PATH_SUFFIXES lib)
-        else()
-            find_library(sodium_LIBRARY_DEBUG libsodium.dll.a
-                    HINTS ${sodium_DIR}
-                    PATH_SUFFIXES lib)
-            find_library(sodium_LIBRARY_RELEASE libsodium.dll.a
-                    HINTS ${sodium_DIR}
-                    PATH_SUFFIXES lib)
-
-            file(GLOB _DLL
-                    LIST_DIRECTORIES false
-                    RELATIVE "${sodium_DIR}/bin"
-                    "${sodium_DIR}/bin/libsodium*.dll")
-            find_library(sodium_DLL_DEBUG ${_DLL} libsodium
-                    HINTS ${sodium_DIR}
-                    PATH_SUFFIXES bin)
-            find_library(sodium_DLL_RELEASE ${_DLL} libsodium
-                    HINTS ${sodium_DIR}
-                    PATH_SUFFIXES bin)
-        endif()
-    else()
-        message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
-    endif()
-
-    # ############################################################################
-    # unsupported
-else()
-    message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
-endif()
-
-# ##############################################################################
-# common stuff
-
-# extract sodium version
-if(sodium_INCLUDE_DIR)
-    set(_VERSION_HEADER "${sodium_INCLUDE_DIR}/sodium/version.h")
-    if(EXISTS "${_VERSION_HEADER}")
-        file(READ "${_VERSION_HEADER}" _VERSION_HEADER_CONTENT)
-        string(REGEX
-                REPLACE ".*define[ \t]+SODIUM_VERSION_STRING[^\"]+\"([^\"]+)\".*"
-                "\\1"
-                sodium_VERSION_STRING
-                "${_VERSION_HEADER_CONTENT}")
-        set(sodium_VERSION_STRING "${sodium_VERSION_STRING}")
-    endif()
-endif()
-
-# communicate results
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(sodium
-        REQUIRED_VARS
-        sodium_LIBRARY_RELEASE
-        sodium_LIBRARY_DEBUG
-        sodium_INCLUDE_DIR
-        VERSION_VAR
-        sodium_VERSION_STRING)
-
-# mark file paths as advanced
-mark_as_advanced(sodium_INCLUDE_DIR)
-mark_as_advanced(sodium_LIBRARY_DEBUG)
-mark_as_advanced(sodium_LIBRARY_RELEASE)
-if(WIN32)
-    mark_as_advanced(sodium_DLL_DEBUG)
-    mark_as_advanced(sodium_DLL_RELEASE)
-endif()
-
-# create imported target
-if(sodium_USE_STATIC_LIBS)
-    set(_LIB_TYPE STATIC)
-else()
-    set(_LIB_TYPE SHARED)
-endif()
-add_library(sodium ${_LIB_TYPE} IMPORTED)
-
-set_target_properties(sodium
-        PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-        "${sodium_INCLUDE_DIR}"
-        IMPORTED_LINK_INTERFACE_LANGUAGES
-        "C")
-
-if(sodium_USE_STATIC_LIBS)
-    set_target_properties(sodium
-            PROPERTIES INTERFACE_COMPILE_DEFINITIONS
-            "SODIUM_STATIC"
-            IMPORTED_LOCATION
-            "${sodium_LIBRARY_RELEASE}"
-            IMPORTED_LOCATION_DEBUG
-            "${sodium_LIBRARY_DEBUG}")
-else()
-    if(UNIX)
-        set_target_properties(sodium
-                PROPERTIES IMPORTED_LOCATION
-                "${sodium_LIBRARY_RELEASE}"
-                IMPORTED_LOCATION_DEBUG
-                "${sodium_LIBRARY_DEBUG}")
-    elseif(WIN32)
-        set_target_properties(sodium
-                PROPERTIES IMPORTED_IMPLIB
-                "${sodium_LIBRARY_RELEASE}"
-                IMPORTED_IMPLIB_DEBUG
-                "${sodium_LIBRARY_DEBUG}")
-        if(NOT (sodium_DLL_DEBUG MATCHES ".*-NOTFOUND"))
-            set_target_properties(sodium
-                    PROPERTIES IMPORTED_LOCATION_DEBUG
-                    "${sodium_DLL_DEBUG}")
-        endif()
-        if(NOT (sodium_DLL_RELEASE MATCHES ".*-NOTFOUND"))
-            set_target_properties(sodium
-                    PROPERTIES IMPORTED_LOCATION_RELWITHDEBINFO
-                    "${sodium_DLL_RELEASE}"
-                    IMPORTED_LOCATION_MINSIZEREL
-                    "${sodium_DLL_RELEASE}"
-                    IMPORTED_LOCATION_RELEASE
-                    "${sodium_DLL_RELEASE}")
-        endif()
-    endif()
-endif()

cmake/MoneroConfig.cmake.in

@@ -1,51 +0,0 @@
-@PACKAGE_INIT@
-
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/modules/")
-include("${CMAKE_CURRENT_LIST_DIR}/MoneroTargets.cmake")
-
-find_package(Threads)
-find_package(Backtrace)
-find_package(PythonInterp)
-find_package(miniupnpc REQUIRED)
-find_package(ZMQ REQUIRED)
-
-find_package(OpenSSL REQUIRED)
-find_package(Boost 1.58 REQUIRED COMPONENTS system filesystem thread date_time chrono regex serialization program_options locale)
-find_package(Libunbound 1.16 REQUIRED)
-find_package(sodium REQUIRED)
-
-check_required_components(epee)
-check_required_components(easylogging)
-check_required_components(qrcodegen)
-check_required_components(lmdb)
-check_required_components(cncrypto)
-check_required_components(version)
-check_required_components(common)
-check_required_components(lmdb_lib)
-check_required_components(randomx)
-check_required_components(cryptonote_format_utils_basic)
-check_required_components(monero-crypto-amd64-64-24k)
-check_required_components(wallet-crypto)
-check_required_components(ringct)
-check_required_components(cryptonote_basic)
-check_required_components(ringct_basic)
-check_required_components(checkpoints)
-check_required_components(blockchain_db)
-check_required_components(cryptonote_core)
-check_required_components(cryptonote_protocol)
-check_required_components(mnemonics)
-check_required_components(device)
-check_required_components(blocks)
-check_required_components(wallet)
-check_required_components(wallet_api)
-check_required_components(rpc_base)
-check_required_components(rpc)
-check_required_components(rpc_pub)
-check_required_components(daemon_messages)
-check_required_components(daemon_rpc_server)
-check_required_components(net)
-check_required_components(p2p)
-check_required_components(multisig)
-check_required_components(hardforks)
-check_required_components(daemonizer)
-check_required_components(serialization)

cmake/SetClangTidy.cmake

@@ -0,0 +1,72 @@
+# Copyright (c) 2014-2022, The Monero Project
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification, are
+# permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other
+#    materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be
+#    used to endorse or promote products derived from this software without specific
+#    prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+# THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_CLANG_TIDY.html
+# This module sets the following variables:
+# CMAKE_C_CLANG_TIDY
+# CMAKE_CXX_CLANG_TIDY
+# when clang-tidy is found in PATH. Afterwards, the code is being linted by the tool.
+# The checks to be enabled can be manipulated with the variable MONERO_CLANG_TIDY_CHECKS
+
+macro (monero_clang_tidy LANGUAGE)
+	set(TOOL_NAME "clang-tidy")
+	set(MONERO_CLANG_TIDY_MIN_VERSION "3.6")
+	if(${CMAKE_VERSION} VERSION_LESS "${MONERO_CLANG_TIDY_MIN_VERSION}")
+		message(FATAL_ERROR "Sorry, ${TOOL_NAME} is available for CMake from version ${MONERO_CLANG_TIDY_MIN_VERSION}")
+	else()
+		message(STATUS "Trying to enable ${TOOL_NAME}")
+		find_program(MONERO_CLANG_BIN ${TOOL_NAME})
+		if(NOT MONERO_CLANG_BIN)
+			message(FATAL_ERROR "${TOOL_NAME} not found! Try running: sudo apt install ${TOOL_NAME}")
+		else()
+			message(STATUS "Found ${MONERO_CLANG_BIN}")
+			set(MONERO_CLANG_TIDY_CHECKS
+			    -header-filter=.; 	# By default the headers are excluded. This line enables them.
+			    -checks=*; 		# Currently enabling all checks
+			    # An example of selectively enabling checks:
+			    #-checks=bugprone-*,cppcoreguidelines-avoid-goto # Have to be in one line :(
+			)
+			# Current list of checks is avaibale under:
+			# https://clang.llvm.org/extra/clang-tidy/
+			if (${LANGUAGE} STREQUAL "C")
+				set(CMAKE_C_CLANG_TIDY
+					${MONERO_CLANG_BIN}; # Mind the semicolon
+					${MONERO_CLANG_TIDY_CHECKS}
+				)
+			elseif (${LANGUAGE} STREQUAL "CXX")
+				set(CMAKE_CXX_CLANG_TIDY
+					${MONERO_CLANG_BIN}; # Mind the semicolon
+					${MONERO_CLANG_TIDY_CHECKS}
+				)
+			else()
+				message(FATAL_ERROR "${TOOL_NAME}: Unsupported language: ${LANGUAGE}")
+			endif()
+		endif()
+	endif()
+endmacro()
+

cmake/functions.cmake

@@ -1,95 +0,0 @@
-include(GNUInstallDirs)
-include(CMakePackageConfigHelpers)
-
-function(monero_install_library targetName)
-    set(flags)
-    set(args)
-    set(listArgs INCLUDE_DIR HEADERS)
-    cmake_parse_arguments(arg "${flags}" "${args}" "${listArgs}" ${ARGN})
-
-    set(include_dir "${arg_INCLUDE_DIR}")
-    set(headers "${arg_HEADERS}")
-
-    if(NOT include_dir)
-        set(include_dir "${CMAKE_INSTALL_INCLUDEDIR}/monero/")
-    endif()
-
-    if(${targetName} STREQUAL "device")
-        message(STATUS "lol")
-    endif()
-
-    if(headers AND include_dir)
-        install_with_directory(DESTINATION ${include_dir} FILES ${headers})
-    endif()
-
-    install(TARGETS ${targetName} EXPORT MoneroTargets
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}/monero/
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/monero/
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}/monero/
-        INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/monero/)
-endfunction()
-
-function(print_cmake_summary)
-    message(STATUS "\n====================================== SUMMARY")
-    message(STATUS "Using C security hardening flags: ${C_SECURITY_FLAGS}")
-    message(STATUS "Using C++ security hardening flags: ${CXX_SECURITY_FLAGS}")
-    message(STATUS "Using linker security hardening flags: ${LD_SECURITY_FLAGS}")
-
-    if(GIT_FOUND)
-        execute_process(COMMAND git rev-parse "HEAD" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/wownero OUTPUT_VARIABLE _WOWNERO_HEAD OUTPUT_STRIP_TRAILING_WHITESPACE)
-        if(NOT _WOWNERO_HEAD STREQUAL WOWNERO_HEAD)
-            message(STATUS "[+] WOWNERO HEAD: ${_WOWNERO_HEAD} ... while CMake requested ${WOWNERO_HEAD}")
-        else()
-            message(STATUS "[+] WOWNERO HEAD: ${WOWNERO_HEAD}")
-        endif()
-    endif()
-
-    message(STATUS "[+] VERSION: ${VERSION}")
-    message(STATUS "[+] STATIC: ${STATIC}")
-    message(STATUS "[+] ARM: ${ARM}")
-    message(STATUS "[+] Android: ${ANDROID}")
-    message(STATUS "[+] iOS: ${IOS}")
-
-    message(STATUS "[+] OpenSSL")
-    message(STATUS "  - version: ${OPENSSL_VERSION}")
-    message(STATUS "  - dirs: ${OPENSSL_INCLUDE_DIR}")
-    message(STATUS "  - libs: ${OPENSSL_LIBRARIES}")
-
-    if(CAIRO_FOUND)
-        message(STATUS "[+] Cairo")
-        message(STATUS "  - version: ${CAIRO_VERSION}")
-        message(STATUS "  - dirs: ${CAIRO_INCLUDE_DIRS}")
-        message(STATUS "  - libs: ${CAIRO_LIBRARIES}")
-    endif()
-
-    if(XFIXES_FOUND)
-        message(STATUS "[+] Xfixes")
-        message(STATUS "  - dirs: ${XFIXES_INCLUDE_DIR}")
-        message(STATUS "  - libs: ${XFIXES_LIBRARY}")
-    endif()
-
-    message(STATUS "[+] Boost")
-    message(STATUS "  - version: ${Boost_VERSION}")
-    message(STATUS "  - dirs: ${Boost_INCLUDE_DIRS}")
-    message(STATUS "  - libs: ${Boost_LIBRARIES}")
-
-    if(Iconv_FOUND)
-        message(STATUS "[+] Iconv")
-        message(STATUS "  - version: ${Iconv_VERSION}")
-        message(STATUS "  - libs: ${Iconv_LIBRARIES}")
-        message(STATUS "  - dirs: ${Iconv_INCLUDE_DIRS}")
-    endif()
-
-endfunction()
-
-macro(install_with_directory)
-    set(optionsArgs "")
-    set(oneValueArgs "DESTINATION")
-    set(multiValueArgs "FILES")
-    cmake_parse_arguments(CAS "${optionsArgs}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
-
-    foreach(FILE ${CAS_FILES})
-        get_filename_component(DIR ${FILE} DIRECTORY)
-        INSTALL(FILES ${FILE} DESTINATION ${CAS_DESTINATION}/${DIR})
-    endforeach()
-endmacro(install_with_directory)

cmake/test-libusb-version.c

@@ -0,0 +1,52 @@
+// Copyright (c) 2014-2022, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <libusb.h>
+
+#define UNUSED(expr) (void)(expr)
+
+int main(int argc, char *argv[]) {
+  libusb_device **devs;
+  libusb_context *ctx = NULL;
+
+  int r = libusb_init(&ctx); UNUSED(r);
+  ssize_t cnt = libusb_get_device_list(ctx, &devs); UNUSED(cnt);
+
+  struct libusb_device_descriptor desc;
+  r = libusb_get_device_descriptor(devs[0], &desc); UNUSED(r);
+  uint8_t bus_id = libusb_get_bus_number(devs[0]); UNUSED(bus_id);
+  uint8_t addr = libusb_get_device_address(devs[0]); UNUSED(addr);
+
+  uint8_t tmp_path[16];
+  r = libusb_get_port_numbers(devs[0], tmp_path, sizeof(tmp_path));
+  UNUSED(r);
+  UNUSED(tmp_path);
+
+  libusb_free_device_list(devs, 1);
+  libusb_exit(ctx);
+}

cmake/test-protobuf.cpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2014-2022, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <string>
+#include <iostream>
+#include <google/protobuf/message.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "test-protobuf.pb.h"
+
+int main(int argc, char *argv[]) {
+  google::protobuf::UnknownFieldSet ufs;
+  ufs.ClearAndFreeMemory();
+
+  Success sc;
+  sc.set_message("test");
+  sc.SerializeToOstream(&std::cerr);
+  return 0;
+}

cmake/test-protobuf.proto

@@ -0,0 +1,7 @@
+syntax = "proto2";
+
+import "google/protobuf/descriptor.proto";
+
+message Success {
+    optional string message = 1;
+}

cmake/test-static-assert.c

@@ -0,0 +1,34 @@
+// Copyright (c) 2014-2022, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <assert.h>
+
+static_assert(1, "FAIL");
+int main(int argc, char *argv[]) {
+	return 0;
+}

cmake/test-static-assert.cpp

@@ -0,0 +1,34 @@
+// Copyright (c) 2014-2022, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <assert.h>
+
+static_assert(1, "FAIL");
+int main(int argc, char *argv[]) {
+	return 0;
+}

contrib/CMakeLists.txt

@@ -26,5 +26,6 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+monero_enable_coverage()
 add_subdirectory(epee)
 

contrib/depends/packages/openssl.mk

@@ -1,19 +1,20 @@
 package=openssl
-$(package)_version=3.0.11
+$(package)_version=1.1.1t
 $(package)_download_path=https://www.openssl.org/source
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=b3425d3bb4a2218d0697eb41f7fc0cdede016ed19ca49d168b78e8d947887f55
+$(package)_sha256_hash=8dee9b24bdb1dcbf0c3d1e9b02fb8f6bf22165e807f45adeb7c9677536859d3b
 
 define $(package)_set_vars
 $(package)_config_env=AR="$($(package)_ar)" ARFLAGS=$($(package)_arflags) RANLIB="$($(package)_ranlib)" CC="$($(package)_cc)"
-$(package)_config_env_android=ANDROID_NDK_ROOT="$(host_prefix)/native" PATH="$(host_prefix)/native/bin" CC=clang AR=ar RANLIB=ranlib
-$(package)_build_env_android=ANDROID_NDK_ROOT="$(host_prefix)/native"
-$(package)_config_opts=--prefix=$(host_prefix) --openssldir=$(host_prefix)/etc/openssl --libdir=$(host_prefix)/lib
+$(package)_config_env_android=ANDROID_NDK_HOME="$(host_prefix)/native" PATH="$(host_prefix)/native/bin" CC=clang AR=ar RANLIB=ranlib
+$(package)_build_env_android=ANDROID_NDK_HOME="$(host_prefix)/native"
+$(package)_config_opts=--prefix=$(host_prefix) --openssldir=$(host_prefix)/etc/openssl
 $(package)_config_opts+=no-capieng
 $(package)_config_opts+=no-dso
 $(package)_config_opts+=no-dtls1
 $(package)_config_opts+=no-ec_nistp_64_gcc_128
 $(package)_config_opts+=no-gost
+$(package)_config_opts+=no-heartbeats
 $(package)_config_opts+=no-md2
 $(package)_config_opts+=no-rc5
 $(package)_config_opts+=no-rdrand
@@ -21,8 +22,8 @@ $(package)_config_opts+=no-rfc3779
 $(package)_config_opts+=no-sctp
 $(package)_config_opts+=no-shared
 $(package)_config_opts+=no-ssl-trace
+$(package)_config_opts+=no-ssl2
 $(package)_config_opts+=no-ssl3
-$(package)_config_opts+=no-tests
 $(package)_config_opts+=no-unit-test
 $(package)_config_opts+=no-weak-ssl-ciphers
 $(package)_config_opts+=no-zlib
@@ -48,7 +49,7 @@ $(package)_config_opts_x86_64_freebsd=BSD-x86_64
 endef
 
 define $(package)_preprocess_cmds
-  sed -i.old 's|crypto ssl apps util tools fuzz providers doc|crypto ssl util tools providers|' build.info
+  sed -i.old 's|"engines", "apps", "test", "util", "tools", "fuzz"|"engines", "tools"|' Configure
 endef
 
 define $(package)_config_cmds

contrib/depends/packages/unbound.mk

@@ -11,7 +11,6 @@ define $(package)_set_vars
   $(package)_config_opts=--disable-shared --enable-static --without-pyunbound --prefix=$(host_prefix) --with-libexpat=$(host_prefix) --with-ssl=$(host_prefix) --with-libevent=no --without-pythonmodule --disable-flto --with-pthreads --with-libunbound-only
   $(package)_config_opts_linux=--with-pic
   $(package)_config_opts_w64=--enable-static-exe --sysconfdir=/etc --prefix=$(host_prefix) --target=$(host_prefix)
-  $(package)_config_opts_x86_64_darwin=ac_cv_func_SHA384_Init=yes
   $(package)_build_opts_mingw32=LDFLAGS="$($(package)_ldflags) -lpthread"
 endef
 

contrib/depends/toolchain.cmake.in

@@ -144,8 +144,8 @@ elseif(ARCHITECTURE STREQUAL "aarch64")
 endif()
 
 if(ARCHITECTURE STREQUAL "riscv64")
-    set(ARCH_ID "riscv64")
-    set(ARCH "rv64gc")
+    set(NO_AES ON)
+    set(ARCH "rv64imafdc")
 endif()
 
 if(ARCHITECTURE STREQUAL "i686")

contrib/epee/include/file_io_utils.h

@@ -29,7 +29,6 @@
 
 #include <string>
 #include <ctime>
-#include <cstdint>
 
 namespace epee
 {

contrib/epee/include/net/abstract_tcp_server2.inl

@@ -583,8 +583,11 @@ namespace net_utils
             break;
         }
       }
-      else {
+      else if (ec.value())
         terminate();
+      else {
+        cancel_timer();
+        on_interrupted();
       }
     };
     m_strand.post(

contrib/epee/include/net/http_client.h

@@ -245,18 +245,8 @@ namespace net_utils
 					}
 				}
 
-				// This magic var determines the maximum length for when copying the body message in
-				// memory is faster/more preferable than the round-trip time for one packet
-				constexpr size_t BODY_NO_COPY_CUTOFF = 128 * 1024; // ~262 KB or ~175 packets
-
-				// Maximum expected total headers bytes
-				constexpr size_t HEADER_RESERVE_SIZE = 2048;
-
-				const bool do_copy_body = body.size() <= BODY_NO_COPY_CUTOFF;
-				const size_t req_buff_cap = HEADER_RESERVE_SIZE + (do_copy_body ? body.size() : 0);
-
 				std::string req_buff{};
-				req_buff.reserve(req_buff_cap);
+				req_buff.reserve(2048);
 				req_buff.append(method.data(), method.size()).append(" ").append(uri.data(), uri.size()).append(" HTTP/1.1\r\n");
 				add_field(req_buff, "Host", m_host_buff);
 				add_field(req_buff, "Content-Length", std::to_string(body.size()));
@@ -265,7 +255,9 @@ namespace net_utils
 				for(const auto& field : additional_params)
 					add_field(req_buff, field);
 
+				for (unsigned sends = 0; sends < 2; ++sends)
 				{
+					const std::size_t initial_size = req_buff.size();
 					const auto auth = m_auth.get_auth_field(method, uri);
 					if (auth)
 						add_field(req_buff, *auth);
@@ -273,21 +265,11 @@ namespace net_utils
 					req_buff += "\r\n";
 					//--
 
-					if (do_copy_body) // small body
-					{
-						// Copy headers + body together and potentially send one fewer packet
-						req_buff.append(body.data(), body.size());
-						const bool res = m_net_client.send(req_buff, timeout);
-						CHECK_AND_ASSERT_MES(res, false, "HTTP_CLIENT: Failed to SEND");
-					}
-					else // large body
-					{
-						// Send headers and body seperately to avoid copying heavy body message
-						bool res = m_net_client.send(req_buff, timeout);
-						CHECK_AND_ASSERT_MES(res, false, "HTTP_CLIENT: Failed to SEND");
+					bool res = m_net_client.send(req_buff, timeout);
+					CHECK_AND_ASSERT_MES(res, false, "HTTP_CLIENT: Failed to SEND");
+					if(body.size())
 						res = m_net_client.send(body, timeout);
-						CHECK_AND_ASSERT_MES(res, false, "HTTP_CLIENT: Failed to SEND");
-					}
+					CHECK_AND_ASSERT_MES(res, false, "HTTP_CLIENT: Failed to SEND");
 
 					m_response_info.clear();
 					m_state = reciev_machine_state_header;
@@ -300,11 +282,19 @@ namespace net_utils
 						return true;
 					}
 
-					if (m_auth.handle_401(m_response_info) == http_client_auth::kParseFailure)
+					switch (m_auth.handle_401(m_response_info))
 					{
+					case http_client_auth::kSuccess:
+						break;
+					case http_client_auth::kBadPassword:
+                                                sends = 2;
+						break;
+					default:
+					case http_client_auth::kParseFailure:
 						LOG_ERROR("Bad server response for authentication");
 						return false;
 					}
+					req_buff.resize(initial_size); // rollback for new auth generation
 				}
 				LOG_ERROR("Client has incorrect username/password for server requiring authentication");
 				return false;

contrib/epee/include/span.h

@@ -147,16 +147,6 @@ namespace epee
     return {reinterpret_cast<const std::uint8_t*>(src.data()), src.size_bytes()}; 
   }
 
-  //! \return `span<std::uint8_t>` from a STL compatible `src`.
-  template<typename T>
-  constexpr span<std::uint8_t> to_mut_byte_span(T& src)
-  {
-    using value_type = typename T::value_type;
-    static_assert(!std::is_empty<value_type>(), "empty value types will not work -> sizeof == 1");
-    static_assert(!has_padding<value_type>(), "source value type may have padding");
-    return {reinterpret_cast<std::uint8_t*>(src.data()), src.size() * sizeof(value_type)};
-  }
-
   //! \return `span<const std::uint8_t>` which represents the bytes at `&src`.
   template<typename T>
   span<const std::uint8_t> as_byte_span(const T& src) noexcept

contrib/epee/include/storages/parserse_base_utils.h

@@ -30,7 +30,6 @@
 
 #include <boost/utility/string_ref_fwd.hpp>
 #include <string>
-#include <cstdint>
 
 namespace epee 
 {

contrib/epee/include/storages/portable_storage_from_bin.h

@@ -33,9 +33,6 @@
 #include "portable_storage_base.h"
 #include "portable_storage_bin_utils.h"
 
-#undef MONERO_DEFAULT_LOG_CATEGORY
-#define MONERO_DEFAULT_LOG_CATEGORY "serialization"
-
 #ifdef EPEE_PORTABLE_STORAGE_RECURSION_LIMIT
 #define EPEE_PORTABLE_STORAGE_RECURSION_LIMIT_INTERNAL EPEE_PORTABLE_STORAGE_RECURSION_LIMIT
 #else 

contrib/epee/include/storages/portable_storage_from_json.h

@@ -31,9 +31,6 @@
 #include "parserse_base_utils.h"
 #include "file_io_utils.h"
 
-#undef MONERO_DEFAULT_LOG_CATEGORY
-#define MONERO_DEFAULT_LOG_CATEGORY "serialization"
-
 #define EPEE_JSON_RECURSION_LIMIT_INTERNAL 100
 
 namespace epee

contrib/epee/src/CMakeLists.txt

@@ -27,37 +27,64 @@
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 set(EPEE_INCLUDE_DIR_BASE "${CMAKE_CURRENT_SOURCE_DIR}/../include")
-file(GLOB EPEE_HEADERS_PUBLIC "${EPEE_INCLUDE_DIR_BASE}/*.h")
 
-file(GLOB EPEE_SOURCES
-    "${CMAKE_CURRENT_SOURCE_DIR}/*.c"
-    "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
+# Add headers to the file list, to be able to search for them and autosave in IDEs.
+monero_find_all_headers(EPEE_HEADERS_PUBLIC "${EPEE_INCLUDE_DIR_BASE}")
+
+monero_add_library(epee byte_slice.cpp byte_stream.cpp hex.cpp abstract_http_client.cpp http_auth.cpp mlog.cpp net_helper.cpp net_utils_base.cpp string_tools.cpp parserse_base_utils.cpp
+    wipeable_string.cpp levin_base.cpp memwipe.c connection_basic.cpp network_throttle.cpp network_throttle-detail.cpp mlocker.cpp buffer.cpp net_ssl.cpp
+    int-util.cpp portable_storage.cpp
+    misc_language.cpp
+    file_io_utils.cpp
+    net_parse_helpers.cpp
+    http_base.cpp
+    ${EPEE_HEADERS_PUBLIC}
     )
 
-add_library(epee)
-target_sources(epee
-    PRIVATE
-        ${EPEE_SOURCES}
-    )
+if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW)))
+  monero_add_library(epee_readline readline_buffer.cpp)
+endif()
 
 set_property(SOURCE memwipe.c PROPERTY C_STANDARD 11)
 
+# Build and install libepee if we're building for GUI
+if (BUILD_GUI_DEPS)
+    if(IOS)
+        set(lib_folder lib-${ARCH})
+    else()
+        set(lib_folder lib)
+    endif()
+    install(TARGETS epee
+        ARCHIVE DESTINATION ${lib_folder})
+    if (USE_READLINE AND GNU_READLINE_FOUND)
+      install(TARGETS epee_readline
+          ARCHIVE DESTINATION ${lib_folder})
+    endif()
+endif()
+
 target_link_libraries(epee
   PUBLIC
     easylogging
-    Boost::chrono
-    Boost::filesystem
-    Boost::thread
-    Boost::regex
-    Boost::system
-    OpenSSL::SSL)
+    ${Boost_CHRONO_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_THREAD_LIBRARY}
+    ${Boost_REGEX_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY}
+    ${OPENSSL_LIBRARIES}
+  PRIVATE
+    ${EXTRA_LIBRARIES})
+
+if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW)))
+  target_link_libraries(epee_readline
+    PUBLIC
+      easylogging
+      ${Boost_SYSTEM_LIBRARY}
+    PRIVATE
+    ${GNU_READLINE_LIBRARY})
+endif()
 
 target_include_directories(epee
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/epee/>)
+  PUBLIC
+    "${EPEE_INCLUDE_DIR_BASE}"
+    "${OPENSSL_INCLUDE_DIR}")
 
-install(DIRECTORY ${EPEE_INCLUDE_DIR_BASE}/
-        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/monero/epee/")
-
-monero_install_library(epee)

contrib/epee/src/mlog.cpp

@@ -338,11 +338,21 @@ bool is_stdout_a_tty()
   return is_a_tty.load(std::memory_order_relaxed);
 }
 
+static bool is_nocolor()
+{
+  static const char *no_color_var = getenv("NO_COLOR");
+  static const bool no_color = no_color_var && *no_color_var; // apparently, NO_COLOR=0 means no color too (as per no-color.org)
+  return no_color;
+}
+
 void set_console_color(int color, bool bright)
 {
   if (!is_stdout_a_tty())
     return;
 
+  if (is_nocolor())
+    return;
+
   switch(color)
   {
   case console_color_default:
@@ -461,6 +471,9 @@ void reset_console_color() {
   if (!is_stdout_a_tty())
     return;
 
+  if (is_nocolor())
+    return;
+
 #ifdef WIN32
   HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
   SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);

contrib/epee/src/net_ssl.cpp

@@ -496,13 +496,6 @@ void ssl_options_t::configure(
   const std::string& host) const
 {
   socket.next_layer().set_option(boost::asio::ip::tcp::no_delay(true));
-  {
-    // in case server is doing "virtual" domains, set hostname
-    SSL* const ssl_ctx = socket.native_handle();
-    if (type == boost::asio::ssl::stream_base::client && !host.empty() && ssl_ctx)
-      SSL_set_tlsext_host_name(ssl_ctx, host.c_str());
-  }
-
 
   /* Using system-wide CA store for client verification is funky - there is
      no expected hostname for server to verify against. If server doesn't have
@@ -520,7 +513,11 @@ void ssl_options_t::configure(
   {
     socket.set_verify_mode(boost::asio::ssl::verify_peer | boost::asio::ssl::verify_fail_if_no_peer_cert);
 
-    
+    // in case server is doing "virtual" domains, set hostname
+    SSL* const ssl_ctx = socket.native_handle();
+    if (type == boost::asio::ssl::stream_base::client && !host.empty() && ssl_ctx)
+      SSL_set_tlsext_host_name(ssl_ctx, host.c_str());
+
     socket.set_verify_callback([&](const bool preverified, boost::asio::ssl::verify_context &ctx)
     {
       // preverified means it passed system or user CA check. System CA is never loaded

contrib/epee/src/readline_buffer.cpp

@@ -238,6 +238,10 @@ static char** attempted_completion(const char* text, int start, int end)
 
 static void install_line_handler()
 {
+#if RL_READLINE_VERSION >= 0x0801
+  rl_variable_bind("enable-bracketed-paste", "off");
+#endif
+
   rl_attempted_completion_function = attempted_completion;
   rl_callback_handler_install("", handle_line);
   stifle_history(500);

contrib/gitian/DOCKRUN.md

@@ -57,7 +57,7 @@ The dockrun.sh script will do everything to build the binaries. Just specify the
 version to build as its only argument, e.g.
 
 ```bash
-VERSION=v0.18.3.0
+VERSION=v0.18.2.0
 ./dockrun.sh $VERSION
 ```
 

contrib/gitian/README.md

@@ -133,7 +133,7 @@ Common setup part:
 su - gitianuser
 
 GH_USER=YOUR_GITHUB_USER_NAME
-VERSION=v0.18.3.0
+VERSION=v0.18.2.0
 ```
 
 Where `GH_USER` is your GitHub user name and `VERSION` is the version tag you want to build. 

external/CMakeLists.txt

@@ -28,11 +28,45 @@
 # 
 # Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
+
+# This is broken up into two parts: first we check for miniupnp, compile it if we can't
+# find it, and thereafter we check for libunbound, and compile it if we can't find it.
+# We always compile if we are building statically to reduce static dependency issues...
+# ...except for FreeBSD, because FreeBSD is a special case that doesn't play well with
+# others.
+
+find_package(Miniupnpc REQUIRED)
+
+message(STATUS "Using in-tree miniupnpc")
+set(UPNPC_NO_INSTALL TRUE CACHE BOOL "Disable miniupnp installation" FORCE)
+add_subdirectory(miniupnp/miniupnpc)
+set_property(TARGET libminiupnpc-static PROPERTY FOLDER "external")
+set_property(TARGET libminiupnpc-static PROPERTY POSITION_INDEPENDENT_CODE ON)
+if(MSVC)
+  set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -wd4244 -wd4267")
+elseif(NOT MSVC)
+  set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-undef -Wno-unused-result -Wno-unused-value")
+endif()
+if(CMAKE_SYSTEM_NAME MATCHES "NetBSD")
+	set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -D_NETBSD_SOURCE")
+endif()
+
+set(UPNP_LIBRARIES "libminiupnpc-static" PARENT_SCOPE)
+
+find_package(Unbound)
+
+if(NOT UNBOUND_INCLUDE_DIR)
+  die("Could not find libunbound")
+else()
+  message(STATUS "Found libunbound include (unbound.h) in ${UNBOUND_INCLUDE_DIR}")
+  if(UNBOUND_LIBRARIES)
+    message(STATUS "Found libunbound library")
+  else()
+    die("Found libunbound includes, but could not find libunbound library. Please make sure you have installed libunbound or libunbound-dev or the equivalent")
+  endif()
+endif()
+
 add_subdirectory(db_drivers)
 add_subdirectory(easylogging++)
 add_subdirectory(qrcodegen)
-add_subdirectory(randomwow)
-add_subdirectory(supercop)
-
-install(DIRECTORY boost
-        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/monero/")
+add_subdirectory(randomwow EXCLUDE_FROM_ALL)

external/db_drivers/liblmdb/CMakeLists.txt

@@ -26,40 +26,40 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
-set(lmdb_sources
-        mdb.c
-        midl.c)
-
-add_library(lmdb)
-target_sources(lmdb PRIVATE ${lmdb_sources})
-
-target_include_directories(lmdb
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-target_link_libraries(lmdb PRIVATE Threads::Threads)
-
 if(FREEBSD)
-  target_compile_definitions(lmdb PUBLIC MDB_DSYNC=O_SYNC)
+  add_definitions(-DMDB_DSYNC=O_SYNC)
 endif()
 
 if(ANDROID)
-  target_compile_definitions(lmdb PUBLIC ANDROID=1)
+  add_definitions("-DANDROID=1")
 endif()
 
+
+set (lmdb_sources
+mdb.c
+midl.c)
+
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
+
+add_library(lmdb
+  ${lmdb_sources})
+target_link_libraries(lmdb
+  PRIVATE
+    ${CMAKE_THREAD_LIBS_INIT})
 if(${ARCH_WIDTH} EQUAL 32)
-  target_compile_definitions(lmdb PUBLIC MDB_VL32=1)
+  target_compile_definitions(lmdb
+    PUBLIC -DMDB_VL32)
 endif()
 
-set_target_properties(lmdb PROPERTIES
-  POSITION_INDEPENDENT_CODE ON
-  CXX_STANDARD 11
-  CXX_STANDARD_REQUIRED ON
-  )
-
-monero_install_library(lmdb
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/lmdb/"
-        HEADERS "midl.h;lmdb.h")
+# GUI/libwallet install target
+if (BUILD_GUI_DEPS)
+    if(IOS)
+        set(lib_folder lib-${ARCH})
+    else()
+        set(lib_folder lib)
+    endif()
+    install(TARGETS lmdb
+        ARCHIVE DESTINATION ${lib_folder}
+        LIBRARY DESTINATION ${lib_folder})
+endif()
+set_property(TARGET lmdb APPEND PROPERTY COMPILE_FLAGS "-fPIC")

external/easylogging++/CMakeLists.txt

@@ -26,31 +26,43 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-set(EL_HEADERS
-    easylogging++.h
-    ea_config.h)
+cmake_minimum_required(VERSION 3.5)
 
-add_library(easylogging)
-target_sources(easylogging
-    PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR}/easylogging++.cc
-    )
+project(easylogging CXX)
 
-target_compile_definitions(easylogging PUBLIC
-        AUTO_INITIALIZE_EASYLOGGINGPP
-        )
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
 
-target_include_directories(easylogging
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/easylogging++/>
-        )
+monero_enable_coverage()
 
+find_package(Threads)
+find_package(Backtrace)
+
+monero_find_all_headers(EASYLOGGING_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}")
+
+add_library(easylogging
+  easylogging++.cc
+  ${EASYLOGGING_HEADERS}
+  )
+
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
+include_directories("${CMAKE_CURRENT_BINARY_DIR}")
 target_link_libraries(easylogging
-    PRIVATE
-        Threads::Threads
-        ${Backtrace_LIBRARIES})
+  PRIVATE
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${Backtrace_LIBRARIES})
+
+# GUI/libwallet install target
+if (BUILD_GUI_DEPS)
+    if(IOS)
+        set(lib_folder lib-${ARCH})
+    else()
+        set(lib_folder lib)
+    endif()
+    install(TARGETS easylogging
+        ARCHIVE DESTINATION ${lib_folder}
+        LIBRARY DESTINATION ${lib_folder})
+endif()
+set_property(TARGET easylogging APPEND PROPERTY COMPILE_FLAGS "-fPIC")
 
-monero_install_library(easylogging
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/easylogging++/"
-        HEADERS ${EL_HEADERS})

external/easylogging++/easylogging++.cc

@@ -149,6 +149,11 @@ static el::Color colorFromLevel(el::Level level)
 
 static void setConsoleColor(el::Color color, bool bright)
 {
+  static const char *no_color_var = getenv("NO_COLOR");
+  static const bool no_color = no_color_var && *no_color_var; // apparently, NO_COLOR=0 means no color too (as per no-color.org)
+  if (no_color)
+    return;
+
 #if ELPP_OS_WINDOWS
   HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
   switch (color)

external/qrcodegen/CMakeLists.txt

@@ -1,16 +1,8 @@
-add_library(qrcodegen)
+project(libqrcodegen)
 
-target_sources(qrcodegen
-    PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR}/QrCode.cpp
-    )
+add_library(qrcodegen STATIC QrCode.cpp)
+set_target_properties(qrcodegen PROPERTIES POSITION_INDEPENDENT_CODE ON)
+set_target_properties(qrcodegen PROPERTIES CXX_STANDARD 11)
 
-target_include_directories(qrcodegen
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-monero_install_library(qrcodegen
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/qrcodegen/"
-        HEADERS QrCode.hpp)
+target_include_directories(qrcodegen PUBLIC 
+    ${CMAKE_CURRENT_SOURCE_DIR})

src/CMakeLists.txt

@@ -28,23 +28,60 @@
 #
 # Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
-include(Version)
-add_library(version)
-target_sources(version
+if (WIN32 OR STATIC)
+  add_definitions(-DSTATICLIB)
+  # miniupnp changed their static define
+  add_definitions(-DMINIUPNP_STATICLIB)
+endif ()
+
+function (monero_private_headers group)
+  source_group("${group}\\Private"
+    FILES
+      ${ARGN})
+endfunction ()
+
+function (monero_install_headers subdir)
+  install(
+    FILES       ${ARGN}
+    DESTINATION "include/${subdir}"
+    COMPONENT   development)
+endfunction ()
+
+function (enable_stack_trace target)
+  if(STACK_TRACE)
+    set_property(TARGET ${target}
+      APPEND PROPERTY COMPILE_DEFINITIONS "STACK_TRACE")
+    if (STATIC)
+      set_property(TARGET "${target}"
+        APPEND PROPERTY LINK_FLAGS "-Wl,--wrap=__cxa_throw")
+    endif()
+  endif()
+endfunction()
+
+function (monero_add_executable name)
+  source_group("${name}"
+    FILES
+      ${ARGN})
+
+  add_executable("${name}"
+    ${ARGN})
+  target_link_libraries("${name}"
     PRIVATE
-        ${CMAKE_BINARY_DIR}/version.cpp
-    )
+      ${EXTRA_LIBRARIES})
+  set_property(TARGET "${name}"
+    PROPERTY
+      FOLDER "prog")
+  set_property(TARGET "${name}"
+    PROPERTY
+      RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+  enable_stack_trace("${name}")
+  
+  monero_set_target_no_relink("${name}")
+  monero_set_target_strip    ("${name}")
+endfunction ()
 
-target_include_directories(version
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/external>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-monero_install_library(version
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/"
-        HEADERS version.h)
+include(Version)
+monero_add_library(version SOURCES ${CMAKE_BINARY_DIR}/version.cpp DEPENDS genversion)
 
 add_subdirectory(common)
 add_subdirectory(crypto)
@@ -59,7 +96,6 @@ add_subdirectory(hardforks)
 add_subdirectory(blockchain_db)
 add_subdirectory(mnemonics)
 add_subdirectory(rpc)
-#add_subdirectory(test)
 if(NOT IOS)
   add_subdirectory(serialization)
 endif()
@@ -74,11 +110,16 @@ if(NOT IOS)
   add_subdirectory(daemon)
 endif()
 
+if(BUILD_DEBUG_UTILITIES)
+  add_subdirectory(debug_utilities)
+  add_subdirectory(blockchain_utilities)
+  add_subdirectory(gen_multisig)
+  add_subdirectory(gen_ssl_cert)
+endif()
+
 if(PER_BLOCK_CHECKPOINT)
   add_subdirectory(blocks)
 endif()
 
 add_subdirectory(device)
-
-install(FILES cryptonote_config.h
-        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/monero/")
+add_subdirectory(device_trezor)

src/blockchain_db/CMakeLists.txt

@@ -26,38 +26,28 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-file(GLOB BCDB_SOURCES *.cpp *.c *.cc)
-list(APPEND BCDB_SOURCES lmdb/db_lmdb.cpp)
+set(blockchain_db_sources
+  blockchain_db.cpp
+  lmdb/db_lmdb.cpp
+  )
 
-set(BCDB_HEADERS
-    blockchain_db.h
-    locked_txn.h
-    testdb.h
-    lmdb/db_lmdb.h)
+set(blockchain_db_headers)
 
-message(STATUS "${BCDB_HEADERS}")
+monero_find_all_headers(blockchain_db_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
 
-add_library(blockchain_db)
-target_sources(blockchain_db
-    PRIVATE
-        ${BCDB_SOURCES}
-    )
+monero_private_headers(blockchain_db
+  ${crypto_private_headers})
+monero_add_library(blockchain_db
+  ${blockchain_db_sources}
+  ${blockchain_db_headers}
+  ${blockchain_db_private_headers})
 target_link_libraries(blockchain_db
   PUBLIC
     common
     cncrypto
     ringct
-    lmdb
-    Boost::filesystem
-    Boost::thread)
-
-target_include_directories(blockchain_db
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../>
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/external>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-monero_install_library(blockchain_db
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/blockchain_db/"
-        HEADERS ${BCDB_HEADERS})
+    ${LMDB_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_THREAD_LIBRARY}
+  PRIVATE
+    ${EXTRA_LIBRARIES})

src/blockchain_utilities/CMakeLists.txt

@@ -158,7 +158,7 @@ endif()
 set_property(TARGET blockchain_import
 	PROPERTY
 	OUTPUT_NAME "wownero-blockchain-import")
-install(TARGETS blockchain_import DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS blockchain_import DESTINATION bin)
 
 monero_add_executable(blockchain_export
   ${blockchain_export_sources}
@@ -179,7 +179,7 @@ target_link_libraries(blockchain_export
 set_property(TARGET blockchain_export
 	PROPERTY
 	OUTPUT_NAME "wownero-blockchain-export")
-install(TARGETS blockchain_export DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS blockchain_export DESTINATION bin)
 
 monero_add_executable(blockchain_blackball
   ${blockchain_blackball_sources}
@@ -201,7 +201,7 @@ target_link_libraries(blockchain_blackball
 set_property(TARGET blockchain_blackball
 	PROPERTY
 	OUTPUT_NAME "wownero-blockchain-mark-spent-outputs")
-install(TARGETS blockchain_blackball DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS blockchain_blackball DESTINATION bin)
 
 
 monero_add_executable(blockchain_usage
@@ -223,7 +223,7 @@ target_link_libraries(blockchain_usage
 set_property(TARGET blockchain_usage
 	PROPERTY
 	OUTPUT_NAME "wownero-blockchain-usage")
-install(TARGETS blockchain_usage DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS blockchain_usage DESTINATION bin)
 
 monero_add_executable(blockchain_ancestry
   ${blockchain_ancestry_sources}
@@ -244,7 +244,7 @@ target_link_libraries(blockchain_ancestry
 set_property(TARGET blockchain_ancestry
 	PROPERTY
 	OUTPUT_NAME "wownero-blockchain-ancestry")
-install(TARGETS blockchain_ancestry DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS blockchain_ancestry DESTINATION bin)
 
 monero_add_executable(blockchain_depth
   ${blockchain_depth_sources}
@@ -265,7 +265,7 @@ target_link_libraries(blockchain_depth
 set_property(TARGET blockchain_depth
 	PROPERTY
 	OUTPUT_NAME "wownero-blockchain-depth")
-install(TARGETS blockchain_depth DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS blockchain_depth DESTINATION bin)
 
 monero_add_executable(blockchain_stats
   ${blockchain_stats_sources}
@@ -286,7 +286,7 @@ target_link_libraries(blockchain_stats
 set_property(TARGET blockchain_stats
 	PROPERTY
 	OUTPUT_NAME "wownero-blockchain-stats")
-install(TARGETS blockchain_stats DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS blockchain_stats DESTINATION bin)
 
 monero_add_executable(blockchain_prune_known_spent_data
   ${blockchain_prune_known_spent_data_sources}
@@ -308,7 +308,7 @@ target_link_libraries(blockchain_prune_known_spent_data
 set_property(TARGET blockchain_prune_known_spent_data
 	PROPERTY
 	OUTPUT_NAME "wownero-blockchain-prune-known-spent-data")
-install(TARGETS blockchain_prune_known_spent_data DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS blockchain_prune_known_spent_data DESTINATION bin)
 
 monero_add_executable(blockchain_prune
   ${blockchain_prune_sources}
@@ -317,7 +317,7 @@ monero_add_executable(blockchain_prune
 set_property(TARGET blockchain_prune
 	PROPERTY
 	OUTPUT_NAME "wownero-blockchain-prune")
-install(TARGETS blockchain_prune DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS blockchain_prune DESTINATION bin)
 
 target_link_libraries(blockchain_prune
   PRIVATE

src/blocks/CMakeLists.txt

@@ -57,20 +57,4 @@ foreach(BLOB_NAME checkpoints)
     )
 endforeach()
 
-add_library(blocks)
-target_sources(blocks
-    PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR}/blocks.cpp
-        ${GENERATED_SOURCES}
-    )
-
-target_include_directories(blocks
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/contrib/epee/include>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-monero_install_library(blocks
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/blocks/"
-        HEADERS blocks.h)
+monero_add_library(blocks blocks.cpp ${GENERATED_SOURCES})

src/checkpoints/CMakeLists.txt

@@ -26,28 +26,38 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-add_library(checkpoints)
-target_sources(checkpoints
-    PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR}/checkpoints.cpp
-    )
+if(APPLE)
+  if(DEPENDS)
+    list(APPEND EXTRA_LIBRARIES "-framework Foundation -framework ApplicationServices -framework AppKit -framework IOKit")
+  else()
+    find_library(IOKIT_LIBRARY IOKit)
+    mark_as_advanced(IOKIT_LIBRARY)
+    list(APPEND EXTRA_LIBRARIES ${IOKIT_LIBRARY})
+  endif()
+endif()
 
-target_link_libraries(checkpoints PUBLIC
+set(checkpoints_sources
+  checkpoints.cpp)
+
+set(checkpoints_headers)
+
+monero_find_all_headers(checkpoints_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
+
+monero_private_headers(checkpoints
+  ${checkpoints_private_headers})
+monero_add_library(checkpoints
+  ${checkpoints_sources}
+  ${checkpoints_headers}
+  ${checkpoints_private_headers})
+target_link_libraries(checkpoints
+  PUBLIC
     common
     cncrypto
-    Boost::date_time
-    Boost::program_options
-    Boost::serialization
-    Boost::filesystem
-    Boost::system
-    Boost::thread)
-
-target_include_directories(checkpoints
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-monero_install_library(checkpoints
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/checkpoints/"
-        HEADERS checkpoints.h)
+    ${Boost_DATE_TIME_LIBRARY}
+    ${Boost_PROGRAM_OPTIONS_LIBRARY}
+    ${Boost_SERIALIZATION_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY}
+    ${Boost_THREAD_LIBRARY}
+  PRIVATE
+    ${EXTRA_LIBRARIES})

src/checkpoints/checkpoints.cpp

@@ -235,11 +235,6 @@ namespace cryptonote
     ADD_CHECKPOINT2(497100,  "2c4c70ac1ada94151f19d67ccf1aa4e846e6067f49f67c85cc03f78e768ea42b", "0x116906bc97a751");
     ADD_CHECKPOINT2(500000,  "f4f771261b8c13cd83a9d8fa22e3cfe988564ad4b57dd90e79d5c0e77d61cf6a", "0x1185e7f2357a03");
     ADD_CHECKPOINT2(503500,  "776f36a17056c3e22bbfb51d5aeabb58000731e9ad549f0f2f8ad1e1bcedf312", "0x11a4884467f53d");
-    ADD_CHECKPOINT2(509900,  "59520faa272fc68e0426c827a38b21cdc1df8f5a37c5fdcbbe00350fece5f3ae", "0x11dc780bd1b580");
-    ADD_CHECKPOINT2(514000,  "1569e712750f19e57aee3f73cc3091a0eea392740bd396ad3570bc96e0e6ffb5", "0x11fff58abe0a82"); //Hard fork to v20
-    ADD_CHECKPOINT2(516700,  "0443c47c5a4e344c3f68a491a3b2f6b78a769cdf9076249c93f187ececf9cc7c", "0x12128a532a59a6");
-    ADD_CHECKPOINT2(522000,  "8c15ae514063bf05e7662ab33b86a4131aa89df0784ce3da7876c5339bc1de3d", "0x123d9c604a7be6");
-    ADD_CHECKPOINT2(566000,  "136e37f5f130dd2dc2d8d30e46e16d74377cb834b7c5be32cd09ee6ad402556c", "0x1318d703b1bff7");
     return true;
   }
 

src/common/CMakeLists.txt

@@ -26,77 +26,61 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-file(GLOB COMMON_SOURCES "*.cpp" "*.c")
-set(COMMON_HEADERS
-    aligned.h
-    apply_permutation.h
-    base58.h
-    boost_serialization_helper.h
-    combinator.h
-    command_line.h
-    common_fwd.h
-    data_cache.h
-    dns_utils.h
-    download.h
-    error.h
-    expect.h
-    http_connection.h
-    i18n.h
-    json_util.h
-    notify.h
-    password.h
-    perf_timer.h
-    pod-class.h
-    powerof.h
-    pruning.h
-    rpc_client.h
-    scoped_message_writer.h
-    sfinae_helpers.h
-    spawn.h
-    stack_trace.h
-    threadpool.h
-    timings.h
-    unordered_containers_boost_serialization.h
-    updates.h
-    utf8.h
-    util.h
-    varint.h)
+include_directories(SYSTEM ${OPENSSL_INCLUDE_DIR})
 
-add_library(common)
-target_sources(common
-    PRIVATE
-        ${COMMON_SOURCES}
-    )
+set(common_sources
+  base58.cpp
+  command_line.cpp
+  dns_utils.cpp
+  download.cpp
+  error.cpp
+  expect.cpp
+  util.cpp
+  i18n.cpp
+  notify.cpp
+  password.cpp
+  perf_timer.cpp
+  pruning.cpp
+  spawn.cpp
+  threadpool.cpp
+  updates.cpp
+  aligned.c
+  timings.cc
+  combinator.cpp)
 
+if (STACK_TRACE)
+  list(APPEND common_sources stack_trace.cpp)
+endif()
+
+if (BACKCOMPAT)
+  list(APPEND common_sources compat/glibc_compat.cpp)
+endif()
+
+set(common_headers)
+
+monero_find_all_headers(common_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
+
+monero_private_headers(common
+  ${common_private_headers})
+monero_add_library(common
+  ${common_sources}
+  ${common_headers}
+  ${common_private_headers}
+  DEPENDS generate_translations_header)
 target_link_libraries(common
   PUBLIC
     cncrypto
-    easylogging
-    Libunbound::Libunbound
-    Boost::chrono
-    Boost::date_time
-    Boost::filesystem
-    Boost::thread
-    Boost::regex
-    Boost::system
+    ${UNBOUND_LIBRARIES}
+    ${LIBUNWIND_LIBRARIES}
+    ${Boost_DATE_TIME_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY}
+    ${Boost_THREAD_LIBRARY}
+    ${Boost_REGEX_LIBRARY}
+    ${Boost_CHRONO_LIBRARY}
   PRIVATE
-    OpenSSL::SSL
-    OpenSSL::Crypto)
+    ${OPENSSL_LIBRARIES}
+    ${EXTRA_LIBRARIES})
 
-target_include_directories(common
-        PRIVATE ${LIBUNBOUND_INCLUDE_DIR}
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../>
-        PRIVATE $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/translations>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-if(STATIC)
-    target_compile_definitions(common PUBLIC STATICLIB=1)
-endif()
-
-add_dependencies(common generate_translations_header)
-
-monero_install_library(common
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/common/"
-        HEADERS ${COMMON_HEADERS})
+#monero_install_headers(common
+#  ${common_headers})

src/common/combinator.h

@@ -34,7 +34,6 @@
 #include <iostream>
 #include <vector>
 #include <stdexcept>
-#include <cstdint>
 
 namespace tools {
 

src/common/compat/glibc_compat.cpp

@@ -0,0 +1,98 @@
+#include <cstddef>
+#include <cstdint>
+#include <strings.h>
+#include <string.h>
+#include <glob.h>
+#include <unistd.h>
+#include <fnmatch.h>
+
+#if defined(HAVE_SYS_SELECT_H)
+#include <sys/select.h>
+#endif
+
+// Prior to GLIBC_2.14, memcpy was aliased to memmove.
+extern "C" void* memmove(void* a, const void* b, size_t c);
+//extern "C" void* memset(void* a, int b, long unsigned int c);
+extern "C" void* memcpy(void* a, const void* b, size_t c)
+{
+    return memmove(a, b, c);
+}
+
+extern "C" void __chk_fail(void) __attribute__((__noreturn__));
+
+#if defined(__i386__) || defined(__arm__)
+
+extern "C" int64_t __udivmoddi4(uint64_t u, uint64_t v, uint64_t* rp);
+
+extern "C" int64_t __wrap___divmoddi4(int64_t u, int64_t v, int64_t* rp)
+{
+    int32_t c1 = 0, c2 = 0;
+    int64_t uu = u, vv = v;
+    int64_t w;
+    int64_t r;
+
+    if (uu < 0) {
+        c1 = ~c1, c2 = ~c2, uu = -uu;
+    }
+    if (vv < 0) {
+        c1 = ~c1, vv = -vv;
+    }
+
+    w = __udivmoddi4(uu, vv, (uint64_t*)&r);
+    if (c1)
+        w = -w;
+    if (c2)
+        r = -r;
+
+    *rp = r;
+    return w;
+}
+#endif
+
+/* glibc-internal users use __explicit_bzero_chk, and explicit_bzero
+   redirects to that.  */
+#undef explicit_bzero
+/* Set LEN bytes of S to 0.  The compiler will not delete a call to
+   this function, even if S is dead after the call.  */
+void
+explicit_bzero (void *s, size_t len)
+{
+  memset (s, '\0', len);
+  /* Compiler barrier.  */
+  asm volatile ("" ::: "memory");
+}
+
+// Redefine explicit_bzero_chk
+void
+__explicit_bzero_chk (void *dst, size_t len, size_t dstlen)
+{
+  /* Inline __memset_chk to avoid a PLT reference to __memset_chk.  */
+  if (__glibc_unlikely (dstlen < len))
+    __chk_fail ();
+  memset (dst, '\0', len);
+  /* Compiler barrier.  */
+  asm volatile ("" ::: "memory");
+}
+/* libc-internal references use the hidden
+   __explicit_bzero_chk_internal symbol.  This is necessary if
+   __explicit_bzero_chk is implemented as an IFUNC because some
+   targets do not support hidden references to IFUNC symbols.  */
+#define strong_alias (__explicit_bzero_chk, __explicit_bzero_chk_internal)
+
+#undef glob
+extern "C" int glob_old(const char * pattern, int flags, int (*errfunc) (const char *epath, int eerrno), glob_t *pglob);
+#ifdef __i386__
+__asm__(".symver glob_old,glob@GLIBC_2.0");
+#elif defined(__amd64__)
+__asm__(".symver glob_old,glob@GLIBC_2.2.5");
+#elif defined(__arm__)
+__asm(".symver glob_old,glob@GLIBC_2.4");
+#elif defined(__aarch64__)
+__asm__(".symver glob_old,glob@GLIBC_2.17");
+#endif
+
+extern "C" int __wrap_glob(const char * pattern, int flags, int (*errfunc) (const char *epath, int eerrno), glob_t *pglob)
+{
+    return glob_old(pattern, flags, errfunc, pglob);
+}
+

src/common/perf_timer.cpp

@@ -62,7 +62,7 @@ namespace tools
     while (1)
     {
       t1 = epee::misc_utils::get_ns_count();
-      if (t1 - t0 > 1*100000000) break; // work 0.1 seconds
+      if (t1 - t0 > 1*1000000000) break; // work one second
     }
 
     uint64_t r1 = get_tick_count();

src/common/stack_trace.cpp

@@ -31,7 +31,7 @@
 #else
 #define ELPP_FEATURE_CRASH_LOG 1
 #endif
-#include "easylogging++.h"
+#include "easylogging++/easylogging++.h"
 
 #include <stdexcept>
 #ifdef USE_UNWIND

src/common/util.cpp

@@ -882,6 +882,13 @@ std::string get_nix_version_display_string()
 
   bool is_local_address(const std::string &address)
   {
+    // always assume Tor/I2P addresses to be untrusted by default
+    if (is_privacy_preserving_network(address))
+    {
+      MDEBUG("Address '" << address << "' is Tor/I2P, non local");
+      return false;
+    }
+
     // extract host
     epee::net_utils::http::url_content u_c;
     if (!epee::net_utils::parse_url(address, u_c))
@@ -895,22 +902,20 @@ std::string get_nix_version_display_string()
       return false;
     }
 
-    if (u_c.host == "localhost" || boost::ends_with(u_c.host, ".localhost")) { // RFC 6761 (6.3)
-      MDEBUG("Address '" << address << "' is local");
-      return true;
-    }
-
-    boost::system::error_code ec;
-    const auto parsed_ip = boost::asio::ip::address::from_string(u_c.host, ec);
-    if (ec) {
-      MDEBUG("Failed to parse '" << address << "' as IP address: " << ec.message() << ". Considering it not local");
-      return false;
-    }
-
-    if (parsed_ip.is_loopback())
+    // resolve to IP
+    boost::asio::io_service io_service;
+    boost::asio::ip::tcp::resolver resolver(io_service);
+    boost::asio::ip::tcp::resolver::query query(u_c.host, "");
+    boost::asio::ip::tcp::resolver::iterator i = resolver.resolve(query);
+    while (i != boost::asio::ip::tcp::resolver::iterator())
     {
-      MDEBUG("Address '" << address << "' is local");
-      return true;
+      const boost::asio::ip::tcp::endpoint &ep = *i;
+      if (ep.address().is_loopback())
+      {
+        MDEBUG("Address '" << address << "' is local");
+        return true;
+      }
+      ++i;
     }
 
     MDEBUG("Address '" << address << "' is not local");

src/crypto/CMakeLists.txt

@@ -27,104 +27,76 @@
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 set(crypto_sources
-    aesb.c
-    blake256.c
-    chacha.c
-    crypto-ops-data.c
-    crypto-ops.c
-    crypto.cpp
-    groestl.c
-    hash-extra-blake.c
-    hash-extra-groestl.c
-    hash-extra-jh.c
-    hash-extra-skein.c
-    hash.c
-    hmac-keccak.c
-    jh.c
-    keccak.c
-    oaes_lib.c
-    random.c
-    skein.c
-    slow-hash.c
-    rx-slow-hash.c
-    CryptonightR_JIT.c
-    tree-hash.c)
+  aesb.c
+  blake256.c
+  chacha.c
+  crypto-ops-data.c
+  crypto-ops.c
+  crypto.cpp
+  groestl.c
+  hash-extra-blake.c
+  hash-extra-groestl.c
+  hash-extra-jh.c
+  hash-extra-skein.c
+  hash.c
+  hmac-keccak.c
+  jh.c
+  keccak.c
+  oaes_lib.c
+  random.c
+  skein.c
+  slow-hash.c
+  rx-slow-hash.c
+  CryptonightR_JIT.c
+  tree-hash.c)
 
-set(crypto_headers
-    CryptonightR_JIT.h
-    CryptonightR_template.h
-    blake256.h
-    c_threads.h
-    chacha.h
-    crypto-ops.h
-    crypto.h
-    duration.h
-    generic-ops.h
-    groestl.h
-    groestl_tables.h
-    hash-ops.h
-    hash.h
-    hmac-keccak.h
-    initializer.h
-    jh.h
-    keccak.h
-    oaes_config.h
-    oaes_lib.h
-    random.h
-    skein.h
-    skein_port.h
-    variant2_int_sqrt.h
-    variant4_random_math.h)
-
-message(STATUS "${crypto_headers}")
-
-if(NOT ARM)
-  list(APPEND crypto_sources CryptonightR_template.S)
+if(ARCH_ID STREQUAL "i386" OR ARCH_ID STREQUAL "x86_64" OR ARCH_ID STREQUAL "x86-64" OR ARCH_ID STREQUAL "amd64")
+list(APPEND crypto_sources CryptonightR_template.S)
 endif()
 
-add_library(cncrypto)
-target_sources(cncrypto
-    PRIVATE
-        ${crypto_sources}
-    )
+include_directories(${RANDOMX_INCLUDE})
 
+set(crypto_headers)
+
+monero_find_all_headers(crypto_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
+
+monero_private_headers(cncrypto
+  ${crypto_private_headers})
+monero_add_library(cncrypto
+  ${crypto_sources}
+  ${crypto_headers}
+  ${crypto_private_headers})
 target_link_libraries(cncrypto
   PUBLIC
     epee
     randomx
-    Boost::system
-    ${sodium_LIBRARY_RELEASE}
+    ${Boost_SYSTEM_LIBRARY}
+    ${SODIUM_LIBRARY}
   PRIVATE
-    OpenSSL::SSL
-    OpenSSL::Crypto)
+    ${EXTRA_LIBRARIES})
 
-target_include_directories(cncrypto
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        PUBLIC ${sodium_INCLUDE_DIR}
-        )
-
-if (ARM AND NO_OPTIMIZED_MULTIPLY_ON_ARM)
-  message(STATUS "Using generic C implementation for multiply")
-  set_property(SOURCE slow-hash.c
-    PROPERTY COMPILE_DEFINITIONS "NO_OPTIMIZED_MULTIPLY_ON_ARM")
+if (ARM)
+  option(NO_OPTIMIZED_MULTIPLY_ON_ARM
+	   "Compute multiply using generic C implementation instead of ARM ASM" OFF)
+  if(NO_OPTIMIZED_MULTIPLY_ON_ARM)
+    message(STATUS "Using generic C implementation for multiply")
+    set_property(SOURCE slow-hash.c
+      PROPERTY COMPILE_DEFINITIONS "NO_OPTIMIZED_MULTIPLY_ON_ARM")
+  endif()
 endif()
 
 # Because of the way Qt works on android with JNI, the code does not live in the main android thread
 # So this code runs with a 1 MB default stack size. 
 # This will force the use of the heap for the allocation of the scratchpad
 if (ANDROID OR IOS)
+  if( BUILD_GUI_DEPS )
     add_definitions(-DFORCE_USE_HEAP=1)
+  endif()
 endif()
 
 # cheat because cmake and ccache hate each other
-set_property(SOURCE CryptonightR_template.S PROPERTY LANGUAGE ASM)
+set_property(SOURCE CryptonightR_template.S PROPERTY LANGUAGE C)
 set_property(SOURCE CryptonightR_template.S PROPERTY XCODE_EXPLICIT_FILE_TYPE sourcecode.asm)
 
 # Must be done last, because it references libraries in this directory
 add_subdirectory(wallet)
-
-monero_install_library(cncrypto
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/crypto/"
-        HEADERS ${crypto_headers})

src/crypto/c_threads.h

@@ -42,11 +42,10 @@
 #define CTHR_RWLOCK_TRYLOCK_READ(x)	TryAcquireSRWLockShared(&x)
 
 #define CTHR_THREAD_TYPE	HANDLE
-#define CTHR_THREAD_RTYPE	unsigned __stdcall
-#define CTHR_THREAD_RETURN	_endthreadex(0); return 0;
-#define CTHR_THREAD_CREATE(thr, func, arg)	((thr = (HANDLE)_beginthreadex(0, 0, func, arg, 0, 0)) != 0L)
-#define CTHR_THREAD_JOIN(thr)			do { WaitForSingleObject(thr, INFINITE); CloseHandle(thr); } while(0)
-#define CTHR_THREAD_CLOSE(thr)			CloseHandle((HANDLE)thr);
+#define CTHR_THREAD_RTYPE	void
+#define CTHR_THREAD_RETURN	return
+#define CTHR_THREAD_CREATE(thr, func, arg)	((thr = (HANDLE)_beginthread(func, 0, arg)) != -1L)
+#define CTHR_THREAD_JOIN(thr)			WaitForSingleObject((HANDLE)thr, INFINITE)
 
 #else
 
@@ -65,6 +64,5 @@
 #define CTHR_THREAD_RETURN	return NULL
 #define CTHR_THREAD_CREATE(thr, func, arg)	(pthread_create(&thr, NULL, func, arg) == 0)
 #define CTHR_THREAD_JOIN(thr)			pthread_join(thr, NULL)
-#define CTHR_THREAD_CLOSE(thr)
 
 #endif

src/crypto/random.c

@@ -61,11 +61,11 @@ static void generate_system_random_bytes(size_t n, void *result) {
 
 #include <err.h>
 #include <errno.h>
+#include <fcntl.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <fcntl.h>
 
 static void generate_system_random_bytes(size_t n, void *result) {
   int fd;

src/crypto/rx-slow-hash.c

@@ -332,7 +332,7 @@ static void rx_init_dataset(size_t max_threads) {
       local_abort("Couldn't start RandomX seed thread");
     }
   }
-  randomx_init_dataset(main_dataset, si[n1].si_cache, si[n1].si_start, si[n1].si_count);
+  rx_seedthread(&si[n1]);
   for (size_t i = 0; i < n1; ++i) CTHR_THREAD_JOIN(st[i]);
   CTHR_RWLOCK_UNLOCK_READ(main_cache_lock);
 
@@ -402,7 +402,6 @@ void rx_set_main_seedhash(const char *seedhash, size_t max_dataset_init_threads)
   if (!CTHR_THREAD_CREATE(t, rx_set_main_seedhash_thread, info)) {
     local_abort("Couldn't start RandomX seed thread");
   }
-  CTHR_THREAD_CLOSE(t);
 }
 
 void rx_slow_hash(const char *seedhash, const void *data, size_t length, char *result_hash) {

src/crypto/wallet/CMakeLists.txt

@@ -27,19 +27,37 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-include(CheckLanguage)
-check_language(ASM-ATT)
+#
+# Possibly user defined values.
+#
+set(MONERO_WALLET_CRYPTO_LIBRARY "auto" CACHE STRING "Select a wallet crypto library")
 
-add_library(wallet-crypto crypto.h)
+#
+# If the user specified "auto", detect best library defaulting to internal.
+#
+if (${MONERO_WALLET_CRYPTO_LIBRARY} STREQUAL "auto")
+   monero_crypto_autodetect(AVAILABLE BEST)
+  if (DEFINED BEST)
+    message("Wallet crypto is using ${BEST} backend")
+    set(MONERO_WALLET_CRYPTO_LIBRARY ${BEST})
+  else ()
+    message("Defaulting to internal crypto library for wallet")
+    set(MONERO_WALLET_CRYPTO_LIBRARY "cn")
+  endif ()
+endif ()
 
-target_include_directories(wallet-crypto
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/generated_include>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
+#
+# Configure library target "wallet-crypto" - clients will use this as a
+# library dependency which in turn will depend on the crypto library selected.
+#
+if (${MONERO_WALLET_CRYPTO_LIBRARY} STREQUAL "cn")
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/empty.h.in ${MONERO_GENERATED_HEADERS_DIR}/crypto/wallet/ops.h)
+  add_library(wallet-crypto ALIAS cncrypto)
+else ()
+  monero_crypto_generate_header(${MONERO_WALLET_CRYPTO_LIBRARY} "${MONERO_GENERATED_HEADERS_DIR}/crypto/wallet/ops.h")
+  monero_crypto_get_target(${MONERO_WALLET_CRYPTO_LIBRARY} CRYPTO_TARGET)
+  add_library(wallet-crypto $<TARGET_OBJECTS:${CRYPTO_TARGET}>)
+  target_link_libraries(wallet-crypto cncrypto)
+endif ()
 
-target_link_libraries(wallet-crypto PUBLIC cncrypto)
 
-monero_install_library(wallet-crypto
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/wallet-crypto/"
-        HEADERS crypto.h)

src/cryptonote_basic/CMakeLists.txt

@@ -26,68 +26,56 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-file(GLOB CN_BASIC_SOURCES *.cpp *.c *.cc)
-set(CN_BASIC_HEADERS
-    account.h
-    account_boost_serialization.h
-    blobdatatype.h
-    connection_context.h
-    cryptonote_basic.h
-    cryptonote_basic_impl.h
-    cryptonote_boost_serialization.h
-    cryptonote_format_utils.h
-    difficulty.h
-    events.h
-    fwd.h
-    hardfork.h
-    merge_mining.h
-    miner.h
-    subaddress_index.h
-    tx_extra.h
-    verification_context.h)
+if(APPLE)
+  if(DEPENDS)
+    list(APPEND EXTRA_LIBRARIES "-framework Foundation -framework ApplicationServices -framework AppKit -framework IOKit")
+  else()
+    find_library(IOKIT_LIBRARY IOKit)
+    mark_as_advanced(IOKIT_LIBRARY)
+    list(APPEND EXTRA_LIBRARIES ${IOKIT_LIBRARY})
+  endif()
+endif()
 
-# cryptonote_format_utils_basic
-add_library(cryptonote_format_utils_basic)
-target_sources(cryptonote_format_utils_basic
-    PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR}/cryptonote_format_utils_basic.cpp
-    )
+monero_add_library(cryptonote_format_utils_basic
+  cryptonote_format_utils_basic.cpp
+)
+target_link_libraries(cryptonote_format_utils_basic
+  PUBLIC
+  cncrypto
+)
 
-target_link_libraries(cryptonote_format_utils_basic PUBLIC cncrypto)
-target_include_directories(cryptonote_format_utils_basic
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
+set(cryptonote_basic_sources
+  account.cpp
+  connection_context.cpp
+  cryptonote_basic_impl.cpp
+  cryptonote_format_utils.cpp
+  difficulty.cpp
+  hardfork.cpp
+  merge_mining.cpp
+  miner.cpp)
 
-# cryptonote_basic
-add_library(cryptonote_basic)
-target_sources(cryptonote_basic
-    PRIVATE
-        ${CN_BASIC_SOURCES}
-    )
+set(cryptonote_basic_headers)
 
+monero_find_all_headers(cryptonote_basic_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
+
+monero_private_headers(cryptonote_basic
+  ${cryptonote_basic_private_headers})
+monero_add_library(cryptonote_basic
+  ${cryptonote_basic_sources}
+  ${cryptonote_basic_headers}
+  ${cryptonote_basic_private_headers})
 target_link_libraries(cryptonote_basic
   PUBLIC
     common
     cncrypto
     checkpoints
+    cryptonote_format_utils_basic
     device
-    Boost::date_time
-    Boost::program_options
-    Boost::serialization
-    Boost::filesystem
-    Boost::system
-    Boost::thread)
-
-target_include_directories(cryptonote_basic
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/cryptonote_basic>
-        )
-
-monero_install_library(cryptonote_format_utils_basic)
-monero_install_library(cryptonote_basic
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/cryptonote_basic/"
-        HEADERS ${CN_BASIC_HEADERS})
+    ${Boost_DATE_TIME_LIBRARY}
+    ${Boost_PROGRAM_OPTIONS_LIBRARY}
+    ${Boost_SERIALIZATION_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY}
+    ${Boost_THREAD_LIBRARY}
+  PRIVATE
+    ${EXTRA_LIBRARIES})

src/cryptonote_basic/cryptonote_format_utils.cpp

@@ -1254,7 +1254,7 @@ namespace cryptonote
     char *end = NULL;
     errno = 0;
     const unsigned long long ull = strtoull(buf, &end, 10);
-    CHECK_AND_ASSERT_THROW_MES(ull != ULLONG_MAX || errno == 0, "Failed to parse rounded amount: " << buf);
+    CHECK_AND_ASSERT_THROW_MES(ull != ULONG_MAX || errno == 0, "Failed to parse rounded amount: " << buf);
     CHECK_AND_ASSERT_THROW_MES(ull != 0 || amount == 0, "Overflow in rounding");
     return ull;
   }

src/cryptonote_basic/verification_context.h

@@ -42,12 +42,7 @@ namespace cryptonote
     static_assert(unsigned(relay_method::none) == 0, "default m_relay initialization is not to relay_method::none");
 
     relay_method m_relay; // gives indication on how tx should be relayed (if at all)
-    bool m_verifivation_failed; //bad tx, tx should not enter mempool and connection should be dropped unless m_no_drop_offense
-    // Do not add to mempool, do not relay, but also do not punish the peer for sending or drop
-    // connections to them. Used for low fees, tx_extra too big, "relay-only rules". Not to be
-    // confused with breaking soft fork rules, because tx could be later added to the chain if mined
-    // because it does not violate consensus rules.
-    bool m_no_drop_offense;
+    bool m_verifivation_failed; //bad tx, should drop connection
     bool m_verifivation_impossible; //the transaction is related with an alternative blockchain
     bool m_added_to_pool; 
     bool m_low_mixin;

src/cryptonote_config.h

@@ -104,12 +104,12 @@
 
 #define BLOCKS_IDS_SYNCHRONIZING_DEFAULT_COUNT          10000  //by default, blocks ids count in synchronizing
 #define BLOCKS_IDS_SYNCHRONIZING_MAX_COUNT              25000  //max blocks ids count in synchronizing
-#define BLOCKS_SYNCHRONIZING_DEFAULT_COUNT_PRE_V4       100    //by default, blocks count in blocks downloading
+#define BLOCKS_SYNCHRONIZING_DEFAULT_COUNT_PRE_V4       50    //by default, blocks count in blocks downloading
 #define BLOCKS_SYNCHRONIZING_DEFAULT_COUNT              20     //by default, blocks count in blocks downloading
 #define BLOCKS_SYNCHRONIZING_MAX_COUNT                  2048   //must be a power of 2, greater than 128, equal to SEEDHASH_EPOCH_BLOCKS
 
-#define CRYPTONOTE_MEMPOOL_TX_LIVETIME                    (86400*3) //seconds, three days
-#define CRYPTONOTE_MEMPOOL_TX_FROM_ALT_BLOCK_LIVETIME     604800 //seconds, one week
+#define CRYPTONOTE_MEMPOOL_TX_LIVETIME                    86400 //seconds, one day
+#define CRYPTONOTE_MEMPOOL_TX_FROM_ALT_BLOCK_LIVETIME     86400 //seconds, one day
 
 
 #define CRYPTONOTE_DANDELIONPP_STEMS              2 // number of outgoing stem connections per epoch
@@ -141,7 +141,7 @@
 #define P2P_LOCAL_WHITE_PEERLIST_LIMIT                  1000
 #define P2P_LOCAL_GRAY_PEERLIST_LIMIT                   5000
 
-#define P2P_DEFAULT_CONNECTIONS_COUNT                   12
+#define P2P_DEFAULT_CONNECTIONS_COUNT                   64
 #define P2P_DEFAULT_HANDSHAKE_INTERVAL                  60           //secondes
 #define P2P_DEFAULT_PACKET_MAX_SIZE                     50000000     //50000000 bytes maximum packet size
 #define P2P_DEFAULT_PEERS_IN_HANDSHAKE                  250
@@ -154,8 +154,8 @@
 #define P2P_DEFAULT_WHITELIST_CONNECTIONS_PERCENT       70
 #define P2P_DEFAULT_ANCHOR_CONNECTIONS_COUNT            2
 #define P2P_DEFAULT_SYNC_SEARCH_CONNECTIONS_COUNT       2
-#define P2P_DEFAULT_LIMIT_RATE_UP                       2048       // kB/s
-#define P2P_DEFAULT_LIMIT_RATE_DOWN                     8192       // kB/s
+#define P2P_DEFAULT_LIMIT_RATE_UP                       1048576    // 1GB/s
+#define P2P_DEFAULT_LIMIT_RATE_DOWN                     1048576   // 1GB/s
 
 #define P2P_FAILED_ADDR_FORGET_SECONDS                  (60*60)     //1 hour
 #define P2P_IP_BLOCKTIME                                (60*60*24)  //24 hour
@@ -265,7 +265,6 @@ namespace config
   const unsigned char HASH_KEY_MM_SLOT = 'm';
   const constexpr char HASH_KEY_MULTISIG_TX_PRIVKEYS_SEED[] = "multisig_tx_privkeys_seed";
   const constexpr char HASH_KEY_MULTISIG_TX_PRIVKEYS[] = "multisig_tx_privkeys";
-  const constexpr char HASH_KEY_TXHASH_AND_MIXRING[] = "txhash_and_mixring";
 
   // Multisig
   const uint32_t MULTISIG_MAX_SIGNERS{16};

src/cryptonote_core/CMakeLists.txt

@@ -26,18 +26,23 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-file(GLOB CN_CORE_SOURCES *.cpp *.c *.cc)
-set(CN_CORE_HEADERS
-  blockchain.h
-  blockchain_storage_boost_serialization.h
-  cryptonote_core.h
-  cryptonote_tx_utils.h
-  i_core_events.h
-  tx_pool.h
-  tx_sanity_check.h
-  tx_verification_utils.h)
+set(cryptonote_core_sources
+  blockchain.cpp
+  cryptonote_core.cpp
+  tx_pool.cpp
+  tx_sanity_check.cpp
+  cryptonote_tx_utils.cpp)
 
-add_library(cryptonote_core)
+set(cryptonote_core_headers)
+
+monero_find_all_headers(cryptonote_core_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
+
+monero_private_headers(cryptonote_core
+  ${cryptonote_core_private_headers})
+monero_add_library(cryptonote_core
+  ${cryptonote_core_sources}
+  ${cryptonote_core_headers}
+  ${cryptonote_core_private_headers})
 target_link_libraries(cryptonote_core
   PUBLIC
     version
@@ -47,34 +52,11 @@ target_link_libraries(cryptonote_core
     ringct
     device
     hardforks
-    Boost::date_time
-    Boost::program_options
-    Boost::serialization
-    Boost::filesystem
-    Boost::system
-    Boost::thread)
-
-target_include_directories(cryptonote_core PRIVATE
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/external>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-if(PER_BLOCK_CHECKPOINT)
-  target_compile_definitions(cryptonote_core PUBLIC PER_BLOCK_CHECKPOINT=1)
-endif()
-
-target_sources(cryptonote_core
-    PRIVATE
-        ${CN_CORE_SOURCES}
-    )
-
-target_include_directories(cryptonote_core
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-monero_install_library(cryptonote_core
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/cryptonote_core/"
-        HEADERS ${CN_CORE_HEADERS})
+    ${Boost_DATE_TIME_LIBRARY}
+    ${Boost_PROGRAM_OPTIONS_LIBRARY}
+    ${Boost_SERIALIZATION_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY}
+    ${Boost_THREAD_LIBRARY}
+  PRIVATE
+    ${EXTRA_LIBRARIES})

src/cryptonote_core/blockchain.cpp

@@ -57,7 +57,6 @@
 #include "common/notify.h"
 #include "common/varint.h"
 #include "common/pruning.h"
-#include "common/data_cache.h"
 #include "time_helper.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -99,8 +98,7 @@ Blockchain::Blockchain(tx_memory_pool& tx_pool) :
   m_difficulty_for_next_block(1),
   m_btc_valid(false),
   m_batch_success(true),
-  m_prepare_height(0),
-  m_rct_ver_cache()
+  m_prepare_height(0)
 {
   LOG_PRINT_L3("Blockchain::" << __func__);
 }
@@ -2167,7 +2165,7 @@ bool Blockchain::handle_alternative_block(const block& b, const crypto::hash& id
       cryptonote::blobdata blob;
       if (m_tx_pool.have_tx(txid, relay_category::legacy))
       {
-        if (m_tx_pool.get_transaction_info(txid, td, true/*include_sensitive_data*/))
+        if (m_tx_pool.get_transaction_info(txid, td))
         {
           bei.block_cumulative_weight += td.weight;
         }
@@ -3324,7 +3322,7 @@ bool Blockchain::have_tx_keyimges_as_spent(const transaction &tx) const
   }
   return false;
 }
-bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_prefix_hash, const std::vector<std::vector<rct::ctkey>> &pubkeys)
+bool Blockchain::expand_transaction_2(transaction &tx, const crypto::hash &tx_prefix_hash, const std::vector<std::vector<rct::ctkey>> &pubkeys) const
 {
   PERF_TIMER(expand_transaction_2);
   CHECK_AND_ASSERT_MES(tx.version == 2, false, "Transaction version is not 2");
@@ -3647,13 +3645,6 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
         false, "Transaction spends at least one output which is too young");
   }
 
-  // Warn that new RCT types are present, and thus the cache is not being used effectively
-  static constexpr const std::uint8_t RCT_CACHE_TYPE = rct::RCTTypeBulletproofPlus;
-  if (tx.rct_signatures.type > RCT_CACHE_TYPE)
-  {
-    MWARNING("RCT cache is not caching new verification results. Please update RCT_CACHE_TYPE!");
-  }
-
   if (tx.version == 1)
   {
     if (threads > 1)
@@ -3675,6 +3666,12 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
   }
   else
   {
+    if (!expand_transaction_2(tx, tx_prefix_hash, pubkeys))
+    {
+      MERROR_VER("Failed to expand rct signatures!");
+      return false;
+    }
+
     // from version 2, check ringct signatures
     // obviously, the original and simple rct APIs use a mixRing that's indexes
     // in opposite orders, because it'd be too simple otherwise...
@@ -3693,7 +3690,61 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
     case rct::RCTTypeCLSAG:
     case rct::RCTTypeBulletproofPlus:
     {
-      if (!ver_rct_non_semantics_simple_cached(tx, pubkeys, m_rct_ver_cache, RCT_CACHE_TYPE))
+      // check all this, either reconstructed (so should really pass), or not
+      {
+        if (pubkeys.size() != rv.mixRing.size())
+        {
+          MERROR_VER("Failed to check ringct signatures: mismatched pubkeys/mixRing size");
+          return false;
+        }
+        for (size_t i = 0; i < pubkeys.size(); ++i)
+        {
+          if (pubkeys[i].size() != rv.mixRing[i].size())
+          {
+            MERROR_VER("Failed to check ringct signatures: mismatched pubkeys/mixRing size");
+            return false;
+          }
+        }
+
+        for (size_t n = 0; n < pubkeys.size(); ++n)
+        {
+          for (size_t m = 0; m < pubkeys[n].size(); ++m)
+          {
+            if (pubkeys[n][m].dest != rct::rct2pk(rv.mixRing[n][m].dest))
+            {
+              MERROR_VER("Failed to check ringct signatures: mismatched pubkey at vin " << n << ", index " << m);
+              return false;
+            }
+            if (pubkeys[n][m].mask != rct::rct2pk(rv.mixRing[n][m].mask))
+            {
+              MERROR_VER("Failed to check ringct signatures: mismatched commitment at vin " << n << ", index " << m);
+              return false;
+            }
+          }
+        }
+      }
+
+      const size_t n_sigs = rct::is_rct_clsag(rv.type) ? rv.p.CLSAGs.size() : rv.p.MGs.size();
+      if (n_sigs != tx.vin.size())
+      {
+        MERROR_VER("Failed to check ringct signatures: mismatched MGs/vin sizes");
+        return false;
+      }
+      for (size_t n = 0; n < tx.vin.size(); ++n)
+      {
+        bool error;
+        if (rct::is_rct_clsag(rv.type))
+          error = memcmp(&boost::get<txin_to_key>(tx.vin[n]).k_image, &rv.p.CLSAGs[n].I, 32);
+        else
+          error = rv.p.MGs[n].II.empty() || memcmp(&boost::get<txin_to_key>(tx.vin[n]).k_image, &rv.p.MGs[n].II[0], 32);
+        if (error)
+        {
+          MERROR_VER("Failed to check ringct signatures: mismatched key image");
+          return false;
+        }
+      }
+
+      if (!rct::verRctNonSemanticsSimpleCached(rv))
       {
         MERROR_VER("Failed to check ringct signatures!");
         return false;
@@ -3703,12 +3754,6 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
     case rct::RCTTypeFull:
     case rct::RCTTypeFullBulletproof:
     {
-      if (!expand_transaction_2(tx, tx_prefix_hash, pubkeys))
-      {
-        MERROR_VER("Failed to expand rct signatures!");
-        return false;
-      }
-
       // check all this, either reconstructed (so should really pass), or not
       {
         bool size_matches = true;
@@ -3823,7 +3868,7 @@ uint64_t Blockchain::get_dynamic_base_fee(uint64_t block_reward, size_t median_b
       div128_64(hi, lo, median_block_weight, &hi, &lo, NULL, NULL);
       assert(hi == 0);
       lo -= lo / 20;
-      return lo == 0 ? 1 : lo;
+      return lo;
     }
     else
     {
@@ -4736,9 +4781,40 @@ bool Blockchain::update_next_cumulative_weight_limit(uint64_t *long_term_effecti
   }
   else
   {
-    const uint64_t nblocks = std::min<uint64_t>(m_long_term_block_weights_window, db_height);
-    const uint64_t long_term_median = get_long_term_block_weight_median(db_height - nblocks, nblocks);
+    const uint64_t block_weight = m_db->get_block_weight(db_height - 1);
 
+    uint64_t long_term_median;
+    if (db_height == 1)
+    {
+      long_term_median = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5;
+    }
+    else
+    {
+      uint64_t nblocks = std::min<uint64_t>(m_long_term_block_weights_window, db_height);
+      if (nblocks == db_height)
+        --nblocks;
+      long_term_median = get_long_term_block_weight_median(db_height - nblocks - 1, nblocks);
+    }
+
+    m_long_term_effective_median_block_weight = std::max<uint64_t>(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5, long_term_median);
+
+    uint64_t short_term_constraint = m_long_term_effective_median_block_weight;
+    if (hf_version >= HF_VERSION_2021_SCALING)
+      short_term_constraint += m_long_term_effective_median_block_weight * 7 / 10;
+    else
+      short_term_constraint += m_long_term_effective_median_block_weight * 2 / 5;
+    uint64_t long_term_block_weight = std::min<uint64_t>(block_weight, short_term_constraint);
+
+    if (db_height == 1)
+    {
+      long_term_median = long_term_block_weight;
+    }
+    else
+    {
+      m_long_term_block_weights_cache_tip_hash = m_db->get_block_hash_from_height(db_height - 1);
+      m_long_term_block_weights_cache_rolling_median.insert(long_term_block_weight);
+      long_term_median = m_long_term_block_weights_cache_rolling_median.median();
+    }
     m_long_term_effective_median_block_weight = std::max<uint64_t>(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5, long_term_median);
 
     std::vector<uint64_t> weights;
@@ -5671,7 +5747,7 @@ void Blockchain::cancel()
 }
 
 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "9ce2e9f40ff58954d6176e300af1d8da1804b829e1be8565805fea497df40f4b";
+static const char expected_block_hashes_hash[] = "758b237b54248c7d47c699156ea8a77db0dc04cc4f89783cc2b1a5b1a9658e18";
 void Blockchain::load_compiled_in_block_hashes(const GetCheckpointsCallback& get_checkpoints)
 {
   if (get_checkpoints == nullptr || !m_fast_sync)

src/cryptonote_core/blockchain.h

@@ -57,7 +57,6 @@
 #include "rpc/core_rpc_server_commands_defs.h"
 #include "cryptonote_basic/difficulty.h"
 #include "cryptonote_tx_utils.h"
-#include "tx_verification_utils.h"
 #include "cryptonote_basic/verification_context.h"
 #include "crypto/hash.h"
 #include "checkpoints/checkpoints.h"
@@ -597,15 +596,6 @@ namespace cryptonote
      */
     bool store_blockchain();
 
-    /**
-     * @brief expands v2 transaction data from blockchain
-     *
-     * RingCT transactions do not transmit some of their data if it
-     * can be reconstituted by the receiver. This function expands
-     * that implicit data.
-     */
-    static bool expand_transaction_2(transaction &tx, const crypto::hash &tx_prefix_hash, const std::vector<std::vector<rct::ctkey>> &pubkeys);
-
     /**
      * @brief validates a transaction's inputs
      *
@@ -1232,9 +1222,6 @@ namespace cryptonote
     uint64_t m_prepare_nblocks;
     std::vector<block> *m_prepare_blocks;
 
-    // cache for verifying transaction RCT non semantics
-    mutable rct_ver_cache_t m_rct_ver_cache;
-
     /**
      * @brief collects the keys for all outputs being "spent" as an input
      *
@@ -1587,6 +1574,15 @@ namespace cryptonote
      */
     void load_compiled_in_block_hashes(const GetCheckpointsCallback& get_checkpoints);
 
+    /**
+     * @brief expands v2 transaction data from blockchain
+     *
+     * RingCT transactions do not transmit some of their data if it
+     * can be reconstituted by the receiver. This function expands
+     * that implicit data.
+     */
+    bool expand_transaction_2(transaction &tx, const crypto::hash &tx_prefix_hash, const std::vector<std::vector<rct::ctkey>> &pubkeys) const;
+
     /**
      * @brief invalidates any cached block template
      */

src/cryptonote_core/cryptonote_core.cpp

@@ -1103,7 +1103,7 @@ namespace cryptonote
       else if(tvc[i].m_verifivation_impossible)
       {MERROR_VER("Transaction verification impossible: " << results[i].hash);}
 
-      if(tvc[i].m_added_to_pool && results[i].tx.extra.size() <= MAX_TX_EXTRA_SIZE)
+      if(tvc[i].m_added_to_pool)
       {
         MDEBUG("tx added: " << results[i].hash);
         valid_events = true;
@@ -1731,11 +1731,6 @@ namespace cryptonote
     return true;
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_pool_transactions_info(const std::vector<crypto::hash>& txids, std::vector<std::pair<crypto::hash, tx_memory_pool::tx_details>>& txs, bool include_sensitive_txes) const
-  {
-    return m_mempool.get_transactions_info(txids, txs, include_sensitive_txes);
-  }
-  //-----------------------------------------------------------------------------------------------
   bool core::get_pool_transactions(std::vector<transaction>& txs, bool include_sensitive_data) const
   {
     m_mempool.get_transactions(txs, include_sensitive_data);
@@ -1748,11 +1743,6 @@ namespace cryptonote
     return true;
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_pool_info(time_t start_time, bool include_sensitive_txes, size_t max_tx_count, std::vector<std::pair<crypto::hash, tx_memory_pool::tx_details>>& added_txs, std::vector<crypto::hash>& remaining_added_txids, std::vector<crypto::hash>& removed_txs, bool& incremental) const
-  {
-    return m_mempool.get_pool_info(start_time, include_sensitive_txes, max_tx_count, added_txs, remaining_added_txids, removed_txs, incremental);
-  }
-  //-----------------------------------------------------------------------------------------------
   bool core::get_pool_transaction_stats(struct txpool_stats& stats, bool include_sensitive_data) const
   {
     m_mempool.get_transaction_stats(stats, include_sensitive_data);
@@ -1840,6 +1830,56 @@ namespace cryptonote
         main_message = "The daemon is running offline and will not attempt to sync to the Wownero network.";
       else
         main_message = "The daemon will start synchronizing with the network. This may take a long time to complete.";
+    MGINFO_MAGENTA(ENDL <<
+    "\n\n"
+    " ██   ██ ██    ██ ███    ██ ████████ ██    ██   \n"
+    " ██  ██  ██    ██ ████   ██    ██     ██  ██    \n"
+    " █████   ██    ██ ██ ██  ██    ██      ████     \n"
+    " ██  ██  ██    ██ ██  ██ ██    ██       ██      \n"
+    " ██   ██  ██████  ██   ████    ██       ██      \n"
+    << ENDL);
+    MGINFO_GREEN(ENDL <<
+    "                m                                   !5!                               \n"
+    "               !Y?~:            .:^~~~~^^::::...   ~7J5G:                             \n"
+    "              ~?JY5P5~     .:!JYJ?!~^::::^^^^^^^^^^::^^~^.                            \n"
+    "             :77?Y555P5~^7Y5P5J7!~~~!7?77!~^^^:::::...:^^^^^:.                        \n"
+    "            .77?JJJYYY5PPP5YJYJJYY55YJ?7!!~~~^^^:::.....^~!!!7!^.                     \n"
+    "            !?J?77??JYY?J55Y5Y55PPP5J??7!~!??7!!~^:.... .:~7???p?!.                   \n"
+    "            !?J?!!!!77JJ77?YY5PGP55YYYJ??Y5PP5J7!~~~~!~..:~~7J55YJJ7:                 \n"
+    "            ~?JJ7^::~!?J?!?5555555PGGP55PGB#BPYJJJY55P5Y?7?J?Y5PP555Y?^               \n"
+    "            .JJY?~:::~!7?YYYJY5PPGGGGGGGB#BGPY?JY5PPGGGGP5YY5PGGGGGPPPY7.             \n"
+    "            :7JJYY?!:.:~JYJ?JYY5PPPPPGGGGGPYJJJJ?JYPGGBBBBG5J7!7777JPPPP5J~            \n"
+    "         :^77!777!7J!?YY77??JJ55Y55555P5YJ?JJJYYYY5PGB#BPJJY555J?~:JPP5P5JJ.          \n"
+    "        ^.~J!7????775JY?777!7JJJJYYYJ??7!7?????J5YY5P55Y5B##B###G5:7PGP5PYJY.         \n"
+    "       :.~J7?J???77~YJ!?JYYY7^^^:~JPPPGBBBBBBGPY77~!?~^#&#Y?YG#&&B?7YGGP5PYJ5.        \n"
+    "       ~^?!!??7?77!~Y!^~~~~!!^^.:5GGPP5PGB##&&&&B7:!Y?:5&Y!?YB#&&&!^7YGP55PJYY        \n"
+    "       ~?!!!?7!7!~~?7^~!!~~!!!!::P5!^~~?5P5PB###B!!P5PY~YGP5PB#&&B^?77YP5Y55J5~       \n"
+    "       !Y?~!7!!~~!7!^^~!^~!7?YYY775Y?~~!JG5!?PGBY:7PPGBGJ?PBBGG5JJGB?!7Y5YY5YY7       \n"
+    "      ^7!77?7!!!!~^^~~~^~!?5PGGGGJ~PBGPPGGGGBBBG:^PGBBBBBGP555PGB###B777Y5YY5JY.      \n"
+    "      ?77^:!!~~^:^^^^~^^~7YPGBBBBBPYGGPPGGGPG5J?JGBBBBBGPYJJJJJYPB&##P77?JJJYYY?      \n"
+    "     :?!!^^7!^~^^^:^^^^^!5PBBBBBBBGGGP5YY555PPPGBB#BBBG7^::......:G&#B???J??JYYY.     \n"
+    "     ^7!!^~7!^^:::^^^:::!PGBBBBBBBBBBB####BBBBBBBBBBBB5^...  ....^5##BY?J??7?JJY!     \n"
+    "     ~!!!~^!7~^::^^:^:^^~YGBBBBBBBBBBBBBBBBBBBGGGGGGGGP7^.......:^YGBB5?J?7!7??JY.    \n"
+    "     ~!!!~^!!~^:^^:^^^^^~75GBBBBBBBBBBBBBBBBBGGGGGGGGPPY?!^:...:^!J5GGY?JJ7!!7??Y!    \n"
+    "     ~!!!~^~7~^^~~~~^^^^~~75PGGGGGGGGBGGGGBBBGGGPPPP555Y?!^^^^^^~!?5GGY??J?!!7??J7    \n"
+    "       !!!!~^^7!^~!77!~~~~~~~YPPGGGGGPGGGGGGGGGGGPPPPPP55?~:::...::!5BBGJ7?J?!!??7?!    \n"
+    "    :7!!!~^^!7^~7?p?!!~!~~!JPGGGGGGGPPPGGGGGGPPPPPP5Y?~:...:::^~7YBBBG?7p?!!!7?7??    \n"
+    "    ??~!~!~^^7~^??4?!77!!!~JPGGGGGGGGGGPGGGGP5Y?7!~~~^^~!!!!!!7YGBBBBP77?!~~!7?7?7    \n"
+    "   .5J!!~!!~:^^!?7J?7?J77~~75PGGGGGGGGGPPPGGPP5J777?YYY55YYYYYPGBBGGGJ7?7!~~!777:     \n"
+    "   ~PY?!!~!!^^!?7?J?????7!775GGBGGGGPPPPPPPGGGGGPPPPPPPGGGGGGBBBBGGGY777!!!!77!.      \n"
+    "   JPYY7!~!77777???7!!!7!~!!JPPGGGGGGGGGPPPPPPPPPPPPPPGGGGGGBGBBGGPY!!?!!7777.        \n"
+    "   PP55YJJ3?!!7??7~^^^^~!~~!75PGGGGGBBBGGPPPPPPPPPPPPPGGGGGGGGGBG57!77!!2?!^          \n"
+    "   GGGPPP5J!!7?7~^:::^~~!!!77YPPPGGGGGGGGPPPPPPPPPPPPPPGGGGGGGGGGYJY7~!?BP.           \n"
+    "   GBGGGGP55YYJ7~^^!~^~77!77775PPPPPP55PPPPPPPPPPPPPPGGGGGGGGGGGGGBPJY5PG~            \n"
+    "                    Fve, V'q yvxr gb fcrnx gb gur gur jbjareb znantre                   "
+    << ENDL);
+    MGINFO_MAGENTA(ENDL <<
+    "                                  ██   ██  █████  ██████  ███████ ███    ██   \n"
+    "                                  ██  ██  ██   ██ ██   ██ ██      ████   ██   \n"
+    "                                  █████   ███████ ██████  █████   ██ ██  ██   \n"
+    "                                  ██  ██  ██   ██ ██   ██ ██      ██  ██ ██   \n"
+    "                                  ██   ██ ██   ██ ██   ██ ███████ ██   ████   \n"
+    << ENDL);
       MGINFO_YELLOW(ENDL << "**********************************************************************" << ENDL
         << main_message << ENDL
         << ENDL

src/cryptonote_core/cryptonote_core.h

@@ -510,23 +510,6 @@ namespace cryptonote
      bool get_pool_transaction_hashes(std::vector<crypto::hash>& txs, bool include_sensitive_txes = false) const;
 
      /**
-      * @copydoc tx_memory_pool::get_pool_transactions_info
-      * @param include_sensitive_txes include private transactions
-      *
-      * @note see tx_memory_pool::get_pool_transactions_info
-      */
-     bool get_pool_transactions_info(const std::vector<crypto::hash>& txids, std::vector<std::pair<crypto::hash, tx_memory_pool::tx_details>>& txs, bool include_sensitive_txes = false) const;
-
-     /**
-      * @copydoc tx_memory_pool::get_pool_info
-      * @param include_sensitive_txes include private transactions
-      * @param max_tx_count max allowed added_txs in response
-      *
-      * @note see tx_memory_pool::get_pool_info
-      */
-     bool get_pool_info(time_t start_time, bool include_sensitive_txes, size_t max_tx_count, std::vector<std::pair<crypto::hash, tx_memory_pool::tx_details>>& added_txs, std::vector<crypto::hash>& remaining_added_txids, std::vector<crypto::hash>& removed_txs, bool& incremental) const;
-
-    /**
       * @copydoc tx_memory_pool::get_transactions
       * @param include_sensitive_txes include private transactions
       *

src/cryptonote_core/cryptonote_tx_utils.cpp

@@ -450,8 +450,6 @@ namespace cryptonote
     if (!sort_tx_extra(tx.extra, tx.extra))
       return false;
 
-    CHECK_AND_ASSERT_MES(tx.extra.size() <= MAX_TX_EXTRA_SIZE, false, "TX extra size (" << tx.extra.size() << ") is greater than max allowed (" << MAX_TX_EXTRA_SIZE << ")");
-
     //check money
     if(summary_outs_money > summary_inputs_money )
     {

src/cryptonote_core/tx_pool.cpp

@@ -133,12 +133,6 @@ namespace cryptonote
     // class code expects unsigned values throughout
     if (m_next_check < time_t(0))
       throw std::runtime_error{"Unexpected time_t (system clock) value"};
-
-    m_added_txs_start_time = (time_t)0;
-    m_removed_txs_start_time = (time_t)0;
-    // We don't set these to "now" already here as we don't know how long it takes from construction
-    // of the pool until it "goes to work". It's safer to set when the first actual txs enter the
-    // corresponding lists.
   }
   //---------------------------------------------------------------------------------
   bool tx_memory_pool::add_tx(transaction &tx, /*const crypto::hash& tx_prefix_hash,*/ const crypto::hash &id, const cryptonote::blobdata &blob, size_t tx_weight, tx_verification_context& tvc, relay_method tx_relay, bool relayed, uint8_t version)
@@ -213,7 +207,6 @@ namespace cryptonote
     {
       tvc.m_verifivation_failed = true;
       tvc.m_fee_too_low = true;
-      tvc.m_no_drop_offense = true;
       return false;
     }
 
@@ -232,7 +225,6 @@ namespace cryptonote
       LOG_PRINT_L1("transaction tx-extra is too big: " << tx_extra_size << " bytes, the limit is: " << MAX_TX_EXTRA_SIZE);
       tvc.m_verifivation_failed = true;
       tvc.m_tx_extra_too_big = true;
-      tvc.m_no_drop_offense = true;
       return false;
     }
 
@@ -298,7 +290,7 @@ namespace cryptonote
             return false;
 
           m_blockchain.add_txpool_tx(id, blob, meta);
-          add_tx_to_transient_lists(id, fee / (double)(tx_weight ? tx_weight : 1), receive_time);
+          m_txs_by_fee_and_receive_time.emplace(std::pair<double, std::time_t>(fee / (double)(tx_weight ? tx_weight : 1), receive_time), id);
           lock.commit();
         }
         catch (const std::exception &e)
@@ -369,7 +361,7 @@ namespace cryptonote
 
           m_blockchain.remove_txpool_tx(id);
           m_blockchain.add_txpool_tx(id, blob, meta);
-          add_tx_to_transient_lists(id, meta.fee / (double)(tx_weight ? tx_weight : 1), receive_time);
+          m_txs_by_fee_and_receive_time.emplace(std::pair<double, std::time_t>(fee / (double)(tx_weight ? tx_weight : 1), receive_time), id);
         }
         lock.commit();
       }
@@ -390,7 +382,7 @@ namespace cryptonote
 
     ++m_cookie;
 
-    MINFO("Transaction added to pool: txid " << id << " weight: " << tx_weight << " fee/byte: " << (fee / (double)(tx_weight ? tx_weight : 1)) << ", count: " << m_added_txs_by_id.size());
+    MINFO("Transaction added to pool: txid " << id << " weight: " << tx_weight << " fee/byte: " << (fee / (double)(tx_weight ? tx_weight : 1)));
 
     prune(m_txpool_max_weight);
 
@@ -481,8 +473,7 @@ namespace cryptonote
         reduce_txpool_weight(meta.weight);
         remove_transaction_keyimages(tx, txid);
         MINFO("Pruned tx " << txid << " from txpool: weight: " << meta.weight << ", fee/byte: " << it->first.first);
-        remove_tx_from_transient_lists(it, txid, !meta.matches(relay_category::broadcasted));
-        it--;
+        m_txs_by_fee_and_receive_time.erase(it--);
         changed = true;
       }
       catch (const std::exception &e)
@@ -564,7 +555,8 @@ namespace cryptonote
     CRITICAL_REGION_LOCAL(m_transactions_lock);
     CRITICAL_REGION_LOCAL1(m_blockchain);
 
-    bool sensitive = false;
+    auto sorted_it = find_tx_in_sorted_container(id);
+
     try
     {
       LockedTXN lock(m_blockchain.get_db());
@@ -595,7 +587,6 @@ namespace cryptonote
       do_not_relay = meta.do_not_relay;
       double_spend_seen = meta.double_spend_seen;
       pruned = meta.pruned;
-      sensitive = !meta.matches(relay_category::broadcasted);
 
       // remove first, in case this throws, so key images aren't removed
       m_blockchain.remove_txpool_tx(id);
@@ -609,12 +600,13 @@ namespace cryptonote
       return false;
     }
 
-    remove_tx_from_transient_lists(find_tx_in_sorted_container(id), id, sensitive);
+    if (sorted_it != m_txs_by_fee_and_receive_time.end())
+      m_txs_by_fee_and_receive_time.erase(sorted_it);
     ++m_cookie;
     return true;
   }
   //---------------------------------------------------------------------------------
-  bool tx_memory_pool::get_transaction_info(const crypto::hash &txid, tx_details &td, bool include_sensitive_data, bool include_blob) const
+  bool tx_memory_pool::get_transaction_info(const crypto::hash &txid, tx_details &td) const
   {
     PERF_TIMER(get_transaction_info);
     CRITICAL_REGION_LOCAL(m_transactions_lock);
@@ -626,12 +618,7 @@ namespace cryptonote
       txpool_tx_meta_t meta;
       if (!m_blockchain.get_txpool_tx_meta(txid, meta))
       {
-        LOG_PRINT_L2("Failed to find tx in txpool: " << txid);
-        return false;
-      }
-      if (!include_sensitive_data && !meta.matches(relay_category::broadcasted))
-      {
-        // We don't want sensitive data && the tx is sensitive, so no need to return it
+        MERROR("Failed to find tx in txpool");
         return false;
       }
       cryptonote::blobdata txblob = m_blockchain.get_txpool_tx_blob(txid, relay_category::all);
@@ -657,13 +644,11 @@ namespace cryptonote
       td.kept_by_block = meta.kept_by_block;
       td.last_failed_height = meta.last_failed_height;
       td.last_failed_id = meta.last_failed_id;
-      td.receive_time = include_sensitive_data ? meta.receive_time : 0;
-      td.last_relayed_time = (include_sensitive_data && !meta.dandelionpp_stem) ? meta.last_relayed_time : 0;
+      td.receive_time = meta.receive_time;
+      td.last_relayed_time = meta.dandelionpp_stem ? 0 : meta.last_relayed_time;
       td.relayed = meta.relayed;
       td.do_not_relay = meta.do_not_relay;
       td.double_spend_seen = meta.double_spend_seen;
-      if (include_blob)
-        td.tx_blob = std::move(txblob);
     }
     catch (const std::exception &e)
     {
@@ -673,25 +658,6 @@ namespace cryptonote
 
     return true;
   }
-  //------------------------------------------------------------------
-  bool tx_memory_pool::get_transactions_info(const std::vector<crypto::hash>& txids, std::vector<std::pair<crypto::hash, tx_details>>& txs, bool include_sensitive) const
-  {
-    CRITICAL_REGION_LOCAL(m_transactions_lock);
-    CRITICAL_REGION_LOCAL1(m_blockchain);
-
-    txs.clear();
-
-    for (const auto &it: txids)
-    {
-      tx_details details;
-      bool success = get_transaction_info(it, details, include_sensitive, true/*include_blob*/);
-      if (success)
-      {
-        txs.push_back(std::make_pair(it, std::move(details)));
-      }
-    }
-    return true;
-  }
   //---------------------------------------------------------------------------------
   bool tx_memory_pool::get_complement(const std::vector<crypto::hash> &hashes, std::vector<cryptonote::blobdata> &txes) const
   {
@@ -753,7 +719,15 @@ namespace cryptonote
          (tx_age > CRYPTONOTE_MEMPOOL_TX_FROM_ALT_BLOCK_LIVETIME && meta.kept_by_block) )
       {
         LOG_PRINT_L1("Tx " << txid << " removed from tx pool due to outdated, age: " << tx_age );
-        remove_tx_from_transient_lists(find_tx_in_sorted_container(txid), txid, !meta.matches(relay_category::broadcasted));
+        auto sorted_it = find_tx_in_sorted_container(txid);
+        if (sorted_it == m_txs_by_fee_and_receive_time.end())
+        {
+          LOG_PRINT_L1("Removing tx " << txid << " from tx pool, but it was not found in the sorted txs container!");
+        }
+        else
+        {
+          m_txs_by_fee_and_receive_time.erase(sorted_it);
+        }
         m_timed_out_transactions.insert(txid);
         remove.push_back(std::make_pair(txid, meta.weight));
       }
@@ -907,12 +881,9 @@ namespace cryptonote
             meta.last_relayed_time = std::chrono::system_clock::to_time_t(now);
 
           m_blockchain.update_txpool_tx(hash, meta);
+
           // wait until db update succeeds to ensure tx is visible in the pool
           was_just_broadcasted = !already_broadcasted && meta.matches(relay_category::broadcasted);
-
-          if (was_just_broadcasted)
-            // Make sure the tx gets re-added with an updated time
-            add_tx_to_transient_lists(hash, meta.fee / (double)meta.weight, std::chrono::system_clock::to_time_t(now));
         }
       }
       catch (const std::exception &e)
@@ -965,81 +936,6 @@ namespace cryptonote
     }, false, category);
   }
   //------------------------------------------------------------------
-  bool tx_memory_pool::get_pool_info(time_t start_time, bool include_sensitive, size_t max_tx_count, std::vector<std::pair<crypto::hash, tx_details>>& added_txs, std::vector<crypto::hash>& remaining_added_txids, std::vector<crypto::hash>& removed_txs, bool& incremental) const
-  {
-    CRITICAL_REGION_LOCAL(m_transactions_lock);
-    CRITICAL_REGION_LOCAL1(m_blockchain);
-
-    incremental = true;
-    if (start_time == (time_t)0)
-    {
-      // Giving no start time means give back whole pool
-      incremental = false;
-    }
-    else if ((m_added_txs_start_time != (time_t)0) && (m_removed_txs_start_time != (time_t)0))
-    {
-      if ((start_time <= m_added_txs_start_time) || (start_time <= m_removed_txs_start_time))
-      {
-        // If either of the two lists do not go back far enough it's not possible to
-        // deliver incremental pool info
-        incremental = false;
-      }
-      // The check uses "<=": We cannot be sure to have ALL txs exactly at start_time, only AFTER that time
-    }
-    else
-    {
-      // Some incremental info still missing completely
-      incremental = false;
-    }
-
-    added_txs.clear();
-    remaining_added_txids.clear();
-    removed_txs.clear();
-
-    std::vector<crypto::hash> txids;
-    if (!incremental)
-    {
-      LOG_PRINT_L2("Giving back the whole pool");
-      // Give back the whole pool in 'added_txs'; because calling 'get_transaction_info' right inside the
-      // anonymous method somehow results in an LMDB error with transactions we have to build a list of
-      // ids first and get the full info afterwards
-      get_transaction_hashes(txids, include_sensitive);
-      if (txids.size() > max_tx_count)
-      {
-        remaining_added_txids = std::vector<crypto::hash>(txids.begin() + max_tx_count, txids.end());
-        txids.erase(txids.begin() + max_tx_count, txids.end());
-      }
-      get_transactions_info(txids, added_txs, include_sensitive);
-      return true;
-    }
-
-    // Give back incrementally, based on time of entry into the map
-    for (const auto &pit : m_added_txs_by_id)
-    {
-      if (pit.second >= start_time)
-        txids.push_back(pit.first);
-    }
-    get_transactions_info(txids, added_txs, include_sensitive);
-    if (added_txs.size() > max_tx_count)
-    {
-      remaining_added_txids.reserve(added_txs.size() - max_tx_count);
-      for (size_t i = max_tx_count; i < added_txs.size(); ++i)
-        remaining_added_txids.push_back(added_txs[i].first);
-      added_txs.erase(added_txs.begin() + max_tx_count, added_txs.end());
-    }
-
-    std::multimap<time_t, removed_tx_info>::const_iterator rit = m_removed_txs_by_time.lower_bound(start_time);
-    while (rit != m_removed_txs_by_time.end())
-    {
-      if (include_sensitive || !rit->second.sensitive)
-      {
-        removed_txs.push_back(rit->second.txid);
-      }
-      ++rit;
-    }
-    return true;
-  }
-  //------------------------------------------------------------------
   void tx_memory_pool::get_transaction_backlog(std::vector<tx_backlog_entry>& backlog, bool include_sensitive) const
   {
     CRITICAL_REGION_LOCAL(m_transactions_lock);
@@ -1744,12 +1640,6 @@ namespace cryptonote
     CRITICAL_REGION_LOCAL(m_transactions_lock);
     CRITICAL_REGION_LOCAL1(m_blockchain);
 
-    // Simply throw away incremental info, too difficult to update
-    m_added_txs_by_id.clear();
-    m_added_txs_start_time = (time_t)0;
-    m_removed_txs_by_time.clear();
-    m_removed_txs_start_time = (time_t)0;
-
     MINFO("Validating txpool contents for v" << (unsigned)version);
 
     LockedTXN lock(m_blockchain.get_db());
@@ -1807,106 +1697,6 @@ namespace cryptonote
     return n_removed;
   }
   //---------------------------------------------------------------------------------
-  void tx_memory_pool::add_tx_to_transient_lists(const crypto::hash& txid, double fee, time_t receive_time)
-  {
-
-    time_t now = time(NULL);
-    const std::unordered_map<crypto::hash, time_t>::iterator it = m_added_txs_by_id.find(txid);
-    if (it == m_added_txs_by_id.end())
-    {
-       m_added_txs_by_id.insert(std::make_pair(txid, now));
-    }
-    else
-    {
-      // This tx was already added to the map earlier, probably because then it was in the "stem"
-      // phase of Dandelion++ and now is in the "fluff" phase i.e. got broadcasted: We have to set
-      // a new time for clients that are not allowed to see sensitive txs to make sure they will
-      // see it now if they query incrementally
-      it->second = now;
-
-      auto sorted_it = find_tx_in_sorted_container(txid);
-      if (sorted_it == m_txs_by_fee_and_receive_time.end())
-      {
-        MERROR("Re-adding tx " << txid << " to tx pool, but it was not found in the sorted txs container");
-      }
-      else
-      {
-        m_txs_by_fee_and_receive_time.erase(sorted_it);
-      }
-    }
-    m_txs_by_fee_and_receive_time.emplace(std::pair<double, time_t>(fee, receive_time), txid);
-
-    // Don't check for "resurrected" txs in case of reorgs i.e. don't check in 'm_removed_txs_by_time'
-    // whether we have that txid there and if yes remove it; this results in possible duplicates
-    // where we return certain txids as deleted AND in the pool at the same time which requires
-    // clients to process deleted ones BEFORE processing pool txs
-    if (m_added_txs_start_time == (time_t)0)
-    {
-      m_added_txs_start_time = now;
-    }
-  }
-  //---------------------------------------------------------------------------------
-  void tx_memory_pool::remove_tx_from_transient_lists(const cryptonote::sorted_tx_container::iterator& sorted_it, const crypto::hash& txid, bool sensitive)
-  {
-    if (sorted_it == m_txs_by_fee_and_receive_time.end())
-    {
-      LOG_PRINT_L1("Removing tx " << txid << " from tx pool, but it was not found in the sorted txs container!");
-    }
-    else
-    {
-      m_txs_by_fee_and_receive_time.erase(sorted_it);
-    }
-
-    const std::unordered_map<crypto::hash, time_t>::iterator it = m_added_txs_by_id.find(txid);
-    if (it != m_added_txs_by_id.end())
-    {
-       m_added_txs_by_id.erase(it);
-    }
-    else
-    {
-      MDEBUG("Removing tx " << txid << " from tx pool, but it was not found in the map of added txs");
-    }
-    track_removed_tx(txid, sensitive);
-  }
-  //---------------------------------------------------------------------------------
-  void tx_memory_pool::track_removed_tx(const crypto::hash& txid, bool sensitive)
-  {
-    time_t now = time(NULL);
-    m_removed_txs_by_time.insert(std::make_pair(now, removed_tx_info{txid, sensitive}));
-    MDEBUG("Transaction removed from pool: txid " << txid << ", total entries in removed list now " << m_removed_txs_by_time.size());
-    if (m_removed_txs_start_time == (time_t)0)
-    {
-      m_removed_txs_start_time = now;
-    }
-
-    // Simple system to make sure the list of removed ids does not swell to an unmanageable size: Set
-    // an absolute size limit plus delete entries that are x minutes old (which is ok because clients
-    // will sync with sensible time intervalls and should not ask for incremental info e.g. 1 hour back)
-    const int MAX_REMOVED = 20000;
-    if (m_removed_txs_by_time.size() > MAX_REMOVED)
-    {
-      auto erase_it = m_removed_txs_by_time.begin();
-      std::advance(erase_it, MAX_REMOVED / 4 + 1);
-      m_removed_txs_by_time.erase(m_removed_txs_by_time.begin(), erase_it);
-      m_removed_txs_start_time = m_removed_txs_by_time.begin()->first;
-      MDEBUG("Erased old transactions from big removed list, leaving " << m_removed_txs_by_time.size());
-    }
-    else
-    {
-      time_t earliest = now - (30 * 60);  // 30 minutes
-      std::map<time_t, removed_tx_info>::iterator from, to;
-      from = m_removed_txs_by_time.begin();
-      to = m_removed_txs_by_time.lower_bound(earliest);
-      int distance = std::distance(from, to);
-      if (distance > 0)
-      {
-        m_removed_txs_by_time.erase(from, to);
-        m_removed_txs_start_time = earliest;
-        MDEBUG("Erased " << distance << " old transactions from removed list, leaving " << m_removed_txs_by_time.size());
-      }
-    }
-  }
-  //---------------------------------------------------------------------------------
   bool tx_memory_pool::init(size_t max_txpool_weight, bool mine_stem_txes)
   {
     CRITICAL_REGION_LOCAL(m_transactions_lock);
@@ -1914,10 +1704,6 @@ namespace cryptonote
 
     m_txpool_max_weight = max_txpool_weight ? max_txpool_weight : DEFAULT_TXPOOL_MAX_WEIGHT;
     m_txs_by_fee_and_receive_time.clear();
-    m_added_txs_by_id.clear();
-    m_added_txs_start_time = (time_t)0;
-    m_removed_txs_by_time.clear();
-    m_removed_txs_start_time = (time_t)0;
     m_spent_key_images.clear();
     m_txpool_weight = 0;
     std::vector<crypto::hash> remove;
@@ -1942,7 +1728,7 @@ namespace cryptonote
           MFATAL("Failed to insert key images from txpool tx");
           return false;
         }
-        add_tx_to_transient_lists(txid, meta.fee / (double)meta.weight, meta.receive_time);
+        m_txs_by_fee_and_receive_time.emplace(std::pair<double, time_t>(meta.fee / (double)meta.weight, meta.receive_time), txid);
         m_txpool_weight += meta.weight;
         return true;
       }, true, relay_category::all);

src/cryptonote_core/tx_pool.h

@@ -428,7 +428,6 @@ namespace cryptonote
     struct tx_details
     {
       transaction tx;  //!< the transaction
-      cryptonote::blobdata tx_blob; //!< the transaction's binary blob
       size_t blob_size;  //!< the transaction's size
       size_t weight;  //!< the transaction's weight
       uint64_t fee;  //!< the transaction's fee amount
@@ -467,25 +466,13 @@ namespace cryptonote
     /**
      * @brief get infornation about a single transaction
      */
-    bool get_transaction_info(const crypto::hash &txid, tx_details &td, bool include_sensitive_data, bool include_blob = false) const;
-
-    /**
-     * @brief get information about multiple transactions
-     */
-    bool get_transactions_info(const std::vector<crypto::hash>& txids, std::vector<std::pair<crypto::hash, tx_details>>& txs, bool include_sensitive_data = false) const;
+    bool get_transaction_info(const crypto::hash &txid, tx_details &td) const;
 
     /**
      * @brief get transactions not in the passed set
      */
     bool get_complement(const std::vector<crypto::hash> &hashes, std::vector<cryptonote::blobdata> &txes) const;
 
-    /**
-     * @brief get info necessary for update of pool-related info in a wallet, preferably incremental
-     *
-     * @return true on success, false on error
-     */
-    bool get_pool_info(time_t start_time, bool include_sensitive, size_t max_tx_count, std::vector<std::pair<crypto::hash, tx_details>>& added_txs, std::vector<crypto::hash>& remaining_added_txids, std::vector<crypto::hash>& removed_txs, bool& incremental) const;
-
   private:
 
     /**
@@ -590,10 +577,6 @@ namespace cryptonote
      */
     void prune(size_t bytes = 0);
 
-    void add_tx_to_transient_lists(const crypto::hash& txid, double fee, time_t receive_time);
-    void remove_tx_from_transient_lists(const cryptonote::sorted_tx_container::iterator& sorted_it, const crypto::hash& txid, bool sensitive);
-    void track_removed_tx(const crypto::hash& txid, bool sensitive);
-
     //TODO: confirm the below comments and investigate whether or not this
     //      is the desired behavior
     //! map key images to transactions which spent them
@@ -626,26 +609,6 @@ private:
 
     std::atomic<uint64_t> m_cookie; //!< incremented at each change
 
-    // Info when transactions entered the pool, accessible by txid
-    std::unordered_map<crypto::hash, time_t> m_added_txs_by_id;
-
-    // Info at what time the pool started to track the adding of transactions
-    time_t m_added_txs_start_time;
-
-    struct removed_tx_info
-    {
-      crypto::hash txid;
-      bool sensitive;
-    };
-
-    // Info about transactions that were removed from the pool, ordered by the time
-    // of deletion
-    std::multimap<time_t, removed_tx_info> m_removed_txs_by_time;
-
-    // Info how far back in time the list of removed tx ids currently reaches
-    // (it gets shorted periodically to prevent overflow)
-    time_t m_removed_txs_start_time;
-
     /**
      * @brief get an iterator to a transaction in the sorted container
      *

src/cryptonote_core/tx_verification_utils.cpp

@@ -1,167 +0,0 @@
-// Copyright (c) 2023, The Monero Project
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification, are
-// permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice, this list of
-//    conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list
-//    of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its contributors may be
-//    used to endorse or promote products derived from this software without specific
-//    prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include "cryptonote_core/blockchain.h"
-#include "cryptonote_core/tx_verification_utils.h"
-#include "ringct/rctSigs.h"
-
-#undef MONERO_DEFAULT_LOG_CATEGORY
-#define MONERO_DEFAULT_LOG_CATEGORY "blockchain"
-
-#define VER_ASSERT(cond, msgexpr) CHECK_AND_ASSERT_MES(cond, false, msgexpr)
-
-using namespace cryptonote;
-
-// Do RCT expansion, then do post-expansion sanity checks, then do full non-semantics verification.
-static bool expand_tx_and_ver_rct_non_sem(transaction& tx, const rct::ctkeyM& mix_ring)
-{
-    // Pruned transactions can not be expanded and verified because they are missing RCT data
-    VER_ASSERT(!tx.pruned, "Pruned transaction will not pass verRctNonSemanticsSimple");
-
-    // Calculate prefix hash
-    const crypto::hash tx_prefix_hash = get_transaction_prefix_hash(tx);
-
-    // Expand mixring, tx inputs, tx key images, prefix hash message, etc into the RCT sig
-    const bool exp_res = Blockchain::expand_transaction_2(tx, tx_prefix_hash, mix_ring);
-    VER_ASSERT(exp_res, "Failed to expand rct signatures!");
-
-    const rct::rctSig& rv = tx.rct_signatures;
-
-    // Check that expanded RCT mixring == input mixring
-    VER_ASSERT(rv.mixRing == mix_ring, "Failed to check ringct signatures: mismatched pubkeys/mixRing");
-
-    // Check CLSAG/MLSAG size against transaction input
-    const size_t n_sigs = rct::is_rct_clsag(rv.type) ? rv.p.CLSAGs.size() : rv.p.MGs.size();
-    VER_ASSERT(n_sigs == tx.vin.size(), "Failed to check ringct signatures: mismatched input sigs/vin sizes");
-
-    // For each input, check that the key images were copied into the expanded RCT sig correctly
-    for (size_t n = 0; n < n_sigs; ++n)
-    {
-        const crypto::key_image& nth_vin_image = boost::get<txin_to_key>(tx.vin[n]).k_image;
-
-        if (rct::is_rct_clsag(rv.type))
-        {
-            const bool ki_match = 0 == memcmp(&nth_vin_image, &rv.p.CLSAGs[n].I, 32);
-            VER_ASSERT(ki_match, "Failed to check ringct signatures: mismatched CLSAG key image");
-        }
-        else
-        {
-            const bool mg_nonempty = !rv.p.MGs[n].II.empty();
-            VER_ASSERT(mg_nonempty, "Failed to check ringct signatures: missing MLSAG key image");
-            const bool ki_match = 0 == memcmp(&nth_vin_image, &rv.p.MGs[n].II[0], 32);
-            VER_ASSERT(ki_match, "Failed to check ringct signatures: mismatched MLSAG key image");
-        }
-    }
-
-    // Mix ring data is now known to be correctly incorporated into the RCT sig inside tx.
-    return rct::verRctNonSemanticsSimple(rv);
-}
-
-// Create a unique identifier for pair of tx blob + mix ring
-static crypto::hash calc_tx_mixring_hash(const transaction& tx, const rct::ctkeyM& mix_ring)
-{
-    std::stringstream ss;
-
-    // Start with domain seperation
-    ss << config::HASH_KEY_TXHASH_AND_MIXRING;
-
-    // Then add TX hash
-    const crypto::hash tx_hash = get_transaction_hash(tx);
-    ss.write(tx_hash.data, sizeof(crypto::hash));
-
-    // Then serialize mix ring
-    binary_archive<true> ar(ss);
-    ::do_serialize(ar, const_cast<rct::ctkeyM&>(mix_ring));
-
-    // Calculate hash of TX hash and mix ring blob
-    crypto::hash tx_and_mixring_hash;
-    get_blob_hash(ss.str(), tx_and_mixring_hash);
-
-    return tx_and_mixring_hash;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace cryptonote
-{
-
-bool ver_rct_non_semantics_simple_cached
-(
-    transaction& tx,
-    const rct::ctkeyM& mix_ring,
-    rct_ver_cache_t& cache,
-    const std::uint8_t rct_type_to_cache
-)
-{
-    // Hello future Monero dev! If you got this assert, read the following carefully:
-    //
-    // For this version of RCT, the way we guaranteed that verification caches do not generate false
-    // positives (and thus possibly enabling double spends) is we take a hash of two things. One,
-    // we use get_transaction_hash() which gives us a (cryptographically secure) unique
-    // representation of all "knobs" controlled by the possibly malicious constructor of the
-    // transaction. Two, we take a hash of all *previously validated* blockchain data referenced by
-    // this transaction which is required to validate the ring signature. In our case, this is the
-    // mixring. Future versions of the protocol may differ in this regard, but if this assumptions
-    // holds true in the future, enable the verification hash by modifying the `untested_tx`
-    // condition below.
-    const bool untested_tx = tx.version > 2 || tx.rct_signatures.type > rct::RCTTypeBulletproofPlus;
-    VER_ASSERT(!untested_tx, "Unknown TX type. Make sure RCT cache works correctly with this type and then enable it in the code here.");
-
-    // Don't cache older (or newer) rctSig types
-    // This cache only makes sense when it caches data from mempool first,
-    // so only "current fork version-enabled" RCT types need to be cached
-    if (tx.rct_signatures.type != rct_type_to_cache)
-    {
-        MDEBUG("RCT cache: tx " << get_transaction_hash(tx) << " skipped");
-        return expand_tx_and_ver_rct_non_sem(tx, mix_ring);
-    }
-
-    // Generate unique hash for tx+mix_ring pair
-    const crypto::hash tx_mixring_hash = calc_tx_mixring_hash(tx, mix_ring);
-
-    // Search cache for successful verification of same TX + mix ring combination
-    if (cache.has(tx_mixring_hash))
-    {
-        MDEBUG("RCT cache: tx " << get_transaction_hash(tx) << " hit");
-        return true;
-    }
-
-    // We had a cache miss, so now we must expand the mix ring and do full verification
-    MDEBUG("RCT cache: tx " << get_transaction_hash(tx) << " missed");
-    if (!expand_tx_and_ver_rct_non_sem(tx, mix_ring))
-    {
-        return false;
-    }
-
-    // At this point, the TX RCT verified successfully, so add it to the cache and return true
-    cache.add(tx_mixring_hash);
-
-    return true;
-}
-
-} // namespace cryptonote

src/cryptonote_core/tx_verification_utils.h

@@ -1,78 +0,0 @@
-// Copyright (c) 2023, The Monero Project
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification, are
-// permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice, this list of
-//    conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list
-//    of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its contributors may be
-//    used to endorse or promote products derived from this software without specific
-//    prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#pragma once
-
-#include "common/data_cache.h"
-#include "cryptonote_basic/cryptonote_basic.h"
-
-namespace cryptonote
-{
-
-// Modifying this value should not affect consensus. You can adjust it for performance needs
-static constexpr const size_t RCT_VER_CACHE_SIZE = 8192;
-
-using rct_ver_cache_t = ::tools::data_cache<::crypto::hash, RCT_VER_CACHE_SIZE>;
-
-/**
- * @brief Cached version of rct::verRctNonSemanticsSimple
- *
- * This function will not affect how the transaction is serialized and it will never modify the
- * transaction prefix.
- *
- * The reference to tx is mutable since the transaction's ring signatures may be expanded by
- * Blockchain::expand_transaction_2. However, on cache hits, the transaction will not be
- * expanded. This means that the caller does not need to call expand_transaction_2 on this
- * transaction before passing it; the transaction will not successfully verify with "old" RCT data
- * if the transaction has been otherwise modified since the last verification.
- *
- * But, if cryptonote::get_transaction_hash(tx) returns a "stale" hash, this function is not
- * guaranteed to work. So make sure that the cryptonote::transaction passed has not had
- * modifications to it since the last time its hash was fetched without properly invalidating the
- * hashes.
- *
- * rct_type_to_cache can be any RCT version value as long as rct::verRctNonSemanticsSimple works for
- * this RCT version, but for most applications, it doesn't make sense to not make this version
- * the "current" RCT version (i.e. the version that transactions in the mempool are).
- *
- * @param tx transaction which contains RCT signature to verify
- * @param mix_ring mixring referenced by this tx. THIS DATA MUST BE PREVIOUSLY VALIDATED
- * @param cache saves tx+mixring hashes used to cache calls
- * @param rct_type_to_cache Only RCT sigs with version (e.g. RCTTypeBulletproofPlus) will be cached
- * @return true when verRctNonSemanticsSimple() w/ expanded tx.rct_signatures would return true
- * @return false when verRctNonSemanticsSimple() w/ expanded tx.rct_signatures would return false
- */
-bool ver_rct_non_semantics_simple_cached
-(
-    transaction& tx,
-    const rct::ctkeyM& mix_ring,
-    rct_ver_cache_t& cache,
-    std::uint8_t rct_type_to_cache
-);
-
-} // namespace cryptonote

src/cryptonote_protocol/CMakeLists.txt

@@ -26,31 +26,16 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-file(GLOB CN_PROT_SOURCES *.cpp *.c *.cc)
-set(CN_PROT_HEADERS
-    block_queue.h
-    cryptonote_protocol_defs.h
-    cryptonote_protocol_handler.h
-    cryptonote_protocol_handler_common.h
-    enums.h
-    fwd.h
-    levin_notify.h)
+cmake_minimum_required (VERSION 3.5)
+project (monero CXX)
 
-add_library(cryptonote_protocol)
-target_sources(cryptonote_protocol
-    PRIVATE
-        ${CN_PROT_SOURCES}
-    )
+file(GLOB CRYPTONOTE_PROTOCOL *)
+source_group(cryptonote_protocol FILES ${CRYPTONOTE_PROTOCOL})
 
-target_link_libraries(cryptonote_protocol PUBLIC p2p)
-
-target_include_directories(cryptonote_protocol
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        PRIVATE ${OPENSSL_INCLUDE_DIR}
-        )
-
-monero_install_library(cryptonote_protocol
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/cryptonote_protocol/"
-        HEADERS ${CN_PROT_HEADERS})
+#monero_private_headers(cryptonote_protocol ${CRYPTONOTE_PROTOCOL})
+monero_add_library(cryptonote_protocol ${CRYPTONOTE_PROTOCOL})
+target_link_libraries(cryptonote_protocol
+  PUBLIC
+    p2p
+  PRIVATE
+    ${EXTRA_LIBRARIES})

src/cryptonote_protocol/cryptonote_protocol_handler.inl

@@ -979,18 +979,8 @@ namespace cryptonote
   int t_cryptonote_protocol_handler<t_core>::handle_notify_new_transactions(int command, NOTIFY_NEW_TRANSACTIONS::request& arg, cryptonote_connection_context& context)
   {
     MLOG_P2P_MESSAGE("Received NOTIFY_NEW_TRANSACTIONS (" << arg.txs.size() << " txes)");
-    std::unordered_set<blobdata> seen;
     for (const auto &blob: arg.txs)
-    {
       MLOGIF_P2P_MESSAGE(cryptonote::transaction tx; crypto::hash hash; bool ret = cryptonote::parse_and_validate_tx_from_blob(blob, tx, hash);, ret, "Including transaction " << hash);
-      if (seen.find(blob) != seen.end())
-      {
-        LOG_PRINT_CCONTEXT_L1("Duplicate transaction in notification, dropping connection");
-        drop_connection(context, false, false);
-        return 1;
-      }
-      seen.insert(blob);
-    }
 
     if(context.m_state != cryptonote_connection_context::state_normal)
       return 1;
@@ -1030,7 +1020,7 @@ namespace cryptonote
     for (auto& tx : arg.txs)
     {
       tx_verification_context tvc{};
-      if (!m_core.handle_incoming_tx({tx, crypto::null_hash}, tvc, tx_relay, true) && !tvc.m_no_drop_offense)
+      if (!m_core.handle_incoming_tx({tx, crypto::null_hash}, tvc, tx_relay, true))
       {
         LOG_PRINT_CCONTEXT_L1("Tx verification failed, dropping connection");
         drop_connection(context, false, false);
@@ -1693,8 +1683,22 @@ namespace cryptonote
                 + std::to_string(previous_stripe) + " -> " + std::to_string(current_stripe);
             if (ELPP->vRegistry()->allowed(el::Level::Debug, "sync-info"))
               timing_message += std::string(": ") + m_block_queue.get_overview(current_blockchain_height);
-            MGINFO_YELLOW("Synced " << current_blockchain_height << "/" << target_blockchain_height
-                << progress_message << timing_message);
+            uint64_t num = (rand() % 4) + 1;
+            switch (num)
+            {
+                case 1:
+                    MGINFO_MAGENTA("*•.¸♡ ♡¸.•* synced *•.¸♡ ♡¸.•* " << current_blockchain_height << "/" << target_blockchain_height << progress_message << timing_message << " ˚ ༘♡ ⋆｡˚");
+                    break;
+                case 2:
+                    MGINFO_YELLOW("ˏˋ°•*⁀➷ pǝɔuʎs ˏˋ°•*⁀➷ " << current_blockchain_height << "/" << target_blockchain_height << progress_message << timing_message << " ︶︶༉‧₊ ☄. *.⋆");
+                    break;
+                case 3:
+                    MGINFO_BLUE("s ★ y ★ n ★ c ★ e ★ d " << current_blockchain_height << "/" << target_blockchain_height << progress_message << timing_message << " *ೃ༄ *·˚˚ ༘♡ ⋆｡˚");
+                    break;
+                case 4:
+                    MGINFO_GREEN("s ♥ y ♥ n ♥ c ♥ e ♥ d " << current_blockchain_height << "/" << target_blockchain_height << progress_message << timing_message << " ⎯୧◦•◦❥•◦'*•.¸♡ ");
+                    break;
+            }
             if (previous_stripe != current_stripe)
               notify_new_stripe(context, current_stripe);
           }

src/daemon/CMakeLists.txt

@@ -26,14 +26,25 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-file(GLOB DAEMON_SOURCES
-    *.cpp
-    *.c
-    *.cc
-    *.h)
+set(daemon_sources
+  command_parser_executor.cpp
+  command_server.cpp
+  daemon.cpp
+  executor.cpp
+  main.cpp
+  rpc_command_executor.cpp
+)
 
-add_executable(daemon ${DAEMON_SOURCES})
+set(daemon_headers)
 
+monero_find_all_headers(daemon_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
+
+monero_private_headers(daemon
+  ${daemon_private_headers})
+monero_add_executable(daemon
+  ${daemon_sources}
+  ${daemon_headers}
+  ${daemon_private_headers})
 target_link_libraries(daemon
   PRIVATE
     rpc
@@ -46,27 +57,19 @@ target_link_libraries(daemon
     daemonizer
     serialization
     daemon_rpc_server
+    ${EPEE_READLINE}
     version
-    Boost::chrono
-    Boost::program_options
-    Boost::filesystem
-    Boost::system
-    Boost::thread
-    Boost::regex
-    Threads::Threads
-    ${ZMQ_LIBRARIES}
-    blocks)
-
-target_include_directories(daemon
-        PRIVATE ${ZMQ_INCLUDE_DIRS}
-        PRIVATE ${OPENSSL_INCLUDE_DIR})
-
-if(PER_BLOCK_CHECKPOINT)
-  target_compile_definitions(daemon PUBLIC PER_BLOCK_CHECKPOINT=1)
-endif()
-
+    ${Boost_CHRONO_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_PROGRAM_OPTIONS_LIBRARY}
+    ${Boost_REGEX_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY}
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${ZMQ_LIB}
+    ${GNU_READLINE_LIBRARY}
+    ${EXTRA_LIBRARIES}
+    ${Blocks})
 set_property(TARGET daemon
   PROPERTY
     OUTPUT_NAME "wownerod")
-
-install(TARGETS daemon DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS daemon DESTINATION bin)

src/daemon/main.cpp

@@ -219,19 +219,6 @@ int main(int argc, char const * argv[])
       {
         po::store(po::parse_config_file<char>(config_path.string<std::string>().c_str(), core_settings), vm);
       }
-      catch (const po::unknown_option &e)
-      {
-        std::string unrecognized_option = e.get_option_name();
-        if (all_options.find_nothrow(unrecognized_option, false))
-        {
-          std::cerr << "Option '" << unrecognized_option << "' is not allowed in the config file, please use it as a command line flag." << std::endl;
-        }
-        else
-        {
-          std::cerr << "Unrecognized option '" << unrecognized_option << "' in config file." << std::endl;
-        }
-        return 1;
-      }
       catch (const std::exception &e)
       {
         // log system isn't initialized yet

src/daemonizer/CMakeLists.txt

@@ -58,16 +58,17 @@ if(CMAKE_BUILD_TYPE STREQUAL "Debug")
   add_definitions(-DDEBUG_TMPDIR_LOG=1)
 endif()
 
-add_library(daemonizer
+monero_private_headers(daemonizer
+  ${daemonizer_private_headers})
+monero_add_library(daemonizer
   ${daemonizer_sources}
   ${daemonizer_headers}
   ${daemonizer_private_headers})
-
 target_link_libraries(daemonizer
   PUBLIC
     common
-    Boost::chrono
-    Boost::filesystem
-    Boost::program_options)
-
-target_include_directories(daemonizer PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../)
+    ${Boost_CHRONO_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_PROGRAM_OPTIONS_LIBRARY}
+  PRIVATE
+    ${EXTRA_LIBRARIES})

src/daemonizer/windows_service.cpp

@@ -196,7 +196,7 @@ bool install_service(
       , 0
       //, GENERIC_EXECUTE | GENERIC_READ
       , SERVICE_WIN32_OWN_PROCESS
-      , SERVICE_DEMAND_START
+      , SERVICE_AUTO_START
       , SERVICE_ERROR_NORMAL
       , full_command.c_str()
       , nullptr

src/daemonizer/windows_service_runner.h

@@ -146,9 +146,6 @@ namespace windows {
       m_handler.run();
 
       on_state_change_request_(SERVICE_CONTROL_STOP);
-
-      // Ensure that the service is uninstalled
-      uninstall_service(m_name);
     }
 
     static void WINAPI on_state_change_request(DWORD control_code)

src/device/CMakeLists.txt

@@ -26,41 +26,57 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-set(HEADERS
-    device.hpp
-    device_io.hpp
-    device_default.hpp
-    device_cold.hpp
-    log.hpp)
+set(device_sources
+  device.cpp
+  device_default.cpp
+  log.cpp
+  )
 
-add_library(device)
-target_sources(device
-    PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR}/device.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/device_default.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/log.cpp
+if(HIDAPI_FOUND)
+  set(device_sources 
+    ${device_sources} 
+    device_ledger.cpp
+    device_io_hid.cpp
     )
+endif()
+
+set(device_headers
+  device.hpp
+  device_io.hpp
+  device_default.hpp
+  device_cold.hpp
+  log.hpp
+ )
+
+if(HIDAPI_FOUND)
+  set(device_headers 
+    ${device_headers} 
+    device_ledger.hpp
+    device_io_hid.hpp
+    )
+endif()
+
+set(device_private_headers)
+
+
+monero_private_headers(device
+  ${device_private_headers})
+
+monero_add_library(device
+  ${device_sources}
+  ${device_headers}
+  ${device_private_headers})
 
 target_link_libraries(device
   PUBLIC
+    ${HIDAPI_LIBRARIES}
     cncrypto
     cryptonote_format_utils_basic
     ringct_basic
     wallet-crypto
-    monero-crypto-amd64-64-24k
-    OpenSSL::Crypto
-    Boost::serialization
+    ${OPENSSL_CRYPTO_LIBRARIES}
+    ${Boost_SERIALIZATION_LIBRARY}
   PRIVATE
     version
-    blocks)
-
-target_include_directories(device
-        PUBLIC $<TARGET_PROPERTY:monero-crypto-amd64-64-24k,INTERFACE_INCLUDE_DIRECTORIES>
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-monero_install_library(device
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/device/"
-        HEADERS "${HEADERS}")
+    ${Blocks}
+    ${EXTRA_LIBRARIES})

src/device/device_ledger.cpp

@@ -526,7 +526,6 @@ namespace hw {
         {0x2c97, 0x0001, 0, 0xffa0}, 
         {0x2c97, 0x0004, 0, 0xffa0},       
         {0x2c97, 0x0005, 0, 0xffa0},
-        {0x2c97, 0x0006, 0, 0xffa0},
     };
 
     bool device_ledger::connect(void) {

src/gen_multisig/CMakeLists.txt

@@ -51,4 +51,4 @@ add_dependencies(gen_multisig
 set_property(TARGET gen_multisig
   PROPERTY
     OUTPUT_NAME "wownero-gen-trusted-multisig")
-install(TARGETS gen_multisig DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS gen_multisig DESTINATION bin)

src/gen_ssl_cert/CMakeLists.txt

@@ -46,4 +46,4 @@ add_dependencies(gen_ssl_cert
 set_property(TARGET gen_ssl_cert
   PROPERTY
     OUTPUT_NAME "wownero-gen-ssl-cert")
-install(TARGETS gen_ssl_cert DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS gen_ssl_cert DESTINATION bin)

src/hardforks/CMakeLists.txt

@@ -26,14 +26,21 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-add_library(hardforks)
-target_sources(hardforks
-    PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR}/hardforks.cpp
-    )
+set(hardforks_sources
+  hardforks.cpp)
 
-target_link_libraries(hardforks PUBLIC version)
+monero_find_all_headers(hardforks_headers "${CMAKE_CURRENT_SOURCE_DIR}")
 
-monero_install_library(hardforks
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/hardforks/"
-        HEADERS hardforks.h)
+set(hardforks_private_headers)
+
+monero_private_headers(hardforks
+  ${hardforks_private_headers})
+monero_add_library(hardforks
+  ${hardforks_sources}
+  ${hardforks_headers}
+  ${hardforks_private_headers})
+target_link_libraries(hardforks
+  PUBLIC
+    version
+  PRIVATE
+    ${EXTRA_LIBRARIES})

src/hardforks/hardforks.cpp

@@ -47,7 +47,8 @@ const hardfork_t mainnet_hard_forks[] = {
   { 19, 331458, 0, 1624793373 },
   { 20, 514000, 0, 1677222289 },
 };
-const size_t num_mainnet_hard_forks = sizeof(mainnet_hard_forks) / sizeof(mainnet_hard_forks[0]);
+// since Wownero starts from v7, added + 6 so that the total number of hard forks = version number
+const size_t num_mainnet_hard_forks = sizeof(mainnet_hard_forks) / sizeof(mainnet_hard_forks[0]) + 6;
 const uint64_t mainnet_hard_fork_version_1_till = 0;
 
 const hardfork_t testnet_hard_forks[] = {

src/lmdb/CMakeLists.txt

@@ -26,26 +26,8 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-file(GLOB LMDB_SOURCES *.cpp *.c *.cc)
-set(LMDB_HEADERS
-    database.h
-    error.h
-    key_stream.h
-    table.h
-    transaction.h
-    util.h
-    value_stream.h)
+set(lmdb_sources database.cpp error.cpp table.cpp value_stream.cpp)
+monero_find_all_headers(lmdb_headers "${CMAKE_CURRENT_SOURCE_DIR}")
 
-add_library(lmdb_lib)
-target_sources(lmdb_lib
-    PRIVATE
-        ${LMDB_SOURCES}
-    )
-
-target_link_libraries(lmdb_lib PRIVATE
-    common
-    lmdb)
-
-monero_install_library(lmdb_lib
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/lmdb_lib/"
-        HEADERS ${LMDB_HEADERS})
+monero_add_library(lmdb_lib ${lmdb_sources} ${lmdb_headers})
+target_link_libraries(lmdb_lib common ${LMDB_LIBRARY})

src/mnemonics/CMakeLists.txt

@@ -26,43 +26,23 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-file(GLOB MN_SOURCES *.cpp *.c *.cc)
-set(MN_HEADERS
-    chinese_simplified.h
-    dutch.h
-    electrum-words.h
-    english.h
-    english_old.h
-    esperanto.h
-    french.h
-    german.h
-    italian.h
-    japanese.h
-    language_base.h
-    lojban.h
-    portuguese.h
-    russian.h
-    singleton.h
-    spanish.h)
+set(mnemonics_sources
+  electrum-words.cpp)
 
-add_library(mnemonics)
-target_sources(mnemonics
-    PRIVATE
-        ${MN_SOURCES}
-    )
+set(mnemonics_headers)
 
+monero_find_all_headers(mnemonics_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
+
+monero_private_headers(mnemonics
+  ${mnemonics_private_headers})
+monero_add_library(mnemonics
+  ${mnemonics_sources}
+  ${mnemonics_headers}
+  ${mnemonics_private_headers})
 target_link_libraries(mnemonics
   PUBLIC
     epee
     easylogging
-    Boost::system)
-
-target_include_directories(mnemonics
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-monero_install_library(mnemonics
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/mnemonics/"
-        HEADERS ${MN_HEADERS})
+    ${Boost_SYSTEM_LIBRARY}
+  PRIVATE
+    ${EXTRA_LIBRARIES})

src/multisig/CMakeLists.txt

@@ -25,20 +25,26 @@
 # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-file(GLOB MULTISIG_SOURCES *.cpp *.c *.cc)
-set(MULTISIG_HEADERS
-    multisig_account.h
-    multisig_clsag_context.h
-    multisig.h
-    multisig_kex_msg.h
-    multisig_kex_msg_serialization.h
-    multisig_tx_builder_ringct.h)
 
-add_library(multisig)
-target_sources(multisig
-    PRIVATE
-        ${MULTISIG_SOURCES}
-    )
+set(multisig_sources
+  multisig.cpp
+  multisig_account.cpp
+  multisig_account_kex_impl.cpp
+  multisig_clsag_context.cpp
+  multisig_kex_msg.cpp
+  multisig_tx_builder_ringct.cpp)
+
+set(multisig_headers)
+
+monero_find_all_headers(multisig_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
+
+monero_private_headers(multisig
+  ${multisig_private_headers})
+
+monero_add_library(multisig
+  ${multisig_sources}
+  ${multisig_headers}
+  ${multisig_private_headers})
 
 target_link_libraries(multisig
   PUBLIC
@@ -46,14 +52,6 @@ target_link_libraries(multisig
     cryptonote_basic
     cryptonote_core
     common
-    cncrypto)
-
-target_include_directories(multisig
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        )
-
-monero_install_library(multisig
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/multisig/"
-        HEADERS ${MULTISIG_HEADERS})
+    cncrypto
+  PRIVATE
+    ${EXTRA_LIBRARIES})

src/net/CMakeLists.txt

@@ -27,40 +27,10 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-SET(NET_HEADERS
-    dandelionpp.h
-    error.h
-    fwd.h
-    http.h
-    i2p_address.h
-    parse.h
-    resolve.h
-    socks_connect.h
-    socks.h
-    tor_address.h
-    zmq.h)
-file(GLOB NET_SOURCES *.cpp *.c *.cc)
+set(net_sources dandelionpp.cpp error.cpp http.cpp i2p_address.cpp parse.cpp resolve.cpp
+    socks.cpp socks_connect.cpp tor_address.cpp zmq.cpp)
+monero_find_all_headers(net_headers "${CMAKE_CURRENT_SOURCE_DIR}")
 
-add_library(net)
-target_sources(net
-    PRIVATE
-        ${NET_SOURCES}
-    )
+monero_add_library(net ${net_sources} ${net_headers})
+target_link_libraries(net common epee ${ZMQ_LIB} ${Boost_ASIO_LIBRARY})
 
-target_link_libraries(net PUBLIC
-        common
-        epee
-        ${ZMQ_LIBRARIES}
-        Boost::system)
-
-target_include_directories(net
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        PRIVATE ${ZMQ_INCLUDE_DIRS}
-        PRIVATE ${OPENSSL_INCLUDE_DIR}
-        )
-
-monero_install_library(net
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/net/"
-        HEADERS ${NET_HEADERS})

src/p2p/CMakeLists.txt

@@ -26,41 +26,27 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-file(GLOB P2P_SOURCES *.cpp *.c *.cc)
-set(P2P_HEADERS
-    net_node_common.h
-    net_node.h
-    net_peerlist_boost_serialization.h
-    net_peerlist.h
-    p2p_protocol_defs.h)
+cmake_minimum_required (VERSION 3.5)
+project (monero CXX)
 
-add_library(p2p)
-target_sources(p2p
-    PRIVATE
-        ${P2P_SOURCES}
-    )
+file(GLOB P2P *)
+source_group(p2p FILES ${P2P})
 
+#add_library(p2p ${P2P})
+
+#monero_private_headers(p2p ${P2P})
+monero_add_library(p2p ${P2P})
 target_link_libraries(p2p
   PUBLIC
     version
     cryptonote_core
     net
-    miniupnpc::miniupnpc
-    Boost::chrono
-    Boost::program_options
-    Boost::filesystem
-    Boost::system
-    Boost::thread
-    Boost::serialization)
-
-target_include_directories(p2p
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-        PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/external>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/>
-        PRIVATE ${OPENSSL_INCLUDE_DIR}
-        )
-
-monero_install_library(p2p
-        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/p2p/"
-        HEADERS ${P2P_HEADERS})
+    ${UPNP_LIBRARIES}
+    ${Boost_CHRONO_LIBRARY}
+    ${Boost_PROGRAM_OPTIONS_LIBRARY}
+    ${Boost_FILESYSTEM_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY}
+    ${Boost_THREAD_LIBRARY}
+    ${Boost_SERIALIZATION_LIBRARY}
+  PRIVATE
+    ${EXTRA_LIBRARIES})

src/p2p/net_node.inl

@@ -60,9 +60,9 @@
 #include "cryptonote_core/cryptonote_core.h"
 #include "net/parse.h"
 
-#include <miniupnpc/miniupnpc.h>
-#include <miniupnpc/upnpcommands.h>
-#include <miniupnpc/upnperrors.h>
+#include <miniupnp/miniupnpc/miniupnpc.h>
+#include <miniupnp/miniupnpc/upnpcommands.h>
+#include <miniupnp/miniupnpc/upnperrors.h>
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net.p2p"
@@ -247,23 +247,7 @@ namespace nodetool
     if (it == m_blocked_hosts.end())
     {
       m_blocked_hosts[host_str] = limit;
-
-      // if the host was already blocked due to being in a blocked subnet, let it be silent
-      bool matches_blocked_subnet = false;
-      if (addr.get_type_id() == epee::net_utils::address_type::ipv4)
-      {
-        auto ipv4_address = addr.template as<epee::net_utils::ipv4_network_address>();
-        for (auto jt = m_blocked_subnets.begin(); jt != m_blocked_subnets.end(); ++jt)
-        {
-          if (jt->first.matches(ipv4_address))
-          {
-            matches_blocked_subnet = true;
-            break;
-          }
-        }
-      }
-      if (!matches_blocked_subnet)
-        added = true;
+      added = true;
     }
     else if (it->second < limit || !add_only)
       it->second = limit;
@@ -333,7 +317,6 @@ namespace nodetool
       limit = std::numeric_limits<time_t>::max();
     else
       limit = now + seconds;
-    const bool added = m_blocked_subnets.find(subnet) == m_blocked_subnets.end();
     m_blocked_subnets[subnet] = limit;
 
     // drop any connection to that subnet. This should only have to look into
@@ -366,10 +349,7 @@ namespace nodetool
       conns.clear();
     }
 
-    if (added)
-      MCLOG_CYAN(el::Level::Info, "global", "Subnet " << subnet.host_str() << " blocked.");
-    else
-      MINFO("Subnet " << subnet.host_str() << " blocked.");
+    MCLOG_CYAN(el::Level::Info, "global", "Subnet " << subnet.host_str() << " blocked.");
     return true;
   }
   //-----------------------------------------------------------------------------------
@@ -714,20 +694,18 @@ namespace nodetool
     }
     else
     {
-      //full_addrs.insert("158.69.60.225:34567");   //  explore.wownero.com
-      //full_addrs.insert("159.65.91.59:34567");    //  jw
+      full_addrs.insert("158.69.60.225:34567");   //  explore.wownero.com
+      full_addrs.insert("159.65.91.59:34567");    //  jw
       full_addrs.insert("51.161.131.176:34567");  //  node.suchwow.xyz
-      //full_addrs.insert("167.114.196.241:34567"); //  wowbux.org
-      //full_addrs.insert("142.93.144.79:34567"); // idontwanttogototoronto.wow.fail
-      //full_addrs.insert("51.75.76.161:34567"); // eu-west-1.wow.xmr.pm
-      //full_addrs.insert("145.239.93.75:34567"); // eu-west-2.wow.xmr.pm
+      full_addrs.insert("167.114.196.241:34567"); //  wowbux.org
+      full_addrs.insert("142.93.144.79:34567"); // idontwanttogototoronto.wow.fail
+      full_addrs.insert("51.75.76.161:34567"); // eu-west-1.wow.xmr.pm
+      full_addrs.insert("145.239.93.75:34567"); // eu-west-2.wow.xmr.pm
       full_addrs.insert("88.198.199.23:34567");
-      //full_addrs.insert("167.114.119.46:34567"); // wownero.stackwallet.com
+      full_addrs.insert("167.114.119.46:34567"); // wownero.stackwallet.com
       full_addrs.insert("143.198.195.132:34567"); // singapore.muchwow.lol
       full_addrs.insert("134.122.53.193:34567"); // amsterdam.muchwow.lol
       full_addrs.insert("204.48.28.218:34567"); // nyc.muchwow.lol
-      full_addrs.insert("192.99.8.110:34567"); // node.monerodevs.org
-      full_addrs.insert("37.187.74.171:34567"); // node2.monerodevs.org
     }
     return full_addrs;
   }
@@ -861,9 +839,6 @@ namespace nodetool
           "77uase4p6y6jsjdf6z2kdgpxgh7nkvywagvhurzphbm7vrkyj2d2gdid.onion:34566",
           "v2admi6gbeprxnk6i2oscizhgy4v5ixu6iezkhj5udiwbfjjs2w7dnid.onion:34566",
           "ttc6kxud3fikyaypn5voknyyvqje7j3wnoevsb7rfjerolynnisurkqd.onion:34566",
-          "5enbij6tz3n2hw5ixzezfayd5gvckyg4xlktz74gj4l6u7olq7ovr3id.onion:34566",
-          "ukpgpdd5gqvholcctejvaaig5hb266td6zaszt55eivuf7docoox5lid.onion:34566",
-          "iorkdy6t4gdtwzn3iblnhy76nu7lhyz2qcvpj4wrspfxyvdrul7u22qd.onion:34566",
         };
       }
       return {};