diff --git a/cmake/modules/FindQREncode.cmake b/cmake/modules/FindQREncode.cmake
new file mode 100644
index 0000000000..fd972df16a
--- /dev/null
+++ b/cmake/modules/FindQREncode.cmake
@@ -0,0 +1,27 @@
+# Try to find libqrencode
+# QRENCODE_FOUND - system has libqrencode
+# QRENCODE_INCLUDE_DIR - the libqrencode include directory
+# QRENCODE_LIBRARY - Library needed to use libqrencode
+
+if (QRENCODE_INCLUDE_DIR AND QRENCODE_LIBRARY)
+	# Already in cache, be silent
+	set(QRENCODE_FIND_QUIETLY TRUE)
+endif()
+
+find_path(QRENCODE_INCLUDE_DIR qrencode.h)
+
+find_library(QRENCODE_LIBRARY NAMES qrencode libqrencode)
+
+message(STATUS "QREncode lib: " ${QRENCODE_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+	QREncode DEFAULT_MSG
+	QRENCODE_INCLUDE_DIR
+	QRENCODE_LIBRARY
+)
+
+mark_as_advanced(QRENCODE_INCLUDE_DIR QRENCODE_LIBRARY)
+
+set(QREncode_LIBRARIES ${QRENCODE_LIBRARY})
+set(QREncode_INCLUDE_DIRS ${QRENCODE_INCLUDE_DIR})
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 27b4544027..1debc14f2f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,436 +1,437 @@
 # Copyright (c) 2017 The Bitcoin developers
 
 cmake_minimum_required(VERSION 3.5)
 project(BitcoinABC)
 
 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(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)
 
 # 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/index.html)"
 		)
 	endif()
 endif()
 
 # Cmake uses the CMAKE_BUILD_TYPE variable to select the build configuration.
 # By default it supports more configurations that needed for Bitcoin ABC, and
 # all the releases types set NDEBUG which is unwanted as it disables the assert
 # completely.
 # Remove the -DNDEBUG flag from the CFLAGS/CXXFLAGS in all the configurations
 include(AddCompilerFlags)
 remove_compiler_flags(-DNDEBUG)
 
 # Overrides the flags for the Debug build type
 # This mimics the autotools behavior by setting the CFLAGS to '-g -O2`, which
 # are not well suited for debugging.
 # FIXME: update CFLAGS with better debug oriented optimization flags
 set(CMAKE_C_FLAGS_DEBUG "-g -O2")
 
 # Prefer -g3, defaults to -g if unavailable
 add_cxx_compiler_flag_with_fallback(CMAKE_CXX_FLAGS_DEBUG -g3 -g)
 
 # Prefer -Og, defaults to -O0 if unavailable
 add_cxx_compiler_flag_with_fallback(CMAKE_CXX_FLAGS_DEBUG -Og -O0)
 
 # Define the debugging symbols DEBUG and DEBUG_LOCKORDER when the Debug build
 # type is selected.
 string(APPEND CMAKE_CXX_FLAGS_DEBUG " -DDEBUG -DDEBUG_LOCKORDER")
 
 # 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_compiler_flag(-static)
 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_flag(-Wl,--exclude-libs,ALL)
 endif()
 
 # Enable statically linking libstdc++
 if(ENABLE_STATIC_LIBSTDCXX)
 	add_linker_flag(-static-libstdc++)
 endif()
 
 # All windows code is PIC, forcing it on just adds useless compile warnings
 if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	add_compiler_flag(-fPIC)
 endif()
 	
 if(ENABLE_HARDENING)
 	# Enable stack protection
 	add_cxx_compiler_flag(-fstack-protector-all -Wstack-protector)
 	
 	# Enable some buffer overflow checking
 	add_compiler_flag(-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2)
 	
 	# Enable ASLR (these flags are primarily targeting MinGw)
 	add_linker_flag(-Wl,--dynamicbase -Wl,--nxcompat -Wl,--high-entropy-va)
 	
 	# Make the relocated sections read-only
 	add_linker_flag(-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: use the POSITION_INDEPENDENT_CODE property instead
 	if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 		add_compiler_flag(-fPIE)
 		add_linker_flag(-pie)
 	else()
 		# MinGw provides its own libssp for stack smashing protection
 		link_libraries(ssp)
 	endif()
 endif()
 
 # Enable warning
 add_c_compiler_flag(-Wnested-externs -Wstrict-prototypes)
 add_compiler_flag(
 	-Wall
 	-Wextra
 	-Wformat
 	-Wvla
 	-Wformat-security
 	-Wcast-align
 	-Wunused-parameter
 	-Wmissing-braces
 	# FIXME: Activating this flag cause cmake to fail on leveldb.
 	# -Wthread-safety-analysis
 	-Wshadow
 )
 
 option(EXTRA_WARNINGS "Enable extra warnings" OFF)
 if(EXTRA_WARNINGS)
 	add_cxx_compiler_flag(-Wsuggest-override)
 else()
 	add_compiler_flag(-Wno-unused-parameter)
 	add_compiler_flag(-Wno-implicit-fallthrough)
 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)
 
 # Because the Bitcoin ABc source code is disorganised, we
 # end up with a bunch of libraries without any aparent
 # 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.cpp
 	utilmoneystr.cpp
 	utilstrencodings.cpp
 	utiltime.cpp
 	util/bytevectorhash.cpp
 )
 
 target_compile_definitions(util PUBLIC HAVE_CONFIG_H)
 target_include_directories(util
 	PUBLIC
 		.
 		# To access the config.
 		${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})
 
 	#__fdelt_chk's params and return type have changed from long unsigned int to
 	# long int. See which one is present here.
 	include(CheckPrototypeDefinition)
 
 	set(CMAKE_REQUIRED_DEFINITIONS -D_FORTIFY_SOURCE=2)
 	# Without some optimization the compiler won't detect the prototype conflict
 	# and always succeed to build.
 	set(CMAKE_REQUIRED_FLAGS -O2)
 
 	check_prototype_definition(
 		__fdelt_warn
 		"extern long unsigned int __fdelt_warn(long unsigned int a)"
 		"0"
 		"sys/select.h"
 		FDELT_PROTOTYPE_LONG_UNSIGNED_INT
 	)
 
 	if(FDELT_PROTOTYPE_LONG_UNSIGNED_INT)
 		set(FDELT_TYPE "long unsigned int")
 	else()
 		set(FDELT_TYPE "long int")
 	endif()
 
 	target_compile_definitions(util PRIVATE "-DFDELT_TYPE=${FDELT_TYPE}")
 
 	# Wrap some glibc functions with ours
 	add_linker_flag(-Wl,--wrap=__divmoddi4)
 	add_linker_flag(-Wl,--wrap=log2f)
 
 	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_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 program_options 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
 	dstencode.cpp
 	feerate.cpp
 	globals.cpp
 	core_read.cpp
 	core_write.cpp
 	key.cpp
 	keystore.cpp
 	netaddress.cpp
 	netbase.cpp
 	primitives/block.cpp
 	protocol.cpp
 	scheduler.cpp
 	script/sign.cpp
 	script/standard.cpp
 	warnings.cpp
 )
 
 target_link_libraries(common util secp256k1)
 
 # libbitcoinconsensus
 add_library(bitcoinconsensus
 	arith_uint256.cpp
 	hash.cpp
 	primitives/transaction.cpp
 	pubkey.cpp
 	script/bitcoinconsensus.cpp
 	script/interpreter.cpp
 	script/script.cpp
 	script/script_error.cpp
 	script/sigencoding.cpp
 	uint256.cpp
 	utilstrencodings.cpp
 )
 
 target_link_libraries(bitcoinconsensus common)
 
 # Bitcoin server facilities
 add_library(server
 	addrman.cpp
 	addrdb.cpp
 	avalanche.cpp
 	bloom.cpp
 	blockencodings.cpp
 	blockfilter.cpp
 	chain.cpp
 	checkpoints.cpp
 	config.cpp
 	consensus/activation.cpp
 	consensus/tx_verify.cpp
 	globals.cpp
 	httprpc.cpp
 	httpserver.cpp
 	init.cpp
 	interfaces/handler.cpp
 	interfaces/node.cpp
 	dbwrapper.cpp
 	merkleblock.cpp
 	miner.cpp
 	net.cpp
 	net_processing.cpp
 	noui.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
 	script/ismine.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
 )
 
 # 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()
 
 # 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)
 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)
 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()
 
 # Bitcoin-qt
 if(BUILD_BITCOIN_QT)
 	add_subdirectory(qt)
 endif()
