diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8f2030342..087c61738 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,87 +1,87 @@
 # Copyright (c) 2017 The Bitcoin developers
 
-cmake_minimum_required(VERSION 3.12)
+cmake_minimum_required(VERSION 3.13)
 
 set(CMAKE_USER_MAKE_RULES_OVERRIDE
 	"${CMAKE_SOURCE_DIR}/cmake/modules/OverrideInitFlags.cmake"
 )
 
 project(bitcoin-abc
 	VERSION 0.20.11
 	DESCRIPTION "Bitcoin ABC is a full node implementation of the Bitcoin Cash protocol."
 	HOMEPAGE_URL "https://www.bitcoinabc.org"
 )
 
 # Package information
 set(PACKAGE_NAME "Bitcoin ABC")
 
 # Copyright
 set(COPYRIGHT_YEAR 2019)
 set(COPYRIGHT_HOLDERS "The %s developers")
 set(COPYRIGHT_HOLDERS_SUBSTITUTION Bitcoin)
 string(REPLACE "%s" ${COPYRIGHT_HOLDERS_SUBSTITUTION} COPYRIGHT_HOLDERS_FINAL ${COPYRIGHT_HOLDERS})
 
 # Add path for custom modules
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
 
 # Make contrib script accessible.
 set(CONTRIB_PATH ${CMAKE_CURRENT_SOURCE_DIR}/contrib)
 
 # If ccache is available, then use it.
 find_program(CCACHE ccache)
 if(CCACHE)
 	message(STATUS "Using ccache: ${CCACHE}")
 	set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE})
 	set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE})
 endif(CCACHE)
 
 # Default to RelWithDebInfo configuration
 if(NOT CMAKE_BUILD_TYPE)
 	set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
 		"Select the configuration for the build" FORCE)
 endif()
 
 # Find the python interpreter. This is required for several targets.
 find_package(PythonInterp 3.5 REQUIRED)
 
 # Add the magic targets `check-*`
 add_custom_target(check-all)
 add_custom_target(check)
 add_custom_target(check-extended)
 add_custom_target(check-upgrade-activated)
 add_custom_target(check-upgrade-activated-extended)
 add_custom_target(check-symbols)
 add_custom_target(check-security)
 
 include(PackageHelper)
 exclude_git_ignored_files_from_source_package()
 
 # Ignore hidden files and directories (starting with a '.')
 set_property(GLOBAL APPEND PROPERTY SOURCE_PACKAGE_IGNORE_FILES	"/\\\\.")
 
 # If the build is out-of-tree, then the build directory can be ignored.
 if(NOT CMAKE_BINARY_DIR STREQUAL CMAKE_SOURCE_DIR)
 	set_property(GLOBAL APPEND PROPERTY SOURCE_PACKAGE_IGNORE_FILES
 		"${CMAKE_BINARY_DIR}/"
 	)
 endif()
 
 exclude_from_source_package(
 	# Subdirectories
 	"arcanist/"
 	"depends/"
 
 	# Files
 	"[^.]+[.]md$"
 	"Dockerfile-doxygen"
 )
 
 add_subdirectory(src)
 add_subdirectory(test)
 
 add_subdirectory(contrib)
 add_subdirectory(doc)
 
 include(PackageOptions)
 get_property(CPACK_SOURCE_IGNORE_FILES GLOBAL PROPERTY SOURCE_PACKAGE_IGNORE_FILES)
 include(CPack)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 5d7bfa326..8869005b5 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,561 +1,560 @@
 # Copyright (c) 2017 The Bitcoin developers
 
