wat

Ensures both transfers and sweeps use a fee that's calculated
from the tx's weight. Using different logic could theoretically
enable distinguishability between the two types of txs. We don't
want that.

.gitmodules

@@ -1,19 +1,12 @@
-[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://github.com/monero-project/supercop
-	branch = monero
+	url = https://git.wownero.com/dsc/supercop.git
+    branch = cmake-rewrite
 [submodule "external/randomwow"]
 	path = external/randomwow
-	url = https://codeberg.org/wownero/RandomWOW
-        branch = 1.2.1-wow
-
+	url = https://git.wownero.com/dsc/randomwow.git
+    branch = cmake-rewrite

Makefile

@@ -48,7 +48,7 @@ all: release-all
 
 depends:
 	cd contrib/depends && $(MAKE) HOST=$(target) && cd ../.. && mkdir -p build/$(target)/release
-	cd build/$(target)/release && USE_DEVICE_TREZOR_MANDATORY=1 cmake -DCMAKE_TOOLCHAIN_FILE=$(CURDIR)/contrib/depends/$(target)/share/toolchain.cmake ../../.. && $(MAKE)
+	cd build/$(target)/release && cmake -DCMAKE_TOOLCHAIN_FILE=$(CURDIR)/contrib/depends/$(target)/share/toolchain.cmake ../../.. && $(MAKE)
 
 cmake-debug:
 	mkdir -p $(builddir)/debug
@@ -104,7 +104,7 @@ release-all:
 
 release-static:
 	mkdir -p $(builddir)/release
-	cd $(builddir)/release && cmake -D BUILD_TESTS=OFF -D USE_DEVICE_TREZOR=OFF -D STATIC=ON -D BUILD_64=ON -D CMAKE_BUILD_TYPE=Release $(topdir) && $(MAKE)
+	cd $(builddir)/release && cmake -D BUILD_TESTS=OFF -D USE_DEVICE_TREZOR=OFF -D STATIC=ON -D ARCH="x86-64" -D BUILD_64=ON -D CMAKE_BUILD_TYPE=Release $(topdir) && $(MAKE)
 
 coverage:
 	mkdir -p $(builddir)/debug

README.md

@@ -1,12 +1,7 @@
-# ~~Mo~~Wownero -  Such privacy! Many coins! Wow!
+# ~~Mo~~Wownero -  Such privacy! Many coins! Wow! 🐕
 
-[<img src="https://suchwow.xyz/data/suchwow/image/to23moqn.jpeg">](https://suchwow.xyz/s/oh-really-9eda16b2/item)
-
-## Introduction
-
-Wownero is a Doge-inspired, CPU-mineable, solo-mining only, privacy-respecting memecoin. It was fairly launched on April Fools' Day in 2018. It is a software fork of Monero, but with a lite version of RandomX, larger ring size, and a fixed supply of 184 million coins emitted over 50 years. Wownero has no trusted setup, premine, or dev tax. Besides betting on online snail racing, the main use case of Wownero is micro-tipping meme creators with sound magic internet money. As a 100% community-driven, free and open source software, Wownero does not depend on billionaire shills or lame ass "influencers."
-
-Unlike Opposing Projects.
+Copyright (c) 2014-2023 The Monero Project.   
+Portions Copyright (c) 2012-2013 The Cryptonote developers.
 
 ## Resources
 
@@ -15,30 +10,33 @@ Unlike Opposing Projects.
 - Twitter: [@w0wn3r0](https://twitter.com/w0wn3r0)
 - Reddit: [/r/wownero](https://www.reddit.com/r/wownero)
 - Mail: [wownero@wownero.org](mailto:wownero@wownero.org)
-- Git: [codeberg.org/wownero/wownero](https://codeberg.org/wownero/wownero)
+- Git: [git.wownero.com/wownero/wownero](https://git.wownero.com/wownero/wownero)
+- Wownero Funding System: [funding.wownero.com](https://funding.wownero.com)
+- Wownero Forum: [forum.wownero.com](https://forum.wownero.com)
 - Discord: [discord.gg/ykZyAzJhDK](https://discord.com/invite/ykZyAzJhDK)
 - Telegram: [t.me/wownero](https://t.me/wownero)
-- Public Node Status: [monero.fail](https://monero.fail/?chain=wownero&network=mainnet)
+- Wowlet Desktop Wallet: [git.wownero.com/wowlet/wowlet](https://git.wownero.com/wowlet/wowlet/releases)
+- Stack Wallet iOS & Android Mobile Wallet: [stackwallet.com](https://stackwallet.com)
+- Wonerujo Android Mobile Wallet: [google store](https://play.google.com/store/apps/details?id=com.m2049r.wowwallet)
+- Elite Wallet Android Mobile Wallet: [github](https://github.com/Elite-Labs/EliteWallet)
+- Public Node Status: [monero.fail](https://monero.fail/?crypto=wownero)
 - Wownero Memes: [suchwow.xyz](https://suchwow.xyz/posts/top)
 - Market Info: [coinmarketcap.com](https://coinmarketcap.com/currencies/wownero), [coingecko.com](https://www.coingecko.com/en/coins/wownero/usd)
 
 ## Exchanges
 
-- [NonKYC](https://nonkyc.io/market/WOW_BTC)
 - [AltQuick](https://altquick.com/market/Wownero)
 - [Majestic Bank](https://majesticbank.sc)
 - [TradeOgre](https://tradeogre.com/exchange/BTC-WOW)
 
-## Wallets
+### Blockchain Explorers
 
-- Wonero CLI Wallet: [codeberg.org/wownero/wownero](https://codeberg.org/wownero/wownero/releases)
-- Wowlet Desktop Wallet: [codeberg.org/wownero/wowlet](https://codeberg.org/wownero/wowlet/releases)
-- Stack Wallet iOS & Android Mobile Wallet: [stackwallet.com](https://stackwallet.com)
-- Cake Wallet [cakewallet.com](https://cakewallet.com)
+- https://explore.wownero.com
+- https://muchwow.lol
 
-## Blockchain Explorers
+## Introduction
 
-- https://explorer.suchwow.xyz
+Wownero is a privacy-centric memecoin that was fairly launched on April 1, 2018 with no pre-mine, stealth-mine or ICO. Wownero has a maximum supply of around 184 million WOW with a slow and steady emission over 50 years. It is a fork of Monero, but with its own genesis block, so there is no degradation of privacy due to ring signatures using different participants for the same tx outputs on opposing forks.
 
 ## Supporting the project
 
@@ -47,8 +45,11 @@ Wownero is a 100% community-sponsored endeavor. Supporting services are also gra
 [<img src="https://git.wownero.com/wownero/meta/raw/branch/master/images/macstadium.png"
 alt="MacStadium"
 height="100">](https://www.macstadium.com)
+[<img src="https://git.wownero.com/wownero/meta/raw/branch/master/images/jetbrains.png"
+alt="JetBrains"
+height="100">](https://www.jetbrains.com)
 
-Developers are volunteers doing this mostly for shits and giggles. If you would like to support our shenanigans and stimulant addictions, please consider donating to the dev slush fund.
+Developers are volunteers doing this mostly for shits and giggles. If you would like to support our shenanigans and stimulant addictions, please consider donating to [WFS proposals](https://funding.wownero.com/proposals) or the dev slush fund.
 
 ### Donation Addresses
 
@@ -62,13 +63,19 @@ XMR: `44SQVPGLufPasUcuUQSZiF5c9BFzjcP8ucDxzzFDgLf1VkCEFaidJ3u2AhSKMhPLKA3jc2iS8w
 
 BTC: `bc1qcw9zglp3fxyl25zswemw7jczlqryms2lsmu464`
 
+### Open Collective
+
+Open Collective is an online funding platform for open source software and collaborative communities. The platform brings together legal entities that act as a “Fiscal Host”, “Collectives” (unincorporated, community-based projects), and individuals interested in supporting projects with donations. Fiscal hosts hold donations for collectives in trust and handle all the taxes and legal stuff.
+
+Wownero is hosted by Open Collective Europe, a Brussels-based non-profit that hosts many other collectives, such as Manjaro, EndeavourOS, Xfce, and peertube.social. If you would like donate to the Wownero Project using this method, you can check out our [Wownero - Open Collective](https://opencollective.com/wownero) page.
+
 ## Release staging and Contributing
 
 **Anyone is welcome to contribute to Wownero's codebase!**
 
 If you have a fix or code change, feel free to submit it as a pull request. Ahead of a scheduled software upgrade, a development branch will be created with the new release version tag. Pull requests that address bugs should be made to Master. Pull requests that require review and testing (generally, optimizations and new features) should be made to the development branch. All pull requests will be considered safe until the US dollar valuation of 1 Wownero equals $1000. After this valuation has been reached, more research will be needed to introduce experimental cryptography and/or code into the codebase.
 
-Things to Do, Work in Progress, and Help Wanted tasks are tracked in the [Meta](https://codeberg.org/wownero/meta/issues) repo.
+Things to Do, Work in Progress, and Help Wanted tasks are tracked in the [Meta](https://git.wownero.com/wownero/meta/issues) repo.
 
 Join `#wownero` on IRC OFTC to participate in development conversation.
 
@@ -77,7 +84,7 @@ Join `#wownero` on IRC OFTC to participate in development conversation.
 Wownero uses a fixed-schedule software upgrade (hard fork) mechanism to implement new features. This means that users of Wownero (end users and service providers) should run current versions and upgrade their software on a regular schedule. The required software for these upgrades will be available prior to the scheduled date. Please check the repository prior to this date for the proper Wownero software version. Below is the historical schedule and the projected schedule for the next upgrade.
 Dates are provided in the format YYYY-MM-DD.
 
-| Software upgrade block height | Date       | Release Name | Minimum Wownero version | Recommended Wownero version | Details                                                                            |
+| Software upgrade block height | Date       | Release Name | Minimum Wownero version | Recommended Wownero version | Details                                                                            |  
 |-------------------------------|------------| ----------------- |-------------------------|-----------------------------| ---------------------------------------------------------------------------------- |
 | 1                             | 2018-04-01 | Awesome Akita                | v0.1.0.0                | v0.1.0.0                    | Cryptonight variant 1, ringsize >= 8, sorted inputs
 | 69,69                         | 2018-04-24 | Busty Brazzers                | v0.2.0.0                | v0.2.0.0                    | Bulletproofs, LWMA difficulty algorithm, ringsize >= 10, reduce unlock to 4
@@ -89,12 +96,14 @@ 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.3.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.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
 
 X's indicate that these details have not been determined as of commit date.
 
 \* indicates estimate as of commit date
 
+## Installing from a package
+
 Packages are available for
 
 * Arch Linux/Manjaro
@@ -122,22 +131,21 @@ Packaging for your favorite distribution would be a welcome contribution!
 
 * Docker
 
-        git clone https://codeberg.org/wownero/wownero && cd wownero
+        git clone https://git.wownero.com/wownero/wownero && cd wownero
         docker build -t git-wow:master -m 4g .
         docker run -it -p 34567:34567 -p 34568:34568 -w /home/wownero/build/release/bin git-wow:master bash
 
 * Arch Linux/Manjaro
 
-        sudo pacman -Syu --needed base-devel cmake boost openssl zeromq libpgm unbound libsodium libunwind xz readline expat gtest python3 ccache doxygen graphviz qt5-tools hidapi libusb protobuf systemd gcc13
-        git clone https://codeberg.org/wownero/wownero && cd wownero
-        export CC=gcc-13 CXX=g++-13
+        sudo pacman -Syu && sudo pacman -S base-devel cmake boost openssl zeromq libpgm unbound libsodium git libusb systemd
+        git clone https://git.wownero.com/wownero/wownero && cd wownero
         make -j2
 
 * Debian/Ubuntu
 
-        sudo apt update && sudo apt install build-essential cmake pkg-config libssl-dev libzmq3-dev libunbound-dev libsodium-dev libunwind8-dev liblzma-dev libreadline6-dev libexpat1-dev libpgm-dev qttools5-dev-tools libhidapi-dev libusb-1.0-0-dev libprotobuf-dev protobuf-compiler libudev-dev libboost-chrono-dev libboost-date-time-dev libboost-filesystem-dev libboost-locale-dev libboost-program-options-dev libboost-regex-dev libboost-serialization-dev libboost-system-dev libboost-thread-dev python3 ccache doxygen graphviz gcc-13 g++-13
-        git clone https://codeberg.org/wownero/wownero && cd wownero
-        CC="gcc-13" CXX="g++-13" make -j2
+        sudo apt update && sudo apt install build-essential cmake pkg-config libboost-all-dev libssl-dev libzmq3-dev libunbound-dev libsodium-dev libunwind8-dev liblzma-dev libreadline6-dev libldns-dev libexpat1-dev libpgm-dev libhidapi-dev libusb-1.0-0-dev libprotobuf-dev protobuf-compiler libudev-dev git -y
+        git clone https://git.wownero.com/wownero/wownero && cd wownero
+        make -j2
 
 
 ## Running Binaries
@@ -160,7 +168,7 @@ To run in background:
 
 To run as a systemd service, copy
 [wownerod.service](utils/systemd/wownerod.service) to `/etc/systemd/system/` and
-[wow.conf](utils/conf/wow.conf) to `/etc/`. The [example
+[wow.conf](wow.conf) to `/etc/`. The [example
 service](utils/systemd/wownerod.service) assumes that the user `wownero` exists
 and its home is the data directory specified in the [example
 config](wow.conf).
@@ -188,7 +196,7 @@ HiddenServiceVersion 3
 save and close nano
 
 * `sudo /etc/init.d/tor restart && sudo systemctl enable tor`
-* copy [wow.conf](utils/conf/wow.conf) file and save it in same directory as `wownerod`.
+* copy [wow.conf](https://git.wownero.com/wownero/wownero/raw/branch/master/wow.conf) file and save it in same directory as `wownerod`.
 * start wownerod like this:
 
 ```
@@ -196,16 +204,14 @@ save and close nano
 ```
 
 * `sudo cat /var/lib/tor/wownero/hostname`
-
-Copy your onion address and share node with others [here](https://monero.fail/?crypto=wownero).
+  copy your onion address and share node with others [here](https://monero.fail/?crypto=wownero) and [here](https://forum.wownero.com/t/wownero-tor-onion-sites/623)
 
 To share your node over p2p, uncomment first line of wownerod.conf and add your onion address.
 
+More information on running Tor and i2p nodes is available [here](https://forum.wownero.com/t/how-to-setup-a-full-node-with-tor-i2p/588)
+
 ### Access remote Tor node from CLI wallet
 
 ```
 ./wownero-wallet-cli --proxy 127.0.0.1:9050 --daemon-address iy6ry6uudpzvbd72zsipepukp6nsazjdu72n52vg3isfnxqn342flzad.onion:34568
 ```
-
-Copyright (c) 2014-2024 The Monero Project.
-Portions Copyright (c) 2012-2013 The Cryptonote developers.

cmake/CheckLinkerFlag.c

@@ -1,14 +0,0 @@
-#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

@@ -1,48 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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

@@ -1,14 +0,0 @@
-/* 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

@@ -0,0 +1,104 @@
+#[=======================================================================[.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

@@ -1,40 +0,0 @@
-# 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

@@ -0,0 +1,17 @@
+# - 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

@@ -0,0 +1,291 @@
+# 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

@@ -0,0 +1,51 @@
+@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

@@ -1,72 +0,0 @@
-# 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

@@ -0,0 +1,95 @@
+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

@@ -1,52 +0,0 @@
-// 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

@@ -1,43 +0,0 @@
-// 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

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

cmake/test-static-assert.c

@@ -1,34 +0,0 @@
-// 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

@@ -1,34 +0,0 @@
-// 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,6 +26,5 @@
 # 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/funcs.mk

@@ -145,7 +145,7 @@ $(1)_build_env+=PATH="$(build_prefix)/bin:$(PATH)"
 $(1)_stage_env+=PATH="$(build_prefix)/bin:$(PATH)"
 $(1)_autoconf=./configure --host=$($($(1)_type)_host) --prefix=$($($(1)_type)_prefix) $$($(1)_config_opts) CC="$$($(1)_cc)" CXX="$$($(1)_cxx)"
 
-ifeq ($(filter $(1),libusb unbound),)
+ifneq ($(1),libusb)
 $(1)_autoconf += --disable-dependency-tracking
 endif
 ifneq ($($(1)_nm),)

contrib/depends/packages/expat.mk

@@ -1,12 +1,12 @@
 package=expat
-$(package)_version=2.6.0
-$(package)_download_path=https://github.com/libexpat/libexpat/releases/download/R_$(subst .,_,$($(package)_version))/
+$(package)_version=2.4.1
+$(package)_download_path=https://github.com/libexpat/libexpat/releases/download/R_2_4_1
 $(package)_file_name=$(package)-$($(package)_version).tar.bz2
-$(package)_sha256_hash=ff60e6a6b6ce570ae012dc7b73169c7fdf4b6bf08c12ed0ec6f55736b78d85ba
+$(package)_sha256_hash=2f9b6a580b94577b150a7d5617ad4643a4301a6616ff459307df3e225bcfbf40
 
 define $(package)_set_vars
-$(package)_config_opts=--disable-shared --without-docbook --without-tests --without-examples
-$(package)_config_opts+=--enable-option-checking --without-xmlwf --with-pic
+$(package)_config_opts=--enable-static
+$(package)_config_opts=--disable-shared
 $(package)_config_opts+=--prefix=$(host_prefix)
 endef
 
@@ -23,6 +23,6 @@ define $(package)_stage_cmds
 endef
 
 define $(package)_postprocess_cmds
-  rm -rf share lib/cmake lib/*.la
+  rm lib/*.la
 endef
 

contrib/depends/packages/openssl.mk

@@ -1,8 +1,8 @@
 package=openssl
-$(package)_version=3.0.13
+$(package)_version=3.0.11
 $(package)_download_path=https://www.openssl.org/source
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=88525753f79d3bec27d2fa7c66aa0b92b3aa9498dafd93d7cfa4b3780cdae313
+$(package)_sha256_hash=b3425d3bb4a2218d0697eb41f7fc0cdede016ed19ca49d168b78e8d947887f55
 
 define $(package)_set_vars
 $(package)_config_env=AR="$($(package)_ar)" ARFLAGS=$($(package)_arflags) RANLIB="$($(package)_ranlib)" CC="$($(package)_cc)"

contrib/depends/packages/unbound.mk

@@ -1,21 +1,18 @@
 package=unbound
-$(package)_version=1.19.1
+$(package)_version=1.15.0
 $(package)_download_path=https://www.nlnetlabs.nl/downloads/$(package)/
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=bc1d576f3dd846a0739adc41ffaa702404c6767d2b6082deb9f2f97cbb24a3a9
+$(package)_sha256_hash=a480dc6c8937447b98d161fe911ffc76cfaffa2da18788781314e81339f1126f
 $(package)_dependencies=openssl expat
 $(package)_patches=disable-glibc-reallocarray.patch
 
 
 define $(package)_set_vars
-  $(package)_config_opts=--disable-shared --enable-static --without-pyunbound --prefix=$(host_prefix)
-  $(package)_config_opts+=--with-libexpat=$(host_prefix) --with-ssl=$(host_prefix) --with-libevent=no
-  $(package)_config_opts+=--without-pythonmodule --disable-flto --with-pthreads --with-libunbound-only
+  $(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"
-  $(package)_cflags_mingw32+="-D_WIN32_WINNT=0x600"
 endef
 
 define $(package)_preprocess_cmds
@@ -34,3 +31,6 @@ endef
 define $(package)_stage_cmds
   $(MAKE) DESTDIR=$($(package)_staging_dir) install
 endef
+
+define $(package)_postprocess_cmds
+endef

contrib/depends/toolchain.cmake.in

@@ -144,11 +144,8 @@ elseif(ARCHITECTURE STREQUAL "aarch64")
 endif()
 
 if(ARCHITECTURE STREQUAL "riscv64")
-  if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    set(BUILD_TAG "linux-riscv64")
-  endif()
-  set(ARCH_ID "riscv64")
-  set(ARCH "rv64gc")
+    set(ARCH_ID "riscv64")
+    set(ARCH "rv64gc")
 endif()
 
 if(ARCHITECTURE STREQUAL "i686")

contrib/epee/include/byte_stream.h

@@ -74,7 +74,6 @@ namespace epee
   public:
     using char_type = std::uint8_t;
     using Ch = char_type;
-    using value_type = char_type;
 
     //! Increase internal buffer by at least `byte_stream_increase` bytes.
     byte_stream() noexcept
@@ -87,7 +86,6 @@ namespace epee
     ~byte_stream() noexcept = default;
     byte_stream& operator=(byte_stream&& rhs) noexcept;
 
-    std::uint8_t* data() noexcept { return buffer_.get(); }
     const std::uint8_t* data() const noexcept { return buffer_.get(); }
     std::uint8_t* tellp() const noexcept { return next_write_; }
     std::size_t available() const noexcept { return end_ - next_write_; }

contrib/epee/include/net/http_client.h

@@ -245,8 +245,18 @@ 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(2048);
+				req_buff.reserve(req_buff_cap);
 				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()));
@@ -255,9 +265,7 @@ 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);
@@ -265,11 +273,21 @@ namespace net_utils
 					req_buff += "\r\n";
 					//--
 
-					bool res = m_net_client.send(req_buff, timeout);
-					CHECK_AND_ASSERT_MES(res, false, "HTTP_CLIENT: Failed to SEND");
-					if(body.size())
+					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");
 						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;
@@ -282,19 +300,11 @@ namespace net_utils
 						return true;
 					}
 
-					switch (m_auth.handle_401(m_response_info))
+					if (m_auth.handle_401(m_response_info) == http_client_auth::kParseFailure)
 					{
-					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/net/http_server_handlers_map2.h

@@ -171,13 +171,6 @@
       epee::serialization::store_t_to_json(static_cast<epee::json_rpc::error_response&>(rsp), response_info.m_body); \
       return true; \
     } \
-    epee::serialization::storage_entry params_; \
-    params_ = epee::serialization::storage_entry(epee::serialization::section()); \
-    if(!ps.get_value("params", params_, nullptr)) \
-    { \
-      epee::serialization::section params_section; \
-      ps.set_value("params", std::move(params_section), nullptr); \
-    } \
     if(false) return true; //just a stub to have "else if"
 
 

contrib/epee/include/serialization/keyvalue_serialization.h

@@ -98,18 +98,16 @@ public: \
 #define KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(varialble, val_name) \
   epee::serialization::selector<is_store>::serialize_t_val_as_blob(this_ref.varialble, stg, hparent_section, val_name); 
 
-#define KV_SERIALIZE_VAL_POD_AS_BLOB_N(variable, val_name) \
-  static_assert(std::is_trivially_copyable<decltype(this_ref.variable)>(), "t_type must be a trivially copyable type."); \
-  static_assert(std::is_standard_layout<decltype(this_ref.variable)>(), "t_type must be a standard layout type."); \
-  KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(variable, val_name)
+#define KV_SERIALIZE_VAL_POD_AS_BLOB_N(varialble, val_name) \
+  static_assert(std::is_pod<decltype(this_ref.varialble)>::value, "t_type must be a POD type."); \
+  KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(varialble, val_name)
 
-#define KV_SERIALIZE_VAL_POD_AS_BLOB_OPT_N(variable, val_name, default_value) \
+#define KV_SERIALIZE_VAL_POD_AS_BLOB_OPT_N(varialble, val_name, default_value) \
   do { \
-    static_assert(std::is_trivially_copyable<decltype(this_ref.variable)>(), "t_type must be a trivially copyable type."); \
-    static_assert(std::is_standard_layout<decltype(this_ref.variable)>(), "t_type must be a standard layout type."); \
-    bool ret = KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(variable, val_name) \
+    static_assert(std::is_pod<decltype(this_ref.varialble)>::value, "t_type must be a POD type."); \
+    bool ret = KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(varialble, val_name); \
     if (!ret) \
-      epee::serialize_default(this_ref.variable, default_value); \
+      epee::serialize_default(this_ref.varialble, default_value); \
   } while(0);
 
 #define KV_SERIALIZE_CONTAINER_POD_AS_BLOB_N(varialble, val_name) \
@@ -120,7 +118,7 @@ public: \
 #define KV_SERIALIZE(varialble)                           KV_SERIALIZE_N(varialble, #varialble)
 #define KV_SERIALIZE_VAL_POD_AS_BLOB(varialble)           KV_SERIALIZE_VAL_POD_AS_BLOB_N(varialble, #varialble)
 #define KV_SERIALIZE_VAL_POD_AS_BLOB_OPT(varialble, def)  KV_SERIALIZE_VAL_POD_AS_BLOB_OPT_N(varialble, #varialble, def)
-#define KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE(varialble)     KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(varialble, #varialble) //skip is_trivially_copyable and is_standard_layout compile time check
+#define KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE(varialble)     KV_SERIALIZE_VAL_POD_AS_BLOB_FORCE_N(varialble, #varialble) //skip is_pod compile time check
 #define KV_SERIALIZE_CONTAINER_POD_AS_BLOB(varialble)     KV_SERIALIZE_CONTAINER_POD_AS_BLOB_N(varialble, #varialble)
 #define KV_SERIALIZE_OPT(variable,default_value)          KV_SERIALIZE_OPT_N(variable, #variable, default_value)
 

contrib/epee/include/span.h

@@ -133,14 +133,17 @@ namespace epee
     return {src.data(), src.size()};
   }
 
+  template<typename T>
+  constexpr bool has_padding() noexcept
+  {
+    return !std::is_standard_layout<T>() || alignof(T) != 1;
+  }
+
   //! \return Cast data from `src` as `span<const std::uint8_t>`.
   template<typename T>
   span<const std::uint8_t> to_byte_span(const span<const T> src) noexcept
   {
-    static_assert(!std::is_empty<T>(), "empty value types will not work -> sizeof == 1");
-    static_assert(std::is_standard_layout<T>(), "type must have standard layout");
-    static_assert(std::is_trivially_copyable<T>(), "type must be trivially copyable");
-    static_assert(alignof(T) == 1, "type may have padding");
+    static_assert(!has_padding<T>(), "source type may have padding");
     return {reinterpret_cast<const std::uint8_t*>(src.data()), src.size_bytes()}; 
   }
 
@@ -150,9 +153,7 @@ namespace epee
   {
     using value_type = typename T::value_type;
     static_assert(!std::is_empty<value_type>(), "empty value types will not work -> sizeof == 1");
-    static_assert(std::is_standard_layout<value_type>(), "value type must have standard layout");
-    static_assert(std::is_trivially_copyable<value_type>(), "value type must be trivially copyable");
-    static_assert(alignof(value_type) == 1, "value type may have padding");
+    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)};
   }
 
@@ -161,9 +162,7 @@ namespace epee
   span<const std::uint8_t> as_byte_span(const T& src) noexcept
   {
     static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
-    static_assert(std::is_standard_layout<T>(), "type must have standard layout");
-    static_assert(std::is_trivially_copyable<T>(), "type must be trivially copyable");
-    static_assert(alignof(T) == 1, "type may have padding");
+    static_assert(!has_padding<T>(), "source type may have padding");
     return {reinterpret_cast<const std::uint8_t*>(std::addressof(src)), sizeof(T)};
   }
 
@@ -172,9 +171,7 @@ namespace epee
   span<std::uint8_t> as_mut_byte_span(T& src) noexcept
   {
     static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
-    static_assert(std::is_standard_layout<T>(), "type must have standard layout");
-    static_assert(std::is_trivially_copyable<T>(), "type must be trivially copyable");
-    static_assert(alignof(T) == 1, "type may have padding");
+    static_assert(!has_padding<T>(), "source type may have padding");
     return {reinterpret_cast<std::uint8_t*>(std::addressof(src)), sizeof(T)};
   }
 

contrib/epee/include/storages/portable_storage_val_converters.h

@@ -37,7 +37,6 @@
 #include "misc_log_ex.h"
 
 #include <boost/lexical_cast.hpp>
-#include <boost/numeric/conversion/bounds.hpp>
 #include <typeinfo>
 #include <iomanip>
 

contrib/epee/include/string_tools.h

@@ -31,7 +31,6 @@
 #include "mlocker.h"
 
 #include <boost/utility/string_ref.hpp>
-#include <boost/algorithm/string.hpp> 
 #include <sstream>
 #include <string>
 #include <cstdint>
@@ -70,17 +69,23 @@ namespace string_tools
 #ifdef _WIN32
    std::string get_current_module_path();
 #endif
-  void set_module_name_and_folder(const std::string& path_to_process_);
+  bool set_module_name_and_folder(const std::string& path_to_process_);
+  bool trim_left(std::string& str);
+  bool trim_right(std::string& str);
   //----------------------------------------------------------------------------
   inline std::string& trim(std::string& str)
   {
-    boost::trim(str);
+    trim_left(str);
+    trim_right(str);
     return str;
   }
   //----------------------------------------------------------------------------
-  inline std::string trim(const std::string& str)
+  inline std::string trim(const std::string& str_)
   {
-    return boost::trim_copy(str);
+    std::string str = str_;
+    trim_left(str);
+    trim_right(str);
+    return str;
   }
   std::string pad_string(std::string s, size_t n, char c = ' ', bool prepend = false);
   
@@ -89,7 +94,6 @@ namespace string_tools
   std::string pod_to_hex(const t_pod_type& s)
   {
     static_assert(std::is_standard_layout<t_pod_type>(), "expected standard layout type");
-    static_assert(alignof(t_pod_type) == 1, "type may have padding");
     return to_hex::string(as_byte_span(s));
   }
   //----------------------------------------------------------------------------
@@ -97,8 +101,6 @@ namespace string_tools
   bool hex_to_pod(const boost::string_ref hex_str, t_pod_type& s)
   {
     static_assert(std::is_standard_layout<t_pod_type>(), "expected standard layout type");
-    static_assert(alignof(t_pod_type) == 1, "type may have padding");
-    static_assert(std::is_trivially_copyable<t_pod_type>(), "type must be trivially copyable");
     return from_hex::to_buffer(as_mut_byte_span(s), hex_str);
   }
   //----------------------------------------------------------------------------

contrib/epee/src/CMakeLists.txt

@@ -27,64 +27,37 @@
 # 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")
 
-# 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}
+file(GLOB EPEE_SOURCES
+    "${CMAKE_CURRENT_SOURCE_DIR}/*.c"
+    "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
     )
 
-if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW)))
-  monero_add_library(epee_readline readline_buffer.cpp)
-endif()
+add_library(epee)
+target_sources(epee
+    PRIVATE
+        ${EPEE_SOURCES}
+    )
 
 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_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()
+    Boost::chrono
+    Boost::filesystem
+    Boost::thread
+    Boost::regex
+    Boost::system
+    OpenSSL::SSL)
 
 target_include_directories(epee
-  PUBLIC
-    "${EPEE_INCLUDE_DIR_BASE}"
-    "${OPENSSL_INCLUDE_DIR}")
+        PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
+        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+        PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/monero/epee/>)
 
+install(DIRECTORY ${EPEE_INCLUDE_DIR_BASE}/
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/monero/epee/")
+
+monero_install_library(epee)

contrib/epee/src/byte_slice.cpp

@@ -152,11 +152,7 @@ namespace epee
   {
     std::size_t space_needed = 0;
     for (const auto& source : sources)
-    {
-      if (std::numeric_limits<std::size_t>::max() - space_needed < source.size())
-        throw std::bad_alloc{};
       space_needed += source.size();
-    }
 
     if (space_needed)
     {
@@ -166,9 +162,9 @@ namespace epee
 
       for (const auto& source : sources)
       {
-        assert(source.size() <= out.size()); // see check above
         std::memcpy(out.data(), source.data(), source.size());
-        out.remove_prefix(source.size());
+        if (out.remove_prefix(source.size()) < source.size())
+          throw std::bad_alloc{}; // size_t overflow on space_needed
       }
       storage_ = std::move(storage);
     }

contrib/epee/src/mlog.cpp

@@ -176,12 +176,11 @@ void mlog_configure(const std::string &filename_base, bool console, const std::s
       std::vector<boost::filesystem::path> found_files;
       const boost::filesystem::directory_iterator end_itr;
       const boost::filesystem::path filename_base_path(filename_base);
-      const std::string filename_base_name = filename_base_path.filename().string();
       const boost::filesystem::path parent_path = filename_base_path.has_parent_path() ? filename_base_path.parent_path() : ".";
       for (boost::filesystem::directory_iterator iter(parent_path); iter != end_itr; ++iter)
       {
-        const std::string filename = iter->path().filename().string();
-        if (filename.size() >= filename_base_name.size() && std::memcmp(filename.data(), filename_base_name.data(), filename_base_name.size()) == 0)
+        const std::string filename = iter->path().string();
+        if (filename.size() >= filename_base.size() && std::memcmp(filename.data(), filename_base.data(), filename_base.size()) == 0)
         {
           found_files.push_back(iter->path());
         }
@@ -339,21 +338,11 @@ 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:
@@ -472,9 +461,6 @@ 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/readline_buffer.cpp

@@ -238,10 +238,6 @@ 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/epee/src/string_tools.cpp

@@ -38,12 +38,9 @@
 #include <cstdlib>
 #include <string>
 #include <type_traits>
-#include <system_error>
 #include <boost/lexical_cast.hpp>
-#include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/utility/string_ref.hpp>
-#include <boost/filesystem.hpp>
 #include "misc_log_ex.h"
 #include "storages/parserse_base_utils.h"
 #include "hex.h"
@@ -160,20 +157,46 @@ namespace string_tools
     return pname;
   }
 #endif
-
-  void set_module_name_and_folder(const std::string& path_to_process_)
-  {
-    boost::filesystem::path path_to_process = path_to_process_;
-
+	
+    bool set_module_name_and_folder(const std::string& path_to_process_)
+	{
+    std::string path_to_process = path_to_process_;
 #ifdef _WIN32
     path_to_process = get_current_module_path();
 #endif 
+		std::string::size_type a = path_to_process.rfind( '\\' );
+		if(a == std::string::npos )
+		{
+			a = path_to_process.rfind( '/' );
+		}
+		if ( a != std::string::npos )
+		{	
+			get_current_module_name() = path_to_process.substr(a+1, path_to_process.size());
+			get_current_module_folder() = path_to_process.substr(0, a);
+			return true;
+		}else
+			return false;
 
-    get_current_module_name() = path_to_process.filename().string();
-    get_current_module_folder() = path_to_process.parent_path().string();
-  }
+	}
 
 	//----------------------------------------------------------------------------
+	bool trim_left(std::string& str)
+	{
+		for(std::string::iterator it = str.begin(); it!= str.end() && isspace(static_cast<unsigned char>(*it));)
+			str.erase(str.begin());
+			
+		return true;
+	}
+	//----------------------------------------------------------------------------
+	bool trim_right(std::string& str)
+	{
+
+		for(std::string::reverse_iterator it = str.rbegin(); it!= str.rend() && isspace(static_cast<unsigned char>(*it));)
+			str.erase( --((it++).base()));
+
+		return true;
+	}
+  //----------------------------------------------------------------------------
   std::string pad_string(std::string s, size_t n, char c, bool prepend)
   {
     if (s.size() < n)
@@ -186,22 +209,28 @@ namespace string_tools
     return s;
   }
   
-  std::string get_extension(const std::string& str)
-  {
-    std::string ext_with_dot = boost::filesystem::path(str).extension().string();
-
-    if (ext_with_dot.empty())
-      return {};
-
-    return ext_with_dot.erase(0, 1);
-  }
-
+    std::string get_extension(const std::string& str)
+	{
+		std::string res;
+		std::string::size_type pos = str.rfind('.');
+		if(std::string::npos == pos)
+			return res;
+		
+		res = str.substr(pos+1, str.size()-pos);
+		return res;
+	}
 	//----------------------------------------------------------------------------
-  std::string cut_off_extension(const std::string& str)
-  {
-    return boost::filesystem::path(str).replace_extension("").string();
-  }
+	std::string cut_off_extension(const std::string& str)
+	{
+		std::string res;
+		std::string::size_type pos = str.rfind('.');
+		if(std::string::npos == pos)
+			return str;
 
+		res = str.substr(0, pos);
+		return res;
+	}
+  //----------------------------------------------------------------------------
 #ifdef _WIN32
   std::wstring utf8_to_utf16(const std::string& str)
   {

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.4
+VERSION=v0.18.3.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.4
+VERSION=v0.18.3.0
 ```
 
 Where `GH_USER` is your GitHub user name and `VERSION` is the version tag you want to build. 

contrib/gitian/dockrun.sh

@@ -41,10 +41,10 @@ RUN useradd -ms /bin/bash -U ubuntu -G docker
 USER ubuntu:docker
 WORKDIR $WORKDIR
 
-RUN	git clone https://codeberg.org/wownero/gitian.sigs.git sigs; \
+RUN	git clone https://git.wownero.com/wownero/gitian.sigs.git sigs; \
   git clone https://github.com/devrandom/gitian-builder.git builder; \
   cd builder; git checkout c0f77ca018cb5332bfd595e0aff0468f77542c23; mkdir -p inputs var; cd inputs; \
-  git clone https://codeberg.org/wownero/wownero
+  git clone https://git.wownero.com/wownero/wownero
 
 CMD ["sleep", "infinity"]
 EOF
@@ -109,7 +109,7 @@ if [ "$check" != "sign" ]; then
 fi
 
 if [ ! -d sigs ]; then
-	git clone https://codeberg.org/wownero/gitian.sigs.git sigs
+	git clone https://git.wownero.com/wownero/gitian.sigs.git sigs
 	cd sigs
 	git remote add $GH_USER git@github.com:$GH_USER/gitian.sigs.git
 	cd ..

contrib/gitian/gitian-android.yml

@@ -26,7 +26,7 @@ packages:
 - "cmake"
 - "unzip"
 remotes:
-- "url": "https://codeberg.org/wownero/wownero.git"
+- "url": "https://git.wownero.com/wownero/wownero.git"
   "dir": "wownero"
 files: []
 script: |

contrib/gitian/gitian-build.py

@@ -5,7 +5,7 @@ import os
 import subprocess
 import sys
 
-gsigs = 'https://codeberg.org/wownero/gitian.sigs.git'
+gsigs = 'https://git.wownero.com/wownero/gitian.sigs.git'
 gbrepo = 'https://github.com/devrandom/gitian-builder.git'
 
 platforms = {'l': ['Linux', 'linux', 'tar.bz2'],
@@ -113,7 +113,7 @@ def main():
     parser = argparse.ArgumentParser(description='Script for running full Gitian builds.', usage='%(prog)s [options] signer version')
     parser.add_argument('-c', '--commit', action='store_true', dest='commit', help='Indicate that the version argument is for a commit or branch')
     parser.add_argument('-p', '--pull', action='store_true', dest='pull', help='Indicate that the version argument is the number of a github repository pull request')
-    parser.add_argument('-u', '--url', dest='url', default='https://codeberg.org/wownero/wownero', help='Specify the URL of the repository. Default is %(default)s')
+    parser.add_argument('-u', '--url', dest='url', default='https://git.wownero.com/wownero/wownero', help='Specify the URL of the repository. Default is %(default)s')
     parser.add_argument('-v', '--verify', action='store_true', dest='verify', help='Verify the Gitian build')
     parser.add_argument('-b', '--build', action='store_true', dest='build', help='Do a Gitian build')
     parser.add_argument('-B', '--buildsign', action='store_true', dest='buildsign', help='Build both signed and unsigned binaries')

contrib/gitian/gitian-freebsd.yml

@@ -26,7 +26,7 @@ packages:
 - "python"
 - "cmake"
 remotes:
-- "url": "https://codeberg.org/wownero/wownero.git"
+- "url": "https://git.wownero.com/wownero/wownero.git"
   "dir": "wownero"
 files: []
 script: |

contrib/gitian/gitian-linux.yml

@@ -21,7 +21,6 @@ packages:
 - "g++-7-arm-linux-gnueabihf"
 - "gcc-arm-linux-gnueabihf"
 - "g++-arm-linux-gnueabihf"
-- "g++-riscv64-linux-gnu"
 - "g++-7-multilib"
 - "gcc-7-multilib"
 - "binutils-arm-linux-gnueabihf"
@@ -38,13 +37,13 @@ packages:
 - "python"
 - "cmake"
 remotes:
-- "url": "https://codeberg.org/wownero/wownero.git"
+- "url": "https://git.wownero.com/wownero/wownero.git"
   "dir": "wownero"
 files: []
 script: |
 
   WRAP_DIR=$HOME/wrapped
-  HOSTS="x86_64-linux-gnu arm-linux-gnueabihf aarch64-linux-gnu i686-linux-gnu riscv64-linux-gnu"
+  HOSTS="x86_64-linux-gnu arm-linux-gnueabihf aarch64-linux-gnu i686-linux-gnu"
   FAKETIME_HOST_PROGS=""
   FAKETIME_PROGS="date"
   HOST_CFLAGS="-O2 -g"
@@ -160,13 +159,7 @@ script: |
     fi
     export C_INCLUDE_PATH="$EXTRA_INCLUDES"
     export CPLUS_INCLUDE_PATH="$EXTRA_INCLUDES"
-    #  glibc only added riscv support in 2.27, disable backwards compatibility
-    if [ "$i" == "riscv64-linux-gnu" ]; then
-      BACKCOMPAT_OPTION=OFF
-    else
-      BACKCOMPAT_OPTION=ON
-    fi
-    cmake .. -DCMAKE_TOOLCHAIN_FILE=${BASEPREFIX}/${i}/share/toolchain.cmake -DBACKCOMPAT=${BACKCOMPAT_OPTION} -DCMAKE_SKIP_RPATH=ON
+    cmake .. -DCMAKE_TOOLCHAIN_FILE=${BASEPREFIX}/${i}/share/toolchain.cmake -DBACKCOMPAT=ON -DCMAKE_SKIP_RPATH=ON
     make ${MAKEOPTS}
     chmod 755 bin/*
     cp ../utils/conf/wow.conf bin

contrib/gitian/gitian-osx.yml

@@ -24,7 +24,7 @@ packages:
 - "python-dev"
 - "python-setuptools"
 remotes:
-- "url": "https://codeberg.org/wownero/wownero.git"
+- "url": "https://git.wownero.com/wownero/wownero.git"
   "dir": "wownero"
 files: []
 script: |

contrib/gitian/gitian-win.yml

@@ -35,7 +35,7 @@ alternatives:
   package: "x86_64-w64-mingw32-gcc"
   path: "/usr/bin/x86_64-w64-mingw32-gcc-posix"
 remotes:
-- "url": "https://codeberg.org/wownero/wownero.git"
+- "url": "https://git.wownero.com/wownero/wownero.git"
   "dir": "wownero"
 files: []
 script: |

docs/ANONYMITY_NETWORKS.md

@@ -71,13 +71,13 @@ type, and max connections:
 
 ```
 --anonymous-inbound rveahdfho7wo4b2m.onion:28083,127.0.0.1:28083,25
---anonymous-inbound cmeua5767mz2q5jsaelk2rxhf67agrwuetaso5dzbenyzwlbkg2q.b32.i2p,127.0.0.1:30000
+--anonymous-inbound cmeua5767mz2q5jsaelk2rxhf67agrwuetaso5dzbenyzwlbkg2q.b32.i2p:5000,127.0.0.1:30000
 ```
 
 which tells `monerod` that a max of 25 inbound Tor connections are being
 received at address "rveahdfho7wo4b2m.onion:28083" and forwarded to `monerod`
 localhost port 28083, and a default max I2P connections are being received at
-address "cmeua5767mz2q5jsaelk2rxhf67agrwuetaso5dzbenyzwlbkg2q.b32.i2p" and
+address "cmeua5767mz2q5jsaelk2rxhf67agrwuetaso5dzbenyzwlbkg2q.b32.i2p:5000" and
 forwarded to `monerod` localhost port 30000.
 These addresses will be shared with outgoing peers, over the same network type,
 otherwise the peer will not be notified of the peer address by the proxy.

external/CMakeLists.txt

@@ -28,45 +28,11 @@
 # 
 # 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 EXCLUDE_FROM_ALL)
+add_subdirectory(randomwow)
+add_subdirectory(supercop)
+
+install(DIRECTORY boost
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/monero/")

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)
-  add_definitions(-DMDB_DSYNC=O_SYNC)
+  target_compile_definitions(lmdb PUBLIC MDB_DSYNC=O_SYNC)
 endif()
 
 if(ANDROID)
-  add_definitions("-DANDROID=1")
+  target_compile_definitions(lmdb PUBLIC ANDROID=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 -DMDB_VL32)
+  target_compile_definitions(lmdb PUBLIC MDB_VL32=1)
 endif()
 
-# 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")
+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")

external/easylogging++/CMakeLists.txt

@@ -26,43 +26,31 @@
 # 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.
 
-cmake_minimum_required(VERSION 3.5)
+set(EL_HEADERS
+    easylogging++.h
+    ea_config.h)
 
-project(easylogging CXX)
+add_library(easylogging)
+target_sources(easylogging
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/easylogging++.cc
+    )
 
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
+target_compile_definitions(easylogging PUBLIC
+        AUTO_INITIALIZE_EASYLOGGINGPP
+        )
 
-monero_enable_coverage()
+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++/>
+        )
 
-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
-    ${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")
+    PRIVATE
+        Threads::Threads
+        ${Backtrace_LIBRARIES})
 
+monero_install_library(easylogging
+        INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/monero/easylogging++/"
+        HEADERS ${EL_HEADERS})

external/easylogging++/easylogging++.cc

@@ -149,11 +149,6 @@ 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,8 +1,16 @@
-project(libqrcodegen)
+add_library(qrcodegen)
 
-add_library(qrcodegen STATIC QrCode.cpp)
-set_target_properties(qrcodegen PROPERTIES POSITION_INDEPENDENT_CODE ON)
-set_target_properties(qrcodegen PROPERTIES CXX_STANDARD 11)
+target_sources(qrcodegen
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/QrCode.cpp
+    )
 
-target_include_directories(qrcodegen PUBLIC 
-    ${CMAKE_CURRENT_SOURCE_DIR})
+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)

src/CMakeLists.txt

@@ -28,60 +28,23 @@
 #
 # Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
-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
-      ${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 ()
-
 include(Version)
-monero_add_library(version SOURCES ${CMAKE_BINARY_DIR}/version.cpp DEPENDS genversion)
+add_library(version)
+target_sources(version
+    PRIVATE
+        ${CMAKE_BINARY_DIR}/version.cpp
+    )
+
+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)
 
 add_subdirectory(common)
 add_subdirectory(crypto)
@@ -96,6 +59,7 @@ add_subdirectory(hardforks)
 add_subdirectory(blockchain_db)
 add_subdirectory(mnemonics)
 add_subdirectory(rpc)
+#add_subdirectory(test)
 if(NOT IOS)
   add_subdirectory(serialization)
 endif()
@@ -110,16 +74,11 @@ 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)
-add_subdirectory(device_trezor)
+
+install(FILES cryptonote_config.h
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/monero/")

src/blockchain_db/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.
 
-set(blockchain_db_sources
-  blockchain_db.cpp
-  lmdb/db_lmdb.cpp
-  )
+file(GLOB BCDB_SOURCES *.cpp *.c *.cc)
+list(APPEND BCDB_SOURCES lmdb/db_lmdb.cpp)
 
-set(blockchain_db_headers)
+set(BCDB_HEADERS
+    blockchain_db.h
+    locked_txn.h
+    testdb.h
+    lmdb/db_lmdb.h)
 
-monero_find_all_headers(blockchain_db_private_headers "${CMAKE_CURRENT_SOURCE_DIR}")
+message(STATUS "${BCDB_HEADERS}")
 
-monero_private_headers(blockchain_db
-  ${crypto_private_headers})
-monero_add_library(blockchain_db
-  ${blockchain_db_sources}
-  ${blockchain_db_headers}
-  ${blockchain_db_private_headers})
+add_library(blockchain_db)
+target_sources(blockchain_db
+    PRIVATE
+        ${BCDB_SOURCES}
+    )
 target_link_libraries(blockchain_db
   PUBLIC
     common
     cncrypto
     ringct
-    ${LMDB_LIBRARY}
-    ${Boost_FILESYSTEM_LIBRARY}
-    ${Boost_THREAD_LIBRARY}
-  PRIVATE
-    ${EXTRA_LIBRARIES})
+    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})

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 bin)
+install(TARGETS blockchain_import DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 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 bin)
+install(TARGETS blockchain_export DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 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 bin)
+install(TARGETS blockchain_blackball DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 
 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 bin)
+install(TARGETS blockchain_usage DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 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 bin)
+install(TARGETS blockchain_ancestry DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 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 bin)
+install(TARGETS blockchain_depth DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 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 bin)
+install(TARGETS blockchain_stats DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 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 bin)
+install(TARGETS blockchain_prune_known_spent_data DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 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 bin)
+install(TARGETS blockchain_prune DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 target_link_libraries(blockchain_prune
   PRIVATE

src/blockchain_utilities/blockchain_prune.cpp

@@ -52,9 +52,11 @@ using namespace cryptonote;
 static std::string db_path;
 
 // default to fast:1
-static uint64_t records_per_sync = 128;
+static uint64_t records_per_sync = 16 * 65536;
 static const size_t slack = 512 * 1024 * 1024;
 
+static std::vector<bool> is_v1;
+
 static std::error_code replace_file(const boost::filesystem::path& replacement_name, const boost::filesystem::path& replaced_name)
 {
   std::error_code ec = tools::replace_file(replacement_name.string(), replaced_name.string());
@@ -89,6 +91,14 @@ static void close(MDB_env *env)
   mdb_env_close(env);
 }
 
+static void mark_v1_tx(const MDB_val &k, const MDB_val &v)
+{
+  const uint64_t tx_id = *(const uint64_t*)k.mv_data;
+  if (tx_id >= is_v1.size())
+    is_v1.resize(tx_id + 1, false);
+  is_v1[tx_id] = cryptonote::is_v1_tx(cryptonote::blobdata_ref{(const char*)v.mv_data, v.mv_size});
+}
+
 static void add_size(MDB_env *env, uint64_t bytes)
 {
   try
@@ -136,7 +146,7 @@ static void check_resize(MDB_env *env, size_t bytes)
     add_size(env, size_used + bytes + 2 * slack - mei.me_mapsize);
 }
 
-static bool resize_point(size_t nrecords, MDB_env *env, MDB_txn **txn, size_t &bytes)
+static bool resize_point(size_t &nrecords, MDB_env *env, MDB_txn **txn, size_t &bytes)
 {
   if (nrecords % records_per_sync && bytes <= slack / 2)
     return false;
@@ -146,10 +156,11 @@ static bool resize_point(size_t nrecords, MDB_env *env, MDB_txn **txn, size_t &b
   dbr = mdb_txn_begin(env, NULL, 0, txn);
   if (dbr) throw std::runtime_error("Failed to create LMDB transaction: " + std::string(mdb_strerror(dbr)));
   bytes = 0;
+  nrecords = 0;
   return true;
 }
 
-static void copy_table(MDB_env *env0, MDB_env *env1, const char *table, unsigned int flags, unsigned int putflags, int (*cmp)(const MDB_val*, const MDB_val*)=0)
+static void copy_table(MDB_env *env0, MDB_env *env1, const char *table, unsigned int flags, unsigned int putflags, int (*cmp)(const MDB_val*, const MDB_val*)=0, void (*f)(const MDB_val&, const MDB_val&) = 0)
 {
   MDB_dbi dbi0, dbi1;
   MDB_txn *txn0, *txn1;
@@ -200,6 +211,11 @@ static void copy_table(MDB_env *env0, MDB_env *env1, const char *table, unsigned
   dbr = mdb_cursor_open(txn1, dbi1, &cur1);
   if (dbr) throw std::runtime_error("Failed to create LMDB cursor: " + std::string(mdb_strerror(dbr)));
 
+  if (flags & MDB_DUPSORT)
+    putflags |= MDB_APPENDDUP;
+  else
+    putflags |= MDB_APPEND;
+
   MDB_val k;
   MDB_val v;
   MDB_cursor_op op = MDB_FIRST;
@@ -214,7 +230,8 @@ static void copy_table(MDB_env *env0, MDB_env *env1, const char *table, unsigned
       throw std::runtime_error("Failed to enumerate " + std::string(table) + " records: " + std::string(mdb_strerror(ret)));
 
     bytes += k.mv_size + v.mv_size;
-    if (resize_point(++nrecords, env1, &txn1, bytes))
+    ++nrecords;
+    if (resize_point(nrecords, env1, &txn1, bytes))
     {
       dbr = mdb_cursor_open(txn1, dbi1, &cur1);
       if (dbr) throw std::runtime_error("Failed to create LMDB cursor: " + std::string(mdb_strerror(dbr)));
@@ -223,6 +240,9 @@ static void copy_table(MDB_env *env0, MDB_env *env1, const char *table, unsigned
     ret = mdb_cursor_put(cur1, &k, &v, putflags);
     if (ret)
       throw std::runtime_error("Failed to write " + std::string(table) + " record: " + std::string(mdb_strerror(ret)));
+
+    if (f)
+      (*f)(k, v);
   }
 
   mdb_cursor_close(cur1);
@@ -235,17 +255,6 @@ static void copy_table(MDB_env *env0, MDB_env *env1, const char *table, unsigned
   mdb_dbi_close(env0, dbi0);
 }
 
-static bool is_v1_tx(MDB_cursor *c_txs_pruned, MDB_val *tx_id)
-{
-  MDB_val v;
-  int ret = mdb_cursor_get(c_txs_pruned, tx_id, &v, MDB_SET);
-  if (ret)
-    throw std::runtime_error("Failed to find transaction pruned data: " + std::string(mdb_strerror(ret)));
-  if (v.mv_size == 0)
-    throw std::runtime_error("Invalid transaction pruned data");
-  return cryptonote::is_v1_tx(cryptonote::blobdata_ref{(const char*)v.mv_data, v.mv_size});
-}
-
 static void prune(MDB_env *env0, MDB_env *env1)
 {
   MDB_dbi dbi0_blocks, dbi0_txs_pruned, dbi0_txs_prunable, dbi0_tx_indices, dbi1_txs_prunable, dbi1_txs_prunable_tip, dbi1_properties;
@@ -324,7 +333,10 @@ static void prune(MDB_env *env0, MDB_env *env1)
   mdb_dbi_close(env0, dbi0_blocks);
   const uint64_t blockchain_height = stats.ms_entries;
   size_t nrecords = 0, bytes = 0;
+  std::vector<bool> prunable_needed;
 
+  // go through all txes tx indices, recording which ones should have their prunable part retained
+  MINFO("Marking prunable txes");
   MDB_cursor_op op = MDB_FIRST;
   while (1)
   {
@@ -336,7 +348,8 @@ static void prune(MDB_env *env0, MDB_env *env1)
 
     const txindex *ti = (const txindex*)v.mv_data;
     const uint64_t block_height = ti->data.block_id;
-    MDB_val_set(kk, ti->data.tx_id);
+    const uint64_t tx_id = ti->data.tx_id;
+    MDB_val_set(kk, tx_id);
     if (block_height + CRYPTONOTE_PRUNING_TIP_BLOCKS >= blockchain_height)
     {
       MDEBUG(block_height << "/" << blockchain_height << " is in tip");
@@ -344,22 +357,23 @@ static void prune(MDB_env *env0, MDB_env *env1)
       dbr = mdb_cursor_put(cur1_txs_prunable_tip, &kk, &vv, 0);
       if (dbr) throw std::runtime_error("Failed to write prunable tx tip data: " + std::string(mdb_strerror(dbr)));
       bytes += kk.mv_size + vv.mv_size;
-    }
-    if (tools::has_unpruned_block(block_height, blockchain_height, pruning_seed) || is_v1_tx(cur0_txs_pruned, &kk))
-    {
-      MDB_val vv;
-      dbr = mdb_cursor_get(cur0_txs_prunable, &kk, &vv, MDB_SET);
-      if (dbr) throw std::runtime_error("Failed to read prunable tx data: " + std::string(mdb_strerror(dbr)));
-      bytes += kk.mv_size + vv.mv_size;
-      if (resize_point(++nrecords, env1, &txn1, bytes))
+
+      ++nrecords;
+      if (resize_point(nrecords, env1, &txn1, bytes))
       {
         dbr = mdb_cursor_open(txn1, dbi1_txs_prunable, &cur1_txs_prunable);
         if (dbr) throw std::runtime_error("Failed to create LMDB cursor: " + std::string(mdb_strerror(dbr)));
         dbr = mdb_cursor_open(txn1, dbi1_txs_prunable_tip, &cur1_txs_prunable_tip);
         if (dbr) throw std::runtime_error("Failed to create LMDB cursor: " + std::string(mdb_strerror(dbr)));
       }
-      dbr = mdb_cursor_put(cur1_txs_prunable, &kk, &vv, 0);
-      if (dbr) throw std::runtime_error("Failed to write prunable tx data: " + std::string(mdb_strerror(dbr)));
+    }
+    if (tx_id >= is_v1.size())
+      throw std::runtime_error("tx_id out of range of is_v1 vector");
+    if (tools::has_unpruned_block(block_height, blockchain_height, pruning_seed) || is_v1[tx_id])
+    {
+      if (tx_id >= prunable_needed.size())
+        prunable_needed.resize(tx_id + 1, false);
+      prunable_needed[tx_id] = true;
     }
     else
     {
@@ -367,6 +381,37 @@ static void prune(MDB_env *env0, MDB_env *env1)
     }
   }
 
+  // go through prunable parts, carrying over those we need
+  MINFO("Copying retained prunable data");
+  op = MDB_FIRST;
+  while (1)
+  {
+    int ret = mdb_cursor_get(cur0_txs_prunable, &k, &v, op);
+    op = MDB_NEXT;
+    if (ret == MDB_NOTFOUND)
+      break;
+    if (ret) throw std::runtime_error("Failed to enumerate records: " + std::string(mdb_strerror(ret)));
+
+    const uint64_t tx_id = *(const uint64_t*)k.mv_data;
+    if (tx_id >= prunable_needed.size())
+      throw std::runtime_error("tx_id out of range of prunable_needed vector");
+    if (prunable_needed[tx_id])
+    {
+      dbr = mdb_cursor_put(cur1_txs_prunable, &k, &v, MDB_APPEND);
+      if (dbr) throw std::runtime_error("Failed to write prunable tx data: " + std::string(mdb_strerror(dbr)));
+
+      bytes += k.mv_size + v.mv_size;
+      ++nrecords;
+      if (resize_point(nrecords, env1, &txn1, bytes))
+      {
+        dbr = mdb_cursor_open(txn1, dbi1_txs_prunable, &cur1_txs_prunable);
+        if (dbr) throw std::runtime_error("Failed to create LMDB cursor: " + std::string(mdb_strerror(dbr)));
+        dbr = mdb_cursor_open(txn1, dbi1_txs_prunable_tip, &cur1_txs_prunable_tip);
+        if (dbr) throw std::runtime_error("Failed to create LMDB cursor: " + std::string(mdb_strerror(dbr)));
+      }
+    }
+  }
+
   mdb_cursor_close(cur1_txs_prunable_tip);
   mdb_cursor_close(cur1_txs_prunable);
   mdb_cursor_close(cur0_txs_prunable);
@@ -419,7 +464,7 @@ static bool parse_db_sync_mode(std::string db_sync_mode, uint64_t &db_flags)
     else if(options[0] == "fastest")
     {
       db_flags = DBF_FASTEST;
-      records_per_sync = 1000; // default to fastest:async:1000
+      // default to fastest:async:N
     }
     else
       return false;
@@ -455,7 +500,7 @@ int main(int argc, char* argv[])
   const command_line::arg_descriptor<std::string> arg_db_sync_mode = {
     "db-sync-mode"
   , "Specify sync option, using format [safe|fast|fastest]:[nrecords_per_sync]."
-  , "fast:1000"
+  , "fast:" + std::to_string(records_per_sync)
   };
   const command_line::arg_descriptor<bool> arg_copy_pruned_database  = {"copy-pruned-database",  "Copy database anyway if already pruned"};
 
@@ -601,26 +646,27 @@ int main(int argc, char* argv[])
   MDB_env *env0 = NULL, *env1 = NULL;
   open(env0, paths[0], db_flags, true);
   open(env1, paths[1], db_flags, false);
-  copy_table(env0, env1, "blocks", MDB_INTEGERKEY, MDB_APPEND);
-  copy_table(env0, env1, "block_info", MDB_INTEGERKEY | MDB_DUPSORT| MDB_DUPFIXED, MDB_APPENDDUP, BlockchainLMDB::compare_uint64);
+  copy_table(env0, env1, "blocks", MDB_INTEGERKEY, 0);
+  copy_table(env0, env1, "block_info", MDB_INTEGERKEY | MDB_DUPSORT| MDB_DUPFIXED, 0, BlockchainLMDB::compare_uint64);
   copy_table(env0, env1, "block_heights", MDB_INTEGERKEY | MDB_DUPSORT| MDB_DUPFIXED, 0, BlockchainLMDB::compare_hash32);
   //copy_table(env0, env1, "txs", MDB_INTEGERKEY);
-  copy_table(env0, env1, "txs_pruned", MDB_INTEGERKEY, MDB_APPEND);
-  copy_table(env0, env1, "txs_prunable_hash", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, MDB_APPEND);
+  copy_table(env0, env1, "txs_pruned", MDB_INTEGERKEY, 0, NULL, &mark_v1_tx);
+  copy_table(env0, env1, "txs_prunable_hash", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, 0);
   // not copied: prunable, prunable_tip
   copy_table(env0, env1, "tx_indices", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, 0, BlockchainLMDB::compare_hash32);
-  copy_table(env0, env1, "tx_outputs", MDB_INTEGERKEY, MDB_APPEND);
-  copy_table(env0, env1, "output_txs", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, MDB_APPENDDUP, BlockchainLMDB::compare_uint64);
-  copy_table(env0, env1, "output_amounts", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, MDB_APPENDDUP, BlockchainLMDB::compare_uint64);
-  copy_table(env0, env1, "spent_keys", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, MDB_NODUPDATA, BlockchainLMDB::compare_hash32);
-  copy_table(env0, env1, "txpool_meta", 0, MDB_NODUPDATA, BlockchainLMDB::compare_hash32);
-  copy_table(env0, env1, "txpool_blob", 0, MDB_NODUPDATA, BlockchainLMDB::compare_hash32);
-  copy_table(env0, env1, "hf_versions", MDB_INTEGERKEY, MDB_APPEND);
+  copy_table(env0, env1, "tx_outputs", MDB_INTEGERKEY, 0);
+  copy_table(env0, env1, "output_txs", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, 0, BlockchainLMDB::compare_uint64);
+  copy_table(env0, env1, "output_amounts", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, 0, BlockchainLMDB::compare_uint64);
+  copy_table(env0, env1, "spent_keys", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, 0, BlockchainLMDB::compare_hash32);
+  copy_table(env0, env1, "txpool_meta", 0, 0, BlockchainLMDB::compare_hash32);
+  copy_table(env0, env1, "txpool_blob", 0, 0, BlockchainLMDB::compare_hash32);
+  copy_table(env0, env1, "alt_blocks", 0, 0, BlockchainLMDB::compare_hash32);
+  copy_table(env0, env1, "hf_versions", MDB_INTEGERKEY, 0);
   copy_table(env0, env1, "properties", 0, 0, BlockchainLMDB::compare_string);
   if (already_pruned)
   {
-    copy_table(env0, env1, "txs_prunable", MDB_INTEGERKEY, MDB_APPEND, BlockchainLMDB::compare_uint64);
-    copy_table(env0, env1, "txs_prunable_tip", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, MDB_NODUPDATA, BlockchainLMDB::compare_uint64);
+    copy_table(env0, env1, "txs_prunable", MDB_INTEGERKEY, 0, BlockchainLMDB::compare_uint64);
+    copy_table(env0, env1, "txs_prunable_tip", MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED, 0, BlockchainLMDB::compare_uint64);
   }
   else
   {

src/blocks/CMakeLists.txt

@@ -57,4 +57,20 @@ foreach(BLOB_NAME checkpoints)
     )
 endforeach()
 
-monero_add_library(blocks blocks.cpp ${GENERATED_SOURCES})
+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)

src/checkpoints/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.
 
-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()
+add_library(checkpoints)
+target_sources(checkpoints
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/checkpoints.cpp
+    )
 
-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
+target_link_libraries(checkpoints PUBLIC
     common
     cncrypto
-    ${Boost_DATE_TIME_LIBRARY}
-    ${Boost_PROGRAM_OPTIONS_LIBRARY}
-    ${Boost_SERIALIZATION_LIBRARY}
-    ${Boost_FILESYSTEM_LIBRARY}
-    ${Boost_SYSTEM_LIBRARY}
-    ${Boost_THREAD_LIBRARY}
-  PRIVATE
-    ${EXTRA_LIBRARIES})
+    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)

src/checkpoints/checkpoints.cpp

@@ -233,7 +233,13 @@ namespace cryptonote
     ADD_CHECKPOINT2(489400,  "b14f49eae77398117ea93435676100d8b655a804689f73a5a4d0d5e71160d603", "0x1123c39bb52f7e");
     ADD_CHECKPOINT2(491200,  "cedba73ad35ce7f51aaca2beb36dc32d79ecc716d146eb8211e6a815f3666c4a", "0x11334734abbd17");
     ADD_CHECKPOINT2(497100,  "2c4c70ac1ada94151f19d67ccf1aa4e846e6067f49f67c85cc03f78e768ea42b", "0x116906bc97a751");
-    ADD_CHECKPOINT2(691500,  "ed8e2507c0938b7eab7b02eccfb3506aeb591e51fbf6cf145fcc60ea2d351025", "0x163a280f2ce8e3");
+    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,61 +26,77 @@
 # 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_directories(SYSTEM ${OPENSSL_INCLUDE_DIR})
+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)
 
-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)
+add_library(common)
+target_sources(common
+    PRIVATE
+        ${COMMON_SOURCES}
+    )
 
-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
-    ${UNBOUND_LIBRARIES}
-    ${LIBUNWIND_LIBRARIES}
-    ${Boost_DATE_TIME_LIBRARY}
-    ${Boost_FILESYSTEM_LIBRARY}
-    ${Boost_SYSTEM_LIBRARY}
-    ${Boost_THREAD_LIBRARY}
-    ${Boost_REGEX_LIBRARY}
-    ${Boost_CHRONO_LIBRARY}
+    easylogging
+    Libunbound::Libunbound
+    Boost::chrono
+    Boost::date_time
+    Boost::filesystem
+    Boost::thread
+    Boost::regex
+    Boost::system
   PRIVATE
-    ${OPENSSL_LIBRARIES}
-    ${EXTRA_LIBRARIES})
+    OpenSSL::SSL
+    OpenSSL::Crypto)
 
-#monero_install_headers(common
-#  ${common_headers})
+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})

src/common/boost_serialization_helper.h

@@ -35,7 +35,6 @@
 #include <boost/archive/portable_binary_iarchive.hpp>
 #include <boost/filesystem/operations.hpp>
 
-#include "common/util.h"
 
 namespace tools
 {
@@ -111,7 +110,7 @@ namespace tools
     catch(...)
     {
       // if failed, try reading in unportable mode
-      tools::copy_file(file_path, file_path + ".unportable");
+      boost::filesystem::copy_file(file_path, file_path + ".unportable", boost::filesystem::copy_option::overwrite_if_exists);
       data_file.close();
       data_file.open( file_path, std::ios_base::binary | std::ios_base::in);
       if(data_file.fail())

src/common/compat/glibc_compat.cpp

@@ -1,98 +0,0 @@
-#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/stack_trace.cpp

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

src/common/util.cpp

@@ -115,24 +115,6 @@ static int flock_exnb(int fd)
 
 namespace tools
 {
-
-  void copy_file(const std::string& from, const std::string& to)
-  {
-    using boost::filesystem::path;
-  #if BOOST_VERSION < 107400
-    // Remove this preprocessor if/else when we are bumping the boost version.
-    boost::filesystem::copy_file(
-        path(from),
-        path(to),
-        boost::filesystem::copy_option::overwrite_if_exists);
-  #else
-    boost::filesystem::copy_file(
-        path(from),
-        path(to),
-        boost::filesystem::copy_options::overwrite_existing);
-  #endif
-  }
-
   std::function<void(int)> signal_handler::m_handler;
 
   private_file::private_file() noexcept : m_handle(), m_filename() {}
@@ -140,7 +122,7 @@ namespace tools
   private_file::private_file(std::FILE* handle, std::string&& filename) noexcept
     : m_handle(handle), m_filename(std::move(filename)) {}
 
-  private_file private_file::create(std::string name, uint32_t extra_flags)
+  private_file private_file::create(std::string name)
   {
 #ifdef WIN32
     struct close_handle
@@ -193,7 +175,7 @@ namespace tools
         name.c_str(),
         GENERIC_WRITE, FILE_SHARE_READ,
         std::addressof(attributes),
-        CREATE_NEW, (FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE | extra_flags),
+        CREATE_NEW, (FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE),
         nullptr
       )
     };
@@ -212,7 +194,7 @@ namespace tools
       }
     }
 #else
-    const int fdr = open(name.c_str(), (O_RDONLY | O_CREAT | extra_flags), S_IRUSR);
+    const int fdr = open(name.c_str(), (O_RDONLY | O_CREAT), S_IRUSR);
     if (0 <= fdr)
     {
       struct stat rstats = {};
@@ -243,23 +225,6 @@ namespace tools
     return {};
   }
 
-  private_file private_file::drop_and_recreate(std::string filename)
-  {
-    if (epee::file_io_utils::is_file_exist(filename)) {
-      boost::system::error_code ec{};
-      boost::filesystem::remove(filename, ec);
-      if (ec) {
-        MERROR("Failed to remove " << filename << ": " << ec.message());
-        return {};
-      }
-    }
-#ifdef WIN32
-    return create(filename);
-#else
-    return create(filename, O_EXCL);
-#endif
-  }
-
   private_file::~private_file() noexcept
   {
     try

src/common/util.h

@@ -67,8 +67,6 @@ namespace tools
     }
   };
 
-  void copy_file(const std::string& from, const std::string& to);
-
   //! A file restricted to process owner AND process. Deletes file on destruction.
   class private_file {
     std::unique_ptr<std::FILE, close_file> m_handle;
@@ -82,11 +80,7 @@ namespace tools
 
     /*! \return File only readable by owner and only used by this process
       OR `private_file{}` on error. */
-    static private_file create(std::string filename, uint32_t extra_flags = 0);
-
-    /*! \return Drop and create file only readable by owner and only used
-      by this process OR `private_file{}` on error. */
-    static private_file drop_and_recreate(std::string filename);    
+    static private_file create(std::string filename);
 
     private_file(private_file&&) = default;
     private_file& operator=(private_file&&) = default;

src/crypto/CMakeLists.txt

@@ -27,76 +27,104 @@
 # 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)
 
-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)
+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)
 endif()
 
-include_directories(${RANDOMX_INCLUDE})
+add_library(cncrypto)
+target_sources(cncrypto
+    PRIVATE
+        ${crypto_sources}
+    )
 
-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_LIBRARY}
-    ${SODIUM_LIBRARY}
+    Boost::system
+    ${sodium_LIBRARY_RELEASE}
   PRIVATE
-    ${EXTRA_LIBRARIES})
+    OpenSSL::SSL
+    OpenSSL::Crypto)
 
-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()
+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")
 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 C)
+set_property(SOURCE CryptonightR_template.S PROPERTY LANGUAGE ASM)
 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/crypto.h

@@ -171,9 +171,7 @@ namespace crypto {
   /* Generate a value filled with random bytes.
    */
   template<typename T>
-  T rand() {
-    static_assert(std::is_standard_layout<T>(), "cannot write random bytes into non-standard layout type");
-    static_assert(std::is_trivially_copyable<T>(), "cannot write random bytes into non-trivially copyable type");
+  typename std::enable_if<std::is_pod<T>::value, T>::type rand() {
     typename std::remove_cv<T>::type res;
     generate_random_bytes_thread_safe(sizeof(T), (uint8_t*)&res);
     return res;
@@ -316,14 +314,8 @@ namespace crypto {
   inline std::ostream &operator <<(std::ostream &o, const crypto::public_key &v) {
     epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
   }
-  /* Do NOT overload the << operator for crypto::secret_key here. Use secret_key_explicit_print_ref
-   * instead to prevent accidental implicit dumping of secret key material to the logs (which has
-   * happened before). For the same reason, do not overload it for crypto::ec_scalar either since
-   * crypto::secret_key is a subclass. I'm not sorry that it's obtuse; that's the point, bozo.
-   */
-  struct secret_key_explicit_print_ref { const crypto::secret_key &sk; };
-  inline std::ostream &operator <<(std::ostream &o, const secret_key_explicit_print_ref v) {
-    epee::to_hex::formatted(o, epee::as_byte_span(unwrap(unwrap(v.sk)))); return o;
+  inline std::ostream &operator <<(std::ostream &o, const crypto::secret_key &v) {
+    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
   }
   inline std::ostream &operator <<(std::ostream &o, const crypto::key_derivation &v) {
     epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;

src/crypto/jh.c

@@ -34,7 +34,7 @@ typedef struct {
 	unsigned long long databitlen;    /*the message size in bits*/
 	unsigned long long datasize_in_buffer;      /*the size of the message remained in buffer; assumed to be multiple of 8bits except for the last partial block at the end of the message*/
 	DATA_ALIGN16(uint64 x[8][2]);     /*the 1024-bit state, ( x[i][0] || x[i][1] ) is the ith row of the state in the pseudocode*/
-	DATA_ALIGN16(unsigned char buffer[64]);         /*the 512-bit message block to be hashed;*/
+	unsigned char buffer[64];         /*the 512-bit message block to be hashed;*/
 } hashState;
 
 
@@ -213,24 +213,16 @@ static void E8(hashState *state)
 /*The compression function F8 */
 static void F8(hashState *state)
 {
-      uint64_t* x = (uint64_t*)state->x;
+      uint64  i;
 
       /*xor the 512-bit message with the fist half of the 1024-bit hash state*/
-      for (int i = 0; i < 8; ++i) {
-            uint64 b;
-            memcpy(&b, &state->buffer[i << 3], sizeof(b));
-            x[i] ^= b;
-      }
+      for (i = 0; i < 8; i++)  state->x[i >> 1][i & 1] ^= ((uint64*)state->buffer)[i];
 
       /*the bijective function E8 */
       E8(state);
 
       /*xor the 512-bit message with the second half of the 1024-bit hash state*/
-      for (int i = 0; i < 8; ++i) {
-            uint64 b;
-            memcpy(&b, &state->buffer[i << 3], sizeof(b));
-            x[i + 8] ^= b;
-      }
+      for (i = 0; i < 8; i++)  state->x[(8+i) >> 1][(8+i) & 1] ^= ((uint64*)state->buffer)[i];
 }
 
 /*before hashing a message, initialize the hash state as H0 */
@@ -248,7 +240,6 @@ static HashReturn Init(hashState *state, int hashbitlen)
             case 224: memcpy(state->x,JH224_H0,128); break;
             case 256: memcpy(state->x,JH256_H0,128); break;
             case 384: memcpy(state->x,JH384_H0,128); break;
-            default:
             case 512: memcpy(state->x,JH512_H0,128); break;
       }
 

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/wallet/CMakeLists.txt

@@ -27,37 +27,19 @@
 # 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.
 
-#
-# Possibly user defined values.
-#
-set(MONERO_WALLET_CRYPTO_LIBRARY "auto" CACHE STRING "Select a wallet crypto library")
+include(CheckLanguage)
+check_language(ASM-ATT)
 
-#
-# 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 ()
+add_library(wallet-crypto crypto.h)
 
-#
-# 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_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/>
+        )
 
+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,56 +26,68 @@
 # 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.
 
-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()
+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)
 
-monero_add_library(cryptonote_format_utils_basic
-  cryptonote_format_utils_basic.cpp
-)
-target_link_libraries(cryptonote_format_utils_basic
-  PUBLIC
-  cncrypto
-)
+# 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
+    )
 
-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)
+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_headers)
+# cryptonote_basic
+add_library(cryptonote_basic)
+target_sources(cryptonote_basic
+    PRIVATE
+        ${CN_BASIC_SOURCES}
+    )
 
-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_LIBRARY}
-    ${Boost_PROGRAM_OPTIONS_LIBRARY}
-    ${Boost_SERIALIZATION_LIBRARY}
-    ${Boost_FILESYSTEM_LIBRARY}
-    ${Boost_SYSTEM_LIBRARY}
-    ${Boost_THREAD_LIBRARY}
-  PRIVATE
-    ${EXTRA_LIBRARIES})
+    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})

src/cryptonote_basic/cryptonote_format_utils.cpp

@@ -312,7 +312,7 @@ namespace cryptonote
     bool r = hwdev.generate_key_derivation(tx_public_key, ack.m_view_secret_key, recv_derivation);
     if (!r)
     {
-      MWARNING("key image helper: failed to generate_key_derivation(" << tx_public_key << ", <viewkey>)");
+      MWARNING("key image helper: failed to generate_key_derivation(" << tx_public_key << ", " << ack.m_view_secret_key << ")");
       memcpy(&recv_derivation, rct::identity().bytes, sizeof(recv_derivation));
     }
 
@@ -323,7 +323,7 @@ namespace cryptonote
       r = hwdev.generate_key_derivation(additional_tx_public_keys[i], ack.m_view_secret_key, additional_recv_derivation);
       if (!r)
       {
-        MWARNING("key image helper: failed to generate_key_derivation(" << additional_tx_public_keys[i] << ", <viewkey>)");
+        MWARNING("key image helper: failed to generate_key_derivation(" << additional_tx_public_keys[i] << ", " << ack.m_view_secret_key << ")");
       }
       else
       {

src/cryptonote_basic/tx_extra.h

@@ -52,7 +52,7 @@ namespace cryptonote
 
     // load
     template <template <bool> class Archive>
-    bool member_do_serialize(Archive<false>& ar)
+    bool do_serialize(Archive<false>& ar)
     {
       // size - 1 - because of variant tag
       for (size = 1; size <= TX_EXTRA_PADDING_MAX_COUNT; ++size)
@@ -73,7 +73,7 @@ namespace cryptonote
 
     // store
     template <template <bool> class Archive>
-    bool member_do_serialize(Archive<true>& ar)
+    bool do_serialize(Archive<true>& ar)
     {
       if(TX_EXTRA_PADDING_MAX_COUNT < size)
         return false;
@@ -129,7 +129,7 @@ namespace cryptonote
 
     // load
     template <template <bool> class Archive>
-    bool member_do_serialize(Archive<false>& ar)
+    bool do_serialize(Archive<false>& ar)
     {
       std::string field;
       if(!::do_serialize(ar, field))
@@ -142,7 +142,7 @@ namespace cryptonote
 
     // store
     template <template <bool> class Archive>
-    bool member_do_serialize(Archive<true>& ar)
+    bool do_serialize(Archive<true>& ar)
     {
       std::ostringstream oss;
       binary_archive<true> oar(oss);

src/cryptonote_basic/verification_context.h

@@ -59,7 +59,6 @@ namespace cryptonote
     bool m_fee_too_low;
     bool m_too_few_outputs;
     bool m_tx_extra_too_big;
-    bool m_nonzero_unlock_time;
   };
 
   struct block_verification_context

src/cryptonote_config.h

@@ -30,7 +30,6 @@
 
 #pragma once
 
-#include <cstdint>
 #include <stdexcept>
 #include <string>
 #include <boost/uuid/uuid.hpp>

src/cryptonote_core/CMakeLists.txt

@@ -26,25 +26,18 @@
 # 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(cryptonote_core_sources
-  blockchain.cpp
-  cryptonote_core.cpp
-  tx_pool.cpp
-  tx_sanity_check.cpp
-  cryptonote_tx_utils.cpp
-  tx_verification_utils.cpp
-)
+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_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})
+add_library(cryptonote_core)
 target_link_libraries(cryptonote_core
   PUBLIC
     version
@@ -54,11 +47,34 @@ target_link_libraries(cryptonote_core
     ringct
     device
     hardforks
-    ${Boost_DATE_TIME_LIBRARY}
-    ${Boost_PROGRAM_OPTIONS_LIBRARY}
-    ${Boost_SERIALIZATION_LIBRARY}
-    ${Boost_FILESYSTEM_LIBRARY}
-    ${Boost_SYSTEM_LIBRARY}
-    ${Boost_THREAD_LIBRARY}
-  PRIVATE
-    ${EXTRA_LIBRARIES})
+    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})

src/cryptonote_core/blockchain.cpp

@@ -1242,7 +1242,12 @@ bool Blockchain::switch_to_alternative_blockchain(std::list<block_extended_info>
       // just the latter (because the rollback was done above).
       rollback_blockchain_switching(disconnected_chain, split_height);
 
+      // FIXME: Why do we keep invalid blocks around?  Possibly in case we hear
+      // about them again so we can immediately dismiss them, but needs some
+      // looking into.
       const crypto::hash blkid = cryptonote::get_block_hash(bei.bl);
+      add_block_as_invalid(bei, blkid);
+      MERROR("The block was inserted as invalid while connecting new alternative chain, block_id: " << blkid);
       m_db->remove_alt_block(blkid);
       alt_ch_iter++;
 
@@ -1250,6 +1255,7 @@ bool Blockchain::switch_to_alternative_blockchain(std::list<block_extended_info>
       {
         const auto &bei = *alt_ch_to_orph_iter++;
         const crypto::hash blkid = cryptonote::get_block_hash(bei.bl);
+        add_block_as_invalid(bei, blkid);
         m_db->remove_alt_block(blkid);
       }
       return false;
@@ -2459,22 +2465,19 @@ void Blockchain::get_output_key_mask_unlocked(const uint64_t& amount, const uint
 bool Blockchain::get_output_distribution(uint64_t amount, uint64_t from_height, uint64_t to_height, uint64_t &start_height, std::vector<uint64_t> &distribution, uint64_t &base) const
 {
   // rct outputs don't exist before v4
-//  if (amount == 0)
-//  {
-//    switch (m_nettype)
-//    {
-//      case STAGENET: start_height = stagenet_hard_forks[3].height; break;
-//      case TESTNET: start_height = testnet_hard_forks[3].height; break;
-//      case MAINNET: start_height = 0; break;
-//      case FAKECHAIN: start_height = 0; break;
-//      default: return false;
-//    }
-//  }
-//  else
-//    start_height = 0;
-
-  // rct outputs start at genesis on wow
-  start_height = 0;
+  if (amount == 0)
+  {
+    switch (m_nettype)
+    {
+      case STAGENET: start_height = stagenet_hard_forks[3].height; break;
+      case TESTNET: start_height = testnet_hard_forks[3].height; break;
+      case MAINNET: start_height = mainnet_hard_forks[3].height; break;
+      case FAKECHAIN: start_height = 0; break;
+      default: return false;
+    }
+  }
+  else
+    start_height = 0;
   base = 0;
 
   if (to_height > 0 && to_height < from_height)
@@ -3942,8 +3945,6 @@ void Blockchain::get_dynamic_base_fee_estimate_2021_scaling(uint64_t grace_block
   const uint8_t version = get_current_hard_fork_version();
   const uint64_t db_height = m_db->height();
 
-  CHECK_AND_ASSERT_THROW_MES(grace_blocks <= CRYPTONOTE_REWARD_BLOCKS_WINDOW, "Grace blocks invalid In 2021 fee scaling estimate.");
-
   // we want Mlw = median of max((min(Mbw, 1.7 * Ml), Zm), Ml / 1.7)
   // Mbw: block weight for the last 99990 blocks, 0 for the next 10
   // Ml: penalty free zone (dynamic), aka long_term_median, aka median of max((min(Mb, 1.7 * Ml), Zm), Ml / 1.7)
@@ -3957,6 +3958,7 @@ void Blockchain::get_dynamic_base_fee_estimate_2021_scaling(uint64_t grace_block
   const uint64_t Mlw_penalty_free_zone_for_wallet = std::max<uint64_t>(rm.median(), CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5);
 
   // Msw: median over [100 - grace blocks] past + [grace blocks] future blocks
+  CHECK_AND_ASSERT_THROW_MES(grace_blocks <= 100, "Grace blocks invalid In 2021 fee scaling estimate.");
   std::vector<uint64_t> weights;
   get_last_n_blocks_weights(weights, 100 - grace_blocks);
   weights.reserve(100);
@@ -5669,7 +5671,7 @@ void Blockchain::cancel()
 }
 
 #if defined(PER_BLOCK_CHECKPOINT)
-static const char expected_block_hashes_hash[] = "3ee7be44d391f20b389ed17b17443ffa26889ac943a57b4e493b833db67159c5";
+static const char expected_block_hashes_hash[] = "9ce2e9f40ff58954d6176e300af1d8da1804b829e1be8565805fea497df40f4b";
 void Blockchain::load_compiled_in_block_hashes(const GetCheckpointsCallback& get_checkpoints)
 {
   if (get_checkpoints == nullptr || !m_fast_sync)

src/cryptonote_core/cryptonote_core.cpp

@@ -1840,56 +1840,6 @@ 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 jbjareb znantre                   "
-    << ENDL);
-    MGINFO_MAGENTA(ENDL <<
-    "                                  ██   ██  █████  ██████  ███████ ███    ██   \n"
-    "                                  ██  ██  ██   ██ ██   ██ ██      ████   ██   \n"
-    "                                  █████   ███████ ██████  █████   ██ ██  ██   \n"
-    "                                  ██  ██  ██   ██ ██   ██ ██      ██  ██ ██   \n"
-    "                                  ██   ██ ██   ██ ██   ██ ███████ ██   ████   \n"
-    << ENDL);
       MGINFO_YELLOW(ENDL << "**********************************************************************" << ENDL
         << main_message << ENDL
         << ENDL

src/cryptonote_core/cryptonote_tx_utils.cpp

@@ -144,7 +144,7 @@ namespace cryptonote
       crypto::key_derivation derivation = AUTO_VAL_INIT(derivation);
       crypto::public_key out_eph_public_key = AUTO_VAL_INIT(out_eph_public_key);
       bool r = crypto::generate_key_derivation(miner_address.m_view_public_key, txkey.sec, derivation);
-      CHECK_AND_ASSERT_MES(r, false, "while creating outs: failed to generate_key_derivation(" << miner_address.m_view_public_key << ", " << crypto::secret_key_explicit_print_ref{txkey.sec} << ")");
+      CHECK_AND_ASSERT_MES(r, false, "while creating outs: failed to generate_key_derivation(" << miner_address.m_view_public_key << ", " << txkey.sec << ")");
 
       r = crypto::derive_public_key(derivation, no, miner_address.m_spend_public_key, out_eph_public_key);
       CHECK_AND_ASSERT_MES(r, false, "while creating outs: failed to derive_public_key(" << derivation << ", " << no << ", "<< miner_address.m_spend_public_key << ")");
@@ -216,7 +216,7 @@ namespace cryptonote
     return addr.m_view_public_key;
   }
   //---------------------------------------------------------------
-  bool construct_tx_with_tx_key(const account_keys& sender_account_keys, const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses, std::vector<tx_source_entry>& sources, std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx, const crypto::secret_key &tx_key, const std::vector<crypto::secret_key> &additional_tx_keys, bool rct, const rct::RCTConfig &rct_config, bool shuffle_outs, bool use_view_tags)
+  bool construct_tx_with_tx_key(const account_keys& sender_account_keys, const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses, std::vector<tx_source_entry>& sources, std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx, uint64_t unlock_time, const crypto::secret_key &tx_key, const std::vector<crypto::secret_key> &additional_tx_keys, bool rct, const rct::RCTConfig &rct_config, bool shuffle_outs, bool use_view_tags)
   {
     hw::device &hwdev = sender_account_keys.get_device();
 
@@ -231,7 +231,7 @@ namespace cryptonote
     amount_keys.clear();
 
     tx.version = rct ? 2 : 1;
-    tx.unlock_time = 0;
+    tx.unlock_time = unlock_time;
 
     tx.extra = extra;
     crypto::public_key txkey_pub;
@@ -497,7 +497,7 @@ namespace cryptonote
           crypto::generate_ring_signature(tx_prefix_hash, boost::get<txin_to_key>(tx.vin[i]).k_image, keys_ptrs, in_contexts[i].in_ephemeral.sec, src_entr.real_output, sigs.data());
         ss_ring_s << "signatures:" << ENDL;
         std::for_each(sigs.begin(), sigs.end(), [&](const crypto::signature& s){ss_ring_s << s << ENDL;});
-        ss_ring_s << "prefix_hash:" << tx_prefix_hash << ENDL << "in_ephemeral_key: " << crypto::secret_key_explicit_print_ref{in_contexts[i].in_ephemeral.sec} << ENDL << "real_output: " << src_entr.real_output << ENDL;
+        ss_ring_s << "prefix_hash:" << tx_prefix_hash << ENDL << "in_ephemeral_key: " << in_contexts[i].in_ephemeral.sec << ENDL << "real_output: " << src_entr.real_output << ENDL;
         i++;
       }
 
@@ -621,7 +621,7 @@ namespace cryptonote
     return true;
   }
   //---------------------------------------------------------------
-  bool construct_tx_and_get_tx_key(const account_keys& sender_account_keys, const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses, std::vector<tx_source_entry>& sources, std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx, crypto::secret_key &tx_key, std::vector<crypto::secret_key> &additional_tx_keys, bool rct, const rct::RCTConfig &rct_config, bool use_view_tags)
+  bool construct_tx_and_get_tx_key(const account_keys& sender_account_keys, const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses, std::vector<tx_source_entry>& sources, std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx, uint64_t unlock_time, crypto::secret_key &tx_key, std::vector<crypto::secret_key> &additional_tx_keys, bool rct, const rct::RCTConfig &rct_config, bool use_view_tags)
   {
     hw::device &hwdev = sender_account_keys.get_device();
     hwdev.open_tx(tx_key);
@@ -642,7 +642,7 @@ namespace cryptonote
       }
 
       bool shuffle_outs = true;
-      bool r = construct_tx_with_tx_key(sender_account_keys, subaddresses, sources, destinations, change_addr, extra, tx, tx_key, additional_tx_keys, rct, rct_config, shuffle_outs, use_view_tags);
+      bool r = construct_tx_with_tx_key(sender_account_keys, subaddresses, sources, destinations, change_addr, extra, tx, unlock_time, tx_key, additional_tx_keys, rct, rct_config, shuffle_outs, use_view_tags);
       hwdev.close_tx();
       return r;
     } catch(...) {
@@ -651,14 +651,14 @@ namespace cryptonote
     }
   }
   //---------------------------------------------------------------
-  bool construct_tx(const account_keys& sender_account_keys, std::vector<tx_source_entry>& sources, const std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx)
+  bool construct_tx(const account_keys& sender_account_keys, std::vector<tx_source_entry>& sources, const std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx, uint64_t unlock_time)
   {
      std::unordered_map<crypto::public_key, cryptonote::subaddress_index> subaddresses;
      subaddresses[sender_account_keys.m_account_address.m_spend_public_key] = {0,0};
      crypto::secret_key tx_key;
      std::vector<crypto::secret_key> additional_tx_keys;
      std::vector<tx_destination_entry> destinations_copy = destinations;
-     return construct_tx_and_get_tx_key(sender_account_keys, subaddresses, sources, destinations_copy, change_addr, extra, tx, tx_key, additional_tx_keys, false, { rct::RangeProofBorromean, 0});
+     return construct_tx_and_get_tx_key(sender_account_keys, subaddresses, sources, destinations_copy, change_addr, extra, tx, unlock_time, tx_key, additional_tx_keys, false, { rct::RangeProofBorromean, 0});
   }
   //---------------------------------------------------------------
   bool generate_genesis_block(

src/cryptonote_core/cryptonote_tx_utils.h

@@ -119,9 +119,9 @@ namespace cryptonote
 
   //---------------------------------------------------------------
   crypto::public_key get_destination_view_key_pub(const std::vector<tx_destination_entry> &destinations, const boost::optional<cryptonote::account_public_address>& change_addr);
-  bool construct_tx(const account_keys& sender_account_keys, std::vector<tx_source_entry> &sources, const std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx);
-  bool construct_tx_with_tx_key(const account_keys& sender_account_keys, const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses, std::vector<tx_source_entry>& sources, std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx, const crypto::secret_key &tx_key, const std::vector<crypto::secret_key> &additional_tx_keys, bool rct = false, const rct::RCTConfig &rct_config = { rct::RangeProofBorromean, 0 }, bool shuffle_outs = true, bool use_view_tags = false);
-  bool construct_tx_and_get_tx_key(const account_keys& sender_account_keys, const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses, std::vector<tx_source_entry>& sources, std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx, crypto::secret_key &tx_key, std::vector<crypto::secret_key> &additional_tx_keys, bool rct = false, const rct::RCTConfig &rct_config = { rct::RangeProofBorromean, 0 }, bool use_view_tags = false);
+  bool construct_tx(const account_keys& sender_account_keys, std::vector<tx_source_entry> &sources, const std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx, uint64_t unlock_time);
+  bool construct_tx_with_tx_key(const account_keys& sender_account_keys, const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses, std::vector<tx_source_entry>& sources, std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx, uint64_t unlock_time, const crypto::secret_key &tx_key, const std::vector<crypto::secret_key> &additional_tx_keys, bool rct = false, const rct::RCTConfig &rct_config = { rct::RangeProofBorromean, 0 }, bool shuffle_outs = true, bool use_view_tags = false);
+  bool construct_tx_and_get_tx_key(const account_keys& sender_account_keys, const std::unordered_map<crypto::public_key, subaddress_index>& subaddresses, std::vector<tx_source_entry>& sources, std::vector<tx_destination_entry>& destinations, const boost::optional<cryptonote::account_public_address>& change_addr, const std::vector<uint8_t> &extra, transaction& tx, uint64_t unlock_time, crypto::secret_key &tx_key, std::vector<crypto::secret_key> &additional_tx_keys, bool rct = false, const rct::RCTConfig &rct_config = { rct::RangeProofBorromean, 0 }, bool use_view_tags = false);
   bool generate_output_ephemeral_keys(const size_t tx_version, const cryptonote::account_keys &sender_account_keys, const crypto::public_key &txkey_pub,  const crypto::secret_key &tx_key,
                                       const cryptonote::tx_destination_entry &dst_entr, const boost::optional<cryptonote::account_public_address> &change_addr, const size_t output_index,
                                       const bool &need_additional_txkeys, const std::vector<crypto::secret_key> &additional_tx_keys,

src/cryptonote_core/tx_pool.cpp

@@ -236,15 +236,6 @@ namespace cryptonote
       return false;
     }
 
-    if (!kept_by_block && tx.unlock_time)
-    {
-      LOG_PRINT_L1("transaction unlock time is not zero: " << tx.unlock_time);
-      tvc.m_verifivation_failed = true;
-      tvc.m_nonzero_unlock_time = true;
-      tvc.m_no_drop_offense = true;
-      return false;
-    }
-
     // if the transaction came from a block popped from the chain,
     // don't check if we have its key images as spent.
     // TODO: Investigate why not?
@@ -256,7 +247,6 @@ namespace cryptonote
         LOG_PRINT_L1("Transaction with id= "<< id << " used already spent key images");
         tvc.m_verifivation_failed = true;
         tvc.m_double_spend = true;
-        tvc.m_no_drop_offense = true;
         return false;
       }
     }
@@ -445,14 +435,8 @@ namespace cryptonote
   void tx_memory_pool::prune(size_t bytes)
   {
     CRITICAL_REGION_LOCAL(m_transactions_lock);
-
-    // Nothing to do if already empty
-    if (m_txs_by_fee_and_receive_time.empty())
-      return;
-
     if (bytes == 0)
       bytes = m_txpool_max_weight;
-
     CRITICAL_REGION_LOCAL1(m_blockchain);
     LockedTXN lock(m_blockchain.get_db());
     bool changed = false;
@@ -497,13 +481,8 @@ 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);
-
-        auto it_prev = it;
-        --it_prev;
-
         remove_tx_from_transient_lists(it, txid, !meta.matches(relay_category::broadcasted));
-        it = it_prev;
-
+        it--;
         changed = true;
       }
       catch (const std::exception &e)
@@ -1095,7 +1074,7 @@ namespace cryptonote
 
     // If the total weight is too high, choose the best paying transactions
     if (total_weight > max_backlog_weight)
-      std::stable_sort(tmp.begin(), tmp.end(), [](const auto& a, const auto& b){ return a.fee * b.weight > b.fee * a.weight; });
+      std::sort(tmp.begin(), tmp.end(), [](const auto& a, const auto& b){ return a.fee * b.weight > b.fee * a.weight; });
 
     backlog.clear();
     uint64_t w = 0;
@@ -1848,7 +1827,7 @@ namespace cryptonote
       auto sorted_it = find_tx_in_sorted_container(txid);
       if (sorted_it == m_txs_by_fee_and_receive_time.end())
       {
-        MDEBUG("Re-adding tx " << txid << " to tx pool, but it was not found in the sorted txs container");
+        MERROR("Re-adding tx " << txid << " to tx pool, but it was not found in the sorted txs container");
       }
       else
       {

src/cryptonote_core/tx_pool.h

@@ -69,12 +69,11 @@ namespace cryptonote
     {
       // sort by greatest first, not least
       if (a.first.first > b.first.first) return true;
-      if (a.first.first < b.first.first) return false;
-
-      if (a.first.second < b.first.second) return true;
-      if (a.first.second > b.first.second) return false;
-
-      return memcmp(a.second.data, b.second.data, sizeof(crypto::hash)) < 0;
+      else if (a.first.first < b.first.first) return false;
+      else if (a.first.second < b.first.second) return true;
+      else if (a.first.second > b.first.second) return false;
+      else if (a.second != b.second) return true;
+      else return false;
     }
   };
 

src/cryptonote_protocol/CMakeLists.txt

@@ -26,16 +26,31 @@
 # 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.
 
-cmake_minimum_required (VERSION 3.5)
-project (monero CXX)
+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)
 
-file(GLOB CRYPTONOTE_PROTOCOL *)
-source_group(cryptonote_protocol FILES ${CRYPTONOTE_PROTOCOL})
+add_library(cryptonote_protocol)
+target_sources(cryptonote_protocol
+    PRIVATE
+        ${CN_PROT_SOURCES}
+    )
 
-#monero_private_headers(cryptonote_protocol ${CRYPTONOTE_PROTOCOL})
-monero_add_library(cryptonote_protocol ${CRYPTONOTE_PROTOCOL})
-target_link_libraries(cryptonote_protocol
-  PUBLIC
-    p2p
-  PRIVATE
-    ${EXTRA_LIBRARIES})
+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})

src/cryptonote_protocol/block_queue.cpp

@@ -40,6 +40,15 @@
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "cn.block_queue"
 
+namespace std {
+  static_assert(sizeof(size_t) <= sizeof(boost::uuids::uuid), "boost::uuids::uuid too small");
+  template<> struct hash<boost::uuids::uuid> {
+    std::size_t operator()(const boost::uuids::uuid &_v) const {
+      return reinterpret_cast<const std::size_t &>(_v);
+    }
+  };
+}
+
 namespace cryptonote
 {
 
@@ -463,7 +472,7 @@ bool block_queue::has_spans(const boost::uuids::uuid &connection_id) const
 float block_queue::get_speed(const boost::uuids::uuid &connection_id) const
 {
   boost::unique_lock<boost::recursive_mutex> lock(mutex);
-  std::unordered_map<boost::uuids::uuid, float, boost::hash<boost::uuids::uuid>> speeds;
+  std::unordered_map<boost::uuids::uuid, float> speeds;
   for (const auto &span: blocks)
   {
     if (span.blocks.empty())
@@ -471,7 +480,7 @@ float block_queue::get_speed(const boost::uuids::uuid &connection_id) const
     // note that the average below does not average over the whole set, but over the
     // previous pseudo average and the latest rate: this gives much more importance
     // to the latest measurements, which is fine here
-    const auto i = speeds.find(span.connection_id);
+    std::unordered_map<boost::uuids::uuid, float>::iterator i = speeds.find(span.connection_id);
     if (i == speeds.end())
       speeds.insert(std::make_pair(span.connection_id, span.rate));
     else

src/cryptonote_protocol/cryptonote_protocol_handler.inl

@@ -1693,22 +1693,8 @@ 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);
-            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;
-            }
+            MGINFO_YELLOW("Synced " << current_blockchain_height << "/" << target_blockchain_height
+                << progress_message << timing_message);
             if (previous_stripe != current_stripe)
               notify_new_stripe(context, current_stripe);
           }

src/cryptonote_protocol/levin_notify.cpp

@@ -396,8 +396,6 @@ namespace levin
         for (auto& connection : connections)
         {
           std::sort(connection.first.begin(), connection.first.end()); // don't leak receive order
-          connection.first.erase(std::unique(connection.first.begin(), connection.first.end()),
-                                  connection.first.end());
           make_payload_send_txs(*zone_->p2p, std::move(connection.first), connection.second, zone_->pad_txs, true);
         }
 
@@ -743,14 +741,9 @@ namespace levin
   notify::status notify::get_status() const noexcept
   {
     if (!zone_)
-      return {false, false, false};
+      return {false, false};
 
-    // `connection_count` is only set when `!noise.empty()`.
-    const std::size_t connection_count = zone_->connection_count;
-    bool has_outgoing = connection_count;
-    if (zone_->noise.empty())
-      has_outgoing = zone_->p2p->get_out_connections_count();
-    return {!zone_->noise.empty(), CRYPTONOTE_NOISE_CHANNELS <= connection_count, has_outgoing};
+    return {!zone_->noise.empty(), CRYPTONOTE_NOISE_CHANNELS <= zone_->connection_count};
   }
 
   void notify::new_out_connection()

src/cryptonote_protocol/levin_notify.h

@@ -75,8 +75,7 @@ namespace levin
     struct status
     {
       bool has_noise;
-      bool connections_filled; //!< True when has zone has `CRYPTONOTE_NOISE_CHANNELS` outgoing noise channels
-      bool has_outgoing; //!< True when zone has outgoing connections
+      bool connections_filled;
     };
 
     //! Construct an instance that cannot notify.

src/daemon/CMakeLists.txt

@@ -26,25 +26,14 @@
 # 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(daemon_sources
-  command_parser_executor.cpp
-  command_server.cpp
-  daemon.cpp
-  executor.cpp
-  main.cpp
-  rpc_command_executor.cpp
-)
+file(GLOB DAEMON_SOURCES
+    *.cpp
+    *.c
+    *.cc
+    *.h)
 
-set(daemon_headers)
+add_executable(daemon ${DAEMON_SOURCES})
 
-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
@@ -57,19 +46,27 @@ target_link_libraries(daemon
     daemonizer
     serialization
     daemon_rpc_server
-    ${EPEE_READLINE}
     version
-    ${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})
+    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()
+
 set_property(TARGET daemon
   PROPERTY
     OUTPUT_NAME "wownerod")
-install(TARGETS daemon DESTINATION bin)
+
+install(TARGETS daemon DESTINATION ${CMAKE_INSTALL_BINDIR})

src/daemon/command_parser_executor.cpp

@@ -696,16 +696,6 @@ bool t_command_parser_executor::ban(const std::vector<std::string>& args)
       std::ifstream ifs(ban_list_path.string());
       for (std::string line; std::getline(ifs, line); )
       {
-        // ignore comments after '#' character
-        const size_t pound_idx = line.find('#');
-        if (pound_idx != std::string::npos)
-          line.resize(pound_idx);
-
-        // trim whitespace and ignore empty lines
-        boost::trim(line);
-        if (line.empty())
-          continue;
-
         auto subnet = net::get_ipv4_subnet_address(line);
         if (subnet)
         {

src/daemonizer/CMakeLists.txt

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

src/device/CMakeLists.txt

@@ -26,57 +26,41 @@
 # 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(device_sources
-  device.cpp
-  device_default.cpp
-  log.cpp
-  )
+set(HEADERS
+    device.hpp
+    device_io.hpp
+    device_default.hpp
+    device_cold.hpp
+    log.hpp)
 
-if(HIDAPI_FOUND)
-  set(device_sources 
-    ${device_sources} 
-    device_ledger.cpp
-    device_io_hid.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
     )
-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
-    ${OPENSSL_CRYPTO_LIBRARIES}
-    ${Boost_SERIALIZATION_LIBRARY}
+    monero-crypto-amd64-64-24k
+    OpenSSL::Crypto
+    Boost::serialization
   PRIVATE
     version
-    ${Blocks}
-    ${EXTRA_LIBRARIES})
+    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}")

src/device/device_default.cpp

@@ -317,15 +317,13 @@ namespace hw {
             {
             // sending change to yourself; derivation = a*R
                 r = generate_key_derivation(txkey_pub, sender_account_keys.m_view_secret_key, derivation);
-                CHECK_AND_ASSERT_MES(r, false, "at creation outs: failed to generate_key_derivation(" << txkey_pub << ", <viewkey>)");
+                CHECK_AND_ASSERT_MES(r, false, "at creation outs: failed to generate_key_derivation(" << txkey_pub << ", " << sender_account_keys.m_view_secret_key << ")");
             }
             else
             {
             // sending to the recipient; derivation = r*A (or s*C in the subaddress scheme)
-                const crypto::secret_key &tx_privkey{dst_entr.is_subaddress && need_additional_txkeys ? additional_txkey.sec : tx_key};
-                r = generate_key_derivation(dst_entr.addr.m_view_public_key, tx_privkey, derivation);
-                CHECK_AND_ASSERT_MES(r, false, "at creation outs: failed to generate_key_derivation("
-                    << dst_entr.addr.m_view_public_key << ", " << crypto::secret_key_explicit_print_ref{tx_privkey} << ")");
+                r = generate_key_derivation(dst_entr.addr.m_view_public_key, dst_entr.is_subaddress && need_additional_txkeys ? additional_txkey.sec : tx_key, derivation);
+                CHECK_AND_ASSERT_MES(r, false, "at creation outs: failed to generate_key_derivation(" << dst_entr.addr.m_view_public_key << ", " << (dst_entr.is_subaddress && need_additional_txkeys ? additional_txkey.sec : tx_key) << ")");
             }
 
             if (need_additional_txkeys)

src/device/device_ledger.cpp

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