diff --git a/src/config/CMakeLists.txt b/src/config/CMakeLists.txt
index 52c3e48b56..7f7b66e030 100644
--- a/src/config/CMakeLists.txt
+++ b/src/config/CMakeLists.txt
@@ -1,161 +1,168 @@
 # Copyright (c) 2017-2019 The Bitcoin developers
 
 # This generates config.h which provides numerous defines
 # about the state of the plateform we are building on.
 
 include(CheckIncludeFiles)
 include(CheckSymbolExists)
 include(CheckCXXSourceCompiles)
 
 # Package informations
 set(PACKAGE_NAME "Bitcoin ABC")
 
 # Version
 set(CLIENT_VERSION_MAJOR 0)
 set(CLIENT_VERSION_MINOR 19)
 set(CLIENT_VERSION_REVISION 7)
 set(CLIENT_VERSION_BUILD 0)
 
 option(CLIENT_VERSION_IS_RELEASE "Build a release version" OFF)
 
 # 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})
 
 # Generate the version.h file
 configure_file(version.h.cmake.in version.h ESCAPE_QUOTES)
 
 # Endianness
 check_include_files("endian.h" HAVE_ENDIAN_H)
 check_include_files("sys/endian.h" HAVE_SYS_ENDIAN_H)
 
 if(HAVE_ENDIAN_H)
 	set(ENDIAN_FILE "endian.h")
 elseif(HAVE_SYS_ENDIAN_H)
 	set(ENDIAN_FILE "sys/endian.h")
 else()
 endif()
 
 if(ENDIAN_FILE)
 	check_symbol_exists(htole16 ${ENDIAN_FILE} HAVE_DECL_HTOLE16)
 	check_symbol_exists(htobe16 ${ENDIAN_FILE} HAVE_DECL_HTOBE16)
 	check_symbol_exists(be16toh ${ENDIAN_FILE} HAVE_DECL_BE16TOH)
 	check_symbol_exists(le16toh ${ENDIAN_FILE} HAVE_DECL_LE16TOH)
 	check_symbol_exists(htobe32 ${ENDIAN_FILE} HAVE_DECL_HTOBE32)
 	check_symbol_exists(htole32 ${ENDIAN_FILE} HAVE_DECL_HTOLE32)
 	check_symbol_exists(be32toh ${ENDIAN_FILE} HAVE_DECL_BE32TOH)
 	check_symbol_exists(le32toh ${ENDIAN_FILE} HAVE_DECL_LE32TOH)
 	check_symbol_exists(htobe64 ${ENDIAN_FILE} HAVE_DECL_HTOBE64)
 	check_symbol_exists(htole64 ${ENDIAN_FILE} HAVE_DECL_HTOLE64)
 	check_symbol_exists(be64toh ${ENDIAN_FILE} HAVE_DECL_BE64TOH)
 	check_symbol_exists(le64toh ${ENDIAN_FILE} HAVE_DECL_LE64TOH)
 endif()
 
 # Byte swap
 check_include_files("byteswap.h" HAVE_BYTESWAP_H)
 
 check_symbol_exists(bswap_16 "byteswap.h" HAVE_DECL_BSWAP_16)
 check_symbol_exists(bswap_32 "byteswap.h" HAVE_DECL_BSWAP_32)
 check_symbol_exists(bswap_64 "byteswap.h" HAVE_DECL_BSWAP_64)
 
 # sys/select.h and sys/prctl.h headers
 check_include_files("sys/select.h" HAVE_SYS_SELECT_H)
 check_include_files("sys/prctl.h" HAVE_SYS_PRCTL_H)
 
 # Bitmanip intrinsics
 function(check_builtin_exist SYMBOL VARIABLE)
 	set(
 		SOURCE_FILE
 		"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckBuiltinExists.c"
 	)
 	set(
 		CMAKE_CONFIGURABLE_FILE_CONTENT
 		"int main(int argc, char** argv) { (void)argv; return ${SYMBOL}(argc); }\n"
 	)
 	configure_file(
 		"${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in"
 		"${SOURCE_FILE}"
 		@ONLY
 	)
 	if(NOT CMAKE_REQUIRED_QUIET)
 		message(STATUS "Looking for ${SYMBOL}")
 	endif()
 	try_compile(${VARIABLE}
 		${CMAKE_BINARY_DIR}
 		${SOURCE_FILE}
 		OUTPUT_VARIABLE OUTPUT
 	)
 	if(${VARIABLE})
 		if(NOT CMAKE_REQUIRED_QUIET)
 			message(STATUS "Looking for ${SYMBOL} - found")
 		endif()
 		set(${VARIABLE} 1 CACHE INTERNAL "Have symbol ${SYMBOL}" PARENT_SCOPE)
 		file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 			"Determining if the ${SYMBOL} "
 			"exist passed with the following output:\n"
 			"${OUTPUT}\nFile ${SOURCEFILE}:\n"
 			"${CMAKE_CONFIGURABLE_FILE_CONTENT}\n")
 	else()
 		if(NOT CMAKE_REQUIRED_QUIET)
 			message(STATUS "Looking for ${SYMBOL} - not found")
 		endif()
 		set(${VARIABLE} "" CACHE INTERNAL "Have symbol ${SYMBOL}" PARENT_SCOPE)
 		file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
 			"Determining if the ${SYMBOL} "
 			"exist failed with the following output:\n"
 			"${OUTPUT}\nFile ${SOURCEFILE}:\n"
 			"${CMAKE_CONFIGURABLE_FILE_CONTENT}\n")
 	endif()
 endfunction()
 
 check_builtin_exist(__builtin_clz HAVE_DECL___BUILTIN_CLZ)
 check_builtin_exist(__builtin_clzl HAVE_DECL___BUILTIN_CLZL)
 check_builtin_exist(__builtin_clzll HAVE_DECL___BUILTIN_CLZLL)
 check_builtin_exist(__builtin_popcount HAVE_DECL___BUILTIN_POPCOUNT)
 
 # Memory management capabilities
 check_symbol_exists(M_ARENA_MAX "malloc.h" HAVE_MALLOPT_ARENA_MAX)
 check_symbol_exists(malloc_info "malloc.h" HAVE_MALLOC_INFO)
 
 # Various system libraries
 check_symbol_exists(strnlen "string.h" HAVE_DECL_STRNLEN)
 check_symbol_exists(daemon "unistd.h" HAVE_DECL_DAEMON)
 
 # Check for ways to obtain entropy
 check_symbol_exists(getentropy "unistd.h" HAVE_GETENTROPY)
 check_symbol_exists(getentropy "sys/random.h" HAVE_GETENTROPY_RAND)
 
 check_cxx_source_compiles("
 	#include <unistd.h>  /* for syscall */
 	#include <sys/syscall.h>  /* for SYS_getrandom */
 	int main() {
 		syscall(SYS_getrandom, nullptr, 0, 0);
 		return 0;
 	}
 " HAVE_SYS_GETRANDOM)
 
 check_cxx_source_compiles("
 	#include <sys/types.h>
 	#include <sys/sysctl.h>
 	int main() {
 		static const int name[2] = {CTL_KERN, KERN_ARND};
 		sysctl(name, 2, nullptr, nullptr, nullptr, 0);
 		return 0;
 	}
 " HAVE_SYSCTL_ARND)
 
 # OpenSSL functionality
 set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_CRYPTO_INCLUDES})
 set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY})
 check_symbol_exists(EVP_MD_CTX_new "openssl/evp.h" HAVE_DECL_EVP_MD_CTX_NEW)
 
 # Activate wallet
 set(ENABLE_WALLET ${BUILD_BITCOIN_WALLET})
 
 # Activate ZeroMQ
 set(ENABLE_ZMQ ${BUILD_BITCOIN_ZMQ})
 
