diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index de4746569..48ec87506 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,745 +1,746 @@
 # Copyright (c) 2017 The Bitcoin developers
 
 project(bitcoind)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # 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_CLI "Build bitcoin-cli" ON)
 option(BUILD_BITCOIN_TX "Build bitcoin-tx" ON)
 option(BUILD_BITCOIN_QT "Build bitcoin-qt" ON)
 option(BUILD_BITCOIN_SEEDER "Build bitcoin-seeder" 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(START_WITH_UPNP "Make UPnP the default to map ports" OFF)
 option(ENABLE_CLANG_TIDY "Enable clang-tidy checks for Bitcoin ABC" OFF)
 option(ENABLE_PROFILING "Select the profiling tool to use" OFF)
 
 # Linker option
 if(CMAKE_CROSSCOMPILING)
 	set(DEFAULT_LINKER "")
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 	set(DEFAULT_LINKER lld)
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	set(DEFAULT_LINKER gold)
 else()
 	set(DEFAULT_LINKER "")
 endif()
 set(USE_LINKER "${DEFAULT_LINKER}" CACHE STRING "Linker to be used (default: ${DEFAULT_LINKER}). Set to empty string to use the system's default.")
 
 set(OS_WITH_JEMALLOC_AS_SYSTEM_DEFAULT
 	"Android"
 	"FreeBSD"
 	"NetBSD"
 )
 if(NOT CMAKE_SYSTEM_NAME IN_LIST OS_WITH_JEMALLOC_AS_SYSTEM_DEFAULT)
 	set(USE_JEMALLOC_DEFAULT ON)
 endif()
 
 # FIXME: Building against jemalloc causes the software to segfault on OSX.
 # See https://github.com/Bitcoin-ABC/bitcoin-abc/issues/401
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND NOT CMAKE_CROSSCOMPILING)
 	set(USE_JEMALLOC_DEFAULT OFF)
 endif()
 
 option(USE_JEMALLOC "Use jemalloc as an allocation library" ${USE_JEMALLOC_DEFAULT})
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 	set(DEFAULT_ENABLE_DBUS_NOTIFICATIONS ON)
 endif()
 option(ENABLE_DBUS_NOTIFICATIONS "Enable DBus desktop notifications. Linux only." ${DEFAULT_ENABLE_DBUS_NOTIFICATIONS})
 
 # If ccache is available, then use it.
 find_program(CCACHE ccache)
 if(CCACHE)
 	message(STATUS "Using ccache: ${CCACHE}")
 	set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE})
 	set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE})
 endif(CCACHE)
 
 # 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"
 	"-DUSE_JEMALLOC=OFF"
 	"-DENABLE_CLANG_TIDY=OFF"
 	"-DENABLE_BIP70=OFF"
 )
 
 if(ENABLE_CLANG_TIDY)
 	include(ClangTidy)
 endif()
 
 if(ENABLE_SANITIZERS)
 	include(Sanitizers)
 	enable_sanitizers(${ENABLE_SANITIZERS})
 endif()
 
 include(AddCompilerFlags)
 
 if(USE_LINKER)
 	set(LINKER_FLAG "-fuse-ld=${USE_LINKER}")
 	check_linker_flag(IS_LINKER_SUPPORTED ${LINKER_FLAG})
 	if(NOT IS_LINKER_SUPPORTED)
 		message(FATAL_ERROR "The ${USE_LINKER} linker is not supported, make sure ${USE_LINKER} is properly installed or use -DUSE_LINKER= to use the system's linker")
 	endif()
 	add_linker_flags(${LINKER_FLAG})
 endif()
 
 # Prefer -g3, defaults to -g if unavailable
 foreach(LANGUAGE C CXX)
 	set(COMPILER_DEBUG_LEVEL -g)
 	check_compiler_flags(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 some debugging symbols when the Debug build type is selected.
 add_compile_definitions_to_configuration(Debug DEBUG DEBUG_LOCKORDER ABORT_ON_FAILED_ASSUME)
 
 # Add -ftrapv when building in Debug
 add_compile_options_to_configuration(Debug -ftrapv)
 
 # All versions of gcc that we commonly use for building are subject to bug
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90348. To work around that, set
 # -fstack-reuse=none for all gcc builds. (Only gcc understands this flag)
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 	add_compiler_flags(-fstack-reuse=none)
 endif()
 
 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)
 
 	add_compile_definitions(
 		# Windows 7
 		_WIN32_WINNT=0x0601
 		# Internet Explorer 5.01 (!)
 		_WIN32_IE=0x0501
 		# Define WIN32_LEAN_AND_MEAN to exclude APIs such as Cryptography, DDE,
 		# RPC, Shell, and Windows Sockets.
 		WIN32_LEAN_AND_MEAN
 	)
 endif()
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	add_compile_definitions(MAC_OSX OBJC_OLD_DISPATCH_PROTOTYPES=0)
 	add_linker_flags(-Wl,-dead_strip_dylibs)
 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_flags(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,libstdc++)
 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, except in -O0 builds which
 	# do not support them
 	add_compiler_flags(-U_FORTIFY_SOURCE)
 	add_compile_options($<$<NOT:$<CONFIG:Debug>>:-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.
 	cmake_policy(SET CMP0083 NEW)
 	include(CheckPIESupported)
 	check_pie_supported()
 
 	if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		# MinGw provides its own libssp for stack smashing protection
 		link_libraries(ssp)
 	endif()
 endif()
 
 if(ENABLE_PROFILING MATCHES "gprof")
 	message(STATUS "Enable profiling with gprof")
 
 	# -pg is incompatible with -pie. Since hardening and profiling together
 	# doesn't make sense, we simply make them mutually exclusive here.
 	# Additionally, hardened toolchains may force -pie by default, in which
 	# case it needs to be turned off with -no-pie.
 	if(ENABLE_HARDENING)
 		message(FATAL_ERROR "Profiling with gprof requires disabling hardening with -DENABLE_HARDENING=OFF.")
 	endif()
 	add_linker_flags(-no-pie)
 
 	add_compiler_flags(-pg)
 	add_linker_flags(-pg)
 endif()
 
 # Enable warning
 add_c_compiler_flags(-Wnested-externs -Wstrict-prototypes)
 add_compiler_flags(
 	-Wall
 	-Wextra
 	-Wformat
 	-Wgnu
 	-Wvla
 	-Wcast-align
 	-Wunused-parameter
 	-Wmissing-braces
 	-Wthread-safety
 	-Wrange-loop-analysis
 	-Wredundant-decls
 	-Wunreachable-code-loop-increment
 	-Wsign-compare
 	-Wconditional-uninitialized
 	-Wduplicated-branches
 	-Wduplicated-cond
 	-Wlogical-op
 )
 add_compiler_flag_group(-Wformat -Wformat-security)
 add_cxx_compiler_flags(
 	-Wredundant-move
 	-Woverloaded-virtual
 )
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 	# GCC has no flag variant which is granular enough to avoid raising the clang
 	# -Wshadow-uncaptured-local equivalent. This is causing a lot of warnings
 	# on serialize.h which cannot be disabled locally, so drop the flag.
 	add_compiler_flags(
 		-Wshadow
 		-Wshadow-field
 	)
 endif()
 
 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()
 
 # libtool style configure
 add_subdirectory(config)
 
 # Enable LFS (Large File Support) on targets that don't have it natively.
 # This should be defined before the libraries are included as leveldb need the
 # definition to be set.
 if(NOT HAVE_LARGE_FILE_SUPPORT)
 	add_compile_definitions(_FILE_OFFSET_BITS=64)
 	add_linker_flags(-Wl,--large-address-aware)
 endif()
 
 if(ENABLE_GLIBC_BACK_COMPAT)
 	# 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()
 endif()
 
 if(USE_JEMALLOC)
 	# Most of the sanitizers require their instrumented allocation functions to
 	# be fully functional. This is obviously the case for all the memory related
 	# sanitizers (asan, lsan, msan) but not only.
 	if(ENABLE_SANITIZERS)
 		message(WARNING "Jemalloc is incompatible with the sanitizers and has been disabled.")
 	else()
 		find_package(Jemalloc 3.6.0 REQUIRED)
 		link_libraries(Jemalloc::jemalloc)
 	endif()
 endif()
 
 
 # Make sure that all the global compiler and linker flags are set BEFORE
 # including the libraries so they apply as needed.
 
 
 # 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
 			ERROR_QUIET
 		)
 
 		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/glibcxx_sanity.cpp
 	compat/strnlen.cpp
 	currencyunit.cpp
 	fs.cpp
 	interfaces/handler.cpp
 	logging.cpp
 	random.cpp
 	randomenv.cpp
 	rcu.cpp
 	rpc/request.cpp
 	blockdb.cpp
 	support/cleanse.cpp
 	support/lockedpool.cpp
 	sync.cpp
 	threadinterrupt.cpp
 	uint256.cpp
 	util/asmap.cpp
 	util/bip32.cpp
 	util/bytevectorhash.cpp
 	util/error.cpp
 	util/message.cpp
 	util/moneystr.cpp
 	util/readwritefile.cpp
 	util/settings.cpp
 	util/sock.cpp
 	util/spanparsing.cpp
 	util/strencodings.cpp
 	util/string.cpp
 	util/system.cpp
 	util/threadnames.cpp
 	util/time.cpp
 	util/url.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)
 	target_sources(util PRIVATE compat/glibc_compat.cpp)
 endif()
 
 # Target specific configs
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	set(Boost_USE_STATIC_LIBS ON)
 	set(Boost_USE_STATIC_RUNTIME ON)
 	set(Boost_THREADAPI win32)
 
 	find_package(SHLWAPI REQUIRED)
 	target_link_libraries(util SHLWAPI::shlwapi)
 
 	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()
 
 target_link_libraries(util univalue crypto)
 
 macro(link_event TARGET)
 	non_native_target_link_libraries(${TARGET} Event 2.0.22 ${ARGN})
 endmacro()
 
 link_event(util event)
 
 macro(link_boost TARGET)
 	non_native_target_link_libraries(${TARGET} Boost 1.59 ${ARGN})
 endmacro()
 
 link_boost(util filesystem thread)
 # 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)
 
 function(add_network_sources NETWORK_SOURCES)
 	set(NETWORK_DIR abc)
 
 	list(TRANSFORM
 		ARGN
 		PREPEND "networks/${NETWORK_DIR}/"
 		OUTPUT_VARIABLE NETWORK_SOURCES
 	)
 	set(NETWORK_SOURCES ${NETWORK_SOURCES} PARENT_SCOPE)
 endfunction()
 
 add_network_sources(NETWORK_SOURCES
 	checkpoints.cpp
 	network.cpp
 	chainparamsconstants.cpp
 )
 
 # 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
 	bloom.cpp
 	cashaddr.cpp
 	cashaddrenc.cpp
 	chainparams.cpp
 	config.cpp
 	consensus/merkle.cpp
 	coins.cpp
 	compressor.cpp
 	eventloop.cpp
 	feerate.cpp
 	core_read.cpp
 	core_write.cpp
 	key.cpp
 	key_io.cpp
 	merkleblock.cpp
 	net_permissions.cpp
 	netaddress.cpp
 	netbase.cpp
 	outputtype.cpp
 	policy/policy.cpp
 	primitives/block.cpp
 	protocol.cpp
 	psbt.cpp
 	rpc/rawtransaction_util.cpp
 	rpc/util.cpp
 	scheduler.cpp
 	salteduint256hasher.cpp
 	versionbitsinfo.cpp
 	warnings.cpp
 
 	${NETWORK_SOURCES}
 )
 
 target_link_libraries(common bitcoinconsensus util secp256k1 script)
 
 # script library
 add_library(script
 	script/bitfield.cpp
 	script/descriptor.cpp
 	script/interpreter.cpp
 	script/script.cpp
 	script/script_error.cpp
 	script/sigencoding.cpp
 	script/sign.cpp
 	script/signingprovider.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
 	consensus/tx_check.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/avalanche.cpp
 	avalanche/delegation.cpp
 	avalanche/delegationbuilder.cpp
 	avalanche/peermanager.cpp
 	avalanche/processor.cpp
 	avalanche/proof.cpp
 	avalanche/proofid.cpp
 	avalanche/proofbuilder.cpp
 	avalanche/proofpool.cpp
 	avalanche/voterecord.cpp
 	banman.cpp
 	blockencodings.cpp
 	blockfilter.cpp
 	blockindex.cpp
 	chain.cpp
 	checkpoints.cpp
 	config.cpp
 	consensus/activation.cpp
 	consensus/tx_verify.cpp
 	dbwrapper.cpp
 	dnsseeds.cpp
 	flatfile.cpp
 	httprpc.cpp
 	httpserver.cpp
+	i2p.cpp
 	index/base.cpp
 	index/blockfilterindex.cpp
 	index/txindex.cpp
 	init.cpp
 	interfaces/chain.cpp
 	interfaces/node.cpp
 	invrequest.cpp
 	miner.cpp
 	minerfund.cpp
 	net.cpp
 	net_processing.cpp
 	node/coin.cpp
 	node/coinstats.cpp
 	node/context.cpp
 	node/psbt.cpp
 	node/transaction.cpp
 	node/ui_interface.cpp
 	noui.cpp
 	policy/fees.cpp
 	policy/settings.cpp
 	pow/aserti32d.cpp
 	pow/daa.cpp
 	pow/eda.cpp
 	pow/grasberg.cpp
 	pow/pow.cpp
 	rest.cpp
 	rpc/abc.cpp
 	rpc/avalanche.cpp
 	rpc/blockchain.cpp
 	rpc/command.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
 	validation.cpp
 	validationinterface.cpp
 	versionbits.cpp
 )
 
 target_include_directories(server PRIVATE leveldb/helpers/memenv)
 
 target_link_libraries(server
 	bitcoinconsensus
 	leveldb
 	memenv
 )
 
 link_event(server event)
 if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	link_event(server pthreads)
 endif()
 
 if(ENABLE_UPNP)
 	find_package(MiniUPnPc 1.9 REQUIRED)
 	target_link_libraries(server MiniUPnPc::miniupnpc)
 
 	if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		# TODO: check if we are really using a static library. Assume this is
 		# the one from the depends for now since the native windows build is not
 		# supported.
 		target_compile_definitions(server
 			PUBLIC -DSTATICLIB
 			PUBLIC -DMINIUPNP_STATICLIB
 		)
 	endif()
 endif()
 
 # Test suites.
 add_subdirectory(test)
 add_subdirectory(avalanche/test)
 add_subdirectory(pow/test)
 
 # Benchmark suite.
 add_subdirectory(bench)
 
 include(BinaryTest)
 include(WindowsVersionInfo)
 
 # Wallet
 if(BUILD_BITCOIN_WALLET)
 	add_subdirectory(wallet)
 	target_link_libraries(server wallet)
 
 	# bitcoin-wallet
 	add_executable(bitcoin-wallet bitcoin-wallet.cpp)
 	generate_windows_version_info(bitcoin-wallet
 		DESCRIPTION "CLI tool for ${PACKAGE_NAME} wallets"
 	)
 
 	target_link_libraries(bitcoin-wallet wallet-tool common util)
 
 	add_to_symbols_check(bitcoin-wallet)
 	add_to_security_check(bitcoin-wallet)
 
 	install_target(bitcoin-wallet)
 	install_manpages(bitcoin-wallet)
 else()
 	target_sources(server PRIVATE dummywallet.cpp)
 endif()
 
 # ZeroMQ
 if(BUILD_BITCOIN_ZMQ)
 	add_subdirectory(zmq)
 	target_link_libraries(server zmq)
 endif()
 
 # RPC client support
 add_library(rpcclient
 	compat/stdin.cpp
 	rpc/client.cpp
 )
 
 target_link_libraries(rpcclient univalue util)
 
 # bitcoin-seeder
 if(BUILD_BITCOIN_SEEDER)
 	add_subdirectory(seeder)
 endif()
 
 # bitcoin-cli
 if(BUILD_BITCOIN_CLI)
 	add_executable(bitcoin-cli bitcoin-cli.cpp)
 	generate_windows_version_info(bitcoin-cli
 		DESCRIPTION "JSON-RPC client for ${PACKAGE_NAME}"
 	)
 
 	target_link_libraries(bitcoin-cli common rpcclient)
 	link_event(bitcoin-cli event)
 
 	add_to_symbols_check(bitcoin-cli)
 	add_to_security_check(bitcoin-cli)
 
 	install_target(bitcoin-cli)
 	install_manpages(bitcoin-cli)
 endif()
 
 # bitcoin-tx
 if(BUILD_BITCOIN_TX)
 	add_executable(bitcoin-tx bitcoin-tx.cpp)
 	generate_windows_version_info(bitcoin-tx
 		DESCRIPTION "CLI Bitcoin transaction editor utility"
 	)
 
 	target_link_libraries(bitcoin-tx bitcoinconsensus)
 
 	add_to_symbols_check(bitcoin-tx)
 	add_to_security_check(bitcoin-tx)
 
 	install_target(bitcoin-tx)
 	install_manpages(bitcoin-tx)
 endif()
 
 # bitcoind
 add_executable(bitcoind bitcoind.cpp)
 target_link_libraries(bitcoind server)
 generate_windows_version_info(bitcoind
 	DESCRIPTION "Bitcoin node with a JSON-RPC server"
 )
 add_to_symbols_check(bitcoind)
 add_to_security_check(bitcoind)
 
 install_target(bitcoind)
 install_manpages(bitcoind)
 
 # Bitcoin-qt
 if(BUILD_BITCOIN_QT)
 	add_subdirectory(qt)
 endif()
diff --git a/src/i2p.cpp b/src/i2p.cpp
new file mode 100644
index 000000000..f66aa2e96
--- /dev/null
+++ b/src/i2p.cpp
@@ -0,0 +1,413 @@
+// Copyright (c) 2020-2020 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <i2p.h>
+
+#include <chainparams.h>
+#include <compat.h>
+#include <compat/endian.h>
+#include <crypto/sha256.h>
+#include <fs.h>
+#include <logging.h>
+#include <netaddress.h>
+#include <netbase.h>
+#include <random.h>
+#include <tinyformat.h>
+#include <util/readwritefile.h>
+#include <util/sock.h>
+#include <util/spanparsing.h>
+#include <util/strencodings.h>
+#include <util/system.h>
+
+#include <chrono>
+#include <stdexcept>
+#include <string>
+
+namespace i2p {
+
+/**
+ * Swap Standard Base64 <-> I2P Base64.
+ * Standard Base64 uses `+` and `/` as last two characters of its alphabet.
+ * I2P Base64 uses `-` and `~` respectively.
+ * So it is easy to detect in which one is the input and convert to the other.
+ * @param[in] from Input to convert.
+ * @return converted `from`
+ */
+static std::string SwapBase64(const std::string &from) {
+    std::string to;
+    to.resize(from.size());
+    for (size_t i = 0; i < from.size(); ++i) {
+        switch (from[i]) {
+            case '-':
+                to[i] = '+';
+                break;
+            case '~':
+                to[i] = '/';
+                break;
+            case '+':
+                to[i] = '-';
+                break;
+            case '/':
+                to[i] = '~';
+                break;
+            default:
+                to[i] = from[i];
+                break;
+        }
+    }
+    return to;
+}
+
+/**
+ * Decode an I2P-style Base64 string.
+ * @param[in] i2p_b64 I2P-style Base64 string.
+ * @return decoded `i2p_b64`
+ * @throw std::runtime_error if decoding fails
+ */
+static Binary DecodeI2PBase64(const std::string &i2p_b64) {
+    const std::string &std_b64 = SwapBase64(i2p_b64);
+    bool invalid;
+    Binary decoded = DecodeBase64(std_b64.c_str(), &invalid);
+    if (invalid) {
+        throw std::runtime_error(
+            strprintf("Cannot decode Base64: \"%s\"", i2p_b64));
+    }
+    return decoded;
+}
+
+/**
+ * Derive the .b32.i2p address of an I2P destination (binary).
+ * @param[in] dest I2P destination.
+ * @return the address that corresponds to `dest`
+ * @throw std::runtime_error if conversion fails
+ */
+static CNetAddr DestBinToAddr(const Binary &dest) {
+    CSHA256 hasher;
+    hasher.Write(dest.data(), dest.size());
+    uint8_t hash[CSHA256::OUTPUT_SIZE];
+    hasher.Finalize(hash);
+
+    CNetAddr addr;
+    const std::string addr_str = EncodeBase32(hash, false) + ".b32.i2p";
+    if (!addr.SetSpecial(addr_str)) {
+        throw std::runtime_error(
+            strprintf("Cannot parse I2P address: \"%s\"", addr_str));
+    }
+
+    return addr;
+}
+
+/**
+ * Derive the .b32.i2p address of an I2P destination (I2P-style Base64).
+ * @param[in] dest I2P destination.
+ * @return the address that corresponds to `dest`
+ * @throw std::runtime_error if conversion fails
+ */
+static CNetAddr DestB64ToAddr(const std::string &dest) {
+    const Binary &decoded = DecodeI2PBase64(dest);
+    return DestBinToAddr(decoded);
+}
+
+namespace sam {
+
+    Session::Session(const fs::path &private_key_file,
+                     const CService &control_host, CThreadInterrupt *interrupt)
+        : m_private_key_file(private_key_file), m_control_host(control_host),
+          m_interrupt(interrupt) {}
+
+    Session::~Session() {
+        LOCK(m_mutex);
+        Disconnect();
+    }
+
+    bool Session::Listen(Connection &conn) {
+        try {
+            LOCK(m_mutex);
+            CreateIfNotCreatedAlready();
+            conn.me = m_my_addr;
+            conn.sock = StreamAccept();
+            return true;
+        } catch (const std::runtime_error &e) {
+            Log("Error listening: %s", e.what());
+            CheckControlSock();
+        }
+        return false;
+    }
+
+    bool Session::Accept(Connection &conn) {
+        try {
+            while (!*m_interrupt) {
+                Sock::Event occurred;
+                conn.sock.Wait(MAX_WAIT_FOR_IO, Sock::RECV, &occurred);
+
+                if ((occurred & Sock::RECV) == 0) {
+                    // Timeout, no incoming connections within MAX_WAIT_FOR_IO.
+                    continue;
+                }
+
+                const std::string &peer_dest = conn.sock.RecvUntilTerminator(
+                    '\n', MAX_WAIT_FOR_IO, *m_interrupt, MAX_MSG_SIZE);
+
+                conn.peer = CService(DestB64ToAddr(peer_dest),
+                                     Params().GetDefaultPort());
+
+                return true;
+            }
+        } catch (const std::runtime_error &e) {
+            Log("Error accepting: %s", e.what());
+            CheckControlSock();
+        }
+        return false;
+    }
+
+    bool Session::Connect(const CService &to, Connection &conn,
+                          bool &proxy_error) {
+        proxy_error = true;
+
+        std::string session_id;
+        Sock sock;
+        conn.peer = to;
+
+        try {
+            {
+                LOCK(m_mutex);
+                CreateIfNotCreatedAlready();
+                session_id = m_session_id;
+                conn.me = m_my_addr;
+                sock = Hello();
+            }
+
+            const Reply &lookup_reply = SendRequestAndGetReply(
+                sock, strprintf("NAMING LOOKUP NAME=%s", to.ToStringIP()));
+
+            const std::string &dest = lookup_reply.Get("VALUE");
+
+            const Reply &connect_reply = SendRequestAndGetReply(
+                sock,
+                strprintf("STREAM CONNECT ID=%s DESTINATION=%s SILENT=false",
+                          session_id, dest),
+                false);
+
+            const std::string &result = connect_reply.Get("RESULT");
+
+            if (result == "OK") {
+                conn.sock = std::move(sock);
+                return true;
+            }
+
+            if (result == "INVALID_ID") {
+                LOCK(m_mutex);
+                Disconnect();
+                throw std::runtime_error("Invalid session id");
+            }
+
+            if (result == "CANT_REACH_PEER" || result == "TIMEOUT") {
+                proxy_error = false;
+            }
+
+            throw std::runtime_error(strprintf("\"%s\"", connect_reply.full));
+        } catch (const std::runtime_error &e) {
+            Log("Error connecting to %s: %s", to.ToString(), e.what());
+            CheckControlSock();
+            return false;
+        }
+    }
+
+    // Private methods
+
+    std::string Session::Reply::Get(const std::string &key) const {
+        const auto &pos = keys.find(key);
+        if (pos == keys.end() || !pos->second.has_value()) {
+            throw std::runtime_error(
+                strprintf("Missing %s= in the reply to \"%s\": \"%s\"", key,
+                          request, full));
+        }
+        return pos->second.value();
+    }
+
+    template <typename... Args>
+    void Session::Log(const std::string &fmt, const Args &... args) const {
+        LogPrint(BCLog::I2P, "I2P: %s\n", tfm::format(fmt, args...));
+    }
+
+    Session::Reply Session::SendRequestAndGetReply(const Sock &sock,
+                                                   const std::string &request,
+                                                   bool check_result_ok) const {
+        sock.SendComplete(request + "\n", MAX_WAIT_FOR_IO, *m_interrupt);
+
+        Reply reply;
+
+        // Don't log the full "SESSION CREATE ..." because it contains our
+        // private key.
+        reply.request = request.substr(0, 14) == "SESSION CREATE"
+                            ? "SESSION CREATE ..."
+                            : request;
+
+        // It could take a few minutes for the I2P router to reply as it is
+        // querying the I2P network (when doing name lookup, for example).
+        // Notice: `RecvUntilTerminator()` is checking `m_interrupt` more often,
+        // so we would not be stuck here for long if `m_interrupt` is signaled.
+        static constexpr auto recv_timeout = 3min;
+
+        reply.full = sock.RecvUntilTerminator('\n', recv_timeout, *m_interrupt,
+                                              MAX_MSG_SIZE);
+
+        for (const auto &kv : spanparsing::Split(reply.full, ' ')) {
+            const auto &pos = std::find(kv.begin(), kv.end(), '=');
+            if (pos != kv.end()) {
+                reply.keys.emplace(std::string{kv.begin(), pos},
+                                   std::string{pos + 1, kv.end()});
+            } else {
+                reply.keys.emplace(std::string{kv.begin(), kv.end()},
+                                   std::nullopt);
+            }
+        }
+
+        if (check_result_ok && reply.Get("RESULT") != "OK") {
+            throw std::runtime_error(strprintf(
+                "Unexpected reply to \"%s\": \"%s\"", request, reply.full));
+        }
+
+        return reply;
+    }
+
+    Sock Session::Hello() const {
+        auto sock = CreateSock(m_control_host);
+
+        if (!sock) {
+            throw std::runtime_error("Cannot create socket");
+        }
+
+        if (!ConnectSocketDirectly(m_control_host, sock->Get(), nConnectTimeout,
+                                   true)) {
+            throw std::runtime_error(
+                strprintf("Cannot connect to %s", m_control_host.ToString()));
+        }
+
+        SendRequestAndGetReply(*sock, "HELLO VERSION MIN=3.1 MAX=3.1");
+
+        return std::move(*sock);
+    }
+
+    void Session::CheckControlSock() {
+        LOCK(m_mutex);
+
+        std::string errmsg;
+        if (!m_control_sock.IsConnected(errmsg)) {
+            Log("Control socket error: %s", errmsg);
+            Disconnect();
+        }
+    }
+
+    void Session::DestGenerate(const Sock &sock) {
+        // https://geti2p.net/spec/common-structures#key-certificates
+        // "7" or "EdDSA_SHA512_Ed25519" - "Recent Router Identities and
+        // Destinations". Use "7" because i2pd <2.24.0 does not recognize the
+        // textual form.
+        const Reply &reply = SendRequestAndGetReply(
+            sock, "DEST GENERATE SIGNATURE_TYPE=7", false);
+
+        m_private_key = DecodeI2PBase64(reply.Get("PRIV"));
+    }
+
+    void Session::GenerateAndSavePrivateKey(const Sock &sock) {
+        DestGenerate(sock);
+
+        // umask is set to 077 in init.cpp, which is ok (unless -sysperms is
+        // given)
+        if (!WriteBinaryFile(
+                m_private_key_file,
+                std::string(m_private_key.begin(), m_private_key.end()))) {
+            throw std::runtime_error(
+                strprintf("Cannot save I2P private key to %s",
+                          fs::quoted(fs::PathToString(m_private_key_file))));
+        }
+    }
+
+    Binary Session::MyDestination() const {
+        // From https://geti2p.net/spec/common-structures#destination:
+        // "They are 387 bytes plus the certificate length specified at bytes
+        // 385-386, which may be non-zero"
+        static constexpr size_t DEST_LEN_BASE = 387;
+        static constexpr size_t CERT_LEN_POS = 385;
+
+        uint16_t cert_len;
+        memcpy(&cert_len, &m_private_key.at(CERT_LEN_POS), sizeof(cert_len));
+        cert_len = be16toh(cert_len);
+
+        const size_t dest_len = DEST_LEN_BASE + cert_len;
+
+        return Binary{m_private_key.begin(), m_private_key.begin() + dest_len};
+    }
+
+    void Session::CreateIfNotCreatedAlready() {
+        std::string errmsg;
+        if (m_control_sock.IsConnected(errmsg)) {
+            return;
+        }
+
+        Log("Creating SAM session with %s", m_control_host.ToString());
+
+        Sock sock = Hello();
+
+        const auto &[read_ok, data] = ReadBinaryFile(m_private_key_file);
+        if (read_ok) {
+            m_private_key.assign(data.begin(), data.end());
+        } else {
+            GenerateAndSavePrivateKey(sock);
+        }
+
+        const std::string &session_id = GetRandHash().GetHex().substr(
+            0, 10); // full is an overkill, too verbose in the logs
+        const std::string &private_key_b64 =
+            SwapBase64(EncodeBase64(m_private_key));
+
+        SendRequestAndGetReply(
+            sock, strprintf("SESSION CREATE STYLE=STREAM ID=%s DESTINATION=%s",
+                            session_id, private_key_b64));
+
+        m_my_addr =
+            CService(DestBinToAddr(MyDestination()), Params().GetDefaultPort());
+        m_session_id = session_id;
+        m_control_sock = std::move(sock);
+
+        LogPrintf("I2P: SAM session created: session id=%s, my address=%s\n",
+                  m_session_id, m_my_addr.ToString());
+    }
+
+    Sock Session::StreamAccept() {
+        Sock sock = Hello();
+
+        const Reply &reply = SendRequestAndGetReply(
+            sock, strprintf("STREAM ACCEPT ID=%s SILENT=false", m_session_id),
+            false);
+
+        const std::string &result = reply.Get("RESULT");
+
+        if (result == "OK") {
+            return sock;
+        }
+
+        if (result == "INVALID_ID") {
+            // If our session id is invalid, then force session re-creation on
+            // next usage.
+            Disconnect();
+        }
+
+        throw std::runtime_error(strprintf("\"%s\"", reply.full));
+    }
+
+    void Session::Disconnect() {
+        if (m_control_sock.Get() != INVALID_SOCKET) {
+            if (m_session_id.empty()) {
+                Log("Destroying incomplete session");
+            } else {
+                Log("Destroying session %s", m_session_id);
+            }
+        }
+        m_control_sock.Reset();
+        m_session_id.clear();
+    }
+} // namespace sam
+} // namespace i2p
diff --git a/src/i2p.h b/src/i2p.h
new file mode 100644
index 000000000..d1de9fa2b
--- /dev/null
+++ b/src/i2p.h
@@ -0,0 +1,282 @@
+// Copyright (c) 2020-2020 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_I2P_H
+#define BITCOIN_I2P_H
+
+#include <compat.h>
+#include <fs.h>
+#include <netaddress.h>
+#include <sync.h>
+#include <threadinterrupt.h>
+#include <util/sock.h>
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace i2p {
+
+/**
+ * Binary data.
+ */
+using Binary = std::vector<uint8_t>;
+
+/**
+ * An established connection with another peer.
+ */
+struct Connection {
+    /** Connected socket. */
+    Sock sock;
+
+    /** Our I2P address. */
+    CService me;
+
+    /** The peer's I2P address. */
+    CService peer;
+};
+
+namespace sam {
+
+    /**
+     * The maximum size of an incoming message from the I2P SAM proxy (in
+     * bytes). Used to avoid a runaway proxy from sending us an "unlimited"
+     * amount of data without a terminator. The longest known message is ~1400
+     * bytes, so this is high enough not to be triggered during normal
+     * operation, yet low enough to avoid a malicious proxy from filling our
+     * memory.
+     */
+    static constexpr size_t MAX_MSG_SIZE{65536};
+
+    /**
+     * I2P SAM session.
+     */
+    class Session {
+    public:
+        /**
+         * Construct a session. This will not initiate any IO, the session will
+         * be lazily created later when first used.
+         * @param[in] private_key_file Path to a private key file. If the file
+         * does not exist then the private key will be generated and saved into
+         * the file.
+         * @param[in] control_host Location of the SAM proxy.
+         * @param[in,out] interrupt If this is signaled then all operations are
+         * canceled as soon as possible and executing methods throw an
+         * exception. Notice: only a pointer to the `CThreadInterrupt` object is
+         * saved, so it must not be destroyed earlier than this `Session`
+         * object.
+         */
+        Session(const fs::path &private_key_file, const CService &control_host,
+                CThreadInterrupt *interrupt);
+
+        /**
+         * Destroy the session, closing the internally used sockets. The sockets
+         * that have been returned by `Accept()` or `Connect()` will not be
+         * closed, but they will be closed by the SAM proxy because the session
+         * is destroyed. So they will return an error next time we try to read
+         * or write to them.
+         */
+        ~Session();
+
+        /**
+         * Start listening for an incoming connection.
+         * @param[out] conn Upon successful completion the `sock` and `me`
+         * members will be set to the listening socket and address.
+         * @return true on success
+         */
+        bool Listen(Connection &conn);
+
+        /**
+         * Wait for and accept a new incoming connection.
+         * @param[in,out] conn The `sock` member is used for waiting and
+         * accepting. Upon successful completion the `peer` member will be set
+         * to the address of the incoming peer.
+         * @return true on success
+         */
+        bool Accept(Connection &conn);
+
+        /**
+         * Connect to an I2P peer.
+         * @param[in] to Peer to connect to.
+         * @param[out] conn Established connection. Only set if `true` is
+         * returned.
+         * @param[out] proxy_error If an error occurs due to proxy or general
+         * network failure, then this is set to `true`. If an error occurs due
+         * to unreachable peer (likely peer is down), then it is set to `false`.
+         * Only set if `false` is returned.
+         * @return true on success
+         */
+        bool Connect(const CService &to, Connection &conn, bool &proxy_error);
+
+    private:
+        /**
+         * A reply from the SAM proxy.
+         */
+        struct Reply {
+            /**
+             * Full, unparsed reply.
+             */
+            std::string full;
+
+            /**
+             * Request, used for detailed error reporting.
+             */
+            std::string request;
+
+            /**
+             * A map of keywords from the parsed reply.
+             * For example, if the reply is "A=X B C=YZ", then the map will be
+             * keys["A"] == "X"
+             * keys["B"] == (empty std::optional)
+             * keys["C"] == "YZ"
+             */
+            std::unordered_map<std::string, std::optional<std::string>> keys;
+
+            /**
+             * Get the value of a given key.
+             * For example if the reply is "A=X B" then:
+             * Value("A") -> "X"
+             * Value("B") -> throws
+             * Value("C") -> throws
+             * @param[in] key Key whose value to retrieve
+             * @returns the key's value
+             * @throws std::runtime_error if the key is not present or if it has
+             * no value
+             */
+            std::string Get(const std::string &key) const;
+        };
+
+        /**
+         * Log a message in the `BCLog::I2P` category.
+         * @param[in] fmt printf(3)-like format string.
+         * @param[in] args printf(3)-like arguments that correspond to `fmt`.
+         */
+        template <typename... Args>
+        void Log(const std::string &fmt, const Args &... args) const;
+
+        /**
+         * Send request and get a reply from the SAM proxy.
+         * @param[in] sock A socket that is connected to the SAM proxy.
+         * @param[in] request Raw request to send, a newline terminator is
+         * appended to it.
+         * @param[in] check_result_ok If true then after receiving the reply a
+         * check is made whether it contains "RESULT=OK" and an exception is
+         * thrown if it does not.
+         * @throws std::runtime_error if an error occurs
+         */
+        Reply SendRequestAndGetReply(const Sock &sock,
+                                     const std::string &request,
+                                     bool check_result_ok = true) const;
+
+        /**
+         * Open a new connection to the SAM proxy.
+         * @return a connected socket
+         * @throws std::runtime_error if an error occurs
+         */
+        Sock Hello() const EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
+
+        /**
+         * Check the control socket for errors and possibly disconnect.
+         */
+        void CheckControlSock();
+
+        /**
+         * Generate a new destination with the SAM proxy and set `m_private_key`
+         * to it.
+         * @param[in] sock Socket to use for talking to the SAM proxy.
+         * @throws std::runtime_error if an error occurs
+         */
+        void DestGenerate(const Sock &sock) EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
+
+        /**
+         * Generate a new destination with the SAM proxy, set `m_private_key` to
+         * it and save it on disk to `m_private_key_file`.
+         * @param[in] sock Socket to use for talking to the SAM proxy.
+         * @throws std::runtime_error if an error occurs
+         */
+        void GenerateAndSavePrivateKey(const Sock &sock)
+            EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
+
+        /**
+         * Derive own destination from `m_private_key`.
+         * @see https://geti2p.net/spec/common-structures#destination
+         * @return an I2P destination
+         */
+        Binary MyDestination() const EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
+
+        /**
+         * Create the session if not already created. Reads the private key file
+         * and connects to the SAM proxy.
+         * @throws std::runtime_error if an error occurs
+         */
+        void CreateIfNotCreatedAlready() EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
+
+        /**
+         * Open a new connection to the SAM proxy and issue "STREAM ACCEPT"
+         * request using the existing session id. Return the idle socket that is
+         * waiting for a peer to connect to us.
+         * @throws std::runtime_error if an error occurs
+         */
+        Sock StreamAccept() EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
+
+        /**
+         * Destroy the session, closing the internally used sockets.
+         */
+        void Disconnect() EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
+
+        /**
+         * The name of the file where this peer's private key is stored (in
+         * binary).
+         */
+        const fs::path m_private_key_file;
+
+        /**
+         * The host and port of the SAM control service.
+         */
+        const CService m_control_host;
+
+        /**
+         * Cease network activity when this is signaled.
+         */
+        CThreadInterrupt *const m_interrupt;
+
+        /**
+         * Mutex protecting the members that can be concurrently accessed.
+         */
+        mutable Mutex m_mutex;
+
+        /**
+         * The private key of this peer.
+         * @see The reply to the "DEST GENERATE" command in
+         * https://geti2p.net/en/docs/api/samv3
+         */
+        Binary m_private_key GUARDED_BY(m_mutex);
+
+        /**
+         * SAM control socket.
+         * Used to connect to the I2P SAM service and create a session
+         * ("SESSION CREATE"). With the established session id we later open
+         * other connections to the SAM service to accept incoming I2P
+         * connections and make outgoing ones.
+         * See https://geti2p.net/en/docs/api/samv3
+         */
+        Sock m_control_sock GUARDED_BY(m_mutex);
+
+        /**
+         * Our .b32.i2p address.
+         * Derived from `m_private_key`.
+         */
+        CService m_my_addr GUARDED_BY(m_mutex);
+
+        /**
+         * SAM session id.
+         */
+        std::string m_session_id GUARDED_BY(m_mutex);
+    };
+
+} // namespace sam
+} // namespace i2p
+
+#endif // BITCOIN_I2P_H
diff --git a/src/logging.cpp b/src/logging.cpp
index 7a244002f..be5b66dc3 100644
--- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -1,346 +1,347 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <logging.h>
 
 #include <util/string.h>
 #include <util/threadnames.h>
 #include <util/time.h>
 
 bool fLogIPs = DEFAULT_LOGIPS;
 const char *const DEFAULT_DEBUGLOGFILE = "debug.log";
 
 BCLog::Logger &LogInstance() {
     /**
      * NOTE: the logger instance is leaked on exit. This is ugly, but will be
      * cleaned up by the OS/libc. Defining a logger as a global object doesn't
      * work since the order of destruction of static/global objects is
      * undefined. Consider if the logger gets destroyed, and then some later
      * destructor calls LogPrintf, maybe indirectly, and you get a core dump at
      * shutdown trying to access the logger. When the shutdown sequence is fully
      * audited and tested, explicit destruction of these objects can be
      * implemented by changing this from a raw pointer to a std::unique_ptr.
      * Since the ~Logger() destructor is never called, the Logger class and all
      * its subclasses must have implicitly-defined destructors.
      *
      * This method of initialization was originally introduced in
      * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
      */
     static BCLog::Logger *g_logger{new BCLog::Logger()};
     return *g_logger;
 }
 
 static int FileWriteStr(const std::string &str, FILE *fp) {
     return fwrite(str.data(), 1, str.size(), fp);
 }
 
 bool BCLog::Logger::StartLogging() {
     StdLockGuard scoped_lock(m_cs);
 
     assert(m_buffering);
     assert(m_fileout == nullptr);
 
     if (m_print_to_file) {
         assert(!m_file_path.empty());
         m_fileout = fsbridge::fopen(m_file_path, "a");
         if (!m_fileout) {
             return false;
         }
 
         // Unbuffered.
         setbuf(m_fileout, nullptr);
 
         // Add newlines to the logfile to distinguish this execution from the
         // last one.
         FileWriteStr("\n\n\n\n\n", m_fileout);
     }
 
     // Dump buffered messages from before we opened the log.
     m_buffering = false;
     while (!m_msgs_before_open.empty()) {
         const std::string &s = m_msgs_before_open.front();
 
         if (m_print_to_file) {
             FileWriteStr(s, m_fileout);
         }
         if (m_print_to_console) {
             fwrite(s.data(), 1, s.size(), stdout);
         }
         for (const auto &cb : m_print_callbacks) {
             cb(s);
         }
 
         m_msgs_before_open.pop_front();
     }
     if (m_print_to_console) {
         fflush(stdout);
     }
 
     return true;
 }
 
 void BCLog::Logger::DisconnectTestLogger() {
     StdLockGuard scoped_lock(m_cs);
     m_buffering = true;
     if (m_fileout != nullptr) {
         fclose(m_fileout);
     }
     m_fileout = nullptr;
     m_print_callbacks.clear();
 }
 
 struct CLogCategoryDesc {
     BCLog::LogFlags flag;
     std::string category;
 };
 
 const CLogCategoryDesc LogCategories[] = {
     {BCLog::NONE, "0"},
     {BCLog::NONE, "none"},
     {BCLog::NET, "net"},
     {BCLog::TOR, "tor"},
     {BCLog::MEMPOOL, "mempool"},
     {BCLog::HTTP, "http"},
     {BCLog::BENCH, "bench"},
     {BCLog::ZMQ, "zmq"},
     {BCLog::WALLETDB, "walletdb"},
     {BCLog::RPC, "rpc"},
     {BCLog::ESTIMATEFEE, "estimatefee"},
     {BCLog::ADDRMAN, "addrman"},
     {BCLog::SELECTCOINS, "selectcoins"},
     {BCLog::REINDEX, "reindex"},
     {BCLog::CMPCTBLOCK, "cmpctblock"},
     {BCLog::RAND, "rand"},
     {BCLog::PRUNE, "prune"},
     {BCLog::PROXY, "proxy"},
     {BCLog::MEMPOOLREJ, "mempoolrej"},
     {BCLog::LIBEVENT, "libevent"},
     {BCLog::COINDB, "coindb"},
     {BCLog::QT, "qt"},
     {BCLog::LEVELDB, "leveldb"},
     {BCLog::VALIDATION, "validation"},
     {BCLog::AVALANCHE, "avalanche"},
+    {BCLog::I2P, "i2p"},
     {BCLog::ALL, "1"},
     {BCLog::ALL, "all"},
 };
 
 bool GetLogCategory(BCLog::LogFlags &flag, const std::string &str) {
     if (str == "") {
         flag = BCLog::ALL;
         return true;
     }
     for (const CLogCategoryDesc &category_desc : LogCategories) {
         if (category_desc.category == str) {
             flag = category_desc.flag;
             return true;
         }
     }
     return false;
 }
 
 std::vector<LogCategory> BCLog::Logger::LogCategoriesList() {
     std::vector<LogCategory> ret;
     for (const CLogCategoryDesc &category_desc : LogCategories) {
         // Omit the special cases.
         if (category_desc.flag != BCLog::NONE &&
             category_desc.flag != BCLog::ALL) {
             LogCategory catActive;
             catActive.category = category_desc.category;
             catActive.active = WillLogCategory(category_desc.flag);
             ret.push_back(catActive);
         }
     }
     return ret;
 }
 
 BCLog::Logger::~Logger() {
     if (m_fileout) {
         fclose(m_fileout);
     }
 }
 
 std::string BCLog::Logger::LogTimestampStr(const std::string &str) {
     std::string strStamped;
 
     if (!m_log_timestamps) {
         return str;
     }
 
     if (m_started_new_line) {
         int64_t nTimeMicros = GetTimeMicros();
         strStamped = FormatISO8601DateTime(nTimeMicros / 1000000);
         if (m_log_time_micros) {
             strStamped.pop_back();
             strStamped += strprintf(".%06dZ", nTimeMicros % 1000000);
         }
         int64_t mocktime = GetMockTime();
         if (mocktime) {
             strStamped +=
                 " (mocktime: " + FormatISO8601DateTime(mocktime) + ")";
         }
         strStamped += ' ' + str;
     } else {
         strStamped = str;
     }
 
     return strStamped;
 }
 
 namespace BCLog {
 /** Belts and suspenders: make sure outgoing log messages don't contain
  * potentially suspicious characters, such as terminal control codes.
  *
  * This escapes control characters except newline ('\n') in C syntax.
  * It escapes instead of removes them to still allow for troubleshooting
  * issues where they accidentally end up in strings.
  */
 std::string LogEscapeMessage(const std::string &str) {
     std::string ret;
     for (char ch_in : str) {
         uint8_t ch = (uint8_t)ch_in;
         if ((ch >= 32 || ch == '\n') && ch != '\x7f') {
             ret += ch_in;
         } else {
             ret += strprintf("\\x%02x", ch);
         }
     }
     return ret;
 }
 } // namespace BCLog
 
 void BCLog::Logger::LogPrintStr(const std::string &str,
                                 const std::string &logging_function,
                                 const std::string &source_file,
                                 const int source_line) {
     StdLockGuard scoped_lock(m_cs);
     std::string str_prefixed = LogEscapeMessage(str);
 
     if (m_log_sourcelocations && m_started_new_line) {
         str_prefixed.insert(0, "[" + RemovePrefix(source_file, "./") + ":" +
                                    ToString(source_line) + "] [" +
                                    logging_function + "] ");
     }
 
     if (m_log_threadnames && m_started_new_line) {
         str_prefixed.insert(0, "[" + util::ThreadGetInternalName() + "] ");
     }
 
     str_prefixed = LogTimestampStr(str_prefixed);
 
     m_started_new_line = !str.empty() && str[str.size() - 1] == '\n';
 
     if (m_buffering) {
         // buffer if we haven't started logging yet
         m_msgs_before_open.push_back(str_prefixed);
         return;
     }
 
     if (m_print_to_console) {
         // Print to console.
         fwrite(str_prefixed.data(), 1, str_prefixed.size(), stdout);
         fflush(stdout);
     }
     for (const auto &cb : m_print_callbacks) {
         cb(str_prefixed);
     }
     if (m_print_to_file) {
         assert(m_fileout != nullptr);
 
         // Reopen the log file, if requested.
         if (m_reopen_file) {
             m_reopen_file = false;
             FILE *new_fileout = fsbridge::fopen(m_file_path, "a");
             if (new_fileout) {
                 // unbuffered.
                 setbuf(m_fileout, nullptr);
                 fclose(m_fileout);
                 m_fileout = new_fileout;
             }
         }
         FileWriteStr(str_prefixed, m_fileout);
     }
 }
 
 void BCLog::Logger::ShrinkDebugFile() {
     // Amount of debug.log to save at end when shrinking (must fit in memory)
     constexpr size_t RECENT_DEBUG_HISTORY_SIZE = 10 * 1000000;
 
     assert(!m_file_path.empty());
 
     // Scroll debug.log if it's getting too big.
     FILE *file = fsbridge::fopen(m_file_path, "r");
 
     // Special files (e.g. device nodes) may not have a size.
     size_t log_size = 0;
     try {
         log_size = fs::file_size(m_file_path);
     } catch (const fs::filesystem_error &) {
     }
 
     // If debug.log file is more than 10% bigger the RECENT_DEBUG_HISTORY_SIZE
     // trim it down by saving only the last RECENT_DEBUG_HISTORY_SIZE bytes.
     if (file && log_size > 11 * (RECENT_DEBUG_HISTORY_SIZE / 10)) {
         // Restart the file with some of the end.
         std::vector<char> vch(RECENT_DEBUG_HISTORY_SIZE, 0);
         if (fseek(file, -((long)vch.size()), SEEK_END)) {
             LogPrintf("Failed to shrink debug log file: fseek(...) failed\n");
             fclose(file);
             return;
         }
         int nBytes = fread(vch.data(), 1, vch.size(), file);
         fclose(file);
 
         file = fsbridge::fopen(m_file_path, "w");
         if (file) {
             fwrite(vch.data(), 1, nBytes, file);
             fclose(file);
         }
     } else if (file != nullptr) {
         fclose(file);
     }
 }
 
 void BCLog::Logger::EnableCategory(LogFlags category) {
     m_categories |= category;
 }
 
 bool BCLog::Logger::EnableCategory(const std::string &str) {
     BCLog::LogFlags flag;
     if (!GetLogCategory(flag, str)) {
         return false;
     }
     EnableCategory(flag);
     return true;
 }
 
 void BCLog::Logger::DisableCategory(LogFlags category) {
     m_categories &= ~category;
 }
 
 bool BCLog::Logger::DisableCategory(const std::string &str) {
     BCLog::LogFlags flag;
     if (!GetLogCategory(flag, str)) {
         return false;
     }
     DisableCategory(flag);
     return true;
 }
 
 bool BCLog::Logger::WillLogCategory(LogFlags category) const {
     // ALL is not meant to be used as a logging category, but only as a mask
     // representing all categories.
     if (category == BCLog::NONE || category == BCLog::ALL) {
         LogPrintf("Error trying to log using a category mask instead of an "
                   "explicit category.\n");
         return true;
     }
 
     return (m_categories.load(std::memory_order_relaxed) & category) != 0;
 }
 
 bool BCLog::Logger::DefaultShrinkDebugFile() const {
     return m_categories != BCLog::NONE;
 }
