diff -Nru bitcoinabc-0.21.11/cmake/modules/InstallationHelper.cmake bitcoinabc-0.21.12/cmake/modules/InstallationHelper.cmake
--- bitcoinabc-0.21.11/cmake/modules/InstallationHelper.cmake	2020-05-04 17:57:49.000000000 +0000
+++ bitcoinabc-0.21.12/cmake/modules/InstallationHelper.cmake	2020-07-17 16:19:01.000000000 +0000
@@ -8,15 +8,19 @@
 		RUNTIME
 			DESTINATION "${CMAKE_INSTALL_BINDIR}"
 			COMPONENT ${PROJECT_NAME}
+			${ARGN}
 		ARCHIVE
 			DESTINATION "${CMAKE_INSTALL_LIBDIR}"
 			COMPONENT ${PROJECT_NAME}
+			${ARGN}
 		LIBRARY
 			DESTINATION "${CMAKE_INSTALL_LIBDIR}"
 			COMPONENT ${PROJECT_NAME}
+			${ARGN}
 		PUBLIC_HEADER
 			DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
 			COMPONENT ${PROJECT_NAME}
+			${ARGN}
 	)
 endfunction()
 
diff -Nru bitcoinabc-0.21.11/cmake/modules/TestSuite.cmake bitcoinabc-0.21.12/cmake/modules/TestSuite.cmake
--- bitcoinabc-0.21.11/cmake/modules/TestSuite.cmake	2020-07-07 17:16:37.000000000 +0000
+++ bitcoinabc-0.21.12/cmake/modules/TestSuite.cmake	2020-07-28 23:45:00.000000000 +0000
@@ -59,7 +59,7 @@
 	add_test_custom_target(${TARGET}
 		TEST_COMMAND
 			"${CMAKE_SOURCE_DIR}/cmake/utils/test_wrapper.sh"
-			"${NAME}.log"
+			"${SUITE}-${NAME}.log"
 			${CMAKE_CROSSCOMPILING_EMULATOR} "$<TARGET_FILE:${EXECUTABLE}>" ${ARGN}
 		CUSTOM_TARGET_ARGS
 			COMMENT "${SUITE}: testing ${NAME}"
diff -Nru bitcoinabc-0.21.11/CMakeLists.txt bitcoinabc-0.21.12/CMakeLists.txt
--- bitcoinabc-0.21.11/CMakeLists.txt	2020-07-14 16:56:53.000000000 +0000
+++ bitcoinabc-0.21.12/CMakeLists.txt	2020-07-28 23:45:00.000000000 +0000
@@ -7,7 +7,7 @@
 )
 
 project(bitcoin-abc
-	VERSION 0.21.11
+	VERSION 0.21.12
 	DESCRIPTION "Bitcoin ABC is a full node implementation of the Bitcoin Cash protocol."
 	HOMEPAGE_URL "https://www.bitcoinabc.org"
 )
diff -Nru bitcoinabc-0.21.11/configure.ac bitcoinabc-0.21.12/configure.ac
--- bitcoinabc-0.21.11/configure.ac	2020-07-14 16:56:53.000000000 +0000
+++ bitcoinabc-0.21.12/configure.ac	2020-07-28 23:45:00.000000000 +0000
@@ -2,7 +2,7 @@
 AC_PREREQ([2.60])
 define(_CLIENT_VERSION_MAJOR, 0)
 define(_CLIENT_VERSION_MINOR, 21)
-define(_CLIENT_VERSION_REVISION, 11)
+define(_CLIENT_VERSION_REVISION, 12)
 define(_CLIENT_VERSION_IS_RELEASE, true)
 define(_COPYRIGHT_YEAR, 2020)
 define(_COPYRIGHT_HOLDERS,[The %s developers])
diff -Nru bitcoinabc-0.21.11/contrib/CMakeLists.txt bitcoinabc-0.21.12/contrib/CMakeLists.txt
--- bitcoinabc-0.21.11/contrib/CMakeLists.txt	2020-05-04 17:57:49.000000000 +0000
+++ bitcoinabc-0.21.12/contrib/CMakeLists.txt	2020-07-20 23:11:19.000000000 +0000
@@ -10,6 +10,7 @@
 	# Subdirectories
 	"debian/"
 	"gitian/"
+	"gitian-builder/"
 	"gitian-descriptors/"
 	"qos/"
 	"seeds/"
diff -Nru bitcoinabc-0.21.11/contrib/devtools/chainparams/chainparams_main.txt bitcoinabc-0.21.12/contrib/devtools/chainparams/chainparams_main.txt
--- bitcoinabc-0.21.11/contrib/devtools/chainparams/chainparams_main.txt	2020-07-09 15:34:59.000000000 +0000
+++ bitcoinabc-0.21.12/contrib/devtools/chainparams/chainparams_main.txt	2020-07-27 15:24:34.000000000 +0000
@@ -1,4 +1,4 @@
-0000000000000000013add16221ff595c977de1027c8c3f962acf8fcdfa05065
-0000000000000000000000000000000000000000013b3489eb103468fa735866
-204
+000000000000000001831f2498ccf63ab3153bf6046362513832a0ac8008c16e
+0000000000000000000000000000000000000000013e03edc46165e17570aac7
+205
 3
diff -Nru bitcoinabc-0.21.11/contrib/devtools/chainparams/chainparams_test.txt bitcoinabc-0.21.12/contrib/devtools/chainparams/chainparams_test.txt
--- bitcoinabc-0.21.11/contrib/devtools/chainparams/chainparams_test.txt	2020-07-09 15:34:59.000000000 +0000
+++ bitcoinabc-0.21.12/contrib/devtools/chainparams/chainparams_test.txt	2020-07-27 15:24:34.000000000 +0000
@@ -1,4 +1,4 @@
-0000000000190c28546af514f5255d8afae5c5f756e191e9b8e9724a1e256e61
-0000000000000000000000000000000000000000000000682bd38e9265377ec0
+0000000031bedd3009e21403ad61614af5237093f8a794c7c7c1dd5d312fc61e
+00000000000000000000000000000000000000000000006983387157261b3275
 55
 2
diff -Nru bitcoinabc-0.21.11/contrib/devtools/symbol-check.py bitcoinabc-0.21.12/contrib/devtools/symbol-check.py
--- bitcoinabc-0.21.11/contrib/devtools/symbol-check.py	2020-06-08 20:54:42.000000000 +0000
+++ bitcoinabc-0.21.12/contrib/devtools/symbol-check.py	2020-07-20 23:11:19.000000000 +0000
@@ -9,7 +9,7 @@
 
 Example usage:
 
-    find ../gitian-builder/build -type f -executable | xargs python3 contrib/devtools/symbol-check.py
+    find contrib/gitian-builder/build -type f -executable | xargs python3 contrib/devtools/symbol-check.py
 '''
 import subprocess
 import re
diff -Nru bitcoinabc-0.21.11/contrib/release/debian-packages.sh bitcoinabc-0.21.12/contrib/release/debian-packages.sh
--- bitcoinabc-0.21.11/contrib/release/debian-packages.sh	2020-07-14 17:36:12.000000000 +0000
+++ bitcoinabc-0.21.12/contrib/release/debian-packages.sh	2020-07-15 16:45:51.000000000 +0000
@@ -4,34 +4,47 @@
 
 set -euo pipefail
 
+DEFAULT_DISTROS=()
+# Bionic: Ubuntu 18.04 LTS
+DEFAULT_DISTROS+=("bionic")
+# Eoan: Ubuntu 19.10
+DEFAULT_DISTROS+=("eoan")
+# Focal: Ubuntu 20.04 LTS
+DEFAULT_DISTROS+=("focal")
+
 DEFAULT_PPA="bitcoin-abc"
 DPUT_CONFIG_FILE=~/".dput.cf"
 TOPLEVEL="$(git rev-parse --show-toplevel)"
 KEYS_TXT="${TOPLEVEL}"/contrib/gitian-signing/keys.txt
 
 help_message() {
-  echo "Build and sign Debian packages and push to a PPA."
-  echo "Usage: $0 <options> signer"
-  echo
-  echo "Example usage: $0 jasonbcox"
-  echo
-  echo "signer will be used to fetch the signing key fingerprint from '${KEYS_TXT}'"
-  echo "  That matching fingerprint will be used to fetch the correctly formatted name and email from GPG."
-  echo "  signer must at least partially match the fingerprint or email in keys.txt"
-  echo
-  echo "Note: This script will prompt you to sign with your PGP key."
-  echo
-  echo "-d, --dry-run             Build and sign the packages, but do not push them to the PPA."
-  echo "-h, --help                Display this help message."
-  echo "-p, --ppa <ppa-name>      PPA hostname. Defaults to: '${DEFAULT_PPA}'. If no config file exists at ${DPUT_CONFIG_FILE}"
-  echo "                            then one will be created using '${DEFAULT_PPA}'. Setting this option to a hostname other than"
-  echo "                            the default will require that you add the necessary settings to the config file."
-  echo "-v, --version <version>   Set the package version. Defaults to the version returned by 'bitcoind --version'."
-  echo "                            If set, version must be of the form: MAJOR.MINOR.REVISION[.OPTIONALPATCH]"
-  echo "                            OPTIONALPATCH may be necessary when source files have changed but the version revision has not,"
-  echo "                            as the PPA will reject source archives of the same name."
+cat <<EOF
+Build and sign Debian packages and push to a PPA.
+Usage: $0 <options> signer
+
+Example usage: $0 jasonbcox
+
+signer will be used to fetch the signing key fingerprint from '${KEYS_TXT}'
+  That matching fingerprint will be used to fetch the correctly formatted name and email from GPG.
+  signer must at least partially match the fingerprint or email in keys.txt
+
+Note: This script will prompt you to sign with your PGP key.
+
+-d, --dry-run             Build and sign the packages, but do not push them to the PPA.
+-D, --distro <name>       Name of the distribution to package for. Can be supplied multiple times.
+                            If supplied at least once, the defaults are ignored. Defaults to: '${DEFAULT_DISTROS[@]}'
+-h, --help                Display this help message.
+-p, --ppa <ppa-name>      PPA hostname. Defaults to: '${DEFAULT_PPA}'. If no config file exists at ${DPUT_CONFIG_FILE}
+                            then one will be created using '${DEFAULT_PPA}'. Setting this option to a hostname other than
+                            the default will require that you add the necessary settings to the config file.
+-v, --version <version>   Set the package version. Defaults to the version returned by 'bitcoind --version'.
+                            If set, version must be of the form: MAJOR.MINOR.REVISION[.OPTIONALPATCH]
+                            OPTIONALPATCH may be necessary when source files have changed but the version revision has not,
+                            as the PPA will reject source archives of the same name.
+EOF
 }
 
+DISTROS=()
 DRY_RUN="false"
 NUM_EXPECTED_ARGUMENTS=1
 PACKAGE_VERSION=""
@@ -44,6 +57,11 @@
     DRY_RUN="true"
     shift # shift past argument
     ;;
+  -D|--distro)
+    DISTROS+=("$2")
+    shift # shift past argument
+    shift # shift past value
+    ;;
   -h|--help)
     help_message
     exit 0
@@ -92,6 +110,11 @@
   exit 20
 fi
 
+# If no distributions are explicitly set, use the defaults
+if [ "${#DISTROS[@]}" == 0 ]; then
+  DISTROS=("${DEFAULT_DISTROS[@]}")
+fi
+
 SIGNER_FINGERPRINT=$(grep "$1" "${KEYS_TXT}" | cut -d' ' -f 1) || {
   echo "Error: Signer '$1' does not match any line in '${KEYS_TXT}'"
   exit 21
@@ -182,11 +205,7 @@
   fi
 }
 
-# Bionic: Ubuntu 18.04 LTS
-package "bionic"
-# Eoan: Ubuntu 19.10
-package "eoan"
-# Focal: Ubuntu 20.04 LTS
-package "focal"
-
+for DISTRO in "${DISTROS[@]}"; do
+  package "${DISTRO}"
+done
 popd
diff -Nru bitcoinabc-0.21.11/debian/changelog bitcoinabc-0.21.12/debian/changelog
--- bitcoinabc-0.21.11/debian/changelog	2020-07-14 18:44:13.000000000 +0000
+++ bitcoinabc-0.21.12/debian/changelog	2020-07-28 23:48:00.000000000 +0000
@@ -1,5 +1,5 @@
-bitcoinabc (0.21.11-eoan) eoan; urgency=medium
+bitcoinabc (0.21.12-eoan) eoan; urgency=medium
 
   * New upstream release.
 
- -- Jason B. Cox <jasonbcox@bitcoinabc.org>  Tue, 14 Jul 2020 11:44:13 -0700
+ -- Jason B. Cox <jasonbcox@bitcoinabc.org>  Tue, 28 Jul 2020 16:48:00 -0700
diff -Nru bitcoinabc-0.21.11/debian/compat bitcoinabc-0.21.12/debian/compat
--- bitcoinabc-0.21.11/debian/compat	2020-07-14 18:44:13.000000000 +0000
+++ bitcoinabc-0.21.12/debian/compat	2020-07-28 23:48:00.000000000 +0000
@@ -1 +1 @@
-9
+12
diff -Nru bitcoinabc-0.21.11/debian/control bitcoinabc-0.21.12/debian/control
--- bitcoinabc-0.21.11/debian/control	2020-07-14 18:44:13.000000000 +0000
+++ bitcoinabc-0.21.12/debian/control	2020-07-28 23:48:00.000000000 +0000
@@ -4,7 +4,7 @@
 Maintainer: Bitcoin ABC Package Maintainers <package-maintainers@bitcoinabc.org>
 Uploaders: Jason B. Cox <jasonbcox@bitcoinabc.org>
 Build-Depends: cmake (>= 3.13),
- debhelper,
+ debhelper (>=12.1),
  devscripts,
  git,
  libdb5.3++-dev,
@@ -20,6 +20,7 @@
  libqrencode-dev,
  libssl-dev,
  libzmq3-dev,
+ ninja-build,
  protobuf-compiler,
  python3,
  qttools5-dev,
diff -Nru bitcoinabc-0.21.11/debian/rules bitcoinabc-0.21.12/debian/rules
--- bitcoinabc-0.21.11/debian/rules	2020-07-14 18:44:13.000000000 +0000
+++ bitcoinabc-0.21.12/debian/rules	2020-07-28 23:48:00.000000000 +0000
@@ -2,7 +2,10 @@
 # -*- mode: makefile; coding: utf-8 -*-
 
 %:
-	dh $@ --buildsystem=cmake
+	dh $@ --buildsystem=cmake+ninja --builddirectory=_build
+
+override_dh_auto_configure:
+	dh_auto_configure -- -DCMAKE_BUILD_TYPE=RelWithDebInfo -DUSE_JEMALLOC=OFF
 
 override_dh_auto_test:
-	echo "Temporarily skipped due to segfault in tests."
+	ninja -C _build check
diff -Nru bitcoinabc-0.21.11/doc/man/bitcoin-cli.1 bitcoinabc-0.21.12/doc/man/bitcoin-cli.1
--- bitcoinabc-0.21.11/doc/man/bitcoin-cli.1	2020-07-13 17:51:00.000000000 +0000
+++ bitcoinabc-0.21.12/doc/man/bitcoin-cli.1	2020-07-27 15:24:34.000000000 +0000
@@ -1,7 +1,7 @@
 .\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.8.
-.TH BITCOIN-CLI "1" "July 2020" "bitcoin-cli v0.21.11" "User Commands"
+.TH BITCOIN-CLI "1" "July 2020" "bitcoin-cli v0.21.12" "User Commands"
 .SH NAME
-bitcoin-cli \- manual page for bitcoin-cli v0.21.11
+bitcoin-cli \- manual page for bitcoin-cli v0.21.12
 .SH SYNOPSIS
 .B bitcoin-cli
 [\fI\,options\/\fR] \fI\,<command> \/\fR[\fI\,params\/\fR]  \fI\,Send command to Bitcoin ABC\/\fR
@@ -15,7 +15,7 @@
 .B bitcoin-cli
 [\fI\,options\/\fR] \fI\,help <command>      Get help for a command\/\fR
 .SH DESCRIPTION
-Bitcoin ABC RPC client version v0.21.11
+Bitcoin ABC RPC client version v0.21.12
 .SH OPTIONS
 .HP
 \-?
diff -Nru bitcoinabc-0.21.11/doc/man/bitcoind.1 bitcoinabc-0.21.12/doc/man/bitcoind.1
--- bitcoinabc-0.21.11/doc/man/bitcoind.1	2020-07-13 17:51:00.000000000 +0000
+++ bitcoinabc-0.21.12/doc/man/bitcoind.1	2020-07-27 15:24:34.000000000 +0000
@@ -1,12 +1,12 @@
 .\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.8.
-.TH BITCOIND "1" "July 2020" "bitcoind v0.21.11" "User Commands"
+.TH BITCOIND "1" "July 2020" "bitcoind v0.21.12" "User Commands"
 .SH NAME
-bitcoind \- manual page for bitcoind v0.21.11
+bitcoind \- manual page for bitcoind v0.21.12
 .SH SYNOPSIS
 .B bitcoind
 [\fI\,options\/\fR]                     \fI\,Start Bitcoin ABC Daemon\/\fR
 .SH DESCRIPTION
-Bitcoin ABC Daemon version v0.21.11
+Bitcoin ABC Daemon version v0.21.12
 .SH OPTIONS
 .HP
 \-?
@@ -23,9 +23,9 @@
 If this block is in the chain assume that it and its ancestors are valid
 and potentially skip their script verification (0 to verify all,
 default:
-0000000000000000013add16221ff595c977de1027c8c3f962acf8fcdfa05065,
+000000000000000001831f2498ccf63ab3153bf6046362513832a0ac8008c16e,
 testnet:
-0000000000190c28546af514f5255d8afae5c5f756e191e9b8e9724a1e256e61)
+0000000031bedd3009e21403ad61614af5237093f8a794c7c7c1dd5d312fc61e)
 .HP
 \fB\-blockfilterindex=\fR<type>
 .IP
diff -Nru bitcoinabc-0.21.11/doc/man/bitcoin-qt.1 bitcoinabc-0.21.12/doc/man/bitcoin-qt.1
--- bitcoinabc-0.21.11/doc/man/bitcoin-qt.1	2020-07-13 17:51:00.000000000 +0000
+++ bitcoinabc-0.21.12/doc/man/bitcoin-qt.1	2020-07-27 15:24:34.000000000 +0000
@@ -1,12 +1,12 @@
 .\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.8.
-.TH BITCOIN-QT "1" "July 2020" "bitcoin-qt v0.21.11" "User Commands"
+.TH BITCOIN-QT "1" "July 2020" "bitcoin-qt v0.21.12" "User Commands"
 .SH NAME
-bitcoin-qt \- manual page for bitcoin-qt v0.21.11
+bitcoin-qt \- manual page for bitcoin-qt v0.21.12
 .SH SYNOPSIS
 .B bitcoin-qt
 [\fI\,command-line options\/\fR]
 .SH DESCRIPTION
-Bitcoin ABC version v0.21.11 (64\-bit)
+Bitcoin ABC version v0.21.12 (64\-bit)
 .SH OPTIONS
 .HP
 \-?
@@ -23,9 +23,9 @@
 If this block is in the chain assume that it and its ancestors are valid
 and potentially skip their script verification (0 to verify all,
 default:
-0000000000000000013add16221ff595c977de1027c8c3f962acf8fcdfa05065,
+000000000000000001831f2498ccf63ab3153bf6046362513832a0ac8008c16e,
 testnet:
-0000000000190c28546af514f5255d8afae5c5f756e191e9b8e9724a1e256e61)
+0000000031bedd3009e21403ad61614af5237093f8a794c7c7c1dd5d312fc61e)
 .HP
 \fB\-blockfilterindex=\fR<type>
 .IP
diff -Nru bitcoinabc-0.21.11/doc/man/bitcoin-tx.1 bitcoinabc-0.21.12/doc/man/bitcoin-tx.1
--- bitcoinabc-0.21.11/doc/man/bitcoin-tx.1	2020-07-13 17:51:00.000000000 +0000
+++ bitcoinabc-0.21.12/doc/man/bitcoin-tx.1	2020-07-27 15:24:34.000000000 +0000
@@ -1,7 +1,7 @@
 .\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.8.
-.TH BITCOIN-TX "1" "July 2020" "bitcoin-tx v0.21.11" "User Commands"
+.TH BITCOIN-TX "1" "July 2020" "bitcoin-tx v0.21.12" "User Commands"
 .SH NAME
-bitcoin-tx \- manual page for bitcoin-tx v0.21.11
+bitcoin-tx \- manual page for bitcoin-tx v0.21.12
 .SH SYNOPSIS
 .B bitcoin-tx
 [\fI\,options\/\fR] \fI\,<hex-tx> \/\fR[\fI\,commands\/\fR]  \fI\,Update hex-encoded bitcoin transaction\/\fR
@@ -9,7 +9,7 @@
 .B bitcoin-tx
 [\fI\,options\/\fR] \fI\,-create \/\fR[\fI\,commands\/\fR]   \fI\,Create hex-encoded bitcoin transaction\/\fR
 .SH DESCRIPTION
-Bitcoin ABC bitcoin\-tx utility version v0.21.11
+Bitcoin ABC bitcoin\-tx utility version v0.21.12
 .SH OPTIONS
 .HP
 \-?
diff -Nru bitcoinabc-0.21.11/doc/man/bitcoin-wallet.1 bitcoinabc-0.21.12/doc/man/bitcoin-wallet.1
--- bitcoinabc-0.21.11/doc/man/bitcoin-wallet.1	2020-07-13 17:51:00.000000000 +0000
+++ bitcoinabc-0.21.12/doc/man/bitcoin-wallet.1	2020-07-27 15:24:34.000000000 +0000
@@ -1,9 +1,9 @@
 .\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.47.8.
-.TH BITCOIN-WALLET "1" "July 2020" "bitcoin-wallet v0.21.11" "User Commands"
+.TH BITCOIN-WALLET "1" "July 2020" "bitcoin-wallet v0.21.12" "User Commands"
 .SH NAME
-bitcoin-wallet \- manual page for bitcoin-wallet v0.21.11
+bitcoin-wallet \- manual page for bitcoin-wallet v0.21.12
 .SH DESCRIPTION
-Bitcoin ABC bitcoin\-wallet version v0.21.11
+Bitcoin ABC bitcoin\-wallet version v0.21.12
 .PP
 wallet\-tool is an offline tool for creating and interacting with Bitcoin ABC wallet files.
 By default wallet\-tool will act on wallets in the default mainnet wallet directory in the datadir.
diff -Nru bitcoinabc-0.21.11/doc/release-notes/release-notes-0.21.11.md bitcoinabc-0.21.12/doc/release-notes/release-notes-0.21.11.md
--- bitcoinabc-0.21.11/doc/release-notes/release-notes-0.21.11.md	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/doc/release-notes/release-notes-0.21.11.md	2020-07-15 16:44:34.000000000 +0000
@@ -0,0 +1,18 @@
+Bitcoin ABC version 0.21.11 is now available from:
+
+  <https://download.bitcoinabc.org/0.21.11/>
+
+This release includes the following features and fixes:
+ - Upgrade minimum supported boost version to 1.59
+
+Deprecated or removed RPCs
+--------------------------
+- The wallet's `generate` RPC method was deprecated in v0.21.5 and has now
+  been fully removed.  This RPC is only used for
+  testing, but its implementation reached across multiple subsystems
+  (wallet and mining), so it has been removed to simplify the
+  wallet-node interface.  Projects that are using `generate` for testing
+  purposes should transition to using the `generatetoaddress` RPC, which
+  does not require or use the wallet component. Calling
+  `generatetoaddress` with an address returned by the `getnewaddress`
+  RPC gives the same functionality as the old `generate` RPC.
diff -Nru bitcoinabc-0.21.11/doc/rpc/CMakeLists.txt bitcoinabc-0.21.12/doc/rpc/CMakeLists.txt
--- bitcoinabc-0.21.11/doc/rpc/CMakeLists.txt	2020-06-08 20:54:42.000000000 +0000
+++ bitcoinabc-0.21.12/doc/rpc/CMakeLists.txt	2020-07-20 15:59:43.000000000 +0000
@@ -3,7 +3,7 @@
 if(BUILD_BITCOIN_CLI)
 	add_custom_target(doc-rpc
 		COMMENT "Generating RPC documentation"
-		COMMAND go run "${CMAKE_CURRENT_SOURCE_DIR}/generate.go"
+		COMMAND go run "${CMAKE_CURRENT_SOURCE_DIR}/generate.go" -regtest
 		WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
 		DEPENDS bitcoin-cli
 	)
diff -Nru bitcoinabc-0.21.11/doc/rpc/generate.go bitcoinabc-0.21.12/doc/rpc/generate.go
--- bitcoinabc-0.21.11/doc/rpc/generate.go	2020-06-18 19:26:30.000000000 +0000
+++ bitcoinabc-0.21.12/doc/rpc/generate.go	2020-07-28 23:45:00.000000000 +0000
@@ -187,6 +187,7 @@
 }
 
 func run(args ...string) string {
+	additionalArgs := os.Args[1:]
+	args = append(additionalArgs, args...)
 	return runCommand(bitcoin_cli_path, args...)
 }
-
diff -Nru bitcoinabc-0.21.11/src/avalanche/peermanager.cpp bitcoinabc-0.21.12/src/avalanche/peermanager.cpp
--- bitcoinabc-0.21.11/src/avalanche/peermanager.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/peermanager.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -4,6 +4,7 @@
 
 #include <avalanche/peermanager.h>
 
+#include <avalanche/validation.h>
 #include <random.h>
 
 #include <cassert>
@@ -17,6 +18,12 @@
         return it->peerid;
     }
 
+    // Reject invalid proof.
+    ProofValidationState state;
+    if (!proof.verify(state)) {
+        return NO_PEER;
+    }
+
     // We have no peer for this proof, time to create it.
     const PeerId peerid = nextPeerId++;
     auto inserted = peers.emplace(peerid, uint32_t(slots.size()), proof);
@@ -61,9 +68,7 @@
 bool PeerManager::addNode(NodeId nodeid, const Proof &proof,
                           const CPubKey &pubkey) {
     const PeerId peerid = getPeer(proof);
-
-    auto pit = peers.find(peerid);
-    if (pit == peers.end()) {
+    if (peerid == NO_PEER) {
         return false;
     }
 
diff -Nru bitcoinabc-0.21.11/src/avalanche/processor.cpp bitcoinabc-0.21.12/src/avalanche/processor.cpp
--- bitcoinabc-0.21.11/src/avalanche/processor.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/processor.cpp	2020-07-20 15:59:43.000000000 +0000
@@ -277,13 +277,12 @@
     {
         LOCK(cs_main);
         for (const auto &v : votes) {
-            BlockMap::iterator mi = mapBlockIndex.find(BlockHash(v.GetHash()));
-            if (mi == mapBlockIndex.end()) {
+            auto pindex = LookupBlockIndex(BlockHash(v.GetHash()));
+            if (!pindex) {
                 // This should not happen, but just in case...
                 continue;
             }
 
-            CBlockIndex *pindex = mi->second;
             if (!IsWorthPolling(pindex)) {
                 // There is no point polling this block.
                 continue;
@@ -333,7 +332,7 @@
     return true;
 }
 
-bool Processor::addPeer(NodeId nodeid, const Proof &proof,
+bool Processor::addNode(NodeId nodeid, const Proof &proof,
                         const CPubKey &pubkey) {
     LOCK(cs_peerManager);
     return peerManager->addNode(nodeid, proof, pubkey);
@@ -428,12 +427,10 @@
 
         {
             LOCK(cs_main);
-            BlockMap::iterator mi = mapBlockIndex.find(BlockHash(inv.hash));
-            if (mi == mapBlockIndex.end()) {
+            pindex = LookupBlockIndex(BlockHash(inv.hash));
+            if (!pindex) {
                 continue;
             }
-
-            pindex = mi->second;
         }
 
         auto w = vote_records.getWriteView();
diff -Nru bitcoinabc-0.21.11/src/avalanche/processor.h bitcoinabc-0.21.12/src/avalanche/processor.h
--- bitcoinabc-0.21.11/src/avalanche/processor.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/processor.h	2020-07-14 19:22:04.000000000 +0000
@@ -258,7 +258,7 @@
     bool registerVotes(NodeId nodeid, const Response &response,
                        std::vector<BlockUpdate> &updates);
 
-    bool addPeer(NodeId nodeid, const Proof &proof, const CPubKey &pubkey);
+    bool addNode(NodeId nodeid, const Proof &proof, const CPubKey &pubkey);
     bool forNode(NodeId nodeid, std::function<bool(const Node &n)> func) const;
 
     CPubKey getSessionPubKey() const { return sessionKey.GetPubKey(); }
diff -Nru bitcoinabc-0.21.11/src/avalanche/proofbuilder.cpp bitcoinabc-0.21.12/src/avalanche/proofbuilder.cpp
--- bitcoinabc-0.21.11/src/avalanche/proofbuilder.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/proofbuilder.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -0,0 +1,77 @@
+// Copyright (c) 2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <avalanche/proofbuilder.h>
+
+#include <random.h>
+
+namespace avalanche {
+
+SignedStake ProofBuilder::StakeSigner::sign(const ProofId &proofid) {
+    const uint256 h = stake.getHash(proofid);
+
+    std::array<uint8_t, 64> sig;
+    std::vector<uint8_t> vchSig;
+    if (key.SignSchnorr(h, vchSig)) {
+        // Schnorr sig are always 64 bytes in size.
+        assert(vchSig.size() == 64);
+        std::copy(vchSig.begin(), vchSig.end(), sig.begin());
+    } else {
+        sig.fill(0);
+    }
+
+    return SignedStake(std::move(stake), std::move(sig));
+}
+
+bool ProofBuilder::addUTXO(COutPoint utxo, Amount amount, uint32_t height,
+                           CKey key) {
+    if (!key.IsValid()) {
+        return false;
+    }
+
+    stakes.emplace_back(Stake(std::move(utxo), amount, height, key.GetPubKey()),
+                        std::move(key));
+    return true;
+}
+
+Proof ProofBuilder::build() {
+    const ProofId proofid = getProofId();
+
+    std::vector<SignedStake> signedStakes;
+    signedStakes.reserve(stakes.size());
+
+    for (auto &s : stakes) {
+        signedStakes.push_back(s.sign(proofid));
+    }
+
+    stakes.clear();
+    return Proof(sequence, expirationTime, std::move(master),
+                 std::move(signedStakes));
+}
+
+ProofId ProofBuilder::getProofId() const {
+    CHashWriter ss(SER_GETHASH, 0);
+    ss << sequence;
+    ss << expirationTime;
+    ss << master;
+
+    WriteCompactSize(ss, stakes.size());
+    for (const auto &s : stakes) {
+        ss << s.stake;
+    }
+
+    return ProofId(ss.GetHash());
+}
+
+Proof ProofBuilder::buildRandom(uint32_t score) {
+    CKey key;
+    key.MakeNewKey(true);
+
+    ProofBuilder pb(0, std::numeric_limits<uint32_t>::max(), CPubKey());
+    pb.addUTXO(COutPoint(TxId(GetRandHash()), 0), (int64_t(score) * COIN) / 100,
+               0, std::move(key));
+    return pb.build();
+}
+
+} // namespace avalanche
diff -Nru bitcoinabc-0.21.11/src/avalanche/proofbuilder.h bitcoinabc-0.21.12/src/avalanche/proofbuilder.h
--- bitcoinabc-0.21.11/src/avalanche/proofbuilder.h	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/proofbuilder.h	2020-07-14 19:22:04.000000000 +0000
@@ -0,0 +1,53 @@
+// Copyright (c) 2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_AVALANCHE_PROOFBUILDER_H
+#define BITCOIN_AVALANCHE_PROOFBUILDER_H
+
+#include <avalanche/proof.h>
+#include <key.h>
+
+#include <cstdio>
+
+namespace avalanche {
+
+class ProofBuilder {
+    uint64_t sequence;
+    int64_t expirationTime;
+    CPubKey master;
+
+    struct StakeSigner {
+        Stake stake;
+        CKey key;
+
+        StakeSigner(Stake stake_, CKey key_)
+            : stake(std::move(stake_)), key(std::move(key_)) {}
+
+        SignedStake sign(const ProofId &proofid);
+    };
+
+    std::vector<StakeSigner> stakes;
+
+public:
+    ProofBuilder(uint64_t sequence_, int64_t expirationTime_, CPubKey master_)
+        : sequence(sequence_), expirationTime(expirationTime_),
+          master(std::move(master_)) {}
+
+    bool addUTXO(COutPoint utxo, Amount amount, uint32_t height, CKey key);
+
+    Proof build();
+
+    /**
+     * Builds a randomized (and therefore invalid) Proof.
+     * Useful for tests.
+     */
+    static Proof buildRandom(uint32_t score);
+
+private:
+    ProofId getProofId() const;
+};
+
+} // namespace avalanche
+
+#endif // BITCOIN_AVALANCHE_PROOFBUILDER_H
diff -Nru bitcoinabc-0.21.11/src/avalanche/proof.cpp bitcoinabc-0.21.12/src/avalanche/proof.cpp
--- bitcoinabc-0.21.11/src/avalanche/proof.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/proof.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -4,18 +4,26 @@
 
 #include <avalanche/proof.h>
 
+#include <avalanche/validation.h>
+#include <coins.h> // For SaltedOutpointHasher
 #include <hash.h>
-#include <random.h>
 
-#include <limits>
+#include <unordered_set>
 
 namespace avalanche {
 
-Proof::Proof(uint64_t sequence_, int64_t expirationTime_, CPubKey master_,
-             std::vector<SignedStake> stakes_)
-    : sequence(sequence_), expirationTime(expirationTime_),
-      master(std::move(master_)), stakes(std::move(stakes_)),
-      proofid(computeProofId()) {}
+uint256 Stake::getHash(const ProofId &proofid) const {
+    CHashWriter ss(SER_GETHASH, 0);
+    ss << proofid;
+    ss << *this;
+    return ss.GetHash();
+}
+
+bool SignedStake::verify(const ProofId &proofid) const {
+    // Unfortunately, the verify API require a vector.
+    std::vector<uint8_t> vchSig{sig.begin(), sig.end()};
+    return stake.getPubkey().VerifySchnorr(stake.getHash(proofid), vchSig);
+}
 
 ProofId Proof::computeProofId() const {
     CHashWriter ss(SER_GETHASH, 0);
@@ -40,11 +48,30 @@
     return uint32_t((100 * total) / COIN);
 }
 
-Proof Proof::makeRandom(uint32_t score) {
-    return Proof(0, std::numeric_limits<uint32_t>::max(), CPubKey(),
-                 {{{COutPoint(TxId(GetRandHash()), 0),
-                    (int64_t(score) * COIN) / 100, 0, CPubKey()},
-                   {}}});
+static constexpr Amount PROOF_DUST_THRESOLD = 1 * SATOSHI;
+
+bool Proof::verify(ProofValidationState &state) const {
+    if (stakes.empty()) {
+        return state.Invalid(ProofValidationResult::NO_STAKE);
+    }
+
+    std::unordered_set<COutPoint, SaltedOutpointHasher> utxos;
+    for (const SignedStake &ss : stakes) {
+        const Stake &s = ss.getStake();
+        if (s.getAmount() < PROOF_DUST_THRESOLD) {
+            return state.Invalid(ProofValidationResult::DUST_THRESOLD);
+        }
+
+        if (!utxos.insert(s.getUTXO()).second) {
+            return state.Invalid(ProofValidationResult::DUPLICATE_STAKE);
+        }
+
+        if (!ss.verify(proofid)) {
+            return state.Invalid(ProofValidationResult::INVALID_SIGNATURE);
+        }
+    }
+
+    return true;
 }
 
 } // namespace avalanche
diff -Nru bitcoinabc-0.21.11/src/avalanche/proof.h bitcoinabc-0.21.12/src/avalanche/proof.h
--- bitcoinabc-0.21.11/src/avalanche/proof.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/proof.h	2020-07-17 16:19:01.000000000 +0000
@@ -17,6 +17,8 @@
 
 namespace avalanche {
 
+class ProofValidationState;
+
 struct ProofId : public uint256 {
     explicit ProofId() : uint256() {}
     explicit ProofId(const uint256 &b) : uint256(b) {}
@@ -56,6 +58,8 @@
     uint32_t getHeight() const { return height >> 1; }
     bool isCoinbase() const { return height & 1; }
     const CPubKey &getPubkey() const { return pubkey; }
+
+    uint256 getHash(const ProofId &proofid) const;
 };
 
 class SignedStake {
@@ -77,6 +81,8 @@
 
     const Stake &getStake() const { return stake; }
     const std::array<uint8_t, 64> &getSignature() const { return sig; }
+
+    bool verify(const ProofId &proofid) const;
 };
 
 class Proof {
@@ -91,7 +97,10 @@
 public:
     Proof() : sequence(0), expirationTime(0), master(), stakes(), proofid() {}
     Proof(uint64_t sequence_, int64_t expirationTime_, CPubKey master_,
-          std::vector<SignedStake> stakes_);
+          std::vector<SignedStake> stakes_)
+        : sequence(sequence_), expirationTime(expirationTime_),
+          master(std::move(master_)), stakes(std::move(stakes_)),
+          proofid(computeProofId()) {}
 
     ADD_SERIALIZE_METHODS;
 
@@ -107,14 +116,15 @@
         }
     }
 
+    uint64_t getSequence() const { return sequence; }
+    int64_t getExpirationTime() const { return expirationTime; }
+    const CPubKey &getMaster() const { return master; }
+    const std::vector<SignedStake> &getStakes() const { return stakes; }
+
     const ProofId &getId() const { return proofid; }
     uint32_t getScore() const;
 
-    /**
-     * Builds a randomized (and therefore invalid) Proof.
-     * Useful for tests.
-     */
-    static Proof makeRandom(uint32_t score);
+    bool verify(ProofValidationState &state) const;
 };
 
 } // namespace avalanche
diff -Nru bitcoinabc-0.21.11/src/avalanche/test/CMakeLists.txt bitcoinabc-0.21.12/src/avalanche/test/CMakeLists.txt
--- bitcoinabc-0.21.11/src/avalanche/test/CMakeLists.txt	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/test/CMakeLists.txt	2020-07-14 19:22:04.000000000 +0000
@@ -10,6 +10,7 @@
 
 add_boost_unit_tests_to_suite(avalanche test-avalanche
 	fixture.cpp
+	util.cpp
 
 	TESTS
 		peermanager_tests.cpp
diff -Nru bitcoinabc-0.21.11/src/avalanche/test/fixture.cpp bitcoinabc-0.21.12/src/avalanche/test/fixture.cpp
--- bitcoinabc-0.21.11/src/avalanche/test/fixture.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/test/fixture.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -3,5 +3,4 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #define BOOST_TEST_MODULE Avalanche Test Suite
-
 #include <boost/test/unit_test.hpp>
diff -Nru bitcoinabc-0.21.11/src/avalanche/test/peermanager_tests.cpp bitcoinabc-0.21.12/src/avalanche/test/peermanager_tests.cpp
--- bitcoinabc-0.21.11/src/avalanche/test/peermanager_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/test/peermanager_tests.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -4,6 +4,8 @@
 
 #include <avalanche/peermanager.h>
 
+#include <avalanche/test/util.h>
+
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
@@ -157,12 +159,12 @@
     const NodeId node0 = 42, node1 = 69, node2 = 37;
 
     // One peer, we always return it.
-    Proof proof0 = Proof::makeRandom(100);
-    pm.addNode(node0, Proof::makeRandom(100), CPubKey());
+    Proof proof0 = buildRandomProof(100);
+    pm.addNode(node0, buildRandomProof(100), CPubKey());
     BOOST_CHECK_EQUAL(pm.selectNode(), node0);
 
     // Two peers, verify ratio.
-    pm.addNode(node1, Proof::makeRandom(200), CPubKey());
+    pm.addNode(node1, buildRandomProof(200), CPubKey());
 
     std::unordered_map<PeerId, int> results = {};
     for (int i = 0; i < 10000; i++) {
@@ -174,7 +176,7 @@
     BOOST_CHECK(abs(2 * results[0] - results[1]) < 500);
 
     // Three peers, verify ratio.
-    pm.addNode(node2, Proof::makeRandom(100), CPubKey());
+    pm.addNode(node2, buildRandomProof(100), CPubKey());
 
     results.clear();
     for (int i = 0; i < 10000; i++) {
@@ -194,7 +196,7 @@
     // Add 4 peers.
     std::array<PeerId, 8> peerids;
     for (int i = 0; i < 4; i++) {
-        peerids[i] = pm.getPeer(Proof::makeRandom(100));
+        peerids[i] = pm.getPeer(buildRandomProof(100));
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 400);
@@ -224,7 +226,7 @@
 
     // Add 4 more peers.
     for (int i = 0; i < 4; i++) {
-        peerids[i + 4] = pm.getPeer(Proof::makeRandom(100));
+        peerids[i + 4] = pm.getPeer(buildRandomProof(100));
     }
 
     BOOST_CHECK_EQUAL(pm.getSlotCount(), 700);
@@ -264,7 +266,7 @@
     // Add 4 peers.
     std::array<PeerId, 4> peerids;
     for (int i = 0; i < 4; i++) {
-        peerids[i] = pm.getPeer(Proof::makeRandom(100));
+        peerids[i] = pm.getPeer(buildRandomProof(100));
     }
 
     // Remove all peers.
@@ -289,7 +291,7 @@
     PeerManager pm;
 
     // Create one peer.
-    Proof proof = Proof::makeRandom(100);
+    Proof proof = buildRandomProof(100000000);
     BOOST_CHECK_EQUAL(pm.selectNode(), NO_NODE);
 
     // Add 4 nodes.
@@ -325,13 +327,20 @@
             pm.updateNextRequestTime(n, std::chrono::steady_clock::now()));
     }
 
-    // Move a node from a peer to another.
-    Proof altproof = Proof::makeRandom(0);
+    // Move a node from a peer to another. This peer has a very low score such
+    // as chances of being picked are 1 in a billion.
+    Proof altproof = buildRandomProof(1);
     BOOST_CHECK(pm.addNode(3, altproof, CPubKey()));
 
+    int node3selected = 0;
     for (int i = 0; i < 100; i++) {
         NodeId n = pm.selectNode();
-        BOOST_CHECK(n == 0);
+        if (n == 3) {
+            // Selecting this node should be exceedingly unlikely.
+            BOOST_CHECK(node3selected++ < 1);
+        } else {
+            BOOST_CHECK_EQUAL(n, 0);
+        }
         BOOST_CHECK(
             pm.updateNextRequestTime(n, std::chrono::steady_clock::now()));
     }
diff -Nru bitcoinabc-0.21.11/src/avalanche/test/processor_tests.cpp bitcoinabc-0.21.12/src/avalanche/test/processor_tests.cpp
--- bitcoinabc-0.21.11/src/avalanche/test/processor_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/test/processor_tests.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -5,6 +5,8 @@
 #include <avalanche/processor.h>
 
 #include <avalanche/peermanager.h>
+#include <avalanche/test/util.h>
+#include <chain.h>
 #include <config.h>
 #include <net_processing.h> // For PeerLogicValidation
 #include <util/time.h>
@@ -210,7 +212,7 @@
                                     PeerLogicValidation &peerLogic,
                                     CConnmanTest *connman) {
     PeerManager &pm = AvalancheTest::getPeerManager(p);
-    Proof proof = Proof::makeRandom(100);
+    Proof proof = buildRandomProof(100);
 
     std::array<CNode *, 8> nodes;
     for (CNode *&n : nodes) {
@@ -530,7 +532,7 @@
     auto avanode =
         ConnectNode(config, NODE_AVALANCHE, *peerLogic, connman.get());
     NodeId avanodeid = avanode->GetId();
-    BOOST_CHECK(p.addPeer(avanodeid, Proof::makeRandom(100), CPubKey()));
+    BOOST_CHECK(p.addNode(avanodeid, buildRandomProof(100), CPubKey()));
 
     // It returns the avalanche peer.
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), avanodeid);
@@ -677,7 +679,7 @@
     auto avanode =
         ConnectNode(config, NODE_AVALANCHE, *peerLogic, connman.get());
     NodeId avanodeid = avanode->GetId();
-    BOOST_CHECK(p.addPeer(avanodeid, Proof::makeRandom(100), CPubKey()));
+    BOOST_CHECK(p.addNode(avanodeid, buildRandomProof(100), CPubKey()));
 
     // Expire requests after some time.
     auto queryTimeDuration = std::chrono::milliseconds(10);
@@ -725,7 +727,7 @@
 
     // Create enough nodes so that we run into the inflight request limit.
     PeerManager &pm = AvalancheTest::getPeerManager(p);
-    Proof proof = Proof::makeRandom(100);
+    Proof proof = buildRandomProof(100);
 
     std::array<CNode *, AVALANCHE_MAX_INFLIGHT_POLL + 1> nodes;
     for (auto &n : nodes) {
@@ -891,7 +893,7 @@
     auto avanode =
         ConnectNode(config, NODE_AVALANCHE, *peerLogic, connman.get());
     NodeId nodeid = avanode->GetId();
-    BOOST_CHECK(p.addPeer(nodeid, Proof::makeRandom(100), CPubKey()));
+    BOOST_CHECK(p.addNode(nodeid, buildRandomProof(100), CPubKey()));
 
     // There is no query in flight at the moment.
     BOOST_CHECK_EQUAL(AvalancheTest::getSuitableNodeToQuery(p), nodeid);
diff -Nru bitcoinabc-0.21.11/src/avalanche/test/proof_tests.cpp bitcoinabc-0.21.12/src/avalanche/test/proof_tests.cpp
--- bitcoinabc-0.21.11/src/avalanche/test/proof_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/test/proof_tests.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -4,6 +4,9 @@
 
 #include <avalanche/proof.h>
 
+#include <avalanche/proofbuilder.h>
+#include <avalanche/test/util.h>
+#include <avalanche/validation.h>
 #include <streams.h>
 #include <util/strencodings.h>
 
@@ -15,11 +18,55 @@
 
 BOOST_FIXTURE_TEST_SUITE(proof_tests, BasicTestingSetup)
 
+BOOST_AUTO_TEST_CASE(proof_random) {
+    for (int i = 0; i < 1000; i++) {
+        const uint32_t score = InsecureRand32();
+        const Proof p = buildRandomProof(score);
+        BOOST_CHECK_EQUAL(p.getScore(), score);
+
+        ProofValidationState state;
+        BOOST_CHECK(p.verify(state));
+        BOOST_CHECK(state.GetResult() == ProofValidationResult::NONE);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(proofbuilder) {
+    CKey key;
+
+    // Master key.
+    key.MakeNewKey(true);
+    const CPubKey master = key.GetPubKey();
+
+    const uint64_t sequence = InsecureRandBits(64);
+    const int64_t expiration = InsecureRandBits(64);
+
+    ProofBuilder pb(sequence, expiration, master);
+
+    for (int i = 0; i < 3; i++) {
+        key.MakeNewKey(true);
+        pb.addUTXO(COutPoint(TxId(GetRandHash()), InsecureRand32()),
+                   int64_t(InsecureRand32()) * COIN / 100, InsecureRand32(),
+                   key);
+    }
+
+    Proof p = pb.build();
+
+    ProofValidationState state;
+    BOOST_CHECK(p.verify(state));
+
+    BOOST_CHECK_EQUAL(p.getSequence(), sequence);
+    BOOST_CHECK_EQUAL(p.getExpirationTime(), expiration);
+    BOOST_CHECK(p.getMaster() == master);
+
+    BOOST_CHECK(state.GetResult() == ProofValidationResult::NONE);
+}
+
 struct TestVector {
     std::string name;
     std::string hex;
     ProofId proofid;
     uint32_t score;
+    ProofValidationResult result;
 };
 
 BOOST_AUTO_TEST_CASE(deserialization) {
@@ -29,7 +76,7 @@
          "3e95b02cacfd357b64e4fb6c92e92dd00",
          ProofId::fromHex("df721b6e2a857ce8abac63d8d5eca35f3bdb0293b6e8295942c7"
                           "6274c5418c0c"),
-         0},
+         0, ProofValidationResult::NO_STAKE},
         {"1 utxo staked",
          "a6d66db9fe9378fdd37a0ad2c01c2acd2103648144bb6a0c1d09b0f04d0df6d55f914"
          "fd81efc65f23a718b68b7c9e42bd5430145a4d07798547464daa53acefb7c97c0c415"
@@ -40,7 +87,7 @@
          "77d8fcf68c54ebfadf08b9a446c251a0088301c50d53",
          ProofId::fromHex("048235ee870030f11c287d898dd3ec184f9b38cf4fb274334966"
                           "c6aad83b769d"),
-         7584312},
+         7584312, ProofValidationResult::INVALID_SIGNATURE},
         {"2 utxo staked",
          "872379ab64f55b4166ca0e79639999ec4104a66861de557a54eefc0375264cc17c3a3"
          "50ccabca6fd9c91883e899ab55bb140517aa56c5b4041908e7027a786b99f66488a04"
@@ -55,7 +102,7 @@
          "91c965cba4dbc11c210979217f1ac3ece7a748f5b2fcf5cced40a5d4c40e",
          ProofId::fromHex("7319126f0d4efc188440dd50105ea30d792687b65e9cdde6c4d6"
                           "08ed226cba00"),
-         15610172},
+         15610172, ProofValidationResult::INVALID_SIGNATURE},
         {"3 utxo staked",
          "525e2aa04af0e2457c66ac9e7f66257f210252db8e3ceea6fca44a7696e82f7b77e5a"
          "4025e60ac60271b174e91ffbb6ce01f039ce8d3b77938e49ce3bc9824e90b72c65542"
@@ -75,7 +122,7 @@
          "91b185e",
          ProofId::fromHex("3b3204993240ab338324310ecadc5f234da1dac0627029cef63e"
                           "1169a049d18f"),
-         29026903},
+         29026903, ProofValidationResult::INVALID_SIGNATURE},
         {"4 utxo staked",
          "eef33172651f752ac255c85a4e1374992102c12b37ff6139157865fc4c3a9d7ad999b"
          "686ade45d453545d04e76f6e14793b404295de5ebf9fbbbb65fc1d9a71587c5284cff"
@@ -99,7 +146,174 @@
          "14a348c80ca1833d68b3d7b",
          ProofId::fromHex("62f256d73411fe69bf0db6083248e4efb75be9788850851468ac"
                           "c913c5c14360"),
-         44059793},
+         44059793, ProofValidationResult::INVALID_SIGNATURE},
+        {"Properly signed 1 UTXO proof",
+         "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
+         "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
+         "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
+         "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
+         "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
+         "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
+         "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
+         "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
+         ProofId::fromHex("17717dbf1cee175925be12321bb04eda7bc861a28b04d764c2d5"
+                          "5eabf01cabd0"),
+         444638638, ProofValidationResult::NONE},
+        {"Duplicated UTXO",
+         "60f8332a3ff3430a4f3c9010160cc63e2102f2df6361a5744521d16753f9efb5ace68"
+         "d43121e90ff67290540b54341cbab0e02d1e26c2287948bc6ab2b55945c591b8ba3ff"
+         "a237f5d9164d30a4f10145a61f788e639b1480731e2aead30500bf84628721029ed70"
+         "5bdc5adf0444c57c5ec2ea929c1adc0cd5b9cef4647d85dcb7fc400dc3afd21b29571"
+         "9c45b90fda493bbc74c8ae1baf28e124cc23bb1987f9932d2df5a0b3455e6c815767c"
+         "be8ccdd04e0e2d33d5f2f092667ef081acdaafde869d58daed1e26c2287948bc6ab2b"
+         "55945c591b8ba3ffa237f5d9164d30a4f10145a61f788e639b1480731e2aead30500b"
+         "f84628721029ed705bdc5adf0444c57c5ec2ea929c1adc0cd5b9cef4647d85dcb7fc4"
+         "00dc3afd21b295719c45b90fda493bbc74c8ae1baf28e124cc23bb1987f9932d2df5a"
+         "0b3455e6c815767cbe8ccdd04e0e2d33d5f2f092667ef081acdaafde869d58dae",
+         ProofId::fromHex("b0c2c07cbc766df0a934bcb252063ad5d7d5167b080369f6feca"
+                          "a3aabae29785"),
+         3280755132, ProofValidationResult::DUPLICATE_STAKE},
+        {"Properly signed 3 UTXO proof",
+         "c96492f9e27a25d7e8404581c7be874e210282eb68a587dc586673f439fe317fa0b76"
+         "aceefa9f99820eadaa70d3b19c0cfe10305d427b706705a5d4b6a368a231d6db62aba"
+         "cf8c29bc32b61e7f65a0a6976aa8b86b687bc0260e821e4f0200b9d3bf6d2102914b1"
+         "aade61c7b5d38b18fb8c02ec4a9411858a43969927e5a2bf371e83ea20aa2a8ac89e9"
+         "fb52edcb227de3c3bd51519c0afcd5c3c134f09e53a9dd4315d4cde560c54b5700c2e"
+         "7b4f15c18461a3c093b790e93ef54640c051fff6798f18e2c18f54247f6390791706a"
+         "f36fac782302479898b5273f9e51a92cb1fb5af43deeb6c8c269403dbd48c9530a001"
+         "34398c441040a9c4426531e19916a0250536684073fbedce86d73e883ee1107e7984e"
+         "7c721b2be965c63bcbdbd23dcabba6de7ae6715872c803a257e53b686ea69217228c0"
+         "6ee1b88c4c7aa55adb1804a13e9d222b8d327c4de466fcd9e71ec20582f8d0760830a"
+         "67e020688e73c91519bd4b74358e65e9ddc95065bcf1bee0d11767e10f30f0d4ce48c"
+         "4ca9d0714b1fa51920270f8575e0af610f07b4e602a018ecdbb649b64fff614c0026e"
+         "9fc8e0030092533d424104973b212564dfb8ff1aa4bab13389ed170ea6cbb06fd9a5b"
+         "5b3e8c00d1a7d4bca7d237748ad793fc043b12f73a28caabb00927c5aea81e323d3ba"
+         "047a9661adbb0728ccfb41ab345299d7469ff5ec259b98fc946c730b5100cc97284ea"
+         "6101f7e43337987bbfe655754939709c72c7ba69a9dc08558733781ee9da34e3de7bd"
+         "a7",
+         ProofId::fromHex("5948d32ee26882a2d9f96c18e9e51ad13a79234b627a020ee7db"
+                          "733684cb05a7"),
+         353426051, ProofValidationResult::NONE},
+        {"Changing sequence affect ProofId",
+         "d87587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
+         "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
+         "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
+         "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
+         "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
+         "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
+         "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
+         "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
+         ProofId::fromHex("3fdcb56110cfe2f394689be3dd28dedee674f79a567c8391dbd9"
+                          "3900c9845ca8"),
+         444638638, ProofValidationResult::INVALID_SIGNATURE},
+        {"Changing expiration affect ProofId",
+         "d97587e6c882615797011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
+         "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
+         "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
+         "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
+         "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
+         "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
+         "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
+         "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
+         ProofId::fromHex("a9ffbb2b37526e05a1f72b43314f872c381281ce8d3d96a5bf56"
+                          "47db057a64dc"),
+         444638638, ProofValidationResult::INVALID_SIGNATURE},
+        {"Changing the master key affect ProofId",
+         "d97587e6c882615796011ec8f9a7b1c64104e556ba897297fd6a655bc2579d26814e8"
+         "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
+         "bd546a614b0e05433528b19587 "
+         "0169a79ff23e1d58c64afad42ad81cffe53967e16be"
+         "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
+         "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
+         "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
+         "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
+         "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
+         ProofId::fromHex("c237e5436f2d21e4ae990422bfb8ec97df52a9f6db5c20c40f54"
+                          "64e590dcda39"),
+         444638638, ProofValidationResult::INVALID_SIGNATURE},
+        {"Changing the TxId affect the ProofId",
+         "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
+         "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
+         "bd546a614b0e05433528b195870179a79ff23e1d58c64afad42ad81cffe53967e16be"
+         "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
+         "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
+         "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
+         "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
+         "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
+         ProofId::fromHex("9d372d7580917985824c632c919ce8bf89fc6f45c07ee60b2564"
+                          "6aea23390ec6"),
+         444638638, ProofValidationResult::INVALID_SIGNATURE},
+        {"Changing the outpoint index change the ProofId",
+         "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
+         "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
+         "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
+         "b692fc5776bb442c79c5d91df00cf21804712806594010038e168a34104d9d84ebf65"
+         "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
+         "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
+         "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
+         "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
+         ProofId::fromHex("1a98c5f7684508665fbc946c64c9486e3f7c91b2f42d299320c5"
+                          "56e68e4028fe"),
+         444638638, ProofValidationResult::INVALID_SIGNATURE},
+        {"Changing the amount changes the ProofId",
+         "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
+         "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
+         "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
+         "b692fc5776bb442c79c5d91de00cf21814712806594010038e168a34104d9d84ebf65"
+         "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
+         "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
+         "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
+         "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
+         ProofId::fromHex("528fa9654e845dfe30ed03966240ab615a8d374d86256e1e4892"
+                          "83eb0a0be44b"),
+         444638638, ProofValidationResult::INVALID_SIGNATURE},
+        {"Changing the height changes the ProofId",
+         "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
+         "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
+         "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
+         "b692fc5776bb442c79c5d91de00cf21804712806594010028e168a34104d9d84ebf65"
+         "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
+         "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
+         "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
+         "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
+         ProofId::fromHex("a932294f46f106b2b38e57a4b1e4b5849730aba2124662f680a6"
+                          "1c8cc429adb0"),
+         444638638, ProofValidationResult::INVALID_SIGNATURE},
+        {"Changing the pubkey changes the ProofId",
+         "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
+         "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
+         "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
+         "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d8d84ebf65"
+         "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
+         "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
+         "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
+         "7c0276a293ee5b3f5a130fc5f9b217585cae23e",
+         ProofId::fromHex("336c9a502b22ba2edcd78298c1ce6cc5e8b5e94cdc60b1047d1f"
+                          "96810d5d17a3"),
+         444638638, ProofValidationResult::INVALID_SIGNATURE},
+        {"Changing the signatue does NOT change the ProofId",
+         "d97587e6c882615796011ec8f9a7b1c64104e556ba887297fd6a655bc2579d26814e8"
+         "54c902448ec3ce3c6fe965e3420aa3f0e9611d3c0b8a73b6329741e2e726fd17f5e8a"
+         "bd546a614b0e05433528b195870169a79ff23e1d58c64afad42ad81cffe53967e16be"
+         "b692fc5776bb442c79c5d91de00cf21804712806594010038e168a34104d9d84ebf65"
+         "22cf24c6fd4addedd068632a4db06c3cd6e40031c72d416e9eefbd90037383d8da9e9"
+         "213a4818a02f108ac1656141ecfbfdde0aeb8620eb210c08b2ce587d9fec0799f9725"
+         "5d2bc5a077c7b4e8ca8a68d6a0377abf0aa2473f97b37779431062dad50ef5fd21cf1"
+         "7c0276a293ee5b3f5a130fc5f9b217585cae23f",
+         ProofId::fromHex("17717dbf1cee175925be12321bb04eda7bc861a28b04d764c2d5"
+                          "5eabf01cabd0"),
+         444638638, ProofValidationResult::INVALID_SIGNATURE},
+        {"1 utxo staked but zero coins",
+         "a6d66db9fe9378fdd37a0ad2c01c2acd2103648144bb6a0c1d09b0f04d0df6d55f914"
+         "fd81efc65f23a718b68b7c9e42bd5430145a4d07798547464daa53acefb7c97c0c415"
+         "ed8e81e549ff56a0ef6f847fcc9ca855b3620000000000000000e707d7274104fb662"
+         "6e21dbd1cc9feeecdefc9213fdce2b51ac4bb44e1f8dc6f14c2052f5dd7bfaeb2267a"
+         "97ca2bec6e0dd4acf50a66204bde1ebb5d6c551684cff2f939920f7fbb2efd860d6d5"
+         "926bf425eb47b78bf6979cdcd67eb705e2c9a4d45a0930ba25463178a3fb99cb28c8b"
+         "77d8fcf68c54ebfadf08b9a446c251a0088301c50d53",
+         ProofId::fromHex("32c852db61880e9e2d4de3edba2daf3f5449e00bf1bc5b18595f"
+                          "80113d5b0722"),
+         0, ProofValidationResult::DUST_THRESOLD},
     };
 
     for (auto &c : testcases) {
@@ -108,14 +322,11 @@
         stream >> p;
         BOOST_CHECK_EQUAL(p.getId(), c.proofid);
         BOOST_CHECK_EQUAL(p.getScore(), c.score);
-    }
-}
 
-BOOST_AUTO_TEST_CASE(proof_random) {
-    for (int i = 0; i < 1000; i++) {
-        const uint32_t score = InsecureRand32();
-        const Proof p = Proof::makeRandom(score);
-        BOOST_CHECK_EQUAL(p.getScore(), score);
+        ProofValidationState state;
+        BOOST_CHECK_EQUAL(p.verify(state),
+                          c.result == ProofValidationResult::NONE);
+        BOOST_CHECK(state.GetResult() == c.result);
     }
 }
 
diff -Nru bitcoinabc-0.21.11/src/avalanche/test/util.cpp bitcoinabc-0.21.12/src/avalanche/test/util.cpp
--- bitcoinabc-0.21.11/src/avalanche/test/util.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/test/util.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -0,0 +1,26 @@
+// Copyright (c) 2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <amount.h>
+#include <avalanche/proofbuilder.h>
+#include <avalanche/test/util.h>
+#include <key.h>
+#include <primitives/transaction.h>
+#include <random.h>
+
+#include <limits>
+
+namespace avalanche {
+
+Proof buildRandomProof(uint32_t score) {
+    CKey key;
+    key.MakeNewKey(true);
+
+    ProofBuilder pb(0, std::numeric_limits<uint32_t>::max(), CPubKey());
+    pb.addUTXO(COutPoint(TxId(GetRandHash()), 0), (int64_t(score) * COIN) / 100,
+               0, std::move(key));
+    return pb.build();
+}
+
+} // namespace avalanche
diff -Nru bitcoinabc-0.21.11/src/avalanche/test/util.h bitcoinabc-0.21.12/src/avalanche/test/util.h
--- bitcoinabc-0.21.11/src/avalanche/test/util.h	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/test/util.h	2020-07-14 19:22:04.000000000 +0000
@@ -0,0 +1,18 @@
+// Copyright (c) 2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_AVALANCHE_TEST_UTIL_H
+#define BITCOIN_AVALANCHE_TEST_UTIL_H
+
+#include <avalanche/proof.h>
+
+#include <cstdio>
+
+namespace avalanche {
+
+Proof buildRandomProof(uint32_t score);
+
+} // namespace avalanche
+
+#endif // BITCOIN_AVALANCHE_TEST_UTIL_H
diff -Nru bitcoinabc-0.21.11/src/avalanche/validation.h bitcoinabc-0.21.12/src/avalanche/validation.h
--- bitcoinabc-0.21.11/src/avalanche/validation.h	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/avalanche/validation.h	2020-07-17 16:19:01.000000000 +0000
@@ -0,0 +1,37 @@
+// Copyright (c) 2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_AVALANCHE_VALIDATION_H
+#define BITCOIN_AVALANCHE_VALIDATION_H
+
+#include <consensus/validation.h>
+
+namespace avalanche {
+
+enum class ProofValidationResult {
+    NONE,
+    NO_STAKE,
+    DUST_THRESOLD,
+    DUPLICATE_STAKE,
+    INVALID_SIGNATURE,
+};
+
+class ProofValidationState : public ValidationState {
+private:
+    ProofValidationResult m_result = ProofValidationResult::NONE;
+
+public:
+    bool Invalid(ProofValidationResult result, unsigned int chRejectCodeIn = 0,
+                 const std::string &reject_reason = "",
+                 const std::string &debug_message = "") {
+        m_result = result;
+        ValidationState::Invalid(chRejectCodeIn, reject_reason, debug_message);
+        return false;
+    }
+    ProofValidationResult GetResult() const { return m_result; }
+};
+
+} // namespace avalanche
+
+#endif // BITCOIN_AVALANCHE_VALIDATION_H
diff -Nru bitcoinabc-0.21.11/src/bench/block_assemble.cpp bitcoinabc-0.21.12/src/bench/block_assemble.cpp
--- bitcoinabc-0.21.11/src/bench/block_assemble.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/bench/block_assemble.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -42,9 +42,8 @@
         LOCK(::cs_main);
 
         for (const auto &txr : txs) {
-            CValidationState vstate;
+            TxValidationState vstate;
             bool ret{::AcceptToMemoryPool(config, ::g_mempool, vstate, txr,
-                                          nullptr /* pfMissingInputs */,
                                           false /* bypass_limits */,
                                           /* nAbsurdFee */ Amount::zero())};
             assert(ret);
diff -Nru bitcoinabc-0.21.11/src/bench/checkblock.cpp bitcoinabc-0.21.12/src/bench/checkblock.cpp
--- bitcoinabc-0.21.11/src/bench/checkblock.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/bench/checkblock.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -46,7 +46,7 @@
         bool rewound = stream.Rewind(benchmark::data::block413567.size());
         assert(rewound);
 
-        CValidationState validationState;
+        BlockValidationState validationState;
         bool checked = CheckBlock(block, validationState, params, options);
         assert(checked);
     }
diff -Nru bitcoinabc-0.21.11/src/bench/CMakeLists.txt bitcoinabc-0.21.12/src/bench/CMakeLists.txt
--- bitcoinabc-0.21.11/src/bench/CMakeLists.txt	2020-07-07 17:16:37.000000000 +0000
+++ bitcoinabc-0.21.12/src/bench/CMakeLists.txt	2020-07-17 16:19:01.000000000 +0000
@@ -75,4 +75,7 @@
 	target_link_libraries(bitcoin-bench wallet)
 endif()
 
+include(InstallationHelper)
+install_target(bitcoin-bench EXCLUDE_FROM_ALL)
+
 add_custom_target(bench-bitcoin COMMAND bitcoin-bench USES_TERMINAL)
diff -Nru bitcoinabc-0.21.11/src/bench/duplicate_inputs.cpp bitcoinabc-0.21.12/src/bench/duplicate_inputs.cpp
--- bitcoinabc-0.21.11/src/bench/duplicate_inputs.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/bench/duplicate_inputs.cpp	2020-07-20 15:59:43.000000000 +0000
@@ -8,7 +8,7 @@
 #include <config.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <random.h>
 #include <script/scriptcache.h>
 #include <txmempool.h>
@@ -17,7 +17,8 @@
 static void DuplicateInputs(benchmark::State &state) {
     const CScript SCRIPT_PUB{CScript(OP_TRUE)};
 
-    const CChainParams &chainparams = Params();
+    const CChainParams &chainParams = Params();
+    const Consensus::Params &consensusParams = chainParams.GetConsensus();
 
     CBlock block{};
     CMutableTransaction coinbaseTx{};
@@ -26,8 +27,7 @@
     LOCK(cs_main);
     CBlockIndex *pindexPrev = ::ChainActive().Tip();
     assert(pindexPrev != nullptr);
-    block.nBits =
-        GetNextWorkRequired(pindexPrev, &block, chainparams.GetConsensus());
+    block.nBits = GetNextWorkRequired(pindexPrev, &block, chainParams);
     block.nNonce = 0;
     auto nHeight = pindexPrev->nHeight + 1;
 
@@ -36,8 +36,7 @@
     coinbaseTx.vin[0].prevout = COutPoint();
     coinbaseTx.vout.resize(1);
     coinbaseTx.vout[0].scriptPubKey = SCRIPT_PUB;
-    coinbaseTx.vout[0].nValue =
-        GetBlockSubsidy(nHeight, chainparams.GetConsensus());
+    coinbaseTx.vout[0].nValue = GetBlockSubsidy(nHeight, consensusParams);
     coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
 
     naughtyTx.vout.resize(1);
@@ -57,8 +56,8 @@
     block.hashMerkleRoot = BlockMerkleRoot(block);
 
     while (state.KeepRunning()) {
-        CValidationState cvstate{};
-        assert(!CheckBlock(block, cvstate, chainparams.GetConsensus(),
+        BlockValidationState cvstate{};
+        assert(!CheckBlock(block, cvstate, consensusParams,
                            BlockValidationOptions(GetConfig())
                                .withCheckPoW(false)
                                .withCheckMerkleRoot(false)));
diff -Nru bitcoinabc-0.21.11/src/blockencodings.cpp bitcoinabc-0.21.12/src/blockencodings.cpp
--- bitcoinabc-0.21.11/src/blockencodings.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/blockencodings.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -240,14 +240,14 @@
         return READ_STATUS_INVALID;
     }
 
-    CValidationState state;
+    BlockValidationState state;
     if (!CheckBlock(block, state, config->GetChainParams().GetConsensus(),
                     BlockValidationOptions(*config))) {
         // TODO: We really want to just check merkle tree manually here, but
         // that is expensive, and CheckBlock caches a block's "checked-status"
         // (in the CBlock?). CBlock should be able to check its own merkle root
         // and cache that check.
-        if (state.GetReason() == ValidationInvalidReason::BLOCK_MUTATED) {
+        if (state.GetResult() == BlockValidationResult::BLOCK_MUTATED) {
             // Possible Short ID collision.
             return READ_STATUS_FAILED;
         }
diff -Nru bitcoinabc-0.21.11/src/blockindex.cpp bitcoinabc-0.21.12/src/blockindex.cpp
--- bitcoinabc-0.21.11/src/blockindex.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/blockindex.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -0,0 +1,77 @@
+// Copyright (c) 2009-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <blockindex.h>
+
+/**
+ * Turn the lowest '1' bit in the binary representation of a number into a '0'.
+ */
+static inline int InvertLowestOne(int n) {
+    return n & (n - 1);
+}
+
+/** Compute what height to jump back to with the CBlockIndex::pskip pointer. */
+static inline int GetSkipHeight(int height) {
+    if (height < 2) {
+        return 0;
+    }
+
+    // Determine which height to jump back to. Any number strictly lower than
+    // height is acceptable, but the following expression seems to perform well
+    // in simulations (max 110 steps to go back up to 2**18 blocks).
+    return (height & 1) ? InvertLowestOne(InvertLowestOne(height - 1)) + 1
+                        : InvertLowestOne(height);
+}
+
+bool CBlockIndex::UpdateChainStats() {
+    if (pprev == nullptr) {
+        nChainTx = nTx;
+        return true;
+    }
+
+    if (pprev->HaveTxsDownloaded()) {
+        nChainTx = pprev->nChainTx + nTx;
+        return true;
+    }
+
+    nChainTx = 0;
+    return false;
+}
+
+const CBlockIndex *CBlockIndex::GetAncestor(int height) const {
+    if (height > nHeight || height < 0) {
+        return nullptr;
+    }
+
+    const CBlockIndex *pindexWalk = this;
+    int heightWalk = nHeight;
+    while (heightWalk > height) {
+        int heightSkip = GetSkipHeight(heightWalk);
+        int heightSkipPrev = GetSkipHeight(heightWalk - 1);
+        if (pindexWalk->pskip != nullptr &&
+            (heightSkip == height ||
+             (heightSkip > height && !(heightSkipPrev < heightSkip - 2 &&
+                                       heightSkipPrev >= height)))) {
+            // Only follow pskip if pprev->pskip isn't better than pskip->pprev.
+            pindexWalk = pindexWalk->pskip;
+            heightWalk = heightSkip;
+        } else {
+            assert(pindexWalk->pprev);
+            pindexWalk = pindexWalk->pprev;
+            heightWalk--;
+        }
+    }
+    return pindexWalk;
+}
+
+CBlockIndex *CBlockIndex::GetAncestor(int height) {
+    return const_cast<CBlockIndex *>(
+        const_cast<const CBlockIndex *>(this)->GetAncestor(height));
+}
+
+void CBlockIndex::BuildSkip() {
+    if (pprev) {
+        pskip = pprev->GetAncestor(GetSkipHeight(nHeight));
+    }
+}
diff -Nru bitcoinabc-0.21.11/src/blockindex.h bitcoinabc-0.21.12/src/blockindex.h
--- bitcoinabc-0.21.11/src/blockindex.h	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/blockindex.h	2020-07-27 15:24:34.000000000 +0000
@@ -0,0 +1,212 @@
+// Copyright (c) 2009-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_BLOCKINDEX_H
+#define BITCOIN_BLOCKINDEX_H
+
+#include <arith_uint256.h>
+#include <blockstatus.h>
+#include <flatfile.h>
+#include <primitives/block.h>
+#include <tinyformat.h>
+#include <uint256.h>
+
+struct BlockHash;
+
+/**
+ * The block chain is a tree shaped structure starting with the genesis block at
+ * the root, with each block potentially having multiple candidates to be the
+ * next block. A blockindex may have multiple pprev pointing to it, but at most
+ * one of them can be part of the currently active branch.
+ */
+class CBlockIndex {
+public:
+    //! pointer to the hash of the block, if any. Memory is owned by this
+    //! CBlockIndex
+    const BlockHash *phashBlock = nullptr;
+
+    //! pointer to the index of the predecessor of this block
+    CBlockIndex *pprev = nullptr;
+
+    //! pointer to the index of some further predecessor of this block
+    CBlockIndex *pskip = nullptr;
+
+    //! height of the entry in the chain. The genesis block has height 0
+    int nHeight = 0;
+
+    //! Which # file this block is stored in (blk?????.dat)
+    int nFile = 0;
+
+    //! Byte offset within blk?????.dat where this block's data is stored
+    unsigned int nDataPos = 0;
+
+    //! Byte offset within rev?????.dat where this block's undo data is stored
+    unsigned int nUndoPos = 0;
+
+    //! (memory only) Total amount of work (expected number of hashes) in the
+    //! chain up to and including this block
+    arith_uint256 nChainWork = arith_uint256();
+
+    //! Number of transactions in this block.
+    //! Note: in a potential headers-first mode, this number cannot be relied
+    //! upon
+    unsigned int nTx = 0;
+
+private:
+    //! (memory only) Number of transactions in the chain up to and including
+    //! this block.
+    //! This value will be non-zero only if and only if transactions for this
+    //! block and all its parents are available. Change to 64-bit type when
+    //! necessary; won't happen before 2030
+    unsigned int nChainTx = 0;
+
+public:
+    //! Verification status of this block. See enum BlockStatus
+    BlockStatus nStatus = BlockStatus();
+
+    //! block header
+    int32_t nVersion = 0;
+    uint256 hashMerkleRoot = uint256();
+    uint32_t nTime = 0;
+    uint32_t nBits = 0;
+    uint32_t nNonce = 0;
+
+    //! (memory only) Sequential id assigned to distinguish order in which
+    //! blocks are received.
+    int32_t nSequenceId = 0;
+
+    //! (memory only) block header metadata
+    uint64_t nTimeReceived = 0;
+
+    //! (memory only) Maximum nTime in the chain up to and including this block.
+    unsigned int nTimeMax = 0;
+
+    explicit CBlockIndex() = default;
+
+    explicit CBlockIndex(const CBlockHeader &block) : CBlockIndex() {
+        nVersion = block.nVersion;
+        hashMerkleRoot = block.hashMerkleRoot;
+        nTime = block.nTime;
+        nTimeReceived = 0;
+        nBits = block.nBits;
+        nNonce = block.nNonce;
+    }
+
+    FlatFilePos GetBlockPos() const {
+        FlatFilePos ret;
+        if (nStatus.hasData()) {
+            ret.nFile = nFile;
+            ret.nPos = nDataPos;
+        }
+        return ret;
+    }
+
+    FlatFilePos GetUndoPos() const {
+        FlatFilePos ret;
+        if (nStatus.hasUndo()) {
+            ret.nFile = nFile;
+            ret.nPos = nUndoPos;
+        }
+        return ret;
+    }
+
+    CBlockHeader GetBlockHeader() const {
+        CBlockHeader block;
+        block.nVersion = nVersion;
+        if (pprev) {
+            block.hashPrevBlock = pprev->GetBlockHash();
+        }
+        block.hashMerkleRoot = hashMerkleRoot;
+        block.nTime = nTime;
+        block.nBits = nBits;
+        block.nNonce = nNonce;
+        return block;
+    }
+
+    BlockHash GetBlockHash() const { return *phashBlock; }
+
+    /**
+     * Get the number of transaction in the chain so far.
+     */
+    int64_t GetChainTxCount() const { return nChainTx; }
+
+    /**
+     * Update chain tx stats.
+     */
+    bool UpdateChainStats();
+
+    /**
+     * Check whether this block's and all previous blocks' transactions have
+     * been downloaded (and stored to disk) at some point.
+     *
+     * Does not imply the transactions are consensus-valid (ConnectTip might
+     * fail) Does not imply the transactions are still stored on disk.
+     * (IsBlockPruned might return true)
+     */
+    bool HaveTxsDownloaded() const { return GetChainTxCount() != 0; }
+
+    int64_t GetBlockTime() const { return int64_t(nTime); }
+
+    int64_t GetBlockTimeMax() const { return int64_t(nTimeMax); }
+
+    int64_t GetHeaderReceivedTime() const { return nTimeReceived; }
+
+    int64_t GetReceivedTimeDiff() const {
+        return GetHeaderReceivedTime() - GetBlockTime();
+    }
+
+    static constexpr int nMedianTimeSpan = 11;
+
+    int64_t GetMedianTimePast() const {
+        int64_t pmedian[nMedianTimeSpan];
+        int64_t *pbegin = &pmedian[nMedianTimeSpan];
+        int64_t *pend = &pmedian[nMedianTimeSpan];
+
+        const CBlockIndex *pindex = this;
+        for (int i = 0; i < nMedianTimeSpan && pindex;
+             i++, pindex = pindex->pprev) {
+            *(--pbegin) = pindex->GetBlockTime();
+        }
+
+        std::sort(pbegin, pend);
+        return pbegin[(pend - pbegin) / 2];
+    }
+
+    std::string ToString() const {
+        return strprintf(
+            "CBlockIndex(pprev=%p, nHeight=%d, merkle=%s, hashBlock=%s)", pprev,
+            nHeight, hashMerkleRoot.ToString(), GetBlockHash().ToString());
+    }
+
+    //! Check whether this block index entry is valid up to the passed validity
+    //! level.
+    bool IsValid(enum BlockValidity nUpTo = BlockValidity::TRANSACTIONS) const {
+        return nStatus.isValid(nUpTo);
+    }
+
+    //! Raise the validity level of this block index entry.
+    //! Returns true if the validity was changed.
+    bool RaiseValidity(enum BlockValidity nUpTo) {
+        // Only validity flags allowed.
+        if (nStatus.isInvalid()) {
+            return false;
+        }
+
+        if (nStatus.getValidity() >= nUpTo) {
+            return false;
+        }
+
+        nStatus = nStatus.withValidity(nUpTo);
+        return true;
+    }
+
+    //! Build the skiplist pointer for this entry.
+    void BuildSkip();
+
+    //! Efficiently find an ancestor of this block.
+    CBlockIndex *GetAncestor(int height);
+    const CBlockIndex *GetAncestor(int height) const;
+};
+
+#endif // BITCOIN_BLOCKINDEX_H
diff -Nru bitcoinabc-0.21.11/src/blockindexworkcomparator.h bitcoinabc-0.21.12/src/blockindexworkcomparator.h
--- bitcoinabc-0.21.11/src/blockindexworkcomparator.h	2020-06-30 00:19:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/blockindexworkcomparator.h	2020-07-27 15:24:34.000000000 +0000
@@ -5,8 +5,7 @@
 #ifndef BITCOIN_BLOCKINDEXWORKCOMPARATOR_H
 #define BITCOIN_BLOCKINDEXWORKCOMPARATOR_H
 
-// TODO: Split chain.h apart and only include CBlockIndex
-#include <chain.h>
+#include <blockindex.h>
 
 struct CBlockIndexWorkComparator {
     bool operator()(const CBlockIndex *pa, const CBlockIndex *pb) const {
diff -Nru bitcoinabc-0.21.11/src/chain.cpp bitcoinabc-0.21.12/src/chain.cpp
--- bitcoinabc-0.21.11/src/chain.cpp	2020-06-30 00:18:54.000000000 +0000
+++ bitcoinabc-0.21.12/src/chain.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -77,78 +77,6 @@
     return (lower == vChain.end() ? nullptr : *lower);
 }
 
-bool CBlockIndex::UpdateChainStats() {
-    if (pprev == nullptr) {
-        nChainTx = nTx;
-        return true;
-    }
-
-    if (pprev->HaveTxsDownloaded()) {
-        nChainTx = pprev->nChainTx + nTx;
-        return true;
-    }
-
-    nChainTx = 0;
-    return false;
-}
-
-/**
- * Turn the lowest '1' bit in the binary representation of a number into a '0'.
- */
-static inline int InvertLowestOne(int n) {
-    return n & (n - 1);
-}
-
-/** Compute what height to jump back to with the CBlockIndex::pskip pointer. */
-static inline int GetSkipHeight(int height) {
-    if (height < 2) {
-        return 0;
-    }
-
-    // Determine which height to jump back to. Any number strictly lower than
-    // height is acceptable, but the following expression seems to perform well
-    // in simulations (max 110 steps to go back up to 2**18 blocks).
-    return (height & 1) ? InvertLowestOne(InvertLowestOne(height - 1)) + 1
-                        : InvertLowestOne(height);
-}
-
-const CBlockIndex *CBlockIndex::GetAncestor(int height) const {
-    if (height > nHeight || height < 0) {
-        return nullptr;
-    }
-
-    const CBlockIndex *pindexWalk = this;
-    int heightWalk = nHeight;
-    while (heightWalk > height) {
-        int heightSkip = GetSkipHeight(heightWalk);
-        int heightSkipPrev = GetSkipHeight(heightWalk - 1);
-        if (pindexWalk->pskip != nullptr &&
-            (heightSkip == height ||
-             (heightSkip > height && !(heightSkipPrev < heightSkip - 2 &&
-                                       heightSkipPrev >= height)))) {
-            // Only follow pskip if pprev->pskip isn't better than pskip->pprev.
-            pindexWalk = pindexWalk->pskip;
-            heightWalk = heightSkip;
-        } else {
-            assert(pindexWalk->pprev);
-            pindexWalk = pindexWalk->pprev;
-            heightWalk--;
-        }
-    }
-    return pindexWalk;
-}
-
-CBlockIndex *CBlockIndex::GetAncestor(int height) {
-    return const_cast<CBlockIndex *>(
-        const_cast<const CBlockIndex *>(this)->GetAncestor(height));
-}
-
-void CBlockIndex::BuildSkip() {
-    if (pprev) {
-        pskip = pprev->GetAncestor(GetSkipHeight(nHeight));
-    }
-}
-
 arith_uint256 GetBlockProof(const CBlockIndex &block) {
     arith_uint256 bnTarget;
     bool fNegative;
diff -Nru bitcoinabc-0.21.11/src/chain.h bitcoinabc-0.21.12/src/chain.h
--- bitcoinabc-0.21.11/src/chain.h	2020-06-30 00:19:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/chain.h	2020-07-27 15:24:34.000000000 +0000
@@ -7,6 +7,7 @@
 #define BITCOIN_CHAIN_H
 
 #include <arith_uint256.h>
+#include <blockindex.h>
 #include <blockstatus.h>
 #include <blockvalidity.h>
 #include <consensus/params.h>
@@ -43,201 +44,6 @@
 static constexpr int64_t MAX_BLOCK_TIME_GAP = 90 * 60;
 
 /**
- * The block chain is a tree shaped structure starting with the genesis block at
- * the root, with each block potentially having multiple candidates to be the
- * next block. A blockindex may have multiple pprev pointing to it, but at most
- * one of them can be part of the currently active branch.
- */
-class CBlockIndex {
-public:
-    //! pointer to the hash of the block, if any. Memory is owned by this
-    //! CBlockIndex
-    const BlockHash *phashBlock = nullptr;
-
-    //! pointer to the index of the predecessor of this block
-    CBlockIndex *pprev = nullptr;
-
-    //! pointer to the index of some further predecessor of this block
-    CBlockIndex *pskip = nullptr;
-
-    //! height of the entry in the chain. The genesis block has height 0
-    int nHeight = 0;
-
-    //! Which # file this block is stored in (blk?????.dat)
-    int nFile = 0;
-
-    //! Byte offset within blk?????.dat where this block's data is stored
-    unsigned int nDataPos = 0;
-
-    //! Byte offset within rev?????.dat where this block's undo data is stored
-    unsigned int nUndoPos = 0;
-
-    //! (memory only) Total amount of work (expected number of hashes) in the
-    //! chain up to and including this block
-    arith_uint256 nChainWork = arith_uint256();
-
-    //! Number of transactions in this block.
-    //! Note: in a potential headers-first mode, this number cannot be relied
-    //! upon
-    unsigned int nTx = 0;
-
-private:
-    //! (memory only) Number of transactions in the chain up to and including
-    //! this block.
-    //! This value will be non-zero only if and only if transactions for this
-    //! block and all its parents are available. Change to 64-bit type when
-    //! necessary; won't happen before 2030
-    unsigned int nChainTx = 0;
-
-public:
-    //! Verification status of this block. See enum BlockStatus
-    BlockStatus nStatus = BlockStatus();
-
-    //! block header
-    int32_t nVersion = 0;
-    uint256 hashMerkleRoot = uint256();
-    uint32_t nTime = 0;
-    uint32_t nBits = 0;
-    uint32_t nNonce = 0;
-
-    //! (memory only) Sequential id assigned to distinguish order in which
-    //! blocks are received.
-    int32_t nSequenceId = 0;
-
-    //! (memory only) block header metadata
-    uint64_t nTimeReceived = 0;
-
-    //! (memory only) Maximum nTime in the chain up to and including this block.
-    unsigned int nTimeMax = 0;
-
-    explicit CBlockIndex() = default;
-
-    explicit CBlockIndex(const CBlockHeader &block) : CBlockIndex() {
-        nVersion = block.nVersion;
-        hashMerkleRoot = block.hashMerkleRoot;
-        nTime = block.nTime;
-        nTimeReceived = 0;
-        nBits = block.nBits;
-        nNonce = block.nNonce;
-    }
-
-    FlatFilePos GetBlockPos() const {
-        FlatFilePos ret;
-        if (nStatus.hasData()) {
-            ret.nFile = nFile;
-            ret.nPos = nDataPos;
-        }
-        return ret;
-    }
-
-    FlatFilePos GetUndoPos() const {
-        FlatFilePos ret;
-        if (nStatus.hasUndo()) {
-            ret.nFile = nFile;
-            ret.nPos = nUndoPos;
-        }
-        return ret;
-    }
-
-    CBlockHeader GetBlockHeader() const {
-        CBlockHeader block;
-        block.nVersion = nVersion;
-        if (pprev) {
-            block.hashPrevBlock = pprev->GetBlockHash();
-        }
-        block.hashMerkleRoot = hashMerkleRoot;
-        block.nTime = nTime;
-        block.nBits = nBits;
-        block.nNonce = nNonce;
-        return block;
-    }
-
-    BlockHash GetBlockHash() const { return *phashBlock; }
-
-    /**
-     * Get the number of transaction in the chain so far.
-     */
-    int64_t GetChainTxCount() const { return nChainTx; }
-
-    /**
-     * Update chain tx stats.
-     */
-    bool UpdateChainStats();
-
-    /**
-     * Check whether this block's and all previous blocks' transactions have
-     * been downloaded (and stored to disk) at some point.
-     *
-     * Does not imply the transactions are consensus-valid (ConnectTip might
-     * fail) Does not imply the transactions are still stored on disk.
-     * (IsBlockPruned might return true)
-     */
-    bool HaveTxsDownloaded() const { return GetChainTxCount() != 0; }
-
-    int64_t GetBlockTime() const { return int64_t(nTime); }
-
-    int64_t GetBlockTimeMax() const { return int64_t(nTimeMax); }
-
-    int64_t GetHeaderReceivedTime() const { return nTimeReceived; }
-
-    int64_t GetReceivedTimeDiff() const {
-        return GetHeaderReceivedTime() - GetBlockTime();
-    }
-
-    static constexpr int nMedianTimeSpan = 11;
-
-    int64_t GetMedianTimePast() const {
-        int64_t pmedian[nMedianTimeSpan];
-        int64_t *pbegin = &pmedian[nMedianTimeSpan];
-        int64_t *pend = &pmedian[nMedianTimeSpan];
-
-        const CBlockIndex *pindex = this;
-        for (int i = 0; i < nMedianTimeSpan && pindex;
-             i++, pindex = pindex->pprev) {
-            *(--pbegin) = pindex->GetBlockTime();
-        }
-
-        std::sort(pbegin, pend);
-        return pbegin[(pend - pbegin) / 2];
-    }
-
-    std::string ToString() const {
-        return strprintf(
-            "CBlockIndex(pprev=%p, nHeight=%d, merkle=%s, hashBlock=%s)", pprev,
-            nHeight, hashMerkleRoot.ToString(), GetBlockHash().ToString());
-    }
-
-    //! Check whether this block index entry is valid up to the passed validity
-    //! level.
-    bool IsValid(enum BlockValidity nUpTo = BlockValidity::TRANSACTIONS) const {
-        return nStatus.isValid(nUpTo);
-    }
-
-    //! Raise the validity level of this block index entry.
-    //! Returns true if the validity was changed.
-    bool RaiseValidity(enum BlockValidity nUpTo) {
-        // Only validity flags allowed.
-        if (nStatus.isInvalid()) {
-            return false;
-        }
-
-        if (nStatus.getValidity() >= nUpTo) {
-            return false;
-        }
-
-        nStatus = nStatus.withValidity(nUpTo);
-        return true;
-    }
-
-    //! Build the skiplist pointer for this entry.
-    void BuildSkip();
-
-    //! Efficiently find an ancestor of this block.
-    CBlockIndex *GetAncestor(int height);
-    const CBlockIndex *GetAncestor(int height) const;
-};
-
-/**
  * Maintain a map of CBlockIndex for all known headers.
  */
 struct BlockHasher {
diff -Nru bitcoinabc-0.21.11/src/chainparamsconstants.h bitcoinabc-0.21.12/src/chainparamsconstants.h
--- bitcoinabc-0.21.11/src/chainparamsconstants.h	2020-07-09 15:34:59.000000000 +0000
+++ bitcoinabc-0.21.12/src/chainparamsconstants.h	2020-07-27 15:24:34.000000000 +0000
@@ -9,13 +9,13 @@
 #include <uint256.h>
 
 namespace ChainParamsConstants {
-    const BlockHash MAINNET_DEFAULT_ASSUME_VALID = BlockHash::fromHex("0000000000000000013add16221ff595c977de1027c8c3f962acf8fcdfa05065");
-    const uint256 MAINNET_MINIMUM_CHAIN_WORK = uint256S("0000000000000000000000000000000000000000013b3489eb103468fa735866");
-    const uint64_t MAINNET_ASSUMED_BLOCKCHAIN_SIZE = 204;
+    const BlockHash MAINNET_DEFAULT_ASSUME_VALID = BlockHash::fromHex("000000000000000001831f2498ccf63ab3153bf6046362513832a0ac8008c16e");
+    const uint256 MAINNET_MINIMUM_CHAIN_WORK = uint256S("0000000000000000000000000000000000000000013e03edc46165e17570aac7");
+    const uint64_t MAINNET_ASSUMED_BLOCKCHAIN_SIZE = 205;
     const uint64_t MAINNET_ASSUMED_CHAINSTATE_SIZE = 3;
 
-    const BlockHash TESTNET_DEFAULT_ASSUME_VALID = BlockHash::fromHex("0000000000190c28546af514f5255d8afae5c5f756e191e9b8e9724a1e256e61");
-    const uint256 TESTNET_MINIMUM_CHAIN_WORK = uint256S("0000000000000000000000000000000000000000000000682bd38e9265377ec0");
+    const BlockHash TESTNET_DEFAULT_ASSUME_VALID = BlockHash::fromHex("0000000031bedd3009e21403ad61614af5237093f8a794c7c7c1dd5d312fc61e");
+    const uint256 TESTNET_MINIMUM_CHAIN_WORK = uint256S("00000000000000000000000000000000000000000000006983387157261b3275");
     const uint64_t TESTNET_ASSUMED_BLOCKCHAIN_SIZE = 55;
     const uint64_t TESTNET_ASSUMED_CHAINSTATE_SIZE = 2;
 } // namespace ChainParamsConstants
diff -Nru bitcoinabc-0.21.11/src/chainparams.cpp bitcoinabc-0.21.12/src/chainparams.cpp
--- bitcoinabc-0.21.11/src/chainparams.cpp	2020-07-01 23:24:38.000000000 +0000
+++ bitcoinabc-0.21.12/src/chainparams.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -108,46 +108,6 @@
             // December 31, 2008
             .nTimeout = 1230767999,
         };
-        consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND] = {
-            .bit = 0,
-            // 66% of 2016
-            .nActivationThreshold = 1344,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-        consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ABC] = {
-            .bit = 1,
-            // 66% of 2016
-            .nActivationThreshold = 1344,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-        consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_BCHD] = {
-            .bit = 2,
-            // 66% of 2016
-            .nActivationThreshold = 1344,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-        consensus
-            .vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ELECTRON_CASH] = {
-            .bit = 3,
-            // 66% of 2016
-            .nActivationThreshold = 1344,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-
-        // The miner fund is enabled by default on mainnet.
-        consensus.enableMinerFund = true;
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork =
@@ -343,46 +303,6 @@
             // December 31, 2008
             .nTimeout = 1230767999,
         };
-        consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND] = {
-            .bit = 0,
-            // 66% of 2016
-            .nActivationThreshold = 1344,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-        consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ABC] = {
-            .bit = 1,
-            // 66% of 2016
-            .nActivationThreshold = 1344,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-        consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_BCHD] = {
-            .bit = 2,
-            // 66% of 2016
-            .nActivationThreshold = 1344,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-        consensus
-            .vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ELECTRON_CASH] = {
-            .bit = 3,
-            // 66% of 2016
-            .nActivationThreshold = 1344,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-
-        // The miner fund is disabled by default on testnet.
-        consensus.enableMinerFund = false;
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork =
@@ -529,46 +449,6 @@
             // 75% of 144
             .nActivationThreshold = 108,
         };
-        consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND] = {
-            .bit = 0,
-            // 66% of 144
-            .nActivationThreshold = 96,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-        consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ABC] = {
-            .bit = 1,
-            // 66% of 144
-            .nActivationThreshold = 96,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-        consensus.vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_BCHD] = {
-            .bit = 2,
-            // 66% of 144
-            .nActivationThreshold = 96,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-        consensus
-            .vDeployments[Consensus::DEPLOYEMENT_MINER_FUND_ELECTRON_CASH] = {
-            .bit = 3,
-            // 66% of 144
-            .nActivationThreshold = 96,
-            // Nov 15, 2019 12:00:00 UTC
-            .nStartTime = 1573819200,
-            // May 15, 2020 12:00:00 UTC
-            .nTimeout = 1589544000,
-        };
-
-        // The miner fund is disabled by default on regnet.
-        consensus.enableMinerFund = false;
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork = uint256S("0x00");
diff -Nru bitcoinabc-0.21.11/src/chainparamsseeds.h bitcoinabc-0.21.12/src/chainparamsseeds.h
--- bitcoinabc-0.21.11/src/chainparamsseeds.h	2020-07-09 15:34:59.000000000 +0000
+++ bitcoinabc-0.21.12/src/chainparamsseeds.h	2020-07-27 15:24:34.000000000 +0000
@@ -8,21 +8,23 @@
  * IPv4 as well as onion addresses are wrapped inside an IPv6 address accordingly.
  */
 static SeedSpec6 pnSeed6_main[] = {
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x03,0x85,0xae,0xed}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x14,0xbc,0x29}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0x4f,0x7b,0xc2}, 9444},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x0d,0x5a,0x8d,0x0d}, 8333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x0d,0xfa,0x70,0x81}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x1b,0x7c,0x11,0x0a}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x1f,0x19,0xf1,0xe0}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x1f,0xdc,0x38,0xc3}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0x5c,0x51,0x7c}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xe1,0x6b,0x8e}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xf4,0xbc,0xda}, 8333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xc3,0xea,0x73}, 9333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x27,0x60,0xbc,0xb9}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xf0,0xdd,0x5a}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x27,0x61,0xb1,0x37}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0x20,0xb2,0xec}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2d,0xfc,0xfa,0xf4}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2e,0xa6,0x8e,0x34}, 8333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x38,0x89,0x9a}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x5a,0x66,0x46}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x6c,0x1e,0x12}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x32,0x27,0xf5,0x1a}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x32,0xdc,0x79,0xd3}, 6628},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x0f,0xbc,0x21}, 8333},
@@ -30,15 +32,15 @@
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0x74,0x9f,0xf6}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xcb,0x42,0x34}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xf6,0xa6,0xc0}, 8333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x36,0x59,0x12,0xc9}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3d,0x12,0x97,0x4e}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3e,0x41,0xc6,0xe5}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x3e,0x70,0x08,0x89}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x42,0x97,0xf2,0x9a}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x44,0x04,0x76,0xf4}, 8333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x44,0xb7,0x4c,0xd7}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x44,0xb7,0xdf,0x7a}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x46,0x43,0x92,0x2d}, 10503},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x46,0xb8,0xf7,0x2c}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4b,0x86,0x5e,0xa1}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4d,0x78,0x71,0x45}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x4d,0x78,0x7a,0x76}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x50,0xb3,0xe2,0x30}, 8333},
@@ -48,7 +50,6 @@
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x52,0xdd,0x80,0xcd}, 8364},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x53,0xdd,0xd3,0x74}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x55,0xd6,0x5d,0xa9}, 8333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x56,0xbf,0xd9,0x14}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x59,0xb3,0xf7,0xec}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5b,0x4d,0x89,0x0f}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5b,0xc5,0x2c,0x90}, 8333},
@@ -56,15 +57,17 @@
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5e,0x13,0x84,0xff}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5e,0xc7,0xb2,0xe9}, 8101},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xae,0x42,0xd3}, 8334},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd8,0x05,0x1f}, 8333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd8,0x09,0xf0}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xb3,0xb3,0xce}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd8,0x0b,0x9c}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x65,0x63,0x5a,0xbd}, 8333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x67,0xe6,0xb9,0x04}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x68,0xf8,0x52,0x99}, 7333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6d,0xc3,0x96,0x6a}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x70,0xd5,0x7e,0x93}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x73,0xb1,0x95,0x6a}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x74,0x6d,0x83,0xc9}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x79,0x4e,0xdf,0xc3}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x8b,0xa2,0xf7,0xf3}, 8333},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x90,0x4c,0x75,0xe9}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x95,0x81,0x6e,0xd3}, 59080},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9f,0x7a,0x5c,0x72}, 8442},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa2,0x3e,0x15,0xb6}, 8333},
@@ -81,7 +84,6 @@
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xb9,0xd9,0x00,0x6b}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0x7f,0xe5,0xee}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0xa5,0xd5,0x12}, 8333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0xd6,0x1e,0x5f}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xbc,0xd6,0x81,0x41}, 20022},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc0,0x1e,0x59,0x8e}, 60714},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc0,0xbb,0x79,0x2b}, 8333},
@@ -97,7 +99,6 @@
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xce,0x7c,0x95,0x43}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd4,0x20,0xe7,0xa2}, 8333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xd5,0x88,0x4c,0xcf}, 8333},
-    {{0x20,0x01,0x19,0xf0,0x74,0x02,0x02,0x92,0x54,0x00,0x00,0xff,0xfe,0x76,0x13,0x39}, 8333},
     {{0x20,0x01,0x04,0x70,0x00,0x08,0x08,0x09,0x00,0x00,0x00,0x00,0x00,0x00,0x1d,0xf5}, 8333},
     {{0x20,0x01,0x0f,0x40,0x09,0x04,0x73,0xff,0x05,0x25,0x39,0x74,0x9d,0x02,0x71,0x4d}, 8333},
     {{0x20,0x02,0x5d,0x73,0x1a,0x84,0x00,0x00,0x00,0x00,0x00,0x00,0x5d,0x73,0x1a,0x84}, 16300},
@@ -112,17 +113,17 @@
     {{0x2a,0x01,0x07,0xc8,0xd0,0x02,0x01,0x0f,0x50,0x54,0x00,0xff,0xfe,0x5c,0xda,0xc7}, 8133},
     {{0x2a,0x01,0x07,0xc8,0xd0,0x02,0x03,0x18,0x50,0x54,0x00,0xff,0xfe,0xbe,0xcb,0xb1}, 8133},
     {{0x2a,0x01,0x7e,0x00,0x00,0x00,0x00,0x00,0xf0,0x3c,0x91,0xff,0xfe,0xfb,0xc1,0x4e}, 8333},
-    {{0x2a,0x02,0x47,0x80,0x00,0x01,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x88,0x4a}, 8333},
     {{0x2a,0x02,0x7b,0x40,0xb0,0xdf,0x89,0x25,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01}, 8335},
     {{0x2a,0x03,0x1b,0x20,0x00,0x01,0xf4,0x10,0x00,0x40,0x00,0x00,0x00,0x00,0xac,0xef}, 8333},
-    {{0x2a,0x04,0x21,0x80,0x00,0x01,0x00,0x11,0xf0,0x00,0x00,0x00,0x00,0x00,0x00,0x16}, 8333}
+    {{0x2a,0x04,0x21,0x80,0x00,0x01,0x00,0x11,0xf0,0x00,0x00,0x00,0x00,0x00,0x00,0x16}, 8333},
+    {{0x2a,0x06,0xdd,0x00,0x00,0x01,0x00,0x12,0x02,0x23,0x7d,0xff,0xfe,0xaa,0x72,0xc4}, 8333}
 };
 
 static SeedSpec6 pnSeed6_test[] = {
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0xbc,0xba,0xac}, 18333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x05,0xbd,0x8d,0x4f}, 18333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x22,0xfd,0x33,0xeb}, 18333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x27,0x64,0x63,0x74}, 20008},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x2f,0x34,0x93,0xe8}, 18333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x33,0x59,0x62,0x4c}, 18333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0x89,0x30,0x2d}, 18333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x34,0xd3,0xd3,0x0b}, 18333},
@@ -130,10 +131,9 @@
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x46,0x43,0x30,0x86}, 18333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x6a,0x0a,0x22,0x4a}, 18333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x74,0xcb,0x76,0x51}, 18333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x78,0x4d,0x52,0xbe}, 18443},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x93,0x87,0xd1,0xe5}, 18333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9d,0xe6,0x72,0x0e}, 18333},
-    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9f,0x41,0x65,0xf0}, 8888},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9f,0x41,0x65,0xeb}, 8888},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9f,0x7a,0x5c,0x72}, 20022},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa3,0xac,0x87,0x90}, 18333},
     {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xc2,0x0e,0xf7,0x82}, 18333},
diff -Nru bitcoinabc-0.21.11/src/CMakeLists.txt bitcoinabc-0.21.12/src/CMakeLists.txt
--- bitcoinabc-0.21.11/src/CMakeLists.txt	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/CMakeLists.txt	2020-07-27 15:24:34.000000000 +0000
@@ -341,6 +341,7 @@
 	util/error.cpp
 	util/moneystr.cpp
 	util/settings.cpp
+	util/spanparsing.cpp
 	util/strencodings.cpp
 	util/string.cpp
 	util/system.cpp
@@ -500,9 +501,11 @@
 	avalanche/peermanager.cpp
 	avalanche/processor.cpp
 	avalanche/proof.cpp
+	avalanche/proofbuilder.cpp
 	banman.cpp
 	blockencodings.cpp
 	blockfilter.cpp
+	blockindex.cpp
 	chain.cpp
 	checkpoints.cpp
 	config.cpp
@@ -519,7 +522,6 @@
 	interfaces/chain.cpp
 	interfaces/node.cpp
 	miner.cpp
-	minerfund.cpp
 	net.cpp
 	net_processing.cpp
 	node/coin.cpp
@@ -530,7 +532,9 @@
 	noui.cpp
 	policy/fees.cpp
 	policy/settings.cpp
-	pow.cpp
+	pow/daa.cpp
+	pow/eda.cpp
+	pow/pow.cpp
 	rest.cpp
 	rpc/abc.cpp
 	rpc/avalanche.cpp
@@ -586,6 +590,7 @@
 # Test suites.
 add_subdirectory(test)
 add_subdirectory(avalanche/test)
+add_subdirectory(pow/test)
 
 # Benchmark suite.
 add_subdirectory(bench)
diff -Nru bitcoinabc-0.21.11/src/consensus/params.h bitcoinabc-0.21.12/src/consensus/params.h
--- bitcoinabc-0.21.11/src/consensus/params.h	2020-07-01 23:24:38.000000000 +0000
+++ bitcoinabc-0.21.12/src/consensus/params.h	2020-07-27 15:24:34.000000000 +0000
@@ -15,10 +15,6 @@
 
 enum DeploymentPos {
     DEPLOYMENT_TESTDUMMY,
-    DEPLOYEMENT_MINER_FUND,
-    DEPLOYEMENT_MINER_FUND_ABC,
-    DEPLOYEMENT_MINER_FUND_BCHD,
-    DEPLOYEMENT_MINER_FUND_ELECTRON_CASH,
     // NOTE: Also add new deployments to VersionBitsDeploymentInfo in
     // versionbitsinfo.cpp
     MAX_VERSION_BITS_DEPLOYMENTS,
@@ -95,9 +91,6 @@
     uint32_t nMinerConfirmationWindow;
     BIP9Deployment vDeployments[MAX_VERSION_BITS_DEPLOYMENTS];
 
-    /** Enable or disable te miner fund by default */
-    bool enableMinerFund;
-
     /** Proof of work parameters */
     uint256 powLimit;
     bool fPowAllowMinDifficultyBlocks;
diff -Nru bitcoinabc-0.21.11/src/consensus/tx_check.cpp bitcoinabc-0.21.12/src/consensus/tx_check.cpp
--- bitcoinabc-0.21.11/src/consensus/tx_check.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/consensus/tx_check.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -11,40 +11,40 @@
 #include <unordered_set>
 
 static bool CheckTransactionCommon(const CTransaction &tx,
-                                   CValidationState &state) {
+                                   TxValidationState &state) {
     // Basic checks that don't depend on any context
     if (tx.vin.empty()) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-vin-empty");
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, REJECT_INVALID,
+                             "bad-txns-vin-empty");
     }
 
     if (tx.vout.empty()) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-vout-empty");
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, REJECT_INVALID,
+                             "bad-txns-vout-empty");
     }
 
     // Size limit
     if (::GetSerializeSize(tx, PROTOCOL_VERSION) > MAX_TX_SIZE) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-oversize");
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, REJECT_INVALID,
+                             "bad-txns-oversize");
     }
 
     // Check for negative or overflow output values
     Amount nValueOut = Amount::zero();
     for (const auto &txout : tx.vout) {
         if (txout.nValue < Amount::zero()) {
-            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+            return state.Invalid(TxValidationResult::TX_CONSENSUS,
                                  REJECT_INVALID, "bad-txns-vout-negative");
         }
 
         if (txout.nValue > MAX_MONEY) {
-            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+            return state.Invalid(TxValidationResult::TX_CONSENSUS,
                                  REJECT_INVALID, "bad-txns-vout-toolarge");
         }
 
         nValueOut += txout.nValue;
         if (!MoneyRange(nValueOut)) {
-            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+            return state.Invalid(TxValidationResult::TX_CONSENSUS,
                                  REJECT_INVALID,
                                  "bad-txns-txouttotal-toolarge");
         }
@@ -53,11 +53,10 @@
     return true;
 }
 
-bool CheckCoinbase(const CTransaction &tx, CValidationState &state) {
+bool CheckCoinbase(const CTransaction &tx, TxValidationState &state) {
     if (!tx.IsCoinBase()) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-cb-missing",
-                             "first tx is not coinbase");
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, REJECT_INVALID,
+                             "bad-cb-missing", "first tx is not coinbase");
     }
 
     if (!CheckTransactionCommon(tx, state)) {
@@ -67,17 +66,17 @@
 
     if (tx.vin[0].scriptSig.size() < 2 ||
         tx.vin[0].scriptSig.size() > MAX_COINBASE_SCRIPTSIG_SIZE) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-cb-length");
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, REJECT_INVALID,
+                             "bad-cb-length");
     }
 
     return true;
 }
 
-bool CheckRegularTransaction(const CTransaction &tx, CValidationState &state) {
+bool CheckRegularTransaction(const CTransaction &tx, TxValidationState &state) {
     if (tx.IsCoinBase()) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-tx-coinbase");
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, REJECT_INVALID,
+                             "bad-tx-coinbase");
     }
 
     if (!CheckTransactionCommon(tx, state)) {
@@ -88,12 +87,18 @@
     std::unordered_set<COutPoint, SaltedOutpointHasher> vInOutPoints;
     for (const auto &txin : tx.vin) {
         if (txin.prevout.IsNull()) {
-            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+            return state.Invalid(TxValidationResult::TX_CONSENSUS,
                                  REJECT_INVALID, "bad-txns-prevout-null");
         }
 
+        // Check for duplicate inputs (see CVE-2018-17144)
+        // While Consensus::CheckTxInputs does check if all inputs of a tx are
+        // available, and UpdateCoins marks all inputs of a tx as spent, it does
+        // not check if the tx has duplicate inputs. Failure to run this check
+        // will result in either a crash or an inflation bug, depending on the
+        // implementation of the underlying coins database.
         if (!vInOutPoints.insert(txin.prevout).second) {
-            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+            return state.Invalid(TxValidationResult::TX_CONSENSUS,
                                  REJECT_INVALID, "bad-txns-inputs-duplicate");
         }
     }
diff -Nru bitcoinabc-0.21.11/src/consensus/tx_check.h bitcoinabc-0.21.12/src/consensus/tx_check.h
--- bitcoinabc-0.21.11/src/consensus/tx_check.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/consensus/tx_check.h	2020-07-15 16:44:34.000000000 +0000
@@ -13,14 +13,14 @@
  */
 
 class CTransaction;
-class CValidationState;
+class TxValidationState;
 
 /**
  * Context-independent validity checks for coinbase and non-coinbase
  * transactions.
  */
 
-bool CheckRegularTransaction(const CTransaction &tx, CValidationState &state);
-bool CheckCoinbase(const CTransaction &tx, CValidationState &state);
+bool CheckRegularTransaction(const CTransaction &tx, TxValidationState &state);
+bool CheckCoinbase(const CTransaction &tx, TxValidationState &state);
 
 #endif // BITCOIN_CONSENSUS_TX_CHECK_H
diff -Nru bitcoinabc-0.21.11/src/consensus/tx_verify.cpp bitcoinabc-0.21.12/src/consensus/tx_verify.cpp
--- bitcoinabc-0.21.11/src/consensus/tx_verify.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/consensus/tx_verify.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -38,21 +38,21 @@
 }
 
 bool ContextualCheckTransaction(const Consensus::Params &params,
-                                const CTransaction &tx, CValidationState &state,
-                                int nHeight, int64_t nLockTimeCutoff,
+                                const CTransaction &tx,
+                                TxValidationState &state, int nHeight,
+                                int64_t nLockTimeCutoff,
                                 int64_t nMedianTimePast) {
     if (!IsFinalTx(tx, nHeight, nLockTimeCutoff)) {
         // While this is only one transaction, we use txns in the error to
         // ensure continuity with other clients.
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-nonfinal",
-                             "non-final transaction");
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, REJECT_INVALID,
+                             "bad-txns-nonfinal", "non-final transaction");
     }
 
     if (IsMagneticAnomalyEnabled(params, nHeight)) {
         // Size limit
         if (::GetSerializeSize(tx, PROTOCOL_VERSION) < MIN_TX_SIZE) {
-            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+            return state.Invalid(TxValidationResult::TX_CONSENSUS,
                                  REJECT_INVALID, "bad-txns-undersize");
         }
     }
@@ -155,12 +155,12 @@
 }
 
 namespace Consensus {
-bool CheckTxInputs(const CTransaction &tx, CValidationState &state,
+bool CheckTxInputs(const CTransaction &tx, TxValidationState &state,
                    const CCoinsViewCache &inputs, int nSpendHeight,
                    Amount &txfee) {
     // are the actual inputs available?
     if (!inputs.HaveInputs(tx)) {
-        return state.Invalid(ValidationInvalidReason::TX_MISSING_INPUTS, false,
+        return state.Invalid(TxValidationResult::TX_MISSING_INPUTS,
                              REJECT_INVALID, "bad-txns-inputs-missingorspent",
                              strprintf("%s: inputs missing/spent", __func__));
     }
@@ -175,8 +175,8 @@
         if (coin.IsCoinBase() &&
             nSpendHeight - coin.GetHeight() < COINBASE_MATURITY) {
             return state.Invalid(
-                ValidationInvalidReason::TX_PREMATURE_SPEND, false,
-                REJECT_INVALID, "bad-txns-premature-spend-of-coinbase",
+                TxValidationResult::TX_PREMATURE_SPEND, REJECT_INVALID,
+                "bad-txns-premature-spend-of-coinbase",
                 strprintf("tried to spend coinbase at depth %d",
                           nSpendHeight - coin.GetHeight()));
         }
@@ -184,7 +184,7 @@
         // Check for negative or overflow input values
         nValueIn += coin.GetTxOut().nValue;
         if (!MoneyRange(coin.GetTxOut().nValue) || !MoneyRange(nValueIn)) {
-            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+            return state.Invalid(TxValidationResult::TX_CONSENSUS,
                                  REJECT_INVALID,
                                  "bad-txns-inputvalues-outofrange");
         }
@@ -192,8 +192,8 @@
 
     const Amount value_out = tx.GetValueOut();
     if (nValueIn < value_out) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-in-belowout",
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, REJECT_INVALID,
+                             "bad-txns-in-belowout",
                              strprintf("value in (%s) < value out (%s)",
                                        FormatMoney(nValueIn),
                                        FormatMoney(value_out)));
@@ -202,8 +202,8 @@
     // Tally transaction fees
     const Amount txfee_aux = nValueIn - value_out;
     if (!MoneyRange(txfee_aux)) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-txns-fee-outofrange");
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, REJECT_INVALID,
+                             "bad-txns-fee-outofrange");
     }
 
     txfee = txfee_aux;
diff -Nru bitcoinabc-0.21.11/src/consensus/tx_verify.h bitcoinabc-0.21.12/src/consensus/tx_verify.h
--- bitcoinabc-0.21.11/src/consensus/tx_verify.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/consensus/tx_verify.h	2020-07-15 16:44:34.000000000 +0000
@@ -12,7 +12,7 @@
 class CBlockIndex;
 class CCoinsViewCache;
 class CTransaction;
-class CValidationState;
+class TxValidationState;
 
 namespace Consensus {
 struct Params;
@@ -24,7 +24,7 @@
  * @param[out] txfee Set to the transaction fee if successful.
  * Preconditions: tx.IsCoinBase() is false.
  */
-bool CheckTxInputs(const CTransaction &tx, CValidationState &state,
+bool CheckTxInputs(const CTransaction &tx, TxValidationState &state,
                    const CCoinsViewCache &inputs, int nSpendHeight,
                    Amount &txfee);
 
@@ -37,8 +37,9 @@
  * activation/deactivation and CLTV.
  */
 bool ContextualCheckTransaction(const Consensus::Params &params,
-                                const CTransaction &tx, CValidationState &state,
-                                int nHeight, int64_t nLockTimeCutoff,
+                                const CTransaction &tx,
+                                TxValidationState &state, int nHeight,
+                                int64_t nLockTimeCutoff,
                                 int64_t nMedianTimePast);
 
 /**
diff -Nru bitcoinabc-0.21.11/src/consensus/validation.h bitcoinabc-0.21.12/src/consensus/validation.h
--- bitcoinabc-0.21.11/src/consensus/validation.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/consensus/validation.h	2020-07-15 16:44:34.000000000 +0000
@@ -19,130 +19,154 @@
 static const uint8_t REJECT_CHECKPOINT = 0x43;
 
 /**
- * A "reason" why something was invalid, suitable for determining whether the
- * provider of the object should be banned/ignored/disconnected/etc. These are
- * much more granular than the rejection codes, which may be more useful for
- * some other use-cases.
+ * A "reason" why a transaction was invalid, suitable for determining whether
+ * the provider of the transaction should be banned/ignored/disconnected/etc.
+ * These are much more granular than the rejection codes, which may be more
+ * useful for some other use-cases.
  */
-enum class ValidationInvalidReason {
-    // txn and blocks:
-    //! not actually invalid
-    NONE,
-    //! invalid by consensus rules (excluding any below reasons)
-    CONSENSUS,
+enum class TxValidationResult {
+    //! initial value. Tx has not yet been rejected
+    TX_RESULT_UNSET,
+    //! invalid by consensus rules
+    TX_CONSENSUS,
     /**
      * Invalid by a recent change to consensus rules.
      * Currently unused as there are no such consensus rule changes.
      */
-    RECENT_CONSENSUS_CHANGE,
-    // Only blocks (or headers):
-    //! this object was cached as being invalid, but we don't know why
-    CACHED_INVALID,
-    //! invalid proof of work or time too old
-    BLOCK_INVALID_HEADER,
-    //! the block's data didn't match the data committed to by the PoW
-    BLOCK_MUTATED,
-    //! We don't have the previous block the checked one is built on
-    BLOCK_MISSING_PREV,
-    //! A block this one builds on is invalid
-    BLOCK_INVALID_PREV,
-    //! block timestamp was > 2 hours in the future (or our clock is bad)
-    BLOCK_TIME_FUTURE,
-    //! the block failed to meet one of our checkpoints
-    BLOCK_CHECKPOINT,
-    //! block finalization problems.
-    BLOCK_FINALIZATION,
-    // Only loose txn:
+    TX_RECENT_CONSENSUS_CHANGE,
     //! didn't meet our local policy rules
     TX_NOT_STANDARD,
-    //! a transaction was missing some of its inputs
+    //! transaction was missing some of its inputs
     TX_MISSING_INPUTS,
     //! transaction spends a coinbase too early, or violates locktime/sequence
     //! locks
     TX_PREMATURE_SPEND,
     /**
      * Tx already in mempool or conflicts with a tx in the chain
-     * TODO: Currently this is only used if the transaction already exists in
-     * the mempool or on chain,
-     * TODO: ATMP's fMissingInputs and a valid CValidationState being used to
-     * indicate missing inputs
+     * Currently this is only used if the transaction already exists in the
+     * mempool or on chain.
      */
     TX_CONFLICT,
     //! violated mempool's fee/size/descendant/etc limits
     TX_MEMPOOL_POLICY,
 };
 
-inline bool IsTransactionReason(ValidationInvalidReason r) {
-    return r == ValidationInvalidReason::NONE ||
-           r == ValidationInvalidReason::CONSENSUS ||
-           r == ValidationInvalidReason::RECENT_CONSENSUS_CHANGE ||
-           r == ValidationInvalidReason::TX_NOT_STANDARD ||
-           r == ValidationInvalidReason::TX_PREMATURE_SPEND ||
-           r == ValidationInvalidReason::TX_MISSING_INPUTS ||
-           r == ValidationInvalidReason::TX_CONFLICT ||
-           r == ValidationInvalidReason::TX_MEMPOOL_POLICY;
-}
-
-inline bool IsBlockReason(ValidationInvalidReason r) {
-    return r == ValidationInvalidReason::NONE ||
-           r == ValidationInvalidReason::CONSENSUS ||
-           r == ValidationInvalidReason::RECENT_CONSENSUS_CHANGE ||
-           r == ValidationInvalidReason::CACHED_INVALID ||
-           r == ValidationInvalidReason::BLOCK_INVALID_HEADER ||
-           r == ValidationInvalidReason::BLOCK_MUTATED ||
-           r == ValidationInvalidReason::BLOCK_MISSING_PREV ||
-           r == ValidationInvalidReason::BLOCK_INVALID_PREV ||
-           r == ValidationInvalidReason::BLOCK_TIME_FUTURE ||
-           r == ValidationInvalidReason::BLOCK_CHECKPOINT ||
-           r == ValidationInvalidReason::BLOCK_FINALIZATION;
-}
+/**
+ * A "reason" why a block was invalid, suitable for determining whether the
+ * provider of the block should be banned/ignored/disconnected/etc.
+ * These are much more granular than the rejection codes, which may be more
+ * useful for some other use-cases.
+ */
+enum class BlockValidationResult {
+    //! initial value. Block has not yet been rejected
+    BLOCK_RESULT_UNSET,
+    //! invalid by consensus rules (excluding any below reasons)
+    BLOCK_CONSENSUS,
+    /**
+     * Invalid by a change to consensus rules more recent than SegWit.
+     * Currently unused as there are no such consensus rule changes, and any
+     * download sources realistically need to support SegWit in order to provide
+     * useful data, so differentiating between always-invalid and
+     * invalid-by-pre-SegWit-soft-fork is uninteresting.
+     */
+    BLOCK_RECENT_CONSENSUS_CHANGE,
+    //! this block was cached as being invalid and we didn't store the reason
+    //! why
+    BLOCK_CACHED_INVALID,
+    //! invalid proof of work or time too old
+    BLOCK_INVALID_HEADER,
+    //! the block's data didn't match the data committed to by the PoW
+    BLOCK_MUTATED,
+    //! We don't have the previous block the checked one is built on
+    BLOCK_MISSING_PREV,
+    //! A block this one builds on is invalid
+    BLOCK_INVALID_PREV,
+    //! block timestamp was > 2 hours in the future (or our clock is bad)
+    BLOCK_TIME_FUTURE,
+    //! the block failed to meet one of our checkpoints
+    BLOCK_CHECKPOINT,
+    //! block finalization problems
+    BLOCK_FINALIZATION,
+};
 
-/** Capture information about block/transaction validation */
-class CValidationState {
+/**
+ * Base class for capturing information about block/transaction validation.
+ * This is subclassed by TxValidationState and BlockValidationState for
+ * validation information on transactions and blocks respectively.
+ */
+class ValidationState {
 private:
     enum mode_state {
         MODE_VALID,   //!< everything ok
         MODE_INVALID, //!< network rule violation (DoS value may be set)
         MODE_ERROR,   //!< run-time error
-    } mode;
-    ValidationInvalidReason m_reason;
-    std::string strRejectReason;
+    } m_mode;
+    std::string m_reject_reason;
     unsigned int chRejectCode;
-    std::string strDebugMessage;
+    std::string m_debug_message;
 
-public:
-    CValidationState()
-        : mode(MODE_VALID), m_reason(ValidationInvalidReason::NONE),
-          chRejectCode(0) {}
-    bool Invalid(ValidationInvalidReason reasonIn, bool ret = false,
-                 unsigned int chRejectCodeIn = 0,
-                 const std::string &strRejectReasonIn = "",
-                 const std::string &strDebugMessageIn = "") {
-        m_reason = reasonIn;
+protected:
+    void Invalid(unsigned int chRejectCodeIn = 0,
+                 const std::string &reject_reason = "",
+                 const std::string &debug_message = "") {
         chRejectCode = chRejectCodeIn;
-        strRejectReason = strRejectReasonIn;
-        strDebugMessage = strDebugMessageIn;
-        if (mode == MODE_ERROR) {
-            return ret;
+        m_reject_reason = reject_reason;
+        m_debug_message = debug_message;
+        if (m_mode != MODE_ERROR) {
+            m_mode = MODE_INVALID;
         }
-        mode = MODE_INVALID;
-        return ret;
     }
-    bool Error(const std::string &strRejectReasonIn) {
-        if (mode == MODE_VALID) {
-            strRejectReason = strRejectReasonIn;
-        }
 
-        mode = MODE_ERROR;
+public:
+    // ValidationState is abstract. Have a pure virtual destructor.
+    virtual ~ValidationState() = 0;
+
+    ValidationState() : m_mode(MODE_VALID), chRejectCode(0) {}
+    bool Error(const std::string &reject_reason) {
+        if (m_mode == MODE_VALID) {
+            m_reject_reason = reject_reason;
+        }
+        m_mode = MODE_ERROR;
         return false;
     }
-    bool IsValid() const { return mode == MODE_VALID; }
-    bool IsInvalid() const { return mode == MODE_INVALID; }
-    bool IsError() const { return mode == MODE_ERROR; }
-    ValidationInvalidReason GetReason() const { return m_reason; }
+    bool IsValid() const { return m_mode == MODE_VALID; }
+    bool IsInvalid() const { return m_mode == MODE_INVALID; }
+    bool IsError() const { return m_mode == MODE_ERROR; }
     unsigned int GetRejectCode() const { return chRejectCode; }
-    std::string GetRejectReason() const { return strRejectReason; }
-    std::string GetDebugMessage() const { return strDebugMessage; }
+    std::string GetRejectReason() const { return m_reject_reason; }
+    std::string GetDebugMessage() const { return m_debug_message; }
+};
+
+inline ValidationState::~ValidationState(){};
+
+class TxValidationState : public ValidationState {
+private:
+    TxValidationResult m_result = TxValidationResult::TX_RESULT_UNSET;
+
+public:
+    bool Invalid(TxValidationResult result, unsigned int chRejectCodeIn = 0,
+                 const std::string &reject_reason = "",
+                 const std::string &debug_message = "") {
+        m_result = result;
+        ValidationState::Invalid(chRejectCodeIn, reject_reason, debug_message);
+        return false;
+    }
+    TxValidationResult GetResult() const { return m_result; }
+};
+
+class BlockValidationState : public ValidationState {
+private:
+    BlockValidationResult m_result = BlockValidationResult::BLOCK_RESULT_UNSET;
+
+public:
+    bool Invalid(BlockValidationResult result, unsigned int chRejectCodeIn = 0,
+                 const std::string &reject_reason = "",
+                 const std::string &debug_message = "") {
+        m_result = result;
+        ValidationState::Invalid(chRejectCodeIn, reject_reason, debug_message);
+        return false;
+    }
+    BlockValidationResult GetResult() const { return m_result; }
 };
 
 #endif // BITCOIN_CONSENSUS_VALIDATION_H
diff -Nru bitcoinabc-0.21.11/src/init.cpp bitcoinabc-0.21.12/src/init.cpp
--- bitcoinabc-0.21.11/src/init.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/init.cpp	2020-07-28 23:45:00.000000000 +0000
@@ -357,7 +357,6 @@
     std::vector<std::string> hidden_args = {
         "-h", "-help", "-dbcrashratio", "-forcecompactdb", "-parkdeepreorg",
         "-automaticunparking", "-replayprotectionactivationtime",
-        "-enableminerfund",
         // GUI args. These will be overwritten by SetupUIArgs for the GUI
         "-allowselfsignedrootcertificates", "-choosedatadir", "-lang=<lang>",
         "-min", "-resetguisettings", "-rootcertificates=<file>", "-splash",
@@ -1339,7 +1338,7 @@
 
         // scan for better chains in the block chain database, that are not yet
         // connected in the active best chain
-        CValidationState state;
+        BlockValidationState state;
         if (!ActivateBestChain(config, state)) {
             LogPrintf("Failed to connect best block (%s)\n",
                       FormatStateMessage(state));
diff -Nru bitcoinabc-0.21.11/src/interfaces/chain.cpp bitcoinabc-0.21.12/src/interfaces/chain.cpp
--- bitcoinabc-0.21.11/src/interfaces/chain.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/interfaces/chain.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -1,4 +1,4 @@
-// Copyright (c) 2018 The Bitcoin Core developers
+// Copyright (c) 2018-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -141,7 +141,7 @@
         }
         bool contextualCheckTransactionForCurrentBlock(
             const Consensus::Params &params, const CTransaction &tx,
-            CValidationState &state) override {
+            TxValidationState &state) override {
             LockAssertion lock(::cs_main);
             return ContextualCheckTransactionForCurrentBlock(params, tx, state);
         }
@@ -340,7 +340,10 @@
         }
         CFeeRate relayMinFee() override { return ::minRelayTxFee; }
         CFeeRate relayDustFee() override { return ::dustRelayFee; }
-        bool getPruneMode() override { return ::fPruneMode; }
+        bool havePruned() override {
+            LOCK(cs_main);
+            return ::fHavePruned;
+        }
         bool p2pEnabled() override { return m_node.connman != nullptr; }
         bool isReadyToBroadcast() override {
             return !::fImporting && !::fReindex && !isInitialBlockDownload();
diff -Nru bitcoinabc-0.21.11/src/interfaces/chain.h bitcoinabc-0.21.12/src/interfaces/chain.h
--- bitcoinabc-0.21.11/src/interfaces/chain.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/interfaces/chain.h	2020-07-27 15:24:34.000000000 +0000
@@ -1,4 +1,4 @@
-// Copyright (c) 2018 The Bitcoin Core developers
+// Copyright (c) 2018-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -15,16 +15,18 @@
 #include <string>
 #include <vector>
 
-struct BlockHash;
 class CBlock;
-struct CBlockLocator;
 class CChainParams;
 class Coin;
 class Config;
 class CRPCCommand;
 class CScheduler;
-class CValidationState;
+class TxValidationState;
+
+struct BlockHash;
+struct CBlockLocator;
 struct NodeContext;
+
 namespace Consensus {
 struct Params;
 }
@@ -131,7 +133,7 @@
         //! Check if transaction will be final given chain height current time.
         virtual bool contextualCheckTransactionForCurrentBlock(
             const Consensus::Params &params, const CTransaction &tx,
-            CValidationState &state) = 0;
+            TxValidationState &state) = 0;
     };
 
     //! Return Lock interface. Chain is locked when this is called, and
@@ -187,8 +189,8 @@
     //! economical to spend.
     virtual CFeeRate relayDustFee() = 0;
 
-    //! Check if pruning is enabled.
-    virtual bool getPruneMode() = 0;
+    //! Check if any block has been pruned.
+    virtual bool havePruned() = 0;
 
     //! Check if p2p enabled.
     virtual bool p2pEnabled() = 0;
diff -Nru bitcoinabc-0.21.11/src/interfaces/wallet.cpp bitcoinabc-0.21.12/src/interfaces/wallet.cpp
--- bitcoinabc-0.21.11/src/interfaces/wallet.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/interfaces/wallet.cpp	2020-07-28 23:45:00.000000000 +0000
@@ -68,7 +68,7 @@
         result.depth_in_main_chain = wtx.GetDepthInMainChain(locked_chain);
         result.time_received = wtx.nTimeReceived;
         result.lock_time = wtx.tx->nLockTime;
-        CValidationState state;
+        TxValidationState state;
         result.is_final =
             locked_chain.contextualCheckTransactionForCurrentBlock(
                 Params().GetConsensus(), *wtx.tx, state);
@@ -233,7 +233,7 @@
                                std::string &reject_reason) override {
             auto locked_chain = m_wallet->chain().lock();
             LOCK(m_wallet->cs_wallet);
-            CValidationState state;
+            TxValidationState state;
             if (!m_wallet->CommitTransaction(std::move(tx),
                                              std::move(value_map),
                                              std::move(order_form), state)) {
diff -Nru bitcoinabc-0.21.11/src/key.h bitcoinabc-0.21.12/src/key.h
--- bitcoinabc-0.21.11/src/key.h	2020-06-30 00:19:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/key.h	2020-07-27 15:24:34.000000000 +0000
@@ -188,6 +188,8 @@
         s.read((char *)&code[0], len);
         Decode(code);
     }
+
+    CExtKey() = default;
 };
 
 /**
diff -Nru bitcoinabc-0.21.11/src/Makefile.am bitcoinabc-0.21.12/src/Makefile.am
--- bitcoinabc-0.21.11/src/Makefile.am	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/Makefile.am	2020-07-27 15:24:34.000000000 +0000
@@ -118,13 +118,16 @@
   avalanche/peermanager.h \
   avalanche/processor.h \
   avalanche/proof.h \
+  avalanche/proofbuilder.h \
   avalanche/protocol.h \
+  avalanche/validation.h \
   banman.h \
   base58.h \
   bloom.h \
   blockencodings.h \
   blockfileinfo.h \
   blockfilter.h \
+  blockindex.h \
   blockindexworkcomparator.h \
   blockstatus.h \
   blockvalidity.h \
@@ -178,7 +181,6 @@
   memusage.h \
   merkleblock.h \
   miner.h \
-  minerfund.h \
   net.h \
   net_permissions.h \
   net_processing.h \
@@ -197,7 +199,9 @@
   policy/mempool.h \
   policy/policy.h \
   policy/settings.h \
-  pow.h \
+  pow/daa.h \
+  pow/eda.h \
+  pow/pow.h \
   protocol.h \
   psbt.h \
   radix.h \
@@ -247,6 +251,7 @@
   util/error.h \
   util/macros.h \
   util/moneystr.h \
+  util/spanparsing.h \
   util/system.h \
   util/settings.h \
   util/string.h \
@@ -300,9 +305,11 @@
   avalanche/peermanager.cpp \
   avalanche/processor.cpp \
   avalanche/proof.cpp \
+  avalanche/proofbuilder.cpp \
   banman.cpp \
   blockencodings.cpp \
   blockfilter.cpp \
+  blockindex.cpp \
   chain.cpp \
   checkpoints.cpp \
   config.cpp \
@@ -319,7 +326,6 @@
   interfaces/node.cpp \
   dbwrapper.cpp \
   miner.cpp \
-  minerfund.cpp \
   net.cpp \
   net_processing.cpp \
   node/coin.cpp \
@@ -330,7 +336,9 @@
   noui.cpp \
   policy/fees.cpp \
   policy/settings.cpp \
-  pow.cpp \
+  pow/daa.cpp \
+  pow/eda.cpp \
+  pow/pow.cpp \
   rest.cpp \
   rpc/abc.cpp \
   rpc/avalanche.cpp \
@@ -558,6 +566,7 @@
   util/system.cpp \
   util/moneystr.cpp \
   util/settings.cpp \
+  util/spanparsing.cpp \
   util/strencodings.cpp \
   util/string.cpp \
   util/threadnames.cpp \
diff -Nru bitcoinabc-0.21.11/src/Makefile.test.include bitcoinabc-0.21.12/src/Makefile.test.include
--- bitcoinabc-0.21.11/src/Makefile.test.include	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/Makefile.test.include	2020-07-20 15:59:43.000000000 +0000
@@ -4,10 +4,15 @@
 
 
 FUZZ_TARGETS = \
+  test/fuzz/addr_info_deserialize \
   test/fuzz/address_deserialize \
   test/fuzz/addrman_deserialize \
   test/fuzz/banentry_deserialize \
+  test/fuzz/cashaddr \
   test/fuzz/block_deserialize \
+  test/fuzz/block_file_info_deserialize \
+  test/fuzz/block_filter_deserialize \
+  test/fuzz/block_header_and_short_txids_deserialize \
   test/fuzz/blockheader_deserialize \
   test/fuzz/blocklocator_deserialize \
   test/fuzz/blockmerkleroot \
@@ -16,14 +21,33 @@
   test/fuzz/blockundo_deserialize \
   test/fuzz/bloomfilter_deserialize \
   test/fuzz/coins_deserialize \
+  test/fuzz/descriptor_parse \
   test/fuzz/diskblockindex_deserialize \
   test/fuzz/eval_script \
+  test/fuzz/fee_rate_deserialize \
+  test/fuzz/flat_file_pos_deserialize \
   test/fuzz/inv_deserialize \
+  test/fuzz/key_origin_info_deserialize \
+  test/fuzz/merkle_block_deserialize \
   test/fuzz/messageheader_deserialize \
   test/fuzz/netaddr_deserialize \
+  test/fuzz/out_point_deserialize \
+  test/fuzz/parse_iso8601 \
+  test/fuzz/partial_merkle_tree_deserialize \
+  test/fuzz/partially_signed_transaction_deserialize \
+  test/fuzz/prefilled_transaction_deserialize \
+  test/fuzz/psbt \
+  test/fuzz/psbt_input_deserialize \
+  test/fuzz/psbt_output_deserialize \
+  test/fuzz/pub_key_deserialize \
+  test/fuzz/script \
+  test/fuzz/script_deserialize \
   test/fuzz/script_flags \
   test/fuzz/service_deserialize \
+  test/fuzz/spanparsing \
+  test/fuzz/sub_net_deserialize \
   test/fuzz/transaction \
+  test/fuzz/tx_in_deserialize \
   test/fuzz/txoutcompressor_deserialize \
   test/fuzz/txundo_deserialize
 
@@ -52,16 +76,25 @@
 GENERATED_TEST_FILES = $(JSON_TEST_FILES:.json=.json.h) $(RAW_TEST_FILES:.raw=.raw.h)
 
 BITCOIN_TEST_SUITE = \
+  avalanche/test/util.cpp \
+  test/fixture.cpp \
   test/jsonutil.cpp \
-  test/main.cpp \
+  test/util/setup_common.h \
+  test/util/setup_common.cpp \
   test/scriptflags.cpp \
   test/sigutil.cpp \
+  test/util/str.h \
+  test/util/str.cpp \
   $(TEST_UTIL_H)
 
 FUZZ_SUITE = \
   test/fuzz/fuzz.cpp \
   test/fuzz/fuzz.h \
-  test/fuzz/FuzzedDataProvider.h
+  test/fuzz/FuzzedDataProvider.h \
+  test/setup_common.cpp \
+  test/setup_common.h \
+  test/util/str.cpp \
+  test/util/str.h
 
 FUZZ_SUITE_LD_COMMON = \
   $(LIBBITCOIN_SERVER) \
@@ -84,6 +117,8 @@
   avalanche/test/peermanager_tests.cpp \
   avalanche/test/processor_tests.cpp \
   avalanche/test/proof_tests.cpp \
+  pow/test/daa_tests.cpp \
+  pow/test/eda_tests.cpp \
   test/scriptnum10.h \
   test/activation_tests.cpp \
   test/addrman_tests.cpp \
@@ -144,7 +179,6 @@
   test/op_reversebytes_tests.cpp \
   test/pmt_tests.cpp \
   test/policyestimator_tests.cpp \
-  test/pow_tests.cpp \
   test/prevector_tests.cpp \
   test/radix_tests.cpp \
   test/raii_event_tests.cpp \
@@ -274,6 +308,12 @@
 test_fuzz_banentry_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
 test_fuzz_banentry_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
 
+test_fuzz_cashaddr_SOURCES = $(FUZZ_SUITE) test/fuzz/cashaddr.cpp
+test_fuzz_cashaddr_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+test_fuzz_cashaddr_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_cashaddr_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_cashaddr_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
 test_fuzz_txundo_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
 test_fuzz_txundo_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DTXUNDO_DESERIALIZE=1
 test_fuzz_txundo_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
@@ -292,12 +332,36 @@
 test_fuzz_coins_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
 test_fuzz_coins_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
 
+test_fuzz_descriptor_parse_SOURCES = $(FUZZ_SUITE) test/fuzz/descriptor_parse.cpp
+test_fuzz_descriptor_parse_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+test_fuzz_descriptor_parse_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_descriptor_parse_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_descriptor_parse_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
 test_fuzz_netaddr_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
 test_fuzz_netaddr_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DNETADDR_DESERIALIZE=1
 test_fuzz_netaddr_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 test_fuzz_netaddr_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
 test_fuzz_netaddr_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
 
+test_fuzz_parse_iso8601_SOURCES = $(FUZZ_SUITE) test/fuzz/parse_iso8601.cpp
+test_fuzz_parse_iso8601_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+test_fuzz_parse_iso8601_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_parse_iso8601_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_parse_iso8601_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_psbt_SOURCES = $(FUZZ_SUITE) test/fuzz/psbt.cpp
+test_fuzz_psbt_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+test_fuzz_psbt_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_psbt_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_psbt_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_script_SOURCES = $(FUZZ_SUITE) test/fuzz/script.cpp
+test_fuzz_script_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+test_fuzz_script_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_script_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_script_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
 test_fuzz_script_flags_SOURCES = $(FUZZ_SUITE) test/fuzz/script_flags.cpp
 test_fuzz_script_flags_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
 test_fuzz_script_flags_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
@@ -310,6 +374,12 @@
 test_fuzz_service_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
 test_fuzz_service_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
 
+test_fuzz_spanparsing_SOURCES = $(FUZZ_SUITE) test/fuzz/spanparsing.cpp
+test_fuzz_spanparsing_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+test_fuzz_spanparsing_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_spanparsing_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_spanparsing_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
 test_fuzz_messageheader_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
 test_fuzz_messageheader_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DMESSAGEHEADER_DESERIALIZE=1
 test_fuzz_messageheader_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
@@ -370,6 +440,114 @@
 test_fuzz_transaction_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
 test_fuzz_transaction_LDADD = $(FUZZ_SUITE_LD_COMMON)
 
+test_fuzz_addr_info_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_addr_info_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DADDR_INFO_DESERIALIZE=1
+test_fuzz_addr_info_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_addr_info_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_addr_info_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_block_file_info_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_block_file_info_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DBLOCK_FILE_INFO_DESERIALIZE=1
+test_fuzz_block_file_info_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_block_file_info_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_block_file_info_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_block_filter_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_block_filter_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DBLOCK_FILTER_DESERIALIZE=1
+test_fuzz_block_filter_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_block_filter_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_block_filter_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_block_header_and_short_txids_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_block_header_and_short_txids_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DBLOCK_HEADER_AND_SHORT_TXIDS_DESERIALIZE=1
+test_fuzz_block_header_and_short_txids_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_block_header_and_short_txids_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_block_header_and_short_txids_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_fee_rate_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_fee_rate_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DFEE_RATE_DESERIALIZE=1
+test_fuzz_fee_rate_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_fee_rate_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_fee_rate_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_flat_file_pos_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_flat_file_pos_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DFLAT_FILE_POS_DESERIALIZE=1
+test_fuzz_flat_file_pos_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_flat_file_pos_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_flat_file_pos_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_key_origin_info_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_key_origin_info_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DKEY_ORIGIN_INFO_DESERIALIZE=1
+test_fuzz_key_origin_info_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_key_origin_info_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_key_origin_info_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_merkle_block_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_merkle_block_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DMERKLE_BLOCK_DESERIALIZE=1
+test_fuzz_merkle_block_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_merkle_block_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_merkle_block_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_out_point_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_out_point_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DOUT_POINT_DESERIALIZE=1
+test_fuzz_out_point_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_out_point_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_out_point_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_partially_signed_transaction_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_partially_signed_transaction_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DPARTIALLY_SIGNED_TRANSACTION_DESERIALIZE=1
+test_fuzz_partially_signed_transaction_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_partially_signed_transaction_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_partially_signed_transaction_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_partial_merkle_tree_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_partial_merkle_tree_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DPARTIAL_MERKLE_TREE_DESERIALIZE=1
+test_fuzz_partial_merkle_tree_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_partial_merkle_tree_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_partial_merkle_tree_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_prefilled_transaction_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_prefilled_transaction_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DPREFILLED_TRANSACTION_DESERIALIZE=1
+test_fuzz_prefilled_transaction_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_prefilled_transaction_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_prefilled_transaction_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_psbt_input_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_psbt_input_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DPSBT_INPUT_DESERIALIZE=1
+test_fuzz_psbt_input_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_psbt_input_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_psbt_input_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_psbt_output_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_psbt_output_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DPSBT_OUTPUT_DESERIALIZE=1
+test_fuzz_psbt_output_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_psbt_output_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_psbt_output_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_pub_key_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_pub_key_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DPUB_KEY_DESERIALIZE=1
+test_fuzz_pub_key_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_pub_key_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_pub_key_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_script_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_script_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DSCRIPT_DESERIALIZE=1
+test_fuzz_script_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_script_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_script_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_sub_net_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_sub_net_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DSUB_NET_DESERIALIZE=1
+test_fuzz_sub_net_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_sub_net_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_sub_net_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
+test_fuzz_tx_in_deserialize_SOURCES = $(FUZZ_SUITE) test/fuzz/deserialize.cpp
+test_fuzz_tx_in_deserialize_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) -DTX_IN_DESERIALIZE=1
+test_fuzz_tx_in_deserialize_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+test_fuzz_tx_in_deserialize_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+test_fuzz_tx_in_deserialize_LDADD = $(FUZZ_SUITE_LD_COMMON)
+
 endif # ENABLE_FUZZ
 
 nodist_test_test_bitcoin_SOURCES = $(GENERATED_TEST_FILES)
diff -Nru bitcoinabc-0.21.11/src/miner.cpp bitcoinabc-0.21.12/src/miner.cpp
--- bitcoinabc-0.21.11/src/miner.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/miner.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -15,11 +15,10 @@
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
-#include <minerfund.h>
 #include <net.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <primitives/transaction.h>
 #include <timedata.h>
 #include <util/moneystr.h>
@@ -30,7 +29,7 @@
 #include <algorithm>
 #include <utility>
 
-int64_t UpdateTime(CBlockHeader *pblock, const Consensus::Params &params,
+int64_t UpdateTime(CBlockHeader *pblock, const CChainParams &chainParams,
                    const CBlockIndex *pindexPrev) {
     int64_t nOldTime = pblock->nTime;
     int64_t nNewTime =
@@ -41,8 +40,8 @@
     }
 
     // Updating time can change work required on testnet:
-    if (params.fPowAllowMinDifficultyBlocks) {
-        pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, params);
+    if (chainParams.GetConsensus().fPowAllowMinDifficultyBlocks) {
+        pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainParams);
     }
 
     return nNewTime - nOldTime;
@@ -61,7 +60,7 @@
 BlockAssembler::BlockAssembler(const CChainParams &params,
                                const CTxMemPool &_mempool,
                                const Options &options)
-    : chainparams(params), mempool(&_mempool) {
+    : chainParams(params), mempool(&_mempool) {
     blockMinFeeRate = options.blockMinFeeRate;
     // Limit size to between 1K and options.nExcessiveBlockSize -1K for sanity:
     nMaxGeneratedBlockSize = std::max<uint64_t>(
@@ -141,12 +140,12 @@
     assert(pindexPrev != nullptr);
     nHeight = pindexPrev->nHeight + 1;
 
-    const Consensus::Params &consensusParams = chainparams.GetConsensus();
+    const Consensus::Params &consensusParams = chainParams.GetConsensus();
 
     pblock->nVersion = ComputeBlockVersion(pindexPrev, consensusParams);
     // -regtest only: allow overriding block.nVersion with
     // -blockversion=N to test forking scenarios
-    if (chainparams.MineBlocksOnDemand()) {
+    if (chainParams.MineBlocksOnDemand()) {
         pblock->nVersion = gArgs.GetArg("-blockversion", pblock->nVersion);
     }
 
@@ -191,15 +190,6 @@
         nFees + GetBlockSubsidy(nHeight, consensusParams);
     coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
 
-    const std::vector<CTxDestination> whitelisted =
-        GetMinerFundWhitelist(consensusParams, pindexPrev);
-    if (!whitelisted.empty()) {
-        const Amount fund = coinbaseTx.vout[0].nValue / MINER_FUND_RATIO;
-        coinbaseTx.vout[0].nValue -= fund;
-        coinbaseTx.vout.emplace_back(fund,
-                                     GetScriptForDestination(whitelisted[0]));
-    }
-
     // Make sure the coinbase is big enough.
     uint64_t coinbaseSize = ::GetSerializeSize(coinbaseTx, PROTOCOL_VERSION);
     if (coinbaseSize < MIN_TX_SIZE) {
@@ -218,13 +208,13 @@
 
     // Fill in header.
     pblock->hashPrevBlock = pindexPrev->GetBlockHash();
-    UpdateTime(pblock, consensusParams, pindexPrev);
-    pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
+    UpdateTime(pblock, chainParams, pindexPrev);
+    pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainParams);
     pblock->nNonce = 0;
     pblocktemplate->entries[0].sigOpCount = 0;
 
-    CValidationState state;
-    if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev,
+    BlockValidationState state;
+    if (!TestBlockValidity(state, chainParams, *pblock, pindexPrev,
                            BlockValidationOptions(nMaxGeneratedBlockSize)
                                .withCheckPoW(false)
                                .withCheckMerkleRoot(false))) {
@@ -279,8 +269,8 @@
     const CTxMemPool::setEntries &package) {
     uint64_t nPotentialBlockSize = nBlockSize;
     for (CTxMemPool::txiter it : package) {
-        CValidationState state;
-        if (!ContextualCheckTransaction(chainparams.GetConsensus(), it->GetTx(),
+        TxValidationState state;
+        if (!ContextualCheckTransaction(chainParams.GetConsensus(), it->GetTx(),
                                         state, nHeight, nLockTimeCutoff,
                                         nMedianTimePast)) {
             return false;
diff -Nru bitcoinabc-0.21.11/src/minerfund.cpp bitcoinabc-0.21.12/src/minerfund.cpp
--- bitcoinabc-0.21.11/src/minerfund.cpp	2020-06-30 00:18:54.000000000 +0000
+++ bitcoinabc-0.21.12/src/minerfund.cpp	1970-01-01 00:00:00.000000000 +0000
@@ -1,76 +0,0 @@
-// Copyright (c) 2020 The Bitcoin developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <minerfund.h>
-
-#include <chainparams.h>
-#include <consensus/activation.h>
-#include <key_io.h> // For DecodeDestination
-#include <util/system.h>
-#include <validation.h> // For VersionBitsBlockState
-
-static CTxDestination BuildDestination(const std::string &dest) {
-    const auto mainNetParams = CreateChainParams(CBaseChainParams::MAIN);
-    return DecodeDestination(dest, *mainNetParams);
-}
-
-static const CTxDestination &GetMinerFundDestination() {
-    static CTxDestination dest =
-        BuildDestination("pqv2r67sgz3qumufap3h2uuj0zfmnzuv8vqhqfgddk");
-    return dest;
-}
-
-static const CTxDestination &GetMinerABCDestination() {
-    static CTxDestination dest =
-        BuildDestination("qzvz0es48sf8wrqy7kn5j5cugka95ztskcanc9laay");
-    return dest;
-}
-
-static const CTxDestination &GetMinerBCHDDestination() {
-    static CTxDestination dest =
-        BuildDestination("qrhea03074073ff3zv9whh0nggxc7k03ssh8jv9mkx");
-    return dest;
-}
-
-static const CTxDestination &GetMinerElectronCashDestination() {
-    static CTxDestination dest =
-        BuildDestination("pp8d685l8kecnmtyy52ndvq625arz2qwmu42qeeqek");
-    return dest;
-}
-
-std::vector<CTxDestination>
-GetMinerFundWhitelist(const Consensus::Params &params,
-                      const CBlockIndex *pindexPrev) {
-    if (!gArgs.GetBoolArg("-enableminerfund", params.enableMinerFund)) {
-        return {};
-    }
-
-    if (!IsPhononEnabled(params, pindexPrev)) {
-        return {};
-    }
-
-    std::vector<CTxDestination> whitelist{};
-    if (VersionBitsBlockState(params, Consensus::DEPLOYEMENT_MINER_FUND,
-                              pindexPrev) == ThresholdState::ACTIVE) {
-        whitelist.push_back(GetMinerFundDestination());
-    }
-
-    if (VersionBitsBlockState(params, Consensus::DEPLOYEMENT_MINER_FUND_ABC,
-                              pindexPrev) == ThresholdState::ACTIVE) {
-        whitelist.push_back(GetMinerABCDestination());
-    }
-
-    if (VersionBitsBlockState(params, Consensus::DEPLOYEMENT_MINER_FUND_BCHD,
-                              pindexPrev) == ThresholdState::ACTIVE) {
-        whitelist.push_back(GetMinerBCHDDestination());
-    }
-
-    if (VersionBitsBlockState(params,
-                              Consensus::DEPLOYEMENT_MINER_FUND_ELECTRON_CASH,
-                              pindexPrev) == ThresholdState::ACTIVE) {
-        whitelist.push_back(GetMinerElectronCashDestination());
-    }
-
-    return whitelist;
-}
diff -Nru bitcoinabc-0.21.11/src/minerfund.h bitcoinabc-0.21.12/src/minerfund.h
--- bitcoinabc-0.21.11/src/minerfund.h	2020-06-30 00:19:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/minerfund.h	1970-01-01 00:00:00.000000000 +0000
@@ -1,24 +0,0 @@
-// Copyright (c) 2020 The Bitcoin developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_MINERFUND_H
-#define BITCOIN_MINERFUND_H
-
-#include <script/standard.h>
-
-#include <vector>
-
-class CBlockIndex;
-
-namespace Consensus {
-struct Params;
-}
-
-static constexpr int MINER_FUND_RATIO = 20;
-
-std::vector<CTxDestination>
-GetMinerFundWhitelist(const Consensus::Params &params,
-                      const CBlockIndex *pindexPrev);
-
-#endif // BITCOIN_MINERFUND_H
diff -Nru bitcoinabc-0.21.11/src/miner.h bitcoinabc-0.21.12/src/miner.h
--- bitcoinabc-0.21.11/src/miner.h	2020-06-30 00:19:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/miner.h	2020-07-20 15:59:43.000000000 +0000
@@ -153,7 +153,7 @@
     int nHeight;
     int64_t nLockTimeCutoff;
     int64_t nMedianTimePast;
-    const CChainParams &chainparams;
+    const CChainParams &chainParams;
 
     const CTxMemPool *mempool;
 
@@ -231,6 +231,6 @@
 void IncrementExtraNonce(CBlock *pblock, const CBlockIndex *pindexPrev,
                          uint64_t nExcessiveBlockSize,
                          unsigned int &nExtraNonce);
-int64_t UpdateTime(CBlockHeader *pblock, const Consensus::Params &params,
+int64_t UpdateTime(CBlockHeader *pblock, const CChainParams &chainParams,
                    const CBlockIndex *pindexPrev);
 #endif // BITCOIN_MINER_H
diff -Nru bitcoinabc-0.21.11/src/net_processing.cpp bitcoinabc-0.21.12/src/net_processing.cpp
--- bitcoinabc-0.21.11/src/net_processing.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/net_processing.cpp	2020-07-20 15:59:43.000000000 +0000
@@ -1201,13 +1201,12 @@
  * banning/disconnecting us. We use this to determine which unaccepted
  * transactions from a whitelisted peer that we can safely relay.
  */
-static bool TxRelayMayResultInDisconnect(const CValidationState &state) {
-    assert(IsTransactionReason(state.GetReason()));
-    return state.GetReason() == ValidationInvalidReason::CONSENSUS;
+static bool TxRelayMayResultInDisconnect(const TxValidationState &state) {
+    return state.GetResult() == TxValidationResult::TX_CONSENSUS;
 }
 
 /**
- * Potentially ban a node based on the contents of a CValidationState object
+ * Potentially ban a node based on the contents of a BlockValidationState object
  *
  * @param[in] via_compact_block: this bool is passed in because net_processing
  * should punish peers differently depending on whether the data was provided in
@@ -1215,25 +1214,24 @@
  * contained invalid txs, the peer should not be punished. See BIP 152.
  *
  * @return Returns true if the peer was punished (probably disconnected)
- *
- * Changes here may need to be reflected in TxRelayMayResultInDisconnect().
  */
-static bool MaybePunishNode(NodeId nodeid, const CValidationState &state,
-                            bool via_compact_block,
-                            const std::string &message = "") {
-    switch (state.GetReason()) {
-        case ValidationInvalidReason::NONE:
+static bool MaybePunishNodeForBlock(NodeId nodeid,
+                                    const BlockValidationState &state,
+                                    bool via_compact_block,
+                                    const std::string &message = "") {
+    switch (state.GetResult()) {
+        case BlockValidationResult::BLOCK_RESULT_UNSET:
             break;
         // The node is providing invalid data:
-        case ValidationInvalidReason::CONSENSUS:
-        case ValidationInvalidReason::BLOCK_MUTATED:
+        case BlockValidationResult::BLOCK_CONSENSUS:
+        case BlockValidationResult::BLOCK_MUTATED:
             if (!via_compact_block) {
                 LOCK(cs_main);
                 Misbehaving(nodeid, 100, message);
                 return true;
             }
             break;
-        case ValidationInvalidReason::CACHED_INVALID: {
+        case BlockValidationResult::BLOCK_CACHED_INVALID: {
             LOCK(cs_main);
             CNodeState *node_state = State(nodeid);
             if (node_state == nullptr) {
@@ -1249,14 +1247,14 @@
             }
             break;
         }
-        case ValidationInvalidReason::BLOCK_INVALID_HEADER:
-        case ValidationInvalidReason::BLOCK_CHECKPOINT:
-        case ValidationInvalidReason::BLOCK_INVALID_PREV: {
+        case BlockValidationResult::BLOCK_INVALID_HEADER:
+        case BlockValidationResult::BLOCK_CHECKPOINT:
+        case BlockValidationResult::BLOCK_INVALID_PREV: {
             LOCK(cs_main);
             Misbehaving(nodeid, 100, message);
         }
             return true;
-        case ValidationInvalidReason::BLOCK_FINALIZATION: {
+        case BlockValidationResult::BLOCK_FINALIZATION: {
             // TODO: Use the state object to report this is probably not the
             // best idea. This is effectively unreachable, unless there is a bug
             // somewhere.
@@ -1265,20 +1263,48 @@
         }
             return true;
         // Conflicting (but not necessarily invalid) data or different policy:
-        case ValidationInvalidReason::BLOCK_MISSING_PREV: {
+        case BlockValidationResult::BLOCK_MISSING_PREV: {
             // TODO: Handle this much more gracefully (10 DoS points is super
             // arbitrary)
             LOCK(cs_main);
             Misbehaving(nodeid, 10, message);
         }
             return true;
-        case ValidationInvalidReason::RECENT_CONSENSUS_CHANGE:
-        case ValidationInvalidReason::BLOCK_TIME_FUTURE:
-        case ValidationInvalidReason::TX_NOT_STANDARD:
-        case ValidationInvalidReason::TX_MISSING_INPUTS:
-        case ValidationInvalidReason::TX_PREMATURE_SPEND:
-        case ValidationInvalidReason::TX_CONFLICT:
-        case ValidationInvalidReason::TX_MEMPOOL_POLICY:
+        case BlockValidationResult::BLOCK_RECENT_CONSENSUS_CHANGE:
+        case BlockValidationResult::BLOCK_TIME_FUTURE:
+            break;
+    }
+    if (message != "") {
+        LogPrint(BCLog::NET, "peer=%d: %s\n", nodeid, message);
+    }
+    return false;
+}
+
+/**
+ * Potentially ban a node based on the contents of a TxValidationState object
+ *
+ * @return Returns true if the peer was punished (probably disconnected)
+ *
+ * Changes here may need to be reflected in TxRelayMayResultInDisconnect().
+ */
+static bool MaybePunishNodeForTx(NodeId nodeid, const TxValidationState &state,
+                                 const std::string &message = "") {
+    switch (state.GetResult()) {
+        case TxValidationResult::TX_RESULT_UNSET:
+            break;
+        // The node is providing invalid data:
+        case TxValidationResult::TX_CONSENSUS: {
+            LOCK(cs_main);
+            Misbehaving(nodeid, 100, message);
+            return true;
+        }
+        // Conflicting (but not necessarily invalid) data or different policy:
+        case TxValidationResult::TX_RECENT_CONSENSUS_CHANGE:
+        case TxValidationResult::TX_NOT_STANDARD:
+        case TxValidationResult::TX_MISSING_INPUTS:
+        case TxValidationResult::TX_PREMATURE_SPEND:
+        case TxValidationResult::TX_CONFLICT:
+        case TxValidationResult::TX_MEMPOOL_POLICY:
             break;
     }
     if (message != "") {
@@ -1485,7 +1511,7 @@
  * peers announce compact blocks.
  */
 void PeerLogicValidation::BlockChecked(const CBlock &block,
-                                       const CValidationState &state) {
+                                       const BlockValidationState &state) {
     LOCK(cs_main);
 
     const BlockHash hash = block.GetHash();
@@ -1502,8 +1528,8 @@
                 state.GetRejectReason().substr(0, MAX_REJECT_MESSAGE_LENGTH),
                 hash};
             State(it->second.first)->rejects.push_back(reject);
-            MaybePunishNode(/*nodeid=*/it->second.first, state,
-                            /*via_compact_block=*/!it->second.second);
+            MaybePunishNodeForBlock(/*nodeid=*/it->second.first, state,
+                                    /*via_compact_block=*/!it->second.second);
         }
     }
     // Check that:
@@ -1653,7 +1679,7 @@
         }
     } // release cs_main before calling ActivateBestChain
     if (need_activate_chain) {
-        CValidationState state;
+        BlockValidationState state;
         if (!ActivateBestChain(config, state, a_recent_block)) {
             LogPrint(BCLog::NET, "failed to activate chain (%s)\n",
                      FormatStateMessage(state));
@@ -1987,13 +2013,11 @@
         }
     }
 
-    CValidationState state;
-    CBlockHeader first_invalid_header;
-    if (!ProcessNewBlockHeaders(config, headers, state, &pindexLast,
-                                &first_invalid_header)) {
+    BlockValidationState state;
+    if (!ProcessNewBlockHeaders(config, headers, state, &pindexLast)) {
         if (state.IsInvalid()) {
-            MaybePunishNode(pfrom->GetId(), state, via_compact_block,
-                            "invalid header received");
+            MaybePunishNodeForBlock(pfrom->GetId(), state, via_compact_block,
+                                    "invalid header received");
             return false;
         }
     }
@@ -2167,11 +2191,11 @@
         const CTransactionRef porphanTx = orphan_it->second.tx;
         const CTransaction &orphanTx = *porphanTx;
         NodeId fromPeer = orphan_it->second.fromPeer;
-        bool fMissingInputs2 = false;
-        // Use a new CValidationState because orphans come from different peers
-        // (and we call MaybePunishNode based on the source peer from the orphan
-        // map, not based on the peer that relayed the previous transaction).
-        CValidationState orphan_state;
+        // Use a new TxValidationState because orphans come from different peers
+        // (and we call MaybePunishNodeForTx based on the source peer from the
+        // orphan map, not based on the peer that relayed the previous
+        // transaction).
+        TxValidationState orphan_state;
 
         auto it = rejectCountPerNode.find(fromPeer);
         if (it != rejectCountPerNode.end() &&
@@ -2180,7 +2204,7 @@
         }
 
         if (AcceptToMemoryPool(config, g_mempool, orphan_state, porphanTx,
-                               &fMissingInputs2, false /* bypass_limits */,
+                               false /* bypass_limits */,
                                Amount::zero() /* nAbsurdFee */)) {
             LogPrint(BCLog::MEMPOOL, "   accepted orphan tx %s\n",
                      orphanTxId.ToString());
@@ -2196,11 +2220,11 @@
             }
             EraseOrphanTx(orphanTxId);
             done = true;
-        } else if (!fMissingInputs2) {
+        } else if (orphan_state.GetResult() !=
+                   TxValidationResult::TX_MISSING_INPUTS) {
             if (orphan_state.IsInvalid()) {
                 // Punish peer that gave us an invalid orphan tx
-                MaybePunishNode(fromPeer, orphan_state,
-                                /*via_compact_block*/ false);
+                MaybePunishNodeForTx(fromPeer, orphan_state);
                 LogPrint(BCLog::MEMPOOL, "   invalid orphan tx %s\n",
                          orphanTxId.ToString());
             }
@@ -2208,7 +2232,6 @@
             // Probably non-standard or insufficient fee
             LogPrint(BCLog::MEMPOOL, "   removed orphan tx %s\n",
                      orphanTxId.ToString());
-            assert(IsTransactionReason(orphan_state.GetReason()));
 
             assert(recentRejects);
             recentRejects->insert(orphanTxId);
@@ -2750,7 +2773,7 @@
                 LOCK(cs_most_recent_block);
                 a_recent_block = most_recent_block;
             }
-            CValidationState state;
+            BlockValidationState state;
             if (!ActivateBestChain(config, state, a_recent_block)) {
                 LogPrint(BCLog::NET, "failed to activate chain (%s)\n",
                          FormatStateMessage(state));
@@ -2967,8 +2990,7 @@
 
         LOCK2(cs_main, g_cs_orphans);
 
-        bool fMissingInputs = false;
-        CValidationState state;
+        TxValidationState state;
 
         CNodeState *nodestate = State(pfrom->GetId());
         nodestate->m_tx_download.m_tx_announced.erase(txid);
@@ -2976,7 +2998,7 @@
         EraseTxRequest(txid);
 
         if (!AlreadyHave(inv) &&
-            AcceptToMemoryPool(config, g_mempool, state, ptx, &fMissingInputs,
+            AcceptToMemoryPool(config, g_mempool, state, ptx,
                                false /* bypass_limits */,
                                Amount::zero() /* nAbsurdFee */)) {
             g_mempool.check(pcoinsTip.get());
@@ -3002,7 +3024,7 @@
             // Recursively process any orphan transactions that depended on this
             // one
             ProcessOrphanTx(config, connman, pfrom->orphan_work_set);
-        } else if (fMissingInputs) {
+        } else if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) {
             // It may be the case that the orphans parents have all been
             // rejected.
             bool fRejectedParents = false;
@@ -3045,8 +3067,6 @@
                 recentRejects->insert(tx.GetId());
             }
         } else {
-            assert(IsTransactionReason(state.GetReason()));
-
             assert(recentRejects);
             recentRejects->insert(tx.GetId());
 
@@ -3107,7 +3127,7 @@
                                              0, MAX_REJECT_MESSAGE_LENGTH),
                                          inv.hash));
             }
-            MaybePunishNode(pfrom->GetId(), state, /*via_compact_block*/ false);
+            MaybePunishNodeForTx(pfrom->GetId(), state);
         }
         return true;
     }
@@ -3148,13 +3168,13 @@
         }
 
         const CBlockIndex *pindex = nullptr;
-        CValidationState state;
+        BlockValidationState state;
         if (!ProcessNewBlockHeaders(config, {cmpctblock.header}, state,
                                     &pindex)) {
             if (state.IsInvalid()) {
-                MaybePunishNode(pfrom->GetId(), state,
-                                /*via_compact_block*/ true,
-                                "invalid header via cmpctblock");
+                MaybePunishNodeForBlock(pfrom->GetId(), state,
+                                        /*via_compact_block*/ true,
+                                        "invalid header via cmpctblock");
                 return true;
             }
         }
@@ -3602,10 +3622,9 @@
 
                 uint32_t error = -1;
                 if (inv.type == MSG_BLOCK) {
-                    BlockMap::iterator mi =
-                        mapBlockIndex.find(BlockHash(inv.hash));
-                    if (mi != mapBlockIndex.end()) {
-                        error = ::ChainActive().Contains(mi->second) ? 0 : 1;
+                    auto blockIndex = LookupBlockIndex(BlockHash(inv.hash));
+                    if (blockIndex) {
+                        error = ::ChainActive().Contains(blockIndex) ? 0 : 1;
                     }
                 }
 
@@ -3657,7 +3676,7 @@
                 switch (u.getStatus()) {
                     case avalanche::BlockUpdate::Status::Invalid:
                     case avalanche::BlockUpdate::Status::Rejected: {
-                        CValidationState state;
+                        BlockValidationState state;
                         ParkBlock(config, state, pindex);
                         if (!state.IsValid()) {
                             return error("Database error: %s",
@@ -3672,7 +3691,7 @@
                 }
             }
 
-            CValidationState state;
+            BlockValidationState state;
             if (!ActivateBestChain(config, state)) {
                 LogPrint(BCLog::NET, "failed to activate chain (%s)\n",
                          FormatStateMessage(state));
diff -Nru bitcoinabc-0.21.11/src/net_processing.h bitcoinabc-0.21.12/src/net_processing.h
--- bitcoinabc-0.21.11/src/net_processing.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/net_processing.h	2020-07-15 16:44:34.000000000 +0000
@@ -59,7 +59,7 @@
      * Overridden from CValidationInterface.
      */
     void BlockChecked(const CBlock &block,
-                      const CValidationState &state) override;
+                      const BlockValidationState &state) override;
     /**
      * Overridden from CValidationInterface.
      */
diff -Nru bitcoinabc-0.21.11/src/node/transaction.cpp bitcoinabc-0.21.12/src/node/transaction.cpp
--- bitcoinabc-0.21.11/src/node/transaction.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/node/transaction.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -45,21 +45,17 @@
 
         if (!g_mempool.exists(txid)) {
             // Transaction is not already in the mempool. Submit it.
-            CValidationState state;
-            bool fMissingInputs;
+            TxValidationState state;
             if (!AcceptToMemoryPool(config, g_mempool, state, std::move(tx),
-                                    &fMissingInputs, false /* bypass_limits */,
-                                    max_tx_fee)) {
+                                    false /* bypass_limits */, max_tx_fee)) {
+                err_string = FormatStateMessage(state);
                 if (state.IsInvalid()) {
-                    err_string = FormatStateMessage(state);
+                    if (state.GetResult() ==
+                        TxValidationResult::TX_MISSING_INPUTS) {
+                        return TransactionError::MISSING_INPUTS;
+                    }
                     return TransactionError::MEMPOOL_REJECTED;
                 }
-
-                if (fMissingInputs) {
-                    return TransactionError::MISSING_INPUTS;
-                }
-
-                err_string = FormatStateMessage(state);
                 return TransactionError::MEMPOOL_ERROR;
             }
 
diff -Nru bitcoinabc-0.21.11/src/pow/daa.cpp bitcoinabc-0.21.12/src/pow/daa.cpp
--- bitcoinabc-0.21.11/src/pow/daa.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow/daa.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -0,0 +1,130 @@
+// Copyright (c) 2017-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <pow/daa.h>
+
+#include <arith_uint256.h>
+#include <chain.h>
+#include <consensus/params.h>
+
+/**
+ * Compute a target based on the work done between 2 blocks and the time
+ * required to produce that work.
+ */
+static arith_uint256 ComputeTarget(const CBlockIndex *pindexFirst,
+                                   const CBlockIndex *pindexLast,
+                                   const Consensus::Params &params) {
+    assert(pindexLast->nHeight > pindexFirst->nHeight);
+
+    /**
+     * From the total work done and the time it took to produce that much work,
+     * we can deduce how much work we expect to be produced in the targeted time
+     * between blocks.
+     */
+    arith_uint256 work = pindexLast->nChainWork - pindexFirst->nChainWork;
+    work *= params.nPowTargetSpacing;
+
+    // In order to avoid difficulty cliffs, we bound the amplitude of the
+    // adjustment we are going to do to a factor in [0.5, 2].
+    int64_t nActualTimespan =
+        int64_t(pindexLast->nTime) - int64_t(pindexFirst->nTime);
+    if (nActualTimespan > 288 * params.nPowTargetSpacing) {
+        nActualTimespan = 288 * params.nPowTargetSpacing;
+    } else if (nActualTimespan < 72 * params.nPowTargetSpacing) {
+        nActualTimespan = 72 * params.nPowTargetSpacing;
+    }
+
+    work /= nActualTimespan;
+
+    /**
+     * We need to compute T = (2^256 / W) - 1 but 2^256 doesn't fit in 256 bits.
+     * By expressing 1 as W / W, we get (2^256 - W) / W, and we can compute
+     * 2^256 - W as the complement of W.
+     */
+    return (-work) / work;
+}
+
+/**
+ * To reduce the impact of timestamp manipulation, we select the block we are
+ * basing our computation on via a median of 3.
+ */
+static const CBlockIndex *GetSuitableBlock(const CBlockIndex *pindex) {
+    assert(pindex->nHeight >= 3);
+
+    /**
+     * In order to avoid a block with a very skewed timestamp having too much
+     * influence, we select the median of the 3 top most blocks as a starting
+     * point.
+     */
+    const CBlockIndex *blocks[3];
+    blocks[2] = pindex;
+    blocks[1] = pindex->pprev;
+    blocks[0] = blocks[1]->pprev;
+
+    // Sorting network.
+    if (blocks[0]->nTime > blocks[2]->nTime) {
+        std::swap(blocks[0], blocks[2]);
+    }
+
+    if (blocks[0]->nTime > blocks[1]->nTime) {
+        std::swap(blocks[0], blocks[1]);
+    }
+
+    if (blocks[1]->nTime > blocks[2]->nTime) {
+        std::swap(blocks[1], blocks[2]);
+    }
+
+    // We should have our candidate in the middle now.
+    return blocks[1];
+}
+
+/**
+ * Compute the next required proof of work using a weighted average of the
+ * estimated hashrate per block.
+ *
+ * Using a weighted average ensure that the timestamp parameter cancels out in
+ * most of the calculation - except for the timestamp of the first and last
+ * block. Because timestamps are the least trustworthy information we have as
+ * input, this ensures the algorithm is more resistant to malicious inputs.
+ */
+uint32_t GetNextDAAWorkRequired(const CBlockIndex *pindexPrev,
+                                const CBlockHeader *pblock,
+                                const Consensus::Params &params) {
+    // This cannot handle the genesis block and early blocks in general.
+    assert(pindexPrev);
+
+    // Special difficulty rule for testnet:
+    // If the new block's timestamp is more than 2* 10 minutes then allow
+    // mining of a min-difficulty block.
+    if (params.fPowAllowMinDifficultyBlocks &&
+        (pblock->GetBlockTime() >
+         pindexPrev->GetBlockTime() + 2 * params.nPowTargetSpacing)) {
+        return UintToArith256(params.powLimit).GetCompact();
+    }
+
+    // Compute the difficulty based on the full adjustment interval.
+    const uint32_t nHeight = pindexPrev->nHeight;
+    assert(nHeight >= params.DifficultyAdjustmentInterval());
+
+    // Get the last suitable block of the difficulty interval.
+    const CBlockIndex *pindexLast = GetSuitableBlock(pindexPrev);
+    assert(pindexLast);
+
+    // Get the first suitable block of the difficulty interval.
+    uint32_t nHeightFirst = nHeight - 144;
+    const CBlockIndex *pindexFirst =
+        GetSuitableBlock(pindexPrev->GetAncestor(nHeightFirst));
+    assert(pindexFirst);
+
+    // Compute the target based on time and work done during the interval.
+    const arith_uint256 nextTarget =
+        ComputeTarget(pindexFirst, pindexLast, params);
+
+    const arith_uint256 powLimit = UintToArith256(params.powLimit);
+    if (nextTarget > powLimit) {
+        return powLimit.GetCompact();
+    }
+
+    return nextTarget.GetCompact();
+}
diff -Nru bitcoinabc-0.21.11/src/pow/daa.h bitcoinabc-0.21.12/src/pow/daa.h
--- bitcoinabc-0.21.11/src/pow/daa.h	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow/daa.h	2020-07-17 16:19:01.000000000 +0000
@@ -0,0 +1,21 @@
+// Copyright (c) 2017-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_POW_DAA_H
+#define BITCOIN_POW_DAA_H
+
+#include <cstdint>
+
+class CBlockHeader;
+class CBlockIndex;
+
+namespace Consensus {
+struct Params;
+}
+
+uint32_t GetNextDAAWorkRequired(const CBlockIndex *pindexPrev,
+                                const CBlockHeader *pblock,
+                                const Consensus::Params &params);
+
+#endif // BITCOIN_POW_DAA_H
diff -Nru bitcoinabc-0.21.11/src/pow/eda.cpp bitcoinabc-0.21.12/src/pow/eda.cpp
--- bitcoinabc-0.21.11/src/pow/eda.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow/eda.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -0,0 +1,115 @@
+// Copyright (c) 2017-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <pow/eda.h>
+
+#include <arith_uint256.h>
+#include <chain.h>
+#include <consensus/params.h>
+
+/**
+ * Do difficulty adjustement Satoshi's way.
+ */
+uint32_t CalculateNextWorkRequired(const CBlockIndex *pindexPrev,
+                                   int64_t nFirstBlockTime,
+                                   const Consensus::Params &params) {
+    // Limit adjustment step
+    int64_t nActualTimespan = pindexPrev->GetBlockTime() - nFirstBlockTime;
+    if (nActualTimespan < params.nPowTargetTimespan / 4) {
+        nActualTimespan = params.nPowTargetTimespan / 4;
+    }
+
+    if (nActualTimespan > params.nPowTargetTimespan * 4) {
+        nActualTimespan = params.nPowTargetTimespan * 4;
+    }
+
+    // Retarget
+    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
+    arith_uint256 bnNew;
+    bnNew.SetCompact(pindexPrev->nBits);
+    bnNew *= nActualTimespan;
+    bnNew /= params.nPowTargetTimespan;
+
+    if (bnNew > bnPowLimit) {
+        bnNew = bnPowLimit;
+    }
+
+    return bnNew.GetCompact();
+}
+
+/**
+ * Compute the next required proof of work using the legacy Bitcoin difficulty
+ * adjustment + Emergency Difficulty Adjustment (EDA).
+ */
+uint32_t GetNextEDAWorkRequired(const CBlockIndex *pindexPrev,
+                                const CBlockHeader *pblock,
+                                const Consensus::Params &params) {
+    // Only change once per difficulty adjustment interval
+    uint32_t nHeight = pindexPrev->nHeight + 1;
+    if (nHeight % params.DifficultyAdjustmentInterval() == 0) {
+        // Go back by what we want to be 14 days worth of blocks
+        assert(nHeight >= params.DifficultyAdjustmentInterval());
+        uint32_t nHeightFirst = nHeight - params.DifficultyAdjustmentInterval();
+        const CBlockIndex *pindexFirst = pindexPrev->GetAncestor(nHeightFirst);
+        assert(pindexFirst);
+
+        return CalculateNextWorkRequired(pindexPrev,
+                                         pindexFirst->GetBlockTime(), params);
+    }
+
+    const uint32_t nProofOfWorkLimit =
+        UintToArith256(params.powLimit).GetCompact();
+
+    if (params.fPowAllowMinDifficultyBlocks) {
+        // Special difficulty rule for testnet:
+        // If the new block's timestamp is more than 2* 10 minutes then allow
+        // mining of a min-difficulty block.
+        if (pblock->GetBlockTime() >
+            pindexPrev->GetBlockTime() + 2 * params.nPowTargetSpacing) {
+            return nProofOfWorkLimit;
+        }
+
+        // Return the last non-special-min-difficulty-rules-block
+        const CBlockIndex *pindex = pindexPrev;
+        while (pindex->pprev &&
+               pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 &&
+               pindex->nBits == nProofOfWorkLimit) {
+            pindex = pindex->pprev;
+        }
+
+        return pindex->nBits;
+    }
+
+    // We can't go below the minimum, so bail early.
+    uint32_t nBits = pindexPrev->nBits;
+    if (nBits == nProofOfWorkLimit) {
+        return nProofOfWorkLimit;
+    }
+
+    // If producing the last 6 blocks took less than 12h, we keep the same
+    // difficulty.
+    const CBlockIndex *pindex6 = pindexPrev->GetAncestor(nHeight - 7);
+    assert(pindex6);
+    int64_t mtp6blocks =
+        pindexPrev->GetMedianTimePast() - pindex6->GetMedianTimePast();
+    if (mtp6blocks < 12 * 3600) {
+        return nBits;
+    }
+
+    // If producing the last 6 blocks took more than 12h, increase the
+    // difficulty target by 1/4 (which reduces the difficulty by 20%).
+    // This ensures that the chain does not get stuck in case we lose
+    // hashrate abruptly.
+    arith_uint256 nPow;
+    nPow.SetCompact(nBits);
+    nPow += (nPow >> 2);
+
+    // Make sure we do not go below allowed values.
+    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
+    if (nPow > bnPowLimit) {
+        nPow = bnPowLimit;
+    }
+
+    return nPow.GetCompact();
+}
diff -Nru bitcoinabc-0.21.11/src/pow/eda.h bitcoinabc-0.21.12/src/pow/eda.h
--- bitcoinabc-0.21.11/src/pow/eda.h	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow/eda.h	2020-07-17 16:19:01.000000000 +0000
@@ -0,0 +1,25 @@
+// Copyright (c) 2017-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_POW_EDA_H
+#define BITCOIN_POW_EDA_H
+
+#include <cstdint>
+
+class CBlockHeader;
+class CBlockIndex;
+
+namespace Consensus {
+struct Params;
+}
+
+uint32_t CalculateNextWorkRequired(const CBlockIndex *pindexPrev,
+                                   int64_t nFirstBlockTime,
+                                   const Consensus::Params &params);
+
+uint32_t GetNextEDAWorkRequired(const CBlockIndex *pindexPrev,
+                                const CBlockHeader *pblock,
+                                const Consensus::Params &params);
+
+#endif // BITCOIN_POW_EDA_H
diff -Nru bitcoinabc-0.21.11/src/pow/pow.cpp bitcoinabc-0.21.12/src/pow/pow.cpp
--- bitcoinabc-0.21.11/src/pow/pow.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow/pow.cpp	2020-07-20 15:59:43.000000000 +0000
@@ -0,0 +1,59 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2016 The Bitcoin Core developers
+// Copyright (c) 2017-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <pow/pow.h>
+
+#include <arith_uint256.h>
+#include <chain.h>
+#include <chainparams.h>
+#include <consensus/activation.h>
+#include <consensus/params.h>
+#include <pow/daa.h>
+#include <pow/eda.h>
+#include <primitives/blockhash.h>
+#include <util/system.h>
+
+uint32_t GetNextWorkRequired(const CBlockIndex *pindexPrev,
+                             const CBlockHeader *pblock,
+                             const CChainParams &chainParams) {
+    // GetNextWorkRequired should never be called on the genesis block
+    assert(pindexPrev != nullptr);
+
+    const Consensus::Params &params = chainParams.GetConsensus();
+
+    // Special rule for regtest: we never retarget.
+    if (params.fPowNoRetargeting) {
+        return pindexPrev->nBits;
+    }
+
+    if (IsDAAEnabled(params, pindexPrev)) {
+        return GetNextDAAWorkRequired(pindexPrev, pblock, params);
+    }
+
+    return GetNextEDAWorkRequired(pindexPrev, pblock, params);
+}
+
+bool CheckProofOfWork(const BlockHash &hash, uint32_t nBits,
+                      const Consensus::Params &params) {
+    bool fNegative;
+    bool fOverflow;
+    arith_uint256 bnTarget;
+
+    bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
+
+    // Check range
+    if (fNegative || bnTarget == 0 || fOverflow ||
+        bnTarget > UintToArith256(params.powLimit)) {
+        return false;
+    }
+
+    // Check proof of work matches claimed amount
+    if (UintToArith256(hash) > bnTarget) {
+        return false;
+    }
+
+    return true;
+}
diff -Nru bitcoinabc-0.21.11/src/pow/pow.h bitcoinabc-0.21.12/src/pow/pow.h
--- bitcoinabc-0.21.11/src/pow/pow.h	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow/pow.h	2020-07-20 15:59:43.000000000 +0000
@@ -0,0 +1,31 @@
+// Copyright (c) 2009-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.
+
+#ifndef BITCOIN_POW_POW_H
+#define BITCOIN_POW_POW_H
+
+#include <cstdint>
+
+struct BlockHash;
+class CBlockHeader;
+class CBlockIndex;
+class CChainParams;
+
+namespace Consensus {
+struct Params;
+}
+
+uint32_t GetNextWorkRequired(const CBlockIndex *pindexPrev,
+                             const CBlockHeader *pblock,
+                             const CChainParams &chainParams);
+
+/**
+ * Check whether a block hash satisfies the proof-of-work requirement specified
+ * by nBits
+ */
+bool CheckProofOfWork(const BlockHash &hash, uint32_t nBits,
+                      const Consensus::Params &params);
+
+#endif // BITCOIN_POW_POW_H
diff -Nru bitcoinabc-0.21.11/src/pow/test/CMakeLists.txt bitcoinabc-0.21.12/src/pow/test/CMakeLists.txt
--- bitcoinabc-0.21.11/src/pow/test/CMakeLists.txt	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow/test/CMakeLists.txt	2020-07-17 16:19:01.000000000 +0000
@@ -0,0 +1,19 @@
+# Copyright (c) 2020 The Bitcoin developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+project(pow-test)
+
+include(TestSuite)
+create_test_suite(pow)
+add_dependencies(check check-pow)
+
+add_boost_unit_tests_to_suite(pow test-pow
+	fixture.cpp
+
+	TESTS
+		daa_tests.cpp
+		eda_tests.cpp
+)
+
+target_link_libraries(test-pow server testutil)
diff -Nru bitcoinabc-0.21.11/src/pow/test/daa_tests.cpp bitcoinabc-0.21.12/src/pow/test/daa_tests.cpp
--- bitcoinabc-0.21.11/src/pow/test/daa_tests.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow/test/daa_tests.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -0,0 +1,246 @@
+// Copyright (c) 2015-2019 The Bitcoin Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <pow/daa.h>
+
+#include <chain.h>
+#include <chainparams.h>
+#include <config.h>
+
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(daa_tests, BasicTestingSetup)
+
+static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval,
+                                 uint32_t nBits) {
+    CBlockIndex block;
+    block.pprev = pindexPrev;
+    block.nHeight = pindexPrev->nHeight + 1;
+    block.nTime = pindexPrev->nTime + nTimeInterval;
+    block.nBits = nBits;
+
+    block.nChainWork = pindexPrev->nChainWork + GetBlockProof(block);
+    return block;
+}
+
+BOOST_AUTO_TEST_CASE(daa_test) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    std::vector<CBlockIndex> blocks(3000);
+
+    const Consensus::Params &params = config.GetChainParams().GetConsensus();
+    const arith_uint256 powLimit = UintToArith256(params.powLimit);
+    uint32_t powLimitBits = powLimit.GetCompact();
+    arith_uint256 currentPow = powLimit >> 4;
+    uint32_t initialBits = currentPow.GetCompact();
+
+    // Genesis block.
+    blocks[0] = CBlockIndex();
+    blocks[0].nHeight = 0;
+    blocks[0].nTime = 1269211443;
+    blocks[0].nBits = initialBits;
+
+    blocks[0].nChainWork = GetBlockProof(blocks[0]);
+
+    // Block counter.
+    size_t i;
+
+    // Pile up some blocks every 10 mins to establish some history.
+    for (i = 1; i < 2050; i++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, initialBits);
+    }
+
+    CBlockHeader blkHeaderDummy;
+    uint32_t nBits =
+        GetNextDAAWorkRequired(&blocks[2049], &blkHeaderDummy, params);
+
+    // Difficulty stays the same as long as we produce a block every 10 mins.
+    for (size_t j = 0; j < 10; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, nBits);
+        BOOST_CHECK_EQUAL(
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params), nBits);
+    }
+
+    // Make sure we skip over blocks that are out of wack. To do so, we produce
+    // a block that is far in the future, and then produce a block with the
+    // expected timestamp.
+    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+    BOOST_CHECK_EQUAL(
+        GetNextDAAWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
+    blocks[i] = GetBlockIndex(&blocks[i - 1], 2 * 600 - 6000, nBits);
+    BOOST_CHECK_EQUAL(
+        GetNextDAAWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
+
+    // The system should continue unaffected by the block with a bogous
+    // timestamps.
+    for (size_t j = 0; j < 20; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, nBits);
+        BOOST_CHECK_EQUAL(
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params), nBits);
+    }
+
+    // We start emitting blocks slightly faster. The first block has no impact.
+    blocks[i] = GetBlockIndex(&blocks[i - 1], 550, nBits);
+    BOOST_CHECK_EQUAL(
+        GetNextDAAWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
+
+    // Now we should see difficulty increase slowly.
+    for (size_t j = 0; j < 10; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 550, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        arith_uint256 currentTarget;
+        currentTarget.SetCompact(nBits);
+        arith_uint256 nextTarget;
+        nextTarget.SetCompact(nextBits);
+
+        // Make sure that difficulty increases very slowly.
+        BOOST_CHECK(nextTarget < currentTarget);
+        BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 10));
+
+        nBits = nextBits;
+    }
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1c0fe7b1);
+
+    // If we dramatically shorten block production, difficulty increases faster.
+    for (size_t j = 0; j < 20; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 10, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        arith_uint256 currentTarget;
+        currentTarget.SetCompact(nBits);
+        arith_uint256 nextTarget;
+        nextTarget.SetCompact(nextBits);
+
+        // Make sure that difficulty increases faster.
+        BOOST_CHECK(nextTarget < currentTarget);
+        BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 4));
+
+        nBits = nextBits;
+    }
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1c0db19f);
+
+    // We start to emit blocks significantly slower. The first block has no
+    // impact.
+    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+    nBits = GetNextDAAWorkRequired(&blocks[i++], &blkHeaderDummy, params);
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1c0d9222);
+
+    // If we dramatically slow down block production, difficulty decreases.
+    for (size_t j = 0; j < 93; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        arith_uint256 currentTarget;
+        currentTarget.SetCompact(nBits);
+        arith_uint256 nextTarget;
+        nextTarget.SetCompact(nextBits);
+
+        // Check the difficulty decreases.
+        BOOST_CHECK(nextTarget <= powLimit);
+        BOOST_CHECK(nextTarget > currentTarget);
+        BOOST_CHECK((nextTarget - currentTarget) < (currentTarget >> 3));
+
+        nBits = nextBits;
+    }
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1c2f13b9);
+
+    // Due to the window of time being bounded, next block's difficulty actually
+    // gets harder.
+    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+    nBits = GetNextDAAWorkRequired(&blocks[i++], &blkHeaderDummy, params);
+    BOOST_CHECK_EQUAL(nBits, 0x1c2ee9bf);
+
+    // And goes down again. It takes a while due to the window being bounded and
+    // the skewed block causes 2 blocks to get out of the window.
+    for (size_t j = 0; j < 192; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        arith_uint256 currentTarget;
+        currentTarget.SetCompact(nBits);
+        arith_uint256 nextTarget;
+        nextTarget.SetCompact(nextBits);
+
+        // Check the difficulty decreases.
+        BOOST_CHECK(nextTarget <= powLimit);
+        BOOST_CHECK(nextTarget > currentTarget);
+        BOOST_CHECK((nextTarget - currentTarget) < (currentTarget >> 3));
+
+        nBits = nextBits;
+    }
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1d00ffff);
+
+    // Once the difficulty reached the minimum allowed level, it doesn't get any
+    // easier.
+    for (size_t j = 0; j < 5; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        // Check the difficulty stays constant.
+        BOOST_CHECK_EQUAL(nextBits, powLimitBits);
+        nBits = nextBits;
+    }
+
+    // We will now mine blocks much faster. For a while, the difficulty will
+    // continue to go down.
+    for (size_t j = 0; j < 130; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 10, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        arith_uint256 currentTarget;
+        currentTarget.SetCompact(nBits);
+        arith_uint256 nextTarget;
+        nextTarget.SetCompact(nextBits);
+
+        // Check the difficulty decreases.
+        BOOST_CHECK(nextTarget <= powLimit);
+        BOOST_CHECK(nextTarget >= currentTarget);
+        BOOST_CHECK((nextTarget - currentTarget) < (currentTarget >> 3));
+
+        nBits = nextBits;
+    }
+
+    // Now the difficulty will go back up, and evetually we will trigger the
+    // cliff code.
+    for (size_t j = 0; j < 70; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 10, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        arith_uint256 currentTarget;
+        currentTarget.SetCompact(nBits);
+        arith_uint256 nextTarget;
+        nextTarget.SetCompact(nextBits);
+
+        // Check the difficulty decreases.
+        BOOST_CHECK(nextTarget < currentTarget);
+        BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 3));
+
+        nBits = nextBits;
+    }
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1c4c068c);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff -Nru bitcoinabc-0.21.11/src/pow/test/eda_tests.cpp bitcoinabc-0.21.12/src/pow/test/eda_tests.cpp
--- bitcoinabc-0.21.11/src/pow/test/eda_tests.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow/test/eda_tests.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -0,0 +1,196 @@
+// Copyright (c) 2015-2019 The Bitcoin Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <pow/eda.h>
+
+#include <chain.h>
+#include <chainparams.h>
+#include <config.h>
+
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(eda_tests, BasicTestingSetup)
+
+/* Test calculation of next difficulty target with no constraints applying */
+BOOST_AUTO_TEST_CASE(get_next_work) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    int64_t nLastRetargetTime = 1261130161; // Block #30240
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 32255;
+    pindexLast.nTime = 1262152739; // Block #32255
+    pindexLast.nBits = 0x1d00ffff;
+    BOOST_CHECK_EQUAL(
+        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
+                                  config.GetChainParams().GetConsensus()),
+        0x1d00d86aU);
+}
+
+/* Test the constraint on the upper bound for next work */
+BOOST_AUTO_TEST_CASE(get_next_work_pow_limit) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    int64_t nLastRetargetTime = 1231006505; // Block #0
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 2015;
+    pindexLast.nTime = 1233061996; // Block #2015
+    pindexLast.nBits = 0x1d00ffff;
+    BOOST_CHECK_EQUAL(
+        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
+                                  config.GetChainParams().GetConsensus()),
+        0x1d00ffffU);
+}
+
+/* Test the constraint on the lower bound for actual time taken */
+BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    int64_t nLastRetargetTime = 1279008237; // Block #66528
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 68543;
+    pindexLast.nTime = 1279297671; // Block #68543
+    pindexLast.nBits = 0x1c05a3f4;
+    BOOST_CHECK_EQUAL(
+        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
+                                  config.GetChainParams().GetConsensus()),
+        0x1c0168fdU);
+}
+
+/* Test the constraint on the upper bound for actual time taken */
+BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    int64_t nLastRetargetTime = 1263163443; // NOTE: Not an actual block time
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 46367;
+    pindexLast.nTime = 1269211443; // Block #46367
+    pindexLast.nBits = 0x1c387f6f;
+    BOOST_CHECK_EQUAL(
+        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
+                                  config.GetChainParams().GetConsensus()),
+        0x1d00e1fdU);
+}
+
+BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    std::vector<CBlockIndex> blocks(10000);
+    for (int i = 0; i < 10000; i++) {
+        blocks[i].pprev = i ? &blocks[i - 1] : nullptr;
+        blocks[i].nHeight = i;
+        blocks[i].nTime =
+            1269211443 +
+            i * config.GetChainParams().GetConsensus().nPowTargetSpacing;
+        blocks[i].nBits = 0x207fffff; /* target 0x7fffff000... */
+        blocks[i].nChainWork =
+            i ? blocks[i - 1].nChainWork + GetBlockProof(blocks[i])
+              : arith_uint256(0);
+    }
+
+    for (int j = 0; j < 1000; j++) {
+        CBlockIndex *p1 = &blocks[InsecureRandRange(10000)];
+        CBlockIndex *p2 = &blocks[InsecureRandRange(10000)];
+        CBlockIndex *p3 = &blocks[InsecureRandRange(10000)];
+
+        int64_t tdiff = GetBlockProofEquivalentTime(
+            *p1, *p2, *p3, config.GetChainParams().GetConsensus());
+        BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime());
+    }
+}
+
+static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval,
+                                 uint32_t nBits) {
+    CBlockIndex block;
+    block.pprev = pindexPrev;
+    block.nHeight = pindexPrev->nHeight + 1;
+    block.nTime = pindexPrev->nTime + nTimeInterval;
+    block.nBits = nBits;
+
+    block.nChainWork = pindexPrev->nChainWork + GetBlockProof(block);
+    return block;
+}
+
+BOOST_AUTO_TEST_CASE(retargeting_test) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    std::vector<CBlockIndex> blocks(115);
+
+    const Consensus::Params &params = config.GetChainParams().GetConsensus();
+    const arith_uint256 powLimit = UintToArith256(params.powLimit);
+    arith_uint256 currentPow = powLimit >> 1;
+    uint32_t initialBits = currentPow.GetCompact();
+
+    // Genesis block.
+    blocks[0] = CBlockIndex();
+    blocks[0].nHeight = 0;
+    blocks[0].nTime = 1269211443;
+    blocks[0].nBits = initialBits;
+
+    blocks[0].nChainWork = GetBlockProof(blocks[0]);
+
+    // Pile up some blocks.
+    for (size_t i = 1; i < 100; i++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], params.nPowTargetSpacing,
+                                  initialBits);
+    }
+
+    CBlockHeader blkHeaderDummy;
+
+    // We start getting 2h blocks time. For the first 5 blocks, it doesn't
+    // matter as the MTP is not affected. For the next 5 block, MTP difference
+    // increases but stays below 12h.
+    for (size_t i = 100; i < 110; i++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 2 * 3600, initialBits);
+        BOOST_CHECK_EQUAL(
+            GetNextEDAWorkRequired(&blocks[i], &blkHeaderDummy, params),
+            initialBits);
+    }
+
+    // Now we expect the difficulty to decrease.
+    blocks[110] = GetBlockIndex(&blocks[109], 2 * 3600, initialBits);
+    currentPow.SetCompact(currentPow.GetCompact());
+    currentPow += (currentPow >> 2);
+    BOOST_CHECK_EQUAL(
+        GetNextEDAWorkRequired(&blocks[110], &blkHeaderDummy, params),
+        currentPow.GetCompact());
+
+    // As we continue with 2h blocks, difficulty continue to decrease.
+    blocks[111] =
+        GetBlockIndex(&blocks[110], 2 * 3600, currentPow.GetCompact());
+    currentPow.SetCompact(currentPow.GetCompact());
+    currentPow += (currentPow >> 2);
+    BOOST_CHECK_EQUAL(
+        GetNextEDAWorkRequired(&blocks[111], &blkHeaderDummy, params),
+        currentPow.GetCompact());
+
+    // We decrease again.
+    blocks[112] =
+        GetBlockIndex(&blocks[111], 2 * 3600, currentPow.GetCompact());
+    currentPow.SetCompact(currentPow.GetCompact());
+    currentPow += (currentPow >> 2);
+    BOOST_CHECK_EQUAL(
+        GetNextEDAWorkRequired(&blocks[112], &blkHeaderDummy, params),
+        currentPow.GetCompact());
+
+    // We check that we do not go below the minimal difficulty.
+    blocks[113] =
+        GetBlockIndex(&blocks[112], 2 * 3600, currentPow.GetCompact());
+    currentPow.SetCompact(currentPow.GetCompact());
+    currentPow += (currentPow >> 2);
+    BOOST_CHECK(powLimit.GetCompact() != currentPow.GetCompact());
+    BOOST_CHECK_EQUAL(
+        GetNextEDAWorkRequired(&blocks[113], &blkHeaderDummy, params),
+        powLimit.GetCompact());
+
+    // Once we reached the minimal difficulty, we stick with it.
+    blocks[114] = GetBlockIndex(&blocks[113], 2 * 3600, powLimit.GetCompact());
+    BOOST_CHECK(powLimit.GetCompact() != currentPow.GetCompact());
+    BOOST_CHECK_EQUAL(
+        GetNextEDAWorkRequired(&blocks[114], &blkHeaderDummy, params),
+        powLimit.GetCompact());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff -Nru bitcoinabc-0.21.11/src/pow/test/fixture.cpp bitcoinabc-0.21.12/src/pow/test/fixture.cpp
--- bitcoinabc-0.21.11/src/pow/test/fixture.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow/test/fixture.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -0,0 +1,6 @@
+// Copyright (c) 2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#define BOOST_TEST_MODULE Difficulty Adjustement Test Suite
+#include <boost/test/unit_test.hpp>
diff -Nru bitcoinabc-0.21.11/src/pow.cpp bitcoinabc-0.21.12/src/pow.cpp
--- bitcoinabc-0.21.11/src/pow.cpp	2020-06-30 00:18:54.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow.cpp	1970-01-01 00:00:00.000000000 +0000
@@ -1,284 +0,0 @@
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2016 The Bitcoin Core developers
-// Copyright (c) 2017-2020 The Bitcoin developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <pow.h>
-
-#include <arith_uint256.h>
-#include <chain.h>
-#include <consensus/activation.h>
-#include <consensus/params.h>
-#include <primitives/block.h>
-#include <primitives/blockhash.h>
-#include <uint256.h>
-#include <util/system.h>
-
-/**
- * Compute the next required proof of work using the legacy Bitcoin difficulty
- * adjustment + Emergency Difficulty Adjustment (EDA).
- */
-static uint32_t GetNextEDAWorkRequired(const CBlockIndex *pindexPrev,
-                                       const CBlockHeader *pblock,
-                                       const Consensus::Params &params) {
-    // Only change once per difficulty adjustment interval
-    uint32_t nHeight = pindexPrev->nHeight + 1;
-    if (nHeight % params.DifficultyAdjustmentInterval() == 0) {
-        // Go back by what we want to be 14 days worth of blocks
-        assert(nHeight >= params.DifficultyAdjustmentInterval());
-        uint32_t nHeightFirst = nHeight - params.DifficultyAdjustmentInterval();
-        const CBlockIndex *pindexFirst = pindexPrev->GetAncestor(nHeightFirst);
-        assert(pindexFirst);
-
-        return CalculateNextWorkRequired(pindexPrev,
-                                         pindexFirst->GetBlockTime(), params);
-    }
-
-    const uint32_t nProofOfWorkLimit =
-        UintToArith256(params.powLimit).GetCompact();
-
-    if (params.fPowAllowMinDifficultyBlocks) {
-        // Special difficulty rule for testnet:
-        // If the new block's timestamp is more than 2* 10 minutes then allow
-        // mining of a min-difficulty block.
-        if (pblock->GetBlockTime() >
-            pindexPrev->GetBlockTime() + 2 * params.nPowTargetSpacing) {
-            return nProofOfWorkLimit;
-        }
-
-        // Return the last non-special-min-difficulty-rules-block
-        const CBlockIndex *pindex = pindexPrev;
-        while (pindex->pprev &&
-               pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 &&
-               pindex->nBits == nProofOfWorkLimit) {
-            pindex = pindex->pprev;
-        }
-
-        return pindex->nBits;
-    }
-
-    // We can't go below the minimum, so bail early.
-    uint32_t nBits = pindexPrev->nBits;
-    if (nBits == nProofOfWorkLimit) {
-        return nProofOfWorkLimit;
-    }
-
-    // If producing the last 6 blocks took less than 12h, we keep the same
-    // difficulty.
-    const CBlockIndex *pindex6 = pindexPrev->GetAncestor(nHeight - 7);
-    assert(pindex6);
-    int64_t mtp6blocks =
-        pindexPrev->GetMedianTimePast() - pindex6->GetMedianTimePast();
-    if (mtp6blocks < 12 * 3600) {
-        return nBits;
-    }
-
-    // If producing the last 6 blocks took more than 12h, increase the
-    // difficulty target by 1/4 (which reduces the difficulty by 20%).
-    // This ensures that the chain does not get stuck in case we lose
-    // hashrate abruptly.
-    arith_uint256 nPow;
-    nPow.SetCompact(nBits);
-    nPow += (nPow >> 2);
-
-    // Make sure we do not go below allowed values.
-    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
-    if (nPow > bnPowLimit) {
-        nPow = bnPowLimit;
-    }
-
-    return nPow.GetCompact();
-}
-
-uint32_t GetNextWorkRequired(const CBlockIndex *pindexPrev,
-                             const CBlockHeader *pblock,
-                             const Consensus::Params &params) {
-    // GetNextWorkRequired should never be called on the genesis block
-    assert(pindexPrev != nullptr);
-
-    // Special rule for regtest: we never retarget.
-    if (params.fPowNoRetargeting) {
-        return pindexPrev->nBits;
-    }
-
-    if (IsDAAEnabled(params, pindexPrev)) {
-        return GetNextCashWorkRequired(pindexPrev, pblock, params);
-    }
-
-    return GetNextEDAWorkRequired(pindexPrev, pblock, params);
-}
-
-uint32_t CalculateNextWorkRequired(const CBlockIndex *pindexPrev,
-                                   int64_t nFirstBlockTime,
-                                   const Consensus::Params &params) {
-    if (params.fPowNoRetargeting) {
-        return pindexPrev->nBits;
-    }
-
-    // Limit adjustment step
-    int64_t nActualTimespan = pindexPrev->GetBlockTime() - nFirstBlockTime;
-    if (nActualTimespan < params.nPowTargetTimespan / 4) {
-        nActualTimespan = params.nPowTargetTimespan / 4;
-    }
-
-    if (nActualTimespan > params.nPowTargetTimespan * 4) {
-        nActualTimespan = params.nPowTargetTimespan * 4;
-    }
-
-    // Retarget
-    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
-    arith_uint256 bnNew;
-    bnNew.SetCompact(pindexPrev->nBits);
-    bnNew *= nActualTimespan;
-    bnNew /= params.nPowTargetTimespan;
-
-    if (bnNew > bnPowLimit) {
-        bnNew = bnPowLimit;
-    }
-
-    return bnNew.GetCompact();
-}
-
-bool CheckProofOfWork(const BlockHash &hash, uint32_t nBits,
-                      const Consensus::Params &params) {
-    bool fNegative;
-    bool fOverflow;
-    arith_uint256 bnTarget;
-
-    bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
-
-    // Check range
-    if (fNegative || bnTarget == 0 || fOverflow ||
-        bnTarget > UintToArith256(params.powLimit)) {
-        return false;
-    }
-
-    // Check proof of work matches claimed amount
-    if (UintToArith256(hash) > bnTarget) {
-        return false;
-    }
-
-    return true;
-}
-
-/**
- * Compute a target based on the work done between 2 blocks and the time
- * required to produce that work.
- */
-static arith_uint256 ComputeTarget(const CBlockIndex *pindexFirst,
-                                   const CBlockIndex *pindexLast,
-                                   const Consensus::Params &params) {
-    assert(pindexLast->nHeight > pindexFirst->nHeight);
-
-    /**
-     * From the total work done and the time it took to produce that much work,
-     * we can deduce how much work we expect to be produced in the targeted time
-     * between blocks.
-     */
-    arith_uint256 work = pindexLast->nChainWork - pindexFirst->nChainWork;
-    work *= params.nPowTargetSpacing;
-
-    // In order to avoid difficulty cliffs, we bound the amplitude of the
-    // adjustment we are going to do to a factor in [0.5, 2].
-    int64_t nActualTimespan =
-        int64_t(pindexLast->nTime) - int64_t(pindexFirst->nTime);
-    if (nActualTimespan > 288 * params.nPowTargetSpacing) {
-        nActualTimespan = 288 * params.nPowTargetSpacing;
-    } else if (nActualTimespan < 72 * params.nPowTargetSpacing) {
-        nActualTimespan = 72 * params.nPowTargetSpacing;
-    }
-
-    work /= nActualTimespan;
-
-    /**
-     * We need to compute T = (2^256 / W) - 1 but 2^256 doesn't fit in 256 bits.
-     * By expressing 1 as W / W, we get (2^256 - W) / W, and we can compute
-     * 2^256 - W as the complement of W.
-     */
-    return (-work) / work;
-}
-
-/**
- * To reduce the impact of timestamp manipulation, we select the block we are
- * basing our computation on via a median of 3.
- */
-static const CBlockIndex *GetSuitableBlock(const CBlockIndex *pindex) {
-    assert(pindex->nHeight >= 3);
-
-    /**
-     * In order to avoid a block with a very skewed timestamp having too much
-     * influence, we select the median of the 3 top most blocks as a starting
-     * point.
-     */
-    const CBlockIndex *blocks[3];
-    blocks[2] = pindex;
-    blocks[1] = pindex->pprev;
-    blocks[0] = blocks[1]->pprev;
-
-    // Sorting network.
-    if (blocks[0]->nTime > blocks[2]->nTime) {
-        std::swap(blocks[0], blocks[2]);
-    }
-
-    if (blocks[0]->nTime > blocks[1]->nTime) {
-        std::swap(blocks[0], blocks[1]);
-    }
-
-    if (blocks[1]->nTime > blocks[2]->nTime) {
-        std::swap(blocks[1], blocks[2]);
-    }
-
-    // We should have our candidate in the middle now.
-    return blocks[1];
-}
-
-/**
- * Compute the next required proof of work using a weighted average of the
- * estimated hashrate per block.
- *
- * Using a weighted average ensure that the timestamp parameter cancels out in
- * most of the calculation - except for the timestamp of the first and last
- * block. Because timestamps are the least trustworthy information we have as
- * input, this ensures the algorithm is more resistant to malicious inputs.
- */
-uint32_t GetNextCashWorkRequired(const CBlockIndex *pindexPrev,
-                                 const CBlockHeader *pblock,
-                                 const Consensus::Params &params) {
-    // This cannot handle the genesis block and early blocks in general.
-    assert(pindexPrev);
-
-    // Special difficulty rule for testnet:
-    // If the new block's timestamp is more than 2* 10 minutes then allow
-    // mining of a min-difficulty block.
-    if (params.fPowAllowMinDifficultyBlocks &&
-        (pblock->GetBlockTime() >
-         pindexPrev->GetBlockTime() + 2 * params.nPowTargetSpacing)) {
-        return UintToArith256(params.powLimit).GetCompact();
-    }
-
-    // Compute the difficulty based on the full adjustment interval.
-    const uint32_t nHeight = pindexPrev->nHeight;
-    assert(nHeight >= params.DifficultyAdjustmentInterval());
-
-    // Get the last suitable block of the difficulty interval.
-    const CBlockIndex *pindexLast = GetSuitableBlock(pindexPrev);
-    assert(pindexLast);
-
-    // Get the first suitable block of the difficulty interval.
-    uint32_t nHeightFirst = nHeight - 144;
-    const CBlockIndex *pindexFirst =
-        GetSuitableBlock(pindexPrev->GetAncestor(nHeightFirst));
-    assert(pindexFirst);
-
-    // Compute the target based on time and work done during the interval.
-    const arith_uint256 nextTarget =
-        ComputeTarget(pindexFirst, pindexLast, params);
-
-    const arith_uint256 powLimit = UintToArith256(params.powLimit);
-    if (nextTarget > powLimit) {
-        return powLimit.GetCompact();
-    }
-
-    return nextTarget.GetCompact();
-}
diff -Nru bitcoinabc-0.21.11/src/pow.h bitcoinabc-0.21.12/src/pow.h
--- bitcoinabc-0.21.11/src/pow.h	2020-06-30 00:19:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pow.h	1970-01-01 00:00:00.000000000 +0000
@@ -1,41 +0,0 @@
-// Copyright (c) 2009-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.
-
-#ifndef BITCOIN_POW_H
-#define BITCOIN_POW_H
-
-#include <cstdint>
-
-struct BlockHash;
-class CBlockHeader;
-class CBlockIndex;
-class uint256;
-
-namespace Consensus {
-struct Params;
-}
-
-uint32_t GetNextWorkRequired(const CBlockIndex *pindexPrev,
-                             const CBlockHeader *pblock,
-                             const Consensus::Params &params);
-uint32_t CalculateNextWorkRequired(const CBlockIndex *pindexPrev,
-                                   int64_t nFirstBlockTime,
-                                   const Consensus::Params &params);
-
-/**
- * Check whether a block hash satisfies the proof-of-work requirement specified
- * by nBits
- */
-bool CheckProofOfWork(const BlockHash &hash, uint32_t nBits,
-                      const Consensus::Params &params);
-
-/**
- * Bitcoin cash's difficulty adjustment mechanism.
- */
-uint32_t GetNextCashWorkRequired(const CBlockIndex *pindexPrev,
-                                 const CBlockHeader *pblock,
-                                 const Consensus::Params &params);
-
-#endif // BITCOIN_POW_H
diff -Nru bitcoinabc-0.21.11/src/pubkey.h bitcoinabc-0.21.12/src/pubkey.h
--- bitcoinabc-0.21.11/src/pubkey.h	2020-06-30 00:19:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/pubkey.h	2020-07-27 15:24:34.000000000 +0000
@@ -228,6 +228,8 @@
         s.read((char *)&code[0], len);
         Decode(code);
     }
+
+    CExtPubKey() = default;
 };
 
 /**
diff -Nru bitcoinabc-0.21.11/src/qt/bitcoingui.cpp bitcoinabc-0.21.12/src/qt/bitcoingui.cpp
--- bitcoinabc-0.21.11/src/qt/bitcoingui.cpp	2020-06-30 00:19:22.000000000 +0000
+++ bitcoinabc-0.21.12/src/qt/bitcoingui.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -1415,19 +1415,19 @@
 
 void BitcoinGUI::showProgress(const QString &title, int nProgress) {
     if (nProgress == 0) {
-        progressDialog = new QProgressDialog(title, "", 0, 100);
+        progressDialog = new QProgressDialog(title, QString(), 0, 100);
+        GUIUtil::PolishProgressDialog(progressDialog);
         progressDialog->setWindowModality(Qt::ApplicationModal);
         progressDialog->setMinimumDuration(0);
-        progressDialog->setCancelButton(nullptr);
         progressDialog->setAutoClose(false);
         progressDialog->setValue(0);
-    } else if (progressDialog) {
-        if (nProgress == 100) {
+    } else if (nProgress == 100) {
+        if (progressDialog) {
             progressDialog->close();
             progressDialog->deleteLater();
-        } else {
-            progressDialog->setValue(nProgress);
         }
+    } else if (progressDialog) {
+        progressDialog->setValue(nProgress);
     }
 }
 
diff -Nru bitcoinabc-0.21.11/src/qt/guiutil.cpp bitcoinabc-0.21.12/src/qt/guiutil.cpp
--- bitcoinabc-0.21.11/src/qt/guiutil.cpp	2020-06-30 00:19:22.000000000 +0000
+++ bitcoinabc-0.21.12/src/qt/guiutil.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -47,9 +47,11 @@
 #include <QFileDialog>
 #include <QFont>
 #include <QFontDatabase>
+#include <QFontMetrics>
 #include <QKeyEvent>
 #include <QLineEdit>
 #include <QMouseEvent>
+#include <QProgressDialog>
 #include <QSettings>
 #include <QTextDocument> // for Qt::mightBeRichText
 #include <QThread>
@@ -972,4 +974,15 @@
 #endif
 }
 
+void PolishProgressDialog(QProgressDialog *dialog) {
+#ifdef Q_OS_MAC
+    // Workaround for macOS-only Qt bug; see: QTBUG-65750, QTBUG-70357.
+    const int margin = dialog->fontMetrics().width("X");
+    dialog->resize(dialog->width() + 2 * margin, dialog->height());
+    dialog->show();
+#else
+    Q_UNUSED(dialog);
+#endif
+}
+
 } // namespace GUIUtil
diff -Nru bitcoinabc-0.21.11/src/qt/guiutil.h bitcoinabc-0.21.12/src/qt/guiutil.h
--- bitcoinabc-0.21.11/src/qt/guiutil.h	2020-06-18 19:26:30.000000000 +0000
+++ bitcoinabc-0.21.12/src/qt/guiutil.h	2020-07-17 16:19:01.000000000 +0000
@@ -32,6 +32,7 @@
 class QDateTime;
 class QFont;
 class QLineEdit;
+class QProgressDialog;
 class QUrl;
 class QWidget;
 QT_END_NAMESPACE
@@ -295,6 +296,9 @@
  * introduced.
  */
 int TextWidth(const QFontMetrics &fm, const QString &text);
+
+// Fix known bugs in QProgressDialog class.
+void PolishProgressDialog(QProgressDialog *dialog);
 } // namespace GUIUtil
 
 #endif // BITCOIN_QT_GUIUTIL_H
diff -Nru bitcoinabc-0.21.11/src/qt/walletview.cpp bitcoinabc-0.21.12/src/qt/walletview.cpp
--- bitcoinabc-0.21.11/src/qt/walletview.cpp	2020-06-30 00:19:22.000000000 +0000
+++ bitcoinabc-0.21.12/src/qt/walletview.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -343,12 +343,12 @@
 
 void WalletView::showProgress(const QString &title, int nProgress) {
     if (nProgress == 0) {
-        progressDialog = new QProgressDialog(title, "", 0, 100);
+        progressDialog = new QProgressDialog(title, tr("Cancel"), 0, 100);
+        GUIUtil::PolishProgressDialog(progressDialog);
         progressDialog->setWindowModality(Qt::ApplicationModal);
         progressDialog->setMinimumDuration(0);
         progressDialog->setAutoClose(false);
         progressDialog->setValue(0);
-        progressDialog->setCancelButtonText(tr("Cancel"));
     } else if (nProgress == 100) {
         if (progressDialog) {
             progressDialog->close();
diff -Nru bitcoinabc-0.21.11/src/rpc/avalanche.cpp bitcoinabc-0.21.12/src/rpc/avalanche.cpp
--- bitcoinabc-0.21.11/src/rpc/avalanche.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/rpc/avalanche.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -4,6 +4,7 @@
 
 #include <avalanche/processor.h>
 #include <avalanche/proof.h>
+#include <avalanche/proofbuilder.h>
 #include <config.h>
 #include <key_io.h>
 #include <rpc/server.h>
@@ -30,48 +31,169 @@
     return HexStr(g_avalanche->getSessionPubKey());
 }
 
-static UniValue addavalanchepeer(const Config &config,
+static CPubKey ParsePubKey(const UniValue &param) {
+    const std::string keyHex = param.get_str();
+    if ((keyHex.length() != 2 * CPubKey::COMPRESSED_PUBLIC_KEY_SIZE &&
+         keyHex.length() != 2 * CPubKey::PUBLIC_KEY_SIZE) ||
+        !IsHex(keyHex)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                           strprintf("Invalid public key: %s\n", keyHex));
+    }
+
+    return HexToPubKey(keyHex);
+}
+
+static UniValue addavalanchenode(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
-        "addavalanchepeer",
-        "\nAdd a peer to the set of peer to poll for avalanche.\n",
+        "addavalanchenode",
+        "\nAdd a node in the set of peers to poll for avalanche.\n",
         {
             {"nodeid", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "Node to be added to avalanche."},
             {"publickey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The public key of the node."},
+            {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
+             "Proof that the node is not a sybil."},
         },
-        RPCResults{},
-        RPCExamples{HelpExampleRpc("addavalanchepeer", "5")},
+        RPCResult{"\"success\"    (boolean) Whether the addition succeeded or "
+                  "not.\n"},
+        RPCExamples{
+            HelpExampleRpc("addavalanchenode", "5, \"<pubkey>\", \"<proof>\"")},
     }
         .Check(request);
 
+    RPCTypeCheck(request.params,
+                 {UniValue::VNUM, UniValue::VSTR, UniValue::VSTR});
+
     if (!g_avalanche) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
     }
 
-    // Parse nodeid
-    if (!request.params[0].isNum()) {
-        throw JSONRPCError(
-            RPC_INVALID_PARAMETER,
-            std::string("Invalid parameter, nodeid must be an integer"));
-    }
+    const NodeId nodeid = request.params[0].get_int64();
+    const CPubKey key = ParsePubKey(request.params[1]);
 
-    NodeId nodeid = request.params[0].get_int64();
+    CDataStream ss(ParseHexV(request.params[2], "proof"), SER_NETWORK,
+                   PROTOCOL_VERSION);
+    avalanche::Proof proof;
+    ss >> proof;
 
-    // Parse the pubkey
-    const std::string keyHex = request.params[1].get_str();
-    if ((keyHex.length() != 2 * CPubKey::COMPRESSED_PUBLIC_KEY_SIZE &&
-         keyHex.length() != 2 * CPubKey::PUBLIC_KEY_SIZE) ||
-        !IsHex(keyHex)) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
-                           strprintf("Invalid public key: %s\n", keyHex));
+    return g_avalanche->addNode(nodeid, proof, key);
+}
+
+static UniValue buildavalancheproof(const Config &config,
+                                    const JSONRPCRequest &request) {
+    RPCHelpMan{
+        "buildavalancheproof",
+        "\nBuild a proof for avalanche's sybil resistance.\n",
+        {
+            {"sequence", RPCArg::Type::NUM, RPCArg::Optional::NO,
+             "The proof's sequence"},
+            {"expiration", RPCArg::Type::NUM, RPCArg::Optional::NO,
+             "A timestamp indicating when the proof expire"},
+            {"master", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
+             "The master public key"},
+            {
+                "stakes",
+                RPCArg::Type::ARR,
+                RPCArg::Optional::NO,
+                "The stakes to be signed and associated private keys",
+                {
+                    {
+                        "stake",
+                        RPCArg::Type::OBJ,
+                        RPCArg::Optional::NO,
+                        "A stake to be attached to this proof",
+                        {
+                            {"txid", RPCArg::Type::STR_HEX,
+                             RPCArg::Optional::NO, "The transaction id"},
+                            {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
+                             "The output number"},
+                            {"amount", RPCArg::Type::AMOUNT,
+                             RPCArg::Optional::NO, "The amount in this UTXO"},
+                            {"height", RPCArg::Type::NUM, RPCArg::Optional::NO,
+                             "The height at which this UTXO was mined"},
+                            {"iscoinbase", RPCArg::Type::BOOL,
+                             /* default */ "false",
+                             "Indicate wether the UTXO is a coinbase"},
+                            {"privatekey", RPCArg::Type::STR,
+                             RPCArg::Optional::NO,
+                             "private key in base58-encoding"},
+                        },
+                    },
+                },
+            },
+        },
+        RPCResult{"\"poof\"    (string) A string that is a serialized, "
+                  "hex-encoded proof data.\n"},
+        RPCExamples{HelpExampleRpc("buildavalancheproof",
+                                   "0 1234567800 \"<master>\" []")},
     }
+        .Check(request);
+
+    RPCTypeCheck(request.params, {UniValue::VNUM, UniValue::VNUM,
+                                  UniValue::VSTR, UniValue::VARR});
 
-    CPubKey pubkey{HexToPubKey(keyHex)};
+    if (!g_avalanche) {
+        throw JSONRPCError(RPC_INTERNAL_ERROR, "Avalanche is not initialized");
+    }
 
-    g_avalanche->addPeer(nodeid, avalanche::Proof::makeRandom(100), pubkey);
-    return {};
+    const uint64_t sequence = request.params[0].get_int64();
+    const int64_t expiration = request.params[1].get_int64();
+    avalanche::ProofBuilder pb(sequence, expiration,
+                               ParsePubKey(request.params[2]));
+
+    const UniValue &stakes = request.params[3].get_array();
+    for (size_t i = 0; i < stakes.size(); i++) {
+        const UniValue &stake = stakes[i];
+        RPCTypeCheckObj(stake,
+                        {
+                            {"txid", UniValue::VSTR},
+                            {"vout", UniValue::VNUM},
+                            // "amount" is also required but check is done below
+                            // due to UniValue::VNUM erroneously not accepting
+                            // quoted numerics (which are valid JSON)
+                            {"height", UniValue::VNUM},
+                            {"privatekey", UniValue::VSTR},
+                        });
+
+        int nOut = find_value(stake, "vout").get_int();
+        if (nOut < 0) {
+            throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
+                               "vout must be positive");
+        }
+
+        const int height = find_value(stake, "height").get_int();
+        if (height < 1) {
+            throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
+                               "height must be positive");
+        }
+
+        const TxId txid(ParseHashO(stake, "txid"));
+        const COutPoint utxo(txid, nOut);
+
+        if (!stake.exists("amount")) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Missing amount");
+        }
+
+        const Amount amount = AmountFromValue(find_value(stake, "amount"));
+
+        const UniValue &iscbparam = find_value(stake, "iscoinbase");
+        const bool iscoinbase =
+            iscbparam.isNull() ? false : iscbparam.get_bool();
+        CKey key = DecodeSecret(find_value(stake, "privatekey").get_str());
+
+        if (!pb.addUTXO(utxo, amount, uint32_t(height) << 1 | iscoinbase,
+                        std::move(key))) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid private key");
+        }
+    }
+
+    const avalanche::Proof proof = pb.build();
+
+    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+    ss << proof;
+    return HexStr(ss.begin(), ss.end());
 }
 
 // clang-format off
@@ -79,7 +201,8 @@
     //  category            name                      actor (function)        argNames
     //  ------------------- ------------------------  ----------------------  ----------
     { "avalanche",          "getavalanchekey",        getavalanchekey,        {}},
-    { "avalanche",          "addavalanchepeer",       addavalanchepeer,       {"nodeid"}},
+    { "avalanche",          "addavalanchenode",       addavalanchenode,       {"nodeid"}},
+    { "avalanche",          "buildavalancheproof",    buildavalancheproof,    {"sequence", "expiration", "master", "stakes"}},
 };
 // clang-format on
 
diff -Nru bitcoinabc-0.21.11/src/rpc/blockchain.cpp bitcoinabc-0.21.12/src/rpc/blockchain.cpp
--- bitcoinabc-0.21.11/src/rpc/blockchain.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/rpc/blockchain.cpp	2020-07-21 16:22:13.000000000 +0000
@@ -1657,7 +1657,7 @@
         }
     }
 
-    CValidationState state;
+    BlockValidationState state;
     PreciousBlock(config, state, pblockindex);
 
     if (!state.IsValid()) {
@@ -1686,16 +1686,17 @@
 
     std::string strHash = request.params[0].get_str();
     BlockHash hash(uint256S(strHash));
-    CValidationState state;
+    BlockValidationState state;
 
     {
         LOCK(cs_main);
         CBlockIndex *pblockindex = LookupBlockIndex(hash);
+
         if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
-        FinalizeBlockAndInvalidate(config, state, pblockindex);
+        ::ChainstateActive().FinalizeBlock(config, state, pblockindex);
     }
 
     if (state.IsValid()) {
@@ -1726,7 +1727,7 @@
         .Check(request);
 
     const BlockHash hash(ParseHashV(request.params[0], "blockhash"));
-    CValidationState state;
+    BlockValidationState state;
 
     CBlockIndex *pblockindex;
     {
@@ -1765,16 +1766,15 @@
 
     const std::string strHash = request.params[0].get_str();
     const BlockHash hash(uint256S(strHash));
-    CValidationState state;
+    BlockValidationState state;
 
-    CBlockIndex *pblockindex;
+    CBlockIndex *pblockindex = nullptr;
     {
         LOCK(cs_main);
-        if (mapBlockIndex.count(hash) == 0) {
+        pblockindex = LookupBlockIndex(hash);
+        if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
-
-        pblockindex = mapBlockIndex[hash];
     }
     ParkBlock(config, state, pblockindex);
 
@@ -1818,7 +1818,7 @@
         ResetBlockFailureFlags(pblockindex);
     }
 
-    CValidationState state;
+    BlockValidationState state;
     ActivateBestChain(config, state);
 
     if (!state.IsValid()) {
@@ -1849,15 +1849,16 @@
 
     {
         LOCK(cs_main);
-        if (mapBlockIndex.count(hash) == 0) {
+
+        CBlockIndex *pblockindex = LookupBlockIndex(hash);
+        if (!pblockindex) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
         }
 
-        CBlockIndex *pblockindex = mapBlockIndex[hash];
         UnparkBlockAndChildren(pblockindex);
     }
 
-    CValidationState state;
+    BlockValidationState state;
     ActivateBestChain(config, state);
 
     if (!state.IsValid()) {
diff -Nru bitcoinabc-0.21.11/src/rpc/client.cpp bitcoinabc-0.21.12/src/rpc/client.cpp
--- bitcoinabc-0.21.11/src/rpc/client.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/rpc/client.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -156,7 +156,8 @@
     {"getnodeaddresses", 0, "count"},
     {"stop", 0, "wait"},
     // Avalanche
-    {"addavalanchepeer", 0, "nodeid"},
+    {"addavalanchenode", 0, "nodeid"},
+    {"buildavalancheproof", 3, "stakes"},
     // ABC specific RPC
     {"setexcessiveblock", 0, "blockSize"},
 };
diff -Nru bitcoinabc-0.21.11/src/rpc/mining.cpp bitcoinabc-0.21.12/src/rpc/mining.cpp
--- bitcoinabc-0.21.11/src/rpc/mining.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/rpc/mining.cpp	2020-07-20 15:59:43.000000000 +0000
@@ -17,7 +17,7 @@
 #include <net.h>
 #include <node/context.h>
 #include <policy/policy.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
@@ -313,7 +313,7 @@
 // NOTE: Assumes a conclusive result; if result is inconclusive, it must be
 // handled by caller
 static UniValue BIP22ValidationResult(const Config &config,
-                                      const CValidationState &state) {
+                                      const BlockValidationState &state) {
     if (state.IsValid()) {
         return NullUniValue;
     }
@@ -502,7 +502,7 @@
             if (block.hashPrevBlock != pindexPrev->GetBlockHash()) {
                 return "inconclusive-not-best-prevblk";
             }
-            CValidationState state;
+            BlockValidationState state;
             TestBlockValidity(state, config.GetChainParams(), block, pindexPrev,
                               BlockValidationOptions(config)
                                   .withCheckPoW(false)
@@ -614,7 +614,7 @@
     CBlock *pblock = &pblocktemplate->block;
 
     // Update nTime
-    UpdateTime(pblock, config.GetChainParams().GetConsensus(), pindexPrev);
+    UpdateTime(pblock, config.GetChainParams(), pindexPrev);
     pblock->nNonce = 0;
 
     UniValue aCaps(UniValue::VARR);
@@ -687,14 +687,14 @@
 public:
     uint256 hash;
     bool found;
-    CValidationState state;
+    BlockValidationState state;
 
     explicit submitblock_StateCatcher(const uint256 &hashIn)
         : hash(hashIn), found(false), state() {}
 
 protected:
     void BlockChecked(const CBlock &block,
-                      const CValidationState &stateIn) override {
+                      const BlockValidationState &stateIn) override {
         if (block.GetHash() != hash) {
             return;
         }
@@ -803,9 +803,8 @@
         }
     }
 
-    CValidationState state;
-    ProcessNewBlockHeaders(config, {h}, state, /* ppindex */ nullptr,
-                           /* first_invalid */ nullptr);
+    BlockValidationState state;
+    ProcessNewBlockHeaders(config, {h}, state);
     if (state.IsValid()) {
         return NullUniValue;
     }
diff -Nru bitcoinabc-0.21.11/src/rpc/rawtransaction.cpp bitcoinabc-0.21.12/src/rpc/rawtransaction.cpp
--- bitcoinabc-0.21.11/src/rpc/rawtransaction.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/rpc/rawtransaction.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -1036,23 +1036,24 @@
     UniValue result_0(UniValue::VOBJ);
     result_0.pushKV("txid", txid.GetHex());
 
-    CValidationState state;
-    bool missing_inputs;
+    TxValidationState state;
     bool test_accept_res;
     {
         LOCK(cs_main);
         test_accept_res = AcceptToMemoryPool(
-            config, g_mempool, state, std::move(tx), &missing_inputs,
-            false /* bypass_limits */, max_raw_tx_fee, true /* test_accept */);
+            config, g_mempool, state, std::move(tx), false /* bypass_limits */,
+            max_raw_tx_fee, true /* test_accept */);
     }
     result_0.pushKV("allowed", test_accept_res);
     if (!test_accept_res) {
         if (state.IsInvalid()) {
-            result_0.pushKV("reject-reason",
-                            strprintf("%i: %s", state.GetRejectCode(),
-                                      state.GetRejectReason()));
-        } else if (missing_inputs) {
-            result_0.pushKV("reject-reason", "missing-inputs");
+            if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) {
+                result_0.pushKV("reject-reason", "missing-inputs");
+            } else {
+                result_0.pushKV("reject-reason",
+                                strprintf("%i: %s", state.GetRejectCode(),
+                                          state.GetRejectReason()));
+            }
         } else {
             result_0.pushKV("reject-reason", state.GetRejectReason());
         }
diff -Nru bitcoinabc-0.21.11/src/script/descriptor.cpp bitcoinabc-0.21.12/src/script/descriptor.cpp
--- bitcoinabc-0.21.11/src/script/descriptor.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/script/descriptor.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -11,6 +11,7 @@
 #include <script/standard.h>
 #include <span.h>
 #include <util/bip32.h>
+#include <util/spanparsing.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
@@ -734,68 +735,6 @@
 };
 
 /**
- * Parse a constant. If successful, sp is updated to skip the constant and
- * return true.
- */
-bool Const(const std::string &str, Span<const char> &sp) {
-    if ((size_t)sp.size() >= str.size() &&
-        std::equal(str.begin(), str.end(), sp.begin())) {
-        sp = sp.subspan(str.size());
-        return true;
-    }
-    return false;
-}
-
-/**
- * Parse a function call. If successful, sp is updated to be the function's
- * argument(s).
- */
-bool Func(const std::string &str, Span<const char> &sp) {
-    if ((size_t)sp.size() >= str.size() + 2 && sp[str.size()] == '(' &&
-        sp[sp.size() - 1] == ')' &&
-        std::equal(str.begin(), str.end(), sp.begin())) {
-        sp = sp.subspan(str.size() + 1, sp.size() - str.size() - 2);
-        return true;
-    }
-    return false;
-}
-
-/** Return the expression that sp begins with, and update sp to skip it. */
-Span<const char> Expr(Span<const char> &sp) {
-    int level = 0;
-    auto it = sp.begin();
-    while (it != sp.end()) {
-        if (*it == '(') {
-            ++level;
-        } else if (level && *it == ')') {
-            --level;
-        } else if (level == 0 && (*it == ')' || *it == ',')) {
-            break;
-        }
-        ++it;
-    }
-    Span<const char> ret = sp.first(it - sp.begin());
-    sp = sp.subspan(it - sp.begin());
-    return ret;
-}
-
-/** Split a string on every instance of sep, returning a vector. */
-std::vector<Span<const char>> Split(const Span<const char> &sp, char sep) {
-    std::vector<Span<const char>> ret;
-    auto it = sp.begin();
-    auto start = it;
-    while (it != sp.end()) {
-        if (*it == sep) {
-            ret.emplace_back(start, it);
-            start = it + 1;
-        }
-        ++it;
-    }
-    ret.emplace_back(start, it);
-    return ret;
-}
-
-/**
  * Parse a key path, being passed a split list of elements (the first element is
  * ignored).
  */
@@ -827,6 +766,8 @@
 std::unique_ptr<PubkeyProvider> ParsePubkeyInner(const Span<const char> &sp,
                                                  FlatSigningProvider &out,
                                                  std::string &error) {
+    using namespace spanparsing;
+
     auto split = Split(sp, '/');
     std::string str(split[0].begin(), split[0].end());
     if (str.size() == 0) {
@@ -881,6 +822,8 @@
 std::unique_ptr<PubkeyProvider> ParsePubkey(const Span<const char> &sp,
                                             FlatSigningProvider &out,
                                             std::string &error) {
+    using namespace spanparsing;
+
     auto origin_split = Split(sp, ']');
     if (origin_split.size() > 2) {
         error = "Multiple ']' characters found for a single pubkey";
@@ -929,6 +872,8 @@
                                             ParseScriptContext ctx,
                                             FlatSigningProvider &out,
                                             std::string &error) {
+    using namespace spanparsing;
+
     auto expr = Expr(sp);
     if (Func("pk", expr)) {
         auto pubkey = ParsePubkey(expr, out, error);
@@ -1125,6 +1070,8 @@
  */
 bool CheckChecksum(Span<const char> &sp, bool require_checksum,
                    std::string &error, std::string *out_checksum = nullptr) {
+    using namespace spanparsing;
+
     auto check_split = Split(sp, '#');
     if (check_split.size() > 2) {
         error = "Multiple '#' symbols";
diff -Nru bitcoinabc-0.21.11/src/test/blockcheck_tests.cpp bitcoinabc-0.21.12/src/test/blockcheck_tests.cpp
--- bitcoinabc-0.21.11/src/test/blockcheck_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/blockcheck_tests.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -15,7 +15,7 @@
 BOOST_FIXTURE_TEST_SUITE(blockcheck_tests, BasicTestingSetup)
 
 static void RunCheckOnBlockImpl(const GlobalConfig &config, const CBlock &block,
-                                CValidationState &state, bool expected) {
+                                BlockValidationState &state, bool expected) {
     block.fChecked = false;
     bool fValid = CheckBlock(
         block, state, config.GetChainParams().GetConsensus(),
@@ -27,13 +27,13 @@
 }
 
 static void RunCheckOnBlock(const GlobalConfig &config, const CBlock &block) {
-    CValidationState state;
+    BlockValidationState state;
     RunCheckOnBlockImpl(config, block, state, true);
 }
 
 static void RunCheckOnBlock(const GlobalConfig &config, const CBlock &block,
                             const std::string &reason) {
-    CValidationState state;
+    BlockValidationState state;
     RunCheckOnBlockImpl(config, block, state, false);
 
     BOOST_CHECK_EQUAL(state.GetRejectCode(), REJECT_INVALID);
diff -Nru bitcoinabc-0.21.11/src/test/blockencodings_tests.cpp bitcoinabc-0.21.12/src/test/blockencodings_tests.cpp
--- bitcoinabc-0.21.11/src/test/blockencodings_tests.cpp	2020-06-30 00:19:22.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/blockencodings_tests.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -7,7 +7,7 @@
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/merkle.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <streams.h>
 #include <txmempool.h>
 
diff -Nru bitcoinabc-0.21.11/src/test/blockfilter_index_tests.cpp bitcoinabc-0.21.12/src/test/blockfilter_index_tests.cpp
--- bitcoinabc-0.21.11/src/test/blockfilter_index_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/blockfilter_index_tests.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -8,7 +8,7 @@
 #include <consensus/validation.h>
 #include <index/blockfilterindex.h>
 #include <miner.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <script/standard.h>
 #include <test/util/blockfilter.h>
 #include <test/util/setup_common.h>
@@ -95,9 +95,8 @@
             CreateBlock(pindex, no_txns, coinbase_script_pub_key, mempool));
         CBlockHeader header = block->GetBlockHeader();
 
-        CValidationState state;
-        if (!ProcessNewBlockHeaders(GetConfig(), {header}, state, &pindex,
-                                    nullptr)) {
+        BlockValidationState state;
+        if (!ProcessNewBlockHeaders(GetConfig(), {header}, state, &pindex)) {
             return false;
         }
     }
diff -Nru bitcoinabc-0.21.11/src/test/bswap_tests.cpp bitcoinabc-0.21.12/src/test/bswap_tests.cpp
--- bitcoinabc-0.21.11/src/test/bswap_tests.cpp	2020-06-30 00:19:22.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/bswap_tests.cpp	2020-07-21 02:44:34.000000000 +0000
@@ -10,7 +10,7 @@
 
 BOOST_FIXTURE_TEST_SUITE(bswap_tests, BasicTestingSetup)
 
-BOOST_AUTO_TEST_CASE(bswap_tests) {
+BOOST_AUTO_TEST_CASE(basic_byteswaps) {
     // Sibling in bitcoin/src/qt/test/compattests.cpp
     uint16_t u1 = 0x1234;
     uint32_t u2 = 0x56789abc;
diff -Nru bitcoinabc-0.21.11/src/test/cashaddr_tests.cpp bitcoinabc-0.21.12/src/test/cashaddr_tests.cpp
--- bitcoinabc-0.21.11/src/test/cashaddr_tests.cpp	2020-06-30 00:19:22.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/cashaddr_tests.cpp	2020-07-20 15:59:43.000000000 +0000
@@ -6,6 +6,7 @@
 #include <cashaddr.h>
 
 #include <test/util/setup_common.h>
+#include <test/util/str.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -16,28 +17,6 @@
 
 BOOST_FIXTURE_TEST_SUITE(cashaddr_tests, BasicTestingSetup)
 
-bool CaseInsensitiveEqual(const std::string &s1, const std::string &s2) {
-    if (s1.size() != s2.size()) {
-        return false;
-    }
-
-    for (size_t i = 0; i < s1.size(); ++i) {
-        char c1 = s1[i];
-        if (c1 >= 'A' && c1 <= 'Z') {
-            c1 -= ('A' - 'a');
-        }
-        char c2 = s2[i];
-        if (c2 >= 'A' && c2 <= 'Z') {
-            c2 -= ('A' - 'a');
-        }
-        if (c1 != c2) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
 BOOST_AUTO_TEST_CASE(cashaddr_testvectors_valid) {
     static const std::string CASES[] = {
         "prefix:x64nx6hz",
diff -Nru bitcoinabc-0.21.11/src/test/checkpoints_tests.cpp bitcoinabc-0.21.12/src/test/checkpoints_tests.cpp
--- bitcoinabc-0.21.11/src/test/checkpoints_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/checkpoints_tests.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -81,8 +81,6 @@
  */
 BOOST_AUTO_TEST_CASE(ban_fork_prior_to_and_at_checkpoints) {
     MainnetConfigWithTestCheckpoints config;
-
-    CBlockHeader invalid;
     const CBlockIndex *pindex = nullptr;
 
     // Start with mainnet genesis block
@@ -92,9 +90,8 @@
                          "1b60a8ce26f"));
 
     {
-        CValidationState state;
-        BOOST_CHECK(ProcessNewBlockHeaders(config, {headerG}, state, &pindex,
-                                           &invalid));
+        BlockValidationState state;
+        BOOST_CHECK(ProcessNewBlockHeaders(config, {headerG}, state, &pindex));
         pindex = nullptr;
     }
 
@@ -157,35 +154,29 @@
 
     // Headers A and AA should be accepted
     {
-        CValidationState state;
-        BOOST_CHECK(ProcessNewBlockHeaders(config, {headerA}, state, &pindex,
-                                           &invalid));
+        BlockValidationState state;
+        BOOST_CHECK(ProcessNewBlockHeaders(config, {headerA}, state, &pindex));
         BOOST_CHECK(state.IsValid());
         BOOST_CHECK(pindex != nullptr);
         pindex = nullptr;
-        BOOST_CHECK(invalid.IsNull());
     }
 
     {
-        CValidationState state;
-        BOOST_CHECK(ProcessNewBlockHeaders(config, {headerAA}, state, &pindex,
-                                           &invalid));
+        BlockValidationState state;
+        BOOST_CHECK(ProcessNewBlockHeaders(config, {headerAA}, state, &pindex));
         BOOST_CHECK(state.IsValid());
         BOOST_CHECK(pindex != nullptr);
         pindex = nullptr;
-        BOOST_CHECK(invalid.IsNull());
     }
 
     // Header B should be rejected
     {
-        CValidationState state;
-        BOOST_CHECK(!ProcessNewBlockHeaders(config, {headerB}, state, &pindex,
-                                            &invalid));
+        BlockValidationState state;
+        BOOST_CHECK(!ProcessNewBlockHeaders(config, {headerB}, state, &pindex));
         BOOST_CHECK(state.IsInvalid());
         BOOST_CHECK(state.GetRejectCode() == REJECT_CHECKPOINT);
         BOOST_CHECK(state.GetRejectReason() == "bad-fork-prior-to-checkpoint");
         BOOST_CHECK(pindex == nullptr);
-        BOOST_CHECK(invalid.GetHash() == headerB.GetHash());
     }
 
     // Sanity check to ensure header was not saved in memory
@@ -196,14 +187,13 @@
 
     // Header AB should be rejected
     {
-        CValidationState state;
-        BOOST_CHECK(!ProcessNewBlockHeaders(config, {headerAB}, state, &pindex,
-                                            &invalid));
+        BlockValidationState state;
+        BOOST_CHECK(
+            !ProcessNewBlockHeaders(config, {headerAB}, state, &pindex));
         BOOST_CHECK(state.IsInvalid());
         BOOST_CHECK(state.GetRejectCode() == REJECT_CHECKPOINT);
         BOOST_CHECK(state.GetRejectReason() == "checkpoint mismatch");
         BOOST_CHECK(pindex == nullptr);
-        BOOST_CHECK(invalid.GetHash() == headerAB.GetHash());
     }
 
     // Sanity check to ensure header was not saved in memory
diff -Nru bitcoinabc-0.21.11/src/test/CMakeLists.txt bitcoinabc-0.21.12/src/test/CMakeLists.txt
--- bitcoinabc-0.21.11/src/test/CMakeLists.txt	2020-07-07 17:16:37.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/CMakeLists.txt	2020-07-28 23:45:00.000000000 +0000
@@ -50,6 +50,7 @@
 	util/blockfilter.cpp
 	util/logging.cpp
 	util/setup_common.cpp
+	util/str.cpp
 	util/transaction_utils.cpp
 )
 
@@ -84,8 +85,8 @@
 endif()
 
 add_boost_unit_tests_to_suite(bitcoin test_bitcoin
+	fixture.cpp
 	jsonutil.cpp
-	main.cpp
 	scriptflags.cpp
 	sigutil.cpp
 
@@ -156,7 +157,6 @@
 		op_reversebytes_tests.cpp
 		pmt_tests.cpp
 		policyestimator_tests.cpp
-		pow_tests.cpp
 		prevector_tests.cpp
 		radix_tests.cpp
 		raii_event_tests.cpp
diff -Nru bitcoinabc-0.21.11/src/test/fixture.cpp bitcoinabc-0.21.12/src/test/fixture.cpp
--- bitcoinabc-0.21.11/src/test/fixture.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fixture.cpp	2020-07-20 15:59:43.000000000 +0000
@@ -0,0 +1,46 @@
+// Copyright (c) 2011-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.
+
+#define BOOST_TEST_MODULE Bitcoin ABC unit tests
+
+#include <util/system.h>
+
+#include <boost/test/unit_test.hpp>
+
+namespace utf = boost::unit_test::framework;
+
+/**
+ * Global fixture for passing custom arguments, and clearing them all after each
+ * test case.
+ */
+struct CustomArgumentsFixture {
+    std::string error;
+
+    CustomArgumentsFixture() {
+        const std::string testsuitename = "-testsuitename";
+
+        const std::set<std::string> testArgs = {
+            testsuitename,
+            "-axionactivationtime",
+        };
+
+        for (const auto &arg : testArgs) {
+            gArgs.AddArg(arg, "", ArgsManager::ALLOW_ANY,
+                         OptionsCategory::HIDDEN);
+        }
+
+        auto &master_test_suite = utf::master_test_suite();
+        if (!gArgs.ParseParameters(master_test_suite.argc,
+                                   master_test_suite.argv, error)) {
+            throw utf::setup_error(error);
+        }
+
+        master_test_suite.p_name.value =
+            gArgs.GetArg(testsuitename, master_test_suite.p_name.value);
+    }
+
+    ~CustomArgumentsFixture(){};
+};
+
+BOOST_TEST_GLOBAL_FIXTURE(CustomArgumentsFixture);
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/cashaddr.cpp bitcoinabc-0.21.12/src/test/fuzz/cashaddr.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/cashaddr.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/cashaddr.cpp	2020-07-20 15:59:43.000000000 +0000
@@ -0,0 +1,52 @@
+// Copyright (c) 2019 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 <cashaddr.h>
+#include <test/fuzz/FuzzedDataProvider.h>
+#include <test/fuzz/fuzz.h>
+#include <test/util/str.h>
+#include <util/strencodings.h>
+
+#include <array>
+#include <cassert>
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <utility>
+#include <vector>
+
+void test_one_input(const std::vector<uint8_t> &buffer) {
+    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
+    const std::string random_string =
+        fuzzed_data_provider.ConsumeRandomLengthString(112);
+    const std::string random_prefix =
+        fuzzed_data_provider.ConsumeRemainingBytesAsString();
+    const std::pair<std::string, std::vector<uint8_t>> r1 =
+        cashaddr::Decode(random_prefix, random_string);
+    if (r1.first.empty()) {
+        assert(r1.second.empty());
+    } else {
+        const std::string &hrp = r1.first;
+        const std::vector<uint8_t> &data = r1.second;
+        const std::string reencoded = cashaddr::Encode(hrp, data);
+        assert(CaseInsensitiveEqual(random_string, reencoded));
+    }
+
+    std::vector<uint8_t> input;
+    ConvertBits<8, 5, true>([&](uint8_t c) { input.push_back(c); },
+                            buffer.begin(), buffer.end());
+    const std::string encoded = cashaddr::Encode(random_prefix, input);
+    assert(!encoded.empty());
+
+    const std::pair<std::string, std::vector<uint8_t>> r2 =
+        cashaddr::Decode(random_prefix, encoded);
+    if (r2.first.empty()) {
+        assert(r2.second.empty());
+    } else {
+        const std::string &hrp = r2.first;
+        const std::vector<uint8_t> &data = r2.second;
+        assert(hrp == random_prefix);
+        assert(data == input);
+    }
+}
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/CMakeLists.txt bitcoinabc-0.21.12/src/test/fuzz/CMakeLists.txt
--- bitcoinabc-0.21.11/src/test/fuzz/CMakeLists.txt	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/CMakeLists.txt	2020-07-20 15:59:43.000000000 +0000
@@ -45,16 +45,26 @@
 endfunction()
 
 add_regular_fuzz_targets(
+	cashaddr
+	descriptor_parse
 	eval_script
+	parse_iso8601
+	psbt
+	script
 	script_flags
+	spanparsing
 	transaction
 )
 
 add_deserialize_fuzz_targets(
+	addr_info_deserialize
 	address_deserialize
 	addrman_deserialize
 	banentry_deserialize
 	block_deserialize
+	block_file_info_deserialize
+	block_filter_deserialize
+	block_header_and_short_txids_deserialize
 	blockheader_deserialize
 	blocklocator_deserialize
 	blockmerkleroot
@@ -64,10 +74,24 @@
 	bloomfilter_deserialize
 	coins_deserialize
 	diskblockindex_deserialize
+	fee_rate_deserialize
+	flat_file_pos_deserialize
 	inv_deserialize
+	key_origin_info_deserialize
+	merkle_block_deserialize
 	messageheader_deserialize
 	netaddr_deserialize
+	out_point_deserialize
+	partial_merkle_tree_deserialize
+	partially_signed_transaction_deserialize
+	prefilled_transaction_deserialize
+	psbt_input_deserialize
+	psbt_output_deserialize
+	pub_key_deserialize
+	script_deserialize
 	service_deserialize
+	sub_net_deserialize
+	tx_in_deserialize
 	txoutcompressor_deserialize
 	txundo_deserialize
-)
\ No newline at end of file
+)
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/descriptor_parse.cpp bitcoinabc-0.21.12/src/test/fuzz/descriptor_parse.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/descriptor_parse.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/descriptor_parse.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -0,0 +1,24 @@
+// Copyright (c) 2009-2019 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 <chainparams.h>
+#include <pubkey.h>
+#include <script/descriptor.h>
+#include <test/fuzz/fuzz.h>
+
+#include <memory>
+
+void initialize() {
+    static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
+    SelectParams(CBaseChainParams::REGTEST);
+}
+
+void test_one_input(const std::vector<uint8_t> &buffer) {
+    const std::string descriptor(buffer.begin(), buffer.end());
+    FlatSigningProvider signing_provider;
+    std::string error;
+    for (const bool require_checksum : {true, false}) {
+        Parse(descriptor, signing_provider, error, require_checksum);
+    }
+}
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/deserialize.cpp bitcoinabc-0.21.12/src/test/fuzz/deserialize.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/deserialize.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/deserialize.cpp	2020-07-17 21:26:12.000000000 +0000
@@ -5,13 +5,20 @@
 #include <addrdb.h>
 #include <addrman.h>
 #include <blockencodings.h>
+#include <blockfileinfo.h>
+#include <blockfilter.h>
 #include <chain.h>
 #include <coins.h>
 #include <compressor.h>
 #include <consensus/merkle.h>
+#include <key.h>
+#include <merkleblock.h>
 #include <net.h>
 #include <primitives/block.h>
 #include <protocol.h>
+#include <psbt.h>
+#include <pubkey.h>
+#include <script/keyorigin.h>
 #include <streams.h>
 #include <undo.h>
 #include <version.h>
@@ -19,32 +26,144 @@
 #include <test/fuzz/fuzz.h>
 
 #include <cstdint>
+#include <stdexcept>
 #include <unistd.h>
 #include <vector>
 
+void initialize() {
+    // Fuzzers using pubkey must hold an ECCVerifyHandle.
+    static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
+}
+
 void test_one_input(const std::vector<uint8_t> &buffer) {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     try {
         int nVersion;
         ds >> nVersion;
         ds.SetVersion(nVersion);
-    } catch (const std::ios_base::failure &e) {
+    } catch (const std::ios_base::failure &) {
         return;
     }
 
-#if BLOCK_DESERIALIZE
+#if BLOCK_FILTER_DESERIALIZE
+    try {
+        BlockFilter block_filter;
+        ds >> block_filter;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif ADDR_INFO_DESERIALIZE
+    try {
+        CAddrInfo addr_info;
+        ds >> addr_info;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif BLOCK_FILE_INFO_DESERIALIZE
+    try {
+        CBlockFileInfo block_file_info;
+        ds >> block_file_info;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif BLOCK_HEADER_AND_SHORT_TXIDS_DESERIALIZE
+    try {
+        CBlockHeaderAndShortTxIDs block_header_and_short_txids;
+        ds >> block_header_and_short_txids;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif FEE_RATE_DESERIALIZE
+    try {
+        CFeeRate fee_rate;
+        ds >> fee_rate;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif MERKLE_BLOCK_DESERIALIZE
+    try {
+        CMerkleBlock merkle_block;
+        ds >> merkle_block;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif OUT_POINT_DESERIALIZE
+    try {
+        COutPoint out_point;
+        ds >> out_point;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif PARTIAL_MERKLE_TREE_DESERIALIZE
+    try {
+        CPartialMerkleTree partial_merkle_tree;
+        ds >> partial_merkle_tree;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif PUB_KEY_DESERIALIZE
+    try {
+        CPubKey pub_key;
+        ds >> pub_key;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif SCRIPT_DESERIALIZE
+    try {
+        CScript script;
+        ds >> script;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif SUB_NET_DESERIALIZE
+    try {
+        CSubNet sub_net;
+        ds >> sub_net;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif TX_IN_DESERIALIZE
+    try {
+        CTxIn tx_in;
+        ds >> tx_in;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif FLAT_FILE_POS_DESERIALIZE
+    try {
+        FlatFilePos flat_file_pos;
+        ds >> flat_file_pos;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif KEY_ORIGIN_INFO_DESERIALIZE
+    try {
+        KeyOriginInfo key_origin_info;
+        ds >> key_origin_info;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif PARTIALLY_SIGNED_TRANSACTION_DESERIALIZE
+    try {
+        PartiallySignedTransaction partially_signed_transaction;
+        ds >> partially_signed_transaction;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif PREFILLED_TRANSACTION_DESERIALIZE
+    try {
+        PrefilledTransaction prefilled_transaction;
+        ds >> prefilled_transaction;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif PSBT_INPUT_DESERIALIZE
+    try {
+        PSBTInput psbt_input;
+        ds >> psbt_input;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif PSBT_OUTPUT_DESERIALIZE
+    try {
+        PSBTOutput psbt_output;
+        ds >> psbt_output;
+    } catch (const std::ios_base::failure &) {
+    }
+#elif BLOCK_DESERIALIZE
     try {
         CBlock block;
         ds >> block;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif BLOCKLOCATOR_DESERIALIZE
     try {
         CBlockLocator bl;
         ds >> bl;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif BLOCKMERKLEROOT
     try {
@@ -52,125 +171,106 @@
         ds >> block;
         bool mutated;
         BlockMerkleRoot(block, &mutated);
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif ADDRMAN_DESERIALIZE
     try {
         CAddrMan am;
         ds >> am;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif BLOCKHEADER_DESERIALIZE
     try {
         CBlockHeader bh;
         ds >> bh;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif BANENTRY_DESERIALIZE
     try {
         CBanEntry be;
         ds >> be;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif TXUNDO_DESERIALIZE
     try {
         CTxUndo tu;
         ds >> tu;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif BLOCKUNDO_DESERIALIZE
     try {
         CBlockUndo bu;
         ds >> bu;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif COINS_DESERIALIZE
     try {
         Coin coin;
         ds >> coin;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif NETADDR_DESERIALIZE
     try {
         CNetAddr na;
         ds >> na;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif SERVICE_DESERIALIZE
     try {
         CService s;
         ds >> s;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif MESSAGEHEADER_DESERIALIZE
-    CMessageHeader::MessageMagic pchMessageStart = {{0x00, 0x00, 0x00, 0x00}};
+    CMessageHeader::MessageMagic pchMessageStart = {0x00, 0x00, 0x00, 0x00};
     try {
         CMessageHeader mh(pchMessageStart);
         ds >> mh;
-        if (!mh.IsValidWithoutConfig(pchMessageStart)) {
-            return;
-        }
-    } catch (const std::ios_base::failure &e) {
-        return;
+        (void)mh.IsValidWithoutConfig(pchMessageStart);
+    } catch (const std::ios_base::failure &) {
     }
 #elif ADDRESS_DESERIALIZE
     try {
         CAddress a;
         ds >> a;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif INV_DESERIALIZE
     try {
         CInv i;
         ds >> i;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif BLOOMFILTER_DESERIALIZE
     try {
         CBloomFilter bf;
         ds >> bf;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif DISKBLOCKINDEX_DESERIALIZE
     try {
         CDiskBlockIndex dbi;
         ds >> dbi;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif TXOUTCOMPRESSOR_DESERIALIZE
     CTxOut to;
     CTxOutCompressor toc(to);
     try {
         ds >> toc;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif BLOCKTRANSACTIONS_DESERIALIZE
     try {
         BlockTransactions bt;
         ds >> bt;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #elif BLOCKTRANSACTIONSREQUEST_DESERIALIZE
     try {
         BlockTransactionsRequest btr;
         ds >> btr;
-    } catch (const std::ios_base::failure &e) {
-        return;
+    } catch (const std::ios_base::failure &) {
     }
 #else
 #error Need at least one fuzz target to compile
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/eval_script.cpp bitcoinabc-0.21.12/src/test/fuzz/eval_script.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/eval_script.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/eval_script.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -2,11 +2,17 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <pubkey.h>
 #include <script/interpreter.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 
 #include <limits>
+#include <memory>
+
+void initialize() {
+    static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
+}
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/fuzz.cpp bitcoinabc-0.21.12/src/test/fuzz/fuzz.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/fuzz.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/fuzz.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -4,10 +4,9 @@
 
 #include <test/fuzz/fuzz.h>
 
-#include <pubkey.h>
-
-#include <memory>
+#include <cstdint>
 #include <unistd.h>
+#include <vector>
 
 static bool read_stdin(std::vector<uint8_t> &data) {
     uint8_t buffer[1024];
@@ -22,9 +21,8 @@
     return length == 0;
 }
 
-static void initialize() {
-    const static auto verify_handle = std::make_unique<ECCVerifyHandle>();
-}
+// Default initialization: Override using a non-weak initialize().
+__attribute__((weak)) void initialize() {}
 
 // This function is used by libFuzzer
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
@@ -39,13 +37,9 @@
     return 0;
 }
 
-// Disabled under WIN32 due to clash with Cygwin's WinMain.
-#ifndef WIN32
 // Declare main(...) "weak" to allow for libFuzzer linking. libFuzzer provides
 // the main(...) function.
-__attribute__((weak))
-#endif
-int main(int argc, char **argv) {
+__attribute__((weak)) int main(int argc, char **argv) {
     initialize();
 #ifdef __AFL_INIT
     // Enable AFL deferred forkserver mode. Requires compilation using
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/fuzz.h bitcoinabc-0.21.12/src/test/fuzz/fuzz.h
--- bitcoinabc-0.21.11/src/test/fuzz/fuzz.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/fuzz.h	2020-07-14 19:22:04.000000000 +0000
@@ -8,6 +8,7 @@
 #include <cstdint>
 #include <vector>
 
+void initialize();
 void test_one_input(const std::vector<uint8_t> &buffer);
 
 #endif // BITCOIN_TEST_FUZZ_FUZZ_H
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/parse_iso8601.cpp bitcoinabc-0.21.12/src/test/fuzz/parse_iso8601.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/parse_iso8601.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/parse_iso8601.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -0,0 +1,32 @@
+// Copyright (c) 2019 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 <test/fuzz/FuzzedDataProvider.h>
+#include <test/fuzz/fuzz.h>
+#include <util/time.h>
+
+#include <cassert>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+void test_one_input(const std::vector<uint8_t> &buffer) {
+    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
+
+    const int64_t random_time = fuzzed_data_provider.ConsumeIntegral<int64_t>();
+    const std::string random_string =
+        fuzzed_data_provider.ConsumeRemainingBytesAsString();
+
+    const std::string iso8601_datetime = FormatISO8601DateTime(random_time);
+    const int64_t parsed_time_1 = ParseISO8601DateTime(iso8601_datetime);
+    if (random_time >= 0) {
+        assert(parsed_time_1 >= 0);
+        if (iso8601_datetime.length() == 20) {
+            assert(parsed_time_1 == random_time);
+        }
+    }
+
+    const int64_t parsed_time_2 = ParseISO8601DateTime(random_string);
+    assert(parsed_time_2 >= 0);
+}
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/psbt.cpp bitcoinabc-0.21.12/src/test/fuzz/psbt.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/psbt.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/psbt.cpp	2020-07-16 17:03:33.000000000 +0000
@@ -0,0 +1,77 @@
+// Copyright (c) 2019 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 <test/fuzz/fuzz.h>
+
+#include <node/psbt.h>
+#include <optional.h>
+#include <psbt.h>
+#include <pubkey.h>
+#include <script/script.h>
+#include <streams.h>
+#include <version.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+void initialize() {
+    static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
+}
+
+void test_one_input(const std::vector<uint8_t> &buffer) {
+    PartiallySignedTransaction psbt_mut;
+    const std::string raw_psbt{buffer.begin(), buffer.end()};
+    std::string error;
+    if (!DecodeRawPSBT(psbt_mut, raw_psbt, error)) {
+        return;
+    }
+    const PartiallySignedTransaction psbt = psbt_mut;
+
+    const PSBTAnalysis analysis = AnalyzePSBT(psbt);
+    (void)PSBTRoleName(analysis.next);
+    for (const PSBTInputAnalysis &input_analysis : analysis.inputs) {
+        (void)PSBTRoleName(input_analysis.next);
+    }
+
+    (void)psbt.IsNull();
+    (void)psbt.IsSane();
+
+    Optional<CMutableTransaction> tx = psbt.tx;
+    if (tx) {
+        const CMutableTransaction &mtx = *tx;
+        const PartiallySignedTransaction psbt_from_tx{mtx};
+    }
+
+    for (const PSBTInput &input : psbt.inputs) {
+        (void)PSBTInputSigned(input);
+        (void)input.IsNull();
+        (void)input.IsSane();
+    }
+
+    for (const PSBTOutput &output : psbt.outputs) {
+        (void)output.IsNull();
+    }
+
+    for (size_t i = 0; i < psbt.tx->vin.size(); ++i) {
+        CTxOut tx_out;
+        if (psbt.GetInputUTXO(tx_out, i)) {
+            (void)tx_out.IsNull();
+            (void)tx_out.ToString();
+        }
+    }
+
+    psbt_mut = psbt;
+    (void)FinalizePSBT(psbt_mut);
+
+    psbt_mut = psbt;
+    CMutableTransaction result;
+    if (FinalizeAndExtractPSBT(psbt_mut, result)) {
+        const PartiallySignedTransaction psbt_from_tx{result};
+    }
+
+    psbt_mut = psbt;
+    (void)psbt_mut.Merge(psbt);
+}
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/script.cpp bitcoinabc-0.21.12/src/test/fuzz/script.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/script.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/script.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -0,0 +1,59 @@
+// Copyright (c) 2019 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 <chainparams.h>
+#include <compressor.h>
+#include <core_io.h>
+#include <core_memusage.h>
+#include <policy/policy.h>
+#include <pubkey.h>
+#include <script/descriptor.h>
+#include <script/script.h>
+#include <script/sign.h>
+#include <script/signingprovider.h>
+#include <script/standard.h>
+#include <streams.h>
+#include <test/fuzz/fuzz.h>
+
+#include <memory>
+
+void initialize() {
+    // Fuzzers using pubkey must hold an ECCVerifyHandle.
+    static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
+}
+
+void test_one_input(const std::vector<uint8_t> &buffer) {
+    const CScript script(buffer.begin(), buffer.end());
+
+    std::vector<uint8_t> compressed;
+    (void)CompressScript(script, compressed);
+
+    CTxDestination address;
+    (void)ExtractDestination(script, address);
+
+    txnouttype type_ret;
+    std::vector<CTxDestination> addresses;
+    int required_ret;
+    (void)ExtractDestinations(script, type_ret, addresses, required_ret);
+
+    const FlatSigningProvider signing_provider;
+    (void)InferDescriptor(script, signing_provider);
+
+    (void)script.IsWitnessProgram();
+
+    (void)IsSolvable(signing_provider, script);
+
+    txnouttype which_type;
+    (void)IsStandard(script, which_type);
+
+    (void)RecursiveDynamicUsage(script);
+
+    std::vector<std::vector<uint8_t>> solutions;
+    (void)Solver(script, solutions);
+
+    (void)script.HasValidOps();
+    (void)script.IsPayToScriptHash();
+    (void)script.IsPushOnly();
+    (void)script.IsUnspendable();
+}
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/script_flags.cpp bitcoinabc-0.21.12/src/test/fuzz/script_flags.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/script_flags.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/script_flags.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -2,15 +2,22 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <pubkey.h>
 #include <script/interpreter.h>
 #include <streams.h>
 #include <version.h>
 
 #include <test/fuzz/fuzz.h>
 
+#include <memory>
+
 /** Flags that are not forbidden by an assert */
 static bool IsValidFlagCombination(uint32_t flags);
 
+void initialize() {
+    static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
+}
+
 void test_one_input(const std::vector<uint8_t> &buffer) {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     try {
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/spanparsing.cpp bitcoinabc-0.21.12/src/test/fuzz/spanparsing.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/spanparsing.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/spanparsing.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -0,0 +1,31 @@
+// Copyright (c) 2019 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 <test/fuzz/FuzzedDataProvider.h>
+#include <test/fuzz/fuzz.h>
+#include <util/spanparsing.h>
+
+void test_one_input(const std::vector<uint8_t> &buffer) {
+    FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
+    const size_t query_size = fuzzed_data_provider.ConsumeIntegral<size_t>();
+    const std::string query = fuzzed_data_provider.ConsumeBytesAsString(
+        std::min<size_t>(query_size, 1024 * 1024));
+    const std::string span_str =
+        fuzzed_data_provider.ConsumeRemainingBytesAsString();
+    const Span<const char> const_span = MakeSpan(span_str);
+
+    Span<const char> mut_span = const_span;
+    (void)spanparsing::Const(query, mut_span);
+
+    mut_span = const_span;
+    (void)spanparsing::Func(query, mut_span);
+
+    mut_span = const_span;
+    (void)spanparsing::Expr(mut_span);
+
+    if (!query.empty()) {
+        mut_span = const_span;
+        (void)spanparsing::Split(mut_span, query.front());
+    }
+}
diff -Nru bitcoinabc-0.21.11/src/test/fuzz/transaction.cpp bitcoinabc-0.21.12/src/test/fuzz/transaction.cpp
--- bitcoinabc-0.21.11/src/test/fuzz/transaction.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/fuzz/transaction.cpp	2020-07-17 21:26:12.000000000 +0000
@@ -25,23 +25,35 @@
         int nVersion;
         ds >> nVersion;
         ds.SetVersion(nVersion);
-    } catch (const std::ios_base::failure &e) {
+    } catch (const std::ios_base::failure &) {
         return;
     }
-    bool valid = true;
+    bool valid_tx = true;
     const CTransaction tx = [&] {
         try {
             return CTransaction(deserialize, ds);
-        } catch (const std::ios_base::failure &e) {
-            valid = false;
+        } catch (const std::ios_base::failure &) {
+            valid_tx = false;
             return CTransaction();
         }
     }();
-    if (!valid) {
+    bool valid_mutable_tx = true;
+    CDataStream ds_mtx(buffer, SER_NETWORK, INIT_PROTO_VERSION);
+    CMutableTransaction mutable_tx;
+    try {
+        int nVersion;
+        ds_mtx >> nVersion;
+        ds_mtx.SetVersion(nVersion);
+        ds_mtx >> mutable_tx;
+    } catch (const std::ios_base::failure &) {
+        valid_mutable_tx = false;
+    }
+    assert(valid_tx == valid_mutable_tx);
+    if (!valid_tx) {
         return;
     }
 
-    CValidationState state;
+    TxValidationState state;
     (void)CheckRegularTransaction(tx, state);
 
     const CFeeRate dust_relay_fee{DUST_RELAY_TX_FEE};
diff -Nru bitcoinabc-0.21.11/src/test/main.cpp bitcoinabc-0.21.12/src/test/main.cpp
--- bitcoinabc-0.21.11/src/test/main.cpp	2020-07-07 17:16:37.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/main.cpp	1970-01-01 00:00:00.000000000 +0000
@@ -1,46 +0,0 @@
-// Copyright (c) 2011-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.
-
-#define BOOST_TEST_MODULE Bitcoin ABC unit tests
-
-#include <util/system.h>
-
-#include <boost/test/unit_test.hpp>
-
-namespace utf = boost::unit_test::framework;
-
-/*
- * Global fixture for passing custom arguments, and clearing them all after each
- * test case.
- */
-struct CustomArgumentsFixture {
-    std::string error;
-
-    CustomArgumentsFixture() {
-        const std::string testsuitename = "-testsuitename";
-
-        const std::set<std::string> testArgs = {
-            testsuitename,
-            "-axionactivationtime",
-        };
-
-        for (const auto &arg : testArgs) {
-            gArgs.AddArg(arg, "", ArgsManager::ALLOW_ANY,
-                         OptionsCategory::HIDDEN);
-        }
-
-        auto &master_test_suite = utf::master_test_suite();
-        if (!gArgs.ParseParameters(master_test_suite.argc,
-                                   master_test_suite.argv, error)) {
-            throw utf::setup_error(error);
-        }
-
-        master_test_suite.p_name.value =
-            gArgs.GetArg(testsuitename, master_test_suite.p_name.value);
-    }
-
-    ~CustomArgumentsFixture(){};
-};
-
-BOOST_GLOBAL_FIXTURE(CustomArgumentsFixture);
diff -Nru bitcoinabc-0.21.11/src/test/miner_tests.cpp bitcoinabc-0.21.12/src/test/miner_tests.cpp
--- bitcoinabc-0.21.11/src/test/miner_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/miner_tests.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -520,7 +520,7 @@
 
     {
         // Locktime passes.
-        CValidationState state;
+        TxValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
     }
@@ -546,7 +546,7 @@
 
     {
         // Locktime passes.
-        CValidationState state;
+        TxValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
     }
@@ -583,7 +583,7 @@
 
     {
         // Locktime fails.
-        CValidationState state;
+        TxValidationState state;
         BOOST_CHECK(!ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-nonfinal");
@@ -594,7 +594,7 @@
 
     {
         // Locktime passes on 2nd block.
-        CValidationState state;
+        TxValidationState state;
         int64_t nMedianTimePast = ::ChainActive().Tip()->GetMedianTimePast();
         BOOST_CHECK(ContextualCheckTransaction(
             params, CTransaction(tx), state, ::ChainActive().Tip()->nHeight + 2,
@@ -611,7 +611,7 @@
 
     {
         // Locktime fails.
-        CValidationState state;
+        TxValidationState state;
         BOOST_CHECK(!ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-nonfinal");
@@ -622,7 +622,7 @@
 
     {
         // Locktime passes 1 second later.
-        CValidationState state;
+        TxValidationState state;
         int64_t nMedianTimePast =
             ::ChainActive().Tip()->GetMedianTimePast() + 1;
         BOOST_CHECK(ContextualCheckTransaction(
@@ -638,7 +638,7 @@
 
     {
         // Locktime passes.
-        CValidationState state;
+        TxValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
             params, CTransaction(tx), state, flags));
     }
diff -Nru bitcoinabc-0.21.11/src/test/pow_tests.cpp bitcoinabc-0.21.12/src/test/pow_tests.cpp
--- bitcoinabc-0.21.11/src/test/pow_tests.cpp	2020-06-30 00:19:22.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/pow_tests.cpp	1970-01-01 00:00:00.000000000 +0000
@@ -1,373 +0,0 @@
-// Copyright (c) 2015-2019 The Bitcoin Core developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <pow.h>
-
-#include <chain.h>
-#include <chainparams.h>
-#include <config.h>
-
-#include <test/util/setup_common.h>
-
-#include <boost/test/unit_test.hpp>
-
-BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
-
-/* Test calculation of next difficulty target with no constraints applying */
-BOOST_AUTO_TEST_CASE(get_next_work) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    int64_t nLastRetargetTime = 1261130161; // Block #30240
-    CBlockIndex pindexLast;
-    pindexLast.nHeight = 32255;
-    pindexLast.nTime = 1262152739; // Block #32255
-    pindexLast.nBits = 0x1d00ffff;
-    BOOST_CHECK_EQUAL(
-        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
-                                  config.GetChainParams().GetConsensus()),
-        0x1d00d86aU);
-}
-
-/* Test the constraint on the upper bound for next work */
-BOOST_AUTO_TEST_CASE(get_next_work_pow_limit) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    int64_t nLastRetargetTime = 1231006505; // Block #0
-    CBlockIndex pindexLast;
-    pindexLast.nHeight = 2015;
-    pindexLast.nTime = 1233061996; // Block #2015
-    pindexLast.nBits = 0x1d00ffff;
-    BOOST_CHECK_EQUAL(
-        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
-                                  config.GetChainParams().GetConsensus()),
-        0x1d00ffffU);
-}
-
-/* Test the constraint on the lower bound for actual time taken */
-BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    int64_t nLastRetargetTime = 1279008237; // Block #66528
-    CBlockIndex pindexLast;
-    pindexLast.nHeight = 68543;
-    pindexLast.nTime = 1279297671; // Block #68543
-    pindexLast.nBits = 0x1c05a3f4;
-    BOOST_CHECK_EQUAL(
-        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
-                                  config.GetChainParams().GetConsensus()),
-        0x1c0168fdU);
-}
-
-/* Test the constraint on the upper bound for actual time taken */
-BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    int64_t nLastRetargetTime = 1263163443; // NOTE: Not an actual block time
-    CBlockIndex pindexLast;
-    pindexLast.nHeight = 46367;
-    pindexLast.nTime = 1269211443; // Block #46367
-    pindexLast.nBits = 0x1c387f6f;
-    BOOST_CHECK_EQUAL(
-        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
-                                  config.GetChainParams().GetConsensus()),
-        0x1d00e1fdU);
-}
-
-BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    std::vector<CBlockIndex> blocks(10000);
-    for (int i = 0; i < 10000; i++) {
-        blocks[i].pprev = i ? &blocks[i - 1] : nullptr;
-        blocks[i].nHeight = i;
-        blocks[i].nTime =
-            1269211443 +
-            i * config.GetChainParams().GetConsensus().nPowTargetSpacing;
-        blocks[i].nBits = 0x207fffff; /* target 0x7fffff000... */
-        blocks[i].nChainWork =
-            i ? blocks[i - 1].nChainWork + GetBlockProof(blocks[i])
-              : arith_uint256(0);
-    }
-
-    for (int j = 0; j < 1000; j++) {
-        CBlockIndex *p1 = &blocks[InsecureRandRange(10000)];
-        CBlockIndex *p2 = &blocks[InsecureRandRange(10000)];
-        CBlockIndex *p3 = &blocks[InsecureRandRange(10000)];
-
-        int64_t tdiff = GetBlockProofEquivalentTime(
-            *p1, *p2, *p3, config.GetChainParams().GetConsensus());
-        BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime());
-    }
-}
-
-static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval,
-                                 uint32_t nBits) {
-    CBlockIndex block;
-    block.pprev = pindexPrev;
-    block.nHeight = pindexPrev->nHeight + 1;
-    block.nTime = pindexPrev->nTime + nTimeInterval;
-    block.nBits = nBits;
-
-    block.nChainWork = pindexPrev->nChainWork + GetBlockProof(block);
-    return block;
-}
-
-BOOST_AUTO_TEST_CASE(retargeting_test) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    std::vector<CBlockIndex> blocks(115);
-
-    const Consensus::Params &params = config.GetChainParams().GetConsensus();
-    const arith_uint256 powLimit = UintToArith256(params.powLimit);
-    arith_uint256 currentPow = powLimit >> 1;
-    uint32_t initialBits = currentPow.GetCompact();
-
-    // Genesis block.
-    blocks[0] = CBlockIndex();
-    blocks[0].nHeight = 0;
-    blocks[0].nTime = 1269211443;
-    blocks[0].nBits = initialBits;
-
-    blocks[0].nChainWork = GetBlockProof(blocks[0]);
-
-    // Pile up some blocks.
-    for (size_t i = 1; i < 100; i++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], params.nPowTargetSpacing,
-                                  initialBits);
-    }
-
-    CBlockHeader blkHeaderDummy;
-
-    // We start getting 2h blocks time. For the first 5 blocks, it doesn't
-    // matter as the MTP is not affected. For the next 5 block, MTP difference
-    // increases but stays below 12h.
-    for (size_t i = 100; i < 110; i++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 2 * 3600, initialBits);
-        BOOST_CHECK_EQUAL(
-            GetNextWorkRequired(&blocks[i], &blkHeaderDummy, params),
-            initialBits);
-    }
-
-    // Now we expect the difficulty to decrease.
-    blocks[110] = GetBlockIndex(&blocks[109], 2 * 3600, initialBits);
-    currentPow.SetCompact(currentPow.GetCompact());
-    currentPow += (currentPow >> 2);
-    BOOST_CHECK_EQUAL(
-        GetNextWorkRequired(&blocks[110], &blkHeaderDummy, params),
-        currentPow.GetCompact());
-
-    // As we continue with 2h blocks, difficulty continue to decrease.
-    blocks[111] =
-        GetBlockIndex(&blocks[110], 2 * 3600, currentPow.GetCompact());
-    currentPow.SetCompact(currentPow.GetCompact());
-    currentPow += (currentPow >> 2);
-    BOOST_CHECK_EQUAL(
-        GetNextWorkRequired(&blocks[111], &blkHeaderDummy, params),
-        currentPow.GetCompact());
-
-    // We decrease again.
-    blocks[112] =
-        GetBlockIndex(&blocks[111], 2 * 3600, currentPow.GetCompact());
-    currentPow.SetCompact(currentPow.GetCompact());
-    currentPow += (currentPow >> 2);
-    BOOST_CHECK_EQUAL(
-        GetNextWorkRequired(&blocks[112], &blkHeaderDummy, params),
-        currentPow.GetCompact());
-
-    // We check that we do not go below the minimal difficulty.
-    blocks[113] =
-        GetBlockIndex(&blocks[112], 2 * 3600, currentPow.GetCompact());
-    currentPow.SetCompact(currentPow.GetCompact());
-    currentPow += (currentPow >> 2);
-    BOOST_CHECK(powLimit.GetCompact() != currentPow.GetCompact());
-    BOOST_CHECK_EQUAL(
-        GetNextWorkRequired(&blocks[113], &blkHeaderDummy, params),
-        powLimit.GetCompact());
-
-    // Once we reached the minimal difficulty, we stick with it.
-    blocks[114] = GetBlockIndex(&blocks[113], 2 * 3600, powLimit.GetCompact());
-    BOOST_CHECK(powLimit.GetCompact() != currentPow.GetCompact());
-    BOOST_CHECK_EQUAL(
-        GetNextWorkRequired(&blocks[114], &blkHeaderDummy, params),
-        powLimit.GetCompact());
-}
-
-BOOST_AUTO_TEST_CASE(cash_difficulty_test) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    std::vector<CBlockIndex> blocks(3000);
-
-    const Consensus::Params &params = config.GetChainParams().GetConsensus();
-    const arith_uint256 powLimit = UintToArith256(params.powLimit);
-    uint32_t powLimitBits = powLimit.GetCompact();
-    arith_uint256 currentPow = powLimit >> 4;
-    uint32_t initialBits = currentPow.GetCompact();
-
-    // Genesis block.
-    blocks[0] = CBlockIndex();
-    blocks[0].nHeight = 0;
-    blocks[0].nTime = 1269211443;
-    blocks[0].nBits = initialBits;
-
-    blocks[0].nChainWork = GetBlockProof(blocks[0]);
-
-    // Block counter.
-    size_t i;
-
-    // Pile up some blocks every 10 mins to establish some history.
-    for (i = 1; i < 2050; i++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, initialBits);
-    }
-
-    CBlockHeader blkHeaderDummy;
-    uint32_t nBits =
-        GetNextCashWorkRequired(&blocks[2049], &blkHeaderDummy, params);
-
-    // Difficulty stays the same as long as we produce a block every 10 mins.
-    for (size_t j = 0; j < 10; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, nBits);
-        BOOST_CHECK_EQUAL(
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params),
-            nBits);
-    }
-
-    // Make sure we skip over blocks that are out of wack. To do so, we produce
-    // a block that is far in the future, and then produce a block with the
-    // expected timestamp.
-    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-    BOOST_CHECK_EQUAL(
-        GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
-    blocks[i] = GetBlockIndex(&blocks[i - 1], 2 * 600 - 6000, nBits);
-    BOOST_CHECK_EQUAL(
-        GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
-
-    // The system should continue unaffected by the block with a bogous
-    // timestamps.
-    for (size_t j = 0; j < 20; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, nBits);
-        BOOST_CHECK_EQUAL(
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params),
-            nBits);
-    }
-
-    // We start emitting blocks slightly faster. The first block has no impact.
-    blocks[i] = GetBlockIndex(&blocks[i - 1], 550, nBits);
-    BOOST_CHECK_EQUAL(
-        GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
-
-    // Now we should see difficulty increase slowly.
-    for (size_t j = 0; j < 10; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 550, nBits);
-        const uint32_t nextBits =
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
-
-        arith_uint256 currentTarget;
-        currentTarget.SetCompact(nBits);
-        arith_uint256 nextTarget;
-        nextTarget.SetCompact(nextBits);
-
-        // Make sure that difficulty increases very slowly.
-        BOOST_CHECK(nextTarget < currentTarget);
-        BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 10));
-
-        nBits = nextBits;
-    }
-
-    // Check the actual value.
-    BOOST_CHECK_EQUAL(nBits, 0x1c0fe7b1);
-
-    // If we dramatically shorten block production, difficulty increases faster.
-    for (size_t j = 0; j < 20; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 10, nBits);
-        const uint32_t nextBits =
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
-
-        arith_uint256 currentTarget;
-        currentTarget.SetCompact(nBits);
-        arith_uint256 nextTarget;
-        nextTarget.SetCompact(nextBits);
-
-        // Make sure that difficulty increases faster.
-        BOOST_CHECK(nextTarget < currentTarget);
-        BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 4));
-
-        nBits = nextBits;
-    }
-
-    // Check the actual value.
-    BOOST_CHECK_EQUAL(nBits, 0x1c0db19f);
-
-    // We start to emit blocks significantly slower. The first block has no
-    // impact.
-    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-    nBits = GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params);
-
-    // Check the actual value.
-    BOOST_CHECK_EQUAL(nBits, 0x1c0d9222);
-
-    // If we dramatically slow down block production, difficulty decreases.
-    for (size_t j = 0; j < 93; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-        const uint32_t nextBits =
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
-
-        arith_uint256 currentTarget;
-        currentTarget.SetCompact(nBits);
-        arith_uint256 nextTarget;
-        nextTarget.SetCompact(nextBits);
-
-        // Check the difficulty decreases.
-        BOOST_CHECK(nextTarget <= powLimit);
-        BOOST_CHECK(nextTarget > currentTarget);
-        BOOST_CHECK((nextTarget - currentTarget) < (currentTarget >> 3));
-
-        nBits = nextBits;
-    }
-
-    // Check the actual value.
-    BOOST_CHECK_EQUAL(nBits, 0x1c2f13b9);
-
-    // Due to the window of time being bounded, next block's difficulty actually
-    // gets harder.
-    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-    nBits = GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params);
-    BOOST_CHECK_EQUAL(nBits, 0x1c2ee9bf);
-
-    // And goes down again. It takes a while due to the window being bounded and
-    // the skewed block causes 2 blocks to get out of the window.
-    for (size_t j = 0; j < 192; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-        const uint32_t nextBits =
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
-
-        arith_uint256 currentTarget;
-        currentTarget.SetCompact(nBits);
-        arith_uint256 nextTarget;
-        nextTarget.SetCompact(nextBits);
-
-        // Check the difficulty decreases.
-        BOOST_CHECK(nextTarget <= powLimit);
-        BOOST_CHECK(nextTarget > currentTarget);
-        BOOST_CHECK((nextTarget - currentTarget) < (currentTarget >> 3));
-
-        nBits = nextBits;
-    }
-
-    // Check the actual value.
-    BOOST_CHECK_EQUAL(nBits, 0x1d00ffff);
-
-    // Once the difficulty reached the minimum allowed level, it doesn't get any
-    // easier.
-    for (size_t j = 0; j < 5; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-        const uint32_t nextBits =
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
-
-        // Check the difficulty stays constant.
-        BOOST_CHECK_EQUAL(nextBits, powLimitBits);
-        nBits = nextBits;
-    }
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff -Nru bitcoinabc-0.21.11/src/test/script_p2sh_tests.cpp bitcoinabc-0.21.12/src/test/script_p2sh_tests.cpp
--- bitcoinabc-0.21.11/src/test/script_p2sh_tests.cpp	2020-06-30 00:19:22.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/script_p2sh_tests.cpp	2020-07-15 16:44:37.000000000 +0000
@@ -115,12 +115,12 @@
         for (int j = 0; j < 8; j++) {
             CScript sigSave = txTo[i].vin[0].scriptSig;
             txTo[i].vin[0].scriptSig = txTo[j].vin[0].scriptSig;
-            const CTxOut &output = txFrom.vout[txTo[i].vin[0].prevout.GetN()];
-            bool sigOK = CScriptCheck(
-                output.scriptPubKey, output.nValue, CTransaction(txTo[i]), 0,
-                SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC |
-                    SCRIPT_ENABLE_SIGHASH_FORKID,
-                false, txdata)();
+            bool sigOK =
+                CScriptCheck(txFrom.vout[txTo[i].vin[0].prevout.GetN()],
+                             CTransaction(txTo[i]), 0,
+                             SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC |
+                                 SCRIPT_ENABLE_SIGHASH_FORKID,
+                             false, txdata)();
             if (i == j) {
                 BOOST_CHECK_MESSAGE(sigOK,
                                     strprintf("VerifySignature %d %d", i, j));
diff -Nru bitcoinabc-0.21.11/src/test/sighash_tests.cpp bitcoinabc-0.21.12/src/test/sighash_tests.cpp
--- bitcoinabc-0.21.11/src/test/sighash_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/sighash_tests.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -252,7 +252,7 @@
             CDataStream stream(ParseHex(raw_tx), SER_NETWORK, PROTOCOL_VERSION);
             stream >> tx;
 
-            CValidationState state;
+            TxValidationState state;
             BOOST_CHECK_MESSAGE(CheckRegularTransaction(*tx, state), strTest);
             BOOST_CHECK(state.IsValid());
 
diff -Nru bitcoinabc-0.21.11/src/test/transaction_tests.cpp bitcoinabc-0.21.12/src/test/transaction_tests.cpp
--- bitcoinabc-0.21.11/src/test/transaction_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/transaction_tests.cpp	2020-07-15 16:44:37.000000000 +0000
@@ -104,7 +104,7 @@
                                PROTOCOL_VERSION);
             CTransaction tx(deserialize, stream);
 
-            CValidationState state;
+            TxValidationState state;
             BOOST_CHECK_MESSAGE(tx.IsCoinBase()
                                     ? CheckCoinbase(tx, state)
                                     : CheckRegularTransaction(tx, state),
@@ -206,7 +206,7 @@
                                PROTOCOL_VERSION);
             CTransaction tx(deserialize, stream);
 
-            CValidationState state;
+            TxValidationState state;
             fValid = CheckRegularTransaction(tx, state) && state.IsValid();
 
             PrecomputedTransactionData txdata(tx);
@@ -263,7 +263,7 @@
     CDataStream stream(vch, SER_DISK, CLIENT_VERSION);
     CMutableTransaction tx;
     stream >> tx;
-    CValidationState state;
+    TxValidationState state;
     BOOST_CHECK_MESSAGE(CheckRegularTransaction(CTransaction(tx), state) &&
                             state.IsValid(),
                         "Simple deserialized transaction should be valid.");
@@ -488,8 +488,7 @@
 
     for (size_t i = 0; i < mtx.vin.size(); i++) {
         std::vector<CScriptCheck> vChecks;
-        CTxOut &out = coins[tx.vin[i].prevout.GetN()].GetTxOut();
-        CScriptCheck check(out.scriptPubKey, out.nValue, tx, i,
+        CScriptCheck check(coins[tx.vin[i].prevout.GetN()].GetTxOut(), tx, i,
                            STANDARD_SCRIPT_VERIFY_FLAGS, false, txdata);
         vChecks.push_back(CScriptCheck());
         check.swap(vChecks.back());
@@ -796,7 +795,7 @@
 
     // A minimaly sized transction.
     CTransaction minTx;
-    CValidationState state;
+    TxValidationState state;
 
     BOOST_CHECK(ContextualCheckTransaction(
         params, minTx, state, magneticAnomalyActivationHeight - 1, 5678, 1234));
diff -Nru bitcoinabc-0.21.11/src/test/txvalidationcache_tests.cpp bitcoinabc-0.21.12/src/test/txvalidationcache_tests.cpp
--- bitcoinabc-0.21.11/src/test/txvalidationcache_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/txvalidationcache_tests.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -32,11 +32,10 @@
     const auto ToMemPool = [this](const CMutableTransaction &tx) {
         LOCK(cs_main);
 
-        CValidationState state;
+        TxValidationState state;
         return AcceptToMemoryPool(
             GetConfig(), *m_node.mempool, state, MakeTransactionRef(tx),
-            nullptr /* pfMissingInputs */, true /* bypass_limits */,
-            Amount::zero() /* nAbsurdFee */);
+            true /* bypass_limits */, Amount::zero() /* nAbsurdFee */);
     };
 
     // Create a double-spend of mature coinbase txn:
@@ -102,7 +101,7 @@
 }
 
 static inline bool
-CheckInputs(const CTransaction &tx, CValidationState &state,
+CheckInputs(const CTransaction &tx, TxValidationState &state,
             const CCoinsViewCache &view, bool fScriptChecks,
             const uint32_t flags, bool sigCacheStore, bool scriptCacheStore,
             const PrecomputedTransactionData &txdata, int &nSigChecksOut,
@@ -139,7 +138,7 @@
     MMIXLinearCongruentialGenerator lcg;
     for (int i = 0; i < 4096; i++) {
         uint32_t test_flags = lcg.next() | required_flags;
-        CValidationState state;
+        TxValidationState state;
 
         // Filter out incompatible flag choices
         if ((test_flags & SCRIPT_VERIFY_CLEANSTACK)) {
@@ -273,7 +272,7 @@
 
         LOCK(cs_main);
 
-        CValidationState state;
+        TxValidationState state;
         PrecomputedTransactionData ptd_spend_tx(tx);
         int nSigChecksDummy;
 
@@ -353,7 +352,7 @@
 
         // Make it valid, and check again
         invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
-        CValidationState state;
+        TxValidationState state;
 
         CTransaction transaction(invalid_with_cltv_tx);
         PrecomputedTransactionData txdata(transaction);
@@ -392,7 +391,7 @@
 
         // Make it valid, and check again
         invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
-        CValidationState state;
+        TxValidationState state;
 
         CTransaction transaction(invalid_with_csv_tx);
         PrecomputedTransactionData txdata(transaction);
@@ -448,7 +447,7 @@
             // Try checking this valid transaction with sigchecks limiter
             // supplied. Each input consumes 1 sigcheck.
 
-            CValidationState state;
+            TxValidationState state;
             CTransaction transaction(tx);
             PrecomputedTransactionData txdata(transaction);
             const uint32_t flags =
@@ -475,7 +474,7 @@
 
             // Serial validation fails with the limiter.
             CheckInputsLimiter sigchecklimiter2(1);
-            CValidationState state2;
+            TxValidationState state2;
             BOOST_CHECK(!CheckInputs(transaction, state2, pcoinsTip.get(), true,
                                      flags, true, true, txdata, nSigChecksDummy,
                                      nullptr, &sigchecklimiter2));
@@ -517,24 +516,24 @@
              * caching.
              */
             CheckInputsLimiter sigchecklimiter6(1);
-            CValidationState state6;
+            TxValidationState state6;
             BOOST_CHECK(!CheckInputs(transaction, state6, pcoinsTip.get(), true,
                                      flags, true, true, txdata, nSigChecksDummy,
                                      nullptr, &sigchecklimiter6));
             BOOST_CHECK_EQUAL(state6.GetRejectReason(), "too-many-sigchecks");
-            BOOST_CHECK_EQUAL(state6.GetReason(),
-                              ValidationInvalidReason::CONSENSUS);
+            BOOST_CHECK_EQUAL(state6.GetResult(),
+                              TxValidationResult::TX_CONSENSUS);
             BOOST_CHECK(!sigchecklimiter6.check());
             // even in parallel validation, immediate fail from the cache.
             std::vector<CScriptCheck> scriptchecks7;
             CheckInputsLimiter sigchecklimiter7(1);
-            CValidationState state7;
+            TxValidationState state7;
             BOOST_CHECK(!CheckInputs(transaction, state7, pcoinsTip.get(), true,
                                      flags, true, true, txdata, nSigChecksDummy,
                                      &scriptchecks7, &sigchecklimiter7));
             BOOST_CHECK_EQUAL(state7.GetRejectReason(), "too-many-sigchecks");
-            BOOST_CHECK_EQUAL(state6.GetReason(),
-                              ValidationInvalidReason::CONSENSUS);
+            BOOST_CHECK_EQUAL(state6.GetResult(),
+                              TxValidationResult::TX_CONSENSUS);
             BOOST_CHECK(!sigchecklimiter7.check());
             BOOST_CHECK(scriptchecks7.empty());
         }
@@ -544,7 +543,7 @@
         // Invalidate vin[1]
         tx.vin[1].scriptSig = CScript();
 
-        CValidationState state;
+        TxValidationState state;
         CTransaction transaction(tx);
         PrecomputedTransactionData txdata(transaction);
 
diff -Nru bitcoinabc-0.21.11/src/test/txvalidation_tests.cpp bitcoinabc-0.21.12/src/test/txvalidation_tests.cpp
--- bitcoinabc-0.21.11/src/test/txvalidation_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/txvalidation_tests.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -32,7 +32,7 @@
 
     BOOST_CHECK(CTransaction(coinbaseTx).IsCoinBase());
 
-    CValidationState state;
+    TxValidationState state;
 
     LOCK(cs_main);
 
@@ -41,7 +41,6 @@
     BOOST_CHECK_EQUAL(false,
                       AcceptToMemoryPool(GetConfig(), *m_node.mempool, state,
                                          MakeTransactionRef(coinbaseTx),
-                                         nullptr /* pfMissingInputs */,
                                          true /* bypass_limits */,
                                          Amount::zero() /* nAbsurdFee */));
 
@@ -51,7 +50,7 @@
     // Check that the validation state reflects the unsuccesful attempt.
     BOOST_CHECK(state.IsInvalid());
     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-tx-coinbase");
-    BOOST_CHECK(state.GetReason() == ValidationInvalidReason::CONSENSUS);
+    BOOST_CHECK(state.GetResult() == TxValidationResult::TX_CONSENSUS);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff -Nru bitcoinabc-0.21.11/src/test/util/setup_common.cpp bitcoinabc-0.21.12/src/test/util/setup_common.cpp
--- bitcoinabc-0.21.11/src/test/util/setup_common.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/util/setup_common.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -15,7 +15,7 @@
 #include <miner.h>
 #include <net.h>
 #include <noui.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <rpc/blockchain.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
@@ -118,7 +118,7 @@
         throw std::runtime_error("LoadGenesisBlock failed.");
     }
     {
-        CValidationState state;
+        BlockValidationState state;
         if (!ActivateBestChain(config, state)) {
             throw std::runtime_error(strprintf("ActivateBestChain failed. (%s)",
                                                FormatStateMessage(state)));
diff -Nru bitcoinabc-0.21.11/src/test/util/str.cpp bitcoinabc-0.21.12/src/test/util/str.cpp
--- bitcoinabc-0.21.11/src/test/util/str.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/util/str.cpp	2020-07-20 15:59:43.000000000 +0000
@@ -0,0 +1,30 @@
+// Copyright (c) 2019 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 <test/util/str.h>
+
+#include <cstdint>
+#include <string>
+
+bool CaseInsensitiveEqual(const std::string &s1, const std::string &s2) {
+    if (s1.size() != s2.size()) {
+        return false;
+    }
+
+    for (size_t i = 0; i < s1.size(); ++i) {
+        char c1 = s1[i];
+        if (c1 >= 'A' && c1 <= 'Z') {
+            c1 -= ('A' - 'a');
+        }
+        char c2 = s2[i];
+        if (c2 >= 'A' && c2 <= 'Z') {
+            c2 -= ('A' - 'a');
+        }
+        if (c1 != c2) {
+            return false;
+        }
+    }
+
+    return true;
+}
diff -Nru bitcoinabc-0.21.11/src/test/util/str.h bitcoinabc-0.21.12/src/test/util/str.h
--- bitcoinabc-0.21.11/src/test/util/str.h	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/util/str.h	2020-07-20 15:59:43.000000000 +0000
@@ -0,0 +1,12 @@
+// Copyright (c) 2019 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_TEST_UTIL_STR_H
+#define BITCOIN_TEST_UTIL_STR_H
+
+#include <string>
+
+bool CaseInsensitiveEqual(const std::string &s1, const std::string &s2);
+
+#endif // BITCOIN_TEST_UTIL_STR_H
diff -Nru bitcoinabc-0.21.11/src/test/util.cpp bitcoinabc-0.21.12/src/test/util.cpp
--- bitcoinabc-0.21.11/src/test/util.cpp	2020-07-07 17:16:37.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/util.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -9,7 +9,7 @@
 #include <consensus/merkle.h>
 #include <key_io.h>
 #include <miner.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <validation.h>
 
 #ifdef ENABLE_WALLET
diff -Nru bitcoinabc-0.21.11/src/test/util_tests.cpp bitcoinabc-0.21.12/src/test/util_tests.cpp
--- bitcoinabc-0.21.11/src/test/util_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/util_tests.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -9,6 +9,7 @@
 #include <sync.h>
 #include <test/util.h>
 #include <util/moneystr.h>
+#include <util/spanparsing.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/time.h>
@@ -2070,4 +2071,126 @@
     BOOST_CHECK_EQUAL(Capitalize("\x00\xfe\xff"), "\x00\xfe\xff");
 }
 
+static std::string SpanToStr(Span<const char> &span) {
+    return std::string(span.begin(), span.end());
+}
+
+BOOST_AUTO_TEST_CASE(test_spanparsing) {
+    using namespace spanparsing;
+    std::string input;
+    Span<const char> sp;
+    bool success;
+
+    // Const(...): parse a constant, update span to skip it if successful
+    input = "MilkToastHoney";
+    sp = MakeSpan(input);
+    success = Const("", sp); // empty
+    BOOST_CHECK(success);
+    BOOST_CHECK_EQUAL(SpanToStr(sp), "MilkToastHoney");
+
+    success = Const("Milk", sp);
+    BOOST_CHECK(success);
+    BOOST_CHECK_EQUAL(SpanToStr(sp), "ToastHoney");
+
+    success = Const("Bread", sp);
+    BOOST_CHECK(!success);
+
+    success = Const("Toast", sp);
+    BOOST_CHECK(success);
+    BOOST_CHECK_EQUAL(SpanToStr(sp), "Honey");
+
+    success = Const("Honeybadger", sp);
+    BOOST_CHECK(!success);
+
+    success = Const("Honey", sp);
+    BOOST_CHECK(success);
+    BOOST_CHECK_EQUAL(SpanToStr(sp), "");
+
+    // Func(...): parse a function call, update span to argument if successful
+    input = "Foo(Bar(xy,z()))";
+    sp = MakeSpan(input);
+
+    success = Func("FooBar", sp);
+    BOOST_CHECK(!success);
+
+    success = Func("Foo(", sp);
+    BOOST_CHECK(!success);
+
+    success = Func("Foo", sp);
+    BOOST_CHECK(success);
+    BOOST_CHECK_EQUAL(SpanToStr(sp), "Bar(xy,z())");
+
+    success = Func("Bar", sp);
+    BOOST_CHECK(success);
+    BOOST_CHECK_EQUAL(SpanToStr(sp), "xy,z()");
+
+    success = Func("xy", sp);
+    BOOST_CHECK(!success);
+
+    // Expr(...): return expression that span begins with, update span to skip
+    // it
+    Span<const char> result;
+
+    input = "(n*(n-1))/2";
+    sp = MakeSpan(input);
+    result = Expr(sp);
+    BOOST_CHECK_EQUAL(SpanToStr(result), "(n*(n-1))/2");
+    BOOST_CHECK_EQUAL(SpanToStr(sp), "");
+
+    input = "foo,bar";
+    sp = MakeSpan(input);
+    result = Expr(sp);
+    BOOST_CHECK_EQUAL(SpanToStr(result), "foo");
+    BOOST_CHECK_EQUAL(SpanToStr(sp), ",bar");
+
+    input = "(aaaaa,bbbbb()),c";
+    sp = MakeSpan(input);
+    result = Expr(sp);
+    BOOST_CHECK_EQUAL(SpanToStr(result), "(aaaaa,bbbbb())");
+    BOOST_CHECK_EQUAL(SpanToStr(sp), ",c");
+
+    input = "xyz)foo";
+    sp = MakeSpan(input);
+    result = Expr(sp);
+    BOOST_CHECK_EQUAL(SpanToStr(result), "xyz");
+    BOOST_CHECK_EQUAL(SpanToStr(sp), ")foo");
+
+    input = "((a),(b),(c)),xxx";
+    sp = MakeSpan(input);
+    result = Expr(sp);
+    BOOST_CHECK_EQUAL(SpanToStr(result), "((a),(b),(c))");
+    BOOST_CHECK_EQUAL(SpanToStr(sp), ",xxx");
+
+    // Split(...): split a string on every instance of sep, return vector
+    std::vector<Span<const char>> results;
+
+    input = "xxx";
+    results = Split(MakeSpan(input), 'x');
+    BOOST_CHECK_EQUAL(results.size(), 4);
+    BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
+    BOOST_CHECK_EQUAL(SpanToStr(results[1]), "");
+    BOOST_CHECK_EQUAL(SpanToStr(results[2]), "");
+    BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
+
+    input = "one#two#three";
+    results = Split(MakeSpan(input), '-');
+    BOOST_CHECK_EQUAL(results.size(), 1);
+    BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one#two#three");
+
+    input = "one#two#three";
+    results = Split(MakeSpan(input), '#');
+    BOOST_CHECK_EQUAL(results.size(), 3);
+    BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one");
+    BOOST_CHECK_EQUAL(SpanToStr(results[1]), "two");
+    BOOST_CHECK_EQUAL(SpanToStr(results[2]), "three");
+
+    input = "*foo*bar*";
+    results = Split(MakeSpan(input), '*');
+    BOOST_CHECK_EQUAL(results.size(), 4);
+    BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
+    BOOST_CHECK_EQUAL(SpanToStr(results[1]), "foo");
+    BOOST_CHECK_EQUAL(SpanToStr(results[2]), "bar");
+    BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff -Nru bitcoinabc-0.21.11/src/test/validation_block_tests.cpp bitcoinabc-0.21.12/src/test/validation_block_tests.cpp
--- bitcoinabc-0.21.11/src/test/validation_block_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/validation_block_tests.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -10,7 +10,7 @@
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <miner.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <random.h>
 #include <test/util/setup_common.h>
 #include <util/time.h>
@@ -149,7 +149,7 @@
     }
 
     bool ignored;
-    CValidationState state;
+    BlockValidationState state;
     std::vector<CBlockHeader> headers;
     std::transform(
         blocks.begin(), blocks.end(), std::back_inserter(headers),
diff -Nru bitcoinabc-0.21.11/src/test/validationinterface_tests.cpp bitcoinabc-0.21.12/src/test/validationinterface_tests.cpp
--- bitcoinabc-0.21.11/src/test/validationinterface_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/test/validationinterface_tests.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -23,14 +23,14 @@
         }
     }
     void BlockChecked(const CBlock &block,
-                      const CValidationState &state) override {
+                      const BlockValidationState &state) override {
         if (m_on_call) {
             m_on_call();
         }
     }
     static void Call() {
         CBlock block;
-        CValidationState state;
+        BlockValidationState state;
         GetMainSignals().BlockChecked(block, state);
     }
     std::function<void()> m_on_call;
diff -Nru bitcoinabc-0.21.11/src/txdb.cpp bitcoinabc-0.21.12/src/txdb.cpp
--- bitcoinabc-0.21.11/src/txdb.cpp	2020-06-30 00:18:54.000000000 +0000
+++ bitcoinabc-0.21.12/src/txdb.cpp	2020-07-17 16:19:01.000000000 +0000
@@ -6,7 +6,7 @@
 #include <txdb.h>
 
 #include <chain.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <random.h>
 #include <shutdown.h>
 #include <ui_interface.h>
@@ -334,7 +334,7 @@
     template <typename Stream> void Unserialize(Stream &s) {
         uint32_t nCode = 0;
         // version
-        unsigned int nVersionDummy;
+        unsigned int nVersionDummy = 0;
         ::Unserialize(s, VARINT(nVersionDummy));
         // header code
         ::Unserialize(s, VARINT(nCode));
diff -Nru bitcoinabc-0.21.11/src/txmempool.cpp bitcoinabc-0.21.12/src/txmempool.cpp
--- bitcoinabc-0.21.11/src/txmempool.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/txmempool.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -571,7 +571,7 @@
         LockPoints lp = it->GetLockPoints();
         bool validLP = TestLockPointValidity(&lp);
 
-        CValidationState state;
+        TxValidationState state;
         if (!ContextualCheckTransactionForCurrentBlock(
                 config.GetChainParams().GetConsensus(), tx, state, flags) ||
             !CheckSequenceLocks(*this, tx, flags, &lp, validLP)) {
@@ -688,11 +688,13 @@
 static void CheckInputsAndUpdateCoins(const CTransaction &tx,
                                       CCoinsViewCache &mempoolDuplicate,
                                       const int64_t spendheight) {
-    CValidationState state;
+    // Not used. CheckTxInputs() should always pass
+    TxValidationState dummy_state;
     Amount txfee = Amount::zero();
     bool fCheckResult =
-        tx.IsCoinBase() || Consensus::CheckTxInputs(tx, state, mempoolDuplicate,
-                                                    spendheight, txfee);
+        tx.IsCoinBase() ||
+        Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate, spendheight,
+                                 txfee);
     assert(fCheckResult);
     UpdateCoins(mempoolDuplicate, tx, std::numeric_limits<int>::max());
 }
@@ -1391,10 +1393,9 @@
     for (const CTransactionRef &tx :
          reverse_iterate(queuedTx.get<insertion_order>())) {
         // ignore validation errors in resurrected transactions
-        CValidationState stateDummy;
+        TxValidationState stateDummy;
         if (!fAddToMempool || tx->IsCoinBase() ||
             !AcceptToMemoryPool(config, g_mempool, stateDummy, tx,
-                                nullptr /* pfMissingInputs */,
                                 true /* bypass_limits */,
                                 Amount::zero() /* nAbsurdFee */)) {
             // If the transaction doesn't make it in to the mempool, remove any
diff -Nru bitcoinabc-0.21.11/src/undo.h bitcoinabc-0.21.12/src/undo.h
--- bitcoinabc-0.21.11/src/undo.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/undo.h	2020-07-15 16:44:34.000000000 +0000
@@ -17,7 +17,7 @@
 class CBlock;
 class CBlockIndex;
 class CCoinsViewCache;
-class CValidationState;
+class BlockValidationState;
 
 /**
  * Undo information for a CTxIn
@@ -59,7 +59,7 @@
             // Old versions stored the version number for the last spend of a
             // transaction's outputs. Non-final spends were indicated with
             // height = 0.
-            unsigned int nVersionDummy;
+            unsigned int nVersionDummy = 0;
             ::Unserialize(s, VARINT(nVersionDummy));
         }
 
diff -Nru bitcoinabc-0.21.11/src/util/spanparsing.cpp bitcoinabc-0.21.12/src/util/spanparsing.cpp
--- bitcoinabc-0.21.11/src/util/spanparsing.cpp	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/util/spanparsing.cpp	2020-07-14 19:22:04.000000000 +0000
@@ -0,0 +1,66 @@
+// Copyright (c) 2018 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 <util/spanparsing.h>
+
+#include <span.h>
+
+#include <string>
+#include <vector>
+
+namespace spanparsing {
+
+bool Const(const std::string &str, Span<const char> &sp) {
+    if (size_t(sp.size()) >= str.size() &&
+        std::equal(str.begin(), str.end(), sp.begin())) {
+        sp = sp.subspan(str.size());
+        return true;
+    }
+    return false;
+}
+
+bool Func(const std::string &str, Span<const char> &sp) {
+    if (size_t(sp.size()) >= str.size() + 2 && sp[str.size()] == '(' &&
+        sp[sp.size() - 1] == ')' &&
+        std::equal(str.begin(), str.end(), sp.begin())) {
+        sp = sp.subspan(str.size() + 1, sp.size() - str.size() - 2);
+        return true;
+    }
+    return false;
+}
+
+Span<const char> Expr(Span<const char> &sp) {
+    int level = 0;
+    auto it = sp.begin();
+    while (it != sp.end()) {
+        if (*it == '(') {
+            ++level;
+        } else if (level && *it == ')') {
+            --level;
+        } else if (level == 0 && (*it == ')' || *it == ',')) {
+            break;
+        }
+        ++it;
+    }
+    Span<const char> ret = sp.first(it - sp.begin());
+    sp = sp.subspan(it - sp.begin());
+    return ret;
+}
+
+std::vector<Span<const char>> Split(const Span<const char> &sp, char sep) {
+    std::vector<Span<const char>> ret;
+    auto it = sp.begin();
+    auto start = it;
+    while (it != sp.end()) {
+        if (*it == sep) {
+            ret.emplace_back(start, it);
+            start = it + 1;
+        }
+        ++it;
+    }
+    ret.emplace_back(start, it);
+    return ret;
+}
+
+} // namespace spanparsing
diff -Nru bitcoinabc-0.21.11/src/util/spanparsing.h bitcoinabc-0.21.12/src/util/spanparsing.h
--- bitcoinabc-0.21.11/src/util/spanparsing.h	1970-01-01 00:00:00.000000000 +0000
+++ bitcoinabc-0.21.12/src/util/spanparsing.h	2020-07-14 19:22:04.000000000 +0000
@@ -0,0 +1,55 @@
+// Copyright (c) 2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_SPANPARSING_H
+#define BITCOIN_UTIL_SPANPARSING_H
+
+#include <span.h>
+
+#include <string>
+#include <vector>
+
+namespace spanparsing {
+
+/**
+ * Parse a constant.
+ *
+ * If sp's initial part matches str, sp is updated to skip that part, and true
+ * is returned. Otherwise sp is unmodified and false is returned.
+ */
+bool Const(const std::string &str, Span<const char> &sp);
+
+/**
+ * Parse a function call.
+ *
+ * If sp's initial part matches str + "(", and sp ends with ")", sp is updated
+ * to be the section between the braces, and true is returned. Otherwise sp is
+ * unmodified and false is returned.
+ */
+bool Func(const std::string &str, Span<const char> &sp);
+
+/**
+ * Extract the expression that sp begins with.
+ *
+ * This function will return the initial part of sp, up to (but not including)
+ * the first comma or closing brace, skipping ones that are surrounded by
+ * braces. So for example, for "foo(bar(1),2),3" the initial part
+ * "foo(bar(1),2)" will be returned. sp will be updated to skip the initial part
+ * that is returned.
+ */
+Span<const char> Expr(Span<const char> &sp);
+
+/**
+ * Split a string on every instance of sep, returning a vector.
+ *
+ * If sep does not occur in sp, a singleton with the entirety of sp is returned.
+ *
+ * Note that this function does not care about braces, so splitting
+ * "foo(bar(1),2),3) on ',' will return {"foo(bar(1)", "2)", "3)"}.
+ */
+std::vector<Span<const char>> Split(const Span<const char> &sp, char sep);
+
+} // namespace spanparsing
+
+#endif // BITCOIN_UTIL_SPANPARSING_H
diff -Nru bitcoinabc-0.21.11/src/util/validation.cpp bitcoinabc-0.21.12/src/util/validation.cpp
--- bitcoinabc-0.21.11/src/util/validation.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/util/validation.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -8,12 +8,19 @@
 #include <consensus/validation.h>
 #include <tinyformat.h>
 
-/** Convert CValidationState to a human-readable message for logging */
-std::string FormatStateMessage(const CValidationState &state) {
-    return strprintf(
-        "%s%s (code %i)", state.GetRejectReason(),
-        state.GetDebugMessage().empty() ? "" : ", " + state.GetDebugMessage(),
-        state.GetRejectCode());
+std::string FormatStateMessage(const ValidationState &state) {
+    if (state.IsValid()) {
+        return "Valid";
+    }
+
+    const std::string debug_message = state.GetDebugMessage();
+    if (!debug_message.empty()) {
+        return strprintf("%s, %s (code %i)", state.GetRejectReason(),
+                         debug_message, state.GetRejectCode());
+    }
+
+    return strprintf("%s (code %i)", state.GetRejectReason(),
+                     state.GetRejectCode());
 }
 
 const std::string strMessageMagic = "Bitcoin Signed Message:\n";
diff -Nru bitcoinabc-0.21.11/src/util/validation.h bitcoinabc-0.21.12/src/util/validation.h
--- bitcoinabc-0.21.11/src/util/validation.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/util/validation.h	2020-07-15 16:44:34.000000000 +0000
@@ -8,10 +8,10 @@
 
 #include <string>
 
-class CValidationState;
+class ValidationState;
 
-/** Convert CValidationState to a human-readable message for logging */
-std::string FormatStateMessage(const CValidationState &state);
+/** Convert ValidationState to a human-readable message for logging */
+std::string FormatStateMessage(const ValidationState &state);
 
 extern const std::string strMessageMagic;
 
diff -Nru bitcoinabc-0.21.11/src/validation.cpp bitcoinabc-0.21.12/src/validation.cpp
--- bitcoinabc-0.21.11/src/validation.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/validation.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -20,12 +20,11 @@
 #include <consensus/validation.h>
 #include <hash.h>
 #include <index/txindex.h>
-#include <minerfund.h>
 #include <policy/fees.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <random.h>
@@ -293,7 +292,7 @@
 // Used to avoid mempool polluting consensus critical paths if CCoinsViewMempool
 // were somehow broken and returning the wrong scriptPubKeys
 static bool CheckInputsFromMempoolAndCache(
-    const CTransaction &tx, CValidationState &state,
+    const CTransaction &tx, TxValidationState &state,
     const CCoinsViewCache &view, const CTxMemPool &pool, const uint32_t flags,
     bool cacheSigStore, PrecomputedTransactionData &txdata, int &nSigChecksOut)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
@@ -339,13 +338,11 @@
  * to optionally remove the cache additions if the associated transaction ends
  *                                up being rejected by the mempool.
  */
-static bool
-AcceptToMemoryPoolWorker(const Config &config, CTxMemPool &pool,
-                         CValidationState &state, const CTransactionRef &ptx,
-                         bool *pfMissingInputs, int64_t nAcceptTime,
-                         bool bypass_limits, const Amount nAbsurdFee,
-                         std::vector<COutPoint> &coins_to_uncache,
-                         bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
+static bool AcceptToMemoryPoolWorker(
+    const Config &config, CTxMemPool &pool, TxValidationState &state,
+    const CTransactionRef &ptx, int64_t nAcceptTime, bool bypass_limits,
+    const Amount nAbsurdFee, std::vector<COutPoint> &coins_to_uncache,
+    bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     AssertLockHeld(cs_main);
 
     const Consensus::Params &consensusParams =
@@ -357,9 +354,6 @@
     // mempool "read lock" (held through
     // GetMainSignals().TransactionAddedToMempool())
     LOCK(pool.cs);
-    if (pfMissingInputs) {
-        *pfMissingInputs = false;
-    }
 
     // Coinbase is only valid in a block, not as a loose transaction.
     if (!CheckRegularTransaction(tx, state)) {
@@ -370,27 +364,27 @@
     // Rather not work on nonstandard transactions (unless -testnet)
     std::string reason;
     if (fRequireStandard && !IsStandardTx(tx, reason)) {
-        return state.Invalid(ValidationInvalidReason::TX_NOT_STANDARD, false,
+        return state.Invalid(TxValidationResult::TX_NOT_STANDARD,
                              REJECT_NONSTANDARD, reason);
     }
 
     // Only accept nLockTime-using transactions that can be mined in the next
     // block; we don't want our mempool filled up with transactions that can't
     // be mined yet.
-    CValidationState ctxState;
+    TxValidationState ctxState;
     if (!ContextualCheckTransactionForCurrentBlock(
             consensusParams, tx, ctxState, STANDARD_LOCKTIME_VERIFY_FLAGS)) {
         // We copy the state from a dummy to ensure we don't increase the
         // ban score of peer for transaction that could be valid in the future.
-        return state.Invalid(ValidationInvalidReason::TX_PREMATURE_SPEND, false,
+        return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND,
                              REJECT_NONSTANDARD, ctxState.GetRejectReason(),
                              ctxState.GetDebugMessage());
     }
 
     // Is it already in the memory pool?
     if (pool.exists(txid)) {
-        return state.Invalid(ValidationInvalidReason::TX_CONFLICT, false,
-                             REJECT_DUPLICATE, "txn-already-in-mempool");
+        return state.Invalid(TxValidationResult::TX_CONFLICT, REJECT_DUPLICATE,
+                             "txn-already-in-mempool");
     }
 
     // Check for conflicts with in-memory transactions
@@ -398,9 +392,8 @@
         auto itConflicting = pool.mapNextTx.find(txin.prevout);
         if (itConflicting != pool.mapNextTx.end()) {
             // Disable replacement feature for good
-            return state.Invalid(ValidationInvalidReason::TX_MEMPOOL_POLICY,
-                                 false, REJECT_DUPLICATE,
-                                 "txn-mempool-conflict");
+            return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
+                                 REJECT_DUPLICATE, "txn-mempool-conflict");
         }
     }
 
@@ -428,29 +421,24 @@
                     // Optimistically just do efficient check of cache for
                     // outputs.
                     if (pcoinsTip->HaveCoinInCache(COutPoint(txid, out))) {
-                        return state.Invalid(
-                            ValidationInvalidReason::TX_CONFLICT, false,
-                            REJECT_DUPLICATE, "txn-already-known");
+                        return state.Invalid(TxValidationResult::TX_CONFLICT,
+                                             REJECT_DUPLICATE,
+                                             "txn-already-known");
                     }
                 }
 
                 // Otherwise assume this might be an orphan tx for which we just
                 // haven't seen parents yet.
-                if (pfMissingInputs) {
-                    *pfMissingInputs = true;
-                }
-
-                // fMissingInputs and !state.IsInvalid() is used to detect this
-                // condition, don't set state.Invalid()
-                return false;
+                return state.Invalid(TxValidationResult::TX_MISSING_INPUTS,
+                                     REJECT_INVALID,
+                                     "bad-txns-inputs-missingorspent");
             }
         }
 
         // Are the actual inputs available?
         if (!view.HaveInputs(tx)) {
-            return state.Invalid(ValidationInvalidReason::TX_MEMPOOL_POLICY,
-                                 false, REJECT_DUPLICATE,
-                                 "bad-txns-inputs-spent");
+            return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
+                                 REJECT_DUPLICATE, "bad-txns-inputs-spent");
         }
 
         // Bring the best block into scope.
@@ -467,8 +455,8 @@
         // own.
         if (!CheckSequenceLocks(pool, tx, STANDARD_LOCKTIME_VERIFY_FLAGS,
                                 &lp)) {
-            return state.Invalid(ValidationInvalidReason::TX_PREMATURE_SPEND,
-                                 false, REJECT_NONSTANDARD, "non-BIP68-final");
+            return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND,
+                                 REJECT_NONSTANDARD, "non-BIP68-final");
         }
 
         Amount nFees = Amount::zero();
@@ -484,8 +472,8 @@
         // Check for non-standard pay-to-script-hash in inputs
         if (fRequireStandard &&
             !AreInputsStandard(tx, view, nextBlockScriptVerifyFlags)) {
-            return state.Invalid(ValidationInvalidReason::TX_NOT_STANDARD,
-                                 false, REJECT_NONSTANDARD,
+            return state.Invalid(TxValidationResult::TX_NOT_STANDARD,
+                                 REJECT_NONSTANDARD,
                                  "bad-txns-nonstandard-inputs");
         }
 
@@ -511,14 +499,14 @@
         // Do not change this to use virtualsize without coordinating a network
         // policy upgrade.
         if (!bypass_limits && nModifiedFees < minRelayTxFee.GetFee(nSize)) {
-            return state.Invalid(ValidationInvalidReason::TX_MEMPOOL_POLICY,
-                                 false, REJECT_INSUFFICIENTFEE,
+            return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
+                                 REJECT_INSUFFICIENTFEE,
                                  "min relay fee not met");
         }
 
         if (nAbsurdFee != Amount::zero() && nFees > nAbsurdFee) {
-            return state.Invalid(ValidationInvalidReason::TX_NOT_STANDARD,
-                                 false, REJECT_HIGHFEE, "absurdly-high-fee",
+            return state.Invalid(TxValidationResult::TX_NOT_STANDARD,
+                                 REJECT_HIGHFEE, "absurdly-high-fee",
                                  strprintf("%d > %d", nFees, nAbsurdFee));
         }
 
@@ -530,7 +518,6 @@
         if (!CheckInputs(tx, state, view, true, scriptVerifyFlags, true, false,
                          txdata, nSigChecksStandard)) {
             // State filled in by CheckInputs.
-            assert(IsTransactionReason(state.GetReason()));
             return false;
         }
 
@@ -547,8 +534,8 @@
         if (!bypass_limits && mempoolRejectFee > Amount::zero() &&
             nModifiedFees < mempoolRejectFee) {
             return state.Invalid(
-                ValidationInvalidReason::TX_MEMPOOL_POLICY, false,
-                REJECT_INSUFFICIENTFEE, "mempool min fee not met",
+                TxValidationResult::TX_MEMPOOL_POLICY, REJECT_INSUFFICIENTFEE,
+                "mempool min fee not met",
                 strprintf("%d < %d", nModifiedFees, mempoolRejectFee));
         }
 
@@ -569,9 +556,9 @@
         if (!pool.CalculateMemPoolAncestors(
                 entry, setAncestors, nLimitAncestors, nLimitAncestorSize,
                 nLimitDescendants, nLimitDescendantSize, errString)) {
-            return state.Invalid(ValidationInvalidReason::TX_MEMPOOL_POLICY,
-                                 false, REJECT_NONSTANDARD,
-                                 "too-long-mempool-chain", errString);
+            return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
+                                 REJECT_NONSTANDARD, "too-long-mempool-chain",
+                                 errString);
         }
 
         // Check again against the next block's script verification flags
@@ -622,9 +609,8 @@
                 std::chrono::hours{
                     gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY)});
             if (!pool.exists(txid)) {
-                return state.Invalid(ValidationInvalidReason::TX_MEMPOOL_POLICY,
-                                     false, REJECT_INSUFFICIENTFEE,
-                                     "mempool full");
+                return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY,
+                                     REJECT_INSUFFICIENTFEE, "mempool full");
             }
         }
     }
@@ -638,15 +624,15 @@
  */
 static bool
 AcceptToMemoryPoolWithTime(const Config &config, CTxMemPool &pool,
-                           CValidationState &state, const CTransactionRef &tx,
-                           bool *pfMissingInputs, int64_t nAcceptTime,
-                           bool bypass_limits, const Amount nAbsurdFee,
-                           bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
+                           TxValidationState &state, const CTransactionRef &tx,
+                           int64_t nAcceptTime, bool bypass_limits,
+                           const Amount nAbsurdFee, bool test_accept)
+    EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     AssertLockHeld(cs_main);
     std::vector<COutPoint> coins_to_uncache;
-    bool res = AcceptToMemoryPoolWorker(
-        config, pool, state, tx, pfMissingInputs, nAcceptTime, bypass_limits,
-        nAbsurdFee, coins_to_uncache, test_accept);
+    bool res = AcceptToMemoryPoolWorker(config, pool, state, tx, nAcceptTime,
+                                        bypass_limits, nAbsurdFee,
+                                        coins_to_uncache, test_accept);
     if (!res) {
         // Remove coins that were not present in the coins cache before calling
         // ATMPW; this is to prevent memory DoS in case we receive a large
@@ -661,19 +647,18 @@
 
     // After we've (potentially) uncached entries, ensure our coins cache is
     // still within its size limits
-    CValidationState stateDummy;
+    BlockValidationState stateDummy;
     ::ChainstateActive().FlushStateToDisk(config.GetChainParams(), stateDummy,
                                           FlushStateMode::PERIODIC);
     return res;
 }
 
 bool AcceptToMemoryPool(const Config &config, CTxMemPool &pool,
-                        CValidationState &state, const CTransactionRef &tx,
-                        bool *pfMissingInputs, bool bypass_limits,
-                        const Amount nAbsurdFee, bool test_accept) {
-    return AcceptToMemoryPoolWithTime(config, pool, state, tx, pfMissingInputs,
-                                      GetTime(), bypass_limits, nAbsurdFee,
-                                      test_accept);
+                        TxValidationState &state, const CTransactionRef &tx,
+                        bool bypass_limits, const Amount nAbsurdFee,
+                        bool test_accept) {
+    return AcceptToMemoryPoolWithTime(config, pool, state, tx, GetTime(),
+                                      bypass_limits, nAbsurdFee, test_accept);
 }
 
 /**
@@ -965,8 +950,8 @@
 }
 
 void CChainState::InvalidBlockFound(CBlockIndex *pindex,
-                                    const CValidationState &state) {
-    if (state.GetReason() != ValidationInvalidReason::BLOCK_MUTATED) {
+                                    const BlockValidationState &state) {
+    if (state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {
         pindex->nStatus = pindex->nStatus.withFailed();
         m_failed_blocks.insert(pindex);
         setDirtyBlockIndex.insert(pindex);
@@ -1010,9 +995,9 @@
 
 bool CScriptCheck::operator()() {
     const CScript &scriptSig = ptxTo->vin[nIn].scriptSig;
-    if (!VerifyScript(scriptSig, scriptPubKey, nFlags,
-                      CachingTransactionSignatureChecker(ptxTo, nIn, amount,
-                                                         cacheStore, txdata),
+    if (!VerifyScript(scriptSig, m_tx_out.scriptPubKey, nFlags,
+                      CachingTransactionSignatureChecker(
+                          ptxTo, nIn, m_tx_out.nValue, cacheStore, txdata),
                       metrics, &error)) {
         return false;
     }
@@ -1035,7 +1020,7 @@
     return pindexPrev->nHeight + 1;
 }
 
-bool CheckInputs(const CTransaction &tx, CValidationState &state,
+bool CheckInputs(const CTransaction &tx, TxValidationState &state,
                  const CCoinsViewCache &inputs, bool fScriptChecks,
                  const uint32_t flags, bool sigCacheStore,
                  bool scriptCacheStore,
@@ -1068,7 +1053,7 @@
         if (!txLimitSigChecks.consume_and_check(nSigChecksOut) ||
             (pBlockLimitSigChecks &&
              !pBlockLimitSigChecks->consume_and_check(nSigChecksOut))) {
-            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+            return state.Invalid(TxValidationResult::TX_CONSENSUS,
                                  REJECT_INVALID, "too-many-sigchecks");
         }
         return true;
@@ -1086,12 +1071,10 @@
         // check that our caching is not introducing consensus failures through
         // additional data in, eg, the coins being spent being checked as a part
         // of CScriptCheck.
-        const CScript &scriptPubKey = coin.GetTxOut().scriptPubKey;
-        const Amount amount = coin.GetTxOut().nValue;
 
         // Verify signature
-        CScriptCheck check(scriptPubKey, amount, tx, i, flags, sigCacheStore,
-                           txdata, &txLimitSigChecks, pBlockLimitSigChecks);
+        CScriptCheck check(coin.GetTxOut(), tx, i, flags, sigCacheStore, txdata,
+                           &txLimitSigChecks, pBlockLimitSigChecks);
         if (pvChecks) {
             pvChecks->push_back(std::move(check));
         } else if (!check()) {
@@ -1108,12 +1091,11 @@
                 // NOT_STANDARD instead of CONSENSUS to avoid downstream users
                 // splitting the network between upgraded and non-upgraded nodes
                 // by banning CONSENSUS-failing data providers.
-                CScriptCheck check2(scriptPubKey, amount, tx, i, mandatoryFlags,
+                CScriptCheck check2(coin.GetTxOut(), tx, i, mandatoryFlags,
                                     sigCacheStore, txdata);
                 if (check2()) {
                     return state.Invalid(
-                        ValidationInvalidReason::TX_NOT_STANDARD, false,
-                        REJECT_NONSTANDARD,
+                        TxValidationResult::TX_NOT_STANDARD, REJECT_NONSTANDARD,
                         strprintf("non-mandatory-script-verify-flag (%s)",
                                   ScriptErrorString(scriptError)));
                 }
@@ -1122,14 +1104,14 @@
             }
 
             // MANDATORY flag failures correspond to
-            // ValidationInvalidReason::CONSENSUS. Because CONSENSUS failures
+            // TxValidationResult::TX_CONSENSUS. Because CONSENSUS failures
             // are the most serious case of validation failures, we may need to
             // consider using RECENT_CONSENSUS_CHANGE for any script failure
             // that could be due to non-upgraded nodes which we may want to
             // support, to avoid splitting the network (but this depends on the
             // details of how net_processing handles such errors).
             return state.Invalid(
-                ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID,
+                TxValidationResult::TX_CONSENSUS, REJECT_INVALID,
                 strprintf("mandatory-script-verify-flag-failed (%s)",
                           ScriptErrorString(scriptError)));
         }
@@ -1225,7 +1207,8 @@
     return false;
 }
 
-static bool AbortNode(CValidationState &state, const std::string &strMessage,
+static bool AbortNode(BlockValidationState &state,
+                      const std::string &strMessage,
                       const std::string &userMessage = "") {
     AbortNode(strMessage, userMessage);
     return state.Error(strMessage);
@@ -1362,11 +1345,12 @@
     }
 }
 
-static bool FindUndoPos(CValidationState &state, int nFile, FlatFilePos &pos,
-                        unsigned int nAddSize);
+static bool FindUndoPos(BlockValidationState &state, int nFile,
+                        FlatFilePos &pos, unsigned int nAddSize);
 
 static bool WriteUndoDataForBlock(const CBlockUndo &blockundo,
-                                  CValidationState &state, CBlockIndex *pindex,
+                                  BlockValidationState &state,
+                                  CBlockIndex *pindex,
                                   const CChainParams &chainparams) {
     // Write undo information to disk
     if (pindex->GetUndoPos().IsNull()) {
@@ -1502,7 +1486,7 @@
  * done; ConnectBlock() can fail if those validity checks fail (among other
  * reasons).
  */
-bool CChainState::ConnectBlock(const CBlock &block, CValidationState &state,
+bool CChainState::ConnectBlock(const CBlock &block, BlockValidationState &state,
                                CBlockIndex *pindex, CCoinsViewCache &view,
                                const CChainParams &params,
                                BlockValidationOptions options,
@@ -1529,7 +1513,7 @@
     if (!CheckBlock(block, state, consensusParams,
                     options.withCheckPoW(!fJustCheck)
                         .withCheckMerkleRoot(!fJustCheck))) {
-        if (state.GetReason() == ValidationInvalidReason::BLOCK_MUTATED) {
+        if (state.GetResult() == BlockValidationResult::BLOCK_MUTATED) {
             // We don't write down blocks to disk if they may have been
             // corrupted, so this should be impossible unless we're having
             // hardware problems.
@@ -1643,10 +1627,10 @@
         for (const auto &tx : block.vtx) {
             for (size_t o = 0; o < tx->vout.size(); o++) {
                 if (view.HaveCoin(COutPoint(tx->GetId(), o))) {
-                    return state.Invalid(
-                        ValidationInvalidReason::CONSENSUS,
-                        error("ConnectBlock(): tried to overwrite transaction"),
-                        REJECT_INVALID, "bad-txns-BIP30");
+                    LogPrintf("ERROR: ConnectBlock(): tried to overwrite "
+                              "transaction\n");
+                    return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                                         REJECT_INVALID, "bad-txns-BIP30");
                 }
             }
         }
@@ -1702,10 +1686,9 @@
         // disk, and older versions may have saved a weird block.
         // - its checks are not applied to pre-CTOR chains, which we might visit
         // with checkpointing off.
-        return state.Invalid(
-            ValidationInvalidReason::CONSENSUS,
-            error("ConnectBlock(): tried to overwrite transaction"),
-            REJECT_INVALID, "tx-duplicate");
+        LogPrintf("ERROR: ConnectBlock(): tried to overwrite transaction\n");
+        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                             REJECT_INVALID, "tx-duplicate");
     }
 
     size_t txIndex = 0;
@@ -1714,28 +1697,31 @@
         const bool isCoinBase = tx.IsCoinBase();
         nInputs += tx.vin.size();
 
-        Amount txfee = Amount::zero();
-        if (!isCoinBase && !Consensus::CheckTxInputs(tx, state, view,
-                                                     pindex->nHeight, txfee)) {
-            if (!IsBlockReason(state.GetReason())) {
-                // CheckTxInputs may return MISSING_INPUTS or PREMATURE_SPEND
-                // but we can't return that, as it's not defined for a block, so
-                // we reset the reason flag to CONSENSUS here.
-                state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                              state.GetRejectCode(), state.GetRejectReason(),
-                              state.GetDebugMessage());
-            }
+        {
+            Amount txfee = Amount::zero();
+            TxValidationState tx_state;
+            if (!isCoinBase &&
+                !Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight,
+                                          txfee)) {
+                // Any transaction validation failure in ConnectBlock is a block
+                // consensus failure.
+                state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                              tx_state.GetRejectCode(),
+                              tx_state.GetRejectReason(),
+                              tx_state.GetDebugMessage());
 
-            return error("%s: Consensus::CheckTxInputs: %s, %s", __func__,
-                         tx.GetId().ToString(), FormatStateMessage(state));
+                return error("%s: Consensus::CheckTxInputs: %s, %s", __func__,
+                             tx.GetId().ToString(), FormatStateMessage(state));
+            }
+            nFees += txfee;
         }
-        nFees += txfee;
+
         if (!MoneyRange(nFees)) {
-            return state.Invalid(
-                ValidationInvalidReason::CONSENSUS,
-                error("%s: accumulated fee in the block out of range.",
-                      __func__),
-                REJECT_INVALID, "bad-txns-accumulated-fee-outofrange");
+            LogPrintf("ERROR: %s: accumulated fee in the block out of range.\n",
+                      __func__);
+            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                                 REJECT_INVALID,
+                                 "bad-txns-accumulated-fee-outofrange");
         }
 
         // The following checks do not apply to the coinbase.
@@ -1752,10 +1738,10 @@
         }
 
         if (!SequenceLocks(tx, nLockTimeFlags, &prevheights, *pindex)) {
-            return state.Invalid(
-                ValidationInvalidReason::CONSENSUS,
-                error("%s: contains a non-BIP68-final transaction", __func__),
-                REJECT_INVALID, "bad-txns-nonfinal");
+            LogPrintf("ERROR: %s: contains a non-BIP68-final transaction\n",
+                      __func__);
+            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                                 REJECT_INVALID, "bad-txns-nonfinal");
         }
 
         // Don't cache results if we're actually connecting blocks (still
@@ -1774,21 +1760,17 @@
         // nSigChecksRet may be accurate (found in cache) or 0 (checks were
         // deferred into vChecks).
         int nSigChecksRet;
-        if (!CheckInputs(tx, state, view, fScriptChecks, flags, fCacheResults,
-                         fCacheResults, PrecomputedTransactionData(tx),
-                         nSigChecksRet, nSigChecksTxLimiters[txIndex],
-                         &nSigChecksBlockLimiter, &vChecks)) {
-            if (state.GetReason() == ValidationInvalidReason::TX_NOT_STANDARD) {
-                // CheckInputs may return NOT_STANDARD for extra flags we
-                // passed, but we can't return that, as it's not defined for a
-                // block, so we reset the reason flag to CONSENSUS here. In the
-                // event of a future soft-fork, we may need to consider whether
-                // rewriting to CONSENSUS or RECENT_CONSENSUS_CHANGE would be
-                // more appropriate.
-                state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                              state.GetRejectCode(), state.GetRejectReason(),
-                              state.GetDebugMessage());
-            }
+        TxValidationState tx_state;
+        if (!CheckInputs(tx, tx_state, view, fScriptChecks, flags,
+                         fCacheResults, fCacheResults,
+                         PrecomputedTransactionData(tx), nSigChecksRet,
+                         nSigChecksTxLimiters[txIndex], &nSigChecksBlockLimiter,
+                         &vChecks)) {
+            // Any transaction validation failure in ConnectBlock is a block
+            // consensus failure
+            state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                          tx_state.GetRejectCode(), tx_state.GetRejectReason(),
+                          tx_state.GetDebugMessage());
             return error("ConnectBlock(): CheckInputs on %s failed with %s",
                          tx.GetId().ToString(), FormatStateMessage(state));
         }
@@ -1817,45 +1799,15 @@
     Amount blockReward =
         nFees + GetBlockSubsidy(pindex->nHeight, consensusParams);
     if (block.vtx[0]->GetValueOut() > blockReward) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS,
-                             error("ConnectBlock(): coinbase pays too much "
-                                   "(actual=%d vs limit=%d)",
-                                   block.vtx[0]->GetValueOut(), blockReward),
+        LogPrintf("ERROR: ConnectBlock(): coinbase pays too much (actual=%d vs "
+                  "limit=%d)\n",
+                  block.vtx[0]->GetValueOut(), blockReward);
+        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              REJECT_INVALID, "bad-cb-amount");
     }
 
-    const std::vector<CTxDestination> whitelist =
-        GetMinerFundWhitelist(consensusParams, pindex->pprev);
-    if (!whitelist.empty()) {
-        const Amount required = blockReward / MINER_FUND_RATIO;
-
-        for (auto &o : block.vtx[0]->vout) {
-            if (o.nValue < required) {
-                // This output doesn't qualify because its amount is too low.
-                continue;
-            }
-
-            CTxDestination address;
-            if (!ExtractDestination(o.scriptPubKey, address)) {
-                // Cannot decode address.
-                continue;
-            }
-
-            if (std::find(whitelist.begin(), whitelist.end(), address) !=
-                whitelist.end()) {
-                goto MinerFundSuccess;
-            }
-        }
-
-        // We did not find an output that match the miner fund requirements.
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             REJECT_INVALID, "bad-cb-minerfund");
-    }
-
-MinerFundSuccess:
-
     if (!control.Wait()) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              REJECT_INVALID, "blk-bad-inputs",
                              "parallel script check failed");
     }
@@ -1902,7 +1854,8 @@
 }
 
 bool CChainState::FlushStateToDisk(const CChainParams &chainparams,
-                                   CValidationState &state, FlushStateMode mode,
+                                   BlockValidationState &state,
+                                   FlushStateMode mode,
                                    int nManualPruneHeight) {
     int64_t nMempoolUsage = g_mempool.DynamicMemoryUsage();
     LOCK(cs_main);
@@ -2048,7 +2001,7 @@
 }
 
 void CChainState::ForceFlushStateToDisk() {
-    CValidationState state;
+    BlockValidationState state;
     const CChainParams &chainparams = Params();
     if (!this->FlushStateToDisk(chainparams, state, FlushStateMode::ALWAYS)) {
         LogPrintf("%s: failed to flush state (%s)\n", __func__,
@@ -2057,7 +2010,7 @@
 }
 
 void CChainState::PruneAndFlush() {
-    CValidationState state;
+    BlockValidationState state;
     fCheckForPruning = true;
     const CChainParams &chainparams = Params();
     if (!this->FlushStateToDisk(chainparams, state, FlushStateMode::NONE)) {
@@ -2101,7 +2054,7 @@
  * in any case).
  */
 bool CChainState::DisconnectTip(const CChainParams &params,
-                                CValidationState &state,
+                                BlockValidationState &state,
                                 DisconnectedBlockTransactions *disconnectpool) {
     AssertLockHeld(cs_main);
     CBlockIndex *pindexDelete = m_chain.Tip();
@@ -2247,26 +2200,26 @@
     }
 };
 
-static bool FinalizeBlockInternal(const Config &config, CValidationState &state,
-                                  const CBlockIndex *pindex)
-    EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
+bool CChainState::MarkBlockAsFinal(const Config &config,
+                                   BlockValidationState &state,
+                                   const CBlockIndex *pindex) {
     AssertLockHeld(cs_main);
     if (pindex->nStatus.isInvalid()) {
         // We try to finalize an invalid block.
-        return state.Invalid(ValidationInvalidReason::CACHED_INVALID,
-                             error("%s: Trying to finalize invalid block %s",
-                                   __func__, pindex->GetBlockHash().ToString()),
+        LogPrintf("ERROR: %s: Trying to finalize invalid block %s\n", __func__,
+                  pindex->GetBlockHash().ToString());
+        return state.Invalid(BlockValidationResult::BLOCK_CACHED_INVALID,
                              REJECT_INVALID, "finalize-invalid-block");
     }
 
     // Check that the request is consistent with current finalization.
     if (pindexFinalized && !AreOnTheSameFork(pindex, pindexFinalized)) {
-        return state.Invalid(
-            ValidationInvalidReason::BLOCK_FINALIZATION,
-            error("%s: Trying to finalize block %s which conflicts "
-                  "with already finalized block",
-                  __func__, pindex->GetBlockHash().ToString()),
-            REJECT_AGAINST_FINALIZED, "bad-fork-prior-finalized");
+        LogPrintf("ERROR: %s: Trying to finalize block %s which conflicts with "
+                  "already finalized block\n",
+                  __func__, pindex->GetBlockHash().ToString());
+        return state.Invalid(BlockValidationResult::BLOCK_FINALIZATION,
+                             REJECT_AGAINST_FINALIZED,
+                             "bad-fork-prior-finalized");
     }
 
     if (IsBlockFinalized(pindex)) {
@@ -2335,7 +2288,7 @@
  * by copying pblock) - if that is not intended, care must be taken to remove
  * the last entry in blocksConnected in case of failure.
  */
-bool CChainState::ConnectTip(const Config &config, CValidationState &state,
+bool CChainState::ConnectTip(const Config &config, BlockValidationState &state,
                              CBlockIndex *pindexNew,
                              const std::shared_ptr<const CBlock> &pblock,
                              ConnectTrace &connectTrace,
@@ -2386,8 +2339,8 @@
         const CBlockIndex *pindexToFinalize =
             FindBlockToFinalize(config, pindexNew);
         if (pindexToFinalize &&
-            !FinalizeBlockInternal(config, state, pindexToFinalize)) {
-            return error("ConnectTip(): FinalizeBlock %s failed (%s)",
+            !MarkBlockAsFinal(config, state, pindexToFinalize)) {
+            return error("ConnectTip(): MarkBlockAsFinal %s failed (%s)",
                          pindexNew->GetBlockHash().ToString(),
                          FormatStateMessage(state));
         }
@@ -2641,9 +2594,9 @@
  * pindexMostWork.
  */
 bool CChainState::ActivateBestChainStep(
-    const Config &config, CValidationState &state, CBlockIndex *pindexMostWork,
-    const std::shared_ptr<const CBlock> &pblock, bool &fInvalidFound,
-    ConnectTrace &connectTrace) {
+    const Config &config, BlockValidationState &state,
+    CBlockIndex *pindexMostWork, const std::shared_ptr<const CBlock> &pblock,
+    bool &fInvalidFound, ConnectTrace &connectTrace) {
     AssertLockHeld(cs_main);
 
     const CBlockIndex *pindexOldTip = m_chain.Tip();
@@ -2696,12 +2649,11 @@
                             connectTrace, disconnectpool)) {
                 if (state.IsInvalid()) {
                     // The block violates a consensus rule.
-                    if (state.GetReason() !=
-                        ValidationInvalidReason::BLOCK_MUTATED) {
+                    if (state.GetResult() !=
+                        BlockValidationResult::BLOCK_MUTATED) {
                         InvalidChainFound(vpindexToConnect.back());
                     }
-
-                    state = CValidationState();
+                    state = BlockValidationState();
                     fInvalidFound = true;
                     fContinue = false;
                     break;
@@ -2780,7 +2732,7 @@
  * call may be quite long during reindexing or a substantial reorg.
  */
 bool CChainState::ActivateBestChain(const Config &config,
-                                    CValidationState &state,
+                                    BlockValidationState &state,
                                     std::shared_ptr<const CBlock> pblock) {
     // Note that while we're often called here from ProcessNewBlock, this is
     // far from a guarantee. Things in the P2P/RPC will often end up calling
@@ -2916,13 +2868,40 @@
     return true;
 }
 
-bool ActivateBestChain(const Config &config, CValidationState &state,
+bool ActivateBestChain(const Config &config, BlockValidationState &state,
                        std::shared_ptr<const CBlock> pblock) {
     return ::ChainstateActive().ActivateBestChain(config, state,
                                                   std::move(pblock));
 }
 
-bool CChainState::PreciousBlock(const Config &config, CValidationState &state,
+bool CChainState::FinalizeBlock(const Config &config,
+                                BlockValidationState &state,
+                                CBlockIndex *pindex) {
+    AssertLockHeld(cs_main);
+    if (!MarkBlockAsFinal(config, state, pindex)) {
+        // state is set by MarkBlockAsFinal.
+        return false;
+    }
+
+    // We have a valid candidate, make sure it is not parked.
+    if (pindex->nStatus.isOnParkedChain()) {
+        UnparkBlock(pindex);
+    }
+
+    // If the finalized block is not on the active chain, we may need to rewind.
+    if (!::ChainActive().Contains(pindex)) {
+        const CBlockIndex *pindexFork = ::ChainActive().FindFork(pindex);
+        CBlockIndex *pindexToInvalidate = ::ChainActive().Next(pindexFork);
+        if (pindexToInvalidate) {
+            return InvalidateBlock(config, state, pindexToInvalidate);
+        }
+    }
+
+    return true;
+}
+
+bool CChainState::PreciousBlock(const Config &config,
+                                BlockValidationState &state,
                                 CBlockIndex *pindex) {
     {
         LOCK(cs_main);
@@ -2960,12 +2939,12 @@
     return ActivateBestChain(config, state);
 }
 
-bool PreciousBlock(const Config &config, CValidationState &state,
+bool PreciousBlock(const Config &config, BlockValidationState &state,
                    CBlockIndex *pindex) {
     return ::ChainstateActive().PreciousBlock(config, state, pindex);
 }
 
-bool CChainState::UnwindBlock(const Config &config, CValidationState &state,
+bool CChainState::UnwindBlock(const Config &config, BlockValidationState &state,
                               CBlockIndex *pindex, bool invalidate) {
     CBlockIndex *to_mark_failed_or_parked = pindex;
     bool pindex_was_in_chain = false;
@@ -3086,37 +3065,12 @@
     return true;
 }
 
-bool FinalizeBlockAndInvalidate(const Config &config, CValidationState &state,
-                                CBlockIndex *pindex) {
-    AssertLockHeld(cs_main);
-    if (!FinalizeBlockInternal(config, state, pindex)) {
-        // state is set by FinalizeBlockInternal.
-        return false;
-    }
-
-    // We have a valid candidate, make sure it is not parked.
-    if (pindex->nStatus.isOnParkedChain()) {
-        UnparkBlock(pindex);
-    }
-
-    // If the finalized block is not on the active chain, we may need to rewind.
-    if (!::ChainActive().Contains(pindex)) {
-        const CBlockIndex *pindexFork = ::ChainActive().FindFork(pindex);
-        CBlockIndex *pindexToInvalidate = ::ChainActive().Next(pindexFork);
-        if (pindexToInvalidate) {
-            return InvalidateBlock(config, state, pindexToInvalidate);
-        }
-    }
-
-    return true;
-}
-
-bool InvalidateBlock(const Config &config, CValidationState &state,
+bool InvalidateBlock(const Config &config, BlockValidationState &state,
                      CBlockIndex *pindex) {
     return ::ChainstateActive().UnwindBlock(config, state, pindex, true);
 }
 
-bool ParkBlock(const Config &config, CValidationState &state,
+bool ParkBlock(const Config &config, BlockValidationState &state,
                CBlockIndex *pindex) {
     return ::ChainstateActive().UnwindBlock(config, state, pindex, false);
 }
@@ -3395,8 +3349,8 @@
     return true;
 }
 
-static bool FindUndoPos(CValidationState &state, int nFile, FlatFilePos &pos,
-                        unsigned int nAddSize) {
+static bool FindUndoPos(BlockValidationState &state, int nFile,
+                        FlatFilePos &pos, unsigned int nAddSize) {
     pos.nFile = nFile;
 
     LOCK(cs_LastBlockFile);
@@ -3427,21 +3381,22 @@
  * Do not call this for any check that depends on the context.
  * For context-dependent calls, see ContextualCheckBlockHeader.
  */
-static bool CheckBlockHeader(const CBlockHeader &block, CValidationState &state,
+static bool CheckBlockHeader(const CBlockHeader &block,
+                             BlockValidationState &state,
                              const Consensus::Params &params,
                              BlockValidationOptions validationOptions) {
     // Check proof of work matches claimed amount
     if (validationOptions.shouldValidatePoW() &&
         !CheckProofOfWork(block.GetHash(), block.nBits, params)) {
-        return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_HEADER,
-                             false, REJECT_INVALID, "high-hash",
+        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER,
+                             REJECT_INVALID, "high-hash",
                              "proof of work failed");
     }
 
     return true;
 }
 
-bool CheckBlock(const CBlock &block, CValidationState &state,
+bool CheckBlock(const CBlock &block, BlockValidationState &state,
                 const Consensus::Params &params,
                 BlockValidationOptions validationOptions) {
     // These are checks that are independent of context.
@@ -3460,7 +3415,7 @@
         bool mutated;
         uint256 hashMerkleRoot2 = BlockMerkleRoot(block, &mutated);
         if (block.hashMerkleRoot != hashMerkleRoot2) {
-            return state.Invalid(ValidationInvalidReason::BLOCK_MUTATED, false,
+            return state.Invalid(BlockValidationResult::BLOCK_MUTATED,
                                  REJECT_INVALID, "bad-txnmrklroot",
                                  "hashMerkleRoot mismatch");
         }
@@ -3469,7 +3424,7 @@
         // sequences of transactions in a block without affecting the merkle
         // root of a block, while still invalidating it.
         if (mutated) {
-            return state.Invalid(ValidationInvalidReason::BLOCK_MUTATED, false,
+            return state.Invalid(BlockValidationResult::BLOCK_MUTATED,
                                  REJECT_INVALID, "bad-txns-duplicate",
                                  "duplicate transaction");
         }
@@ -3481,7 +3436,7 @@
 
     // First transaction must be coinbase.
     if (block.vtx.empty()) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              REJECT_INVALID, "bad-cb-missing",
                              "first tx is not coinbase");
     }
@@ -3491,37 +3446,39 @@
 
     // Bail early if there is no way this block is of reasonable size.
     if ((block.vtx.size() * MIN_TRANSACTION_SIZE) > nMaxBlockSize) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              REJECT_INVALID, "bad-blk-length",
                              "size limits failed");
     }
 
     auto currentBlockSize = ::GetSerializeSize(block, PROTOCOL_VERSION);
     if (currentBlockSize > nMaxBlockSize) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              REJECT_INVALID, "bad-blk-length",
                              "size limits failed");
     }
 
     // And a valid coinbase.
-    if (!CheckCoinbase(*block.vtx[0], state)) {
-        return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
-                             state.GetRejectCode(), state.GetRejectReason(),
+    TxValidationState tx_state;
+    if (!CheckCoinbase(*block.vtx[0], tx_state)) {
+        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                             tx_state.GetRejectCode(),
+                             tx_state.GetRejectReason(),
                              strprintf("Coinbase check failed (txid %s) %s",
                                        block.vtx[0]->GetId().ToString(),
-                                       state.GetDebugMessage()));
+                                       tx_state.GetDebugMessage()));
     }
 
     // Check transactions for regularity, skipping the first. Note that this
     // is the first time we check that all after the first are !IsCoinBase.
     for (size_t i = 1; i < block.vtx.size(); i++) {
         auto *tx = block.vtx[i].get();
-        if (!CheckRegularTransaction(*tx, state)) {
+        if (!CheckRegularTransaction(*tx, tx_state)) {
             return state.Invalid(
-                ValidationInvalidReason::CONSENSUS, false,
-                state.GetRejectCode(), state.GetRejectReason(),
+                BlockValidationResult::BLOCK_CONSENSUS,
+                tx_state.GetRejectCode(), tx_state.GetRejectReason(),
                 strprintf("Transaction check failed (txid %s) %s",
-                          tx->GetId().ToString(), state.GetDebugMessage()));
+                          tx->GetId().ToString(), tx_state.GetDebugMessage()));
         }
     }
 
@@ -3543,21 +3500,20 @@
  * in ConnectBlock().
  * Note that -reindex-chainstate skips the validation that happens here!
  */
-static bool
-ContextualCheckBlockHeader(const CChainParams &params,
-                           const CBlockHeader &block, CValidationState &state,
-                           const CBlockIndex *pindexPrev, int64_t nAdjustedTime)
+static bool ContextualCheckBlockHeader(const CChainParams &params,
+                                       const CBlockHeader &block,
+                                       BlockValidationState &state,
+                                       const CBlockIndex *pindexPrev,
+                                       int64_t nAdjustedTime)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     assert(pindexPrev != nullptr);
     const int nHeight = pindexPrev->nHeight + 1;
 
     // Check proof of work
-    const Consensus::Params &consensusParams = params.GetConsensus();
-    if (block.nBits !=
-        GetNextWorkRequired(pindexPrev, &block, consensusParams)) {
+    if (block.nBits != GetNextWorkRequired(pindexPrev, &block, params)) {
         LogPrintf("bad bits after height: %d\n", pindexPrev->nHeight);
-        return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_HEADER,
-                             false, REJECT_INVALID, "bad-diffbits",
+        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER,
+                             REJECT_INVALID, "bad-diffbits",
                              "incorrect proof of work");
     }
 
@@ -3568,11 +3524,10 @@
         // Check that the block chain matches the known block chain up to a
         // checkpoint.
         if (!Checkpoints::CheckBlock(checkpoints, nHeight, block.GetHash())) {
-            return state.Invalid(
-                ValidationInvalidReason::BLOCK_CHECKPOINT,
-                error("%s: rejected by checkpoint lock-in at %d", __func__,
-                      nHeight),
-                REJECT_CHECKPOINT, "checkpoint mismatch");
+            LogPrintf("ERROR: %s: rejected by checkpoint lock-in at %d\n",
+                      __func__, nHeight);
+            return state.Invalid(BlockValidationResult::BLOCK_CHECKPOINT,
+                                 REJECT_CHECKPOINT, "checkpoint mismatch");
         }
 
         // Don't accept any forks from the main chain prior to last checkpoint.
@@ -3580,24 +3535,25 @@
         // in our MapBlockIndex.
         CBlockIndex *pcheckpoint = Checkpoints::GetLastCheckpoint(checkpoints);
         if (pcheckpoint && nHeight < pcheckpoint->nHeight) {
-            return state.Invalid(
-                ValidationInvalidReason::BLOCK_CHECKPOINT,
-                error("%s: forked chain older than last checkpoint (height %d)",
-                      __func__, nHeight),
-                REJECT_CHECKPOINT, "bad-fork-prior-to-checkpoint");
+            LogPrintf("ERROR: %s: forked chain older than last checkpoint "
+                      "(height %d)\n",
+                      __func__, nHeight);
+            return state.Invalid(BlockValidationResult::BLOCK_CHECKPOINT,
+                                 REJECT_CHECKPOINT,
+                                 "bad-fork-prior-to-checkpoint");
         }
     }
 
     // Check timestamp against prev
     if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast()) {
-        return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_HEADER,
-                             false, REJECT_INVALID, "time-too-old",
+        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER,
+                             REJECT_INVALID, "time-too-old",
                              "block's timestamp is too early");
     }
 
     // Check timestamp
     if (block.GetBlockTime() > nAdjustedTime + MAX_FUTURE_BLOCK_TIME) {
-        return state.Invalid(ValidationInvalidReason::BLOCK_TIME_FUTURE, false,
+        return state.Invalid(BlockValidationResult::BLOCK_TIME_FUTURE,
                              REJECT_INVALID, "time-too-new",
                              "block timestamp too far in the future");
     }
@@ -3605,12 +3561,13 @@
     // Reject outdated version blocks when 95% (75% on testnet) of the network
     // has upgraded:
     // check for version 2, 3 and 4 upgrades
+    const Consensus::Params &consensusParams = params.GetConsensus();
     if ((block.nVersion < 2 && nHeight >= consensusParams.BIP34Height) ||
         (block.nVersion < 3 && nHeight >= consensusParams.BIP66Height) ||
         (block.nVersion < 4 && nHeight >= consensusParams.BIP65Height)) {
         return state.Invalid(
-            ValidationInvalidReason::BLOCK_INVALID_HEADER, false,
-            REJECT_OBSOLETE, strprintf("bad-version(0x%08x)", block.nVersion),
+            BlockValidationResult::BLOCK_INVALID_HEADER, REJECT_OBSOLETE,
+            strprintf("bad-version(0x%08x)", block.nVersion),
             strprintf("rejected nVersion=0x%08x block", block.nVersion));
     }
 
@@ -3619,7 +3576,7 @@
 
 bool ContextualCheckTransactionForCurrentBlock(const Consensus::Params &params,
                                                const CTransaction &tx,
-                                               CValidationState &state,
+                                               TxValidationState &state,
                                                int flags) {
     AssertLockHeld(cs_main);
 
@@ -3662,7 +3619,8 @@
  * in ConnectBlock().
  * Note that -reindex-chainstate skips the validation that happens here!
  */
-static bool ContextualCheckBlock(const CBlock &block, CValidationState &state,
+static bool ContextualCheckBlock(const CBlock &block,
+                                 BlockValidationState &state,
                                  const Consensus::Params &params,
                                  const CBlockIndex *pindexPrev) {
     const int nHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
@@ -3697,14 +3655,14 @@
         if (fIsMagneticAnomalyEnabled) {
             if (prevTx && (tx.GetId() <= prevTx->GetId())) {
                 if (tx.GetId() == prevTx->GetId()) {
-                    return state.Invalid(ValidationInvalidReason::CONSENSUS,
-                                         false, REJECT_INVALID, "tx-duplicate",
+                    return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                                         REJECT_INVALID, "tx-duplicate",
                                          strprintf("Duplicated transaction %s",
                                                    tx.GetId().ToString()));
                 }
 
                 return state.Invalid(
-                    ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID,
+                    BlockValidationResult::BLOCK_CONSENSUS, REJECT_INVALID,
                     "tx-ordering",
                     strprintf("Transaction order is invalid (%s < %s)",
                               tx.GetId().ToString(),
@@ -3716,10 +3674,12 @@
             }
         }
 
-        if (!ContextualCheckTransaction(params, tx, state, nHeight,
+        TxValidationState tx_state;
+        if (!ContextualCheckTransaction(params, tx, tx_state, nHeight,
                                         nLockTimeCutoff, nMedianTimePast)) {
-            // state set by ContextualCheckTransaction.
-            return false;
+            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                                 REJECT_INVALID, tx_state.GetRejectReason(),
+                                 tx_state.GetDebugMessage());
         }
     }
 
@@ -3729,7 +3689,7 @@
         if (block.vtx[0]->vin[0].scriptSig.size() < expect.size() ||
             !std::equal(expect.begin(), expect.end(),
                         block.vtx[0]->vin[0].scriptSig.begin())) {
-            return state.Invalid(ValidationInvalidReason::CONSENSUS, false,
+            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                                  REJECT_INVALID, "bad-cb-height",
                                  "block height mismatch in coinbase");
         }
@@ -3745,7 +3705,7 @@
  */
 bool CChainState::AcceptBlockHeader(const Config &config,
                                     const CBlockHeader &block,
-                                    CValidationState &state,
+                                    BlockValidationState &state,
                                     CBlockIndex **ppindex) {
     AssertLockHeld(cs_main);
     const CChainParams &chainparams = config.GetChainParams();
@@ -3763,10 +3723,11 @@
             }
 
             if (pindex->nStatus.isInvalid()) {
-                return state.Invalid(ValidationInvalidReason::CACHED_INVALID,
-                                     error("%s: block %s is marked invalid",
-                                           __func__, hash.ToString()),
-                                     0, "duplicate");
+                LogPrintf("ERROR: %s: block %s is marked invalid\n", __func__,
+                          hash.ToString());
+                return state.Invalid(
+                    BlockValidationResult::BLOCK_CACHED_INVALID, 0,
+                    "duplicate");
             }
 
             return true;
@@ -3781,16 +3742,16 @@
         // Get prev block index
         BlockMap::iterator mi = mapBlockIndex.find(block.hashPrevBlock);
         if (mi == mapBlockIndex.end()) {
-            return state.Invalid(ValidationInvalidReason::BLOCK_MISSING_PREV,
-                                 error("%s: prev block not found", __func__), 0,
+            LogPrintf("ERROR: %s: prev block not found\n", __func__);
+            return state.Invalid(BlockValidationResult::BLOCK_MISSING_PREV, 0,
                                  "prev-blk-not-found");
         }
 
         CBlockIndex *pindexPrev = (*mi).second;
         assert(pindexPrev);
         if (pindexPrev->nStatus.isInvalid()) {
-            return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_PREV,
-                                 error("%s: prev block invalid", __func__),
+            LogPrintf("ERROR: %s: prev block invalid\n", __func__);
+            return state.Invalid(BlockValidationResult::BLOCK_INVALID_PREV,
                                  REJECT_INVALID, "bad-prevblk");
         }
 
@@ -3835,9 +3796,9 @@
                         setDirtyBlockIndex.insert(invalid_walk);
                         invalid_walk = invalid_walk->pprev;
                     }
+                    LogPrintf("ERROR: %s: prev block invalid\n", __func__);
                     return state.Invalid(
-                        ValidationInvalidReason::BLOCK_INVALID_PREV,
-                        error("%s: prev block invalid", __func__),
+                        BlockValidationResult::BLOCK_INVALID_PREV,
                         REJECT_INVALID, "bad-prevblk");
                 }
             }
@@ -3859,13 +3820,8 @@
 // Exposed wrapper for AcceptBlockHeader
 bool ProcessNewBlockHeaders(const Config &config,
                             const std::vector<CBlockHeader> &headers,
-                            CValidationState &state,
-                            const CBlockIndex **ppindex,
-                            CBlockHeader *first_invalid) {
-    if (first_invalid != nullptr) {
-        first_invalid->SetNull();
-    }
-
+                            BlockValidationState &state,
+                            const CBlockIndex **ppindex) {
     {
         LOCK(cs_main);
         for (const CBlockHeader &header : headers) {
@@ -3873,9 +3829,6 @@
             CBlockIndex *pindex = nullptr;
             if (!::ChainstateActive().AcceptBlockHeader(config, header, state,
                                                         &pindex)) {
-                if (first_invalid) {
-                    *first_invalid = header;
-                }
                 return false;
             }
 
@@ -3928,7 +3881,7 @@
  */
 bool CChainState::AcceptBlock(const Config &config,
                               const std::shared_ptr<const CBlock> &pblock,
-                              CValidationState &state, bool fRequested,
+                              BlockValidationState &state, bool fRequested,
                               const FlatFilePos *dbp, bool *fNewBlock) {
     AssertLockHeld(cs_main);
 
@@ -4021,9 +3974,8 @@
     if (!CheckBlock(block, state, consensusParams,
                     BlockValidationOptions(config)) ||
         !ContextualCheckBlock(block, state, consensusParams, pindex->pprev)) {
-        assert(IsBlockReason(state.GetReason()));
         if (state.IsInvalid() &&
-            state.GetReason() != ValidationInvalidReason::BLOCK_MUTATED) {
+            state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {
             pindex->nStatus = pindex->nStatus.withFailed();
             setDirtyBlockIndex.insert(pindex);
         }
@@ -4090,7 +4042,7 @@
             *fNewBlock = false;
         }
 
-        CValidationState state;
+        BlockValidationState state;
 
         // CheckBlock() does not support multi-threaded block validation
         // because CBlock::fChecked can cause data race.
@@ -4119,7 +4071,7 @@
     NotifyHeaderTip();
 
     // Only used to report errors, not invalidity - ignore it
-    CValidationState state;
+    BlockValidationState state;
     if (!::ChainstateActive().ActivateBestChain(config, state, pblock)) {
         return error("%s: ActivateBestChain failed (%s)", __func__,
                      FormatStateMessage(state));
@@ -4128,7 +4080,7 @@
     return true;
 }
 
-bool TestBlockValidity(CValidationState &state, const CChainParams &params,
+bool TestBlockValidity(BlockValidationState &state, const CChainParams &params,
                        const CBlock &block, CBlockIndex *pindexPrev,
                        BlockValidationOptions validationOptions) {
     AssertLockHeld(cs_main);
@@ -4265,7 +4217,7 @@
 
 /* This function is called from the RPC code for pruneblockchain */
 void PruneBlockFilesManual(int nManualPruneHeight) {
-    CValidationState state;
+    BlockValidationState state;
     const CChainParams &chainparams = Params();
     if (!::ChainstateActive().FlushStateToDisk(
             chainparams, state, FlushStateMode::NONE, nManualPruneHeight)) {
@@ -4598,7 +4550,7 @@
     CBlockIndex *pindex;
     CBlockIndex *pindexFailure = nullptr;
     int nGoodTransactions = 0;
-    CValidationState state;
+    BlockValidationState state;
     int reportDone = 0;
     LogPrintfToBeContinued("[0%%]...");
     for (pindex = ::ChainActive().Tip(); pindex && pindex->pprev;
@@ -5046,7 +4998,7 @@
                     // process in case the block isn't known yet
                     CBlockIndex *pindex = LookupBlockIndex(hash);
                     if (!pindex || !pindex->nStatus.hasData()) {
-                        CValidationState state;
+                        BlockValidationState state;
                         if (::ChainstateActive().AcceptBlock(
                                 config, pblock, state, true, dbp, nullptr)) {
                             nLoaded++;
@@ -5067,7 +5019,7 @@
                 // Activate the genesis block so normal node progress can
                 // continue
                 if (hash == chainparams.GetConsensus().hashGenesisBlock) {
-                    CValidationState state;
+                    BlockValidationState state;
                     if (!ActivateBestChain(config, state)) {
                         break;
                     }
@@ -5098,7 +5050,7 @@
                                 __func__, pblockrecursive->GetHash().ToString(),
                                 head.ToString());
                             LOCK(cs_main);
-                            CValidationState dummy;
+                            BlockValidationState dummy;
                             if (::ChainstateActive().AcceptBlock(
                                     config, pblockrecursive, dummy, true,
                                     &it->second, nullptr)) {
@@ -5532,12 +5484,11 @@
             if (amountdelta != Amount::zero()) {
                 pool.PrioritiseTransaction(tx->GetId(), amountdelta);
             }
-            CValidationState state;
+            TxValidationState state;
             if (nTime + nExpiryTimeout > nNow) {
                 LOCK(cs_main);
                 AcceptToMemoryPoolWithTime(
-                    config, pool, state, tx, nullptr /* pfMissingInputs */,
-                    nTime, false /* bypass_limits */,
+                    config, pool, state, tx, nTime, false /* bypass_limits */,
                     Amount::zero() /* nAbsurdFee */, false /* test_accept */);
                 if (state.IsValid()) {
                     ++count;
diff -Nru bitcoinabc-0.21.11/src/validation.h bitcoinabc-0.21.12/src/validation.h
--- bitcoinabc-0.21.11/src/validation.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/validation.h	2020-07-15 16:44:37.000000000 +0000
@@ -34,6 +34,7 @@
 #include <utility>
 #include <vector>
 
+class BlockValidationState;
 class CBlockIndex;
 class CBlockTreeDB;
 class CBlockUndo;
@@ -46,8 +47,8 @@
 class CScriptCheck;
 class CTxMemPool;
 class CTxUndo;
-class CValidationState;
 class DisconnectedBlockTransactions;
+class TxValidationState;
 
 struct ChainTxData;
 struct FlatFilePos;
@@ -311,14 +312,12 @@
  *                           occurred processing them.
  * @param[out] ppindex       If set, the pointer will be set to point to the
  *                           last new block index object for the given headers.
- * @param[out] first_invalid First header that fails validation, if one exists.
  * @return True if block headers were accepted as valid.
  */
 bool ProcessNewBlockHeaders(const Config &config,
                             const std::vector<CBlockHeader> &block,
-                            CValidationState &state,
-                            const CBlockIndex **ppindex = nullptr,
-                            CBlockHeader *first_invalid = nullptr)
+                            BlockValidationState &state,
+                            const CBlockIndex **ppindex = nullptr)
     LOCKS_EXCLUDED(cs_main);
 
 /**
@@ -379,7 +378,7 @@
  * validationinterface callback.
  */
 bool ActivateBestChain(
-    const Config &config, CValidationState &state,
+    const Config &config, BlockValidationState &state,
     std::shared_ptr<const CBlock> pblock = std::shared_ptr<const CBlock>());
 Amount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams);
 
@@ -412,9 +411,9 @@
  * (try to) add transaction to memory pool
  */
 bool AcceptToMemoryPool(const Config &config, CTxMemPool &pool,
-                        CValidationState &state, const CTransactionRef &tx,
-                        bool *pfMissingInputs, bool bypass_limits,
-                        const Amount nAbsurdFee, bool test_accept = false)
+                        TxValidationState &state, const CTransactionRef &tx,
+                        bool bypass_limits, const Amount nAbsurdFee,
+                        bool test_accept = false)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 /**
@@ -486,7 +485,7 @@
  * returned pvChecks must be executed exactly once in order to probe the limit
  * accurately.
  */
-bool CheckInputs(const CTransaction &tx, CValidationState &state,
+bool CheckInputs(const CTransaction &tx, TxValidationState &state,
                  const CCoinsViewCache &view, bool fScriptChecks,
                  const uint32_t flags, bool sigCacheStore,
                  bool scriptCacheStore,
@@ -500,7 +499,7 @@
  * Handy shortcut to full fledged CheckInputs call.
  */
 static inline bool
-CheckInputs(const CTransaction &tx, CValidationState &state,
+CheckInputs(const CTransaction &tx, TxValidationState &state,
             const CCoinsViewCache &view, bool fScriptChecks,
             const uint32_t flags, bool sigCacheStore, bool scriptCacheStore,
             const PrecomputedTransactionData &txdata, int &nSigChecksOut)
@@ -582,8 +581,7 @@
  */
 class CScriptCheck {
 private:
-    CScript scriptPubKey;
-    Amount amount;
+    CTxOut m_tx_out;
     const CTransaction *ptxTo;
     unsigned int nIn;
     uint32_t nFlags;
@@ -596,28 +594,25 @@
 
 public:
     CScriptCheck()
-        : amount(), ptxTo(nullptr), nIn(0), nFlags(0), cacheStore(false),
+        : ptxTo(nullptr), nIn(0), nFlags(0), cacheStore(false),
           error(ScriptError::UNKNOWN), txdata(), pTxLimitSigChecks(nullptr),
           pBlockLimitSigChecks(nullptr) {}
 
-    CScriptCheck(const CScript &scriptPubKeyIn, const Amount amountIn,
-                 const CTransaction &txToIn, unsigned int nInIn,
-                 uint32_t nFlagsIn, bool cacheIn,
+    CScriptCheck(const CTxOut &outIn, const CTransaction &txToIn,
+                 unsigned int nInIn, uint32_t nFlagsIn, bool cacheIn,
                  const PrecomputedTransactionData &txdataIn,
                  TxSigCheckLimiter *pTxLimitSigChecksIn = nullptr,
                  CheckInputsLimiter *pBlockLimitSigChecksIn = nullptr)
-        : scriptPubKey(scriptPubKeyIn), amount(amountIn), ptxTo(&txToIn),
-          nIn(nInIn), nFlags(nFlagsIn), cacheStore(cacheIn),
-          error(ScriptError::UNKNOWN), txdata(txdataIn),
+        : m_tx_out(outIn), ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn),
+          cacheStore(cacheIn), error(ScriptError::UNKNOWN), txdata(txdataIn),
           pTxLimitSigChecks(pTxLimitSigChecksIn),
           pBlockLimitSigChecks(pBlockLimitSigChecksIn) {}
 
     bool operator()();
 
     void swap(CScriptCheck &check) {
-        scriptPubKey.swap(check.scriptPubKey);
         std::swap(ptxTo, check.ptxTo);
-        std::swap(amount, check.amount);
+        std::swap(m_tx_out, check.m_tx_out);
         std::swap(nIn, check.nIn);
         std::swap(nFlags, check.nFlags);
         std::swap(cacheStore, check.cacheStore);
@@ -649,7 +644,7 @@
  * Returns true if the provided block is valid (has valid header,
  * transactions are valid, block is a valid size, etc.)
  */
-bool CheckBlock(const CBlock &block, CValidationState &state,
+bool CheckBlock(const CBlock &block, BlockValidationState &state,
                 const Consensus::Params &params,
                 BlockValidationOptions validationOptions);
 
@@ -661,14 +656,14 @@
  */
 bool ContextualCheckTransactionForCurrentBlock(const Consensus::Params &params,
                                                const CTransaction &tx,
-                                               CValidationState &state,
+                                               TxValidationState &state,
                                                int flags = -1);
 
 /**
  * Check a block is completely valid from start to finish (only works on top of
  * our current best block)
  */
-bool TestBlockValidity(CValidationState &state, const CChainParams &params,
+bool TestBlockValidity(BlockValidationState &state, const CChainParams &params,
                        const CBlock &block, CBlockIndex *pindexPrev,
                        BlockValidationOptions validationOptions)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main);
@@ -789,7 +784,7 @@
      * anything besides checking if we need to prune.
      */
     bool FlushStateToDisk(const CChainParams &chainparams,
-                          CValidationState &state, FlushStateMode mode,
+                          BlockValidationState &state, FlushStateMode mode,
                           int nManualPruneHeight = 0);
 
     //! Unconditionally flush all changes to disk.
@@ -800,7 +795,7 @@
     void PruneAndFlush();
 
     bool ActivateBestChain(
-        const Config &config, CValidationState &state,
+        const Config &config, BlockValidationState &state,
         std::shared_ptr<const CBlock> pblock = std::shared_ptr<const CBlock>());
 
     /**
@@ -809,11 +804,11 @@
      * mapBlockIndex.
      */
     bool AcceptBlockHeader(const Config &config, const CBlockHeader &block,
-                           CValidationState &state, CBlockIndex **ppindex)
+                           BlockValidationState &state, CBlockIndex **ppindex)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     bool AcceptBlock(const Config &config,
                      const std::shared_ptr<const CBlock> &pblock,
-                     CValidationState &state, bool fRequested,
+                     BlockValidationState &state, bool fRequested,
                      const FlatFilePos *dbp, bool *fNewBlock)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
@@ -821,21 +816,27 @@
     DisconnectResult DisconnectBlock(const CBlock &block,
                                      const CBlockIndex *pindex,
                                      CCoinsViewCache &view);
-    bool ConnectBlock(const CBlock &block, CValidationState &state,
+    bool ConnectBlock(const CBlock &block, BlockValidationState &state,
                       CBlockIndex *pindex, CCoinsViewCache &view,
                       const CChainParams &params,
                       BlockValidationOptions options, bool fJustCheck = false)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     // Block disconnection on our pcoinsTip:
-    bool DisconnectTip(const CChainParams &params, CValidationState &state,
+    bool DisconnectTip(const CChainParams &params, BlockValidationState &state,
                        DisconnectedBlockTransactions *disconnectpool)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     // Manual block validity manipulation:
-    bool PreciousBlock(const Config &config, CValidationState &state,
+    bool PreciousBlock(const Config &config, BlockValidationState &state,
                        CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main);
-    bool UnwindBlock(const Config &config, CValidationState &state,
+    /**
+     * Finalize a block.
+     * A finalized block can not be reorged in any way.
+     */
+    bool FinalizeBlock(const Config &config, BlockValidationState &state,
+                       CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool UnwindBlock(const Config &config, BlockValidationState &state,
                      CBlockIndex *pindex, bool invalidate);
     void ResetBlockFailureFlags(CBlockIndex *pindex)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
@@ -864,12 +865,13 @@
     bool IsInitialBlockDownload() const;
 
 private:
-    bool ActivateBestChainStep(const Config &config, CValidationState &state,
+    bool ActivateBestChainStep(const Config &config,
+                               BlockValidationState &state,
                                CBlockIndex *pindexMostWork,
                                const std::shared_ptr<const CBlock> &pblock,
                                bool &fInvalidFound, ConnectTrace &connectTrace)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    bool ConnectTip(const Config &config, CValidationState &state,
+    bool ConnectTip(const Config &config, BlockValidationState &state,
                     CBlockIndex *pindexNew,
                     const std::shared_ptr<const CBlock> &pblock,
                     ConnectTrace &connectTrace,
@@ -878,6 +880,10 @@
 
     CBlockIndex *AddToBlockIndex(const CBlockHeader &block)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    bool MarkBlockAsFinal(const Config &config, BlockValidationState &state,
+                          const CBlockIndex *pindex)
+        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+
     /** Create a new block index entry for a given block hash */
     CBlockIndex *InsertBlockIndex(const BlockHash &hash)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
@@ -889,7 +895,8 @@
      */
     void CheckBlockIndex(const Consensus::Params &consensusParams);
 
-    void InvalidBlockFound(CBlockIndex *pindex, const CValidationState &state)
+    void InvalidBlockFound(CBlockIndex *pindex,
+                           const BlockValidationState &state)
         EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     CBlockIndex *FindMostWorkChain() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     void ReceivedBlockTransactions(const CBlock &block, CBlockIndex *pindexNew,
@@ -906,23 +913,15 @@
  *
  * May not be called in a validationinterface callback.
  */
-bool PreciousBlock(const Config &config, CValidationState &state,
+bool PreciousBlock(const Config &config, BlockValidationState &state,
                    CBlockIndex *pindex) LOCKS_EXCLUDED(cs_main);
 
-/**
- * Mark a block as finalized.
- * A finalized block can not be reorged in any way.
- */
-bool FinalizeBlockAndInvalidate(const Config &config, CValidationState &state,
-                                CBlockIndex *pindex)
-    EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-
 /** Mark a block as invalid. */
-bool InvalidateBlock(const Config &config, CValidationState &state,
+bool InvalidateBlock(const Config &config, BlockValidationState &state,
                      CBlockIndex *pindex);
 
 /** Park a block. */
-bool ParkBlock(const Config &config, CValidationState &state,
+bool ParkBlock(const Config &config, BlockValidationState &state,
                CBlockIndex *pindex);
 
 /** Remove invalidity status from a block and its descendants. */
diff -Nru bitcoinabc-0.21.11/src/validationinterface.cpp bitcoinabc-0.21.12/src/validationinterface.cpp
--- bitcoinabc-0.21.11/src/validationinterface.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/validationinterface.cpp	2020-07-15 16:44:34.000000000 +0000
@@ -259,7 +259,7 @@
 }
 
 void CMainSignals::BlockChecked(const CBlock &block,
-                                const CValidationState &state) {
+                                const BlockValidationState &state) {
     LOG_EVENT("%s: block hash=%s state=%s", __func__,
               block.GetHash().ToString(), FormatStateMessage(state));
     m_internals->Iterate([&](CValidationInterface &callbacks) {
diff -Nru bitcoinabc-0.21.11/src/validationinterface.h bitcoinabc-0.21.12/src/validationinterface.h
--- bitcoinabc-0.21.11/src/validationinterface.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/validationinterface.h	2020-07-15 16:44:34.000000000 +0000
@@ -13,13 +13,13 @@
 #include <memory>
 
 extern RecursiveMutex cs_main;
+class BlockValidationState;
 class CBlock;
 class CBlockIndex;
 struct CBlockLocator;
 class CBlockIndex;
 class CConnman;
 class CValidationInterface;
-class CValidationState;
 class uint256;
 class CScheduler;
 
@@ -150,11 +150,11 @@
     virtual void ChainStateFlushed(const CBlockLocator &locator) {}
     /**
      * Notifies listeners of a block validation result.
-     * If the provided CValidationState IsValid, the provided block
+     * If the provided BlockValidationState IsValid, the provided block
      * is guaranteed to be the current best block at the time the
      * callback was generated (not necessarily now)
      */
-    virtual void BlockChecked(const CBlock &, const CValidationState &) {}
+    virtual void BlockChecked(const CBlock &, const BlockValidationState &) {}
     /**
      * Notifies listeners that a block which builds directly on our current tip
      * has been received and connected to the headers tree, though not validated
@@ -203,7 +203,7 @@
                    const std::shared_ptr<const std::vector<CTransactionRef>> &);
     void BlockDisconnected(const std::shared_ptr<const CBlock> &);
     void ChainStateFlushed(const CBlockLocator &);
-    void BlockChecked(const CBlock &, const CValidationState &);
+    void BlockChecked(const CBlock &, const BlockValidationState &);
     void NewPoWValidBlock(const CBlockIndex *,
                           const std::shared_ptr<const CBlock> &);
 };
diff -Nru bitcoinabc-0.21.11/src/versionbitsinfo.cpp bitcoinabc-0.21.12/src/versionbitsinfo.cpp
--- bitcoinabc-0.21.11/src/versionbitsinfo.cpp	2020-06-30 00:18:54.000000000 +0000
+++ bitcoinabc-0.21.12/src/versionbitsinfo.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -12,20 +12,4 @@
             /*.name =*/"testdummy",
             /*.gbt_force =*/true,
         },
-        {
-            /*.name =*/"minerfund",
-            /*.gbt_force =*/true,
-        },
-        {
-            /*.name =*/"minerfundabc",
-            /*.gbt_force =*/true,
-        },
-        {
-            /*.name =*/"minerfundbchd",
-            /*.gbt_force =*/true,
-        },
-        {
-            /*.name =*/"minerfundelectroncash",
-            /*.gbt_force =*/true,
-        },
 };
diff -Nru bitcoinabc-0.21.11/src/wallet/db.cpp bitcoinabc-0.21.12/src/wallet/db.cpp
--- bitcoinabc-0.21.11/src/wallet/db.cpp	2020-06-30 00:19:22.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/db.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -95,6 +95,13 @@
     return database && database->IsDatabaseLoaded(database_filename);
 }
 
+fs::path WalletDataFilePath(const fs::path &wallet_path) {
+    fs::path env_directory;
+    std::string database_filename;
+    SplitWalletPath(wallet_path, env_directory, database_filename);
+    return env_directory / database_filename;
+}
+
 /**
  * @param[in] wallet_path Path to wallet directory. Or (for backwards
  * compatibility only) a path to a berkeley btree data file inside a wallet
@@ -612,7 +619,7 @@
             if (fCreate && !Exists(std::string("version"))) {
                 bool fTmp = fReadOnly;
                 fReadOnly = false;
-                WriteVersion(CLIENT_VERSION);
+                Write(std::string("version"), CLIENT_VERSION);
                 fReadOnly = fTmp;
             }
         }
diff -Nru bitcoinabc-0.21.11/src/wallet/db.h bitcoinabc-0.21.12/src/wallet/db.h
--- bitcoinabc-0.21.11/src/wallet/db.h	2020-06-18 19:26:30.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/db.h	2020-07-27 15:24:34.000000000 +0000
@@ -104,6 +104,11 @@
 /** Return whether a wallet database is currently loaded. */
 bool IsWalletLoaded(const fs::path &wallet_path);
 
+/**
+ * Given a wallet directory path or legacy file path, return path to main data
+ * file in the wallet database. */
+fs::path WalletDataFilePath(const fs::path &wallet_path);
+
 /** Get BerkeleyEnvironment and database filename given a wallet path. */
 std::shared_ptr<BerkeleyEnvironment>
 GetWalletEnv(const fs::path &wallet_path, std::string &database_filename);
@@ -444,15 +449,6 @@
         return (ret == 0);
     }
 
-    bool ReadVersion(int &nVersion) {
-        nVersion = 0;
-        return Read(std::string("version"), nVersion);
-    }
-
-    bool WriteVersion(int nVersion) {
-        return Write(std::string("version"), nVersion);
-    }
-
     static bool Rewrite(BerkeleyDatabase &database,
                         const char *pszSkip = nullptr);
 };
diff -Nru bitcoinabc-0.21.11/src/wallet/fees.h bitcoinabc-0.21.12/src/wallet/fees.h
--- bitcoinabc-0.21.11/src/wallet/fees.h	2020-06-08 20:54:42.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/fees.h	2020-07-27 15:24:34.000000000 +0000
@@ -1,6 +1,6 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2017 The Bitcoin Core developers
-// Copyright (c) 2018-2019 The Bitcoin developers
+// Copyright (c) 2018-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff -Nru bitcoinabc-0.21.11/src/wallet/init.cpp bitcoinabc-0.21.12/src/wallet/init.cpp
--- bitcoinabc-0.21.11/src/wallet/init.cpp	2020-06-30 00:19:22.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/init.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -1,6 +1,6 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2017 The Bitcoin Core developers
-// Copyright (c) 2018-2019 The Bitcoin developers
+// Copyright (c) 2018-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff -Nru bitcoinabc-0.21.11/src/wallet/rpcdump.cpp bitcoinabc-0.21.12/src/wallet/rpcdump.cpp
--- bitcoinabc-0.21.11/src/wallet/rpcdump.cpp	2020-07-07 17:16:37.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/rpcdump.cpp	2020-07-28 23:45:00.000000000 +0000
@@ -160,9 +160,12 @@
             fRescan = request.params[2].get_bool();
         }
 
-        if (fRescan && pwallet->chain().getPruneMode()) {
+        if (fRescan && pwallet->chain().havePruned()) {
+            // Exit early and print an error.
+            // If a block is pruned after this check, we will import the key(s),
+            // but fail the rescan with a generic error.
             throw JSONRPCError(RPC_WALLET_ERROR,
-                               "Rescan is disabled in pruned mode");
+                               "Rescan is disabled when blocks are pruned");
         }
 
         if (fRescan && !reserver.reserve()) {
@@ -291,9 +294,12 @@
         fRescan = request.params[2].get_bool();
     }
 
-    if (fRescan && pwallet->chain().getPruneMode()) {
+    if (fRescan && pwallet->chain().havePruned()) {
+        // Exit early and print an error.
+        // If a block is pruned after this check, we will import the key(s),
+        // but fail the rescan with a generic error.
         throw JSONRPCError(RPC_WALLET_ERROR,
-                           "Rescan is disabled in pruned mode");
+                           "Rescan is disabled when blocks are pruned");
     }
 
     WalletRescanReserver reserver(pwallet);
@@ -538,9 +544,12 @@
         fRescan = request.params[2].get_bool();
     }
 
-    if (fRescan && pwallet->chain().getPruneMode()) {
+    if (fRescan && pwallet->chain().havePruned()) {
+        // Exit early and print an error.
+        // If a block is pruned after this check, we will import the key(s),
+        // but fail the rescan with a generic error.
         throw JSONRPCError(RPC_WALLET_ERROR,
-                           "Rescan is disabled in pruned mode");
+                           "Rescan is disabled when blocks are pruned");
     }
 
     WalletRescanReserver reserver(pwallet);
@@ -617,9 +626,13 @@
     }
         .Check(request);
 
-    if (pwallet->chain().getPruneMode()) {
-        throw JSONRPCError(RPC_WALLET_ERROR,
-                           "Importing wallets is disabled in pruned mode");
+    if (pwallet->chain().havePruned()) {
+        // Exit early and print an error.
+        // If a block is pruned after this check, we will import the key(s),
+        // but fail the rescan with a generic error.
+        throw JSONRPCError(
+            RPC_WALLET_ERROR,
+            "Importing wallets is disabled when blocks are pruned");
     }
 
     WalletRescanReserver reserver(pwallet);
diff -Nru bitcoinabc-0.21.11/src/wallet/rpcwallet.cpp bitcoinabc-0.21.12/src/wallet/rpcwallet.cpp
--- bitcoinabc-0.21.11/src/wallet/rpcwallet.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/rpcwallet.cpp	2020-07-28 23:45:00.000000000 +0000
@@ -373,7 +373,7 @@
         }
         throw JSONRPCError(RPC_WALLET_ERROR, strError);
     }
-    CValidationState state;
+    TxValidationState state;
     if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */,
                                     state)) {
         strError =
@@ -695,7 +695,7 @@
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
 
-        CValidationState state;
+        TxValidationState state;
         if (wtx.IsCoinBase() ||
             !locked_chain->contextualCheckTransactionForCurrentBlock(
                 config.GetChainParams().GetConsensus(), *wtx.tx, state)) {
@@ -769,7 +769,7 @@
     Amount nAmount = Amount::zero();
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
-        CValidationState state;
+        TxValidationState state;
         if (wtx.IsCoinBase() ||
             !locked_chain->contextualCheckTransactionForCurrentBlock(
                 config.GetChainParams().GetConsensus(), *wtx.tx, state)) {
@@ -1062,7 +1062,7 @@
     if (!fCreated) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, strFailReason);
     }
-    CValidationState state;
+    TxValidationState state;
     if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */,
                                     state)) {
         strFailReason = strprintf("Transaction commit failed:: %s",
@@ -1210,7 +1210,7 @@
     for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
         const CWalletTx &wtx = pairWtx.second;
 
-        CValidationState state;
+        TxValidationState state;
         if (wtx.IsCoinBase() ||
             !locked_chain.contextualCheckTransactionForCurrentBlock(
                 config.GetChainParams().GetConsensus(), *wtx.tx, state)) {
@@ -1690,28 +1690,11 @@
         nCount = ret.size() - nFrom;
     }
 
-    std::vector<UniValue> arrTmp = ret.getValues();
-
-    std::vector<UniValue>::iterator first = arrTmp.begin();
-    std::advance(first, nFrom);
-    std::vector<UniValue>::iterator last = arrTmp.begin();
-    std::advance(last, nFrom + nCount);
-
-    if (last != arrTmp.end()) {
-        arrTmp.erase(last, arrTmp.end());
-    }
-    if (first != arrTmp.begin()) {
-        arrTmp.erase(arrTmp.begin(), first);
-    }
-
+    const std::vector<UniValue> &txs = ret.getValues();
+    UniValue result{UniValue::VARR};
     // Return oldest to newest
-    std::reverse(arrTmp.begin(), arrTmp.end());
-
-    ret.clear();
-    ret.setArray();
-    ret.push_backV(arrTmp);
-
-    return ret;
+    result.push_backV({txs.rend() - nFrom - nCount, txs.rend() - nFrom});
+    return result;
 }
 
 static UniValue listsinceblock(const Config &config,
@@ -2882,6 +2865,14 @@
             "  \"private_keys_enabled\": true|false (boolean) false if "
             "privatekeys are disabled for this wallet (enforced watch-only "
             "wallet)\n"
+            "  \"scanning\":                        (json object) current "
+            "scanning details, or false if no scan is in progress\n"
+            "    {\n"
+            "      \"duration\" : xxxx              (numeric) elapsed seconds "
+            "since scan start\n"
+            "      \"progress\" : x.xxxx,           (numeric) scanning "
+            "progress percentage [0.0, 1.0]\n"
+            "    }\n"
             "  \"avoid_reuse\": true|false          (boolean) whether this "
             "wallet tracks clean/dirty coins in terms of reuse\n"
             "}\n"},
@@ -2924,6 +2915,14 @@
     }
     obj.pushKV("private_keys_enabled",
                !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
+    if (pwallet->IsScanning()) {
+        UniValue scanning(UniValue::VOBJ);
+        scanning.pushKV("duration", pwallet->ScanningDuration() / 1000);
+        scanning.pushKV("progress", pwallet->ScanningProgress());
+        obj.pushKV("scanning", scanning);
+    } else {
+        obj.pushKV("scanning", false);
+    }
     obj.pushKV("avoid_reuse",
                pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE));
     return obj;
diff -Nru bitcoinabc-0.21.11/src/wallet/test/walletdb_tests.cpp bitcoinabc-0.21.12/src/wallet/test/walletdb_tests.cpp
--- bitcoinabc-0.21.11/src/wallet/test/walletdb_tests.cpp	2020-07-07 17:16:37.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/test/walletdb_tests.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019 The Bitcoin developers
+// Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
diff -Nru bitcoinabc-0.21.11/src/wallet/test/wallet_tests.cpp bitcoinabc-0.21.12/src/wallet/test/wallet_tests.cpp
--- bitcoinabc-0.21.11/src/wallet/test/wallet_tests.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/test/wallet_tests.cpp	2020-07-28 23:45:00.000000000 +0000
@@ -364,6 +364,86 @@
     BOOST_CHECK_EQUAL(values[1], "val_rr1");
 }
 
+// Test some watch-only wallet methods by the procedure of loading
+// (LoadWatchOnly), checking (HaveWatchOnly), getting (GetWatchPubKey) and
+// removing (RemoveWatchOnly) a given PubKey, resp. its corresponding P2PK
+// Script. Results of the the impact on the address -> PubKey map is dependent
+// on whether the PubKey is a point on the curve
+static void TestWatchOnlyPubKey(CWallet &wallet, const CPubKey &add_pubkey) {
+    CScript p2pk = GetScriptForRawPubKey(add_pubkey);
+    CKeyID add_address = add_pubkey.GetID();
+    CPubKey found_pubkey;
+    LOCK(wallet.cs_wallet);
+
+    // all Scripts (i.e. also all PubKeys) are added to the general watch-only
+    // set
+    BOOST_CHECK(!wallet.HaveWatchOnly(p2pk));
+    wallet.LoadWatchOnly(p2pk);
+    BOOST_CHECK(wallet.HaveWatchOnly(p2pk));
+
+    // only PubKeys on the curve shall be added to the watch-only address ->
+    // PubKey map
+    bool is_pubkey_fully_valid = add_pubkey.IsFullyValid();
+    if (is_pubkey_fully_valid) {
+        BOOST_CHECK(wallet.GetWatchPubKey(add_address, found_pubkey));
+        BOOST_CHECK(found_pubkey == add_pubkey);
+    } else {
+        BOOST_CHECK(!wallet.GetWatchPubKey(add_address, found_pubkey));
+        // passed key is unchanged
+        BOOST_CHECK(found_pubkey == CPubKey());
+    }
+
+    wallet.RemoveWatchOnly(p2pk);
+    BOOST_CHECK(!wallet.HaveWatchOnly(p2pk));
+
+    if (is_pubkey_fully_valid) {
+        BOOST_CHECK(!wallet.GetWatchPubKey(add_address, found_pubkey));
+        // passed key is unchanged
+        BOOST_CHECK(found_pubkey == add_pubkey);
+    }
+}
+
+// Cryptographically invalidate a PubKey whilst keeping length and first byte
+static void PollutePubKey(CPubKey &pubkey) {
+    std::vector<uint8_t> pubkey_raw(pubkey.begin(), pubkey.end());
+    std::fill(pubkey_raw.begin() + 1, pubkey_raw.end(), 0);
+    pubkey = CPubKey(pubkey_raw);
+    assert(!pubkey.IsFullyValid());
+    assert(pubkey.IsValid());
+}
+
+// Test watch-only wallet logic for PubKeys
+BOOST_AUTO_TEST_CASE(WatchOnlyPubKeys) {
+    CKey key;
+    CPubKey pubkey;
+
+    BOOST_CHECK(!m_wallet.HaveWatchOnly());
+
+    // uncompressed valid PubKey
+    key.MakeNewKey(false);
+    pubkey = key.GetPubKey();
+    assert(!pubkey.IsCompressed());
+    TestWatchOnlyPubKey(m_wallet, pubkey);
+
+    // uncompressed cryptographically invalid PubKey
+    PollutePubKey(pubkey);
+    TestWatchOnlyPubKey(m_wallet, pubkey);
+
+    // compressed valid PubKey
+    key.MakeNewKey(true);
+    pubkey = key.GetPubKey();
+    assert(pubkey.IsCompressed());
+    TestWatchOnlyPubKey(m_wallet, pubkey);
+
+    // compressed cryptographically invalid PubKey
+    PollutePubKey(pubkey);
+    TestWatchOnlyPubKey(m_wallet, pubkey);
+
+    // invalid empty PubKey
+    pubkey = CPubKey();
+    TestWatchOnlyPubKey(m_wallet, pubkey);
+}
+
 class ListCoinsTestingSetup : public TestChain100Setup {
 public:
     ListCoinsTestingSetup() {
@@ -401,7 +481,7 @@
             BOOST_CHECK(wallet->CreateTransaction(
                 *locked_chain, {recipient}, tx, fee, changePos, error, dummy));
         }
-        CValidationState state;
+        TxValidationState state;
         BOOST_CHECK(wallet->CommitTransaction(tx, {}, {}, state));
         CMutableTransaction blocktx;
         {
diff -Nru bitcoinabc-0.21.11/src/wallet/wallet.cpp bitcoinabc-0.21.12/src/wallet/wallet.cpp
--- bitcoinabc-0.21.11/src/wallet/wallet.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/wallet.cpp	2020-07-28 23:45:00.000000000 +0000
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2016 The Bitcoin Core developers
+// Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -7,7 +7,6 @@
 
 #include <chain.h>
 #include <chainparams.h>
-#include <checkpoints.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
@@ -280,7 +279,6 @@
 CPubKey CWallet::GenerateNewKey(WalletBatch &batch, bool internal) {
     assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     assert(!IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET));
-    // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     // default to compressed public keys if we want 0.6.0 wallets
     bool fCompressed = CanSupportFeature(FEATURE_COMPRPUBKEY);
@@ -395,7 +393,6 @@
 
 bool CWallet::AddKeyPubKeyWithDB(WalletBatch &batch, const CKey &secret,
                                  const CPubKey &pubkey) {
-    // mapKeyMetadata
     AssertLockHeld(cs_wallet);
 
     // Make sure we aren't adding private keys to private key disabled wallets
@@ -462,7 +459,6 @@
 }
 
 void CWallet::LoadKeyMetadata(const CKeyID &keyID, const CKeyMetadata &meta) {
-    // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     UpdateTimeFirstKey(meta.nCreateTime);
     mapKeyMetadata[keyID] = meta;
@@ -470,14 +466,12 @@
 
 void CWallet::LoadScriptMetadata(const CScriptID &script_id,
                                  const CKeyMetadata &meta) {
-    // m_script_metadata
     AssertLockHeld(cs_wallet);
     UpdateTimeFirstKey(meta.nCreateTime);
     m_script_metadata[script_id] = meta;
 }
 
 void CWallet::UpgradeKeyMetadata() {
-    // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     if (IsLocked() || IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
         return;
@@ -577,22 +571,9 @@
 }
 
 static bool ExtractPubKey(const CScript &dest, CPubKey &pubKeyOut) {
-    // TODO: Use Solver to extract this?
-    CScript::const_iterator pc = dest.begin();
-    opcodetype opcode;
-    std::vector<uint8_t> vch;
-    if (!dest.GetOp(pc, opcode, vch) || !CPubKey::ValidSize(vch)) {
-        return false;
-    }
-    pubKeyOut = CPubKey(vch);
-    if (!pubKeyOut.IsFullyValid()) {
-        return false;
-    }
-    if (!dest.GetOp(pc, opcode, vch) || opcode != OP_CHECKSIG ||
-        dest.GetOp(pc, opcode, vch)) {
-        return false;
-    }
-    return true;
+    std::vector<std::vector<uint8_t>> solutions;
+    return Solver(dest, solutions) == TX_PUBKEY &&
+           (pubKeyOut = CPubKey(solutions[0])).IsFullyValid();
 }
 
 bool CWallet::AddWatchOnlyInMem(const CScript &dest) {
@@ -782,7 +763,6 @@
 
 void CWallet::SetMinVersion(enum WalletFeature nVersion, WalletBatch *batch_in,
                             bool fExplicit) {
-    // nWalletVersion
     LOCK(cs_wallet);
     if (nWalletVersion >= nVersion) {
         return;
@@ -810,7 +790,6 @@
 }
 
 bool CWallet::SetMaxVersion(int nVersion) {
-    // nWalletVersion, nWalletMaxVersion
     LOCK(cs_wallet);
 
     // Cannot downgrade below current version
@@ -1019,6 +998,7 @@
         if (!EncryptKeys(_vMasterKey)) {
             encrypted_batch->TxnAbort();
             delete encrypted_batch;
+            encrypted_batch = nullptr;
             // We now probably have half of our keys encrypted in memory, and
             // half not... die and let the user reload the unencrypted wallet.
             assert(false);
@@ -1029,6 +1009,7 @@
 
         if (!encrypted_batch->TxnCommit()) {
             delete encrypted_batch;
+            encrypted_batch = nullptr;
             // We now have keys encrypted in memory, but not on disk...
             // die to avoid confusion and let the user reload the unencrypted
             // wallet.
@@ -1121,7 +1102,6 @@
 }
 
 int64_t CWallet::IncOrderPosNext(WalletBatch *batch) {
-    // nOrderPosNext
     AssertLockHeld(cs_wallet);
     int64_t nRet = nOrderPosNext++;
     if (batch) {
@@ -2216,16 +2196,14 @@
         }
         double progress_current = progress_begin;
         while (block_height && !fAbortRescan && !chain().shutdownRequested()) {
+            m_scanning_progress = (progress_current - progress_begin) /
+                                  (progress_end - progress_begin);
             if (*block_height % 100 == 0 &&
                 progress_end - progress_begin > 0.0) {
                 ShowProgress(
                     strprintf("%s " + _("Rescanning...").translated,
                               GetDisplayName()),
-                    std::max(
-                        1,
-                        std::min(99, (int)((progress_current - progress_begin) /
-                                           (progress_end - progress_begin) *
-                                           100))));
+                    std::max(1, std::min(99, int(m_scanning_progress * 100))));
             }
             if (GetTime() >= nNow + 60) {
                 nNow = GetTime();
@@ -2510,7 +2488,7 @@
 
 bool CWalletTx::IsTrusted(interfaces::Chain::Lock &locked_chain) const {
     // Quick answer in most cases
-    CValidationState state;
+    TxValidationState state;
     if (!locked_chain.contextualCheckTransactionForCurrentBlock(
             Params().GetConsensus(), *tx, state)) {
         return false;
@@ -2714,7 +2692,7 @@
         const TxId &wtxid = entry.first;
         const CWalletTx &wtx = entry.second;
 
-        CValidationState state;
+        TxValidationState state;
         if (!locked_chain.contextualCheckTransactionForCurrentBlock(
                 params, *wtx.tx, state)) {
             continue;
@@ -3103,6 +3081,7 @@
 }
 
 bool CWallet::SignTransaction(CMutableTransaction &tx) {
+    AssertLockHeld(cs_wallet);
     // sign the new tx
     int nIn = 0;
     for (CTxIn &input : tx.vin) {
@@ -3659,7 +3638,7 @@
 bool CWallet::CommitTransaction(
     CTransactionRef tx, mapValue_t mapValue,
     std::vector<std::pair<std::string, std::string>> orderForm,
-    CValidationState &state) {
+    TxValidationState &state) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
@@ -3736,7 +3715,6 @@
 
 DBErrors CWallet::ZapSelectTx(std::vector<TxId> &txIdsIn,
                               std::vector<TxId> &txIdsOut) {
-    // mapWallet
     AssertLockHeld(cs_wallet);
     DBErrors nZapSelectTxRet =
         WalletBatch(*database, "cr+").ZapSelectTx(txIdsIn, txIdsOut);
@@ -3892,7 +3870,6 @@
 }
 
 size_t CWallet::KeypoolCountExternalKeys() {
-    // setExternalKeyPool
     AssertLockHeld(cs_wallet);
     return setExternalKeyPool.size() + set_pre_split_keypool.size();
 }
@@ -3998,9 +3975,7 @@
     {
         LOCK(cs_wallet);
 
-        if (!IsLocked()) {
-            TopUpKeyPool();
-        }
+        TopUpKeyPool();
 
         bool fReturningInternal = fRequestedInternal;
         fReturningInternal &=
@@ -4100,9 +4075,8 @@
                                 CTxDestination &dest, std::string &error) {
     LOCK(cs_wallet);
     error.clear();
-    if (!IsLocked()) {
-        TopUpKeyPool();
-    }
+
+    TopUpKeyPool();
 
     // Generate a new key that is added to wallet
     CPubKey new_key;
@@ -4121,9 +4095,8 @@
                                       CTxDestination &dest,
                                       std::string &error) {
     error.clear();
-    if (!IsLocked()) {
-        TopUpKeyPool();
-    }
+
+    TopUpKeyPool();
 
     ReserveDestination reservedest(this);
     if (!reservedest.GetReservedDestination(type, dest, true)) {
@@ -4218,7 +4191,6 @@
 }
 
 std::set<std::set<CTxDestination>> CWallet::GetAddressGroupings() {
-    // mapWallet
     AssertLockHeld(cs_wallet);
     std::set<std::set<CTxDestination>> groupings;
     std::set<CTxDestination> grouping;
@@ -4416,32 +4388,27 @@
 }
 
 void CWallet::LockCoin(const COutPoint &output) {
-    // setLockedCoins
     AssertLockHeld(cs_wallet);
     setLockedCoins.insert(output);
 }
 
 void CWallet::UnlockCoin(const COutPoint &output) {
-    // setLockedCoins
     AssertLockHeld(cs_wallet);
     setLockedCoins.erase(output);
 }
 
 void CWallet::UnlockAllCoins() {
-    // setLockedCoins
     AssertLockHeld(cs_wallet);
     setLockedCoins.clear();
 }
 
 bool CWallet::IsLockedCoin(const COutPoint &outpoint) const {
-    // setLockedCoins
     AssertLockHeld(cs_wallet);
 
     return setLockedCoins.count(outpoint) > 0;
 }
 
 void CWallet::ListLockedCoins(std::vector<COutPoint> &vOutpts) const {
-    // setLockedCoins
     AssertLockHeld(cs_wallet);
     for (COutPoint outpoint : setLockedCoins) {
         vOutpts.push_back(outpoint);
@@ -4452,7 +4419,6 @@
 
 void CWallet::GetKeyBirthTimes(interfaces::Chain::Lock &locked_chain,
                                std::map<CKeyID, int64_t> &mapKeyBirth) const {
-    // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     mapKeyBirth.clear();
 
@@ -4716,7 +4682,8 @@
 std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(
     const CChainParams &chainParams, interfaces::Chain &chain,
     const WalletLocation &location, uint64_t wallet_creation_flags) {
-    const std::string &walletFile = location.GetName();
+    const std::string &walletFile =
+        WalletDataFilePath(location.GetPath()).string();
 
     // Needed to restore wallet transaction meta data after -zapwallettxes
     std::vector<CWalletTx> vWtx;
@@ -4781,7 +4748,7 @@
         }
     }
 
-    int prev_version = walletInstance->nWalletVersion;
+    int prev_version = walletInstance->GetVersion();
     if (gArgs.GetBoolArg("-upgradewallet", fFirstRun)) {
         int nMaxVersion = gArgs.GetArg("-upgradewallet", 0);
         // The -upgradewallet without argument case
@@ -4810,7 +4777,7 @@
 
         // Do not upgrade versions to any version between HD_SPLIT and
         // FEATURE_PRE_SPLIT_KEYPOOL unless already supporting HD_SPLIT
-        int max_version = walletInstance->nWalletVersion;
+        int max_version = walletInstance->GetVersion();
         if (!walletInstance->CanSupportFeature(FEATURE_HD_SPLIT) &&
             max_version >= FEATURE_HD_SPLIT &&
             max_version < FEATURE_PRE_SPLIT_KEYPOOL) {
@@ -5028,9 +4995,12 @@
     if (tip_height && *tip_height != rescan_height) {
         // We can't rescan beyond non-pruned blocks, stop and throw an error.
         // This might happen if a user uses an old wallet within a pruned node
-        // or if he ran -disablewallet for a longer time, then decided to
-        // re-enable.
-        if (chain.getPruneMode()) {
+        // or if they ran -disablewallet for a longer time, then decided to
+        // re-enable
+        if (chain.havePruned()) {
+            // Exit early and print an error.
+            // If a block is pruned after this check, we will load the wallet,
+            // but fail the rescan with a generic error.
             int block_height = *tip_height;
             while (block_height > 0 &&
                    locked_chain->haveBlockOnDisk(block_height - 1) &&
@@ -5158,11 +5128,6 @@
     m_pre_split = false;
 }
 
-CWalletKey::CWalletKey(int64_t nExpires) {
-    nTimeCreated = (nExpires ? GetTime() : 0);
-    nTimeExpires = nExpires;
-}
-
 void CMerkleTx::SetMerkleBranch(const BlockHash &block_hash, int posInBlock) {
     // Update the tx's hashBlock
     hashBlock = block_hash;
@@ -5186,8 +5151,10 @@
         return 0;
     }
 
-    return std::max(0, (COINBASE_MATURITY + 1) -
-                           GetDepthInMainChain(locked_chain));
+    int chain_depth = GetDepthInMainChain(locked_chain);
+    // coinbase tx should not be conflicted
+    assert(chain_depth >= 0);
+    return std::max(0, (COINBASE_MATURITY + 1) - chain_depth);
 }
 
 bool CMerkleTx::IsImmatureCoinBase(
diff -Nru bitcoinabc-0.21.11/src/wallet/walletdb.cpp bitcoinabc-0.21.12/src/wallet/walletdb.cpp
--- bitcoinabc-0.21.11/src/wallet/walletdb.cpp	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/walletdb.cpp	2020-07-27 15:24:34.000000000 +0000
@@ -1,6 +1,6 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
-// Copyright (c) 2017-2019 The Bitcoin developers
+// Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -20,6 +20,32 @@
 
 #include <atomic>
 
+namespace DBKeys {
+const std::string ACENTRY{"acentry"};
+const std::string BESTBLOCK_NOMERKLE{"bestblock_nomerkle"};
+const std::string BESTBLOCK{"bestblock"};
+const std::string CRYPTED_KEY{"ckey"};
+const std::string CSCRIPT{"cscript"};
+const std::string DEFAULTKEY{"defaultkey"};
+const std::string DESTDATA{"destdata"};
+const std::string FLAGS{"flags"};
+const std::string HDCHAIN{"hdchain"};
+const std::string KEYMETA{"keymeta"};
+const std::string KEY{"key"};
+const std::string MASTER_KEY{"mkey"};
+const std::string MINVERSION{"minversion"};
+const std::string NAME{"name"};
+const std::string OLD_KEY{"wkey"};
+const std::string ORDERPOSNEXT{"orderposnext"};
+const std::string POOL{"pool"};
+const std::string PURPOSE{"purpose"};
+const std::string SETTINGS{"settings"};
+const std::string TX{"tx"};
+const std::string VERSION{"version"};
+const std::string WATCHMETA{"watchmeta"};
+const std::string WATCHS{"watchs"};
+} // namespace DBKeys
+
 //
 // WalletBatch
 //
@@ -29,9 +55,9 @@
     if (!IsValidDestination(address)) {
         return false;
     }
-    return WriteIC(std::make_pair(std::string("name"),
-                                  EncodeLegacyAddr(address, Params())),
-                   strName);
+    return WriteIC(
+        std::make_pair(DBKeys::NAME, EncodeLegacyAddr(address, Params())),
+        strName);
 }
 
 bool WalletBatch::EraseName(const CTxDestination &address) {
@@ -41,8 +67,8 @@
     if (!IsValidDestination(address)) {
         return false;
     }
-    return EraseIC(std::make_pair(std::string("name"),
-                                  EncodeLegacyAddr(address, Params())));
+    return EraseIC(
+        std::make_pair(DBKeys::NAME, EncodeLegacyAddr(address, Params())));
 }
 
 bool WalletBatch::WritePurpose(const CTxDestination &address,
@@ -50,32 +76,31 @@
     if (!IsValidDestination(address)) {
         return false;
     }
-    return WriteIC(std::make_pair(std::string("purpose"),
-                                  EncodeLegacyAddr(address, Params())),
-                   strPurpose);
+    return WriteIC(
+        std::make_pair(DBKeys::PURPOSE, EncodeLegacyAddr(address, Params())),
+        strPurpose);
 }
 
 bool WalletBatch::ErasePurpose(const CTxDestination &address) {
     if (!IsValidDestination(address)) {
         return false;
     }
-    return EraseIC(std::make_pair(std::string("purpose"),
-                                  EncodeLegacyAddr(address, Params())));
+    return EraseIC(
+        std::make_pair(DBKeys::PURPOSE, EncodeLegacyAddr(address, Params())));
 }
 
 bool WalletBatch::WriteTx(const CWalletTx &wtx) {
-    return WriteIC(std::make_pair(std::string("tx"), wtx.GetId()), wtx);
+    return WriteIC(std::make_pair(DBKeys::TX, wtx.GetId()), wtx);
 }
 
 bool WalletBatch::EraseTx(uint256 hash) {
-    return EraseIC(std::make_pair(std::string("tx"), hash));
+    return EraseIC(std::make_pair(DBKeys::TX, hash));
 }
 
 bool WalletBatch::WriteKeyMetadata(const CKeyMetadata &meta,
                                    const CPubKey &pubkey,
                                    const bool overwrite) {
-    return WriteIC(std::make_pair(std::string("keymeta"), pubkey), meta,
-                   overwrite);
+    return WriteIC(std::make_pair(DBKeys::KEYMETA, pubkey), meta, overwrite);
 }
 
 bool WalletBatch::WriteKey(const CPubKey &vchPubKey, const CPrivKey &vchPrivKey,
@@ -91,7 +116,7 @@
     vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());
 
     return WriteIC(
-        std::make_pair(std::string("key"), vchPubKey),
+        std::make_pair(DBKeys::KEY, vchPubKey),
         std::make_pair(vchPrivKey, Hash(vchKey.begin(), vchKey.end())), false);
 }
 
@@ -102,74 +127,71 @@
         return false;
     }
 
-    if (!WriteIC(std::make_pair(std::string("ckey"), vchPubKey),
+    if (!WriteIC(std::make_pair(DBKeys::CRYPTED_KEY, vchPubKey),
                  vchCryptedSecret, false)) {
         return false;
     }
-    EraseIC(std::make_pair(std::string("key"), vchPubKey));
-    EraseIC(std::make_pair(std::string("wkey"), vchPubKey));
+    EraseIC(std::make_pair(DBKeys::KEY, vchPubKey));
     return true;
 }
 
 bool WalletBatch::WriteMasterKey(unsigned int nID,
                                  const CMasterKey &kMasterKey) {
-    return WriteIC(std::make_pair(std::string("mkey"), nID), kMasterKey, true);
+    return WriteIC(std::make_pair(DBKeys::MASTER_KEY, nID), kMasterKey, true);
 }
 
 bool WalletBatch::WriteCScript(const uint160 &hash,
                                const CScript &redeemScript) {
-    return WriteIC(std::make_pair(std::string("cscript"), hash), redeemScript,
-                   false);
+    return WriteIC(std::make_pair(DBKeys::CSCRIPT, hash), redeemScript, false);
 }
 
 bool WalletBatch::WriteWatchOnly(const CScript &dest,
                                  const CKeyMetadata &keyMeta) {
-    if (!WriteIC(std::make_pair(std::string("watchmeta"), dest), keyMeta)) {
+    if (!WriteIC(std::make_pair(DBKeys::WATCHMETA, dest), keyMeta)) {
         return false;
     }
-    return WriteIC(std::make_pair(std::string("watchs"), dest), '1');
+    return WriteIC(std::make_pair(DBKeys::WATCHS, dest), '1');
 }
 
 bool WalletBatch::EraseWatchOnly(const CScript &dest) {
-    if (!EraseIC(std::make_pair(std::string("watchmeta"), dest))) {
+    if (!EraseIC(std::make_pair(DBKeys::WATCHMETA, dest))) {
         return false;
     }
-    return EraseIC(std::make_pair(std::string("watchs"), dest));
+    return EraseIC(std::make_pair(DBKeys::WATCHS, dest));
 }
 
 bool WalletBatch::WriteBestBlock(const CBlockLocator &locator) {
     // Write empty block locator so versions that require a merkle branch
     // automatically rescan
-    WriteIC(std::string("bestblock"), CBlockLocator());
-    return WriteIC(std::string("bestblock_nomerkle"), locator);
+    WriteIC(DBKeys::BESTBLOCK, CBlockLocator());
+    return WriteIC(DBKeys::BESTBLOCK_NOMERKLE, locator);
 }
 
 bool WalletBatch::ReadBestBlock(CBlockLocator &locator) {
-    if (m_batch.Read(std::string("bestblock"), locator) &&
-        !locator.vHave.empty()) {
+    if (m_batch.Read(DBKeys::BESTBLOCK, locator) && !locator.vHave.empty()) {
         return true;
     }
-    return m_batch.Read(std::string("bestblock_nomerkle"), locator);
+    return m_batch.Read(DBKeys::BESTBLOCK_NOMERKLE, locator);
 }
 
 bool WalletBatch::WriteOrderPosNext(int64_t nOrderPosNext) {
-    return WriteIC(std::string("orderposnext"), nOrderPosNext);
+    return WriteIC(DBKeys::ORDERPOSNEXT, nOrderPosNext);
 }
 
 bool WalletBatch::ReadPool(int64_t nPool, CKeyPool &keypool) {
-    return m_batch.Read(std::make_pair(std::string("pool"), nPool), keypool);
+    return m_batch.Read(std::make_pair(DBKeys::POOL, nPool), keypool);
 }
 
 bool WalletBatch::WritePool(int64_t nPool, const CKeyPool &keypool) {
-    return WriteIC(std::make_pair(std::string("pool"), nPool), keypool);
+    return WriteIC(std::make_pair(DBKeys::POOL, nPool), keypool);
 }
 
 bool WalletBatch::ErasePool(int64_t nPool) {
-    return EraseIC(std::make_pair(std::string("pool"), nPool));
+    return EraseIC(std::make_pair(DBKeys::POOL, nPool));
 }
 
 bool WalletBatch::WriteMinVersion(int nVersion) {
-    return WriteIC(std::string("minversion"), nVersion);
+    return WriteIC(DBKeys::MINVERSION, nVersion);
 }
 
 class CWalletScanState {
@@ -181,7 +203,6 @@
     unsigned int m_unknown_records{0};
     bool fIsEncrypted{false};
     bool fAnyUnordered{false};
-    int nFileVersion{0};
     std::vector<TxId> vWalletUpgrade;
 
     CWalletScanState() {}
@@ -196,26 +217,26 @@
         // Taking advantage of the fact that pair serialization is just the two
         // items serialized one after the other.
         ssKey >> strType;
-        if (strType == "name") {
+        if (strType == DBKeys::NAME) {
             std::string strAddress;
             ssKey >> strAddress;
             ssValue >> pwallet
                            ->mapAddressBook[DecodeDestination(
                                strAddress, pwallet->chainParams)]
                            .name;
-        } else if (strType == "purpose") {
+        } else if (strType == DBKeys::PURPOSE) {
             std::string strAddress;
             ssKey >> strAddress;
             ssValue >> pwallet
                            ->mapAddressBook[DecodeDestination(
                                strAddress, pwallet->chainParams)]
                            .purpose;
-        } else if (strType == "tx") {
+        } else if (strType == DBKeys::TX) {
             TxId txid;
             ssKey >> txid;
             CWalletTx wtx(nullptr /* pwallet */, MakeTransactionRef());
             ssValue >> wtx;
-            CValidationState state;
+            TxValidationState state;
             bool isValid = wtx.IsCoinBase()
                                ? CheckCoinbase(*wtx.tx, state)
                                : CheckRegularTransaction(*wtx.tx, state);
@@ -249,7 +270,7 @@
             }
 
             pwallet->LoadToWallet(wtx);
-        } else if (strType == "watchs") {
+        } else if (strType == DBKeys::WATCHS) {
             wss.nWatchKeys++;
             CScript script;
             ssKey >> script;
@@ -258,7 +279,7 @@
             if (fYes == '1') {
                 pwallet->LoadWatchOnly(script);
             }
-        } else if (strType == "key" || strType == "wkey") {
+        } else if (strType == DBKeys::KEY) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             if (!vchPubKey.IsValid()) {
@@ -269,19 +290,13 @@
             CPrivKey pkey;
             uint256 hash;
 
-            if (strType == "key") {
-                wss.nKeys++;
-                ssValue >> pkey;
-            } else {
-                CWalletKey wkey;
-                ssValue >> wkey;
-                pkey = wkey.vchPrivKey;
-            }
+            wss.nKeys++;
+            ssValue >> pkey;
 
-            // Old wallets store keys as "key" [pubkey] => [privkey]
-            // ... which was slow for wallets with lots of keys, because the
-            // public key is re-derived from the private key using EC operations
-            // as a checksum. Newer wallets store keys as "key"[pubkey] =>
+            // Old wallets store keys as DBKeys::KEY [pubkey] => [privkey] ...
+            // which was slow for wallets with lots of keys, because the public
+            // key is re-derived from the private key using EC operations as a
+            // checksum. Newer wallets store keys as DBKeys::KEY [pubkey] =>
             // [privkey][hash(pubkey,privkey)], which is much faster while
             // remaining backwards-compatible.
             try {
@@ -315,7 +330,7 @@
                 strErr = "Error reading wallet database: LoadKey failed";
                 return false;
             }
-        } else if (strType == "mkey") {
+        } else if (strType == DBKeys::MASTER_KEY) {
             unsigned int nID;
             ssKey >> nID;
             CMasterKey kMasterKey;
@@ -330,7 +345,7 @@
             if (pwallet->nMasterKeyMaxID < nID) {
                 pwallet->nMasterKeyMaxID = nID;
             }
-        } else if (strType == "ckey") {
+        } else if (strType == DBKeys::CRYPTED_KEY) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             if (!vchPubKey.IsValid()) {
@@ -346,7 +361,7 @@
                 return false;
             }
             wss.fIsEncrypted = true;
-        } else if (strType == "keymeta") {
+        } else if (strType == DBKeys::KEYMETA) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             CKeyMetadata keyMeta;
@@ -354,14 +369,14 @@
             wss.nKeyMeta++;
 
             pwallet->LoadKeyMetadata(vchPubKey.GetID(), keyMeta);
-        } else if (strType == "watchmeta") {
+        } else if (strType == DBKeys::WATCHMETA) {
             CScript script;
             ssKey >> script;
             CKeyMetadata keyMeta;
             ssValue >> keyMeta;
             wss.nKeyMeta++;
             pwallet->LoadScriptMetadata(CScriptID(script), keyMeta);
-        } else if (strType == "defaultkey") {
+        } else if (strType == DBKeys::DEFAULTKEY) {
             // We don't want or need the default key, but if there is one set,
             // we want to make sure that it is valid so that we can detect
             // corruption
@@ -371,19 +386,14 @@
                 strErr = "Error reading wallet database: Default Key corrupt";
                 return false;
             }
-        } else if (strType == "pool") {
+        } else if (strType == DBKeys::POOL) {
             int64_t nIndex;
             ssKey >> nIndex;
             CKeyPool keypool;
             ssValue >> keypool;
 
             pwallet->LoadKeyPool(nIndex, keypool);
-        } else if (strType == "version") {
-            ssValue >> wss.nFileVersion;
-            if (wss.nFileVersion == 10300) {
-                wss.nFileVersion = 300;
-            }
-        } else if (strType == "cscript") {
+        } else if (strType == DBKeys::CSCRIPT) {
             uint160 hash;
             ssKey >> hash;
             CScript script;
@@ -392,9 +402,9 @@
                 strErr = "Error reading wallet database: LoadCScript failed";
                 return false;
             }
-        } else if (strType == "orderposnext") {
+        } else if (strType == DBKeys::ORDERPOSNEXT) {
             ssValue >> pwallet->nOrderPosNext;
-        } else if (strType == "destdata") {
+        } else if (strType == DBKeys::DESTDATA) {
             std::string strAddress, strKey, strValue;
             ssKey >> strAddress;
             ssKey >> strKey;
@@ -402,11 +412,11 @@
             pwallet->LoadDestData(
                 DecodeDestination(strAddress, pwallet->chainParams), strKey,
                 strValue);
-        } else if (strType == "hdchain") {
+        } else if (strType == DBKeys::HDCHAIN) {
             CHDChain chain;
             ssValue >> chain;
             pwallet->SetHDChain(chain, true);
-        } else if (strType == "flags") {
+        } else if (strType == DBKeys::FLAGS) {
             uint64_t flags;
             ssValue >> flags;
             if (!pwallet->SetWalletFlags(flags, true)) {
@@ -414,19 +424,34 @@
                          "wallet flags found";
                 return false;
             }
-        } else if (strType != "bestblock" && strType != "bestblock_nomerkle" &&
-                   strType != "minversion" && strType != "acentry") {
+        } else if (strType == DBKeys::OLD_KEY) {
+            strErr = "Found unsupported 'wkey' record, try loading with "
+                     "version 0.20";
+            return false;
+        } else if (strType != DBKeys::BESTBLOCK &&
+                   strType != DBKeys::BESTBLOCK_NOMERKLE &&
+                   strType != DBKeys::MINVERSION &&
+                   strType != DBKeys::ACENTRY && strType != DBKeys::VERSION &&
+                   strType != DBKeys::SETTINGS) {
             wss.m_unknown_records++;
         }
+    } catch (const std::exception &e) {
+        if (strErr.empty()) {
+            strErr = e.what();
+        }
+        return false;
     } catch (...) {
+        if (strErr.empty()) {
+            strErr = "Caught unknown exception in ReadKeyValue";
+        }
         return false;
     }
     return true;
 }
 
 bool WalletBatch::IsKeyType(const std::string &strType) {
-    return (strType == "key" || strType == "wkey" || strType == "mkey" ||
-            strType == "ckey");
+    return (strType == DBKeys::KEY || strType == DBKeys::MASTER_KEY ||
+            strType == DBKeys::CRYPTED_KEY);
 }
 
 DBErrors WalletBatch::LoadWallet(CWallet *pwallet) {
@@ -437,7 +462,7 @@
     LOCK(pwallet->cs_wallet);
     try {
         int nMinVersion = 0;
-        if (m_batch.Read((std::string) "minversion", nMinVersion)) {
+        if (m_batch.Read(DBKeys::MINVERSION, nMinVersion)) {
             if (nMinVersion > FEATURE_LATEST) {
                 return DBErrors::TOO_NEW;
             }
@@ -471,9 +496,9 @@
             if (!ReadKeyValue(pwallet, ssKey, ssValue, wss, strType, strErr)) {
                 // losing keys is considered a catastrophic error, anything else
                 // we assume the user can live with:
-                if (IsKeyType(strType) || strType == "defaultkey") {
+                if (IsKeyType(strType) || strType == DBKeys::DEFAULTKEY) {
                     result = DBErrors::CORRUPT;
-                } else if (strType == "flags") {
+                } else if (strType == DBKeys::FLAGS) {
                     // Reading the wallet flags can only fail if unknown flags
                     // are present.
                     result = DBErrors::TOO_NEW;
@@ -482,7 +507,7 @@
                     // make things worse. But do warn the user there is
                     // something wrong.
                     fNoncriticalErrors = true;
-                    if (strType == "tx") {
+                    if (strType == DBKeys::TX) {
                         // Rescan if there is a bad transaction record:
                         gArgs.SoftSetBoolArg("-rescan", true);
                     }
@@ -509,7 +534,14 @@
         return result;
     }
 
-    pwallet->WalletLogPrintf("nFileVersion = %d\n", wss.nFileVersion);
+    // Last client version to open this wallet, was previously the file version
+    // number
+    int last_client = CLIENT_VERSION;
+    m_batch.Read(DBKeys::VERSION, last_client);
+
+    int wallet_version = pwallet->GetVersion();
+    pwallet->WalletLogPrintf("Wallet File Version = %d\n",
+                             wallet_version > 0 ? wallet_version : last_client);
 
     pwallet->WalletLogPrintf("Keys: %u plaintext, %u encrypted, %u w/ "
                              "metadata, %u total. Unknown wallet records: %u\n",
@@ -526,14 +558,13 @@
     }
 
     // Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
-    if (wss.fIsEncrypted &&
-        (wss.nFileVersion == 40000 || wss.nFileVersion == 50000)) {
+    if (wss.fIsEncrypted && (last_client == 40000 || last_client == 50000)) {
         return DBErrors::NEED_REWRITE;
     }
 
-    if (wss.nFileVersion < CLIENT_VERSION) {
+    if (last_client < CLIENT_VERSION) {
         // Update
-        WriteVersion(CLIENT_VERSION);
+        m_batch.Write(DBKeys::VERSION, CLIENT_VERSION);
     }
 
     if (wss.fAnyUnordered) {
@@ -558,7 +589,7 @@
 
     try {
         int nMinVersion = 0;
-        if (m_batch.Read((std::string) "minversion", nMinVersion)) {
+        if (m_batch.Read(DBKeys::MINVERSION, nMinVersion)) {
             if (nMinVersion > FEATURE_LATEST) {
                 return DBErrors::TOO_NEW;
             }
@@ -587,7 +618,7 @@
 
             std::string strType;
             ssKey >> strType;
-            if (strType == "tx") {
+            if (strType == DBKeys::TX) {
                 TxId txid;
                 ssKey >> txid;
 
@@ -730,7 +761,7 @@
         fReadOK = ReadKeyValue(dummyWallet, ssKey, ssValue, dummyWss, strType,
                                strErr);
     }
-    if (!IsKeyType(strType) && strType != "hdchain") {
+    if (!IsKeyType(strType) && strType != DBKeys::HDCHAIN) {
         return false;
     }
     if (!fReadOK) {
@@ -762,7 +793,7 @@
     }
     return WriteIC(
         std::make_pair(
-            std::string("destdata"),
+            DBKeys::DESTDATA,
             std::make_pair(EncodeLegacyAddr(address, Params()), key)),
         value);
 }
@@ -773,16 +804,16 @@
         return false;
     }
     return EraseIC(std::make_pair(
-        std::string("destdata"),
+        DBKeys::DESTDATA,
         std::make_pair(EncodeLegacyAddr(address, Params()), key)));
 }
 
 bool WalletBatch::WriteHDChain(const CHDChain &chain) {
-    return WriteIC(std::string("hdchain"), chain);
+    return WriteIC(DBKeys::HDCHAIN, chain);
 }
 
 bool WalletBatch::WriteWalletFlags(const uint64_t flags) {
-    return WriteIC(std::string("flags"), flags);
+    return WriteIC(DBKeys::FLAGS, flags);
 }
 
 bool WalletBatch::TxnBegin() {
@@ -796,11 +827,3 @@
 bool WalletBatch::TxnAbort() {
     return m_batch.TxnAbort();
 }
-
-bool WalletBatch::ReadVersion(int &nVersion) {
-    return m_batch.ReadVersion(nVersion);
-}
-
-bool WalletBatch::WriteVersion(int nVersion) {
-    return m_batch.WriteVersion(nVersion);
-}
diff -Nru bitcoinabc-0.21.11/src/wallet/walletdb.h bitcoinabc-0.21.12/src/wallet/walletdb.h
--- bitcoinabc-0.21.11/src/wallet/walletdb.h	2020-06-18 19:26:30.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/walletdb.h	2020-07-27 15:24:34.000000000 +0000
@@ -262,10 +262,6 @@
     bool TxnCommit();
     //! Abort current transaction
     bool TxnAbort();
-    //! Read wallet version
-    bool ReadVersion(int &nVersion);
-    //! Write wallet version
-    bool WriteVersion(int nVersion);
 
 private:
     BerkeleyBatch m_batch;
diff -Nru bitcoinabc-0.21.11/src/wallet/wallet.h bitcoinabc-0.21.12/src/wallet/wallet.h
--- bitcoinabc-0.21.11/src/wallet/wallet.h	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/src/wallet/wallet.h	2020-07-28 23:45:00.000000000 +0000
@@ -708,33 +708,6 @@
     }
 };
 
-/** Private key that includes an expiration date in case it never gets used. */
-class CWalletKey {
-public:
-    CPrivKey vchPrivKey;
-    int64_t nTimeCreated;
-    int64_t nTimeExpires;
-    std::string strComment;
-    // todo: add something to note what created it (user, getnewaddress,
-    // change) maybe should have a map<string, string> property map
-
-    explicit CWalletKey(int64_t nExpires = 0);
-
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream &s, Operation ser_action) {
-        int nVersion = s.GetVersion();
-        if (!(s.GetType() & SER_GETHASH)) {
-            READWRITE(nVersion);
-        }
-        READWRITE(vchPrivKey);
-        READWRITE(nTimeCreated);
-        READWRITE(nTimeExpires);
-        READWRITE(LIMITED_STRING(strComment, 65536));
-    }
-};
-
 struct CoinSelectionParams {
     bool use_bnb = true;
     size_t change_output_size = 0;
@@ -794,6 +767,8 @@
     std::atomic<bool> fAbortRescan{false};
     // controlled by WalletRescanReserver
     std::atomic<bool> fScanningWallet{false};
+    std::atomic<int64_t> m_scanning_start{0};
+    std::atomic<double> m_scanning_progress{0};
     std::mutex mutexScanning;
     friend class WalletRescanReserver;
 
@@ -801,7 +776,7 @@
 
     //! the current wallet version: clients below this version are not able to
     //! load the wallet
-    int nWalletVersion = FEATURE_BASE;
+    int nWalletVersion GUARDED_BY(cs_wallet) = FEATURE_BASE;
 
     //! the maximum wallet format version: memory-only variable that specifies
     //! to what version this wallet may be upgraded
@@ -878,9 +853,9 @@
                            CKey &secret, bool internal = false)
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
-    std::set<int64_t> setInternalKeyPool;
+    std::set<int64_t> setInternalKeyPool GUARDED_BY(cs_wallet);
     std::set<int64_t> setExternalKeyPool GUARDED_BY(cs_wallet);
-    std::set<int64_t> set_pre_split_keypool;
+    std::set<int64_t> set_pre_split_keypool GUARDED_BY(cs_wallet);
     int64_t m_max_keypool_index GUARDED_BY(cs_wallet) = 0;
     std::map<CKeyID, int64_t> m_pool_key_to_index;
     std::atomic<uint64_t> m_wallet_flags{0};
@@ -1120,6 +1095,12 @@
     void AbortRescan() { fAbortRescan = true; }
     bool IsAbortingRescan() { return fAbortRescan; }
     bool IsScanning() { return fScanningWallet; }
+    int64_t ScanningDuration() const {
+        return fScanningWallet ? GetTimeMillis() - m_scanning_start : 0;
+    }
+    double ScanningProgress() const {
+        return fScanningWallet ? double(m_scanning_progress) : 0;
+    }
 
     /**
      * keystore implementation
@@ -1305,7 +1286,7 @@
     bool CommitTransaction(
         CTransactionRef tx, mapValue_t mapValue,
         std::vector<std::pair<std::string, std::string>> orderForm,
-        CValidationState &state);
+        TxValidationState &state);
 
     bool DummySignTx(CMutableTransaction &txNew, const std::set<CTxOut> &txouts,
                      bool use_max_sig = false) const {
@@ -1436,7 +1417,6 @@
         EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     unsigned int GetKeyPoolSize() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
-        // set{Ex,In}ternalKeyPool
         AssertLockHeld(cs_wallet);
         return setInternalKeyPool.size() + setExternalKeyPool.size();
     }
@@ -1676,6 +1656,8 @@
         if (m_wallet->fScanningWallet) {
             return false;
         }
+        m_wallet->m_scanning_start = GetTimeMillis();
+        m_wallet->m_scanning_progress = 0;
         m_wallet->fScanningWallet = true;
         m_could_reserve = true;
         return true;
diff -Nru bitcoinabc-0.21.11/test/functional/abc-miner-fund.py bitcoinabc-0.21.12/test/functional/abc-miner-fund.py
--- bitcoinabc-0.21.11/test/functional/abc-miner-fund.py	2020-07-07 17:16:37.000000000 +0000
+++ bitcoinabc-0.21.12/test/functional/abc-miner-fund.py	1970-01-01 00:00:00.000000000 +0000
@@ -1,208 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2020 The Bitcoin developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-from test_framework.blocktools import (
-    create_block,
-    create_coinbase,
-    TIME_GENESIS_BLOCK,
-)
-from test_framework.messages import ToHex
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_equal,
-    assert_greater_than_or_equal,
-)
-
-from decimal import Decimal
-
-PHONON_ACTIVATION_TIME = 1589544000
-VERSION_BASE = 536870912
-
-MINER_FUND_RATIO = 20
-
-MINER_FUND_ADDR = 'bchreg:pqv2r67sgz3qumufap3h2uuj0zfmnzuv8v7ej0fffv'
-MINER_FUND_ABC_ADDR = 'bchreg:qzvz0es48sf8wrqy7kn5j5cugka95ztskcra2r7ee7'
-MINER_FUND_BCHD_ADDR = 'bchreg:qrhea03074073ff3zv9whh0nggxc7k03ssffq2ylju'
-MINER_FUND_ELECTRON_CASH_ADDR = 'bchreg:pp8d685l8kecnmtyy52ndvq625arz2qwmutyjlcyav'
-
-
-class MinerFundTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.setup_clean_chain = True
-        self.num_nodes = 1
-        self.extra_args = [['-enableminerfund']]
-
-    def check_bip9_state(self, name, status):
-        miner_fund_info = self.nodes[0].getblockchaininfo()['softforks'][name]
-        assert_equal(miner_fund_info['bip9'], status)
-
-    def run_test(self):
-        node = self.nodes[0]
-        address = node.get_deterministic_priv_key().address
-
-        self.log.info('Create some old blocks')
-        for t in range(TIME_GENESIS_BLOCK,
-                       TIME_GENESIS_BLOCK + 200 * 600, 600):
-            # ten-minute steps from genesis block time
-            self.nodes[0].setmocktime(t)
-            self.nodes[0].generatetoaddress(1, address)
-        assert_equal(self.nodes[0].getblockchaininfo()['blocks'], 200)
-
-        # Get the vote started.
-        node.setmocktime(1580000000)
-
-        def check_all_bip9_state(status):
-            self.check_bip9_state('minerfund', status)
-            self.check_bip9_state('minerfundabc', status)
-            self.check_bip9_state('minerfundbchd', status)
-            self.check_bip9_state('minerfundelectroncash', status)
-
-        # We need to finish the current period and move the MTP forward.
-        while ((node.getblockchaininfo()['blocks'] + 2) % 144) != 0:
-            node.generatetoaddress(1, address)
-            check_all_bip9_state({
-                'status': 'defined',
-                'start_time': 1573819200,
-                'timeout': 1589544000,
-                'since': 0,
-            })
-
-        height = node.getblockcount()
-        self.run_no_miner_fund_test()
-
-        def run_test_for(bit, name, address):
-            # Make sure we have a clean slate.
-            node.invalidateblock(node.getblockhash(height + 1))
-            self.run_miner_fund_test(bit, name, address)
-
-        run_test_for(0, 'minerfund', MINER_FUND_ADDR)
-        run_test_for(1, 'minerfundabc', MINER_FUND_ABC_ADDR)
-        run_test_for(2, 'minerfundbchd', MINER_FUND_BCHD_ADDR)
-        run_test_for(3, 'minerfundelectroncash', MINER_FUND_ELECTRON_CASH_ADDR)
-
-    def run_no_miner_fund_test(self):
-        node = self.nodes[0]
-        address = node.get_deterministic_priv_key().address
-
-        # Move MTP forward to phonon activation
-        node.setmocktime(PHONON_ACTIVATION_TIME)
-        node.generatetoaddress(6, address)
-        assert_equal(
-            node.getblockchaininfo()['mediantime'],
-            PHONON_ACTIVATION_TIME)
-
-        # First block with the new rules.
-        node.generatetoaddress(1, address)
-
-        def get_best_coinbase():
-            return node.getblock(node.getbestblockhash(), 2)['tx'][0]
-
-        # No money goes to the fund.
-        coinbase = get_best_coinbase()
-        assert_equal(len(coinbase['vout']), 1)
-
-    def run_miner_fund_test(self, bit, name, fund_address):
-        self.log.info("Testing miner fund {} on bit {}.".format(name, bit))
-
-        version = VERSION_BASE | (1 << bit)
-
-        self.stop_node(0)
-        self.start_node(
-            0, ['-enableminerfund', "-blockversion={}".format(version)])
-
-        node = self.nodes[0]
-        node.setmocktime(1580000000)
-        address = node.get_deterministic_priv_key().address
-
-        for i in range(144):
-            node.generatetoaddress(1, address)
-            self.check_bip9_state(name, {
-                'status': 'started',
-                'bit': bit,
-                'start_time': 1573819200,
-                'timeout': 1589544000,
-                'since': 288,
-                'statistics': {
-                    'period': 144,
-                    'threshold': 96,
-                    'elapsed': i,
-                    'count': i,
-                    'possible': True,
-                },
-            })
-
-        for i in range(144):
-            node.generatetoaddress(1, address)
-            self.check_bip9_state(name, {
-                'status': 'locked_in',
-                'start_time': 1573819200,
-                'timeout': 1589544000,
-                'since': 432,
-            })
-
-        # Now this should be active.
-        node.generatetoaddress(1, address)
-        self.check_bip9_state(name, {
-            'status': 'active',
-            'start_time': 1573819200,
-            'timeout': 1589544000,
-            'since': 576,
-        })
-
-        # Move MTP forward to phonon activation
-        node.setmocktime(PHONON_ACTIVATION_TIME)
-        node.generatetoaddress(6, address)
-        assert_equal(
-            node.getblockchaininfo()['mediantime'],
-            PHONON_ACTIVATION_TIME)
-
-        self.check_bip9_state(name, {
-            'status': 'active',
-            'start_time': 1573819200,
-            'timeout': 1589544000,
-            'since': 576,
-        })
-
-        # Let's remember the hash of this block for later use.
-        fork_block_hash = int(node.getbestblockhash(), 16)
-
-        def get_best_coinbase():
-            return node.getblock(node.getbestblockhash(), 2)['tx'][0]
-
-        # Check that we do not send anything to the fund yet.
-        assert_equal(len(get_best_coinbase()['vout']), 1)
-
-        # Now the miner fund is enforced
-        node.generatetoaddress(1, address)
-
-        # Now we send part of the coinbase to the fund.
-        coinbase = get_best_coinbase()
-        assert_equal(len(coinbase['vout']), 2)
-        assert_equal(
-            coinbase['vout'][1]['scriptPubKey']['addresses'][0],
-            fund_address)
-
-        total = Decimal()
-        for o in coinbase['vout']:
-            total += o['value']
-
-        assert_greater_than_or_equal(
-            total / MINER_FUND_RATIO,
-            coinbase['vout'][1]['value'])
-
-        # Invalidate top block, submit a custom block that do not send anything
-        # to the fund and check it is rejected.
-        node.invalidateblock(node.getbestblockhash())
-
-        block_height = node.getblockcount() + 1
-        block = create_block(
-            fork_block_hash, create_coinbase(block_height), PHONON_ACTIVATION_TIME + 99, version=4)
-        block.solve()
-
-        assert_equal(node.submitblock(ToHex(block)), 'bad-cb-minerfund')
-
-
-if __name__ == '__main__':
-    MinerFundTest().main()
diff -Nru bitcoinabc-0.21.11/test/functional/abc_p2p_avalanche.py bitcoinabc-0.21.12/test/functional/abc_p2p_avalanche.py
--- bitcoinabc-0.21.11/test/functional/abc_p2p_avalanche.py	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/test/functional/abc_p2p_avalanche.py	2020-07-14 19:22:04.000000000 +0000
@@ -181,9 +181,19 @@
             "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747")
         pubkey = schnorr.getpubkey(privkey, compressed=True)
 
+        privatekey = node.get_deterministic_priv_key().key
+        proof = node.buildavalancheproof(11, 12, pubkey.hex(), [{
+            'txid': "12b004fff7f4b69ef8650e767f18f11ede158148b425660723b9f9a66e61f747",
+            'vout': 0,
+            'amount': 10,
+            'height': 100,
+            'privatekey': privatekey,
+        }])
+
         # Activate the quorum.
         for n in quorum:
-            node.addavalanchepeer(n.nodeid, pubkey.hex())
+            success = node.addavalanchenode(n.nodeid, pubkey.hex(), proof)
+            assert success is True
 
         def can_find_block_in_poll(hash, resp=BLOCK_ACCEPTED):
             found_hash = False
diff -Nru bitcoinabc-0.21.11/test/functional/interface_bitcoin_cli.py bitcoinabc-0.21.12/test/functional/interface_bitcoin_cli.py
--- bitcoinabc-0.21.11/test/functional/interface_bitcoin_cli.py	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/test/functional/interface_bitcoin_cli.py	2020-07-14 19:22:04.000000000 +0000
@@ -27,7 +27,7 @@
         assert "Bitcoin ABC RPC client version" in cli_response
 
         self.log.info(
-            "Compare responses from gewalletinfo RPC and `bitcoin-cli getwalletinfo`")
+            "Compare responses from getwalletinfo RPC and `bitcoin-cli getwalletinfo`")
         if self.is_wallet_compiled():
             cli_response = self.nodes[0].cli.getwalletinfo()
             rpc_response = self.nodes[0].getwalletinfo()
diff -Nru bitcoinabc-0.21.11/test/functional/rpc_blockchain.py bitcoinabc-0.21.12/test/functional/rpc_blockchain.py
--- bitcoinabc-0.21.11/test/functional/rpc_blockchain.py	2020-06-19 20:22:33.000000000 +0000
+++ bitcoinabc-0.21.12/test/functional/rpc_blockchain.py	2020-07-27 15:24:34.000000000 +0000
@@ -131,46 +131,6 @@
                 },
                 'active': False,
             },
-            'minerfund': {
-                'type': 'bip9',
-                'bip9': {
-                    'status': 'defined',
-                    'start_time': 1573819200,
-                    'timeout': 1589544000,
-                    'since': 0,
-                },
-                'active': False,
-            },
-            'minerfundabc': {
-                'type': 'bip9',
-                'bip9': {
-                    'status': 'defined',
-                    'start_time': 1573819200,
-                    'timeout': 1589544000,
-                    'since': 0,
-                },
-                'active': False,
-            },
-            'minerfundbchd': {
-                'type': 'bip9',
-                'bip9': {
-                    'status': 'defined',
-                    'start_time': 1573819200,
-                    'timeout': 1589544000,
-                    'since': 0,
-                },
-                'active': False,
-            },
-            'minerfundelectroncash': {
-                'type': 'bip9',
-                'bip9': {
-                    'status': 'defined',
-                    'start_time': 1573819200,
-                    'timeout': 1589544000,
-                    'since': 0,
-                },
-                'active': False,
-            },
         })
 
         # pruneheight should be greater or equal to 0
diff -Nru bitcoinabc-0.21.11/test/functional/rpc_rawtransaction.py bitcoinabc-0.21.12/test/functional/rpc_rawtransaction.py
--- bitcoinabc-0.21.11/test/functional/rpc_rawtransaction.py	2020-07-14 18:43:12.000000000 +0000
+++ bitcoinabc-0.21.12/test/functional/rpc_rawtransaction.py	2020-07-14 19:22:04.000000000 +0000
@@ -210,8 +210,10 @@
         rawtx = self.nodes[2].signrawtransactionwithwallet(rawtx)
 
         # This will raise an exception since there are missing inputs
-        assert_raises_rpc_error(
-            -25, "Missing inputs", self.nodes[2].sendrawtransaction, rawtx['hex'])
+        assert_raises_rpc_error(-25,
+                                "bad-txns-inputs-missingorspent",
+                                self.nodes[2].sendrawtransaction,
+                                rawtx['hex'])
 
         #####################################
         # getrawtransaction with block hash #
diff -Nru bitcoinabc-0.21.11/test/functional/test_runner.py bitcoinabc-0.21.12/test/functional/test_runner.py
--- bitcoinabc-0.21.11/test/functional/test_runner.py	2020-06-24 18:26:49.000000000 +0000
+++ bitcoinabc-0.21.12/test/functional/test_runner.py	2020-07-27 15:24:34.000000000 +0000
@@ -154,7 +154,7 @@
             status = "Failed"
 
         return TestResult(self.test_num, self.test_case, testdir, status,
-                          int(time.time() - time0), stdout, stderr)
+                          time.time() - time0, stdout, stderr)
 
 
 def on_ci():
@@ -397,7 +397,7 @@
     time0 = time.time()
     test_results = execute_test_processes(
         num_jobs, test_list, tests_dir, tmpdir, flags, failfast)
-    runtime = int(time.time() - time0)
+    runtime = time.time() - time0
 
     max_len_name = len(max(test_list, key=len))
     print_results(test_results, tests_dir, max_len_name,
@@ -458,13 +458,13 @@
 
             if test_result.status == "Passed":
                 print("{}{}{} passed, Duration: {} s".format(
-                    BOLD[1], test_result.name, BOLD[0], test_result.time))
+                    BOLD[1], test_result.name, BOLD[0], TimeResolution.seconds(test_result.time)))
             elif test_result.status == "Skipped":
                 print("{}{}{} skipped".format(
                     BOLD[1], test_result.name, BOLD[0]))
             else:
                 print("{}{}{} failed, Duration: {} s\n".format(
-                    BOLD[1], test_result.name, BOLD[0], test_result.time))
+                    BOLD[1], test_result.name, BOLD[0], TimeResolution.seconds(test_result.time)))
                 print(BOLD[1] + 'stdout:' + BOLD[0])
                 print(test_result.stdout)
                 print(BOLD[1] + 'stderr:' + BOLD[0])
@@ -598,10 +598,10 @@
     if not all_passed:
         results += RED[1]
     results += BOLD[1] + "\n{} | {} | {} s (accumulated) \n".format(
-        "ALL".ljust(max_len_name), status.ljust(9), time_sum) + BOLD[0]
+        "ALL".ljust(max_len_name), status.ljust(9), TimeResolution.seconds(time_sum)) + BOLD[0]
     if not all_passed:
         results += RED[0]
-    results += "Runtime: {} s\n".format(runtime)
+    results += "Runtime: {} s\n".format(TimeResolution.seconds(runtime))
     print(results)
 
 
@@ -640,7 +640,7 @@
             glyph = CIRCLE
 
         return color[1] + "{} | {}{} | {} s\n".format(
-            self.name.ljust(self.padding), glyph, self.status.ljust(7), self.time) + color[0]
+            self.name.ljust(self.padding), glyph, self.status.ljust(7), TimeResolution.seconds(self.time)) + color[0]
 
     @property
     def was_successful(self):
@@ -658,7 +658,7 @@
 def check_script_prefixes(all_scripts):
     """Check that no more than `EXPECTED_VIOLATION_COUNT` of the
        test scripts don't start with one of the allowed name prefixes."""
-    EXPECTED_VIOLATION_COUNT = 17
+    EXPECTED_VIOLATION_COUNT = 16
 
     # LEEWAY is provided as a transition measure, so that pull-requests
     # that introduce new tests that don't conform with the naming
@@ -797,7 +797,7 @@
                                "failures": str(len([t for t in test_results if t.status == "Failed"])),
                                "id": "0",
                                "skipped": str(len([t for t in test_results if t.status == "Skipped"])),
-                               "time": str(time),
+                               "time": str(TimeResolution.milliseconds(time)),
                                "timestamp": datetime.datetime.now().isoformat('T')
                                })
 
@@ -805,7 +805,7 @@
         e_test_case = ET.SubElement(e_test_suite, "testcase",
                                     {"name": test_result.name,
                                      "classname": test_result.name,
-                                     "time": str(test_result.time)
+                                     "time": str(TimeResolution.milliseconds(test_result.time))
                                      }
                                     )
         if test_result.status == "Skipped":
@@ -860,7 +860,7 @@
         # we only save test that have passed - timings for failed test might be
         # wrong (timeouts or early fails)
         passed_results = [t for t in test_results if t.status == 'Passed']
-        new_timings = list(map(lambda t: {'name': t.name, 'time': t.time},
+        new_timings = list(map(lambda t: {'name': t.name, 'time': TimeResolution.seconds(t.time)},
                                passed_results))
         merged_timings = self.get_merged_timings(new_timings)
 
@@ -868,5 +868,15 @@
             json.dump(merged_timings, f, indent=True)
 
 
+class TimeResolution:
+    @staticmethod
+    def seconds(time_fractional_second):
+        return round(time_fractional_second)
+
+    @staticmethod
+    def milliseconds(time_fractional_second):
+        return round(time_fractional_second, 3)
+
+
 if __name__ == '__main__':
     main()
diff -Nru bitcoinabc-0.21.11/test/functional/timing.json bitcoinabc-0.21.12/test/functional/timing.json
--- bitcoinabc-0.21.11/test/functional/timing.json	2020-07-09 15:34:59.000000000 +0000
+++ bitcoinabc-0.21.12/test/functional/timing.json	2020-07-27 15:24:34.000000000 +0000
@@ -5,7 +5,7 @@
  },
  {
   "name": "abc-finalize-block.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "abc-get-invalid-block.py",
@@ -13,7 +13,7 @@
  },
  {
   "name": "abc-invalid-chains.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "abc-invalid-message.py",
@@ -21,19 +21,19 @@
  },
  {
   "name": "abc-magnetic-anomaly-mining.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "abc-mempool-coherence-on-activations.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "abc-miner-fund.py",
-  "time": 7
+  "time": 8
  },
  {
   "name": "abc-minimaldata.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "abc-parkedchain.py",
@@ -41,7 +41,7 @@
  },
  {
   "name": "abc-replay-protection.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "abc-schnorr.py",
@@ -53,15 +53,15 @@
  },
  {
   "name": "abc-segwit-recovery.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "abc-sync-chain.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "abc-transaction-ordering.py",
-  "time": 3
+  "time": 4
  },
  {
   "name": "abc-version-message.py",
@@ -69,23 +69,23 @@
  },
  {
   "name": "abc_p2p_avalanche.py",
-  "time": 6
+  "time": 5
  },
  {
   "name": "abc_p2p_compactblocks.py",
-  "time": 399
+  "time": 437
  },
  {
   "name": "abc_p2p_fullblocktest.py",
-  "time": 88
+  "time": 91
  },
  {
   "name": "abc_rpc_excessiveblock.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "abc_rpc_mocktime.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "abc_wallet_standardness.py",
@@ -101,11 +101,11 @@
  },
  {
   "name": "feature_assumevalid.py",
-  "time": 7
+  "time": 8
  },
  {
   "name": "feature_bip68_sequence.py",
-  "time": 15
+  "time": 20
  },
  {
   "name": "feature_block.py",
@@ -117,7 +117,7 @@
  },
  {
   "name": "feature_cltv.py",
-  "time": 3
+  "time": 4
  },
  {
   "name": "feature_config_args.py",
@@ -125,11 +125,11 @@
  },
  {
   "name": "feature_csv_activation.py",
-  "time": 15
+  "time": 16
  },
  {
   "name": "feature_dbcrash.py",
-  "time": 899
+  "time": 1003
  },
  {
   "name": "feature_dersig.py",
@@ -141,7 +141,7 @@
  },
  {
   "name": "feature_help.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "feature_includeconf.py",
@@ -157,23 +157,23 @@
  },
  {
   "name": "feature_maxuploadtarget.py",
-  "time": 17
+  "time": 18
  },
  {
   "name": "feature_minchainwork.py",
-  "time": 4
+  "time": 5
  },
  {
   "name": "feature_notifications.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "feature_proxy.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "feature_pruning.py",
-  "time": 164
+  "time": 166
  },
  {
   "name": "feature_reindex.py",
@@ -185,7 +185,7 @@
  },
  {
   "name": "feature_uacomment.py",
-  "time": 2
+  "time": 3
  },
  {
   "name": "interface_bitcoin_cli.py",
@@ -197,19 +197,19 @@
  },
  {
   "name": "interface_rest.py",
-  "time": 15
+  "time": 14
  },
  {
   "name": "interface_rpc.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "interface_zmq.py",
-  "time": 4
+  "time": 7
  },
  {
   "name": "mempool_accept.py",
-  "time": 2
+  "time": 3
  },
  {
   "name": "mempool_limit.py",
@@ -217,55 +217,55 @@
  },
  {
   "name": "mempool_packages.py",
-  "time": 9
+  "time": 17
  },
  {
   "name": "mempool_persist.py",
-  "time": 14
+  "time": 9
  },
  {
   "name": "mempool_reorg.py",
-  "time": 3
+  "time": 5
  },
  {
   "name": "mempool_resurrect.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "mempool_spend_coinbase.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "mining_basic.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "mining_getblocktemplate_longpoll.py",
-  "time": 65
+  "time": 66
  },
  {
   "name": "mining_prioritisetransaction.py",
-  "time": 3
+  "time": 4
  },
  {
   "name": "p2p_blocksonly.py",
-  "time": 3
+  "time": 14
  },
  {
   "name": "p2p_compactblocks.py",
-  "time": 11
+  "time": 12
  },
  {
   "name": "p2p_disconnect_ban.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "p2p_dos_header_tree.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "p2p_feefilter.py",
-  "time": 28
+  "time": 27
  },
  {
   "name": "p2p_fingerprint.py",
@@ -277,27 +277,27 @@
  },
  {
   "name": "p2p_invalid_locator.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "p2p_invalid_messages.py",
-  "time": 4
+  "time": 5
  },
  {
   "name": "p2p_invalid_tx.py",
-  "time": 2
+  "time": 3
  },
  {
   "name": "p2p_leak.py",
-  "time": 5
+  "time": 6
  },
  {
   "name": "p2p_leak_tx.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "p2p_mempool.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "p2p_node_network_limited.py",
@@ -309,15 +309,15 @@
  },
  {
   "name": "p2p_sendheaders.py",
-  "time": 12
+  "time": 13
  },
  {
   "name": "p2p_timeouts.py",
-  "time": 5
+  "time": 6
  },
  {
   "name": "p2p_tx_download.py",
-  "time": 9
+  "time": 71
  },
  {
   "name": "p2p_unrequested_blocks.py",
@@ -333,47 +333,47 @@
  },
  {
   "name": "rpc_createmultisig.py",
-  "time": 2
+  "time": 3
  },
  {
   "name": "rpc_decodescript.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_deprecated.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_deriveaddresses.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_deriveaddresses.py --usecli",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_estimatefee.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_fundrawtransaction.py",
-  "time": 36
+  "time": 55
  },
  {
   "name": "rpc_getblockfilter.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_getblockstats.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_getchaintips.py",
-  "time": 3
+  "time": 2
  },
  {
   "name": "rpc_help.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_invalidateblock.py",
@@ -381,11 +381,11 @@
  },
  {
   "name": "rpc_misc.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_named_arguments.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_net.py",
@@ -397,11 +397,11 @@
  },
  {
   "name": "rpc_psbt.py",
-  "time": 26
+  "time": 28
  },
  {
   "name": "rpc_rawtransaction.py",
-  "time": 40
+  "time": 45
  },
  {
   "name": "rpc_scantxoutset.py",
@@ -413,7 +413,7 @@
  },
  {
   "name": "rpc_signmessage.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_signrawtransaction.py",
@@ -425,7 +425,7 @@
  },
  {
   "name": "rpc_uptime.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "rpc_users.py",
@@ -433,43 +433,43 @@
  },
  {
   "name": "rpc_whitelist.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "tool_wallet.py",
-  "time": 3
+  "time": 4
  },
  {
   "name": "wallet_abandonconflict.py",
-  "time": 4
+  "time": 16
  },
  {
   "name": "wallet_address_types.py",
-  "time": 13
+  "time": 12
  },
  {
   "name": "wallet_avoidreuse.py",
-  "time": 2
+  "time": 4
  },
  {
   "name": "wallet_backup.py",
-  "time": 36
+  "time": 33
  },
  {
   "name": "wallet_balance.py",
-  "time": 38
+  "time": 39
  },
  {
   "name": "wallet_basic.py",
-  "time": 22
+  "time": 26
  },
  {
   "name": "wallet_create_tx.py",
-  "time": 4
+  "time": 5
  },
  {
   "name": "wallet_createwallet.py",
-  "time": 2
+  "time": 3
  },
  {
   "name": "wallet_createwallet.py --usecli",
@@ -477,11 +477,11 @@
  },
  {
   "name": "wallet_disable.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "wallet_dump.py",
-  "time": 2
+  "time": 3
  },
  {
   "name": "wallet_encryption.py",
@@ -489,7 +489,7 @@
  },
  {
   "name": "wallet_groups.py",
-  "time": 10
+  "time": 11
  },
  {
   "name": "wallet_hd.py",
@@ -497,11 +497,11 @@
  },
  {
   "name": "wallet_import_rescan.py",
-  "time": 4
+  "time": 5
  },
  {
   "name": "wallet_import_with_label.py",
-  "time": 0
+  "time": 1
  },
  {
   "name": "wallet_importmulti.py",
@@ -513,11 +513,11 @@
  },
  {
   "name": "wallet_keypool.py",
-  "time": 2
+  "time": 3
  },
  {
   "name": "wallet_keypool_topup.py",
-  "time": 2
+  "time": 3
  },
  {
   "name": "wallet_labels.py",
@@ -525,31 +525,31 @@
  },
  {
   "name": "wallet_listreceivedby.py",
-  "time": 7
+  "time": 8
  },
  {
   "name": "wallet_listsinceblock.py",
-  "time": 4
+  "time": 3
  },
  {
   "name": "wallet_listtransactions.py",
-  "time": 14
+  "time": 8
  },
  {
   "name": "wallet_multiwallet.py",
-  "time": 11
+  "time": 12
  },
  {
   "name": "wallet_multiwallet.py --usecli",
-  "time": 13
+  "time": 14
  },
  {
   "name": "wallet_resendwallettransactions.py",
-  "time": 17
+  "time": 7
  },
  {
   "name": "wallet_txn_clone.py",
-  "time": 1
+  "time": 2
  },
  {
   "name": "wallet_txn_clone.py --mineblock",
diff -Nru bitcoinabc-0.21.11/test/functional/wallet_balance.py bitcoinabc-0.21.12/test/functional/wallet_balance.py
--- bitcoinabc-0.21.11/test/functional/wallet_balance.py	2020-06-22 16:12:47.000000000 +0000
+++ bitcoinabc-0.21.12/test/functional/wallet_balance.py	2020-07-16 22:14:34.000000000 +0000
@@ -251,6 +251,8 @@
         self.log.info('Put txs back into mempool of node 1 (not node 0)')
         self.nodes[0].invalidateblock(block_reorg)
         self.nodes[1].invalidateblock(block_reorg)
+        self.sync_blocks()
+        self.nodes[0].syncwithvalidationinterfacequeue()
         # wallet txs not in the mempool are untrusted
         assert_equal(self.nodes[0].getbalance(minconf=0), 0)
         self.nodes[0].generatetoaddress(1, ADDRESS_WATCHONLY)
diff -Nru bitcoinabc-0.21.11/test/functional/wallet_import_rescan.py bitcoinabc-0.21.12/test/functional/wallet_import_rescan.py
--- bitcoinabc-0.21.11/test/functional/wallet_import_rescan.py	2020-06-08 20:54:42.000000000 +0000
+++ bitcoinabc-0.21.12/test/functional/wallet_import_rescan.py	2020-07-27 15:24:34.000000000 +0000
@@ -26,7 +26,6 @@
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
-    assert_raises_rpc_error,
     connect_nodes,
     set_node_times,
 )
@@ -41,36 +40,20 @@
 
     """Helper for importing one key and verifying scanned transactions."""
 
-    def try_rpc(self, func, *args, **kwargs):
-        if self.expect_disabled:
-            assert_raises_rpc_error(-4, "Rescan is disabled in pruned mode",
-                                    func, *args, **kwargs)
-        else:
-            return func(*args, **kwargs)
-
     def do_import(self, timestamp):
         """Call one key import RPC."""
         rescan = self.rescan == Rescan.yes
 
         if self.call == Call.single:
             if self.data == Data.address:
-                response = self.try_rpc(
-                    self.node.importaddress,
-                    address=self.address["address"],
-                    label=self.label,
-                    rescan=rescan)
+                response = self.node.importaddress(
+                    address=self.address["address"], label=self.label, rescan=rescan)
             elif self.data == Data.pub:
-                response = self.try_rpc(
-                    self.node.importpubkey,
-                    pubkey=self.address["pubkey"],
-                    label=self.label,
-                    rescan=rescan)
+                response = self.node.importpubkey(
+                    pubkey=self.address["pubkey"], label=self.label, rescan=rescan)
             elif self.data == Data.priv:
-                response = self.try_rpc(
-                    self.node.importprivkey,
-                    privkey=self.key,
-                    label=self.label,
-                    rescan=rescan)
+                response = self.node.importprivkey(
+                    privkey=self.key, label=self.label, rescan=rescan)
             assert_equal(response, None)
 
         elif self.call in (Call.multiaddress, Call.multiscript):
@@ -190,15 +173,15 @@
             self.nodes[0].getbestblockhash())["time"]
         set_node_times(self.nodes, timestamp + TIMESTAMP_WINDOW + 1)
         self.nodes[0].generate(1)
-        self.sync_blocks()
+        self.sync_all()
 
         # For each variation of wallet key import, invoke the import RPC and
         # check the results from getbalance and listtransactions.
         for variant in IMPORT_VARIANTS:
-            variant.expect_disabled = variant.rescan == Rescan.yes and variant.prune and variant.call == Call.single
-            expect_rescan = variant.rescan == Rescan.yes and not variant.expect_disabled
-            variant.node = self.nodes[
-                2 + IMPORT_NODES.index(ImportNode(variant.prune, expect_rescan))]
+            self.log.info('Run import for variant {}'.format(variant))
+            expect_rescan = variant.rescan == Rescan.yes
+            variant.node = self.nodes[2 + IMPORT_NODES.index(
+                ImportNode(variant.prune, expect_rescan))]
             variant.do_import(timestamp)
             if expect_rescan:
                 variant.expected_balance = variant.initial_amount
@@ -218,16 +201,14 @@
         # Generate a block containing the new transactions.
         self.nodes[0].generate(1)
         assert_equal(self.nodes[0].getrawmempool(), [])
-        self.sync_blocks()
+        self.sync_all()
 
         # Check the latest results from getbalance and listtransactions.
         for variant in IMPORT_VARIANTS:
-            if not variant.expect_disabled:
-                variant.expected_balance += variant.sent_amount
-                variant.expected_txs += 1
-                variant.check(variant.sent_txid, variant.sent_amount, 1)
-            else:
-                variant.check()
+            self.log.info('Run check for variant {}'.format(variant))
+            variant.expected_balance += variant.sent_amount
+            variant.expected_txs += 1
+            variant.check(variant.sent_txid, variant.sent_amount, 1)
 
 
 if __name__ == "__main__":
diff -Nru bitcoinabc-0.21.11/test/fuzz/test_runner.py bitcoinabc-0.21.12/test/fuzz/test_runner.py
--- bitcoinabc-0.21.11/test/fuzz/test_runner.py	2020-06-08 20:54:42.000000000 +0000
+++ bitcoinabc-0.21.12/test/fuzz/test_runner.py	2020-07-17 21:26:12.000000000 +0000
@@ -12,6 +12,10 @@
 import subprocess
 import sys
 
+# Fuzzers known to lack a seed corpus in
+# https://github.com/Bitcoin-ABC/qa-assets/tree/master/fuzz_seed_corpus
+FUZZERS_MISSING_CORPORA = []
+
 
 def main():
     parser = argparse.ArgumentParser(
@@ -111,10 +115,14 @@
 
 def run_once(*, corpus, test_list, test_dir, export_coverage):
     for t in test_list:
+        corpus_path = os.path.join(corpus, t)
+        if t in FUZZERS_MISSING_CORPORA:
+            os.makedirs(corpus_path, exist_ok=True)
         args = [
             os.path.join(test_dir, t),
             '-runs=1',
-            os.path.join(corpus, t),
+            '-detect_leaks=0',
+            corpus_path,
         ]
         logging.debug('Run {} with args {}'.format(t, args))
         output = subprocess.run(