+# Try to find libqrencode
+# Only used in the wallet GUI
+if(ENABLE_QRCODE AND BUILD_BITCOIN_WALLET AND BUILD_BITCOIN_QT)
+	find_package(QREncode REQUIRED)
+	set(USE_QRCODE 1 CACHE INTERNAL "QR code is enabled")
+endif()
+
 # Generate the config
 configure_file(bitcoin-config.h.cmake.in bitcoin-config.h ESCAPE_QUOTES)
diff --git a/src/config/bitcoin-config.h.cmake.in b/src/config/bitcoin-config.h.cmake.in
index 2e91df501a..2f07f5782a 100644
--- a/src/config/bitcoin-config.h.cmake.in
+++ b/src/config/bitcoin-config.h.cmake.in
@@ -1,58 +1,61 @@
 // Copyright (c) 2017 The Bitcoin developers
 
 #ifndef BITCOIN_CONFIG_BITCOIN_CONFIG_H
 #define BITCOIN_CONFIG_BITCOIN_CONFIG_H
 
 #define PACKAGE_NAME "${PACKAGE_NAME}"
 
 #define COPYRIGHT_YEAR "${COPYRIGHT_YEAR}"
 #define COPYRIGHT_HOLDERS "${COPYRIGHT_HOLDERS}"
 #define COPYRIGHT_HOLDERS_SUBSTITUTION "${COPYRIGHT_HOLDERS_SUBSTITUTION}"
 #define COPYRIGHT_HOLDERS_FINAL "${COPYRIGHT_HOLDERS_FINAL}"
 
 #cmakedefine HAVE_ENDIAN_H 1
 #cmakedefine HAVE_SYS_ENDIAN_H 1
 
 #cmakedefine HAVE_DECL_HTOLE16 1
 #cmakedefine HAVE_DECL_HTOBE16 1
 #cmakedefine HAVE_DECL_BE16TOH 1
 #cmakedefine HAVE_DECL_LE16TOH 1
 #cmakedefine HAVE_DECL_HTOBE32 1
 #cmakedefine HAVE_DECL_HTOLE32 1
 #cmakedefine HAVE_DECL_BE32TOH 1
 #cmakedefine HAVE_DECL_LE32TOH 1
 #cmakedefine HAVE_DECL_HTOBE64 1
 #cmakedefine HAVE_DECL_HTOLE64 1
 #cmakedefine HAVE_DECL_BE64TOH 1
 #cmakedefine HAVE_DECL_LE64TOH 1
 
 #cmakedefine HAVE_BYTESWAP_H 1
 
 #cmakedefine HAVE_DECL_BSWAP_16 1
 #cmakedefine HAVE_DECL_BSWAP_32 1
 #cmakedefine HAVE_DECL_BSWAP_64 1
 
 #cmakedefine HAVE_SYS_SELECT_H 1
 #cmakedefine HAVE_SYS_PRCTL_H 1
 
 #cmakedefine HAVE_DECL___BUILTIN_CLZ 1
 #cmakedefine HAVE_DECL___BUILTIN_CLZL 1
 #cmakedefine HAVE_DECL___BUILTIN_CLZLL 1
 #cmakedefine HAVE_DECL___BUILTIN_POPCOUNT 1
 
 #cmakedefine HAVE_MALLOPT_ARENA_MAX 1
 #cmakedefine HAVE_MALLOC_INFO 1
 
 #cmakedefine HAVE_DECL_STRNLEN 1
 #cmakedefine HAVE_DECL_DAEMON 1
 #cmakedefine HAVE_GETENTROPY 1
 #cmakedefine HAVE_GETENTROPY_RAND 1
 #cmakedefine HAVE_SYS_GETRANDOM 1
 #cmakedefine HAVE_SYSCTL_ARND 1
 
 #cmakedefine HAVE_DECL_EVP_MD_CTX_NEW 1
 
 #cmakedefine ENABLE_WALLET 1
 #cmakedefine ENABLE_ZMQ 1
 