diff --git a/src/logging.h b/src/logging.h
index 2f1408f3f..5d5f56107 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -1,217 +1,218 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_LOGGING_H
 #define BITCOIN_LOGGING_H
 
 #include <fs.h>
 #include <threadsafety.h>
 #include <tinyformat.h>
 #include <util/string.h>
 
 #include <atomic>
 #include <cstdint>
 #include <list>
 #include <mutex>
 #include <string>
 
 static const bool DEFAULT_LOGTIMEMICROS = false;
 static const bool DEFAULT_LOGIPS = false;
 static const bool DEFAULT_LOGTIMESTAMPS = true;
 static const bool DEFAULT_LOGTHREADNAMES = false;
 static const bool DEFAULT_LOGSOURCELOCATIONS = false;
 
 extern bool fLogIPs;
 extern const char *const DEFAULT_DEBUGLOGFILE;
 
 struct LogCategory {
     std::string category;
     bool active;
 };
 
 namespace BCLog {
 
 enum LogFlags : uint32_t {
     NONE = 0,
     NET = (1 << 0),
     TOR = (1 << 1),
     MEMPOOL = (1 << 2),
     HTTP = (1 << 3),
     BENCH = (1 << 4),
     ZMQ = (1 << 5),
     WALLETDB = (1 << 6),
     RPC = (1 << 7),
     ESTIMATEFEE = (1 << 8),
     ADDRMAN = (1 << 9),
     SELECTCOINS = (1 << 10),
     REINDEX = (1 << 11),
     CMPCTBLOCK = (1 << 12),
     RAND = (1 << 13),
     PRUNE = (1 << 14),
     PROXY = (1 << 15),
     MEMPOOLREJ = (1 << 16),
     LIBEVENT = (1 << 17),
     COINDB = (1 << 18),
     QT = (1 << 19),
     LEVELDB = (1 << 20),
     VALIDATION = (1 << 21),
     AVALANCHE = (1 << 22),
+    I2P = (1 << 23),
     ALL = ~uint32_t(0),
 };
 
 class Logger {
 private:
     // Can not use Mutex from sync.h because in debug mode it would cause a
     // deadlock when a potential deadlock was detected
     mutable StdMutex m_cs;
 
     FILE *m_fileout GUARDED_BY(m_cs) = nullptr;
     std::list<std::string> m_msgs_before_open GUARDED_BY(m_cs);
     //! Buffer messages before logging can be started.
     bool m_buffering GUARDED_BY(m_cs) = true;
 
     /**
      * m_started_new_line is a state variable that will suppress printing of the
      * timestamp when multiple calls are made that don't end in a newline.
      */
     std::atomic_bool m_started_new_line{true};
 
     /**
      * Log categories bitfield.
      */
     std::atomic<uint32_t> m_categories{0};
 
     std::string LogTimestampStr(const std::string &str);
 
     /** Slots that connect to the print signal */
     std::list<std::function<void(const std::string &)>>
         m_print_callbacks GUARDED_BY(m_cs){};
 
 public:
     bool m_print_to_console = false;
     bool m_print_to_file = false;
 
     bool m_log_timestamps = DEFAULT_LOGTIMESTAMPS;
     bool m_log_time_micros = DEFAULT_LOGTIMEMICROS;
     bool m_log_threadnames = DEFAULT_LOGTHREADNAMES;
     bool m_log_sourcelocations = DEFAULT_LOGSOURCELOCATIONS;
 
     fs::path m_file_path;
     std::atomic<bool> m_reopen_file{false};
 
     ~Logger();
 
     /** Send a string to the log output */
     void LogPrintStr(const std::string &str,
                      const std::string &logging_function,
                      const std::string &source_file, const int source_line);
 
     /** Returns whether logs will be written to any output */
     bool Enabled() const {
         StdLockGuard scoped_lock(m_cs);
         return m_buffering || m_print_to_console || m_print_to_file ||
                !m_print_callbacks.empty();
     }
 
     /** Connect a slot to the print signal and return the connection */
     std::list<std::function<void(const std::string &)>>::iterator
     PushBackCallback(std::function<void(const std::string &)> fun) {
         StdLockGuard scoped_lock(m_cs);
         m_print_callbacks.push_back(std::move(fun));
         return --m_print_callbacks.end();
     }
 
     /** Delete a connection */
     void DeleteCallback(
         std::list<std::function<void(const std::string &)>>::iterator it) {
         StdLockGuard scoped_lock(m_cs);
         m_print_callbacks.erase(it);
     }
 
     /** Start logging (and flush all buffered messages) */
     bool StartLogging();
     /** Only for testing */
     void DisconnectTestLogger();
 
     void ShrinkDebugFile();
 
     uint32_t GetCategoryMask() const { return m_categories.load(); }
 
     void EnableCategory(LogFlags category);
     bool EnableCategory(const std::string &str);
     void DisableCategory(LogFlags category);
     bool DisableCategory(const std::string &str);
 
     /** Return true if log accepts specified category */
     bool WillLogCategory(LogFlags category) const;
 
     /** Returns a vector of the log categories */
     std::vector<LogCategory> LogCategoriesList();
     /** Returns a string with the log categories */
     std::string LogCategoriesString() {
         return Join(LogCategoriesList(), ", ",
                     [&](const LogCategory &i) { return i.category; });
     };
 
     /** Default for whether ShrinkDebugFile should be run */
     bool DefaultShrinkDebugFile() const;
 };
 
 } // namespace BCLog
 
 BCLog::Logger &LogInstance();
 
 /** Return true if log accepts specified category */
 static inline bool LogAcceptCategory(BCLog::LogFlags category) {
     return LogInstance().WillLogCategory(category);
 }
 
 /** Return true if str parses as a log category and set the flag */
 bool GetLogCategory(BCLog::LogFlags &flag, const std::string &str);
 
 // Be conservative when using LogPrintf/error or other things which
 // unconditionally log to debug.log! It should not be the case that an inbound
 // peer can fill up a user's disk with debug.log entries.
 template <typename... Args>
 static inline void
 LogPrintf_(const std::string &logging_function, const std::string &source_file,
            const int source_line, const char *fmt, const Args &... args) {
     if (LogInstance().Enabled()) {
         std::string log_msg;
         try {
             log_msg = tfm::format(fmt, args...);
         } catch (tinyformat::format_error &fmterr) {
             /**
              * Original format string will have newline so don't add one here
              */
             log_msg = "Error \"" + std::string(fmterr.what()) +
                       "\" while formatting log message: " + fmt;
         }
         LogInstance().LogPrintStr(log_msg, logging_function, source_file,
                                   source_line);
     }
 }
 
 #define LogPrintf(...) LogPrintf_(__func__, __FILE__, __LINE__, __VA_ARGS__)
 
 // Use a macro instead of a function for conditional logging to prevent
 // evaluating arguments when logging for the category is not enabled.
 #define LogPrint(category, ...)                                                \
     do {                                                                       \
         if (LogAcceptCategory((category))) {                                   \
             LogPrintf(__VA_ARGS__);                                            \
         }                                                                      \
     } while (0)
 
 /**
  * These are aliases used to explicitly state that the message should not end
  * with a newline character. It allows for detecting the missing newlines that
  * could make the logs hard to read.
  */
 #define LogPrintfToBeContinued LogPrintf
 #define LogPrintToBeContinued LogPrint
 
 #endif // BITCOIN_LOGGING_H