-cmake_minimum_required(VERSION 3.12)
 project(bitcoind)
 
 set(CMAKE_CXX_STANDARD 14)
 
 # Default visibility is hidden on all targets.
 set(CMAKE_C_VISIBILITY_PRESET hidden)
 set(CMAKE_CXX_VISIBILITY_PRESET hidden)
 
 option(BUILD_BITCOIN_WALLET "Activate the wallet functionality" ON)
 option(BUILD_BITCOIN_ZMQ "Activate the ZeroMQ functionalities" ON)
 option(BUILD_BITCOIN_SEEDER "Build bitcoin-seeder" ON)
 option(BUILD_BITCOIN_CLI "Build bitcoin-cli" ON)
 option(BUILD_BITCOIN_TX "Build bitcoin-tx" ON)
 option(BUILD_BITCOIN_QT "Build bitcoin-qt" ON)
 option(BUILD_LIBBITCOINCONSENSUS "Build the bitcoinconsenus shared library" ON)
 option(ENABLE_BIP70 "Enable BIP70 (payment protocol) support in GUI" ON)
 option(ENABLE_HARDENING "Harden the executables" ON)
 option(ENABLE_REDUCE_EXPORTS "Reduce the amount of exported symbols" OFF)
 option(ENABLE_STATIC_LIBSTDCXX "Statically link libstdc++" OFF)
 option(ENABLE_GLIBC_BACK_COMPAT "Enable Glibc compatibility features" OFF)
 option(ENABLE_QRCODE "Enable QR code display" ON)
 option(ENABLE_UPNP "Enable UPnP support" ON)
 option(ENABLE_NOTIFICATIONS "Enable desktop notifications" ON)
 option(ENABLE_WERROR "Promote some compiler warnings to errors" OFF)
 option(START_WITH_UPNP "Make UPnP the default to map ports" OFF)
 
 # Disable what we do not need for the native build.
 include(NativeExecutable)
 native_add_cmake_flags(
 	"-DBUILD_BITCOIN_WALLET=OFF"
 	"-DBUILD_BITCOIN_QT=OFF"
 	"-DBUILD_BITCOIN_ZMQ=OFF"
 	"-DENABLE_QRCODE=OFF"
 	"-DENABLE_UPNP=OFF"
 )
 
 # Allow usage of sanitizers by setting ECM_ENABLE_SANITIZERS
 if(ENABLE_SANITIZERS)
 	set(ECM_ENABLE_SANITIZERS ${ENABLE_SANITIZERS})
 	find_package(ECM NO_MODULE)
 	if(ECM_MODULE_PATH)
 		list(APPEND CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 		include(ECMEnableSanitizers)
 	else()
 		message(FATAL_ERROR
 			"ECM is required to enable the sanitizers (https://api.kde.org/ecm/manual/ecm.7.html). Try installing 'extra-cmake-modules' package."
 		)
 	endif()
 endif()
 
 include(AddCompilerFlags)
 
 # Prefer -g3, defaults to -g if unavailable
 foreach(LANGUAGE C CXX)
 	set(COMPILER_DEBUG_LEVEL -g)
 	check_compiler_flag(G3_IS_SUPPORTED ${LANGUAGE} -g3)
 	if(${G3_IS_SUPPORTED})
 		set(COMPILER_DEBUG_LEVEL -g3)
 	endif()
 	add_compile_options_to_configuration_for_language(Debug ${LANGUAGE} ${COMPILER_DEBUG_LEVEL})
 endforeach()
 
 # Define the debugging symbols DEBUG and DEBUG_LOCKORDER when the Debug build
 # type is selected.
 add_compile_definitions_to_configuration(Debug DEBUG DEBUG_LOCKORDER)
 
 # Add -ftrapv when building in Debug
 add_compile_options_to_configuration(Debug -ftrapv)
 
 # Ensure that WINDRES_PREPROC is enabled when using windres.
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	# Ensure that WINDRES_PREPROC is enabled when using windres.
 	list(APPEND CMAKE_RC_FLAGS "-DWINDRES_PREPROC")
 
 	# Build all static so there is no dll file to distribute.
 	add_linker_flags(-static)
 endif()
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	add_compile_definitions(MAC_OSX OBJC_OLD_DISPATCH_PROTOTYPES=0)
 endif()
 
 if(ENABLE_REDUCE_EXPORTS)
 	# Default visibility is set by CMAKE_<LANG>_VISIBILITY_PRESET, but this
 	# doesn't tell if the visibility set is effective.
 	# Check if the flag -fvisibility=hidden is supported, as using the hidden
 	# visibility is a requirement to reduce exports.
 	check_compiler_flag(HAS_CXX_FVISIBILITY CXX -fvisibility=hidden)
 	if(NOT HAS_CXX_FVISIBILITY)
 		message(FATAL_ERROR "Cannot set default symbol visibility. Use -DENABLE_REDUCE_EXPORTS=OFF.")
 	endif()
 
 	# Also hide symbols from static libraries
 	add_linker_flags(-Wl,--exclude-libs,ALL)
 endif()
 
 # Enable statically linking libstdc++
 if(ENABLE_STATIC_LIBSTDCXX)
 	add_linker_flags(-static-libstdc++)
 endif()
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 if(ENABLE_HARDENING)
 	# Enable stack protection
 	add_cxx_compiler_flags(-fstack-protector-all -Wstack-protector)
 
 	# Enable some buffer overflow checking
 	add_compiler_flags(-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2)
 
 	# Enable ASLR (these flags are primarily targeting MinGw)
 	add_linker_flags(-Wl,--dynamicbase -Wl,--nxcompat -Wl,--high-entropy-va)
 
 	# Make the relocated sections read-only
 	add_linker_flags(-Wl,-z,relro -Wl,-z,now)
 
 	# CMake provides the POSITION_INDEPENDENT_CODE property to set PIC/PIE.
 	# Unfortunately setting the -pie linker flag this way require CMake >= 3.14,
 	# which is not widely distributed at the time of writing.
 	# FIXME: remove the fallback case when cmake >= 3.14 get enforced.
 	if(POLICY CMP0083)
 		cmake_policy(SET CMP0083 NEW)
 		include(CheckPIESupported)
 		check_pie_supported()
 	elseif(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		add_linker_flags(-pie)
 	endif()
 
 	if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		# MinGw provides its own libssp for stack smashing protection
 		link_libraries(ssp)
 	endif()
 endif()
 
 # Enable warning
 add_c_compiler_flags(-Wnested-externs -Wstrict-prototypes)
 add_compiler_flags(
 	-Wall
 	-Wextra
 	-Wformat
 	-Wvla
 	-Wformat-security
 	-Wcast-align
 	-Wunused-parameter
 	-Wmissing-braces
 	-Wthread-safety-analysis
 	-Wshadow
 	-Wrange-loop-analysis
 	-Wredundant-decls
 	-Wredundant-move
 )
 
 option(EXTRA_WARNINGS "Enable extra warnings" OFF)
 if(EXTRA_WARNINGS)
 	add_cxx_compiler_flags(-Wsuggest-override)
 else()
 	add_compiler_flags(-Wno-unused-parameter)
 	add_compiler_flags(-Wno-implicit-fallthrough)
 endif()
 
 if(ENABLE_WERROR)
 	add_compiler_flags(
 		-Werror=vla
 		-Werror=thread-safety-analysis
 	)
 endif()
 
 # Create a target for OpenSSL
 include(BrewHelper)
 find_brew_prefix(OPENSSL_ROOT_DIR openssl)
 find_package(OpenSSL REQUIRED)
 
 # libtool style configure
 add_subdirectory(config)
 
 # libraries
 add_subdirectory(crypto)
 add_subdirectory(leveldb)
 add_subdirectory(secp256k1)
 add_subdirectory(univalue)
 
 # Find the git root, and returns the full path to the .git/logs/HEAD file if
 # it exists.
 function(find_git_head_logs_file RESULT)
 	find_package(Git)
 	if(GIT_FOUND)
 		execute_process(
 			COMMAND "${GIT_EXECUTABLE}" "rev-parse" "--show-toplevel"
 			WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
 			OUTPUT_VARIABLE GIT_ROOT
 			RESULT_VARIABLE GIT_RESULT
 			OUTPUT_STRIP_TRAILING_WHITESPACE
 		)
 
 		if(GIT_RESULT EQUAL 0)
 			set(GIT_LOGS_DIR "${GIT_ROOT}/.git/logs")
 			set(GIT_HEAD_LOGS_FILE "${GIT_LOGS_DIR}/HEAD")
 			# If the .git/logs/HEAD does not exist, create it
 			if(NOT EXISTS "${GIT_HEAD_LOGS_FILE}")
 				file(MAKE_DIRECTORY "${GIT_LOGS_DIR}")
 				file(TOUCH "${GIT_HEAD_LOGS_FILE}")
 			endif()
 			set(${RESULT} "${GIT_HEAD_LOGS_FILE}" PARENT_SCOPE)
 		endif()
 	endif()
 endfunction()
 
 find_git_head_logs_file(GIT_HEAD_LOGS_FILE)
 
 set(OBJ_DIR "${CMAKE_CURRENT_BINARY_DIR}/obj")
 file(MAKE_DIRECTORY "${OBJ_DIR}")
 set(BUILD_HEADER "${OBJ_DIR}/build.h")
 set(BUILD_HEADER_TMP "${BUILD_HEADER}.tmp")
 
 add_custom_command(
 	DEPENDS
 		"${GIT_HEAD_LOGS_FILE}"
 		"${CMAKE_SOURCE_DIR}/share/genbuild.sh"
 	OUTPUT
 		"${BUILD_HEADER}"
 	COMMAND
 		"${CMAKE_SOURCE_DIR}/share/genbuild.sh"
 		"${BUILD_HEADER_TMP}"
 		"${CMAKE_SOURCE_DIR}"
 	COMMAND
 		${CMAKE_COMMAND} -E copy_if_different "${BUILD_HEADER_TMP}" "${BUILD_HEADER}"
 	COMMAND
 		${CMAKE_COMMAND} -E remove "${BUILD_HEADER_TMP}"
 )
 
 # Because the Bitcoin ABc source code is disorganised, we
 # end up with a bunch of libraries without any apparent
 # cohesive structure. This is inherited from Bitcoin Core
 # and reflecting this.
 # TODO: Improve the structure once cmake is rocking.
 
 # Various completely unrelated features shared by all executables.
 add_library(util
 	chainparamsbase.cpp
 	clientversion.cpp
 	compat/glibc_sanity.cpp
 	compat/glibcxx_sanity.cpp
 	compat/strnlen.cpp
 	fs.cpp
 	logging.cpp
 	random.cpp
 	rcu.cpp
 	rpc/protocol.cpp
 	rpc/util.cpp
 	support/cleanse.cpp
 	support/lockedpool.cpp
 	sync.cpp
 	threadinterrupt.cpp
 	uint256.cpp
 	util/system.cpp
 	util/moneystr.cpp
 	util/strencodings.cpp
 	util/time.cpp
 	util/bytevectorhash.cpp
 
 	# obj/build.h
 	"${BUILD_HEADER}"
 )
 
 target_compile_definitions(util PUBLIC HAVE_CONFIG_H HAVE_BUILD_INFO)
 target_include_directories(util
 	PUBLIC
 		.
 		# To access the config/ and obj/ directories
 		${CMAKE_CURRENT_BINARY_DIR}
 )
 
 if(ENABLE_GLIBC_BACK_COMPAT)
 	# glibc absorbed clock_gettime in 2.17. librt (its previous location) is
 	# safe to link in anyway for back-compat.
 	find_library(RT_LIBRARY rt)
 	target_link_libraries(util ${RT_LIBRARY})
 
 	# Wrap some glibc functions with ours
 	add_linker_flags(-Wl,--wrap=__divmoddi4)
 	add_linker_flags(-Wl,--wrap=log2f)
 
 	if(NOT HAVE_LARGE_FILE_SUPPORT)
 		add_linker_flags(-Wl,--wrap=fcntl -Wl,--wrap=fcntl64)
 	endif()
 
 	target_sources(util PRIVATE compat/glibc_compat.cpp)
 endif()
 
 # Enable LFS (Large File Support) on targets that don't have it natively.
 if(NOT HAVE_LARGE_FILE_SUPPORT)
 	add_compiler_flags(-D_FILE_OFFSET_BITS=64)
 	add_linker_flags(-Wl,--large-address-aware)
 endif()
 
 # Target specific configs
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	set(Boost_USE_STATIC_LIBS ON)
 	set(Boost_THREADAPI win32)
 
 	find_package(SHLWAPI REQUIRED)
 	target_link_libraries(util ${SHLWAPI_LIBRARY})
 	target_include_directories(util PUBLIC ${SHLWAPI_INCLUDE_DIR})
 
 	find_library(WS2_32_LIBRARY NAMES ws2_32)
 	target_link_libraries(util ${WS2_32_LIBRARY})
 
 	target_compile_definitions(util PUBLIC BOOST_THREAD_USE_LIB)
 endif()
 
 # Boost packages
 set(BOOST_PACKAGES_REQUIRED chrono filesystem thread)
 
 function(prepend var prefix)
 	set(listVar "")
 	foreach(f ${ARGN})
 		list(APPEND listVar "${prefix}${f}")
 	endforeach(f)
 	set(${var} "${listVar}" PARENT_SCOPE)
 endfunction(prepend)
 
 prepend(BOOST_LIBRARIES "Boost::" ${BOOST_PACKAGES_REQUIRED})
 
 find_package(Boost 1.58 REQUIRED ${BOOST_PACKAGES_REQUIRED})
 target_link_libraries(util univalue crypto ${BOOST_LIBRARIES})
 
 # Make sure boost uses std::atomic (it doesn't before 1.63)
 target_compile_definitions(util PUBLIC BOOST_SP_USE_STD_ATOMIC BOOST_AC_USE_STD_ATOMIC)
 
 # More completely unrelated features shared by all executables.
 # Because nothing says this is different from util than "common"
 add_library(common
 	amount.cpp
 	base58.cpp
 	cashaddr.cpp
 	cashaddrenc.cpp
 	chainparams.cpp
 	config.cpp
 	consensus/merkle.cpp
 	coins.cpp
 	compressor.cpp
 	feerate.cpp
 	globals.cpp
 	core_read.cpp
 	core_write.cpp
 	key.cpp
 	key_io.cpp
 	keystore.cpp
 	netaddress.cpp
 	netbase.cpp
 	primitives/block.cpp
 	protocol.cpp
 	scheduler.cpp
 	warnings.cpp
 )
 
 target_link_libraries(common util secp256k1)
 
 # script library
 add_library(script
 	script/bitfield.cpp
 	script/descriptor.cpp
 	script/interpreter.cpp
 	script/ismine.cpp
 	script/script.cpp
 	script/script_error.cpp
 	script/sigencoding.cpp
 	script/sign.cpp
 	script/standard.cpp
 )
 
 target_link_libraries(script common)
 
 # libbitcoinconsensus
 add_library(bitcoinconsensus
 	arith_uint256.cpp
 	hash.cpp
 	primitives/transaction.cpp
 	pubkey.cpp
 	uint256.cpp
 	util/strencodings.cpp
 )
 
 target_link_libraries(bitcoinconsensus script)
 
 include(InstallationHelper)
 if(BUILD_LIBBITCOINCONSENSUS)
 	target_compile_definitions(bitcoinconsensus
 		PUBLIC
 			BUILD_BITCOIN_INTERNAL
 			HAVE_CONSENSUS_LIB
 	)
 
 	install_shared_library(bitcoinconsensus
 		script/bitcoinconsensus.cpp
 		PUBLIC_HEADER script/bitcoinconsensus.h
 	)
 endif()
 
 # Bitcoin server facilities
 add_library(server
 	addrdb.cpp
 	addrman.cpp
 	avalanche.cpp
 	banman.cpp
 	bloom.cpp
 	blockencodings.cpp
 	blockfilter.cpp
 	chain.cpp
 	checkpoints.cpp
 	config.cpp
 	consensus/activation.cpp
 	consensus/tx_verify.cpp
 	dbwrapper.cpp
 	flatfile.cpp
 	globals.cpp
 	httprpc.cpp
 	httpserver.cpp
 	index/base.cpp
 	index/txindex.cpp
 	init.cpp
 	interfaces/handler.cpp
 	interfaces/node.cpp
 	merkleblock.cpp
 	miner.cpp
 	net.cpp
 	net_processing.cpp
 	noui.cpp
 	outputtype.cpp
 	policy/fees.cpp
 	policy/policy.cpp
 	pow.cpp
 	rest.cpp
 	rpc/abc.cpp
 	rpc/blockchain.cpp
 	rpc/command.cpp
 	rpc/jsonrpcrequest.cpp
 	rpc/mining.cpp
 	rpc/misc.cpp
 	rpc/net.cpp
 	rpc/rawtransaction.cpp
 	rpc/server.cpp
 	script/scriptcache.cpp
 	script/sigcache.cpp
 	shutdown.cpp
 	timedata.cpp
 	torcontrol.cpp
 	txdb.cpp
 	txmempool.cpp
 	ui_interface.cpp
 	validation.cpp
 	validationinterface.cpp
 )
 
 # This require libevent
 find_package(Event REQUIRED)
 
 target_include_directories(server PRIVATE leveldb/helpers/memenv)
 
 target_link_libraries(server
 	Event
 	bitcoinconsensus
 	leveldb
 	memenv
 )
 
 if(ENABLE_UPNP)
 	target_include_directories(server PUBLIC ${MINIUPNPC_INCLUDE_DIR})
 	target_link_libraries(server ${MINIUPNPC_LIBRARY})
 
 	if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		find_library(IPHLPAPI_LIBRARY NAMES iphlpapi)
 		if(NOT IPHLPAPI_LIBRARY)
 			message(FATAL_ERROR "Lib iphlpapi is missing")
 		endif()
 		target_link_libraries(server ${IPHLPAPI_LIBRARY})
 
 		target_compile_definitions(server
 			PUBLIC -DSTATICLIB
 			PUBLIC -DMINIUPNP_STATICLIB
 		)
 	endif()
 endif()
 
 # Test suite.
 add_subdirectory(test)
 
 # Benchmark suite.
 add_subdirectory(bench)
 
 # Wallet
 if(BUILD_BITCOIN_WALLET)
 	add_subdirectory(wallet)
 	target_link_libraries(server wallet)
 endif()
 
 # ZeroMQ
 if(BUILD_BITCOIN_ZMQ)
 	add_subdirectory(zmq)
 	target_link_libraries(server zmq)
 endif()
 
 # RPC client support
 add_library(rpcclient rpc/client.cpp)
 target_link_libraries(rpcclient univalue util)
 
 # bitcoin-seeder
 if(BUILD_BITCOIN_SEEDER)
 	add_subdirectory(seeder)
 endif()
 
 include(BinaryTest)
 
 # bitcoin-cli
 if(BUILD_BITCOIN_CLI)
 	add_executable(bitcoin-cli bitcoin-cli.cpp)
 	if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		target_sources(bitcoin-cli PRIVATE bitcoin-cli-res.rc)
 	endif()
 
 	target_link_libraries(bitcoin-cli common rpcclient Event)
 
 	add_to_symbols_check(bitcoin-cli)
 	add_to_security_check(bitcoin-cli)
 
 	install_target(bitcoin-cli)
 endif()
 
 # bitcoin-tx
 if(BUILD_BITCOIN_TX)
 	add_executable(bitcoin-tx bitcoin-tx.cpp)
 	if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		target_sources(bitcoin-tx PRIVATE bitcoin-tx-res.rc)
 	endif()
 
 	target_link_libraries(bitcoin-tx bitcoinconsensus)
 
 	add_to_symbols_check(bitcoin-tx)
 	add_to_security_check(bitcoin-tx)
 
 	install_target(bitcoin-tx)
 endif()
 
 # bitcoind
 add_executable(bitcoind bitcoind.cpp)
 target_link_libraries(bitcoind server)
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	target_sources(bitcoind PRIVATE bitcoind-res.rc)
 endif()
 add_to_symbols_check(bitcoind)
 add_to_security_check(bitcoind)
 
 install_target(bitcoind)
 
 # Bitcoin-qt
 if(BUILD_BITCOIN_QT)
 	add_subdirectory(qt)
 endif()
diff --git a/src/leveldb/CMakeLists.txt b/src/leveldb/CMakeLists.txt
index 322104253..524b95ba6 100644
--- a/src/leveldb/CMakeLists.txt
+++ b/src/leveldb/CMakeLists.txt
@@ -1,222 +1,222 @@
 # Copyright 2017 The LEVELDB Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file. See the AUTHORS file for names of contributors.
 
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.13)
 project(Leveldb VERSION 0.1.0 LANGUAGES C CXX)
 
 # This project can take advantage of C++11.
 set(CMAKE_CXX_STANDARD 11)
 
 # Remove some warnings for leveldb as they can get noisy.
 add_compiler_flags(-Wno-sign-compare -Wno-implicit-fallthrough)
 add_c_compiler_flags(-Wno-strict-prototypes)
 
 include(CheckIncludeFileCXX)
 check_include_file_cxx("atomic" LEVELDB_ATOMIC_PRESENT)
 
 include_directories(.)
 
 # Leveldb library
 add_library(leveldb
 	db/builder.cc
 	db/c.cc
 	db/dbformat.cc
 	db/db_impl.cc
 	db/db_iter.cc
 	db/dumpfile.cc
 	db/filename.cc
 	db/log_reader.cc
 	db/log_writer.cc
 	db/memtable.cc
 	db/repair.cc
 	db/table_cache.cc
 	db/version_edit.cc
 	db/version_set.cc
 	db/write_batch.cc
 	table/block_builder.cc
 	table/block.cc
 	table/filter_block.cc
 	table/format.cc
 	table/iterator.cc
 	table/merger.cc
 	table/table_builder.cc
 	table/table.cc
 	table/two_level_iterator.cc
 	util/arena.cc
 	util/bloom.cc
 	util/cache.cc
 	util/coding.cc
 	util/comparator.cc
 	util/crc32c.cc
 	util/env.cc
 	util/env_posix.cc
 	util/filter_policy.cc
 	util/hash.cc
 	util/histogram.cc
 	util/logging.cc
 	util/options.cc
 	util/status.cc
 )
 
 # The SSE4.2 optimized CRC32 implementation.
 add_library(leveldb-sse4.2 port/port_posix_sse.cc)
 target_link_libraries(leveldb leveldb-sse4.2)
 
 # The libmemenv library.
 add_library(memenv helpers/memenv/memenv.cc)
 
 # Select the proper port: posix or Windows.
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	set(LEVELDB_PLATFORM WINDOWS)
 	set(LEVELDB_OS WINDOWS)
 	target_sources(leveldb
 		PRIVATE
 			util/env_win.cc
 			port/port_win.cc
 	)
 	target_compile_definitions(leveldb
 		PRIVATE
 			WINVER=0x0500
 			__USE_MINGW_ANSI_STDIO=1
 	)
 
 	find_package(SHLWAPI REQUIRED)
 	target_link_libraries(leveldb ${SHLWAPI_LIBRARY})
 	target_include_directories(leveldb PUBLIC ${SHLWAPI_INCLUDE_DIR})
 else()
 	set(LEVELDB_PLATFORM POSIX)
 	target_sources(leveldb PRIVATE port/port_posix.cc)
 
 	set(THREADS_PREFER_PTHREAD_FLAG ON)
 	find_package(Threads REQUIRED)
 	target_link_libraries(leveldb Threads::Threads)
 
 	if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 		set(LEVELDB_OS LINUX)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 		set(LEVELDB_OS MACOSX)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "(Solaris|SunOS)")
 		set(LEVELDB_OS SOLARIS)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
 		set(LEVELDB_OS FREEBSD)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "KFreeBSD")
 		set(LEVELDB_OS KFREEBSD)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
 		set(LEVELDB_OS NETBSD)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
 		set(LEVELDB_OS OPENBSD)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "DragonFly")
 		set(LEVELDB_OS DRAGONFLYBSD)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "Android")
 		set(LEVELDB_OS ANDROID)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "HPUX")
 		# No idea what's the proper system name is here.
 		set(LEVELDB_OS HPUX)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "iOS")
 		# No idea what's the proper system name is here.
 		set(LEVELDB_OS IOS)
 	else()
 		message(FATAL_ERROR "Cannot build leveldb for ${CMAKE_SYSTEM_NAME}. Please file a bug report.")
 	endif()
 endif()
 
 # Right now this is not used but the latest version of leveldb uses this
 # so we might as well be ready for it.
 if (HAVE_CRC32C)
   target_link_libraries(leveldb crc32c)
 endif (HAVE_CRC32C)
 if (HAVE_SNAPPY)
   target_link_libraries(leveldb snappy)
 endif (HAVE_SNAPPY)
 
 # Configure all leveldb libraries.
 function(configure_leveldb_lib LIB)
 	target_include_directories(${LIB} PUBLIC include)
 	target_compile_definitions(${LIB}
 		PUBLIC
 			OS_${LEVELDB_OS}
 			LEVELDB_PLATFORM_${LEVELDB_PLATFORM}
 	)
 	if(LEVELDB_ATOMIC_PRESENT)
 		target_compile_definitions(${LIB} PUBLIC LEVELDB_ATOMIC_PRESENT)
 	endif(LEVELDB_ATOMIC_PRESENT)
 endfunction()
 
 configure_leveldb_lib(leveldb)
 configure_leveldb_lib(leveldb-sse4.2)
 configure_leveldb_lib(memenv)
 
 # Check support for SSE4.2 and act accordingly.
 set(CMAKE_REQUIRED_FLAGS -msse4.2)
 check_c_source_compiles("
 	#include <stdint.h>
 	#if defined(_MSC_VER)
 	#include <intrin.h>
 	#elif defined(__GNUC__) && defined(__SSE4_2__)
 	#include <nmmintrin.h>
 	#endif
 	int main() {
 		uint64_t l = 0;
 		l = _mm_crc32_u8(l, 0);
 		l = _mm_crc32_u32(l, 0);
 		l = _mm_crc32_u64(l, 0);
 		return l;
 	}
 " ENABLE_HWCRC32)
 if(ENABLE_HWCRC32)
 	target_compile_definitions(leveldb-sse4.2 PRIVATE LEVELDB_PLATFORM_POSIX_SSE)
 	target_compile_options(leveldb-sse4.2 PRIVATE -msse4.2)
 endif()
 
 option(LEVELDB_BUILD_TESTS "Build LevelDB's unit tests" ON)
 if(LEVELDB_BUILD_TESTS)
 	include(TestSuite)
 	create_test_suite(leveldb)
 
 	add_library(leveldb_test_base
 		EXCLUDE_FROM_ALL
 		util/testharness.cc
 		util/testutil.cc
 	)
 
 	target_link_libraries(leveldb_test_base leveldb)
 
 	function(create_leveldb_test NAME FILES)
 		add_test_to_suite(leveldb ${NAME} EXCLUDE_FROM_ALL ${FILES})
 		target_link_libraries(${NAME} leveldb_test_base)
 	endfunction()
 
 	create_leveldb_test(autocompact_test db/autocompact_test.cc)
 	create_leveldb_test(corruption_test db/corruption_test.cc)
 	create_leveldb_test(db_test db/db_test.cc)
 	create_leveldb_test(dbformat_test db/dbformat_test.cc)
 	create_leveldb_test(fault_injection_test db/fault_injection_test.cc)
 	create_leveldb_test(filename_test db/filename_test.cc)
 	create_leveldb_test(log_test db/log_test.cc)
 	create_leveldb_test(recovery_test db/recovery_test.cc)
 	create_leveldb_test(skiplist_test db/skiplist_test.cc)
 	create_leveldb_test(version_edit_test db/version_edit_test.cc)
 	create_leveldb_test(version_set_test db/version_set_test.cc)
 	create_leveldb_test(write_batch_test db/write_batch_test.cc)
 	create_leveldb_test(issue178_test issues/issue178_test.cc)
 	create_leveldb_test(issue200_test issues/issue200_test.cc)
 	create_leveldb_test(filter_block_test table/filter_block_test.cc)
 	create_leveldb_test(table_test table/table_test.cc)
 	create_leveldb_test(arena_test util/arena_test.cc)
 	create_leveldb_test(bloom_test util/bloom_test.cc)
 	create_leveldb_test(cache_test util/cache_test.cc)
 	create_leveldb_test(coding_test util/coding_test.cc)
 	create_leveldb_test(crc32c_test util/crc32c_test.cc)
 	create_leveldb_test(env_test util/env_test.cc)
 	create_leveldb_test(hash_test util/hash_test.cc)
 
 	create_leveldb_test(memenv_test helpers/memenv/memenv_test.cc)
 	target_link_libraries(memenv_test memenv)
 
 	# These tests only work on posix
 	if(${LEVELDB_PLATFORM} MATCHES "POSIX")
 		create_leveldb_test(c_test db/c_test.c)
 		create_leveldb_test(env_posix_test util/env_posix_test.cc)
 	endif()
 endif(LEVELDB_BUILD_TESTS)
diff --git a/src/secp256k1/CMakeLists.txt b/src/secp256k1/CMakeLists.txt
index 60d27b76d..df6d95885 100644
--- a/src/secp256k1/CMakeLists.txt
+++ b/src/secp256k1/CMakeLists.txt
@@ -1,242 +1,242 @@
 # Copyright (c) 2017 The Bitcoin developers
 
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.13)
 project(secp256k1 LANGUAGES C)
 
 # Add path for custom modules when building as a standalone project
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
 
 include(AddCompilerFlags)
 
 # libsecp256k1 use a different set of flags.
 add_c_compiler_flags(
 	-pedantic
 	-Wall
 	-Wextra
 	-Wcast-align
 	-Wshadow
 	-Wno-unused-function
 	-Wno-overlength-strings
 	-std=c89
 	-Wnested-externs
 	-Wstrict-prototypes
 	-Wno-long-long
 )
 
 # Default visibility is hidden on all targets.
 set(CMAKE_C_VISIBILITY_PRESET hidden)
 
 include_directories(
 	.
 	src
 	# For the config
 	${CMAKE_CURRENT_BINARY_DIR}/src
 )
 
 # The library
 add_library(secp256k1 src/secp256k1.c)
 target_include_directories(secp256k1 PUBLIC include)
 
 # We need to link in GMP
 find_package(GMP)
 if(GMP_FOUND)
 	target_include_directories(secp256k1 PUBLIC ${GMP_INCLUDE_DIR})
 	target_link_libraries(secp256k1 ${GMP_LIBRARY})
 	set(USE_NUM_GMP 1)
 	set(USE_FIELD_INV_NUM 1)
 	set(USE_SCALAR_INV_NUM 1)
 else()
 	set(USE_NUM_NONE 1)
 	set(USE_FIELD_INV_BUILTIN 1)
 	set(USE_SCALAR_INV_BUILTIN 1)
 endif()
 
 # We check if amd64 asm is supported.
 check_c_source_compiles("
 	#include <stdint.h>
 	int main() {
 		uint64_t a = 11, tmp;
 		__asm__ __volatile__(\"movq \$0x100000000,%1; mulq %%rsi\" : \"+a\"(a) : \"S\"(tmp) : \"cc\", \"%rdx\");
 		return 0;
 	}
 " USE_ASM_X86_64)
 
 # We make sure __int128 is defined
 include(CheckTypeSize)
 check_type_size(__int128 SIZEOF___INT128)
 if(SIZEOF___INT128 EQUAL 16)
 	set(HAVE___INT128 1)
 else()
 	# If we do not support __int128, we should be falling back
 	# on 32bits implementations for field and scalar.
 endif()
 
 # Detect if we are on a 32 or 64 bits platform and chose
 # scalar and field implementation accordingly.
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
 	# 64 bits implementation require either __int128 or asm support.
 	if (HAVE___INT128 OR USE_ASM_X86_64)
 		set(USE_SCALAR_4X64 1)
 		set(USE_FIELD_5X52 1)
 	else()
 		message(SEND_ERROR "Compiler does not support __int128 or inline assembly")
 	endif()
 else()
 	set(USE_SCALAR_8X32 1)
 	set(USE_FIELD_10X26 1)
 endif()
 
 # Executable internal to secp256k1 need to have the HAVE_CONFIG_H define set.
 # For convenience, we wrap this into a function.
 function(link_secp256k1_internal NAME)
 	target_link_libraries(${NAME} secp256k1)
 	target_compile_definitions(${NAME} PRIVATE HAVE_CONFIG_H SECP256K1_BUILD)
 endfunction(link_secp256k1_internal)
 
 # Phony target to build benchmarks
 add_custom_target(bench-secp256k1)
 
 function(add_secp256k1_bench NAME)
 	set(EXECUTABLE_NAME "${NAME}-bench")
 	add_executable(${EXECUTABLE_NAME} EXCLUDE_FROM_ALL ${ARGN})
 	link_secp256k1_internal(${EXECUTABLE_NAME})
 
 	set(BENCH_NAME "bench-secp256k1-${NAME}")
 	add_custom_target(${BENCH_NAME} COMMAND ${EXECUTABLE_NAME} USES_TERMINAL)
 	add_dependencies(bench-secp256k1 ${BENCH_NAME})
 endfunction(add_secp256k1_bench)
 
 # ECDH module
 option(SECP256K1_ENABLE_MODULE_ECDH "Build libsecp256k1's ECDH module" OFF)
 if(SECP256K1_ENABLE_MODULE_ECDH)
 	set(ENABLE_MODULE_ECDH 1)
 	add_secp256k1_bench(ecdh src/bench_ecdh.c)
 endif()
 
 # MultiSet module
 option(SECP256K1_ENABLE_MODULE_MULTISET "Build libsecp256k1's MULTISET module" ON)
 if(SECP256K1_ENABLE_MODULE_MULTISET)
     set(ENABLE_MODULE_MULTISET 1)
 	add_secp256k1_bench(multiset src/bench_multiset.c)
 endif()
 
 # Recovery module
 option(SECP256K1_ENABLE_MODULE_RECOVERY "Build libsecp256k1's recovery module" ON)
 if(SECP256K1_ENABLE_MODULE_RECOVERY)
 	set(ENABLE_MODULE_RECOVERY 1)
 	add_secp256k1_bench(recover src/bench_recover.c)
 endif()
 
 # Schnorr module
 option(SECP256K1_ENABLE_MODULE_SCHNORR "Build libsecp256k1's Schnorr module" ON)
 if(SECP256K1_ENABLE_MODULE_SCHNORR)
 	set(ENABLE_MODULE_SCHNORR 1)
 endif()
 
 # Static precomputation for elliptic curve multiplication
 option(SECP256K1_ECMULT_STATIC_PRECOMPUTATION "Precompute libsecp256k1's elliptic curve multiplication tables" ON)
 if(SECP256K1_ECMULT_STATIC_PRECOMPUTATION)
 	set(USE_ECMULT_STATIC_PRECOMPUTATION 1)
 	set(SECP256K1_ECMULT_WINDOW_SIZE 15 CACHE STRING "Window size for ecmult precomputation for verification, specified as integer in range [2..24].")
 	if(${SECP256K1_ECMULT_WINDOW_SIZE} LESS 2 OR ${SECP256K1_ECMULT_WINDOW_SIZE} GREATER 24)
 		message(FATAL_ERROR "SECP256K1_ECMULT_WINDOW_SIZE must be an integer in range [2..24]")
 	endif()
 
 	# FIXME: Propagate SECP256K1_ECMULT_WINDOW_SIZE
 	include(NativeExecutable)
 	add_native_executable(gen_context src/gen_context.c)
 
 	add_custom_command(
 		OUTPUT src/ecmult_static_context.h
 		COMMAND gen_context
 	)
 
 	target_sources(secp256k1 PRIVATE src/ecmult_static_context.h)
 endif()
 
 # Generate the config
 configure_file(src/libsecp256k1-config.h.cmake.in src/libsecp256k1-config.h ESCAPE_QUOTES)
 target_compile_definitions(secp256k1 PRIVATE HAVE_CONFIG_H SECP256K1_BUILD)
 
 # Build the Java binding
 option(SECP256K1_ENABLE_JNI "Enable the Java Native Interface binding" OFF)
 if(SECP256K1_ENABLE_JNI)
 	if(NOT SECP256K1_ENABLE_MODULE_ECDH)
 		message(FATAL_ERROR "The secp256k1 JNI support requires ECDH. Try again with -DSECP256K1_ENABLE_MODULE_ECDH=ON.")
 	endif()
 
 	find_package(Java REQUIRED)
 	find_package(JNI REQUIRED)
 	include(UseJava)
 
 	add_library(secp256k1_jni SHARED
 		src/java/org_bitcoin_NativeSecp256k1.c
 		src/java/org_bitcoin_Secp256k1Context.c
 	)
 
 	target_include_directories(secp256k1_jni PUBLIC ${JNI_INCLUDE_DIRS})
 	# As per CMake documentation: the POSITION_INDEPENDENT_CODE property is set
 	# when a target is created. It defaults to True for SHARED or MODULE library
 	# targets and False otherwise.
 	# The secp256ki_jni library being shared, the property is set and it will
 	# build with PIC enabled. But the secp256k1 dependency might not have the
 	# property set, so it's associated source files won't be built with PIC
 	# enabled. That would cause the linker to fail.
 	# Forcing the property for the secp256k1 library fixes the issue.
 	set_target_properties(secp256k1 PROPERTIES POSITION_INDEPENDENT_CODE ON)
 	link_secp256k1_internal(secp256k1_jni)
 endif()
 
 # Tests
 option(SECP256K1_BUILD_TEST "Build secp256k1's unit tests" ON)
 if(SECP256K1_BUILD_TEST)
 	include(TestSuite)
 	create_test_suite(secp256k1)
 
 	function(create_secp256k1_test NAME FILES)
 		add_test_to_suite(secp256k1 ${NAME} EXCLUDE_FROM_ALL ${FILES})
 		link_secp256k1_internal(${NAME})
 	endfunction()
 
 	create_secp256k1_test(tests src/tests.c)
 	target_compile_definitions(tests PRIVATE VERIFY)
 
 	create_secp256k1_test(exhaustive_tests src/tests_exhaustive.c)
 	# This should not be enabled at the same time as coverage is.
 	# TODO: support coverage.
 	target_compile_definitions(exhaustive_tests PRIVATE VERIFY)
 
 	if(SECP256K1_ENABLE_JNI)
 		set(SECP256k1_JNI_TEST_JAR "secp256k1-jni-test")
 
 		set(CMAKE_JNI_TARGET TRUE)
 		add_jar(secp256k1-jni-test-jar
 			SOURCES
 				src/java/org/bitcoin/NativeSecp256k1.java
 				src/java/org/bitcoin/NativeSecp256k1Test.java
 				src/java/org/bitcoin/NativeSecp256k1Util.java
 				src/java/org/bitcoin/Secp256k1Context.java
 			ENTRY_POINT org/bitcoin/NativeSecp256k1Test
 			OUTPUT_NAME "${SECP256k1_JNI_TEST_JAR}"
 		)
 		add_dependencies(secp256k1-jni-test-jar secp256k1_jni)
 
 		add_custom_target(check-secp256k1-java
 			COMMAND
 				"${Java_JAVA_EXECUTABLE}"
 				"-Djava.library.path=${CMAKE_CURRENT_BINARY_DIR}"
 				"-jar"
 				"${SECP256k1_JNI_TEST_JAR}.jar"
 			WORKING_DIRECTORY
 				"${CMAKE_CURRENT_BINARY_DIR}"
 		)
 		add_dependencies(check-secp256k1-java secp256k1-jni-test-jar)
 		add_dependencies(check-secp256k1 check-secp256k1-java)
 	endif()
 endif(SECP256K1_BUILD_TEST)
 
 # Benchmarks
 add_secp256k1_bench(verify src/bench_verify.c)
 add_secp256k1_bench(sign src/bench_sign.c)
 add_secp256k1_bench(internal src/bench_internal.c)
 add_secp256k1_bench(ecmult src/bench_ecmult.c)
diff --git a/src/univalue/CMakeLists.txt b/src/univalue/CMakeLists.txt
index bf1a4b97c..dd2da1f71 100644
--- a/src/univalue/CMakeLists.txt
+++ b/src/univalue/CMakeLists.txt
@@ -1,54 +1,54 @@
 # Copyright (c) 2017 The Bitcoin developers
 
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.13)
 project(univalue)
 
 option(UNIVALUE_BUILD_TESTS "Build univalue's unit tests" ON)
 
 # TODO: Version info
 add_library(univalue
 	lib/univalue.cpp
 	lib/univalue_get.cpp
 	lib/univalue_read.cpp
 	lib/univalue_write.cpp
 )
 
 target_include_directories(univalue
 	PUBLIC
 		include
 	PRIVATE
 		lib
 )
 
 if(UNIVALUE_BUILD_TESTS)
 	include(TestSuite)
 	create_test_suite(univalue)
 
 	function(create_univalue_test NAME FILES)
 		add_test_to_suite(univalue ${NAME} ${FILES})
 		target_link_libraries(${NAME} univalue)
 	endfunction()
 
 	create_univalue_test(unitester_test test/unitester.cpp)
 	target_compile_definitions(unitester_test
 		PUBLIC JSON_TEST_SRC="${PROJECT_SOURCE_DIR}/test"
 	)
 
 	create_univalue_test(no_nul_test test/no_nul.cpp)
 	create_univalue_test(object_test test/object.cpp)
 
 	# test_json is not meant to run in an automated test suite.
 	add_executable(json_test EXCLUDE_FROM_ALL test/test_json.cpp)
 	target_link_libraries(json_test univalue)
 	add_dependencies(check-univalue json_test)
 endif(UNIVALUE_BUILD_TESTS)
 
 # Generate lib/univalue_escapes.h
 include(NativeExecutable)
 add_native_executable(univalue_gen gen/gen.cpp)
 native_target_include_directories(univalue_gen PUBLIC include)
 
 # Custom target to regenerate univalue_escapes.h
 add_custom_target(generate_univalue_escapes_h
 	COMMAND univalue_gen > ${CMAKE_CURRENT_SOURCE_DIR}/lib/univalue_escapes.h
 )