+/* Define if QR support should be compiled in */
+#cmakedefine USE_QRCODE 1
+
 #endif // BITCOIN_BITCOIN_CONFIG_H
diff --git a/src/qt/CMakeLists.txt b/src/qt/CMakeLists.txt
index 1d90f6f497..6446db200e 100644
--- a/src/qt/CMakeLists.txt
+++ b/src/qt/CMakeLists.txt
@@ -1,235 +1,240 @@
 # Copyright (c) 2018 The Bitcoin developers
 
 project(bitcoin-qt)
 
 # This ensure that AUTOMOC doesn't run on generated files.
 cmake_policy(SET CMP0071 OLD)
 
 include(BrewHelper)
 find_brew_prefix(QT5_PREFIX qt5)
 
 set(QT_REQUIRED_COMPONENTS Core Widgets Network Test)
 find_package(Qt5 COMPONENTS ${QT_REQUIRED_COMPONENTS} REQUIRED HINTS "${QT5_PREFIX}")
 
 # Find out more about Qt. This is similar to
 # http://code.qt.io/cgit/qt/qtwebkit.git/tree/Source/cmake/OptionsQt.cmake
 get_target_property(QT_CORE_TYPE Qt5::Core TYPE)
 if(QT_CORE_TYPE MATCHES STATIC)
 	set(QT_STATIC_BUILD ON)
 endif()
 
 # Determine the Qt libraries directory from the QT5::Core library location
 get_target_property(QT_CORE_LIB_LOCATION Qt5::Core LOCATION)
 get_filename_component(QT5_LIB_DIR "${QT_CORE_LIB_LOCATION}" DIRECTORY)
 
 set(STATIC_DEPENDENCIES_CMAKE_FILE "${CMAKE_BINARY_DIR}/QtStaticDependencies.cmake")
 if(EXISTS ${STATIC_DEPENDENCIES_CMAKE_FILE})
 	file(REMOVE ${STATIC_DEPENDENCIES_CMAKE_FILE})
 endif()
 
 set(CONVERT_PRL_PATH "${CONTRIB_PATH}/qt/convert-prl-libs-to-cmake.pl")
 macro(CONVERT_PRL_LIBS_TO_CMAKE _qt_component)
 	if(TARGET Qt5::${_qt_component})
 		get_target_property(_lib_location Qt5::${_qt_component} LOCATION)
 		execute_process(COMMAND ${PERL_EXECUTABLE} "${CONVERT_PRL_PATH}"
 			--lib "${_lib_location}"
 			--qt_lib_install_dir "${QT5_LIB_DIR}"
 			--out "${STATIC_DEPENDENCIES_CMAKE_FILE}"
 			--component "${_qt_component}"
 			--compiler "${CMAKE_CXX_COMPILER_ID}"
 		)
 	endif()
 endmacro()
 
 if(QT_STATIC_BUILD)
 	foreach(qt_module ${QT_REQUIRED_COMPONENTS})
 		CONVERT_PRL_LIBS_TO_CMAKE(${qt_module})
 	endforeach()
 	# HACK: We must explicitly add LIB path of the Qt installation
 	# to correctly find qtpcre
 	link_directories("${QT5_LIB_DIR}")
 
 	# Now that we generated the dependencies, import them.
 	set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${CONVERT_PRL_PATH}")
 	if(NOT EXISTS ${STATIC_DEPENDENCIES_CMAKE_FILE})
 		message(FATAL_ERROR "Unable to find ${STATIC_DEPENDENCIES_CMAKE_FILE}")
 	endif()
 	include(${STATIC_DEPENDENCIES_CMAKE_FILE})
 	list(REMOVE_DUPLICATES STATIC_LIB_DEPENDENCIES)
 endif()
 
 # Localisation
 add_subdirectory(locale)
 
 add_custom_command(OUTPUT temp_bitcoin_locale.qrc
 	COMMAND cmake
 	ARGS
 		-E copy
 		"${CMAKE_CURRENT_SOURCE_DIR}/bitcoin_locale.qrc"
 		temp_bitcoin_locale.qrc
 	MAIN_DEPENDENCY bitcoin_locale.qrc
 	VERBATIM
 )
 
 add_custom_command(OUTPUT qrc_bitcoin_locale.cpp
 	COMMAND Qt5::rcc
 	ARGS
 		temp_bitcoin_locale.qrc
 		-name bitcoin_locale
 		-o qrc_bitcoin_locale.cpp
 	MAIN_DEPENDENCY temp_bitcoin_locale.qrc
 	DEPENDS locales
 	VERBATIM
 )
 
 # UI elements
 # qt5_wrap_ui() generates the files in the CMAKE_CURRENT_BINARY_DIR. As there
 # is no option to change the output directory, moving the files to the forms
 # subdirectory requires to override the variable. It is reset to its actual
 # value after the call so it does not impact the other sections of this
 # CMakeLists.txt file.
 set(SAVE_CMAKE_CURRENT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 set(CMAKE_CURRENT_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/forms")
 qt5_wrap_ui(UI_GENERATED_HEADERS
 	forms/addressbookpage.ui
 	forms/askpassphrasedialog.ui
 	forms/coincontroldialog.ui
 	forms/editaddressdialog.ui
 	forms/helpmessagedialog.ui
 	forms/intro.ui
 	forms/modaloverlay.ui
 	forms/openuridialog.ui
 	forms/optionsdialog.ui
 	forms/overviewpage.ui
 	forms/receivecoinsdialog.ui
 	forms/receiverequestdialog.ui
 	forms/debugwindow.ui
 	forms/sendcoinsdialog.ui
 	forms/sendcoinsentry.ui
 	forms/signverifymessagedialog.ui
 	forms/transactiondescdialog.ui
 )
 set(CMAKE_CURRENT_BINARY_DIR ${SAVE_CMAKE_CURRENT_BINARY_DIR})
 
 # Qt MOC
 set(CMAKE_AUTOMOC ON)
 
 # Handle qrc resources
 qt5_add_resources(QRC_BITCOIN_CPP bitcoin.qrc)
 
 # Do protobuf codegen
 find_package(Protobuf REQUIRED)
 protobuf_generate_cpp(PROTOBUF_SOURCES PROTOBUF_HEADERS paymentrequest.proto)
 
 add_library(bitcoin-qt-base
 	bantablemodel.cpp
 	bitcoinaddressvalidator.cpp
 	bitcoinamountfield.cpp
 	bitcoingui.cpp
 	bitcoinunits.cpp
 	clientmodel.cpp
 	csvmodelwriter.cpp
 	guiutil.cpp
 	intro.cpp
 	modaloverlay.cpp
 	networkstyle.cpp
 	notificator.cpp
 	optionsdialog.cpp
 	optionsmodel.cpp
 	peertablemodel.cpp
 	platformstyle.cpp
 	qvalidatedlineedit.cpp
 	qvaluecombobox.cpp
 	rpcconsole.cpp
 	splashscreen.cpp
 	trafficgraphwidget.cpp
 	utilitydialog.cpp
 
 	# Handle ui files
 	${UI_GENERATED_HEADERS}
 
 	# Protobuf codegen
 	${PROTOBUF_HEADERS}
 	${PROTOBUF_SOURCES}
 
 	# Translations
 	${BITCOIN_QM_FILES}
 
 	# Handle qrc files
 	${QRC_BITCOIN_CPP}
 	qrc_bitcoin_locale.cpp
 )
 
 # Windows support
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	target_sources(bitcoin-qt-base PRIVATE winshutdownmonitor.cpp)
 endif()
 
 # OSX support
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	target_sources(bitcoin-qt-base PRIVATE 
 		macdockiconhandler.mm
 		macnotificationhandler.mm
 	)
 endif()
 
 target_include_directories(bitcoin-qt-base PUBLIC ${Protobuf_INCLUDE_DIRS})
 
 target_link_libraries(bitcoin-qt-base
 	server
 	rpcclient
 	Qt5::Widgets
 	Qt5::Network
 	OpenSSL::SSL
 	${Protobuf_LIBRARIES}
 )
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	set_property(TARGET bitcoin-qt-base PROPERTY AUTOMOC_MOC_OPTIONS "-DQ_OS_MAC")
 endif()
 
 # Wallet
 if(BUILD_BITCOIN_WALLET)
 	# Automoc option.
 	set(AUTOMOC_MOC_OPTIONS -DENABLE_WALLET=1)
 
 	# Add wallet functionality to bitcoin-qt
 	target_sources(bitcoin-qt-base
 		PRIVATE
 			addressbookpage.cpp
 			addresstablemodel.cpp
 			askpassphrasedialog.cpp
 			coincontroldialog.cpp
 			coincontroltreewidget.cpp
 			editaddressdialog.cpp
 			openuridialog.cpp
 			overviewpage.cpp
 			paymentrequestplus.cpp
 			paymentserver.cpp
 			receivecoinsdialog.cpp
 			receiverequestdialog.cpp
 			recentrequeststablemodel.cpp
 			sendcoinsdialog.cpp
 			sendcoinsentry.cpp
 			signverifymessagedialog.cpp
 			transactiondesc.cpp
 			transactiondescdialog.cpp
 			transactionfilterproxy.cpp
 			transactionrecord.cpp
 			transactiontablemodel.cpp
 			transactionview.cpp
 			walletframe.cpp
 			walletmodel.cpp
 			walletmodeltransaction.cpp
 			walletview.cpp
 	)
 
 	target_link_libraries(bitcoin-qt-base wallet)
+
+	if(ENABLE_QRCODE)
+		target_include_directories(bitcoin-qt-base PUBLIC ${QRENCODE_INCLUDE_DIR})
+		target_link_libraries(bitcoin-qt-base ${QRENCODE_LIBRARY})
+	endif()
 endif()
 
 # The executable
 add_executable(bitcoin-qt bitcoin.cpp)
 target_link_libraries(bitcoin-qt bitcoin-qt-base)
 
 # Test tests
 add_subdirectory(test)