No OneTemporary
Actions

Size

86 KB

Subscribers

None

View Options

	diff --git a/configure.ac b/configure.ac
	index 252eaad04..cfe4379a8 100644
	--- a/configure.ac
	+++ b/configure.ac
	@@ -1,1421 +1,1429 @@
	dnl require autoconf 2.60 (AS_ECHO/AS_ECHO_N)
	AC_PREREQ([2.60])
	define(_CLIENT_VERSION_MAJOR, 0)
	define(_CLIENT_VERSION_MINOR, 18)
	define(_CLIENT_VERSION_REVISION, 3)
	define(_CLIENT_VERSION_BUILD, 0)
	define(_CLIENT_VERSION_IS_RELEASE, true)
	define(_COPYRIGHT_YEAR, 2018)
	define(_COPYRIGHT_HOLDERS,[The %s developers])
	define(_COPYRIGHT_HOLDERS_SUBSTITUTION,[[Bitcoin]])
	AC_INIT([Bitcoin ABC],[_CLIENT_VERSION_MAJOR._CLIENT_VERSION_MINOR._CLIENT_VERSION_REVISION],[https://github.com/Bitcoin-ABC/bitcoin-abc/issues],[bitcoin-abc],[https://bitcoinabc.org/])
	AC_CONFIG_SRCDIR([src/validation.cpp])
	AC_CONFIG_HEADERS([src/config/bitcoin-config.h])
	AC_CONFIG_AUX_DIR([build-aux])
	AC_CONFIG_MACRO_DIR([build-aux/m4])

	BITCOIN_DAEMON_NAME=bitcoind
	BITCOIN_GUI_NAME=bitcoin-qt
	BITCOIN_CLI_NAME=bitcoin-cli
	BITCOIN_TX_NAME=bitcoin-tx
	BITCOIN_SEEDER_NAME=bitcoin-seeder

	AC_CANONICAL_HOST

	AH_TOP([#ifndef BITCOIN_BITCOIN_CONFIG_H])
	AH_TOP([#define BITCOIN_BITCOIN_CONFIG_H])
	AH_BOTTOM([#endif // BITCOIN_BITCOIN_CONFIG_H])

	dnl faketime breaks configure and is only needed for make. Disable it here.
	unset FAKETIME

	dnl Automake init set-up and checks
	AM_INIT_AUTOMAKE([no-define subdir-objects foreign])

	dnl faketime messes with timestamps and causes configure to be re-run.
	dnl --disable-maintainer-mode can be used to bypass this.
	AM_MAINTAINER_MODE([enable])

	dnl make the compilation flags quiet unless V=1 is used
	m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])

	dnl Compiler checks (here before libtool).
	if test "x${CXXFLAGS+set}" = "xset"; then
	CXXFLAGS_overridden=yes
	else
	CXXFLAGS_overridden=no
	fi
	AC_PROG_CXX

	dnl By default, libtool for mingw refuses to link static libs into a dll for
	dnl fear of mixing pic/non-pic objects, and import/export complications. Since
	dnl we have those under control, re-enable that functionality.
	case $host in
	mingw)
	lt_cv_deplibs_check_method="pass_all"
	;;
	esac
	dnl Require C++11 compiler (no GNU extensions)
	AX_CXX_COMPILE_STDCXX([11], [noext], [mandatory], [nodefault])
	dnl Check if -latomic is required for <std::atomic>
	CHECK_ATOMIC

	dnl Unless the user specified OBJCXX, force it to be the same as CXX. This ensures
	dnl that we get the same -std flags for both.
	m4_ifdef([AC_PROG_OBJCXX],[
	if test "x${OBJCXX+set}" = "x"; then
	OBJCXX="${CXX}"
	fi
	AC_PROG_OBJCXX
	])

	dnl Libtool init checks.
	LT_INIT([pic-only])

	dnl Check/return PATH for base programs.
	AC_PATH_TOOL(AR, ar)
	AC_PATH_TOOL(RANLIB, ranlib)
	AC_PATH_TOOL(STRIP, strip)
	AC_PATH_TOOL(GCOV, gcov)
	AC_PATH_PROG(LCOV, lcov)
	dnl Python 3.x is supported from 3.4 on (see https://github.com/bitcoin/bitcoin/issues/7893)
	AC_PATH_PROGS([PYTHON], [python3.6 python3.5 python3.4 python3 python2.7 python2 python])
	AC_PATH_PROG(GENHTML, genhtml)
	AC_PATH_PROG([GIT], [git])
	AC_PATH_PROG(CCACHE,ccache)
	AC_PATH_PROG(XGETTEXT,xgettext)
	AC_PATH_PROG(HEXDUMP,hexdump)
	AC_PATH_TOOL(READELF, readelf)
	AC_PATH_TOOL(CPPFILT, c++filt)
	AC_PATH_TOOL(OBJCOPY, objcopy)

	AC_ARG_VAR(PYTHONPATH, Augments the default search path for python module files)

	# Enable wallet
	AC_ARG_ENABLE([wallet],
	[AS_HELP_STRING([--disable-wallet],
	[disable wallet (enabled by default)])],
	[enable_wallet=$enableval],
	[enable_wallet=yes])

	AC_ARG_WITH([miniupnpc],
	[AS_HELP_STRING([--with-miniupnpc],
	[enable UPNP (default is yes if libminiupnpc is found)])],
	[use_upnp=$withval],
	[use_upnp=auto])

	AC_ARG_ENABLE([upnp-default],
	[AS_HELP_STRING([--enable-upnp-default],
	[if UPNP is enabled, turn it on at startup (default is no)])],
	[use_upnp_default=$enableval],
	[use_upnp_default=no])

	AC_ARG_ENABLE(tests,
	AS_HELP_STRING([--disable-tests],[do not compile tests (default is to compile)]),
	[use_tests=$enableval],
	[use_tests=yes])

	AC_ARG_ENABLE(gui-tests,
	AS_HELP_STRING([--disable-gui-tests],[do not compile GUI tests (default is to compile if GUI and tests enabled)]),
	[use_gui_tests=$enableval],
	[use_gui_tests=$use_tests])

	AC_ARG_ENABLE(bench,
	AS_HELP_STRING([--disable-bench],[do not compile benchmarks (default is to compile)]),
	[use_bench=$enableval],
	[use_bench=yes])

	AC_ARG_ENABLE([extended-functional-tests],
	AS_HELP_STRING([--enable-extended-functional-tests],[enable expensive functional tests when using lcov (default no)]),
	[use_extended_functional_tests=$enableval],
	[use_extended_functional_tests=no])

	AC_ARG_WITH([qrencode],
	[AS_HELP_STRING([--with-qrencode],
	[enable QR code support (default is yes if qt is enabled and libqrencode is found)])],
	[use_qr=$withval],
	[use_qr=auto])

	AC_ARG_ENABLE([hardening],
	[AS_HELP_STRING([--disable-hardening],
	[do not attempt to harden the resulting executables (default is to harden)])],
	[use_hardening=$enableval],
	[use_hardening=yes])

	AC_ARG_ENABLE([reduce-exports],
	[AS_HELP_STRING([--enable-reduce-exports],
	[attempt to reduce exported symbols in the resulting executables (default is no)])],
	[use_reduce_exports=$enableval],
	[use_reduce_exports=no])

	AC_ARG_ENABLE([ccache],
	[AS_HELP_STRING([--disable-ccache],
	[do not use ccache for building (default is to use if found)])],
	[use_ccache=$enableval],
	[use_ccache=auto])

	AC_ARG_ENABLE([lcov],
	[AS_HELP_STRING([--enable-lcov],
	[enable lcov testing (default is no)])],
	[use_lcov=yes],
	[use_lcov=no])

	AC_ARG_ENABLE([glibc-back-compat],
	[AS_HELP_STRING([--enable-glibc-back-compat],
	[enable backwards compatibility with glibc])],
	[use_glibc_compat=$enableval],
	[use_glibc_compat=no])

	AC_ARG_ENABLE([asm],
	[AS_HELP_STRING([--enable-asm],
	[Enable assembly routines (default is yes)])],
	[use_asm=$enableval],
	[use_asm=yes])

	if test "x$use_asm" = xyes; then
	AC_DEFINE(USE_ASM, 1, [Define this symbol to build in assembly routines])
	fi

	AC_ARG_WITH([system-univalue],
	[AS_HELP_STRING([--with-system-univalue],
	[Build with system UniValue (default is no)])],
	[system_univalue=$withval],
	[system_univalue=no]
	)
	AC_ARG_ENABLE([zmq],
	[AS_HELP_STRING([--disable-zmq],
	[disable ZMQ notifications])],
	[use_zmq=$enableval],
	[use_zmq=yes])

	AC_ARG_WITH([protoc-bindir],[AS_HELP_STRING([--with-protoc-bindir=BIN_DIR],[specify protoc bin path])], [protoc_bin_path=$withval], [])

	AC_ARG_ENABLE(man,
	[AS_HELP_STRING([--disable-man],
	[do not install man pages (default is to install)])],,
	enable_man=yes)
	AM_CONDITIONAL(ENABLE_MAN, test "$enable_man" != no)

	# Enable debug
	AC_ARG_ENABLE([debug],
	[AS_HELP_STRING([--enable-debug],
	[use debug compiler flags and macros (default is no)])],
	[enable_debug=$enableval],
	[enable_debug=no])

	# Enable ASAN
	AC_ARG_ENABLE([asan],
	[AS_HELP_STRING([--enable-asan],
	[enable address sanitizer compiler flags (implies --enable-debug, default is no)])],
	[enable_asan=$enableval],
	[enable_asan=no])

	# Enable TSAN
	AC_ARG_ENABLE([tsan],
	[AS_HELP_STRING([--enable-tsan],
	[enable thread sanitizer compiler flags; requires 64-bit target architecture (implies --enable-debug, default is no)])],
	[enable_tsan=$enableval],
	[enable_tsan=no])

	# Enable UBSAN
	AC_ARG_ENABLE([ubsan],
	[AS_HELP_STRING([--enable-ubsan],
	[enable undefined behavior sanitizer compiler flags (implies --enable-debug, default is no)])],
	[enable_ubsan=$enableval],
	[enable_ubsan=no])

	# Turn warnings into errors
	AC_ARG_ENABLE([werror],
	[AS_HELP_STRING([--enable-werror],
	[Treat certain compiler warnings as errors (default is no)])],
	[enable_werror=$enableval],
	[enable_werror=no])

	AC_LANG_PUSH([C++])
	AX_CHECK_COMPILE_FLAG([-Werror],[CXXFLAG_WERROR="-Werror"],[CXXFLAG_WERROR=""])

	if test "x$enable_asan" = xyes; then
	enable_debug=yes
	asan_failed=no
	AX_CHECK_COMPILE_FLAG([-fsanitize=address],
	[CXXFLAGS="$CXXFLAGS -fsanitize=address"],
	[asan_failed=yes])
	AX_CHECK_LINK_FLAG([-fsanitize=address],
	[LDFLAGS="$LDFLAGS -fsanitize=address"],
	[asan_failed=yes])
	AX_CHECK_COMPILE_FLAG([-fno-omit-frame-pointer],
	[CXXFLAGS="$CXXFLAGS -fno-omit-frame-pointer"],
	[asan_failed=yes])

	if test "x$asan_failed" = xyes; then
	AC_MSG_ERROR("ASAN is not supported")
	fi
	# fix linkage in MacOs
	[LIBTOOL_APP_LDFLAGS="$LIBTOOL_APP_LDFLAGS -fsanitize=address"],
	fi

	if test "x$enable_tsan" = xyes; then
	enable_debug=yes
	tsan_failed=no
	AX_CHECK_COMPILE_FLAG([-fsanitize=thread],
	[CXXFLAGS="$CXXFLAGS -fsanitize=thread"],
	[tsan_failed=yes])
	AX_CHECK_LINK_FLAG([-fsanitize=thread],
	[LDFLAGS="$LDFLAGS -fsanitize=thread"],
	[tsan_failed=yes])
	AX_CHECK_COMPILE_FLAG([-fno-omit-frame-pointer],
	[CXXFLAGS="$CXXFLAGS -fno-omit-frame-pointer"],
	[tsan_failed=yes])

	if test "x$tsan_failed" = xyes; then
	AC_MSG_ERROR("TSAN is not supported")
	fi
	fi

	if test "x$enable_ubsan" = xyes; then
	enable_debug=yes
	ubsan_failed=no
	AX_CHECK_COMPILE_FLAG([-fsanitize=undefined],
	[CXXFLAGS="$CXXFLAGS -fsanitize=undefined"],
	[ubsan_failed=yes])
	AX_CHECK_LINK_FLAG([-fsanitize=undefined],
	[LDFLAGS="$LDFLAGS -fsanitize=undefined"],
	[ubsan_failed=yes])
	AX_CHECK_COMPILE_FLAG([-fno-omit-frame-pointer],
	[CXXFLAGS="$CXXFLAGS -fno-omit-frame-pointer"],
	[ubsan_failed=yes])

	if test "x$ubsan_failed" = xyes; then
	AC_MSG_ERROR("UBSAN is not supported")
	fi
	fi

	if test "x$enable_debug" = xyes; then
	CPPFLAGS="$CPPFLAGS -DDEBUG -DDEBUG_LOCKORDER"
	if test "x$GCC" = xyes; then
	CFLAGS="$CFLAGS -g3 -O0"
	fi

	if test "x$GXX" = xyes; then
	CXXFLAGS="$CXXFLAGS -g3 -O0"
	fi
	fi

	ERROR_CXXFLAGS=
	if test "x$enable_werror" = "xyes"; then
	if test "x$CXXFLAG_WERROR" = "x"; then
	AC_MSG_ERROR("enable-werror set but -Werror is not usable")
	fi
	AX_CHECK_COMPILE_FLAG([-Werror=vla],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=vla"],,[[$CXXFLAG_WERROR]])
	AX_CHECK_COMPILE_FLAG([-Werror=thread-safety-analysis],[ERROR_CXXFLAGS="$ERROR_CXXFLAGS -Werror=thread-safety-analysis"],,[[$CXXFLAG_WERROR]])
	fi

	if test "x$CXXFLAGS_overridden" = "xno"; then
	AX_CHECK_COMPILE_FLAG([-Wall],[CXXFLAGS="$CXXFLAGS -Wall"],,[[$CXXFLAG_WERROR]])
	AX_CHECK_COMPILE_FLAG([-Wextra],[CXXFLAGS="$CXXFLAGS -Wextra"],,[[$CXXFLAG_WERROR]])
	AX_CHECK_COMPILE_FLAG([-Wformat],[CXXFLAGS="$CXXFLAGS -Wformat"],,[[$CXXFLAG_WERROR]])
	AX_CHECK_COMPILE_FLAG([-Wvla],[CXXFLAGS="$CXXFLAGS -Wvla"],,[[$CXXFLAG_WERROR]])
	AX_CHECK_COMPILE_FLAG([-Wformat-security],[CXXFLAGS="$CXXFLAGS -Wformat-security"],,[[$CXXFLAG_WERROR]])
	AX_CHECK_COMPILE_FLAG([-Wthread-safety-analysis],[CXXFLAGS="$CXXFLAGS -Wthread-safety-analysis"],,[[$CXXFLAG_WERROR]])
	AX_CHECK_COMPILE_FLAG([-Wshadow],[CXXFLAGS="$CXXFLAGS -Wshadow"],,[[$CXXFLAG_WERROR]])

	## Some compilers (gcc) ignore unknown -Wno-* options, but warn about all
	## unknown options if any other warning is produced. Test the -Wfoo case, and
	## set the -Wno-foo case if it works.
	AX_CHECK_COMPILE_FLAG([-Wunused-parameter],[CXXFLAGS="$CXXFLAGS -Wno-unused-parameter"],,[[$CXXFLAG_WERROR]])
	fi

	# Check for optional instruction set support. Enabling these does _not_ imply that all code will
	# be compiled with them, rather that specific objects/libs may use them after checking for runtime
	# compatibility.
	AX_CHECK_COMPILE_FLAG([-msse4.2],[[SSE42_CXXFLAGS="-msse4.2"]],,[[$CXXFLAG_WERROR]])
	AX_CHECK_COMPILE_FLAG([-msse4.1],[[SSE41_CXXFLAGS="-msse4.1"]],,[[$CXXFLAG_WERROR]])
	AX_CHECK_COMPILE_FLAG([-mavx -mavx2],[[AVX2_CXXFLAGS="-mavx -mavx2"]],,[[$CXXFLAG_WERROR]])
	AX_CHECK_COMPILE_FLAG([-msse4 -msha],[[SHANI_CXXFLAGS="-msse4 -msha"]],,[[$CXXFLAG_WERROR]])

	TEMP_CXXFLAGS="$CXXFLAGS"
	CXXFLAGS="$CXXFLAGS $SSE42_CXXFLAGS"
	AC_MSG_CHECKING(for assembler crc32 support)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	#include <stdint.h>
	#if defined(_MSC_VER)
	#include <intrin.h>
	#elif defined(__GNUC__) && defined(__SSE4_2__)
	#include <nmmintrin.h>
	#endif
	]],[[
	uint64_t l = 0;
	l = _mm_crc32_u8(l, 0);
	l = _mm_crc32_u32(l, 0);
	l = _mm_crc32_u64(l, 0);
	return l;
	]])],
	[ AC_MSG_RESULT(yes); enable_hwcrc32=yes],
	[ AC_MSG_RESULT(no)]
	)
	CXXFLAGS="$TEMP_CXXFLAGS"

	TEMP_CXXFLAGS="$CXXFLAGS"
	CXXFLAGS="$CXXFLAGS $SSE41_CXXFLAGS"
	AC_MSG_CHECKING(for SSE4.1 intrinsics)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	#include <stdint.h>
	#include <immintrin.h>
	]],[[
	__m128i l = _mm_set1_epi32(0);
	return _mm_extract_epi32(l, 3);
	]])],
	[ AC_MSG_RESULT(yes); enable_sse41=yes; AC_DEFINE(ENABLE_SSE41, 1, [Define this symbol to build code that uses SSE4.1 intrinsics]) ],
	[ AC_MSG_RESULT(no)]
	)
	CXXFLAGS="$TEMP_CXXFLAGS"

	TEMP_CXXFLAGS="$CXXFLAGS"
	CXXFLAGS="$CXXFLAGS $AVX2_CXXFLAGS"
	AC_MSG_CHECKING(for AVX2 intrinsics)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	#include <stdint.h>
	#include <immintrin.h>
	]],[[
	__m256i l = _mm256_set1_epi32(0);
	return _mm256_extract_epi32(l, 7);
	]])],
	[ AC_MSG_RESULT(yes); enable_avx2=yes; AC_DEFINE(ENABLE_AVX2, 1, [Define this symbol to build code that uses AVX2 intrinsics]) ],
	[ AC_MSG_RESULT(no)]
	)
	CXXFLAGS="$TEMP_CXXFLAGS"

	TEMP_CXXFLAGS="$CXXFLAGS"
	CXXFLAGS="$CXXFLAGS $SHANI_CXXFLAGS"
	AC_MSG_CHECKING(for SHA-NI intrinsics)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
	#include <stdint.h>
	#include <immintrin.h>
	]],[[
	__m128i i = _mm_set1_epi32(0);
	__m128i j = _mm_set1_epi32(1);
	__m128i k = _mm_set1_epi32(2);
	return _mm_extract_epi32(_mm_sha256rnds2_epu32(i, i, k), 0);
	]])],
	[ AC_MSG_RESULT(yes); enable_shani=yes; AC_DEFINE(ENABLE_SHANI, 1, [Define this symbol to build code that uses SHA-NI intrinsics]) ],
	[ AC_MSG_RESULT(no)]
	)
	CXXFLAGS="$TEMP_CXXFLAGS"

	CPPFLAGS="$CPPFLAGS -DHAVE_BUILD_INFO -D__STDC_FORMAT_MACROS"

	AC_ARG_WITH([utils],
	[AS_HELP_STRING([--with-utils],
	[build bitcoin-cli bitcoin-tx (default=yes)])],
	[build_bitcoin_utils=$withval],
	[build_bitcoin_utils=yes])

	AC_ARG_WITH([libs],
	[AS_HELP_STRING([--with-libs],
	[build libraries (default=yes)])],
	[build_bitcoin_libs=$withval],
	[build_bitcoin_libs=yes])

	AC_ARG_WITH([daemon],
	[AS_HELP_STRING([--with-daemon],
	[build bitcoind daemon (default=yes)])],
	[build_bitcoind=$withval],
	[build_bitcoind=yes])

	AC_ARG_WITH([seeder],
	[AS_HELP_STRING([--with-seeder],
	[build seeder (default=yes)])],
	[build_bitcoin_seeder=$withval],
	[build_bitcoin_seeder=yes])

	use_pkgconfig=yes
	case $host in
	mingw)

	#pkgconfig does more harm than good with MinGW
	use_pkgconfig=no

	TARGET_OS=windows
	AC_CHECK_LIB([mingwthrd], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([kernel32], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([user32], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([gdi32], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([comdlg32], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([winspool], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([winmm], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([shell32], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([comctl32], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([ole32], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([oleaut32], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([uuid], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([rpcrt4], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([advapi32], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([ws2_32], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([mswsock], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([shlwapi], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([iphlpapi], [main],, AC_MSG_ERROR(lib missing))
	AC_CHECK_LIB([crypt32], [main],, AC_MSG_ERROR(lib missing))

	# -static is interpreted by libtool, where it has a different meaning.
	# In libtool-speak, it's -all-static.
	AX_CHECK_LINK_FLAG([[-static]],[LIBTOOL_APP_LDFLAGS="$LIBTOOL_APP_LDFLAGS -all-static"])

	AC_PATH_PROG([MAKENSIS], [makensis], none)
	if test x$MAKENSIS = xnone; then
	AC_MSG_WARN("makensis not found. Cannot create installer.")
	fi

	AC_PATH_TOOL(WINDRES, windres, none)
	if test x$WINDRES = xnone; then
	AC_MSG_ERROR("windres not found")
	fi

	CPPFLAGS="$CPPFLAGS -D_MT -DWIN32 -D_WINDOWS -DBOOST_THREAD_USE_LIB"
	LEVELDB_TARGET_FLAGS="-DOS_WINDOWS"
	if test "x$CXXFLAGS_overridden" = "xno"; then
	CXXFLAGS="$CXXFLAGS -w"
	fi
	case $host in
	i?86-*) WINDOWS_BITS=32 ;;
	x86_64-*) WINDOWS_BITS=64 ;;
	*) AC_MSG_ERROR("Could not determine win32/win64 for installer") ;;
	esac
	AC_SUBST(WINDOWS_BITS)

	dnl libtool insists upon adding -nostdlib and a list of objects/libs to link against.
	dnl That breaks our ability to build dll's with static libgcc/libstdc++/libssp. Override
	dnl its command here, with the predeps/postdeps removed, and -static inserted. Postdeps are
	dnl also overridden to prevent their insertion later.
	dnl This should only affect dll's.
	archive_cmds_CXX="\$CC -shared \$libobjs \$deplibs \$compiler_flags -static -o \$output_objdir/\$soname \${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker \$lib"
	postdeps_CXX=

	;;
	darwin)
	TARGET_OS=darwin
	LEVELDB_TARGET_FLAGS="-DOS_MACOSX"
	if test x$cross_compiling != xyes; then
	BUILD_OS=darwin
	AC_CHECK_PROG([PORT],port, port)
	if test x$PORT = xport; then
	dnl add default macports paths
	CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
	LIBS="$LIBS -L/opt/local/lib"
	if test -d /opt/local/include/db48; then
	CPPFLAGS="$CPPFLAGS -I/opt/local/include/db48"
	LIBS="$LIBS -L/opt/local/lib/db48"
	fi
	fi

	AC_PATH_PROGS([RSVG_CONVERT], [rsvg-convert rsvg],rsvg-convert)
	AC_CHECK_PROG([BREW],brew, brew)
	if test x$BREW = xbrew; then
	dnl These Homebrew packages may be keg-only, meaning that they won't be found
	dnl in expected paths because they may conflict with system files. Ask
	dnl Homebrew where each one is located, then adjust paths accordingly.
	dnl It's safe to add these paths even if the functionality is disabled by
	dnl the user (--without-wallet or --without-gui for example).

	openssl_prefix=`$BREW --prefix openssl 2>/dev/null`
	bdb_prefix=`$BREW --prefix berkeley-db 2>/dev/null`
	qt5_prefix=`$BREW --prefix qt5 2>/dev/null`
	if test x$openssl_prefix != x; then
	PKG_CONFIG_PATH="$openssl_prefix/lib/pkgconfig:$PKG_CONFIG_PATH"
	export PKG_CONFIG_PATH
	fi
	if test x$bdb_prefix != x; then
	CPPFLAGS="$CPPFLAGS -I$bdb_prefix/include"
	LIBS="$LIBS -L$bdb_prefix/lib"
	fi
	if test x$qt5_prefix != x; then
	PKG_CONFIG_PATH="$qt5_prefix/lib/pkgconfig:$PKG_CONFIG_PATH"
	export PKG_CONFIG_PATH
	fi
	fi
	else
	case $build_os in
	darwin)
	BUILD_OS=darwin
	;;
	*)
	AC_PATH_TOOL([INSTALLNAMETOOL], [install_name_tool], install_name_tool)
	AC_PATH_TOOL([OTOOL], [otool], otool)
	AC_PATH_PROGS([GENISOIMAGE], [genisoimage mkisofs],genisoimage)
	AC_PATH_PROGS([RSVG_CONVERT], [rsvg-convert rsvg],rsvg-convert)
	AC_PATH_PROGS([IMAGEMAGICK_CONVERT], [convert],convert)
	AC_PATH_PROGS([TIFFCP], [tiffcp],tiffcp)

	dnl libtool will try to strip the static lib, which is a problem for
	dnl cross-builds because strip attempts to call a hard-coded ld,
	dnl which may not exist in the path. Stripping the .a is not
	dnl necessary, so just disable it.
	old_striplib=
	;;
	esac
	fi

	AX_CHECK_LINK_FLAG([[-Wl,-headerpad_max_install_names]], [LDFLAGS="$LDFLAGS -Wl,-headerpad_max_install_names"])
	CPPFLAGS="$CPPFLAGS -DMAC_OSX"
	OBJCXXFLAGS="$CXXFLAGS"
	;;
	linux)
	TARGET_OS=linux
	LEVELDB_TARGET_FLAGS="-DOS_LINUX"
	;;
	freebsd)
	LEVELDB_TARGET_FLAGS="-DOS_FREEBSD"
	;;
	openbsd)
	LEVELDB_TARGET_FLAGS="-DOS_OPENBSD"
	;;
	*)
	OTHER_OS=`echo ${host_os} \| awk '{print toupper($0)}'`
	AC_MSG_WARN([Guessing LevelDB OS as OS_${OTHER_OS}, please check whether this is correct, if not add an entry to configure.ac.])
	LEVELDB_TARGET_FLAGS="-DOS_${OTHER_OS}"
	;;
	esac

	if test x$use_pkgconfig = xyes; then
	m4_ifndef([PKG_PROG_PKG_CONFIG], [AC_MSG_ERROR(PKG_PROG_PKG_CONFIG macro not found. Please install pkg-config and re-run autogen.sh.)])
	m4_ifdef([PKG_PROG_PKG_CONFIG], [
	PKG_PROG_PKG_CONFIG
	if test x"$PKG_CONFIG" = "x"; then
	AC_MSG_ERROR(pkg-config not found.)
	fi
	])
	fi

	if test x$use_extended_functional_tests != xno; then
	AC_SUBST(EXTENDED_FUNCTIONAL_TESTS, --extended)
	fi

	if test x$use_lcov = xyes; then
	if test x$LCOV = x; then
	AC_MSG_ERROR("lcov testing requested but lcov not found")
	fi
	if test x$GCOV = x; then
	AC_MSG_ERROR("lcov testing requested but gcov not found")
	fi
	if test x$PYTHON = x; then
	AC_MSG_ERROR("lcov testing requested but python not found")
	fi
	if test x$GENHTML = x; then
	AC_MSG_ERROR("lcov testing requested but genhtml not found")
	fi
	LCOV="$LCOV --gcov-tool=$GCOV"
	AX_CHECK_LINK_FLAG([[--coverage]], [LDFLAGS="$LDFLAGS --coverage"],
	[AC_MSG_ERROR("lcov testing requested but --coverage linker flag does not work")])
	AX_CHECK_COMPILE_FLAG([--coverage],[CXXFLAGS="$CXXFLAGS --coverage"],
	[AC_MSG_ERROR("lcov testing requested but --coverage flag does not work")])
	fi

	dnl Check for endianness
	AC_C_BIGENDIAN

	dnl Check for pthread compile/link requirements
	AX_PTHREAD

	# The following macro will add the necessary defines to bitcoin-config.h, but
	# they also need to be passed down to any subprojects. Pull the results out of
	# the cache and add them to CPPFLAGS.
	AC_SYS_LARGEFILE
	# detect POSIX or GNU variant of strerror_r
	AC_FUNC_STRERROR_R

	if test x$ac_cv_sys_file_offset_bits != x &&
	test x$ac_cv_sys_file_offset_bits != xno &&
	test x$ac_cv_sys_file_offset_bits != xunknown; then
	CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits"
	fi

	if test x$ac_cv_sys_large_files != x &&
	test x$ac_cv_sys_large_files != xno &&
	test x$ac_cv_sys_large_files != xunknown; then
	CPPFLAGS="$CPPFLAGS -D_LARGE_FILES=$ac_cv_sys_large_files"
	fi

	AX_CHECK_LINK_FLAG([[-Wl,--large-address-aware]], [LDFLAGS="$LDFLAGS -Wl,--large-address-aware"])

	AX_GCC_FUNC_ATTRIBUTE([visibility])
	AX_GCC_FUNC_ATTRIBUTE([dllexport])
	AX_GCC_FUNC_ATTRIBUTE([dllimport])

	if test x$use_glibc_compat != xno; then

	#glibc absorbed clock_gettime in 2.17. librt (its previous location) is safe to link
	#in anyway for back-compat.
	AC_CHECK_LIB([rt],[clock_gettime],, AC_MSG_ERROR(lib missing))

	#__fdelt_chk's params and return type have changed from long unsigned int to long int.
	# See which one is present here.
	AC_MSG_CHECKING(__fdelt_chk type)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#ifdef _FORTIFY_SOURCE
	#undef _FORTIFY_SOURCE
	#endif
	#define _FORTIFY_SOURCE 2
	#include <sys/select.h>
	extern "C" long unsigned int __fdelt_warn(long unsigned int);]],[[]])],
	[ fdelt_type="long unsigned int"],
	[ fdelt_type="long int"])
	AC_MSG_RESULT($fdelt_type)
	AC_DEFINE_UNQUOTED(FDELT_TYPE, $fdelt_type,[parameter and return value type for __fdelt_chk])
	AX_CHECK_LINK_FLAG([[-Wl,--wrap=__divmoddi4]], [COMPAT_LDFLAGS="$COMPAT_LDFLAGS -Wl,--wrap=__divmoddi4"])
	AX_CHECK_LINK_FLAG([[-Wl,--wrap=log2f]], [COMPAT_LDFLAGS="$COMPAT_LDFLAGS -Wl,--wrap=log2f"])
	else
	AC_SEARCH_LIBS([clock_gettime],[rt])
	fi

	if test x$TARGET_OS != xwindows; then
	# All windows code is PIC, forcing it on just adds useless compile warnings
	AX_CHECK_COMPILE_FLAG([-fPIC],[PIC_FLAGS="-fPIC"])
	fi

	if test x$use_hardening != xno; then
	AX_CHECK_COMPILE_FLAG([-Wstack-protector],[HARDENED_CXXFLAGS="$HARDENED_CXXFLAGS -Wstack-protector"])
	AX_CHECK_COMPILE_FLAG([-fstack-protector-all],[HARDENED_CXXFLAGS="$HARDENED_CXXFLAGS -fstack-protector-all"])

	AX_CHECK_PREPROC_FLAG([-D_FORTIFY_SOURCE=2],[
	AX_CHECK_PREPROC_FLAG([-U_FORTIFY_SOURCE],[
	HARDENED_CPPFLAGS="$HARDENED_CPPFLAGS -U_FORTIFY_SOURCE"
	])
	HARDENED_CPPFLAGS="$HARDENED_CPPFLAGS -D_FORTIFY_SOURCE=2"
	])

	AX_CHECK_LINK_FLAG([[-Wl,--dynamicbase]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,--dynamicbase"])
	AX_CHECK_LINK_FLAG([[-Wl,--nxcompat]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,--nxcompat"])
	AX_CHECK_LINK_FLAG([[-Wl,--high-entropy-va]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,--high-entropy-va"])
	AX_CHECK_LINK_FLAG([[-Wl,-z,relro]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,-z,relro"])
	AX_CHECK_LINK_FLAG([[-Wl,-z,now]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,-z,now"])

	if test x$TARGET_OS != xwindows; then
	AX_CHECK_COMPILE_FLAG([-fPIE],[PIE_FLAGS="-fPIE"])
	AX_CHECK_LINK_FLAG([[-pie]], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -pie"])
	fi

	case $host in
	mingw)
	AC_CHECK_LIB([ssp], [main],, AC_MSG_ERROR(lib missing))
	;;
	esac
	fi

	dnl this flag screws up non-darwin gcc even when the check fails. special-case it.
	if test x$TARGET_OS = xdarwin; then
	AX_CHECK_LINK_FLAG([[-Wl,-dead_strip]], [LDFLAGS="$LDFLAGS -Wl,-dead_strip"])
	fi

	AC_CHECK_HEADERS([endian.h sys/endian.h byteswap.h stdio.h stdlib.h unistd.h strings.h sys/types.h sys/stat.h sys/select.h sys/prctl.h])

	AC_CHECK_DECLS([strnlen])

	# Check for daemon(3), unrelated to --with-daemon (although used by it)
	AC_CHECK_DECLS([daemon])

	AC_CHECK_DECLS([le16toh, le32toh, le64toh, htole16, htole32, htole64, be16toh, be32toh, be64toh, htobe16, htobe32, htobe64],,,
	[#if HAVE_ENDIAN_H
	#include <endian.h>
	#elif HAVE_SYS_ENDIAN_H
	#include <sys/endian.h>
	#endif])

	AC_CHECK_DECLS([bswap_16, bswap_32, bswap_64],,,
	[#if HAVE_BYTESWAP_H
	#include <byteswap.h>
	#endif])

	AC_CHECK_DECLS([__builtin_clz, __builtin_clzl, __builtin_clzll])

	dnl Check for mallopt(M_ARENA_MAX) (to set glibc arenas)
	AC_MSG_CHECKING(for mallopt M_ARENA_MAX)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <malloc.h>]],
	[[ mallopt(M_ARENA_MAX, 1); ]])],
	[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_MALLOPT_ARENA_MAX, 1,[Define this symbol if you have mallopt with M_ARENA_MAX]) ],
	[ AC_MSG_RESULT(no)]
	)

	+dnl Check for malloc_info (for memory statistics information in getmemoryinfo)
	+AC_MSG_CHECKING(for getmemoryinfo)
	+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <malloc.h>]],
	+ [[ int f = malloc_info(0, NULL); ]])],
	+ [ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_MALLOC_INFO, 1,[Define this symbol if you have malloc_info]) ],
	+ [ AC_MSG_RESULT(no)]
	+)
	+
	AC_MSG_CHECKING([for visibility attribute])
	AC_LINK_IFELSE([AC_LANG_SOURCE([
	int foo_def( void ) __attribute__((visibility("default")));
	int main(){}
	])],
	[
	AC_DEFINE(HAVE_VISIBILITY_ATTRIBUTE,1,[Define if the visibility attribute is supported.])
	AC_MSG_RESULT(yes)
	],
	[
	AC_MSG_RESULT(no)
	if test x$use_reduce_exports = xyes; then
	AC_MSG_ERROR([Cannot find a working visibility attribute. Use --disable-reduce-exports.])
	fi
	]
	)

	# Check for different ways of gathering OS randomness
	AC_MSG_CHECKING(for Linux getrandom syscall)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>
	#include <sys/syscall.h>
	#include <linux/random.h>]],
	[[ syscall(SYS_getrandom, nullptr, 32, 0); ]])],
	[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_SYS_GETRANDOM, 1,[Define this symbol if the Linux getrandom system call is available]) ],
	[ AC_MSG_RESULT(no)]
	)

	AC_MSG_CHECKING(for getentropy)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>]],
	[[ getentropy(nullptr, 32) ]])],
	[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_GETENTROPY, 1,[Define this symbol if the BSD getentropy system call is available]) ],
	[ AC_MSG_RESULT(no)]
	)

	AC_MSG_CHECKING(for getentropy via random.h)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>
	#include <sys/random.h>]],
	[[ getentropy(nullptr, 32) ]])],
	[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_GETENTROPY_RAND, 1,[Define this symbol if the BSD getentropy system call is available with sys/random.h]) ],
	[ AC_MSG_RESULT(no)]
	)

	AC_MSG_CHECKING(for sysctl KERN_ARND)
	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
	#include <sys/sysctl.h>]],
	[[ static const int name[2] = {CTL_KERN, KERN_ARND};
	sysctl(name, 2, nullptr, nullptr, nullptr, 0); ]])],
	[ AC_MSG_RESULT(yes); AC_DEFINE(HAVE_SYSCTL_ARND, 1,[Define this symbol if the BSD sysctl(KERN_ARND) is available]) ],
	[ AC_MSG_RESULT(no)]
	)

	# Check for reduced exports
	if test x$use_reduce_exports = xyes; then
	AX_CHECK_COMPILE_FLAG([-fvisibility=hidden],[RE_CXXFLAGS="-fvisibility=hidden"],
	[AC_MSG_ERROR([Cannot set default symbol visibility. Use --disable-reduce-exports.])])
	fi

	LEVELDB_CPPFLAGS=
	LIBLEVELDB=
	LIBMEMENV=
	AM_CONDITIONAL([EMBEDDED_LEVELDB],[true])
	AC_SUBST(LEVELDB_CPPFLAGS)
	AC_SUBST(LIBLEVELDB)
	AC_SUBST(LIBMEMENV)

	if test x$enable_wallet != xno; then
	dnl Check for libdb_cxx only if wallet enabled
	BITCOIN_FIND_BDB53
	fi

	dnl Check for libminiupnpc (optional)
	if test x$use_upnp != xno; then
	AC_CHECK_HEADERS(
	[miniupnpc/miniwget.h miniupnpc/miniupnpc.h miniupnpc/upnpcommands.h miniupnpc/upnperrors.h],
	[AC_CHECK_LIB([miniupnpc], [upnpDiscover], [MINIUPNPC_LIBS=-lminiupnpc], [have_miniupnpc=no])],
	[have_miniupnpc=no]
	)
	fi

	BITCOIN_QT_INIT

	dnl sets $bitcoin_enable_qt, $bitcoin_enable_qt_test, $bitcoin_enable_qt_dbus
	BITCOIN_QT_CONFIGURE([$use_pkgconfig])

	if test x$build_bitcoin_utils$build_bitcoind$bitcoin_enable_qt$build_bitcoin_seeder$use_tests$use_bench = xnononononono; then
	use_boost=no
	else
	use_boost=yes
	fi

	if test x$use_boost = xyes; then

	dnl Minimum required Boost version
	define(MINIMUM_REQUIRED_BOOST, 1.58.0)

	dnl Check for boost libs
	AX_BOOST_BASE([MINIMUM_REQUIRED_BOOST])
	AX_BOOST_SYSTEM
	AX_BOOST_FILESYSTEM
	AX_BOOST_PROGRAM_OPTIONS
	AX_BOOST_THREAD
	AX_BOOST_CHRONO

	dnl Boost 1.56 through 1.62 allow using std::atomic instead of its own atomic
	dnl counter implementations. In 1.63 and later the std::atomic approach is default.
	m4_pattern_allow(DBOOST_AC_USE_STD_ATOMIC) dnl otherwise it's treated like a macro
	BOOST_CPPFLAGS="-DBOOST_SP_USE_STD_ATOMIC -DBOOST_AC_USE_STD_ATOMIC $BOOST_CPPFLAGS"

	if test x$use_reduce_exports = xyes; then
	AC_MSG_CHECKING([for working boost reduced exports])
	TEMP_CPPFLAGS="$CPPFLAGS"
	CPPFLAGS="$BOOST_CPPFLAGS $CPPFLAGS"
	AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[
	@%:@include <boost/version.hpp>
	]], [[
	#if BOOST_VERSION >= 104900
	// Everything is okay
	#else
	# error Boost version is too old
	#endif
	]])],[
	AC_MSG_RESULT(yes)
	],[
	AC_MSG_ERROR([boost versions < 1.49 are known to be broken with reduced exports. Use --disable-reduce-exports.])
	])
	CPPFLAGS="$TEMP_CPPFLAGS"
	fi
	fi

	if test x$use_reduce_exports = xyes; then
	CXXFLAGS="$CXXFLAGS $RE_CXXFLAGS"
	AX_CHECK_LINK_FLAG([[-Wl,--exclude-libs,ALL]], [RELDFLAGS="-Wl,--exclude-libs,ALL"])
	fi

	if test x$use_tests = xyes; then

	if test x$HEXDUMP = x; then
	AC_MSG_ERROR(hexdump is required for tests)
	fi


	if test x$use_boost = xyes; then

	AX_BOOST_UNIT_TEST_FRAMEWORK

	dnl Determine if -DBOOST_TEST_DYN_LINK is needed
	AC_MSG_CHECKING([for dynamic linked boost test])
	TEMP_LIBS="$LIBS"
	LIBS="$LIBS $BOOST_LDFLAGS $BOOST_UNIT_TEST_FRAMEWORK_LIB"
	TEMP_CPPFLAGS="$CPPFLAGS"
	CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
	AC_LINK_IFELSE([AC_LANG_SOURCE([
	#define BOOST_TEST_DYN_LINK
	#define BOOST_TEST_MAIN
	#include <boost/test/unit_test.hpp>

	])],
	[AC_MSG_RESULT(yes)]
	[TESTDEFS="$TESTDEFS -DBOOST_TEST_DYN_LINK"],
	[AC_MSG_RESULT(no)])
	LIBS="$TEMP_LIBS"
	CPPFLAGS="$TEMP_CPPFLAGS"

	fi
	fi

	if test x$use_boost = xyes; then

	BOOST_LIBS="$BOOST_LDFLAGS $BOOST_SYSTEM_LIB $BOOST_FILESYSTEM_LIB $BOOST_PROGRAM_OPTIONS_LIB $BOOST_THREAD_LIB $BOOST_CHRONO_LIB"


	dnl If boost (prior to 1.57) was built without c++11, it emulated scoped enums
	dnl using c++98 constructs. Unfortunately, this implementation detail leaked into
	dnl the abi. This was fixed in 1.57.

	dnl When building against that installed version using c++11, the headers pick up
	dnl on the native c++11 scoped enum support and enable it, however it will fail to
	dnl link. This can be worked around by disabling c++11 scoped enums if linking will
	dnl fail.
	dnl BOOST_NO_SCOPED_ENUMS was changed to BOOST_NO_CXX11_SCOPED_ENUMS in 1.51.

	TEMP_LIBS="$LIBS"
	LIBS="$BOOST_LIBS $LIBS"
	TEMP_CPPFLAGS="$CPPFLAGS"
	CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
	AC_MSG_CHECKING([for mismatched boost c++11 scoped enums])
	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	#include <boost/config.hpp>
	#include <boost/version.hpp>
	#if !defined(BOOST_NO_SCOPED_ENUMS) && !defined(BOOST_NO_CXX11_SCOPED_ENUMS) && BOOST_VERSION < 105700
	#define BOOST_NO_SCOPED_ENUMS
	#define BOOST_NO_CXX11_SCOPED_ENUMS
	#define CHECK
	#endif
	#include <boost/filesystem.hpp>
	]],[[
	#if defined(CHECK)
	boost::filesystem::copy_file("foo", "bar");
	#else
	choke;
	#endif
	]])],
	[AC_MSG_RESULT(mismatched); BOOST_CPPFLAGS="$BOOST_CPPFLAGS -DBOOST_NO_SCOPED_ENUMS -DBOOST_NO_CXX11_SCOPED_ENUMS"], [AC_MSG_RESULT(ok)])
	LIBS="$TEMP_LIBS"
	CPPFLAGS="$TEMP_CPPFLAGS"

	dnl Boost >= 1.50 uses sleep_for rather than the now-deprecated sleep, however
	dnl it was broken from 1.50 to 1.52 when backed by nanosleep. Use sleep_for if
	dnl a working version is available, else fall back to sleep. sleep was removed
	dnl after 1.56.
	dnl If neither is available, abort.
	TEMP_LIBS="$LIBS"
	LIBS="$BOOST_LIBS $LIBS"
	TEMP_CPPFLAGS="$CPPFLAGS"
	CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	#include <boost/thread/thread.hpp>
	#include <boost/version.hpp>
	]],[[
	#if BOOST_VERSION >= 105000 && (!defined(BOOST_HAS_NANOSLEEP) \|\| BOOST_VERSION >= 105200)
	boost::this_thread::sleep_for(boost::chrono::milliseconds(0));
	#else
	choke me
	#endif
	]])],
	[boost_sleep=yes;
	AC_DEFINE(HAVE_WORKING_BOOST_SLEEP_FOR, 1, [Define this symbol if boost sleep_for works])],
	[boost_sleep=no])
	LIBS="$TEMP_LIBS"
	CPPFLAGS="$TEMP_CPPFLAGS"

	if test x$boost_sleep != xyes; then
	TEMP_LIBS="$LIBS"
	LIBS="$BOOST_LIBS $LIBS"
	TEMP_CPPFLAGS="$CPPFLAGS"
	CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	#include <boost/version.hpp>
	#include <boost/thread.hpp>
	#include <boost/date_time/posix_time/posix_time_types.hpp>
	]],[[
	#if BOOST_VERSION <= 105600
	boost::this_thread::sleep(boost::posix_time::milliseconds(0));
	#else
	choke me
	#endif
	]])],
	[boost_sleep=yes; AC_DEFINE(HAVE_WORKING_BOOST_SLEEP, 1, [Define this symbol if boost sleep works])],
	[boost_sleep=no])
	LIBS="$TEMP_LIBS"
	CPPFLAGS="$TEMP_CPPFLAGS"
	fi

	if test x$boost_sleep != xyes; then
	AC_MSG_ERROR(No working boost sleep implementation found.)
	fi

	fi

	if test x$use_pkgconfig = xyes; then
	: dnl
	m4_ifdef(
	[PKG_CHECK_MODULES],
	[
	PKG_CHECK_MODULES([SSL], [libssl],, [AC_MSG_ERROR(openssl not found.)])
	PKG_CHECK_MODULES([CRYPTO], [libcrypto],,[AC_MSG_ERROR(libcrypto not found.)])
	BITCOIN_QT_CHECK([PKG_CHECK_MODULES([PROTOBUF], [protobuf], [have_protobuf=yes], [BITCOIN_QT_FAIL(libprotobuf not found)])])
	if test x$use_qr != xno; then
	BITCOIN_QT_CHECK([PKG_CHECK_MODULES([QR], [libqrencode], [have_qrencode=yes], [have_qrencode=no])])
	fi
	if test x$build_bitcoin_utils$build_bitcoind$bitcoin_enable_qt$use_tests != xnononono; then
	PKG_CHECK_MODULES([EVENT], [libevent],, [AC_MSG_ERROR(libevent not found.)])
	if test x$TARGET_OS != xwindows; then
	PKG_CHECK_MODULES([EVENT_PTHREADS], [libevent_pthreads],, [AC_MSG_ERROR(libevent_pthreads not found.)])
	fi
	fi

	if test "x$use_zmq" = "xyes"; then
	PKG_CHECK_MODULES([ZMQ],[libzmq >= 4],
	[AC_DEFINE([ENABLE_ZMQ],[1],[Define to 1 to enable ZMQ functions])],
	[AC_DEFINE([ENABLE_ZMQ],[0],[Define to 1 to enable ZMQ functions])
	AC_MSG_WARN([libzmq version 4.x or greater not found, disabling])
	use_zmq=no])
	else
	AC_DEFINE_UNQUOTED([ENABLE_ZMQ],[0],[Define to 1 to enable ZMQ functions])
	fi
	]
	)
	else
	AC_CHECK_HEADER([openssl/crypto.h],,AC_MSG_ERROR(libcrypto headers missing))
	AC_CHECK_LIB([crypto], [main],CRYPTO_LIBS=-lcrypto, AC_MSG_ERROR(libcrypto missing))

	AC_CHECK_HEADER([openssl/ssl.h],, AC_MSG_ERROR(libssl headers missing),)
	AC_CHECK_LIB([ssl], [main],SSL_LIBS=-lssl, AC_MSG_ERROR(libssl missing))

	if test x$build_bitcoin_utils$build_bitcoind$bitcoin_enable_qt$use_tests != xnononono; then
	AC_CHECK_HEADER([event2/event.h],, AC_MSG_ERROR(libevent headers missing),)
	AC_CHECK_LIB([event],[main],EVENT_LIBS=-levent,AC_MSG_ERROR(libevent missing))
	if test x$TARGET_OS != xwindows; then
	AC_CHECK_LIB([event_pthreads],[main],EVENT_PTHREADS_LIBS=-levent_pthreads,AC_MSG_ERROR(libevent_pthreads missing))
	fi
	fi

	if test "x$use_zmq" = "xyes"; then
	AC_CHECK_HEADER([zmq.h],
	[AC_DEFINE([ENABLE_ZMQ],[1],[Define to 1 to enable ZMQ functions])],
	[AC_MSG_WARN([zmq.h not found, disabling zmq support])
	use_zmq=no
	AC_DEFINE([ENABLE_ZMQ],[0],[Define to 1 to enable ZMQ functions])])
	AC_CHECK_LIB([zmq],[zmq_ctx_shutdown],ZMQ_LIBS=-lzmq,
	[AC_MSG_WARN([libzmq >= 4.0 not found, disabling zmq support])
	use_zmq=no
	AC_DEFINE([ENABLE_ZMQ],[0],[Define to 1 to enable ZMQ functions])])
	else
	AC_DEFINE_UNQUOTED([ENABLE_ZMQ],[0],[Define to 1 to enable ZMQ functions])
	fi

	if test "x$use_zmq" = "xyes"; then
	dnl Assume libzmq was built for static linking
	case $host in
	mingw)
	ZMQ_CFLAGS="$ZMQ_CFLAGS -DZMQ_STATIC"
	;;
	esac
	fi

	BITCOIN_QT_CHECK(AC_CHECK_LIB([protobuf] ,[main],[PROTOBUF_LIBS=-lprotobuf], BITCOIN_QT_FAIL(libprotobuf not found)))
	if test x$use_qr != xno; then
	BITCOIN_QT_CHECK([AC_CHECK_LIB([qrencode], [main],[QR_LIBS=-lqrencode], [have_qrencode=no])])
	BITCOIN_QT_CHECK([AC_CHECK_HEADER([qrencode.h],, have_qrencode=no)])
	fi
	fi

	save_CXXFLAGS="${CXXFLAGS}"
	CXXFLAGS="${CXXFLAGS} ${CRYPTO_CFLAGS} ${SSL_CFLAGS}"
	AC_CHECK_DECLS([EVP_MD_CTX_new],,,[AC_INCLUDES_DEFAULT
	#include <openssl/x509_vfy.h>
	])
	CXXFLAGS="${save_CXXFLAGS}"

	dnl univalue check

	need_bundled_univalue=yes

	if test x$build_bitcoin_utils$build_bitcoind$bitcoin_enable_qt$use_tests$use_bench = xnonononono; then
	need_bundled_univalue=no
	else

	if test x$system_univalue != xno ; then
	found_univalue=no
	if test x$use_pkgconfig = xyes; then
	: #NOP
	m4_ifdef(
	[PKG_CHECK_MODULES],
	[
	PKG_CHECK_MODULES([UNIVALUE],[libunivalue >= 1.0.4],[found_univalue=yes],[true])
	]
	)
	else
	AC_CHECK_HEADER([univalue.h],[
	AC_CHECK_LIB([univalue], [main],[
	UNIVALUE_LIBS=-lunivalue
	found_univalue=yes
	],[true])
	],[true])
	fi

	if test x$found_univalue = xyes ; then
	system_univalue=yes
	need_bundled_univalue=no
	elif test x$system_univalue = xyes ; then
	AC_MSG_ERROR([univalue not found])
	else
	system_univalue=no
	fi
	fi

	if test x$need_bundled_univalue = xyes ; then
	UNIVALUE_CFLAGS='-I$(srcdir)/univalue/include'
	UNIVALUE_LIBS='univalue/libunivalue.la'
	fi

	fi

	AM_CONDITIONAL([EMBEDDED_UNIVALUE],[test x$need_bundled_univalue = xyes])
	AC_SUBST(UNIVALUE_CFLAGS)
	AC_SUBST(UNIVALUE_LIBS)

	BITCOIN_QT_PATH_PROGS([PROTOC], [protoc],$protoc_bin_path)

	AC_MSG_CHECKING([whether to build bitcoind])
	AM_CONDITIONAL([BUILD_BITCOIND], [test x$build_bitcoind = xyes])
	AC_MSG_RESULT($build_bitcoind)

	AC_MSG_CHECKING([whether to build bitcoin-seeder])
	AM_CONDITIONAL([BUILD_BITCOIN_SEEDER], [test x$build_bitcoin_seeder = xyes])
	AC_MSG_RESULT($build_bitcoin_seeder)

	AC_MSG_CHECKING([whether to build utils (bitcoin-cli bitcoin-tx)])
	AM_CONDITIONAL([BUILD_BITCOIN_UTILS], [test x$build_bitcoin_utils = xyes])
	AC_MSG_RESULT($build_bitcoin_utils)

	AC_MSG_CHECKING([whether to build libraries])
	AM_CONDITIONAL([BUILD_BITCOIN_LIBS], [test x$build_bitcoin_libs = xyes])
	if test x$build_bitcoin_libs = xyes; then
	AC_DEFINE(HAVE_CONSENSUS_LIB, 1, [Define this symbol if the consensus lib has been built])
	AC_CONFIG_FILES([libbitcoinconsensus.pc:libbitcoinconsensus.pc.in])
	fi
	AC_MSG_RESULT($build_bitcoin_libs)

	AC_LANG_POP

	if test "x$use_ccache" != "xno"; then
	AC_MSG_CHECKING(if ccache should be used)
	if test x$CCACHE = x; then
	if test "x$use_ccache" = "xyes"; then
	AC_MSG_ERROR([ccache not found.]);
	else
	use_ccache=no
	fi
	else
	use_ccache=yes
	CC="$ac_cv_path_CCACHE $CC"
	CXX="$ac_cv_path_CCACHE $CXX"
	fi
	AC_MSG_RESULT($use_ccache)
	fi
	if test "x$use_ccache" = "xyes"; then
	AX_CHECK_PREPROC_FLAG([-Qunused-arguments],[CPPFLAGS="-Qunused-arguments $CPPFLAGS"])
	fi

	dnl enable wallet
	AC_MSG_CHECKING([if wallet should be enabled])
	if test x$enable_wallet != xno; then
	AC_MSG_RESULT(yes)
	AC_DEFINE_UNQUOTED([ENABLE_WALLET],[1],[Define to 1 to enable wallet functions])

	else
	AC_MSG_RESULT(no)
	fi

	dnl enable upnp support
	AC_MSG_CHECKING([whether to build with support for UPnP])
	if test x$have_miniupnpc = xno; then
	if test x$use_upnp = xyes; then
	AC_MSG_ERROR("UPnP requested but cannot be built. use --without-miniupnpc")
	fi
	AC_MSG_RESULT(no)
	else
	if test x$use_upnp != xno; then
	AC_MSG_RESULT(yes)
	AC_MSG_CHECKING([whether to build with UPnP enabled by default])
	use_upnp=yes
	upnp_setting=0
	if test x$use_upnp_default != xno; then
	use_upnp_default=yes
	upnp_setting=1
	fi
	AC_MSG_RESULT($use_upnp_default)
	AC_DEFINE_UNQUOTED([USE_UPNP],[$upnp_setting],[UPnP support not compiled if undefined, otherwise value (0 or 1) determines default state])
	if test x$TARGET_OS = xwindows; then
	MINIUPNPC_CPPFLAGS="-DSTATICLIB -DMINIUPNP_STATICLIB"
	fi
	else
	AC_MSG_RESULT(no)
	fi
	fi

	dnl these are only used when qt is enabled
	BUILD_TEST_QT=""
	if test x$bitcoin_enable_qt != xno; then
	dnl enable dbus support
	AC_MSG_CHECKING([whether to build GUI with support for D-Bus])
	if test x$bitcoin_enable_qt_dbus != xno; then
	AC_DEFINE([USE_DBUS],[1],[Define if dbus support should be compiled in])
	fi
	AC_MSG_RESULT($bitcoin_enable_qt_dbus)

	dnl enable qr support
	AC_MSG_CHECKING([whether to build GUI with support for QR codes])
	if test x$have_qrencode = xno; then
	if test x$use_qr = xyes; then
	AC_MSG_ERROR("QR support requested but cannot be built. use --without-qrencode")
	fi
	AC_MSG_RESULT(no)
	else
	if test x$use_qr != xno; then
	AC_MSG_RESULT(yes)
	AC_DEFINE([USE_QRCODE],[1],[Define if QR support should be compiled in])
	use_qr=yes
	else
	AC_MSG_RESULT(no)
	fi
	fi

	if test x$XGETTEXT = x; then
	AC_MSG_WARN("xgettext is required to update qt translations")
	fi

	AC_MSG_CHECKING([whether to build test_bitcoin-qt])
	if test x$use_gui_tests$bitcoin_enable_qt_test = xyesyes; then
	AC_MSG_RESULT([yes])
	BUILD_TEST_QT="yes"
	else
	AC_MSG_RESULT([no])
	fi
	fi

	AM_CONDITIONAL([ENABLE_ZMQ], [test "x$use_zmq" = "xyes"])

	AC_MSG_CHECKING([whether to build test_bitcoin])
	if test x$use_tests = xyes; then
	AC_MSG_RESULT([yes])
	BUILD_TEST="yes"
	else
	AC_MSG_RESULT([no])
	BUILD_TEST=""
	fi

	AC_MSG_CHECKING([whether to reduce exports])
	if test x$use_reduce_exports = xyes; then
	AC_MSG_RESULT([yes])
	else
	AC_MSG_RESULT([no])
	fi

	if test x$build_bitcoin_utils$build_bitcoin_libs$build_bitcoind$bitcoin_enable_qt$use_bench$use_tests = xnononononono; then
	AC_MSG_ERROR([No targets! Please specify at least one of: --with-utils --with-libs --with-daemon --with-seeder --with-gui --enable-bench or --enable-tests])
	fi

	AM_CONDITIONAL([TARGET_DARWIN], [test x$TARGET_OS = xdarwin])
	AM_CONDITIONAL([BUILD_DARWIN], [test x$BUILD_OS = xdarwin])
	AM_CONDITIONAL([TARGET_WINDOWS], [test x$TARGET_OS = xwindows])
	AM_CONDITIONAL([ENABLE_WALLET],[test x$enable_wallet = xyes])
	AM_CONDITIONAL([ENABLE_TESTS],[test x$BUILD_TEST = xyes])
	AM_CONDITIONAL([ENABLE_QT],[test x$bitcoin_enable_qt = xyes])
	AM_CONDITIONAL([ENABLE_QT_TESTS],[test x$BUILD_TEST_QT = xyes])
	AM_CONDITIONAL([ENABLE_BENCH],[test x$use_bench = xyes])
	AM_CONDITIONAL([USE_QRCODE], [test x$use_qr = xyes])
	AM_CONDITIONAL([USE_LCOV],[test x$use_lcov = xyes])
	AM_CONDITIONAL([GLIBC_BACK_COMPAT],[test x$use_glibc_compat = xyes])
	AM_CONDITIONAL([HARDEN],[test x$use_hardening = xyes])
	AM_CONDITIONAL([ENABLE_HWCRC32],[test x$enable_hwcrc32 = xyes])
	AM_CONDITIONAL([ENABLE_SSE41],[test x$enable_sse41 = xyes])
	AM_CONDITIONAL([ENABLE_AVX2],[test x$enable_avx2 = xyes])
	AM_CONDITIONAL([ENABLE_SHANI],[test x$enable_shani = xyes])
	AM_CONDITIONAL([USE_ASM],[test x$use_asm = xyes])

	AC_DEFINE(CLIENT_VERSION_MAJOR, _CLIENT_VERSION_MAJOR, [Major version])
	AC_DEFINE(CLIENT_VERSION_MINOR, _CLIENT_VERSION_MINOR, [Minor version])
	AC_DEFINE(CLIENT_VERSION_REVISION, _CLIENT_VERSION_REVISION, [Build revision])
	AC_DEFINE(CLIENT_VERSION_BUILD, _CLIENT_VERSION_BUILD, [Version Build])
	AC_DEFINE(CLIENT_VERSION_IS_RELEASE, _CLIENT_VERSION_IS_RELEASE, [Version is release])
	AC_DEFINE(COPYRIGHT_YEAR, _COPYRIGHT_YEAR, [Copyright year])
	AC_DEFINE(COPYRIGHT_HOLDERS, "_COPYRIGHT_HOLDERS", [Copyright holder(s) before %s replacement])
	AC_DEFINE(COPYRIGHT_HOLDERS_SUBSTITUTION, "_COPYRIGHT_HOLDERS_SUBSTITUTION", [Replacement for %s in copyright holders string])
	define(_COPYRIGHT_HOLDERS_FINAL, [patsubst(_COPYRIGHT_HOLDERS, [%s], [_COPYRIGHT_HOLDERS_SUBSTITUTION])])
	AC_DEFINE(COPYRIGHT_HOLDERS_FINAL, "_COPYRIGHT_HOLDERS_FINAL", [Copyright holder(s)])
	AC_SUBST(CLIENT_VERSION_MAJOR, _CLIENT_VERSION_MAJOR)
	AC_SUBST(CLIENT_VERSION_MINOR, _CLIENT_VERSION_MINOR)
	AC_SUBST(CLIENT_VERSION_REVISION, _CLIENT_VERSION_REVISION)
	AC_SUBST(CLIENT_VERSION_BUILD, _CLIENT_VERSION_BUILD)
	AC_SUBST(CLIENT_VERSION_IS_RELEASE, _CLIENT_VERSION_IS_RELEASE)
	AC_SUBST(COPYRIGHT_YEAR, _COPYRIGHT_YEAR)
	AC_SUBST(COPYRIGHT_HOLDERS, "_COPYRIGHT_HOLDERS")
	AC_SUBST(COPYRIGHT_HOLDERS_SUBSTITUTION, "_COPYRIGHT_HOLDERS_SUBSTITUTION")
	AC_SUBST(COPYRIGHT_HOLDERS_FINAL, "_COPYRIGHT_HOLDERS_FINAL")
	AC_SUBST(BITCOIN_DAEMON_NAME)
	AC_SUBST(BITCOIN_GUI_NAME)
	AC_SUBST(BITCOIN_CLI_NAME)
	AC_SUBST(BITCOIN_TX_NAME)
	AC_SUBST(BITCOIN_SEEDER_NAME)

	AC_SUBST(RELDFLAGS)
	AC_SUBST(COMPAT_LDFLAGS)
	AC_SUBST(ERROR_CXXFLAGS)
	AC_SUBST(HARDENED_CXXFLAGS)
	AC_SUBST(HARDENED_CPPFLAGS)
	AC_SUBST(HARDENED_LDFLAGS)
	AC_SUBST(PIC_FLAGS)
	AC_SUBST(PIE_FLAGS)
	AC_SUBST(SSE42_CXXFLAGS)
	AC_SUBST(SSE41_CXXFLAGS)
	AC_SUBST(AVX2_CXXFLAGS)
	AC_SUBST(SHANI_CXXFLAGS)
	AC_SUBST(LIBTOOL_APP_LDFLAGS)
	AC_SUBST(USE_UPNP)
	AC_SUBST(USE_QRCODE)
	AC_SUBST(BOOST_LIBS)
	AC_SUBST(TESTDEFS)
	AC_SUBST(LEVELDB_TARGET_FLAGS)
	AC_SUBST(MINIUPNPC_CPPFLAGS)
	AC_SUBST(MINIUPNPC_LIBS)
	AC_SUBST(CRYPTO_LIBS)
	AC_SUBST(SSL_LIBS)
	AC_SUBST(EVENT_LIBS)
	AC_SUBST(EVENT_PTHREADS_LIBS)
	AC_SUBST(ZMQ_LIBS)
	AC_SUBST(PROTOBUF_LIBS)
	AC_SUBST(QR_LIBS)
	AC_CONFIG_FILES([Makefile src/Makefile doc/man/Makefile share/setup.nsi share/qt/Info.plist test/config.ini])
	AC_CONFIG_FILES([contrib/devtools/split-debug.sh],[chmod +x contrib/devtools/split-debug.sh])
	AC_CONFIG_LINKS([test/functional/test_runner.py:test/functional/test_runner.py])
	AC_CONFIG_LINKS([test/util/bitcoin-util-test.py:test/util/bitcoin-util-test.py])

	dnl boost's m4 checks do something really nasty: they export these vars. As a
	dnl result, they leak into secp256k1's configure and crazy things happen.
	dnl Until this is fixed upstream and we've synced, we'll just un-export them.
	CPPFLAGS_TEMP="$CPPFLAGS"
	unset CPPFLAGS
	CPPFLAGS="$CPPFLAGS_TEMP"

	LDFLAGS_TEMP="$LDFLAGS"
	unset LDFLAGS
	LDFLAGS="$LDFLAGS_TEMP"

	LIBS_TEMP="$LIBS"
	unset LIBS
	LIBS="$LIBS_TEMP"

	PKGCONFIG_PATH_TEMP="$PKG_CONFIG_PATH"
	unset PKG_CONFIG_PATH
	PKG_CONFIG_PATH="$PKGCONFIG_PATH_TEMP"

	PKGCONFIG_LIBDIR_TEMP="$PKG_CONFIG_LIBDIR"
	unset PKG_CONFIG_LIBDIR
	PKG_CONFIG_LIBDIR="$PKGCONFIG_LIBDIR_TEMP"

	if test x$need_bundled_univalue = xyes; then
	AC_CONFIG_SUBDIRS([src/univalue])
	fi

	ac_configure_args="${ac_configure_args} --disable-shared --with-pic --with-bignum=no --enable-module-recovery --enable-module-multiset --disable-jni"
	AC_CONFIG_SUBDIRS([src/secp256k1])

	AC_OUTPUT

	dnl Taken from https://wiki.debian.org/RpathIssue
	case $host in
	--linux-gnu)
	AC_MSG_RESULT([Fixing libtool for -rpath problems.])
	sed < libtool > libtool-2 \
	's/^hardcode_libdir_flag_spec.*$'/'hardcode_libdir_flag_spec=" -D__LIBTOOL_IS_A_FOOL__ "/'
	mv libtool-2 libtool
	chmod 755 libtool
	;;
	esac

	dnl Replace the BUILDDIR path with the correct Windows path if compiling on Native Windows
	case ${OS} in
	Windows)
	sed 's/BUILDDIR="\/$[[a-z]]$/BUILDDIR="\1:/' test/config.ini > test/config-2.ini
	mv test/config-2.ini test/config.ini
	;;
	esac

	echo
	echo "Options used to compile and link:"
	echo " with wallet = $enable_wallet"
	echo " with gui / qt = $bitcoin_enable_qt"
	if test x$bitcoin_enable_qt != xno; then
	echo " with qr = $use_qr"
	fi
	echo " with zmq = $use_zmq"
	echo " with test = $use_tests"
	echo " with bench = $use_bench"
	echo " with upnp = $use_upnp"
	echo " use asm = $use_asm"
	echo " debug enabled = $enable_debug"
	echo " werror = $enable_werror"
	echo
	echo " sanitizers "
	echo " asan = $enable_asan"
	echo " tsan = $enable_tsan"
	echo " ubsan = $enable_ubsan"
	echo
	echo " target os = $TARGET_OS"
	echo " build os = $BUILD_OS"
	echo
	echo " CC = $CC"
	echo " CFLAGS = $CFLAGS"
	echo " CPPFLAGS = $CPPFLAGS"
	echo " CXX = $CXX"
	echo " CXXFLAGS = $CXXFLAGS"
	echo " LDFLAGS = $LDFLAGS"
	echo
	diff --git a/doc/release-notes.md b/doc/release-notes.md
	index 07fa0eb34..51b6903d1 100644
	--- a/doc/release-notes.md
	+++ b/doc/release-notes.md
	@@ -1,9 +1,10 @@
	Bitcoin ABC version 0.18.3 is now available from:

	<https://download.bitcoinabc.org/0.18.3/>

	This release includes the following features and fixes:
	- Remove support for Qt4
	- Upgrade reproducible build to us Qt 5.9.6
	- Improve SHA256 performance using SSE4.1, AVX2 and/or SHA if available.
	+ - Add a mode argument to the `getmemoryinfo` RPC call to query `malloc_info` from the system if available.

	diff --git a/src/config/CMakeLists.txt b/src/config/CMakeLists.txt
	index 30d42e6d7..be56672b9 100644
	--- a/src/config/CMakeLists.txt
	+++ b/src/config/CMakeLists.txt
	@@ -1,128 +1,129 @@
	# Copyright (c) 2017-2018 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)

	# Package informations
	set(PACKAGE_NAME "Bitcoin ABC")

	# Version
	set(CLIENT_VERSION_MAJOR 0)
	set(CLIENT_VERSION_MINOR 18)
	set(CLIENT_VERSION_REVISION 3)
	set(CLIENT_VERSION_BUILD 0)

	option(CLIENT_VERSION_IS_RELEASE "Build a release version" OFF)

	# Copyright
	set(COPYRIGHT_YEAR 2018)
	set(COPYRIGHT_HOLDERS "The %s developers")
	set(COPYRIGHT_HOLDERS_SUBSTITUTION Bitcoin)
	string(REPLACE "%s" ${COPYRIGHT_HOLDERS_SUBSTITUTION} COPYRIGHT_HOLDERS_FINAL ${COPYRIGHT_HOLDERS})

	# 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)

	# 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)

	# 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)

	# 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})

	# 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 3fdd9d80a..e599f5df6 100644
	--- a/src/config/bitcoin-config.h.cmake.in
	+++ b/src/config/bitcoin-config.h.cmake.in
	@@ -1,55 +1,56 @@
	// Copyright (c) 2017 The Bitcoin developers

	#ifndef BITCOIN_CONFIG_BITCOIN_CONFIG_H
	#define BITCOIN_CONFIG_BITCOIN_CONFIG_H

	#define PACKAGE_NAME "${PACKAGE_NAME}"

	#define CLIENT_VERSION_MAJOR ${CLIENT_VERSION_MAJOR}
	#define CLIENT_VERSION_MINOR ${CLIENT_VERSION_MINOR}
	#define CLIENT_VERSION_REVISION ${CLIENT_VERSION_REVISION}
	#define CLIENT_VERSION_BUILD ${CLIENT_VERSION_BUILD}
	#cmakedefine01 CLIENT_VERSION_IS_RELEASE

	#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_DECL___BUILTIN_CLZ 1
	#cmakedefine HAVE_DECL___BUILTIN_CLZL 1
	#cmakedefine HAVE_DECL___BUILTIN_CLZLL 1

	#cmakedefine HAVE_MALLOPT_ARENA_MAX 1
	+#cmakedefine HAVE_MALLOC_INFO 1

	#cmakedefine HAVE_DECL_STRNLEN 1
	#cmakedefine HAVE_DECL_DAEMON 1

	#cmakedefine HAVE_DECL_EVP_MD_CTX_NEW 1

	#cmakedefine ENABLE_WALLET 1
	#cmakedefine ENABLE_ZMQ 1

	#endif // BITCOIN_BITCOIN_CONFIG_H
	diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
	index 5fea53dfd..ed7aa41f7 100644
	--- a/src/rpc/misc.cpp
	+++ b/src/rpc/misc.cpp
	@@ -1,653 +1,697 @@
	// Copyright (c) 2010 Satoshi Nakamoto
	// Copyright (c) 2009-2016 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 "rpc/misc.h"
	#include "base58.h"
	#include "clientversion.h"
	#include "config.h"
	#include "dstencode.h"
	#include "init.h"
	#include "net.h"
	#include "netbase.h"
	#include "rpc/blockchain.h"
	#include "rpc/server.h"
	#include "timedata.h"
	#include "util.h"
	#include "utilstrencodings.h"
	#include "validation.h"
	#ifdef ENABLE_WALLET
	#include "wallet/rpcwallet.h"
	#include "wallet/wallet.h"
	#include "wallet/walletdb.h"
	#endif

	#include <univalue.h>

	#include <cstdint>
	+#ifdef HAVE_MALLOC_INFO
	+#include <malloc.h>
	+#endif

	/**
	* @note Do not add or change anything in the information returned by this
	* method. `getinfo` exists for backwards-compatibility only. It combines
	* information from wildly different sources in the program, which is a mess,
	* and is thus planned to be deprecated eventually.
	*
	* Based on the source of the information, new information should be added to:
	* - `getblockchaininfo`,
	* - `getnetworkinfo` or
	* - `getwalletinfo`
	*
	* Or alternatively, create a specific query method for the information.
	**/
	static UniValue getinfo(const Config &config, const JSONRPCRequest &request) {
	if (request.fHelp \|\| request.params.size() != 0) {
	throw std::runtime_error(
	"getinfo\n"
	"\nDEPRECATED. Returns an object containing various state info.\n"
	"\nResult:\n"
	"{\n"
	" \"version\": xxxxx, (numeric) the server version\n"
	" \"protocolversion\": xxxxx, (numeric) the protocol version\n"
	" \"walletversion\": xxxxx, (numeric) the wallet version\n"
	" \"balance\": xxxxxxx, (numeric) the total bitcoin "
	"balance of the wallet\n"
	" \"blocks\": xxxxxx, (numeric) the current number of "
	"blocks processed in the server\n"
	" \"timeoffset\": xxxxx, (numeric) the time offset\n"
	" \"connections\": xxxxx, (numeric) the number of "
	"connections\n"
	" \"proxy\": \"host:port\", (string, optional) the proxy used "
	"by the server\n"
	" \"difficulty\": xxxxxx, (numeric) the current difficulty\n"
	" \"testnet\": true\|false, (boolean) if the server is using "
	"testnet or not\n"
	" \"keypoololdest\": xxxxxx, (numeric) the timestamp (seconds "
	"since Unix epoch) of the oldest pre-generated key in the key "
	"pool\n"
	" \"keypoolsize\": xxxx, (numeric) how many new keys are "
	"pre-generated\n"
	" \"unlocked_until\": ttt, (numeric) the timestamp in "
	"seconds since epoch (midnight Jan 1 1970 GMT) that the wallet is "
	"unlocked for transfers, or 0 if the wallet is locked\n"
	" \"paytxfee\": x.xxxx, (numeric) the transaction fee set "
	"in " +
	CURRENCY_UNIT + "/kB\n"
	" \"relayfee\": x.xxxx, (numeric) minimum "
	"relay fee for non-free transactions in " +
	CURRENCY_UNIT +
	"/kB\n"
	" \"errors\": \"...\" (string) any error messages\n"
	"}\n"
	"\nExamples:\n" +
	HelpExampleCli("getinfo", "") + HelpExampleRpc("getinfo", ""));
	}

	#ifdef ENABLE_WALLET
	CWallet *const pwallet = GetWalletForJSONRPCRequest(request);

	LOCK2(cs_main, pwallet ? &pwallet->cs_wallet : nullptr);
	#else
	LOCK(cs_main);
	#endif

	proxyType proxy;
	GetProxy(NET_IPV4, proxy);

	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("version", CLIENT_VERSION));
	obj.push_back(Pair("protocolversion", PROTOCOL_VERSION));
	#ifdef ENABLE_WALLET
	if (pwallet) {
	obj.push_back(Pair("walletversion", pwallet->GetVersion()));
	obj.push_back(Pair("balance", ValueFromAmount(pwallet->GetBalance())));
	}
	#endif
	obj.push_back(Pair("blocks", (int)chainActive.Height()));
	obj.push_back(Pair("timeoffset", GetTimeOffset()));
	if (g_connman) {
	obj.push_back(
	Pair("connections",
	(int)g_connman->GetNodeCount(CConnman::CONNECTIONS_ALL)));
	}
	obj.push_back(Pair("proxy", (proxy.IsValid() ? proxy.proxy.ToStringIPPort()
	: std::string())));
	obj.push_back(Pair("difficulty", double(GetDifficulty(chainActive.Tip()))));
	obj.push_back(Pair("testnet",
	config.GetChainParams().NetworkIDString() ==
	CBaseChainParams::TESTNET));
	#ifdef ENABLE_WALLET
	if (pwallet) {
	obj.push_back(Pair("keypoololdest", pwallet->GetOldestKeyPoolTime()));
	obj.push_back(Pair("keypoolsize", (int)pwallet->GetKeyPoolSize()));
	}
	if (pwallet && pwallet->IsCrypted()) {
	obj.push_back(Pair("unlocked_until", pwallet->nRelockTime));
	}
	obj.push_back(Pair("paytxfee", ValueFromAmount(payTxFee.GetFeePerK())));
	#endif
	obj.push_back(Pair("relayfee",
	ValueFromAmount(config.GetMinFeePerKB().GetFeePerK())));
	obj.push_back(Pair("errors", GetWarnings("statusbar")));
	return obj;
	}

	#ifdef ENABLE_WALLET
	class DescribeAddressVisitor : public boost::static_visitor<UniValue> {
	public:
	CWallet *const pwallet;

	DescribeAddressVisitor(CWallet *_pwallet) : pwallet(_pwallet) {}

	UniValue operator()(const CNoDestination &dest) const {
	return UniValue(UniValue::VOBJ);
	}

	UniValue operator()(const CKeyID &keyID) const {
	UniValue obj(UniValue::VOBJ);
	CPubKey vchPubKey;
	obj.push_back(Pair("isscript", false));
	if (pwallet && pwallet->GetPubKey(keyID, vchPubKey)) {
	obj.push_back(Pair("pubkey", HexStr(vchPubKey)));
	obj.push_back(Pair("iscompressed", vchPubKey.IsCompressed()));
	}
	return obj;
	}

	UniValue operator()(const CScriptID &scriptID) const {
	UniValue obj(UniValue::VOBJ);
	CScript subscript;
	obj.push_back(Pair("isscript", true));
	if (pwallet && pwallet->GetCScript(scriptID, subscript)) {
	std::vector<CTxDestination> addresses;
	txnouttype whichType;
	int nRequired;
	ExtractDestinations(subscript, whichType, addresses, nRequired);
	obj.push_back(Pair("script", GetTxnOutputType(whichType)));
	obj.push_back(
	Pair("hex", HexStr(subscript.begin(), subscript.end())));
	UniValue a(UniValue::VARR);
	for (const CTxDestination &addr : addresses) {
	a.push_back(EncodeDestination(addr));
	}
	obj.push_back(Pair("addresses", a));
	if (whichType == TX_MULTISIG) {
	obj.push_back(Pair("sigsrequired", nRequired));
	}
	}
	return obj;
	}
	};
	#endif

	static UniValue validateaddress(const Config &config,
	const JSONRPCRequest &request) {
	if (request.fHelp \|\| request.params.size() != 1) {
	throw std::runtime_error(
	"validateaddress \"address\"\n"
	"\nReturn information about the given bitcoin address.\n"
	"\nArguments:\n"
	"1. \"address\" (string, required) The bitcoin address to "
	"validate\n"
	"\nResult:\n"
	"{\n"
	" \"isvalid\" : true\|false, (boolean) If the address is "
	"valid or not. If not, this is the only property returned.\n"
	" \"address\" : \"address\", (string) The bitcoin address "
	"validated\n"
	" \"scriptPubKey\" : \"hex\", (string) The hex encoded "
	"scriptPubKey generated by the address\n"
	" \"ismine\" : true\|false, (boolean) If the address is "
	"yours or not\n"
	" \"iswatchonly\" : true\|false, (boolean) If the address is "
	"watchonly\n"
	" \"isscript\" : true\|false, (boolean) If the key is a "
	"script\n"
	" \"pubkey\" : \"publickeyhex\", (string) The hex value of the "
	"raw public key\n"
	" \"iscompressed\" : true\|false, (boolean) If the address is "
	"compressed\n"
	" \"account\" : \"account\" (string) DEPRECATED. The "
	"account associated with the address, \"\" is the default account\n"
	" \"timestamp\" : timestamp, (number, optional) The "
	"creation time of the key if available in seconds since epoch (Jan "
	"1 1970 GMT)\n"
	" \"hdkeypath\" : \"keypath\" (string, optional) The HD "
	"keypath if the key is HD and available\n"
	" \"hdmasterkeyid\" : \"<hash160>\" (string, optional) The "
	"Hash160 of the HD master pubkey\n"
	"}\n"
	"\nExamples:\n" +
	HelpExampleCli("validateaddress",
	"\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"") +
	HelpExampleRpc("validateaddress",
	"\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\""));
	}

	#ifdef ENABLE_WALLET
	CWallet *const pwallet = GetWalletForJSONRPCRequest(request);

	LOCK2(cs_main, pwallet ? &pwallet->cs_wallet : nullptr);
	#else
	LOCK(cs_main);
	#endif

	CTxDestination dest =
	DecodeDestination(request.params[0].get_str(), config.GetChainParams());
	bool isValid = IsValidDestination(dest);

	UniValue ret(UniValue::VOBJ);
	ret.push_back(Pair("isvalid", isValid));
	if (isValid) {
	std::string currentAddress = EncodeDestination(dest);
	ret.push_back(Pair("address", currentAddress));

	CScript scriptPubKey = GetScriptForDestination(dest);
	ret.push_back(Pair("scriptPubKey",
	HexStr(scriptPubKey.begin(), scriptPubKey.end())));

	#ifdef ENABLE_WALLET
	isminetype mine = pwallet ? IsMine(*pwallet, dest) : ISMINE_NO;
	ret.push_back(Pair("ismine", (mine & ISMINE_SPENDABLE) ? true : false));
	ret.push_back(
	Pair("iswatchonly", (mine & ISMINE_WATCH_ONLY) ? true : false));
	UniValue detail =
	boost::apply_visitor(DescribeAddressVisitor(pwallet), dest);
	ret.pushKVs(detail);
	if (pwallet && pwallet->mapAddressBook.count(dest)) {
	ret.push_back(Pair("account", pwallet->mapAddressBook[dest].name));
	}
	if (pwallet) {
	const auto &meta = pwallet->mapKeyMetadata;
	const CKeyID *keyID = boost::get<CKeyID>(&dest);
	auto it = keyID ? meta.find(*keyID) : meta.end();
	if (it == meta.end()) {
	it = meta.find(CScriptID(scriptPubKey));
	}
	if (it != meta.end()) {
	ret.push_back(Pair("timestamp", it->second.nCreateTime));
	if (!it->second.hdKeypath.empty()) {
	ret.push_back(Pair("hdkeypath", it->second.hdKeypath));
	ret.push_back(Pair("hdmasterkeyid",
	it->second.hdMasterKeyID.GetHex()));
	}
	}
	}
	#endif
	}
	return ret;
	}

	// Needed even with !ENABLE_WALLET, to pass (ignored) pointers around
	class CWallet;

	/**
	* Used by addmultisigaddress / createmultisig:
	*/
	CScript createmultisig_redeemScript(CWallet *const pwallet,
	const UniValue &params) {
	int nRequired = params[0].get_int();
	const UniValue &keys = params[1].get_array();

	// Gather public keys
	if (nRequired < 1) {
	throw std::runtime_error(
	"a multisignature address must require at least one key to redeem");
	}
	if ((int)keys.size() < nRequired) {
	throw std::runtime_error(
	strprintf("not enough keys supplied "
	"(got %u keys, but need at least %d to redeem)",
	keys.size(), nRequired));
	}
	if (keys.size() > 16) {
	throw std::runtime_error(
	"Number of addresses involved in the "
	"multisignature address creation > 16\nReduce the "
	"number");
	}
	std::vector<CPubKey> pubkeys;
	pubkeys.resize(keys.size());
	for (size_t i = 0; i < keys.size(); i++) {
	const std::string &ks = keys[i].get_str();
	#ifdef ENABLE_WALLET
	// Case 1: Bitcoin address and we have full public key:
	if (pwallet) {
	CTxDestination dest = DecodeDestination(ks, pwallet->chainParams);
	if (IsValidDestination(dest)) {
	const CKeyID *keyID = boost::get<CKeyID>(&dest);
	if (!keyID) {
	throw std::runtime_error(
	strprintf("%s does not refer to a key", ks));
	}
	CPubKey vchPubKey;
	if (!pwallet->GetPubKey(*keyID, vchPubKey)) {
	throw std::runtime_error(
	strprintf("no full public key for address %s", ks));
	}
	if (!vchPubKey.IsFullyValid()) {
	throw std::runtime_error(" Invalid public key: " + ks);
	}
	pubkeys[i] = vchPubKey;
	continue;
	}
	}
	#endif
	// Case 2: hex public key
	if (IsHex(ks)) {
	CPubKey vchPubKey(ParseHex(ks));
	if (!vchPubKey.IsFullyValid()) {
	throw std::runtime_error(" Invalid public key: " + ks);
	}
	pubkeys[i] = vchPubKey;
	} else {
	throw std::runtime_error(" Invalid public key: " + ks);
	}
	}

	CScript result = GetScriptForMultisig(nRequired, pubkeys);
	if (result.size() > MAX_SCRIPT_ELEMENT_SIZE) {
	throw std::runtime_error(
	strprintf("redeemScript exceeds size limit: %d > %d", result.size(),
	MAX_SCRIPT_ELEMENT_SIZE));
	}

	return result;
	}

	static UniValue createmultisig(const Config &config,
	const JSONRPCRequest &request) {
	#ifdef ENABLE_WALLET
	CWallet *const pwallet = GetWalletForJSONRPCRequest(request);
	#else
	CWallet *const pwallet = nullptr;
	#endif

	if (request.fHelp \|\| request.params.size() < 2 \|\|
	request.params.size() > 2) {
	std::string msg =
	"createmultisig nrequired [\"key\",...]\n"
	"\nCreates a multi-signature address with n signature of m keys "
	"required.\n"
	"It returns a json object with the address and redeemScript.\n"

	"\nArguments:\n"
	"1. nrequired (numeric, required) The number of required "
	"signatures out of the n keys or addresses.\n"
	"2. \"keys\" (string, required) A json array of keys which "
	"are bitcoin addresses or hex-encoded public keys\n"
	" [\n"
	" \"key\" (string) bitcoin address or hex-encoded public "
	"key\n"
	" ,...\n"
	" ]\n"

	"\nResult:\n"
	"{\n"
	" \"address\":\"multisigaddress\", (string) The value of the new "
	"multisig address.\n"
	" \"redeemScript\":\"script\" (string) The string value of "
	"the hex-encoded redemption script.\n"
	"}\n"

	"\nExamples:\n"
	"\nCreate a multisig address from 2 addresses\n" +
	HelpExampleCli("createmultisig",
	"2 "
	"\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
	"\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"") +
	"\nAs a json rpc call\n" +
	HelpExampleRpc("createmultisig",
	"2, "
	"\"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\","
	"\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"");
	throw std::runtime_error(msg);
	}

	// Construct using pay-to-script-hash:
	CScript inner = createmultisig_redeemScript(pwallet, request.params);
	CScriptID innerID(inner);

	UniValue result(UniValue::VOBJ);
	result.push_back(Pair("address", EncodeDestination(innerID)));
	result.push_back(Pair("redeemScript", HexStr(inner.begin(), inner.end())));

	return result;
	}

	static UniValue verifymessage(const Config &config,
	const JSONRPCRequest &request) {
	if (request.fHelp \|\| request.params.size() != 3) {
	throw std::runtime_error(
	"verifymessage \"address\" \"signature\" \"message\"\n"
	"\nVerify a signed message\n"
	"\nArguments:\n"
	"1. \"address\" (string, required) The bitcoin address to "
	"use for the signature.\n"
	"2. \"signature\" (string, required) The signature provided "
	"by the signer in base 64 encoding (see signmessage).\n"
	"3. \"message\" (string, required) The message that was "
	"signed.\n"
	"\nResult:\n"
	"true\|false (boolean) If the signature is verified or not.\n"
	"\nExamples:\n"
	"\nUnlock the wallet for 30 seconds\n" +
	HelpExampleCli("walletpassphrase", "\"mypassphrase\" 30") +
	"\nCreate the signature\n" +
	HelpExampleCli(
	"signmessage",
	"\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\" \"my message\"") +
	"\nVerify the signature\n" +
	HelpExampleCli("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4"
	"XX\" \"signature\" \"my "
	"message\"") +
	"\nAs json rpc\n" +
	HelpExampleRpc("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4"
	"XX\", \"signature\", \"my "
	"message\""));
	}

	LOCK(cs_main);

	std::string strAddress = request.params[0].get_str();
	std::string strSign = request.params[1].get_str();
	std::string strMessage = request.params[2].get_str();

	CTxDestination destination =
	DecodeDestination(strAddress, config.GetChainParams());
	if (!IsValidDestination(destination)) {
	throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
	}

	const CKeyID *keyID = boost::get<CKeyID>(&destination);
	if (!keyID) {
	throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
	}

	bool fInvalid = false;
	std::vector<uint8_t> vchSig = DecodeBase64(strSign.c_str(), &fInvalid);

	if (fInvalid) {
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
	"Malformed base64 encoding");
	}

	CHashWriter ss(SER_GETHASH, 0);
	ss << strMessageMagic;
	ss << strMessage;

	CPubKey pubkey;
	if (!pubkey.RecoverCompact(ss.GetHash(), vchSig)) {
	return false;
	}

	return (pubkey.GetID() == *keyID);
	}

	static UniValue signmessagewithprivkey(const Config &config,
	const JSONRPCRequest &request) {
	if (request.fHelp \|\| request.params.size() != 2) {
	throw std::runtime_error(
	"signmessagewithprivkey \"privkey\" \"message\"\n"
	"\nSign a message with the private key of an address\n"
	"\nArguments:\n"
	"1. \"privkey\" (string, required) The private key to sign "
	"the message with.\n"
	"2. \"message\" (string, required) The message to create a "
	"signature of.\n"
	"\nResult:\n"
	"\"signature\" (string) The signature of the message "
	"encoded in base 64\n"
	"\nExamples:\n"
	"\nCreate the signature\n" +
	HelpExampleCli("signmessagewithprivkey",
	"\"privkey\" \"my message\"") +
	"\nVerify the signature\n" +
	HelpExampleCli("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4"
	"XX\" \"signature\" \"my "
	"message\"") +
	"\nAs json rpc\n" + HelpExampleRpc("signmessagewithprivkey",
	"\"privkey\", \"my message\""));
	}

	std::string strPrivkey = request.params[0].get_str();
	std::string strMessage = request.params[1].get_str();

	CBitcoinSecret vchSecret;
	bool fGood = vchSecret.SetString(strPrivkey);
	if (!fGood) {
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");
	}
	CKey key = vchSecret.GetKey();
	if (!key.IsValid()) {
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
	"Private key outside allowed range");
	}

	CHashWriter ss(SER_GETHASH, 0);
	ss << strMessageMagic;
	ss << strMessage;

	std::vector<uint8_t> vchSig;
	if (!key.SignCompact(ss.GetHash(), vchSig)) {
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");
	}

	return EncodeBase64(&vchSig[0], vchSig.size());
	}

	static UniValue setmocktime(const Config &config,
	const JSONRPCRequest &request) {
	if (request.fHelp \|\| request.params.size() != 1) {
	throw std::runtime_error(
	"setmocktime timestamp\n"
	"\nSet the local time to given timestamp (-regtest only)\n"
	"\nArguments:\n"
	"1. timestamp (integer, required) Unix seconds-since-epoch "
	"timestamp\n"
	" Pass 0 to go back to using the system time.");
	}

	if (!config.GetChainParams().MineBlocksOnDemand()) {
	throw std::runtime_error(
	"setmocktime for regression testing (-regtest mode) only");
	}

	// For now, don't change mocktime if we're in the middle of validation, as
	// this could have an effect on mempool time-based eviction, as well as
	// IsCurrentForFeeEstimation() and IsInitialBlockDownload().
	// TODO: figure out the right way to synchronize around mocktime, and
	// ensure all callsites of GetTime() are accessing this safely.
	LOCK(cs_main);

	RPCTypeCheck(request.params, {UniValue::VNUM});
	SetMockTime(request.params[0].get_int64());

	return NullUniValue;
	}

	static UniValue RPCLockedMemoryInfo() {
	LockedPool::Stats stats = LockedPoolManager::Instance().stats();
	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("used", uint64_t(stats.used)));
	obj.push_back(Pair("free", uint64_t(stats.free)));
	obj.push_back(Pair("total", uint64_t(stats.total)));
	obj.push_back(Pair("locked", uint64_t(stats.locked)));
	obj.push_back(Pair("chunks_used", uint64_t(stats.chunks_used)));
	obj.push_back(Pair("chunks_free", uint64_t(stats.chunks_free)));
	return obj;
	}

	+#ifdef HAVE_MALLOC_INFO
	+static std::string RPCMallocInfo() {
	+ char *ptr = nullptr;
	+ size_t size = 0;
	+ FILE *f = open_memstream(&ptr, &size);
	+ if (f) {
	+ malloc_info(0, f);
	+ fclose(f);
	+ if (ptr) {
	+ std::string rv(ptr, size);
	+ free(ptr);
	+ return rv;
	+ }
	+ }
	+ return "";
	+}
	+#endif
	+
	static UniValue getmemoryinfo(const Config &config,
	const JSONRPCRequest &request) {
	/* Please, avoid using the word "pool" here in the RPC interface or help,
	* as users will undoubtedly confuse it with the other "memory pool"
	*/
	- if (request.fHelp \|\| request.params.size() != 0) {
	+ if (request.fHelp \|\| request.params.size() > 1) {
	throw std::runtime_error(
	- "getmemoryinfo\n"
	+ "getmemoryinfo (\"mode\")\n"
	"Returns an object containing information about memory usage.\n"
	- "\nResult:\n"
	+ "Arguments:\n"
	+ "1. \"mode\" determines what kind of information is returned. This "
	+ "argument is optional, the default mode is \"stats\".\n"
	+ " - \"stats\" returns general statistics about memory usage in "
	+ "the daemon.\n"
	+ " - \"mallocinfo\" returns an XML string describing low-level "
	+ "heap state (only available if compiled with glibc 2.10+).\n"
	+ "\nResult (mode \"stats\"):\n"
	"{\n"
	" \"locked\": { (json object) Information about "
	"locked memory manager\n"
	" \"used\": xxxxx, (numeric) Number of bytes used\n"
	" \"free\": xxxxx, (numeric) Number of bytes available "
	"in current arenas\n"
	" \"total\": xxxxxxx, (numeric) Total number of bytes "
	"managed\n"
	" \"locked\": xxxxxx, (numeric) Amount of bytes that "
	"succeeded locking. If this number is smaller than total, locking "
	"pages failed at some point and key data could be swapped to "
	"disk.\n"
	" \"chunks_used\": xxxxx, (numeric) Number allocated chunks\n"
	" \"chunks_free\": xxxxx, (numeric) Number unused chunks\n"
	" }\n"
	"}\n"
	+ "\nResult (mode \"mallocinfo\"):\n"
	+ "\"<malloc version=\"1\">...\"\n"
	"\nExamples:\n" +
	HelpExampleCli("getmemoryinfo", "") +
	HelpExampleRpc("getmemoryinfo", ""));
	}

	- UniValue obj(UniValue::VOBJ);
	- obj.push_back(Pair("locked", RPCLockedMemoryInfo()));
	- return obj;
	+ std::string mode = (request.params.size() < 1 \|\| request.params[0].isNull())
	+ ? "stats"
	+ : request.params[0].get_str();
	+ if (mode == "stats") {
	+ UniValue obj(UniValue::VOBJ);
	+ obj.push_back(Pair("locked", RPCLockedMemoryInfo()));
	+ return obj;
	+ } else if (mode == "mallocinfo") {
	+#ifdef HAVE_MALLOC_INFO
	+ return RPCMallocInfo();
	+#else
	+ throw JSONRPCError(
	+ RPC_INVALID_PARAMETER,
	+ "mallocinfo is only available when compiled with glibc 2.10+");
	+#endif
	+ } else {
	+ throw JSONRPCError(RPC_INVALID_PARAMETER, "unknown mode " + mode);
	+ }
	}

	static UniValue echo(const Config &config, const JSONRPCRequest &request) {
	if (request.fHelp) {
	throw std::runtime_error(
	"echo\|echojson \"message\" ...\n"
	"\nSimply echo back the input arguments. This command is for "
	"testing.\n"
	"\nThe difference between echo and echojson is that echojson has "
	"argument conversion enabled in the client-side table in"
	"bitcoin-cli and the GUI. There is no server-side difference.");
	}

	return request.params;
	}

	// clang-format off
	static const ContextFreeRPCCommand commands[] = {
	// category name actor (function) okSafeMode
	// ------------------- ------------------------ ---------------------- ----------
	{ "control", "getinfo", getinfo, true, {} }, /* uses wallet if enabled */
	- { "control", "getmemoryinfo", getmemoryinfo, true, {} },
	+ { "control", "getmemoryinfo", getmemoryinfo, true, {"mode"} },
	{ "util", "validateaddress", validateaddress, true, {"address"} }, /* uses wallet if enabled */
	{ "util", "createmultisig", createmultisig, true, {"nrequired","keys"} },
	{ "util", "verifymessage", verifymessage, true, {"address","signature","message"} },
	{ "util", "signmessagewithprivkey", signmessagewithprivkey, true, {"privkey","message"} },
	-
	/* Not shown in help */
	{ "hidden", "setmocktime", setmocktime, true, {"timestamp"}},
	{ "hidden", "echo", echo, true, {"arg0","arg1","arg2","arg3","arg4","arg5","arg6","arg7","arg8","arg9"}},
	{ "hidden", "echojson", echo, true, {"arg0","arg1","arg2","arg3","arg4","arg5","arg6","arg7","arg8","arg9"}},
	};
	// clang-format on

	void RegisterMiscRPCCommands(CRPCTable &t) {
	for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
	t.appendCommand(commands[vcidx].name, &commands[vcidx]);
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Apr 17, 03:26 (8 h, 22 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5508698
Default Alt Text: (86 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions