From eac4f023489b86ff908bc7d3f7f6dfc04bb2d4a4 Mon Sep 17 00:00:00 2001
From: Anthony Fieroni <bvbfan@abv.bg>
Date: Mon, 6 Jan 2020 20:05:09 +0200
Subject: [PATCH] Fix rebase issues

Signed-off-by: Anthony Fieroni <bvbfan@abv.bg>
---
 Makefile.am                                  |    3 -
 configure.ac                                 |   58 +-
 depends/Makefile                             |    2 +
 src/Makefile.am                              |   12 +-
 src/Makefile.bench.include                   |    1 -
 src/Makefile.qt.include                      |    2 +-
 src/Makefile.qttest.include                  |    4 +-
 src/Makefile.test.include                    |   11 +-
 src/addrdb.cpp                               |    2 +-
 src/bench/block_assemble.cpp                 |    4 +-
 src/bench/checkblock.cpp                     |    6 +-
 src/bloom.cpp                                |    4 +-
 src/chainparams.cpp                          |   21 +-
 src/claimscriptop.cpp                        |    1 +
 src/claimscriptop.h                          |   12 +-
 src/claimtrie/blob.cpp                       |    2 +-
 src/claimtrie/forks.cpp                      |    2 +-
 src/claimtrie/forks.h                        |    3 +-
 src/claimtrie/sqlite/hdr/sqlite_modern_cpp.h |    4 +-
 src/claimtrie/trie.cpp                       |   22 +-
 src/claimtrie/trie.h                         |   18 +-
 src/claimtrie/txoutpoint.cpp                 |   10 +-
 src/claimtrie/txoutpoint.h                   |    4 +-
 src/coins.h                                  |    7 +-
 src/consensus/params.h                       |    2 -
 src/consensus/validation.h                   |    1 +
 src/core_write.cpp                           |    2 +-
 src/crypto/siphash.cpp                       |    1 +
 src/index/base.cpp                           |  371 ++++
 src/index/base.h                             |  117 ++
 src/index/blockfilterindex.cpp               |  197 +--
 src/index/blockfilterindex.h                 |    2 +-
 src/init.cpp                                 |   14 +-
 src/interfaces/chain.cpp                     |    2 +-
 src/miner.cpp                                |    3 +-
 src/nameclaim.cpp                            |    8 +-
 src/nameclaim.h                              |   10 +-
 src/net_processing.cpp                       |    1 +
 src/protocol.cpp                             |   14 +-
 src/qt/bitcoingui.cpp                        |    6 -
 src/qt/guiutil.cpp                           |    3 -
 src/qt/locale/bitcoin_da.ts                  |    8 +-
 src/qt/locale/bitcoin_de.ts                  |    4 +
 src/qt/locale/bitcoin_el.ts                  |    4 -
 src/qt/locale/bitcoin_es.ts                  |    4 +
 src/qt/locale/bitcoin_fi.ts                  |   12 -
 src/qt/locale/bitcoin_fr.ts                  |    4 +
 src/qt/locale/bitcoin_ja.ts                  |   12 +-
 src/qt/locale/bitcoin_ko.ts                  |    3 +
 src/qt/locale/bitcoin_nl.ts                  |    4 +
 src/qt/locale/bitcoin_pl.ts                  |    4 +
 src/qt/locale/bitcoin_pt_BR.ts               |    4 +
 src/qt/locale/bitcoin_ro.ts                  |    8 -
 src/qt/locale/bitcoin_sk.ts                  |    4 +
 src/qt/locale/bitcoin_uk.ts                  |    3 +
 src/qt/locale/bitcoin_zh_TW.ts               |    4 +
 src/rest.cpp                                 |    8 +-
 src/rpc/claimtrie.cpp                        |   60 +-
 src/rpc/mining.cpp                           |   48 +-
 src/rpc/misc.cpp                             |    2 +-
 src/rpc/rawtransaction.cpp                   |    9 -
 src/rpc/server.cpp                           |    9 +
 src/rpc/server.h                             |   14 +
 src/scheduler.cpp                            |    2 +-
 src/script/sign.cpp                          |   23 +-
 src/script/sign.h                            |    3 -
 src/test/Checkpoints_tests.cpp               |   27 -
 src/test/claimtriebranching_tests.cpp        |   15 +-
 src/test/claimtriecache_tests.cpp            |    1 -
 src/test/claimtrieexpirationfork_tests.cpp   |    5 +-
 src/test/claimtriefixture.cpp                |   63 +-
 src/test/claimtriefixture.h                  |   24 +-
 src/test/claimtriehashfork_tests.cpp         |   47 +-
 src/test/claimtrienormalization_tests.cpp    |   17 +-
 src/test/claimtrierpc_tests.cpp              |   58 +-
 src/test/coins_tests.cpp                     |    2 +
 src/test/hash_tests.cpp                      |    1 +
 src/test/miner_tests.cpp                     |   10 +-
 src/test/nameclaim_tests.cpp                 |    2 +-
 src/test/script_tests.1cpp                   | 1665 ++++++++++++++++++
 src/test/script_tests.cpp                    |   22 +-
 src/test/serialize_tests.cpp                 |    1 +
 src/test/setup_common.cpp                    |    4 +-
 src/test/sigopcount_tests.cpp                |    1 +
 src/txdb.cpp                                 |   22 +-
 src/txdb.h                                   |   31 +-
 src/undo.h                                   |  111 +-
 src/validation.cpp                           |   76 +-
 src/validation.h                             |    5 +-
 src/versionbits.cpp                          |    6 -
 src/wallet/db.cpp                            |   38 -
 src/wallet/db.h                              |    2 -
 src/wallet/init.cpp                          |    1 +
 src/wallet/ismine.h                          |    7 +-
 src/wallet/rpcwallet.cpp                     |  104 +-
 src/wallet/test/claim_rpc_tests.cpp          |   51 +-
 src/wallet/test/wallet_tests.cpp             |   45 +-
 src/wallet/wallet.cpp                        |   23 -
 src/wallet/wallet.h                          |    7 +-
 src/wallet/walletutil.cpp                    |   11 -
 src/wallet/walletutil.h                      |   20 -
 101 files changed, 2761 insertions(+), 993 deletions(-)
 create mode 100644 src/index/base.cpp
 create mode 100644 src/index/base.h
 delete mode 100644 src/test/Checkpoints_tests.cpp
 create mode 100644 src/test/script_tests.1cpp

diff --git a/Makefile.am b/Makefile.am
index 13836c07d..50e14b934 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -175,9 +175,6 @@ $(BITCOIN_CLI_BIN): FORCE
 $(BITCOIN_TX_BIN): FORCE
 	$(MAKE) -C src $(@F)
 
-$(BITCOIN_TX_BIN): FORCE
-	$(MAKE) -C src $(@F)
-
 $(BITCOIN_WALLET_BIN): FORCE
 	$(MAKE) -C src $(@F)
 
diff --git a/configure.ac b/configure.ac
index 6b90a1443..dcdefd3c7 100644
--- a/configure.ac
+++ b/configure.ac
@@ -8,7 +8,7 @@ define(_CLIENT_VERSION_RC, 1)
 define(_COPYRIGHT_YEAR, 2019)
 define(_COPYRIGHT_HOLDERS,[The %s developers])
 define(_COPYRIGHT_HOLDERS_SUBSTITUTION,[[LBRYcrd Core]])
-AC_INIT([LBRYcrd Core],[_CLIENT_VERSION_MAJOR._CLIENT_VERSION_MINOR._CLIENT_VERSION_REVISION],[https://github.com/lbryio/lbrycrd/issues],[lbrycrd],[https://lbry.com/])
+AC_INIT([LBRYcrd Core],m4_join([.], _CLIENT_VERSION_MAJOR, _CLIENT_VERSION_MINOR, _CLIENT_VERSION_REVISION, m4_if(_CLIENT_VERSION_BUILD, [0], [], _CLIENT_VERSION_BUILD))m4_if(_CLIENT_VERSION_RC, [0], [], [rc]_CLIENT_VERSION_RC),[https://github.com/lbryio/lbrycrd/issues],[lbrycrd],[https://lbry.com/])
 AC_CONFIG_SRCDIR([src/validation.cpp])
 AC_CONFIG_HEADERS([src/config/bitcoin-config.h])
 AC_CONFIG_AUX_DIR([build-aux])
@@ -438,23 +438,29 @@ fi
 
 CPPFLAGS="$CPPFLAGS -DHAVE_BUILD_INFO -D__STDC_FORMAT_MACROS"
 
+AC_ARG_WITH([utils],
+  [AS_HELP_STRING([--with-utils],
+  [build lbrycrd-cli lbrycrd-tx lbrycrd-wallet (default=yes)])],
+  [build_lbrycrd_utils=$withval],
+  [build_lbrycrd_utils=yes])
+
 AC_ARG_ENABLE([util-cli],
   [AS_HELP_STRING([--enable-util-cli],
   [build lbrycrd-cli])],
   [build_lbrycrd_cli=$enableval],
-  [build_lbrycrd_cli=$build_bitcoin_utils])
+  [build_lbrycrd_cli=$build_lbrycrd_utils])
 
 AC_ARG_ENABLE([util-tx],
   [AS_HELP_STRING([--enable-util-tx],
   [build lbrycrd-tx])],
   [build_lbrycrd_tx=$enableval],
-  [build_lbrycrd_tx=$build_bitcoin_utils])
+  [build_lbrycrd_tx=$build_lbrycrd_utils])
 
 AC_ARG_ENABLE([util-wallet],
   [AS_HELP_STRING([--enable-util-wallet],
   [build lbrycrd-wallet])],
   [build_lbrycrd_wallet=$enableval],
-  [build_lbrycrd_wallet=$build_bitcoin_utils])
+  [build_lbrycrd_wallet=$build_lbrycrd_utils])
 
 AC_ARG_WITH([libs],
   [AS_HELP_STRING([--with-libs],
@@ -511,7 +517,6 @@ case $host in
      fi
 
      CPPFLAGS="$CPPFLAGS -D_MT -DWIN32 -D_WINDOWS -DBOOST_THREAD_USE_LIB -D_WIN32_WINNT=0x0601"
-     LEVELDB_TARGET_FLAGS="-DOS_WINDOWS"
      if test "x$CXXFLAGS_overridden" = "xno"; then
        CXXFLAGS="$CXXFLAGS -w"
      fi
@@ -533,7 +538,6 @@ case $host in
      ;;
   *darwin*)
      TARGET_OS=darwin
-     LEVELDB_TARGET_FLAGS="-DOS_MACOSX"
      if  test x$cross_compiling != xyes; then
        BUILD_OS=darwin
        AC_PATH_PROGS([RSVG_CONVERT], [rsvg-convert rsvg],rsvg-convert)
@@ -587,37 +591,8 @@ case $host in
      CPPFLAGS="$CPPFLAGS -DMAC_OSX -DOBJC_OLD_DISPATCH_PROTOTYPES=0"
      OBJCXXFLAGS="$CXXFLAGS"
      ;;
-   *android*)
-     dnl make sure android stays above linux for hosts like *linux-android*
-     LEVELDB_TARGET_FLAGS="-DOS_ANDROID"
-     ;;
    *linux*)
      TARGET_OS=linux
-     LEVELDB_TARGET_FLAGS="-DOS_LINUX"
-     ;;
-   *kfreebsd*)
-     LEVELDB_TARGET_FLAGS="-DOS_KFREEBSD"
-     ;;
-   *freebsd*)
-     LEVELDB_TARGET_FLAGS="-DOS_FREEBSD"
-     ;;
-   *openbsd*)
-     LEVELDB_TARGET_FLAGS="-DOS_OPENBSD"
-     ;;
-   *netbsd*)
-     LEVELDB_TARGET_FLAGS="-DOS_NETBSD"
-     ;;
-   *dragonfly*)
-     LEVELDB_TARGET_FLAGS="-DOS_DRAGONFLYBSD"
-     ;;
-   *solaris*)
-     LEVELDB_TARGET_FLAGS="-DOS_SOLARIS"
-     ;;
-   *hpux*)
-     LEVELDB_TARGET_FLAGS="-DOS_HPUX"
-     ;;
-   *)
-     AC_MSG_ERROR(Cannot build leveldb for $host. Please file a bug report.)
      ;;
 esac
 
@@ -986,18 +961,10 @@ AC_LINK_IFELSE(
 # Define to 1 if std::system or ::wsystem (Windows) is available
 AC_DEFINE([HAVE_SYSTEM], [HAVE_STD__SYSTEM || HAVE_WSYSTEM], [std::system or ::wsystem])
 
-LEVELDB_CPPFLAGS=
-LIBLEVELDB=
-LIBMEMENV=
-AM_CONDITIONAL([EMBEDDED_LEVELDB],[true])
-AC_SUBST(LEVELDB_CPPFLAGS)
-AC_SUBST(LIBLEVELDB)
-AC_SUBST(LIBMEMENV)
-
 dnl enable-fuzz should disable all other targets
 if test "x$enable_fuzz" = "xyes"; then
   AC_MSG_WARN(enable-fuzz will disable all other targets)
-  build_bitcoin_utils=no
+  build_lbrycrd_utils=no
   build_lbrycrd_cli=no
   build_lbrycrd_tx=no
   build_lbrycrd_wallet=no
@@ -1412,7 +1379,7 @@ if test x$have_protobuf != xno &&
   BITCOIN_QT_PATH_PROGS([PROTOC], [protoc],$protoc_bin_path)
 fi
 
-AC_MSG_CHECKING([whether to build bitcoind])
+AC_MSG_CHECKING([whether to build lbrycrdd])
 AM_CONDITIONAL([BUILD_BITCOIND], [test x$build_lbrycrdd = xyes])
 AC_MSG_RESULT($build_lbrycrdd)
 
@@ -1646,7 +1613,6 @@ AC_SUBST(BOOST_LIBS)
 AC_SUBST(ICU_CPPFLAGS)
 AC_SUBST(ICU_LIBS)
 AC_SUBST(TESTDEFS)
-AC_SUBST(LEVELDB_TARGET_FLAGS)
 AC_SUBST(MINIUPNPC_CPPFLAGS)
 AC_SUBST(MINIUPNPC_LIBS)
 AC_SUBST(CRYPTO_LIBS)
diff --git a/depends/Makefile b/depends/Makefile
index 7243cc61e..ec5d16519 100644
--- a/depends/Makefile
+++ b/depends/Makefile
@@ -114,6 +114,8 @@ endif
 
 ifeq ($(rapidcheck_packages_),)
 packages += $(rapidcheck_packages)
+endif
+
 all_packages = $(packages) $(native_packages)
 
 meta_depends = Makefile funcs.mk builders/default.mk hosts/default.mk hosts/$(host_os).mk builders/$(build_os).mk
diff --git a/src/Makefile.am b/src/Makefile.am
index 2709780ad..95a7cc887 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -137,6 +137,7 @@ BITCOIN_CORE_H = \
   fs.h \
   httprpc.h \
   httpserver.h \
+  index/base.h \
   index/blockfilterindex.h \
   indirectmap.h \
   init.h \
@@ -275,13 +276,13 @@ libbitcoin_server_a_SOURCES = \
   flatfile.cpp \
   httprpc.cpp \
   httpserver.cpp \
+  index/base.cpp \
   index/blockfilterindex.cpp \
   interfaces/chain.cpp \
   interfaces/node.cpp \
   init.cpp \
   lbry.cpp \
   miner.cpp \
-  nameclaim.cpp \
   net.cpp \
   net_processing.cpp \
   node/coin.cpp \
@@ -309,7 +310,6 @@ libbitcoin_server_a_SOURCES = \
   txmempool.cpp \
   ui_interface.cpp \
   uint256.cpp \
-  utilstrencodings.cpp \
   validation.cpp \
   validationinterface.cpp \
   versionbits.cpp \
@@ -362,7 +362,7 @@ libbitcoin_wallet_tool_a_SOURCES = \
   $(BITCOIN_CORE_H)
 
 # crypto primitives library
-crypto_libbitcoin_crypto_base_a_CPPFLAGS = $(AM_CPPFLAGS)
+crypto_libbitcoin_crypto_base_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
 crypto_libbitcoin_crypto_base_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 crypto_libbitcoin_crypto_base_a_SOURCES = \
   crypto/aes.cpp \
@@ -573,7 +573,6 @@ lbrycrdd_LDADD = \
   $(LIBBITCOIN_ZMQ) \
   $(LIBBITCOIN_CONSENSUS) \
   $(LIBBITCOIN_CRYPTO) \
-  $(LIBMEMENV) \
   $(LIBSECP256K1)
 
 lbrycrdd_LDADD += $(BOOST_LIBS) $(LIBCLAIMTRIE) $(BOOST_LOCALE_LIB) $(BDB_LIBS) $(CRYPTO_LIBS) $(ICU_LIBS) $(MINIUPNPC_LIBS) $(EVENT_PTHREADS_LIBS) $(EVENT_LIBS) $(ZMQ_LIBS)
@@ -630,15 +629,14 @@ endif
 
 lbrycrd_wallet_LDADD = \
   $(LIBBITCOIN_WALLET_TOOL) \
+  $(LIBBITCOIN_SERVER) \
   $(LIBBITCOIN_WALLET) \
+  $(LIBBITCOIN_SERVER) \
   $(LIBBITCOIN_COMMON) \
   $(LIBBITCOIN_CONSENSUS) \
   $(LIBBITCOIN_UTIL) \
   $(LIBBITCOIN_CRYPTO) \
   $(LIBBITCOIN_ZMQ) \
-  $(LIBLEVELDB) \
-  $(LIBLEVELDB_SSE42) \
-  $(LIBMEMENV) \
   $(LIBSECP256K1) \
   $(LIBUNIVALUE)
 
diff --git a/src/Makefile.bench.include b/src/Makefile.bench.include
index 13af2dea5..ac9ae9ec1 100644
--- a/src/Makefile.bench.include
+++ b/src/Makefile.bench.include
@@ -56,7 +56,6 @@ bench_bench_bitcoin_LDADD = \
   $(LIBBITCOIN_UTIL) \
   $(LIBBITCOIN_CONSENSUS) \
   $(LIBBITCOIN_CRYPTO) \
-  $(LIBMEMENV) \
   $(LIBSECP256K1) \
   $(LIBUNIVALUE) \
   $(EVENT_PTHREADS_LIBS) \
diff --git a/src/Makefile.qt.include b/src/Makefile.qt.include
index 9beab6c06..7c22a0760 100644
--- a/src/Makefile.qt.include
+++ b/src/Makefile.qt.include
@@ -334,7 +334,7 @@ endif
 if ENABLE_ZMQ
 qt_lbrycrd_qt_LDADD += $(LIBBITCOIN_ZMQ) $(ZMQ_LIBS)
 endif
-qt_lbrycrd_qt_LDADD += $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) $(LIBMEMENV) \
+qt_lbrycrd_qt_LDADD += $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) \
   $(BOOST_LIBS) $(LIBCLAIMTRIE) $(BOOST_LOCALE_LIB) $(QT_LIBS) $(QT_DBUS_LIBS) $(QR_LIBS) $(PROTOBUF_LIBS) $(ICU_LIBS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS) $(LIBSECP256K1) \
   $(EVENT_PTHREADS_LIBS) $(EVENT_LIBS)
 if ENABLE_BIP70
diff --git a/src/Makefile.qttest.include b/src/Makefile.qttest.include
index 14c069e2d..50a216443 100644
--- a/src/Makefile.qttest.include
+++ b/src/Makefile.qttest.include
@@ -58,7 +58,7 @@ qt_test_test_lbrycrd_qt_SOURCES += \
   qt/test/wallettests.cpp \
   wallet/test/wallet_test_fixture.cpp
 if ENABLE_BIP70
-qt_test_test_bitcoin_qt_SOURCES += \
+qt_test_test_lbrycrd_qt_SOURCES += \
   qt/test/paymentservertests.cpp
 endif # ENABLE_BIP70
 endif # ENABLE_WALLET
@@ -73,7 +73,7 @@ if ENABLE_ZMQ
 qt_test_test_lbrycrd_qt_LDADD += $(LIBBITCOIN_ZMQ) $(ZMQ_LIBS)
 endif
 qt_test_test_lbrycrd_qt_LDADD += $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) \
-  $(LIBMEMENV) $(BOOST_LIBS) $(LIBCLAIMTRIE) $(BOOST_LOCALE_LIB) $(QT_DBUS_LIBS) $(QT_TEST_LIBS) $(QT_LIBS) \
+  $(BOOST_LIBS) $(LIBCLAIMTRIE) $(BOOST_LOCALE_LIB) $(QT_DBUS_LIBS) $(QT_TEST_LIBS) $(QT_LIBS) \
   $(QR_LIBS) $(PROTOBUF_LIBS) $(ICU_LIBS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS) $(LIBSECP256K1) \
   $(EVENT_PTHREADS_LIBS) $(EVENT_LIBS)
 qt_test_test_lbrycrd_qt_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(QT_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 930e60f8b..ccb2bc054 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -68,15 +68,12 @@ FUZZ_SUITE_LD_COMMON = \
  $(LIBBITCOIN_CONSENSUS) \
  $(LIBBITCOIN_CRYPTO) \
  $(LIBUNIVALUE) \
- $(LIBLEVELDB) \
- $(LIBLEVELDB_SSE42) \
  $(BOOST_LIBS) \
- $(LIBMEMENV) \
  $(LIBSECP256K1) \
  $(EVENT_LIBS) \
  $(CRYPTO_LIBS) \
- $(EVENT_PTHREADS_LIBS)
- $(LIBCLAIMTRIE)
+ $(EVENT_PTHREADS_LIBS) \
+ $(LIBCLAIMTRIE) \
  $(BOOST_LOCALE_LIB)
 
 # test_bitcoin binary #
@@ -96,7 +93,6 @@ BITCOIN_TESTS =\
   test/blockfilter_tests.cpp \
   test/blockfilter_index_tests.cpp \
   test/bloom_tests.cpp \
-  test/Checkpoints_tests.cpp \
   test/bswap_tests.cpp \
   test/checkqueue_tests.cpp \
   test/coins_tests.cpp \
@@ -173,7 +169,6 @@ if ENABLE_WALLET
 BITCOIN_TESTS += \
   wallet/test/db_tests.cpp \
   wallet/test/claim_rpc_tests.cpp \
-  wallet/test/db_tests.cpp \
   wallet/test/psbt_wallet_tests.cpp \
   wallet/test/wallet_tests.cpp \
   wallet/test/wallet_crypto_tests.cpp \
@@ -196,7 +191,7 @@ test_test_lbrycrd_LDADD += $(LIBBITCOIN_WALLET)
 endif
 
 test_test_lbrycrd_LDADD += $(LIBBITCOIN_SERVER) $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) \
-  $(LIBMEMENV) $(BOOST_LIBS) $(LIBCLAIMTRIE) $(BOOST_LOCALE_LIB) $(BOOST_UNIT_TEST_FRAMEWORK_LIB) $(LIBSECP256K1) $(EVENT_LIBS) $(EVENT_PTHREADS_LIBS)
+  $(BOOST_LIBS) $(LIBCLAIMTRIE) $(BOOST_LOCALE_LIB) $(BOOST_UNIT_TEST_FRAMEWORK_LIB) $(LIBSECP256K1) $(EVENT_LIBS) $(EVENT_PTHREADS_LIBS)
 test_test_lbrycrd_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 
 test_test_lbrycrd_LDADD += $(BDB_LIBS) $(CRYPTO_LIBS) $(ICU_LIBS) $(MINIUPNPC_LIBS) $(RAPIDCHECK_LIBS)
diff --git a/src/addrdb.cpp b/src/addrdb.cpp
index 5993f96aa..db936486b 100644
--- a/src/addrdb.cpp
+++ b/src/addrdb.cpp
@@ -110,7 +110,7 @@ bool DeserializeFileDB(const fs::path& path, Data& data)
     FILE *file = fsbridge::fopen(path, "rb");
     CAutoFile filein(file, SER_DISK, CLIENT_VERSION);
     if (filein.IsNull())
-        return false;
+        return error("%s: Failed to open file %s", __func__, path.string());
 
     return DeserializeDB(filein, data);
 }
diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index f0fe898ed..089f9af5e 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -3,13 +3,13 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
+#include <chainparams.h>
 #include <consensus/validation.h>
 #include <crypto/sha256.h>
 #include <test/util.h>
 #include <txmempool.h>
-#include <util.h>
 #include <validation.h>
-
+#include <util/system.h>
 
 #include <list>
 #include <vector>
diff --git a/src/bench/checkblock.cpp b/src/bench/checkblock.cpp
index ce52906e9..c53afa37c 100644
--- a/src/bench/checkblock.cpp
+++ b/src/bench/checkblock.cpp
@@ -58,22 +58,24 @@ CDataStream getTestBlockStream()
 static void DeserializeBlockTest(benchmark::State& state)
 {
     auto stream = getTestBlockStream();
+    auto size = stream.size() - 1;
     while (state.KeepRunning()) {
         CBlock block;
         stream >> block;
-        assert(stream.Rewind(block.size()));
+        assert(stream.Rewind(size));
     }
 }
 
 static void DeserializeAndCheckBlockTest(benchmark::State& state)
 {
     auto stream = getTestBlockStream();
+    auto size = stream.size() - 1;
     const auto chainParams = CreateChainParams(CBaseChainParams::REGTEST);
 
     while (state.KeepRunning()) {
         CBlock block; // Note that CBlock caches its checked state, so we need to recreate it here
         stream >> block;
-        assert(stream.Rewind(block.size()));
+        assert(stream.Rewind(size));
 
         CValidationState validationState;
         bool checked = CheckBlock(block, validationState, chainParams->GetConsensus());
diff --git a/src/bloom.cpp b/src/bloom.cpp
index a59bfeaba..a06192508 100644
--- a/src/bloom.cpp
+++ b/src/bloom.cpp
@@ -3,7 +3,6 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bloom.h>
-#include <nameclaim.h>
 
 #include <primitives/transaction.h>
 #include <hash.h>
@@ -156,8 +155,7 @@ bool CBloomFilter::IsRelevantAndUpdate(const CTransaction& tx)
                 else if ((nFlags & BLOOM_UPDATE_MASK) == BLOOM_UPDATE_P2PUBKEY_ONLY)
                 {
                     std::vector<std::vector<unsigned char> > vSolutions;
-                    const CScript& scriptPubKey = txout.scriptPubKey;
-                    txnouttype type = Solver(scriptPubKey, vSolutions);
+                    txnouttype type = Solver(txout.scriptPubKey, vSolutions);
                     if (type == TX_PUBKEY || type == TX_MULTISIG) {
                         insert(COutPoint(hash, i));
                     }
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 5a1af7619..de1be5b62 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -3,8 +3,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <arith_uint256.h>
 #include <chainparams.h>
-
 #include <chainparamsseeds.h>
 #include <consensus/merkle.h>
 #include <tinyformat.h>
@@ -125,9 +125,9 @@ public:
         consensus.BIP66Height = 200000;
         consensus.powLimit = uint256S("0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.nPowTargetTimespan = 150; //retarget every block
-        consensus.CSVHeight = 419328; // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
-        consensus.SegwitHeight = 481824; // 0000000000000000001c8018d9cb3b742ef25114f27563e3fc4a1902167f9893
-        consensus.MinBIP9WarningHeight = 483840; // segwit activation height + miner confirmation window
+        consensus.CSVHeight = 200000;
+        consensus.SegwitHeight = 680770;
+        consensus.MinBIP9WarningHeight = 682786; // segwit activation height + miner confirmation window
         consensus.nPowTargetSpacing = 150;
         consensus.nOriginalClaimExpirationTime = 262974;
         consensus.nExtendedClaimExpirationTime = 2102400;
@@ -137,7 +137,6 @@ public:
         consensus.nNormalizedNameForkHeight = 539940; // targeting 21 March 2019
         consensus.nMinRemovalWorkaroundHeight = 297706;
         consensus.nMaxRemovalWorkaroundHeight = 100000000;
-        consensus.nWitnessForkHeight = 680770; // targeting 11 Dec 2019
         consensus.nAllClaimsInMerkleForkHeight = 658310; // targeting 30 Oct 2019
         consensus.fPowAllowMinDifficultyBlocks = false;
         consensus.fPowNoRetargeting = false;
@@ -236,9 +235,9 @@ public:
         consensus.BIP66Height = 1200000;
         consensus.powLimit = uint256S("0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.nPowTargetTimespan = 150;
-        consensus.CSVHeight = 770112; // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
-        consensus.SegwitHeight = 834624; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca
-        consensus.MinBIP9WarningHeight = 836640; // segwit activation height + miner confirmation window
+        consensus.CSVHeight = 1200000;
+        consensus.SegwitHeight = 1198600;
+        consensus.MinBIP9WarningHeight = 1200616; // segwit activation height + miner confirmation window
         consensus.nPowTargetSpacing = 150;
         consensus.nOriginalClaimExpirationTime = 262974;
         consensus.nExtendedClaimExpirationTime = 2102400;
@@ -248,7 +247,6 @@ public:
         consensus.nNormalizedNameForkHeight = 993380;   // targeting, 21 Feb 2019
         consensus.nMinRemovalWorkaroundHeight = 99;
         consensus.nMaxRemovalWorkaroundHeight = 100000000;
-        consensus.nWitnessForkHeight = 1198600;
         consensus.nAllClaimsInMerkleForkHeight = 1198560; // targeting 30 Sep 2019
         consensus.fPowAllowMinDifficultyBlocks = true;
         consensus.fPowNoRetargeting = false;
@@ -334,8 +332,8 @@ public:
         consensus.BIP65Height = 1351; // BIP65 activated on regtest (Used in rpc activation tests)
         consensus.BIP66Height = 1251; // BIP66 activated on regtest (Used in rpc activation tests)
         consensus.CSVHeight = 432; // CSV activated on regtest (Used in rpc activation tests)
-        consensus.SegwitHeight = 0; // SEGWIT is always activated on regtest unless overridden
-        consensus.MinBIP9WarningHeight = 0;
+        consensus.SegwitHeight = 150; // SEGWIT is always activated on regtest unless overridden
+        consensus.MinBIP9WarningHeight = 294;
         consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.nPowTargetTimespan = 1;//14 * 24 * 60 * 60; // two weeks
         consensus.nPowTargetSpacing = 1;
@@ -347,7 +345,6 @@ public:
         consensus.nNormalizedNameForkHeight = 250; // SDK depends upon this number
         consensus.nMinRemovalWorkaroundHeight = -1;
         consensus.nMaxRemovalWorkaroundHeight = -1;
-        consensus.nWitnessForkHeight = 150;
         consensus.nAllClaimsInMerkleForkHeight = 350;
         consensus.fPowAllowMinDifficultyBlocks = false;
         consensus.fPowNoRetargeting = false;
diff --git a/src/claimscriptop.cpp b/src/claimscriptop.cpp
index 62d8db381..cea777ab3 100644
--- a/src/claimscriptop.cpp
+++ b/src/claimscriptop.cpp
@@ -4,6 +4,7 @@
 
 #include <coins.h>
 #include <claimscriptop.h>
+#include <logging.h>
 #include <nameclaim.h>
 
 CClaimScriptAddOp::CClaimScriptAddOp(const COutPoint& point, CAmount nValue, int nHeight)
diff --git a/src/claimscriptop.h b/src/claimscriptop.h
index 915ff1dc0..ff9e9424d 100644
--- a/src/claimscriptop.h
+++ b/src/claimscriptop.h
@@ -5,13 +5,11 @@
 #ifndef CLAIMSCRIPTOP_H
 #define CLAIMSCRIPTOP_H
 
-#include "amount.h"
-#include "claimtrie/forks.h"
-#include "hash.h"
-#include "primitives/transaction.h"
-#include "script/script.h"
-#include "uint256.h"
-#include "util.h"
+#include <amount.h>
+#include <claimtrie/forks.h>
+#include <claimtrie/uints.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
 
 #include <string>
 #include <vector>
diff --git a/src/claimtrie/blob.cpp b/src/claimtrie/blob.cpp
index 9a86c2097..b492f7887 100644
--- a/src/claimtrie/blob.cpp
+++ b/src/claimtrie/blob.cpp
@@ -112,7 +112,7 @@ void CBaseBlob<BITS>::SetHex(const char* psz)
 template<uint32_t BITS>
 uint64_t CBaseBlob<BITS>::GetUint64(int pos) const
 {
-    assert((pos + 1) * 8 <= size());
+    assert(uint32_t(pos + 1) * 8 <= size());
     const uint8_t* ptr = begin() + pos * 8;
     uint64_t res = 0;
     for (int i = 0; i < 8; ++i)
diff --git a/src/claimtrie/forks.cpp b/src/claimtrie/forks.cpp
index dea3e7909..62af1475b 100644
--- a/src/claimtrie/forks.cpp
+++ b/src/claimtrie/forks.cpp
@@ -203,7 +203,7 @@ bool CClaimTrieCacheNormalizationFork::getProofForName(const std::string& name,
     return CClaimTrieCacheExpirationFork::getProofForName(normalizeClaimName(name), claim, proof);
 }
 
-bool CClaimTrieCacheNormalizationFork::getInfoForName(const std::string& name, CClaimValue& claim, int offsetHeight) const
+bool CClaimTrieCacheNormalizationFork::getInfoForName(const std::string& name, CClaimValue& claim, int offsetHeight)
 {
     return CClaimTrieCacheExpirationFork::getInfoForName(normalizeClaimName(name), claim, offsetHeight);
 }
diff --git a/src/claimtrie/forks.h b/src/claimtrie/forks.h
index 0e780bcc7..74cd9624d 100644
--- a/src/claimtrie/forks.h
+++ b/src/claimtrie/forks.h
@@ -38,7 +38,8 @@ public:
     bool decrementBlock() override;
 
     bool getProofForName(const std::string& name, const uint160& claim, CClaimTrieProof& proof) override;
-    bool getInfoForName(const std::string& name, CClaimValue& claim, int heightOffset = 0) const override;
+    bool getInfoForName(const std::string& name, CClaimValue& claim, int heightOffset = 0) override;
+
     CClaimSupportToName getClaimsForName(const std::string& name) const override;
     std::string adjustNameForValidHeight(const std::string& name, int validHeight) const override;
 
diff --git a/src/claimtrie/sqlite/hdr/sqlite_modern_cpp.h b/src/claimtrie/sqlite/hdr/sqlite_modern_cpp.h
index 81721d0cb..15287d0eb 100644
--- a/src/claimtrie/sqlite/hdr/sqlite_modern_cpp.h
+++ b/src/claimtrie/sqlite/hdr/sqlite_modern_cpp.h
@@ -402,11 +402,11 @@ namespace sqlite {
         database(std::shared_ptr<sqlite3> db):
                 _db(db) {}
 
-        database_binder operator<<(str_ref sql) {
+        database_binder operator<<(str_ref sql) const {
             return database_binder(_db, sql);
         }
 
-        database_binder operator<<(u16str_ref sql) {
+        database_binder operator<<(u16str_ref sql) const {
             return database_binder(_db, sql);
         }
 
diff --git a/src/claimtrie/trie.cpp b/src/claimtrie/trie.cpp
index 944017577..5584b2280 100644
--- a/src/claimtrie/trie.cpp
+++ b/src/claimtrie/trie.cpp
@@ -355,7 +355,7 @@ int64_t CClaimTrieCacheBase::getTotalValueOfClaimsInTrie(bool fControllingOnly)
     return ret;
 }
 
-bool CClaimTrieCacheBase::getInfoForName(const std::string& name, CClaimValue& claim, int heightOffset) const
+bool CClaimTrieCacheBase::getInfoForName(const std::string& name, CClaimValue& claim, int heightOffset)
 {
     auto ret = false;
     auto nextHeight = nNextHeight + heightOffset;
@@ -509,10 +509,11 @@ extern const std::string proofClaimQuery_s =
     "ORDER BY n.name";
 
 CClaimTrieCacheBase::CClaimTrieCacheBase(CClaimTrie* base)
-    : base(base), db(base->dbFile, sharedConfig), transacting(false),
+    : base(base), db(base->dbFile, sharedConfig),
       childHashQuery(db << childHashQuery_s),
       claimHashQuery(db << claimHashQuery_s),
-      claimHashQueryLimit(db << claimHashQueryLimit_s)
+      claimHashQueryLimit(db << claimHashQueryLimit_s),
+      transacting(false)
 {
     assert(base);
     nNextHeight = base->nNextHeight;
@@ -900,7 +901,8 @@ void CClaimTrieCacheBase::getNamesInTrie(std::function<void(const std::string&)>
         };
 }
 
-std::vector<uint160> CClaimTrieCacheBase::getActivatedClaims(int height) {
+std::vector<uint160> CClaimTrieCacheBase::getActivatedClaims(int height) const
+{
     std::vector<uint160> ret;
     auto query = db << "SELECT DISTINCT claimID FROM claim WHERE activationHeight = ?1 AND blockHeight < ?1" << height;
     for (auto&& row: query) {
@@ -909,7 +911,9 @@ std::vector<uint160> CClaimTrieCacheBase::getActivatedClaims(int height) {
     }
     return ret;
 }
-std::vector<uint160> CClaimTrieCacheBase::getClaimsWithActivatedSupports(int height) {
+
+std::vector<uint160> CClaimTrieCacheBase::getClaimsWithActivatedSupports(int height) const
+{
     std::vector<uint160> ret;
     auto query = db << "SELECT DISTINCT supportedClaimID FROM support WHERE activationHeight = ?1 AND blockHeight < ?1" << height;
     for (auto&& row: query) {
@@ -918,7 +922,9 @@ std::vector<uint160> CClaimTrieCacheBase::getClaimsWithActivatedSupports(int hei
     }
     return ret;
 }
-std::vector<uint160> CClaimTrieCacheBase::getExpiredClaims(int height) {
+
+std::vector<uint160> CClaimTrieCacheBase::getExpiredClaims(int height) const
+{
     std::vector<uint160> ret;
     auto query = db << "SELECT DISTINCT claimID FROM claim WHERE expirationHeight = ?1 AND blockHeight < ?1" << height;
     for (auto&& row: query) {
@@ -927,7 +933,9 @@ std::vector<uint160> CClaimTrieCacheBase::getExpiredClaims(int height) {
     }
     return ret;
 }
-std::vector<uint160> CClaimTrieCacheBase::getClaimsWithExpiredSupports(int height) {
+
+std::vector<uint160> CClaimTrieCacheBase::getClaimsWithExpiredSupports(int height) const
+{
     std::vector<uint160> ret;
     auto query = db << "SELECT DISTINCT supportedClaimID FROM support WHERE expirationHeight = ?1 AND blockHeight < ?1" << height;
     for (auto&& row: query) {
diff --git a/src/claimtrie/trie.h b/src/claimtrie/trie.h
index 5beea596d..598ac90ad 100644
--- a/src/claimtrie/trie.h
+++ b/src/claimtrie/trie.h
@@ -52,7 +52,8 @@ protected:
     const int nProportionalDelayFactor;
 
     const int nNormalizedNameForkHeight;
-    const int nMinRemovalWorkaroundHeight, nMaxRemovalWorkaroundHeight;
+    const int nMinRemovalWorkaroundHeight;
+    const int nMaxRemovalWorkaroundHeight;
     const int64_t nOriginalClaimExpirationTime;
     const int64_t nExtendedClaimExpirationTime;
     const int64_t nExtendedClaimExpirationForkHeight;
@@ -95,8 +96,8 @@ public:
 
     virtual int expirationTime() const;
 
+    virtual bool getInfoForName(const std::string& name, CClaimValue& claim, int heightOffset = 0);
     virtual bool getProofForName(const std::string& name, const uint160& claim, CClaimTrieProof& proof);
-    virtual bool getInfoForName(const std::string& name, CClaimValue& claim, int heightOffset = 0) const;
 
     virtual CClaimSupportToName getClaimsForName(const std::string& name) const;
     virtual std::string adjustNameForValidHeight(const std::string& name, int validHeight) const;
@@ -105,18 +106,17 @@ public:
     bool getLastTakeoverForName(const std::string& name, uint160& claimId, int& takeoverHeight) const;
     bool findNameForClaim(std::vector<unsigned char> claim, CClaimValue& value, std::string& name) const;
 
-    std::vector<uint160> getActivatedClaims(int height);
-    std::vector<uint160> getClaimsWithActivatedSupports(int height);
-    std::vector<uint160> getExpiredClaims(int height);
-    std::vector<uint160> getClaimsWithExpiredSupports(int height);
+    std::vector<uint160> getActivatedClaims(int height) const;
+    std::vector<uint160> getClaimsWithActivatedSupports(int height) const;
+    std::vector<uint160> getExpiredClaims(int height) const;
+    std::vector<uint160> getClaimsWithExpiredSupports(int height) const;
 
 protected:
     int nNextHeight; // Height of the block that is being worked on, which is
     CClaimTrie* base;
-    mutable sqlite::database db;
+    sqlite::database db;
     mutable std::unordered_set<std::string> removalWorkaround;
-
-    mutable sqlite::database_binder claimHashQuery, childHashQuery, claimHashQueryLimit;
+    sqlite::database_binder childHashQuery, claimHashQuery, claimHashQueryLimit;
 
     virtual uint256 computeNodeHash(const std::string& name, int takeoverHeight);
     supportEntryType getSupportsForName(const std::string& name) const;
diff --git a/src/claimtrie/txoutpoint.cpp b/src/claimtrie/txoutpoint.cpp
index 1a16b1c49..ab53d9eb7 100644
--- a/src/claimtrie/txoutpoint.cpp
+++ b/src/claimtrie/txoutpoint.cpp
@@ -1,8 +1,14 @@
 
 #include <txoutpoint.h>
 
+#include <limits>
 #include <sstream>
 
+COutPoint::COutPoint() noexcept
+{
+    SetNull();
+}
+
 COutPoint::COutPoint(uint256 hashIn, uint32_t nIn) : hash(std::move(hashIn)), n(nIn)
 {
 }
@@ -10,12 +16,12 @@ COutPoint::COutPoint(uint256 hashIn, uint32_t nIn) : hash(std::move(hashIn)), n(
 void COutPoint::SetNull()
 {
     hash.SetNull();
-    n = uint32_t(-1);
+    n = std::numeric_limits<uint32_t>::max();
 }
 
 bool COutPoint::IsNull() const
 {
-    return hash.IsNull() && n == uint32_t(-1);
+    return hash.IsNull() && n == std::numeric_limits<uint32_t>::max();
 }
 
 bool COutPoint::operator<(const COutPoint& b) const
diff --git a/src/claimtrie/txoutpoint.h b/src/claimtrie/txoutpoint.h
index 2398c97dc..5045e55e9 100644
--- a/src/claimtrie/txoutpoint.h
+++ b/src/claimtrie/txoutpoint.h
@@ -15,9 +15,9 @@ class COutPoint
 {
 public:
     uint256 hash;
-    uint32_t n = uint32_t(-1);
+    uint32_t n;
 
-    COutPoint() = default;
+    COutPoint() noexcept;
     COutPoint(COutPoint&&) = default;
     COutPoint(const COutPoint&) = default;
     COutPoint(uint256 hashIn, uint32_t nIn);
diff --git a/src/coins.h b/src/coins.h
index 5bacc0530..bdfff0ed1 100644
--- a/src/coins.h
+++ b/src/coins.h
@@ -40,8 +40,8 @@ public:
     uint32_t nHeight : 31;
 
     //! construct a Coin from a CTxOut and height/coinbase information.
-  Coin(CTxOut&& outIn, int nHeightIn, bool fCoinBaseIn) : out(std::move(outIn)), fCoinBase(fCoinBaseIn), nHeight(nHeightIn) {}
-  Coin(const CTxOut& outIn, int nHeightIn, bool fCoinBaseIn) : out(outIn), fCoinBase(fCoinBaseIn), nHeight(nHeightIn) {}
+    Coin(CTxOut&& outIn, int nHeightIn, bool fCoinBaseIn) : out(std::move(outIn)), fCoinBase(fCoinBaseIn), nHeight(nHeightIn) {}
+    Coin(const CTxOut& outIn, int nHeightIn, bool fCoinBaseIn) : out(outIn), fCoinBase(fCoinBaseIn),nHeight(nHeightIn) {}
 
     void Clear() {
         out.SetNull();
@@ -133,7 +133,6 @@ typedef std::unordered_map<COutPoint, CCoinsCacheEntry, SaltedOutpointHasher> CC
 /** Cursor for iterating over CoinsView state */
 class CCoinsViewCursor
 {
-    uint256 hashBlock;
 public:
     CCoinsViewCursor(const uint256 &hashBlockIn): hashBlock(hashBlockIn) {}
     virtual ~CCoinsViewCursor() noexcept {}
@@ -146,6 +145,8 @@ public:
 
     //! Get best block at the time this cursor was created
     const uint256 &GetBestBlock() const { return hashBlock; }
+private:
+    uint256 hashBlock;
 };
 
 /** Abstract view on the open txout dataset. */
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 33dd801f7..2a8ff4564 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -88,8 +88,6 @@ struct Params {
     int nMinRemovalWorkaroundHeight;
     int nMaxRemovalWorkaroundHeight;
 
-    int nWitnessForkHeight;
-
     int64_t nPowTargetSpacing;
     int64_t nPowTargetTimespan;
     /** how long it took claims to expire before the hard fork */
diff --git a/src/consensus/validation.h b/src/consensus/validation.h
index 0b711a14a..f83a54388 100644
--- a/src/consensus/validation.h
+++ b/src/consensus/validation.h
@@ -65,6 +65,7 @@ enum class ValidationInvalidReason {
      */
     TX_CONFLICT,
     TX_MEMPOOL_POLICY,        //!< violated mempool's fee/size/descendant/RBF/etc limits
+    CLAIMTRIE_HASH = 100,
 };
 
 inline bool IsTransactionReason(ValidationInvalidReason r)
diff --git a/src/core_write.cpp b/src/core_write.cpp
index 5a295a119..9ec3111be 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -191,7 +191,7 @@ void ScriptPubKeyToUniv(const CScript& scriptPubKey,
     else
         out.pushKV("type", GetTxnOutputType(type));
 
-    if (extracted || type == TX_PUBLIC) {
+    if (extracted) {
         UniValue a(UniValue::VARR);
         for (const CTxDestination &addr : addresses) {
             a.push_back(EncodeDestination(addr));
diff --git a/src/crypto/siphash.cpp b/src/crypto/siphash.cpp
index e81957111..d174053b7 100644
--- a/src/crypto/siphash.cpp
+++ b/src/crypto/siphash.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <cassert>
 #include <crypto/siphash.h>
 
 #define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
diff --git a/src/index/base.cpp b/src/index/base.cpp
new file mode 100644
index 000000000..640601c93
--- /dev/null
+++ b/src/index/base.cpp
@@ -0,0 +1,371 @@
+// Copyright (c) 2017-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 <chainparams.h>
+#include <index/base.h>
+#include <shutdown.h>
+#include <tinyformat.h>
+#include <ui_interface.h>
+#include <util/system.h>
+#include <validation.h>
+#include <warnings.h>
+
+constexpr int64_t SYNC_LOG_INTERVAL = 30; // seconds
+constexpr int64_t SYNC_LOCATOR_WRITE_INTERVAL = 30; // seconds
+
+template<typename... Args>
+static void FatalError(const char* fmt, const Args&... args)
+{
+    std::string strMessage = tfm::format(fmt, args...);
+    SetMiscWarning(strMessage);
+    LogPrintf("*** %s\n", strMessage);
+    uiInterface.ThreadSafeMessageBox(
+        "Error: A fatal internal error occurred, see debug.log for details",
+        "", CClientUIInterface::MSG_ERROR);
+    StartShutdown();
+}
+
+static const sqlite::sqlite_config sharedConfig {
+    sqlite::OpenFlags::READWRITE | sqlite::OpenFlags::CREATE,
+    nullptr, sqlite::Encoding::UTF8
+};
+
+BaseIndex::DB::DB(const fs::path& path, size_t n_cache_size, bool fMemory, bool fWipe)
+    : sqlite::database(fMemory ? ":memory:" : (path / "index.sqlite").string(), sharedConfig)
+{
+    (*this) << "PRAGMA cache_size=-" + std::to_string(n_cache_size >> 10); // in -KB
+    (*this) << "PRAGMA synchronous=OFF"; // don't disk sync after transaction commit
+    (*this) << "PRAGMA journal_mode=MEMORY";
+    (*this) << "PRAGMA temp_store=MEMORY";
+    (*this) << "PRAGMA case_sensitive_like=true";
+
+    (*this) << "CREATE TABLE IF NOT EXISTS locator (branch BLOB NOT NULL COLLATE BINARY);";
+    (*this) << "CREATE TABLE IF NOT EXISTS file_pos (file INTEGER NOT NULL, pos INTEGER NOT NULL);";
+
+    (*this) << "CREATE TABLE IF NOT EXISTS block (height INTEGER, hash BLOB NOT NULL COLLATE BINARY, "
+                "filter_hash BLOB NOT NULL COLLATE BINARY, header BLOB NOT NULL COLLATE BINARY, "
+                "file INTEGER NOT NULL, pos INTEGER NOT NULL, "
+                "PRIMARY KEY(height, hash), UNIQUE(filter_hash, header, file, pos));";
+
+    if (fWipe) {
+        (*this) << "DELETE FROM locator";
+        (*this) << "DELETE FROM file_pos";
+        (*this) << "DELETE FROM block";
+    }
+    (*this) << "begin";
+}
+
+bool BaseIndex::DB::ReadBestBlock(CBlockLocator& locator) const
+{
+    locator.SetNull();
+    bool success = false;
+    auto& branches = locator.vHave;
+    for (auto&& row : (*this) << "SELECT branch FROM locator") {
+        row >> *branches.insert(branches.end(), uint256{});
+        success = true;
+    }
+    return success;
+}
+
+bool BaseIndex::DB::WriteBestBlock(const CBlockLocator& locator)
+{
+    (*this) << "DELETE FROM locator";
+    for (auto& branch : locator.vHave)
+        (*this) << "INSERT INTO locator VALUES(?)" << branch;
+    return (*this).rows_modified() > 0;
+}
+
+bool BaseIndex::DB::ReadFilePos(FlatFilePos& file) const
+{
+    file.SetNull();
+    bool success = false;
+    for (auto&& row : (*this) << "SELECT file, pos FROM file_pos") {
+        row >> file.nFile >> file.nPos;
+        success = true;
+    }
+    return success;
+}
+
+bool BaseIndex::DB::WriteFilePos(const FlatFilePos& file)
+{
+    (*this) << "DELETE FROM file_pos";
+    (*this) << "INSERT INTO file_pos VALUES(?, ?)" << file.nFile << file.nPos;
+    return rows_modified() > 0;
+}
+
+BaseIndex::~BaseIndex()
+{
+    Interrupt();
+    Stop();
+}
+
+bool BaseIndex::Init()
+{
+    CBlockLocator locator;
+    if (!GetDB().ReadBestBlock(locator)) {
+        locator.SetNull();
+    }
+
+    LOCK(cs_main);
+    if (locator.IsNull()) {
+        m_best_block_index = nullptr;
+    } else {
+        m_best_block_index = FindForkInGlobalIndex(::ChainActive(), locator);
+    }
+    m_synced = m_best_block_index.load() == ::ChainActive().Tip();
+    return true;
+}
+
+static const CBlockIndex* NextSyncBlock(const CBlockIndex* pindex_prev) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
+{
+    AssertLockHeld(cs_main);
+
+    if (!pindex_prev) {
+        return ::ChainActive().Genesis();
+    }
+
+    const CBlockIndex* pindex = ::ChainActive().Next(pindex_prev);
+    if (pindex) {
+        return pindex;
+    }
+
+    return ::ChainActive().Next(::ChainActive().FindFork(pindex_prev));
+}
+
+void BaseIndex::ThreadSync()
+{
+    const CBlockIndex* pindex = m_best_block_index.load();
+    if (!m_synced) {
+        auto& consensus_params = Params().GetConsensus();
+
+        int64_t last_log_time = 0;
+        int64_t last_locator_write_time = 0;
+        while (true) {
+            if (m_interrupt) {
+                m_best_block_index = pindex;
+                // No need to handle errors in Commit. If it fails, the error will be already be
+                // logged. The best way to recover is to continue, as index cannot be corrupted by
+                // a missed commit to disk for an advanced index state.
+                Commit();
+                return;
+            }
+
+            {
+                LOCK(cs_main);
+                const CBlockIndex* pindex_next = NextSyncBlock(pindex);
+                if (!pindex_next) {
+                    m_best_block_index = pindex;
+                    m_synced = true;
+                    // No need to handle errors in Commit. See rationale above.
+                    Commit();
+                    break;
+                }
+                if (pindex_next->pprev != pindex && !Rewind(pindex, pindex_next->pprev)) {
+                    FatalError("%s: Failed to rewind index %s to a previous chain tip",
+                               __func__, GetName());
+                    return;
+                }
+                pindex = pindex_next;
+            }
+
+            int64_t current_time = GetTime();
+            if (last_log_time + SYNC_LOG_INTERVAL < current_time) {
+                LogPrintf("Syncing %s with block chain from height %d\n",
+                          GetName(), pindex->nHeight);
+                last_log_time = current_time;
+            }
+
+            if (last_locator_write_time + SYNC_LOCATOR_WRITE_INTERVAL < current_time) {
+                m_best_block_index = pindex;
+                last_locator_write_time = current_time;
+                // No need to handle errors in Commit. See rationale above.
+                Commit();
+            }
+
+            CBlock block;
+            if (!ReadBlockFromDisk(block, pindex, consensus_params)) {
+                FatalError("%s: Failed to read block %s from disk",
+                           __func__, pindex->GetBlockHash().ToString());
+                return;
+            }
+            if (!WriteBlock(block, pindex)) {
+                FatalError("%s: Failed to write block %s to index database",
+                           __func__, pindex->GetBlockHash().ToString());
+                return;
+            }
+        }
+    }
+
+    if (pindex) {
+        LogPrintf("%s is enabled at height %d\n", GetName(), pindex->nHeight);
+    } else {
+        LogPrintf("%s is enabled\n", GetName());
+    }
+}
+
+bool BaseIndex::Commit()
+{
+    if (!CommitInternal() || sqlite::commit(GetDB()) != SQLITE_OK) {
+        GetDB() << "rollback; begin";
+        return error("%s: Failed to commit latest %s state", __func__, GetName());
+    }
+    GetDB() << "begin";
+    return true;
+}
+
+bool BaseIndex::CommitInternal()
+{
+    LOCK(cs_main);
+    return GetDB().WriteBestBlock(::ChainActive().GetLocator(m_best_block_index));
+}
+
+bool BaseIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
+{
+    assert(current_tip == m_best_block_index);
+    assert(current_tip->GetAncestor(new_tip->nHeight) == new_tip);
+
+    // In the case of a reorg, ensure persisted block locator is not stale.
+    m_best_block_index = new_tip;
+    if (!Commit()) {
+        // If commit fails, revert the best block index to avoid corruption.
+        m_best_block_index = current_tip;
+        return false;
+    }
+
+    return true;
+}
+
+void BaseIndex::BlockConnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex,
+                               const std::vector<CTransactionRef>& txn_conflicted)
+{
+    if (!m_synced) {
+        return;
+    }
+
+    const CBlockIndex* best_block_index = m_best_block_index.load();
+    if (!best_block_index) {
+        if (pindex->nHeight != 0) {
+            FatalError("%s: First block connected is not the genesis block (height=%d)",
+                       __func__, pindex->nHeight);
+            return;
+        }
+    } else {
+        // Ensure block connects to an ancestor of the current best block. This should be the case
+        // most of the time, but may not be immediately after the sync thread catches up and sets
+        // m_synced. Consider the case where there is a reorg and the blocks on the stale branch are
+        // in the ValidationInterface queue backlog even after the sync thread has caught up to the
+        // new chain tip. In this unlikely event, log a warning and let the queue clear.
+        if (best_block_index->GetAncestor(pindex->nHeight - 1) != pindex->pprev) {
+            LogPrintf("%s: WARNING: Block %s does not connect to an ancestor of " /* Continued */
+                      "known best chain (tip=%s); not updating index\n",
+                      __func__, pindex->GetBlockHash().ToString(),
+                      best_block_index->GetBlockHash().ToString());
+            return;
+        }
+        if (best_block_index != pindex->pprev && !Rewind(best_block_index, pindex->pprev)) {
+            FatalError("%s: Failed to rewind index %s to a previous chain tip",
+                       __func__, GetName());
+            return;
+        }
+    }
+
+    if (WriteBlock(*block, pindex)) {
+        m_best_block_index = pindex;
+    } else {
+        FatalError("%s: Failed to write block %s to index",
+                   __func__, pindex->GetBlockHash().ToString());
+        return;
+    }
+}
+
+void BaseIndex::ChainStateFlushed(const CBlockLocator& locator)
+{
+    if (!m_synced) {
+        return;
+    }
+
+    const uint256& locator_tip_hash = locator.vHave.front();
+    const CBlockIndex* locator_tip_index;
+    {
+        LOCK(cs_main);
+        locator_tip_index = LookupBlockIndex(locator_tip_hash);
+    }
+
+    if (!locator_tip_index) {
+        FatalError("%s: First block (hash=%s) in locator was not found",
+                   __func__, locator_tip_hash.ToString());
+        return;
+    }
+
+    // This checks that ChainStateFlushed callbacks are received after BlockConnected. The check may fail
+    // immediately after the sync thread catches up and sets m_synced. Consider the case where
+    // there is a reorg and the blocks on the stale branch are in the ValidationInterface queue
+    // backlog even after the sync thread has caught up to the new chain tip. In this unlikely
+    // event, log a warning and let the queue clear.
+    const CBlockIndex* best_block_index = m_best_block_index.load();
+    if (best_block_index->GetAncestor(locator_tip_index->nHeight) != locator_tip_index) {
+        LogPrintf("%s: WARNING: Locator contains block (hash=%s) not on known best " /* Continued */
+                  "chain (tip=%s); not writing index locator\n",
+                  __func__, locator_tip_hash.ToString(),
+                  best_block_index->GetBlockHash().ToString());
+        return;
+    }
+
+    // No need to handle errors in Commit. If it fails, the error will be already be logged. The
+    // best way to recover is to continue, as index cannot be corrupted by a missed commit to disk
+    // for an advanced index state.
+    Commit();
+}
+
+bool BaseIndex::BlockUntilSyncedToCurrentChain()
+{
+    AssertLockNotHeld(cs_main);
+
+    if (!m_synced) {
+        return false;
+    }
+
+    {
+        // Skip the queue-draining stuff if we know we're caught up with
+        // ::ChainActive().Tip().
+        LOCK(cs_main);
+        const CBlockIndex* chain_tip = ::ChainActive().Tip();
+        const CBlockIndex* best_block_index = m_best_block_index.load();
+        if (best_block_index->GetAncestor(chain_tip->nHeight) == chain_tip) {
+            return true;
+        }
+    }
+
+    LogPrintf("%s: %s is catching up on block notifications\n", __func__, GetName());
+    SyncWithValidationInterfaceQueue();
+    return true;
+}
+
+void BaseIndex::Interrupt()
+{
+    m_interrupt();
+}
+
+void BaseIndex::Start()
+{
+    // Need to register this ValidationInterface before running Init(), so that
+    // callbacks are not missed if Init sets m_synced to true.
+    RegisterValidationInterface(this);
+    if (!Init()) {
+        FatalError("%s: %s failed to initialize", __func__, GetName());
+        return;
+    }
+
+    m_thread_sync = std::thread(&TraceThread<std::function<void()>>, GetName(),
+                                std::bind(&BaseIndex::ThreadSync, this));
+}
+
+void BaseIndex::Stop()
+{
+    UnregisterValidationInterface(this);
+
+    if (m_thread_sync.joinable()) {
+        m_thread_sync.join();
+    }
+}
diff --git a/src/index/base.h b/src/index/base.h
new file mode 100644
index 000000000..cd84ce9cb
--- /dev/null
+++ b/src/index/base.h
@@ -0,0 +1,117 @@
+// Copyright (c) 2017-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_INDEX_BASE_H
+#define BITCOIN_INDEX_BASE_H
+
+#include <flatfile.h>
+#include <primitives/block.h>
+#include <primitives/transaction.h>
+#include <sqlite.h>
+#include <threadinterrupt.h>
+#include <uint256.h>
+#include <validationinterface.h>
+
+class CBlockIndex;
+
+/**
+ * Base class for indices of blockchain data. This implements
+ * CValidationInterface and ensures blocks are indexed sequentially according
+ * to their position in the active chain.
+ */
+class BaseIndex : public CValidationInterface
+{
+protected:
+    class DB : public sqlite::database
+    {
+    public:
+        DB(const fs::path& path, size_t n_cache_size, bool fMemory, bool fWipe);
+
+        /// Read block locator of the chain that the txindex is in sync with.
+        bool ReadBestBlock(CBlockLocator& locator) const;
+
+        /// Write block locator of the chain that the txindex is in sync with.
+        bool WriteBestBlock(const CBlockLocator& locator);
+
+        bool ReadFilePos(FlatFilePos& file) const;
+
+        bool WriteFilePos(const FlatFilePos& file);
+    };
+
+private:
+    /// Whether the index is in sync with the main chain. The flag is flipped
+    /// from false to true once, after which point this starts processing
+    /// ValidationInterface notifications to stay in sync.
+    std::atomic<bool> m_synced{false};
+
+    /// The last block in the chain that the index is in sync with.
+    std::atomic<const CBlockIndex*> m_best_block_index{nullptr};
+
+    std::thread m_thread_sync;
+    CThreadInterrupt m_interrupt;
+
+    /// Sync the index with the block index starting from the current best block.
+    /// Intended to be run in its own thread, m_thread_sync, and can be
+    /// interrupted with m_interrupt. Once the index gets in sync, the m_synced
+    /// flag is set and the BlockConnected ValidationInterface callback takes
+    /// over and the sync thread exits.
+    void ThreadSync();
+
+    /// Write the current index state (eg. chain block locator and subclass-specific items) to disk.
+    ///
+    /// Recommendations for error handling:
+    /// If called on a successor of the previous committed best block in the index, the index can
+    /// continue processing without risk of corruption, though the index state will need to catch up
+    /// from further behind on reboot. If the new state is not a successor of the previous state (due
+    /// to a chain reorganization), the index must halt until Commit succeeds or else it could end up
+    /// getting corrupted.
+    bool Commit();
+
+protected:
+    void BlockConnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex,
+                        const std::vector<CTransactionRef>& txn_conflicted) override;
+
+    void ChainStateFlushed(const CBlockLocator& locator) override;
+
+    /// Initialize internal state from the database and block index.
+    virtual bool Init();
+
+    /// Write update index entries for a newly connected block.
+    virtual bool WriteBlock(const CBlock& block, const CBlockIndex* pindex) { return true; }
+
+    /// Virtual method called internally by Commit that can be overridden to atomically
+    /// commit more index state.
+    virtual bool CommitInternal();
+
+    /// Rewind index to an earlier chain tip during a chain reorg. The tip must
+    /// be an ancestor of the current best block.
+    virtual bool Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip);
+
+    virtual DB& GetDB() const = 0;
+
+    /// Get the name of the index for display in logs.
+    virtual const char* GetName() const = 0;
+
+public:
+    /// Destructor interrupts sync thread if running and blocks until it exits.
+    virtual ~BaseIndex();
+
+    /// Blocks the current thread until the index is caught up to the current
+    /// state of the block chain. This only blocks if the index has gotten in
+    /// sync once and only needs to process blocks in the ValidationInterface
+    /// queue. If the index is catching up from far behind, this method does
+    /// not block and immediately returns false.
+    bool BlockUntilSyncedToCurrentChain();
+
+    void Interrupt();
+
+    /// Start initializes the sync state and registers the instance as a
+    /// ValidationInterface so that it stays in sync with blockchain updates.
+    void Start();
+
+    /// Stops the instance from staying in sync with blockchain updates.
+    void Stop();
+};
+
+#endif // BITCOIN_INDEX_BASE_H
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
index c3ce8d7af..97a90ef24 100644
--- a/src/index/blockfilterindex.cpp
+++ b/src/index/blockfilterindex.cpp
@@ -4,8 +4,10 @@
 
 #include <map>
 
-#include <dbwrapper.h>
+#include <clientversion.h>
 #include <index/blockfilterindex.h>
+#include <streams.h>
+#include <sqlite.h>
 #include <util/system.h>
 #include <validation.h>
 
@@ -14,19 +16,7 @@
  * height, and those belonging to blocks that have been reorganized out of the active chain are
  * indexed by block hash. This ensures that filter data for any block that becomes part of the
  * active chain can always be retrieved, alleviating timing concerns.
- *
- * The filters themselves are stored in flat files and referenced by the LevelDB entries. This
- * minimizes the amount of data written to LevelDB and keeps the database values constant size. The
- * disk location of the next block filter to be written (represented as a FlatFilePos) is stored
- * under the DB_FILTER_POS key.
- *
- * Keys for the height index have the type [DB_BLOCK_HEIGHT, uint32 (BE)]. The height is represented
- * as big-endian so that sequential reads of filters by height are fast.
- * Keys for the hash index have the type [DB_BLOCK_HASH, uint256].
  */
-constexpr char DB_BLOCK_HASH = 's';
-constexpr char DB_BLOCK_HEIGHT = 't';
-constexpr char DB_FILTER_POS = 'P';
 
 constexpr unsigned int MAX_FLTR_FILE_SIZE = 0x1000000; // 16 MiB
 /** The pre-allocation chunk size for fltr?????.dat files */
@@ -49,50 +39,7 @@ struct DBVal {
     }
 };
 
-struct DBHeightKey {
-    int height;
-
-    DBHeightKey() : height(0) {}
-    explicit DBHeightKey(int height_in) : height(height_in) {}
-
-    template<typename Stream>
-    void Serialize(Stream& s) const
-    {
-        ser_writedata8(s, DB_BLOCK_HEIGHT);
-        ser_writedata32be(s, height);
-    }
-
-    template<typename Stream>
-    void Unserialize(Stream& s)
-    {
-        char prefix = ser_readdata8(s);
-        if (prefix != DB_BLOCK_HEIGHT) {
-            throw std::ios_base::failure("Invalid format for block filter index DB height key");
-        }
-        height = ser_readdata32be(s);
-    }
-};
-
-struct DBHashKey {
-    uint256 hash;
-
-    explicit DBHashKey(const uint256& hash_in) : hash(hash_in) {}
-
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        char prefix = DB_BLOCK_HASH;
-        READWRITE(prefix);
-        if (prefix != DB_BLOCK_HASH) {
-            throw std::ios_base::failure("Invalid format for block filter index DB hash key");
-        }
-
-        READWRITE(hash);
-    }
-};
-
-}; // namespace
+} // namespace
 
 static std::map<BlockFilterType, BlockFilterIndex> g_filter_indexes;
 
@@ -113,23 +60,11 @@ BlockFilterIndex::BlockFilterIndex(BlockFilterType filter_type,
 
 bool BlockFilterIndex::Init()
 {
-    if (!m_db->Read(DB_FILTER_POS, m_next_filter_pos)) {
-        // Check that the cause of the read failure is that the key does not exist. Any other errors
-        // indicate database corruption or a disk failure, and starting the index would cause
-        // further corruption.
-        if (m_db->Exists(DB_FILTER_POS)) {
-            return error("%s: Cannot read current %s state; index may be corrupted",
-                         __func__, GetName());
-        }
-
-        // If the DB_FILTER_POS is not set, then initialize to the first location.
-        m_next_filter_pos.nFile = 0;
-        m_next_filter_pos.nPos = 0;
-    }
+    m_db->ReadFilePos(m_next_filter_pos);
     return BaseIndex::Init();
 }
 
-bool BlockFilterIndex::CommitInternal(CDBBatch& batch)
+bool BlockFilterIndex::CommitInternal()
 {
     const FlatFilePos& pos = m_next_filter_pos;
 
@@ -142,8 +77,7 @@ bool BlockFilterIndex::CommitInternal(CDBBatch& batch)
         return error("%s: Failed to commit filter file %d", __func__, pos.nFile);
     }
 
-    batch.Write(DB_FILTER_POS, pos);
-    return BaseIndex::CommitInternal(batch);
+    return BaseIndex::CommitInternal();
 }
 
 bool BlockFilterIndex::ReadFilterFromDisk(const FlatFilePos& pos, BlockFilter& filter) const
@@ -222,18 +156,20 @@ bool BlockFilterIndex::WriteBlock(const CBlock& block, const CBlockIndex* pindex
             return false;
         }
 
-        std::pair<uint256, DBVal> read_out;
-        if (!m_db->Read(DBHeightKey(pindex->nHeight - 1), read_out)) {
+        uint256 block_hash;
+        auto query = (*m_db) << "SELECT hash, header FROM block WHERE height = ?"
+                             << pindex->nHeight - 1;
+        auto it = query.begin();
+        if (it == query.end())
             return false;
-        }
+
+        *it >> block_hash >> prev_header;
 
         uint256 expected_block_hash = pindex->pprev->GetBlockHash();
-        if (read_out.first != expected_block_hash) {
+        if (block_hash != expected_block_hash) {
             return error("%s: previous block header belongs to unexpected block %s; expected %s",
-                         __func__, read_out.first.ToString(), expected_block_hash.ToString());
+                         __func__, block_hash.ToString(), expected_block_hash.ToString());
         }
-
-        prev_header = read_out.second.header;
     }
 
     BlockFilter filter(m_filter_type, block, block_undo);
@@ -241,13 +177,15 @@ bool BlockFilterIndex::WriteBlock(const CBlock& block, const CBlockIndex* pindex
     size_t bytes_written = WriteFilterToDisk(m_next_filter_pos, filter);
     if (bytes_written == 0) return false;
 
-    std::pair<uint256, DBVal> value;
-    value.first = pindex->GetBlockHash();
-    value.second.hash = filter.GetHash();
-    value.second.header = filter.ComputeHeader(prev_header);
-    value.second.pos = m_next_filter_pos;
+    (*m_db) << "INSERT INTO block VALUES(?, ?, ?, ?, ?, ?)"
+            << pindex->nHeight
+            << pindex->GetBlockHash()
+            << filter.GetHash()
+            << filter.ComputeHeader(prev_header)
+            << m_next_filter_pos.nFile
+            << m_next_filter_pos.nPos;
 
-    if (!m_db->Write(DBHeightKey(pindex->nHeight), value)) {
+    if (!(m_db->rows_modified() > 0)) {
         return false;
     }
 
@@ -255,74 +193,49 @@ bool BlockFilterIndex::WriteBlock(const CBlock& block, const CBlockIndex* pindex
     return true;
 }
 
-static bool CopyHeightIndexToHashIndex(CDBIterator& db_it, CDBBatch& batch,
-                                       const std::string& index_name,
+static bool CopyHeightIndexToHashIndex(sqlite::database& db,
                                        int start_height, int stop_height)
 {
-    DBHeightKey key(start_height);
-    db_it.Seek(key);
-
-    for (int height = start_height; height <= stop_height; ++height) {
-        if (!db_it.GetKey(key) || key.height != height) {
-            return error("%s: unexpected key in %s: expected (%c, %d)",
-                         __func__, index_name, DB_BLOCK_HEIGHT, height);
-        }
-
-        std::pair<uint256, DBVal> value;
-        if (!db_it.GetValue(value)) {
-            return error("%s: unable to read value in %s at key (%c, %d)",
-                         __func__, index_name, DB_BLOCK_HEIGHT, height);
-        }
-
-        batch.Write(DBHashKey(value.first), std::move(value.second));
-
-        db_it.Next();
-    }
-    return true;
+    db << "UPDATE block SET height = NULL WHERE height >= ? and height <= ?"
+        << start_height << stop_height;
+    return db.rows_modified() > 0;
 }
 
 bool BlockFilterIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
 {
     assert(current_tip->GetAncestor(new_tip->nHeight) == new_tip);
 
-    CDBBatch batch(*m_db);
-    std::unique_ptr<CDBIterator> db_it(m_db->NewIterator());
-
     // During a reorg, we need to copy all filters for blocks that are getting disconnected from the
     // height index to the hash index so we can still find them when the height index entries are
     // overwritten.
-    if (!CopyHeightIndexToHashIndex(*db_it, batch, m_name, new_tip->nHeight, current_tip->nHeight)) {
+    if (!CopyHeightIndexToHashIndex(*m_db, new_tip->nHeight, current_tip->nHeight)) {
         return false;
     }
 
     // The latest filter position gets written in Commit by the call to the BaseIndex::Rewind.
     // But since this creates new references to the filter, the position should get updated here
     // atomically as well in case Commit fails.
-    batch.Write(DB_FILTER_POS, m_next_filter_pos);
-    if (!m_db->WriteBatch(batch)) return false;
+    if (!m_db->WriteFilePos(m_next_filter_pos)) return false;
 
     return BaseIndex::Rewind(current_tip, new_tip);
 }
 
-static bool LookupOne(const CDBWrapper& db, const CBlockIndex* block_index, DBVal& result)
+static bool LookupOne(sqlite::database& db, const CBlockIndex* block_index, DBVal& result)
 {
     // First check if the result is stored under the height index and the value there matches the
     // block hash. This should be the case if the block is on the active chain.
-    std::pair<uint256, DBVal> read_out;
-    if (!db.Read(DBHeightKey(block_index->nHeight), read_out)) {
-        return false;
-    }
-    if (read_out.first == block_index->GetBlockHash()) {
-        result = std::move(read_out.second);
+    auto query = db << "SELECT filter_hash, header, file, pos FROM block WHERE (height = ? "
+                    << "OR height IS NULL) AND hash = ? LIMIT 1"
+                    << block_index->nHeight << block_index->GetBlockHash();
+
+    for (auto&& row : query) {
+        row >> result.hash >> result.header >> result.pos.nFile >> result.pos.nPos;
         return true;
     }
-
-    // If value at the height index corresponds to an different block, the result will be stored in
-    // the hash index.
-    return db.Read(DBHashKey(block_index->GetBlockHash()), result);
+    return false;
 }
 
-static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start_height,
+static bool LookupRange(sqlite::database& db, const std::string& index_name, int start_height,
                         const CBlockIndex* stop_index, std::vector<DBVal>& results)
 {
     if (start_height < 0) {
@@ -334,25 +247,6 @@ static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start
     }
 
     size_t results_size = static_cast<size_t>(stop_index->nHeight - start_height + 1);
-    std::vector<std::pair<uint256, DBVal>> values(results_size);
-
-    DBHeightKey key(start_height);
-    std::unique_ptr<CDBIterator> db_it(db.NewIterator());
-    db_it->Seek(DBHeightKey(start_height));
-    for (int height = start_height; height <= stop_index->nHeight; ++height) {
-        if (!db_it->Valid() || !db_it->GetKey(key) || key.height != height) {
-            return false;
-        }
-
-        size_t i = static_cast<size_t>(height - start_height);
-        if (!db_it->GetValue(values[i])) {
-            return error("%s: unable to read value in %s at key (%c, %d)",
-                         __func__, index_name, DB_BLOCK_HEIGHT, height);
-        }
-
-        db_it->Next();
-    }
-
     results.resize(results_size);
 
     // Iterate backwards through block indexes collecting results in order to access the block hash
@@ -360,17 +254,10 @@ static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start
     for (const CBlockIndex* block_index = stop_index;
          block_index && block_index->nHeight >= start_height;
          block_index = block_index->pprev) {
-        uint256 block_hash = block_index->GetBlockHash();
-
         size_t i = static_cast<size_t>(block_index->nHeight - start_height);
-        if (block_hash == values[i].first) {
-            results[i] = std::move(values[i].second);
-            continue;
-        }
-
-        if (!db.Read(DBHashKey(block_hash), results[i])) {
-            return error("%s: unable to read value in %s at key (%c, %s)",
-                         __func__, index_name, DB_BLOCK_HASH, block_hash.ToString());
+        if (!LookupOne(db, block_index, results[i])) {
+            return error("%s: unable to read value in %s at key %s", __func__,
+                         index_name, block_index->GetBlockHash().ToString());
         }
     }
 
diff --git a/src/index/blockfilterindex.h b/src/index/blockfilterindex.h
index 436d52515..b124a3665 100644
--- a/src/index/blockfilterindex.h
+++ b/src/index/blockfilterindex.h
@@ -33,7 +33,7 @@ private:
 protected:
     bool Init() override;
 
-    bool CommitInternal(CDBBatch& batch) override;
+    bool CommitInternal() override;
 
     bool WriteBlock(const CBlock& block, const CBlockIndex* pindex) override;
 
diff --git a/src/init.cpp b/src/init.cpp
index f943b48c5..e88fe6223 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -52,7 +52,9 @@
 #include <ui_interface.h>
 #include <util/moneystr.h>
 #include <util/system.h>
+#include <util/strencodings.h>
 #include <util/threadnames.h>
+#include <util/translation.h>
 #include <util/validation.h>
 #include <validation.h>
 #include <validationinterface.h>
@@ -286,7 +288,6 @@ void Shutdown(InitInterfaces& interfaces)
         LogPrintf("%s: Unable to remove PID file: %s\n", __func__, fsbridge::get_filesystem_error_message(e));
     }
     interfaces.chain_clients.clear();
-    g_wallet_init_interface.Close();
     UnregisterAllValidationInterfaces();
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     GetMainSignals().UnregisterWithMempoolSignals(mempool);
@@ -1213,7 +1214,6 @@ bool AppInitMain(InitInterfaces& interfaces)
         // Detailed error printed inside CreatePidFile().
         return false;
     }
-    }
     if (!LogInstance().StartLogging()) {
             return InitError(strprintf("Could not open debug log file %s",
                 LogInstance().m_file_path.string()));
@@ -1505,7 +1505,7 @@ bool AppInitMain(InitInterfaces& interfaces)
                 // From here on out fReindex and fReset mean something different!
                 if (!LoadBlockIndex(chainparams)) {
                     if (ShutdownRequested()) break;
-                    strLoadError = _("Error loading block index database");
+                    strLoadError = _("Error loading block index database").translated;
                     break;
                 }
 
@@ -1546,8 +1546,8 @@ bool AppInitMain(InitInterfaces& interfaces)
                         "", CClientUIInterface::MSG_ERROR);
                 });
 
-                if (g_logger->Enabled() && LogAcceptCategory(BCLog::CLAIMS))
-                    CLogPrint::global().setLogger(g_logger);
+                if (LogInstance().Enabled() && LogAcceptCategory(BCLog::CLAIMS))
+                    CLogPrint::global().setLogger(&LogInstance());
 
                 delete pclaimTrie;
                 auto& consensus = chainparams.GetConsensus();
@@ -1588,9 +1588,9 @@ bool AppInitMain(InitInterfaces& interfaces)
                 break;
             }
 
-                auto tip = chainActive.Tip();
+                auto tip = ::ChainActive().Tip();
                 if (tip && !CClaimTrieCache(pclaimTrie).validateDb(tip->nHeight, tip->hashClaimTrie)) {
-                    strLoadError = _("Error validating the claim trie from disk");
+                    strLoadError = _("Error validating the claim trie from disk").translated;
                     break;
                 }
 
diff --git a/src/interfaces/chain.cpp b/src/interfaces/chain.cpp
index aa44a69f0..90ee956ab 100644
--- a/src/interfaces/chain.cpp
+++ b/src/interfaces/chain.cpp
@@ -246,7 +246,7 @@ public:
         if (try_lock && result && !*result) return {};
         // std::move necessary on some compilers due to conversion from
         // LockImpl to Lock pointer
-        return std::move(result);
+        return std::unique_ptr<Chain::Lock>{std::move(result)};
     }
     bool findBlock(const uint256& hash, CBlock* block, int64_t* time, int64_t* time_max) override
     {
diff --git a/src/miner.cpp b/src/miner.cpp
index 81591ec2f..ac9bd09b4 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -21,6 +21,7 @@
 #include <primitives/transaction.h>
 #include <script/standard.h>
 #include <timedata.h>
+#include <validation.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <util/validation.h>
@@ -58,7 +59,7 @@ void blockToCache(const CBlock* pblock, CClaimTrieCache& trieCache, int nHeight)
 
     trieCache.initializeIncrement();
 
-    CCoinsViewCache view(pcoinsTip.get());
+    CCoinsViewCache view(&::ChainstateActive().CoinsTip());
 
     for (auto& tx : pblock->vtx)
         if (!tx->IsCoinBase())
diff --git a/src/nameclaim.cpp b/src/nameclaim.cpp
index 17c448325..5af7659d7 100644
--- a/src/nameclaim.cpp
+++ b/src/nameclaim.cpp
@@ -1,6 +1,6 @@
-#include "nameclaim.h"
-#include "hash.h"
-#include "util.h"
+#include <nameclaim.h>
+#include <hash.h>
+#include <logging.h>
 
 std::vector<unsigned char> uint32_t_to_vch(uint32_t n)
 {
@@ -164,7 +164,7 @@ size_t ClaimNameSize(const CScript& scriptIn)
     return vvchParams[0].size();
 }
 
-CAmount CalcMinClaimTrieFee(const CTransaction& tx, const CAmount &minFeePerNameClaimChar)
+CAmount CalcMinClaimTrieFee(const CMutableTransaction& tx, const CAmount &minFeePerNameClaimChar)
 {
     if (minFeePerNameClaimChar == 0)
         return 0;
diff --git a/src/nameclaim.h b/src/nameclaim.h
index 47ebbaf12..f56db467e 100644
--- a/src/nameclaim.h
+++ b/src/nameclaim.h
@@ -1,10 +1,10 @@
 #ifndef BITCOIN_NAMECLAIM_H
 #define BITCOIN_NAMECLAIM_H
 
-#include "amount.h"
-#include "script/script.h"
-#include "primitives/transaction.h"
-#include "uint256.h"
+#include <amount.h>
+#include <script/script.h>
+#include <primitives/transaction.h>
+#include <uint256.h>
 
 #include <vector>
 
@@ -40,6 +40,6 @@ size_t ClaimScriptSize(const CScript& scriptIn);
 // get size of the name in a claim script, returns 0 if scriptin is not a claimetrie transaction
 size_t ClaimNameSize(const CScript& scriptIn);
 // calculate the minimum fee (mempool rule) required for transaction
-CAmount CalcMinClaimTrieFee(const CTransaction& tx, const CAmount &minFeePerNameClaimChar);
+CAmount CalcMinClaimTrieFee(const CMutableTransaction& tx, const CAmount &minFeePerNameClaimChar);
 
 #endif // BITCOIN_NAMECLAIM_H
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 3d0efa041..c84f03a24 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -1015,6 +1015,7 @@ static bool MaybePunishNode(NodeId nodeid, const CValidationState& state, bool v
     // The node is providing invalid data:
     case ValidationInvalidReason::CONSENSUS:
     case ValidationInvalidReason::BLOCK_MUTATED:
+    case ValidationInvalidReason::CLAIMTRIE_HASH:
         if (!via_compact_block) {
             LOCK(cs_main);
             Misbehaving(nodeid, 100, message);
diff --git a/src/protocol.cpp b/src/protocol.cpp
index 2805eea8d..bdf236c2c 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -128,20 +128,12 @@ bool CMessageHeader::IsValid(const MessageStartChars& pchMessageStartIn) const
     return true;
 }
 
-// NOTE: After we fork, we can require these service bits
-//
-/* ServiceFlags GetDesirableServiceFlags(ServiceFlags services) { */
-/*     if ((services & NODE_NETWORK_LIMITED) && g_initial_block_download_completed) { */
-/*         return ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS); */
-/*     } */
-/*     return ServiceFlags(NODE_NETWORK | NODE_WITNESS); */
-/* } */
 
 ServiceFlags GetDesirableServiceFlags(ServiceFlags services) {
-    if ((services & NODE_NETWORK) && g_initial_block_download_completed) {
-        return ServiceFlags(NODE_NETWORK | NODE_BLOOM);
+    if ((services & NODE_NETWORK_LIMITED) && g_initial_block_download_completed) {
+        return ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS);
     }
-    return ServiceFlags(NODE_NETWORK | NODE_BLOOM);
+    return ServiceFlags(NODE_NETWORK | NODE_WITNESS);
 }
 
 void SetServiceFlagsIBDCache(bool state) {
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 152ba061b..784fdcb6e 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -773,12 +773,6 @@ void BitcoinGUI::macosDockIconActivated()
     show();
     activateWindow();
 }
-#else
-void BitcoinGUI::macosDockIconActivated()
-{
-    show();
-    activateWindow();
-}
 #endif
 
 void BitcoinGUI::optionsClicked()
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index c557a528d..6c9bb95cb 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -384,9 +384,6 @@ void bringToFront(QWidget* w)
     }
 }
 
-    }
-}
-
 void openDebugLogfile()
 {
     fs::path pathDebug = GetDataDir() / "debug.log";
diff --git a/src/qt/locale/bitcoin_da.ts b/src/qt/locale/bitcoin_da.ts
index 18dcdb584..48ad3cfa4 100644
--- a/src/qt/locale/bitcoin_da.ts
+++ b/src/qt/locale/bitcoin_da.ts
@@ -3381,10 +3381,6 @@ Note: Siden gebyret er kalkuleret på en per-byte basis, et gebyr på "100 satos
         <source>Error reading %s! All keys read correctly, but transaction data or address book entries might be missing or incorrect.</source>
         <translation>Fejl under læsning af %s! Alle nøgler blev læst korrekt, men transaktionsdata eller indgange i adressebogen kan mangle eller være ukorrekte.</translation>
     </message>
-    <message>
-        <source>Group outputs by address, selecting all or none, instead of selecting on a per-output basis. Privacy is improved as an address is only used once (unless someone sends to it after spending from it), but may result in slightly higher fees as suboptimal coin selection may result due to the added limitation (default: %u)</source>
-        <translation>Gruppér output efter adresse og vælg alle eller ingen, i stedet for at vælge på per-output-basis. Højere sikring af privatliv, da en adresse kun bruges én gang (med mindre nogen sender til en adresse efter den er brugt), men kan resultere i en anelse højere gebyrer, da ikke-optimal valg af output-adresser kan forekomme på grund af den tilføjede begrænsning (standard: %u)</translation>
-    </message>
     <message>
         <source>Please check that your computer's date and time are correct! If your clock is wrong, %s will not work properly.</source>
         <translation>Undersøg venligst at din computers dato og klokkeslet er korrekt indstillet! Hvis der er fejl i disse, vil %s ikke fungere korrekt.</translation>
@@ -3687,7 +3683,11 @@ Note: Siden gebyret er kalkuleret på en per-byte basis, et gebyr på "100 satos
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>Den specificerede konfigurationsfil %s eksisterer ikke.
+</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>Transaktionsbeløbet er for lille til at betale gebyret</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_de.ts b/src/qt/locale/bitcoin_de.ts
index ac40732f9..5ebb7254e 100644
--- a/src/qt/locale/bitcoin_de.ts
+++ b/src/qt/locale/bitcoin_de.ts
@@ -3685,7 +3685,11 @@ Hinweis: Eine Gebühr von "100 Satoshis pro kB" bei einer Größe der Transaktio
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>Die spezifische Konfigurationsdatei %s existiert nicht.
+</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>Der Transaktionsbetrag ist zu niedrig, um die Gebühr zu bezahlen.</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_el.ts b/src/qt/locale/bitcoin_el.ts
index f389c19ea..8da642ada 100644
--- a/src/qt/locale/bitcoin_el.ts
+++ b/src/qt/locale/bitcoin_el.ts
@@ -1600,10 +1600,6 @@
         <source>Copy fee</source>
         <translation>Αντιγραφή τελών</translation>
     </message>
-    <message>
-        <source>Copy fee</source>
-        <translation>Αντιγραφή τελών</translation>
-    </message>
     <message>
         <source>or</source>
         <translation>ή</translation>
diff --git a/src/qt/locale/bitcoin_es.ts b/src/qt/locale/bitcoin_es.ts
index 7d7f682d3..ddeed2ca1 100644
--- a/src/qt/locale/bitcoin_es.ts
+++ b/src/qt/locale/bitcoin_es.ts
@@ -3675,7 +3675,11 @@ Nota: Dado que la comisión se calcula por byte, una comisión de "100 satoshis
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>El fichero de configuración %s especificado no existe
+</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>El monto de la transacción es muy pequeño para pagar la comisión</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_fi.ts b/src/qt/locale/bitcoin_fi.ts
index 8f0fe0ddd..830309ee4 100644
--- a/src/qt/locale/bitcoin_fi.ts
+++ b/src/qt/locale/bitcoin_fi.ts
@@ -337,14 +337,6 @@
         <source>Wallet:</source>
         <translation>Lompakko:</translation>
     </message>
-    <message>
-        <source>Wallet:</source>
-        <translation>Lompakko:</translation>
-    </message>
-    <message>
-        <source>default wallet</source>
-        <translation>oletuslompakko</translation>
-    </message>
     <message>
         <source>Click to disable network activity.</source>
         <translation>Paina poistaaksesi verkkoyhteysilmaisin käytöstä.</translation>
@@ -1968,10 +1960,6 @@
         <source>&amp;Unban</source>
         <translation>&amp;Poista esto</translation>
     </message>
-    <message>
-        <source>default wallet</source>
-        <translation>oletuslompakko</translation>
-    </message>
     <message>
         <source>Welcome to the %1 RPC console.</source>
         <translation>Tervetuloa %1 RPC-konsoliin.</translation>
diff --git a/src/qt/locale/bitcoin_fr.ts b/src/qt/locale/bitcoin_fr.ts
index 6f64c4769..493700455 100644
--- a/src/qt/locale/bitcoin_fr.ts
+++ b/src/qt/locale/bitcoin_fr.ts
@@ -3683,7 +3683,11 @@ Note : Les frais étant calculés par octet, des frais de « 100 satoshis par
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>Le fichier de configuration indiqué %s n’existe pas
+</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>Le montant de la transaction est trop bas pour que les frais soient payés</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_ja.ts b/src/qt/locale/bitcoin_ja.ts
index 941b5dffc..951b7afe2 100644
--- a/src/qt/locale/bitcoin_ja.ts
+++ b/src/qt/locale/bitcoin_ja.ts
@@ -3382,10 +3382,6 @@ Note:  Since the fee is calculated on a per-byte basis, a fee of "100 satoshis p
         <source>Error reading %s! All keys read correctly, but transaction data or address book entries might be missing or incorrect.</source>
         <translation>%s の読み込み中にエラーが発生しました！ 全ての鍵は正しく読み込めましたが、取引データやアドレス帳の項目が失われたか、正しくない可能性があります。</translation>
     </message>
-    <message>
-        <source>Group outputs by address, selecting all or none, instead of selecting on a per-output basis. Privacy is improved as an address is only used once (unless someone sends to it after spending from it), but may result in slightly higher fees as suboptimal coin selection may result due to the added limitation (default: %u)</source>
-        <translation>出力ごとではなく、アドレス単位に出力をまとめて選択します。(後からまたそのアドレスに支払われない限り)アドレスが一度しか使用されないためプライバシーが向上します。ただし追加の制限により最適ではないコイン選択が発生した場合に、わずかに高い手数料となる可能性があります。(初期値: %u)</translation>
-    </message>
     <message>
         <source>Please check that your computer's date and time are correct! If your clock is wrong, %s will not work properly.</source>
         <translation>お使いのコンピューターの日付と時刻が正しいことを確認してください！ PCの時計が正しくない場合 %s は正確に動作しません。</translation>
@@ -3538,10 +3534,6 @@ Note:  Since the fee is calculated on a per-byte basis, a fee of "100 satoshis p
         <source>Unknown change type '%s'</source>
         <translation>未知のおつり用アドレス形式 '%s' です</translation>
     </message>
-    <message>
-        <source>Specified blocks directory "%s" does not exist.</source>
-        <translation>指定のブロックディレクトリ"%s"は存在しません｡</translation>
-    </message>
     <message>
         <source>Upgrading txindex database</source>
         <translation>txindex データベースの更新中</translation>
@@ -3692,7 +3684,11 @@ Note:  Since the fee is calculated on a per-byte basis, a fee of "100 satoshis p
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>指定された設定ファイル %s が存在しません｡
+</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>取引の手数料差引後金額が小さすぎるため、送金できません。</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_ko.ts b/src/qt/locale/bitcoin_ko.ts
index 1a9264d60..f9ac10a88 100644
--- a/src/qt/locale/bitcoin_ko.ts
+++ b/src/qt/locale/bitcoin_ko.ts
@@ -3531,8 +3531,11 @@ Note:  Since the fee is calculated on a per-byte basis, a fee of "100 satoshis p
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>지정한 설정 파일 "%s"는 존재하지 않습니다
 </translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>거래액이 수수료를 지불하기엔 너무 작습니다</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_nl.ts b/src/qt/locale/bitcoin_nl.ts
index 3699d6f3a..748da9b80 100644
--- a/src/qt/locale/bitcoin_nl.ts
+++ b/src/qt/locale/bitcoin_nl.ts
@@ -3684,7 +3684,11 @@ Notitie: Omdat de vergoeding per byte wordt gerekend, zal een vergoeding van "10
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>Het opgegeven configuratiebestand %s bestaat niet
+</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>Het transactiebedrag is te klein om transactiekosten in rekening te brengen</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_pl.ts b/src/qt/locale/bitcoin_pl.ts
index 9ecdb7149..75f94e02e 100644
--- a/src/qt/locale/bitcoin_pl.ts
+++ b/src/qt/locale/bitcoin_pl.ts
@@ -3686,7 +3686,11 @@ Zwróć uwagę, że poprawnie zweryfikowana wiadomość potwierdza to, że nadaw
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>Podany plik konfiguracyjny %s nie istnieje
+</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>Zbyt niska kwota transakcji by zapłacić opłatę</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_pt_BR.ts b/src/qt/locale/bitcoin_pt_BR.ts
index 5e87ce1cb..4ceb834b6 100644
--- a/src/qt/locale/bitcoin_pt_BR.ts
+++ b/src/qt/locale/bitcoin_pt_BR.ts
@@ -3684,7 +3684,11 @@ Diretório de blocos especificados "%s" não existe.</translation>
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>O Arquivo de configuração especificado %s não existe
+</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>A quantidade da transação é pequena demais para  pagar a taxa</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_ro.ts b/src/qt/locale/bitcoin_ro.ts
index ec669f90d..c1e27e0d9 100644
--- a/src/qt/locale/bitcoin_ro.ts
+++ b/src/qt/locale/bitcoin_ro.ts
@@ -297,10 +297,6 @@
         <source>Wallet:</source>
         <translation>Portofel:</translation>
     </message>
-    <message>
-        <source>default wallet</source>
-        <translation>portofel implicit</translation>
-    </message>
     <message>
         <source>Click to disable network activity.</source>
         <translation>Click pentru a opri activitatea retelei.</translation>
@@ -1792,10 +1788,6 @@
         <source>&amp;Unban</source>
         <translation>&amp;Unban</translation>
     </message>
-    <message>
-        <source>default wallet</source>
-        <translation>portofel implicit</translation>
-    </message>
     <message>
         <source>Welcome to the %1 RPC console.</source>
         <translation>Bun venit la consola %1 RPC.</translation>
diff --git a/src/qt/locale/bitcoin_sk.ts b/src/qt/locale/bitcoin_sk.ts
index 2a8e32eca..9f84850ca 100644
--- a/src/qt/locale/bitcoin_sk.ts
+++ b/src/qt/locale/bitcoin_sk.ts
@@ -3684,7 +3684,11 @@ Poznámka: Keďže poplatok je počítaný za bajt, poplatok o hodnote "100 sato
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>Zadaný konfiguračný súbor %s neexistuje
+</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>Suma transakcie je príliš malá na zaplatenie poplatku</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_uk.ts b/src/qt/locale/bitcoin_uk.ts
index d263320f4..88e8c3d3c 100644
--- a/src/qt/locale/bitcoin_uk.ts
+++ b/src/qt/locale/bitcoin_uk.ts
@@ -3605,7 +3605,10 @@ Note:  Since the fee is calculated on a per-byte basis, a fee of "100 satoshis p
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>Зазначений файл конфігурації %s не існує</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>Неможливо сплатити комісію із-за малої суми транзакції</translation>
     </message>
diff --git a/src/qt/locale/bitcoin_zh_TW.ts b/src/qt/locale/bitcoin_zh_TW.ts
index 8b502cd4d..3ab92b56e 100644
--- a/src/qt/locale/bitcoin_zh_TW.ts
+++ b/src/qt/locale/bitcoin_zh_TW.ts
@@ -3567,7 +3567,11 @@ Note:  Since the fee is calculated on a per-byte basis, a fee of "100 satoshis p
     </message>
     <message>
         <source>The specified config file %s does not exist
+</source>
         <translation>指定的配置文件 %s 不存在
+</translation>
+    </message>
+    <message>
         <source>The transaction amount is too small to pay the fee</source>
         <translation>交易金額太少而付不起手續費</translation>
     </message>
diff --git a/src/rest.cpp b/src/rest.cpp
index f856095e7..7350be83c 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -214,13 +214,13 @@ static bool rest_block(HTTPRequest* req,
         LOCK(cs_main);
         tip = ::ChainActive().Tip();
         if (blockHeight < 0) // negative block heights take us back from current tip
-            blockHeight += chainActive.Height();
-        if (blockHeight > 0 && blockHeight <= chainActive.Height())
-            pblockindex = chainActive[blockHeight];
+            blockHeight += tip->nHeight;
+        if (blockHeight > 0 && blockHeight <= tip->nHeight)
+            pblockindex = ::ChainActive()[blockHeight];
         else if (blockHeight != 0)
             return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash or block height: " + hashStr);
         else if (hashStr == "tip")
-            pblockindex = chainActive.Tip();
+            pblockindex = tip;
         else
             pblockindex = LookupBlockIndex(hash);
         if (!pblockindex) {
diff --git a/src/rpc/claimtrie.cpp b/src/rpc/claimtrie.cpp
index d9464e731..53325361f 100644
--- a/src/rpc/claimtrie.cpp
+++ b/src/rpc/claimtrie.cpp
@@ -6,14 +6,16 @@
 #include <logging.h>
 #include <nameclaim.h>
 #include <rpc/claimrpchelp.h>
+#include <rpc/protocol.h>
 #include <rpc/server.h>
+#include <rpc/util.h>
 #include <script/standard.h>
 #include <shutdown.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <undo.h>
 #include <univalue.h>
-#include <utilstrencodings.h>
+#include <util/strencodings.h>
 #include <validation.h>
 
 #include <boost/locale.hpp>
@@ -35,11 +37,10 @@ static CBlockIndex* BlockHashIndex(const uint256& blockHash)
 {
     AssertLockHeld(cs_main);
 
-    if (mapBlockIndex.count(blockHash) == 0)
+    CBlockIndex* pblockIndex = LookupBlockIndex(blockHash);
+    if (!pblockIndex)
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
-
-    CBlockIndex* pblockIndex = mapBlockIndex[blockHash];
-    if (!chainActive.Contains(pblockIndex))
+    if (!::ChainActive().Contains(pblockIndex))
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Block not in main chain");
 
     return pblockIndex;
@@ -47,17 +48,17 @@ static CBlockIndex* BlockHashIndex(const uint256& blockHash)
 
 #define MAX_RPC_BLOCK_DECREMENTS 500
 
-extern CChainState g_chainstate;
 void RollBackTo(const CBlockIndex* targetIndex, CCoinsViewCache& coinsCache, CClaimTrieCache& trieCache)
 {
     AssertLockHeld(cs_main);
 
-    const CBlockIndex* activeIndex = chainActive.Tip();
+    const CBlockIndex* activeIndex = ::ChainActive().Tip();
 
     if (activeIndex->nHeight > (targetIndex->nHeight + MAX_RPC_BLOCK_DECREMENTS))
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Block is too deep");
 
-    const size_t currentMemoryUsage = pcoinsTip->DynamicMemoryUsage();
+    auto& chainstate = ::ChainstateActive();
+    const size_t currentMemoryUsage = chainstate.CoinsTip().DynamicMemoryUsage();
 
     for (; activeIndex && activeIndex != targetIndex; activeIndex = activeIndex->pprev) {
         boost::this_thread::interruption_point();
@@ -72,7 +73,7 @@ void RollBackTo(const CBlockIndex* targetIndex, CCoinsViewCache& coinsCache, CCl
         if (ShutdownRequested())
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Shutdown requested");
 
-        if (g_chainstate.DisconnectBlock(block, activeIndex, coinsCache, trieCache) != DisconnectResult::DISCONNECT_OK)
+        if (chainstate.DisconnectBlock(block, activeIndex, coinsCache, trieCache) != DisconnectResult::DISCONNECT_OK)
             throw JSONRPCError(RPC_INTERNAL_ERROR, strprintf("Failed to disconnect %s", block.ToString()));
     }
     trieCache.getMerkleHash(); // update the hash tree
@@ -246,8 +247,8 @@ static UniValue getnamesintrie(const JSONRPCRequest& request)
     validateRequest(request, GETNAMESINTRIE, 0, 1);
 
     LOCK(cs_main);
-    CCoinsViewCache coinsCache(pcoinsTip.get());
     CClaimTrieCache trieCache(pclaimTrie);
+    CCoinsViewCache coinsCache(&::ChainstateActive().CoinsTip());
 
     if (!request.params.empty()) {
         CBlockIndex* blockIndex = BlockHashIndex(ParseHashV(request.params[0], T_BLOCKHASH " (optional parameter 1)"));
@@ -271,8 +272,8 @@ static UniValue getvalueforname(const JSONRPCRequest& request)
     validateRequest(request, GETVALUEFORNAME, 1, 2);
 
     LOCK(cs_main);
-    CCoinsViewCache coinsCache(pcoinsTip.get());
     CClaimTrieCache trieCache(pclaimTrie);
+    CCoinsViewCache coinsCache(&::ChainstateActive().CoinsTip());
 
     if (request.params.size() > 1) {
         CBlockIndex* blockIndex = BlockHashIndex(ParseHashV(request.params[1], T_BLOCKHASH " (optional parameter 2)"));
@@ -319,8 +320,8 @@ UniValue getclaimsforname(const JSONRPCRequest& request)
     validateRequest(request, GETCLAIMSFORNAME, 1, 1);
 
     LOCK(cs_main);
-    CCoinsViewCache coinsCache(pcoinsTip.get());
     CClaimTrieCache trieCache(pclaimTrie);
+    CCoinsViewCache coinsCache(&::ChainstateActive().CoinsTip());
 
     if (request.params.size() > 1) {
         CBlockIndex* blockIndex = BlockHashIndex(ParseHashV(request.params[1], T_BLOCKHASH " (optional parameter 2)"));
@@ -359,8 +360,8 @@ UniValue getclaimbybid(const JSONRPCRequest& request)
     validateRequest(request, GETCLAIMBYBID, 1, 2);
 
     LOCK(cs_main);
-    CCoinsViewCache coinsCache(pcoinsTip.get());
     CClaimTrieCache trieCache(pclaimTrie);
+    CCoinsViewCache coinsCache(&::ChainstateActive().CoinsTip());
 
     int bid = 0;
     if (request.params.size() > 1)
@@ -402,8 +403,8 @@ UniValue getclaimbyseq(const JSONRPCRequest& request)
     validateRequest(request, GETCLAIMBYSEQ, 1, 2);
 
     LOCK(cs_main);
-    CCoinsViewCache coinsCache(pcoinsTip.get());
     CClaimTrieCache trieCache(pclaimTrie);
+    CCoinsViewCache coinsCache(&::ChainstateActive().CoinsTip());
 
     int seq = 0;
     if (request.params.size() > 1)
@@ -448,7 +449,7 @@ UniValue getclaimbyid(const JSONRPCRequest& request)
 
     LOCK(cs_main);
     CClaimTrieCache trieCache(pclaimTrie);
-    CCoinsViewCache coinsCache(pcoinsTip.get());
+    CCoinsViewCache coinsCache(&::ChainstateActive().CoinsTip());
 
     std::string claimId;
     ParseClaimtrieId(request.params[0], claimId, T_CLAIMID " (parameter 1)");
@@ -524,7 +525,8 @@ UniValue getclaimsfortx(const JSONRPCRequest& request)
     std::vector<std::vector<unsigned char> > vvchParams;
 
     CClaimTrieCache trieCache(pclaimTrie);
-    CCoinsViewCache view(pcoinsTip.get());
+    CCoinsViewCache view(&::ChainstateActive().CoinsTip());
+
     const Coin& coin = AccessByTxid(view, hash);
     std::vector<CTxOut> txouts{ coin.out };
     int nHeight = coin.nHeight;
@@ -551,7 +553,7 @@ UniValue getclaimsfortx(const JSONRPCRequest& request)
                 o.pushKV(T_VALUE, HexStr(vvchParams[2].begin(), vvchParams[2].end()));
         }
         if (nHeight > 0) {
-            o.pushKV(T_DEPTH, chainActive.Height() - nHeight);
+            o.pushKV(T_DEPTH, ::ChainActive().Height() - nHeight);
             if (op == OP_CLAIM_NAME || op == OP_UPDATE_CLAIM) {
                 bool inClaimTrie = trieCache.haveClaim(sName, COutPoint(hash, i));
                 o.pushKV(T_INCLAIMTRIE, inClaimTrie);
@@ -564,7 +566,7 @@ UniValue getclaimsfortx(const JSONRPCRequest& request)
                     int nValidAtHeight;
                     if (trieCache.haveClaimInQueue(sName, COutPoint(hash, i), nValidAtHeight)) {
                         o.pushKV(T_INQUEUE, true);
-                        o.pushKV(T_BLOCKSTOVALID, nValidAtHeight - chainActive.Height());
+                        o.pushKV(T_BLOCKSTOVALID, nValidAtHeight - ::ChainActive().Height());
                     } else
                         o.pushKV(T_INQUEUE, false);
                     }
@@ -575,7 +577,7 @@ UniValue getclaimsfortx(const JSONRPCRequest& request)
                     int nValidAtHeight;
                     if (trieCache.haveSupportInQueue(sName, COutPoint(hash, i), nValidAtHeight)) {
                         o.pushKV(T_INQUEUE, true);
-                        o.pushKV(T_BLOCKSTOVALID, nValidAtHeight - chainActive.Height());
+                        o.pushKV(T_BLOCKSTOVALID, nValidAtHeight - ::ChainActive().Height());
                     } else
                         o.pushKV(T_INQUEUE, false);
                 }
@@ -617,19 +619,19 @@ UniValue proofToJSON(const CClaimTrieProof& proof)
     }
 
     if (!nodes.empty())
-        result.push_back(Pair(T_NODES, nodes));
+        result.pushKV(T_NODES, nodes);
 
     UniValue pairs(UniValue::VARR);
 
     for (const auto& itPair : proof.pairs) {
         UniValue child(UniValue::VOBJ);
-        child.push_back(Pair(T_ODD, itPair.first));
-        child.push_back(Pair(T_HASH, itPair.second.GetHex()));
+        child.pushKV(T_ODD, itPair.first);
+        child.pushKV(T_HASH, itPair.second.GetHex());
         pairs.push_back(child);
     }
 
     if (!pairs.empty())
-        result.push_back(Pair(T_PAIRS, pairs));
+        result.pushKV(T_PAIRS, pairs);
 
     if (proof.hasValue) {
         result.pushKV(T_TXID, proof.outPoint.hash.GetHex());
@@ -644,10 +646,10 @@ UniValue getnameproof(const JSONRPCRequest& request)
     validateRequest(request, GETNAMEPROOF, 1, 2);
 
     LOCK(cs_main);
-    CCoinsViewCache coinsCache(pcoinsTip.get());
     CClaimTrieCache trieCache(pclaimTrie);
+    CCoinsViewCache coinsCache(&::ChainstateActive().CoinsTip());
 
-    int validHeight = chainActive.Tip()->nHeight;
+    int validHeight = ::ChainActive().Tip()->nHeight;
     if (request.params.size() > 1) {
         CBlockIndex* pblockIndex = BlockHashIndex(ParseHashV(request.params[1], T_BLOCKHASH " (optional parameter 2)"));
         RollBackTo(pblockIndex, coinsCache, trieCache);
@@ -681,8 +683,8 @@ UniValue getclaimproofbybid(const JSONRPCRequest& request)
     validateRequest(request, GETCLAIMPROOFBYBID, 1, 2);
 
     LOCK(cs_main);
-    CCoinsViewCache coinsCache(pcoinsTip.get());
     CClaimTrieCache trieCache(pclaimTrie);
+    CCoinsViewCache coinsCache(&::ChainstateActive().CoinsTip());
 
     int bid = 0;
     if (request.params.size() > 1)
@@ -715,8 +717,8 @@ UniValue getclaimproofbyseq(const JSONRPCRequest& request)
     validateRequest(request, GETCLAIMPROOFBYSEQ, 1, 2);
 
     LOCK(cs_main);
-    CCoinsViewCache coinsCache(pcoinsTip.get());
     CClaimTrieCache trieCache(pclaimTrie);
+    CCoinsViewCache coinsCache(&::ChainstateActive().CoinsTip());
 
     int seq = 0;
     if (request.params.size() > 1)
@@ -752,7 +754,7 @@ UniValue getchangesinblock(const JSONRPCRequest& request)
     CBlock block;
     LOCK(cs_main);
     bool allowSupportMetadata;
-    CCoinsViewCache coinsCache(pcoinsTip.get());
+    CCoinsViewCache coinsCache(&::ChainstateActive().CoinsTip());
 
     UniValue claimsAddUp(UniValue::VARR),
             claimsRm(UniValue::VARR),
@@ -760,7 +762,7 @@ UniValue getchangesinblock(const JSONRPCRequest& request)
             supportsRm(UniValue::VARR);
 
     {
-        auto index = chainActive.Tip();
+        auto index = ::ChainActive().Tip();
         if (request.params.size() > 0)
             index = BlockHashIndex(ParseHashV(request.params[0], T_BLOCKHASH " (optional parameter)"));
 
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 541fdd9e4..162c8e225 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -30,11 +30,6 @@
 #include <validationinterface.h>
 #include <versionbitsinfo.h>
 #include <warnings.h>
-#ifdef ENABLE_WALLET
-#include <wallet/rpcwallet.h>
-#include <wallet/wallet.h>
-#endif
-
 
 #include <memory>
 #include <stdint.h>
@@ -369,8 +364,6 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
     UniValue lpval = NullUniValue;
     std::set<std::string> setClientRules;
     int64_t nMaxVersionPreVB = -1;
-    UniValue aMutable(UniValue::VARR);
-    bool wantsCoinbaseTxn = false;
     if (!request.params[0].isNull())
     {
         const UniValue& oparam = request.params[0].get_obj();
@@ -385,17 +378,6 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
         lpval = find_value(oparam, "longpollid");
 
-        const UniValue& capval = find_value(oparam, "capabilities");
-        if (capval.isArray()) {
-            for (std::size_t i = 0; i < capval.size(); ++i)
-                if (capval[i].get_str() == "coinbase/append") // should be coinbase/* ? we dont' care what they do to the coinbase
-                    aMutable.push_back(capval[i]);
-#ifdef ENABLE_WALLET
-                else if (capval[i].get_str() == "coinbasetxn")
-                    wantsCoinbaseTxn = true;
-#endif
-        }
-
         if (strMode == "proposal")
         {
             const UniValue& dataval = find_value(oparam, "data");
@@ -524,20 +506,8 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
         nStart = GetTime();
 
         // Create new block
-        CScript newBlockScript = CScript() << OP_TRUE;
-#ifdef ENABLE_WALLET
-        if (wantsCoinbaseTxn) {
-            std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
-            if (!wallet)
-                throw JSONRPCError(RPC_INVALID_PARAMS, "No wallet to comply with coinbasetxn request.");
-            std::shared_ptr<CReserveScript> coinbase_script;
-            wallet->GetScriptForMining(coinbase_script); // tops up and locks inside
-            if (!coinbase_script)
-                throw JSONRPCError(RPC_INVALID_PARAMS, "Unable to acquire address for coinbasetxn request.");
-            newBlockScript = coinbase_script->reserveScript;
-        }
-#endif
-        pblocktemplate = BlockAssembler(Params()).CreateNewBlock(newBlockScript);
+        CScript scriptDummy = CScript() << OP_TRUE;
+        pblocktemplate = BlockAssembler(Params()).CreateNewBlock(scriptDummy);
         if (!pblocktemplate)
             throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
 
@@ -554,11 +524,10 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
 
     // NOTE: If at some point we support pre-segwit miners post-segwit-activation, this needs to take segwit support into consideration
     const bool fPreSegWit = (pindexPrev->nHeight + 1 < consensusParams.SegwitHeight);
-    if (!fPreSegWit && !fSupportsSegwit)
+    if (!fPreSegWit)
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Segwit support is now required. Please include \"segwit\" in the client's rules.");
 
     UniValue aCaps(UniValue::VARR); aCaps.push_back("proposal");
-    UniValue result(UniValue::VOBJ);
 
     UniValue transactions(UniValue::VARR);
     std::map<uint256, int64_t> setTxIndex;
@@ -568,8 +537,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
         uint256 txHash = tx.GetHash();
         setTxIndex[txHash] = i++;
 
-        auto isCoinbase = tx.IsCoinBase();
-        if (isCoinbase && !wantsCoinbaseTxn)
+        if (tx.IsCoinBase())
             continue;
 
         UniValue entry(UniValue::VOBJ);
@@ -596,10 +564,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
         entry.pushKV("sigops", nTxSigOps);
         entry.pushKV("weight", GetTransactionWeight(tx));
 
-        if (isCoinbase)
-            result.pushKV("coinbasetxn", entry);
-        else
-            transactions.push_back(entry);
+        transactions.push_back(entry);
     }
 
     UniValue aux(UniValue::VOBJ);
@@ -607,10 +572,12 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
 
     arith_uint256 hashTarget = arith_uint256().SetCompact(pblock->nBits);
 
+    UniValue aMutable(UniValue::VARR);
     aMutable.push_back("time");
     aMutable.push_back("transactions");
     aMutable.push_back("prevblock");
 
+    UniValue result(UniValue::VOBJ);
     result.pushKV("capabilities", aCaps);
 
     UniValue aRules(UniValue::VARR);
@@ -677,7 +644,6 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
     result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1);
     result.pushKV("mutable", aMutable);
     result.pushKV("noncerange", "00000000ffffffff");
-
     int64_t nSigOpLimit = MAX_BLOCK_SIGOPS_COST;
     int64_t nSizeLimit = MAX_BLOCK_SERIALIZED_SIZE;
     if (fPreSegWit) {
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index a905ab62e..2f14533f9 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -542,7 +542,7 @@ static UniValue echo(const JSONRPCRequest& request)
             RPCHelpMan{"echo|echojson ...",
                 "\nSimply echo back the input arguments. This command is for testing.\n"
                 "\nThe difference between echo and echojson is that echojson has argument conversion enabled in the client-side table in "
-                "lbrycrd-cli and the GUI. There is no server-side difference."
+                "lbrycrd-cli and the GUI. There is no server-side difference.",
                 {},
                 RPCResults{},
                 RPCExamples{""},
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 44507c994..741c7cbfc 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -332,15 +332,6 @@ static UniValue verifytxoutproof(const JSONRPCRequest& request)
     return res;
 }
 
-
-    // Duplicate checking
-    std::set<CTxDestination> destinations;
-    bool has_data{false};
-
-            if (has_data) {
-                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, duplicate key: data");
-            }
-            has_data = true;
 static UniValue createrawtransaction(const JSONRPCRequest& request)
 {
             RPCHelpMan{"createrawtransaction",
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
index 3e5bb85c1..e2fc06d1d 100644
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -439,6 +439,15 @@ UniValue CRPCTable::execute(const JSONRPCRequest &request) const
     throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");
 }
 
+CRPCCaller CRPCTable::operator[](const std::string &name) const
+{
+    auto it = mapCommands.find(name);
+    assert(it != mapCommands.end());
+    auto& cmds = it->second;
+    assert(cmds.size() == 1);
+    return CRPCCaller(cmds[0]->actor);
+}
+
 static bool ExecuteCommand(const CRPCCommand& command, const JSONRPCRequest& request, UniValue& result, bool last_handler)
 {
     try
diff --git a/src/rpc/server.h b/src/rpc/server.h
index b060db5bf..2cf599d3a 100644
--- a/src/rpc/server.h
+++ b/src/rpc/server.h
@@ -115,6 +115,19 @@ public:
     intptr_t unique_id;
 };
 
+class CRPCCaller
+{
+    const CRPCCommand::Actor& actor;
+public:
+    explicit CRPCCaller(const CRPCCommand::Actor& actor) : actor(actor) {}
+    UniValue operator()(const JSONRPCRequest& jsonRequest)
+    {
+        UniValue val;
+        assert(actor(jsonRequest, val, true));
+        return val;
+    }
+};
+
 /**
  * Bitcoin RPC command dispatcher.
  */
@@ -124,6 +137,7 @@ private:
     std::map<std::string, std::vector<const CRPCCommand*>> mapCommands;
 public:
     CRPCTable();
+    CRPCCaller operator[](const std::string& name) const;
     std::string help(const std::string& name, const JSONRPCRequest& helpreq) const;
 
     /**
diff --git a/src/scheduler.cpp b/src/scheduler.cpp
index 193a92abb..fdc859b3a 100644
--- a/src/scheduler.cpp
+++ b/src/scheduler.cpp
@@ -16,7 +16,7 @@ CScheduler::CScheduler() : nThreadsServicingQueue(0), stopRequested(false), stop
 
 CScheduler::~CScheduler()
 {
-    assert(!AreThreadsServicingQueue());
+    assert(nThreadsServicingQueue == 0);
 }
 
 
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index 056b3299c..124bd169c 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -90,7 +90,8 @@ static bool CreateSig(const BaseSignatureCreator& creator, SignatureData& sigdat
     return false;
 }
 
-static CScript StripTimelockPrefix(const CScript& script) {
+static CScript StripTimelockPrefix(const CScript& script)
+{
     auto it = script.begin();
     opcodetype op;
     if (!script.GetOp(it, op))
@@ -263,26 +264,6 @@ bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreato
 }
 
 namespace {
-{
-    return !input.final_script_sig.empty() || !input.final_script_witness.IsNull();
-}
-
-    PSBTInput& input = psbt.inputs.at(index);
-    const CMutableTransaction& tx = *psbt.tx;
-
-
-    // Verify input sanity, which checks that at most one of witness or non-witness utxos is provided.
-    if (!input.IsSane()) {
-        return false;
-    }
-
-
-    // If we have a witness signature, use the smaller witness UTXO.
-    if (sigdata.witness) {
-        input.witness_utxo = utxo;
-        input.non_witness_utxo = nullptr;
-    }
-
 class SignatureExtractorChecker final : public BaseSignatureChecker
 {
 private:
diff --git a/src/script/sign.h b/src/script/sign.h
index c5b1a60da..0e751afd3 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -156,9 +156,6 @@ bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreato
 bool SignSignature(const SigningProvider &provider, const CScript& fromPubKey, CMutableTransaction& txTo, unsigned int nIn, const CAmount& amount, int nHashType);
 bool SignSignature(const SigningProvider &provider, const CTransaction& txFrom, CMutableTransaction& txTo, unsigned int nIn, int nHashType);
 
-/** Checks whether a PSBTInput is already signed. */
-bool PSBTInputSigned(PSBTInput& input);
-
 /** Extract signature data from a transaction input, and insert it. */
 SignatureData DataFromTransaction(const CMutableTransaction& tx, unsigned int nIn, const CTxOut& txout);
 void UpdateInput(CTxIn& input, const SignatureData& data);
diff --git a/src/test/Checkpoints_tests.cpp b/src/test/Checkpoints_tests.cpp
deleted file mode 100644
index 003e5d40a..000000000
--- a/src/test/Checkpoints_tests.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2011-2015 The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-//
-// Unit tests for block-chain checkpoints
-//
-
-#include "checkpoints.h"
-
-#include "uint256.h"
-#include "test/test_bitcoin.h"
-#include "chainparams.h"
-
-#include <boost/test/unit_test.hpp>
-
-using namespace std;
-
-BOOST_FIXTURE_TEST_SUITE(Checkpoints_tests, BasicTestingSetup)
-
-BOOST_AUTO_TEST_CASE(sanity)
-{
-    //const CCheckpointData& checkpoints = Params(CBaseChainParams::MAIN).Checkpoints();
-    //BOOST_CHECK(Checkpoints::GetTotalBlocksEstimate(checkpoints) >= 134444);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/claimtriebranching_tests.cpp b/src/test/claimtriebranching_tests.cpp
index 09bb3a458..f2c2ed12b 100644
--- a/src/test/claimtriebranching_tests.cpp
+++ b/src/test/claimtriebranching_tests.cpp
@@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE(takeover_stability_test) {
     BOOST_CHECK(fixture.is_best_claim("@bass", tx2));
     uint160 id; int takeover;
     BOOST_REQUIRE(fixture.getLastTakeoverForName("@bass", id, takeover));
-    auto height = chainActive.Tip()->nHeight;
+    auto height = ::ChainActive().Tip()->nHeight;
     BOOST_CHECK_EQUAL(takeover, height);
     CMutableTransaction tx3 = fixture.MakeClaim(fixture.GetCoinbase(), "@bass", "three", 3);
     fixture.Spend(tx3);
@@ -462,7 +462,7 @@ BOOST_AUTO_TEST_CASE(claimtrie_update_takeover_test)
     fixture.IncrementBlocks(1);
     uint160 cid2;
     int takeover;
-    int height = chainActive.Tip()->nHeight;
+    int height = ::ChainActive().Tip()->nHeight;
     fixture.getLastTakeoverForName("test", cid2, takeover);
     BOOST_CHECK_EQUAL(height, takeover);
     CMutableTransaction u1 = fixture.MakeUpdate(tx1, "test", "a", cid, 4);
@@ -1056,7 +1056,7 @@ BOOST_AUTO_TEST_CASE(insert_update_claim_test)
     fixture.IncrementBlocks(5);
 
     // put in bad tx10
-    CTransaction root = fixture.GetCoinbase();
+    auto root = fixture.GetCoinbase();
     CMutableTransaction tx10 = fixture.MakeUpdate(root, sName1, sValue1, tx1ClaimId, root.vout[0].nValue);
     COutPoint tx10OutPoint(tx10.GetHash(), 0);
     fixture.IncrementBlocks(1, true);
@@ -1198,7 +1198,7 @@ BOOST_AUTO_TEST_CASE(supporting_claims_test)
     std::string sValue1("testa");
     std::string sValue2("testb");
 
-    int initialHeight = chainActive.Height();
+    int initialHeight = ::ChainActive().Height();
 
     CClaimValue val;
 
@@ -1220,6 +1220,7 @@ BOOST_AUTO_TEST_CASE(supporting_claims_test)
     CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), sName, sValue1, 1);
     fixture.IncrementBlocks(1); // 1
 
+    auto* pcoinsTip = &::ChainstateActive().CoinsTip();
     BOOST_CHECK(pcoinsTip->HaveCoin(COutPoint(tx1.GetHash(), 0)));
     BOOST_CHECK(!pclaimTrie->empty());
     BOOST_CHECK(fixture.queueEmpty());
@@ -1361,7 +1362,7 @@ BOOST_AUTO_TEST_CASE(supporting_claims_test)
 
     // roll all the way back
     fixture.DecrementBlocks(22); // 0
-    BOOST_CHECK_EQUAL(initialHeight, chainActive.Height());
+    BOOST_CHECK_EQUAL(initialHeight, ::ChainActive().Height());
 
     // Make sure that when a support in the queue gets spent and then the spend is
     // undone, it goes back into the queue in the right spot
@@ -1462,6 +1463,7 @@ BOOST_AUTO_TEST_CASE(supporting_claims2_test)
     CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), sName, sValue1, 1);
     fixture.IncrementBlocks(1); // 1
 
+    auto* pcoinsTip = &::ChainstateActive().CoinsTip();
     BOOST_CHECK(pcoinsTip->HaveCoin(COutPoint(tx1.GetHash(), 0)));
     BOOST_CHECK(!pclaimTrie->empty());
     BOOST_CHECK(fixture.queueEmpty());
@@ -1839,6 +1841,7 @@ BOOST_AUTO_TEST_CASE(invalid_claimid_test)
     CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), sName, sValue1, 1);
     fixture.IncrementBlocks(1, true); // 1
 
+    auto* pcoinsTip = &::ChainstateActive().CoinsTip();
     BOOST_CHECK(pcoinsTip->HaveCoin(COutPoint(tx1.GetHash(), 0)));
     BOOST_CHECK(!pclaimTrie->empty());
     BOOST_CHECK(fixture.queueEmpty());
@@ -1947,7 +1950,7 @@ BOOST_AUTO_TEST_CASE(update_on_support2_test)
     std::string name = "test";
     std::string value = "one";
 
-    auto height = chainActive.Height();
+    auto height = ::ChainActive().Height();
 
     CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), name, value, 3);
     CMutableTransaction s1 = fixture.MakeSupport(fixture.GetCoinbase(), tx1, name, 1);
diff --git a/src/test/claimtriecache_tests.cpp b/src/test/claimtriecache_tests.cpp
index 30305e1c2..44a93fe8d 100644
--- a/src/test/claimtriecache_tests.cpp
+++ b/src/test/claimtriecache_tests.cpp
@@ -4,7 +4,6 @@
 #include <validation.h>
 
 #include <test/claimtriefixture.h>
-#include <test/test_bitcoin.h>
 #include <boost/test/unit_test.hpp>
 #include <boost/scope_exit.hpp>
 
diff --git a/src/test/claimtrieexpirationfork_tests.cpp b/src/test/claimtrieexpirationfork_tests.cpp
index a51d6ab46..e8ae418d8 100644
--- a/src/test/claimtrieexpirationfork_tests.cpp
+++ b/src/test/claimtrieexpirationfork_tests.cpp
@@ -194,7 +194,7 @@ BOOST_AUTO_TEST_CASE(hardfork_support_test)
     CMutableTransaction u1 = fixture.MakeUpdate(tx1, "test", "two", ClaimIdHash(tx1.GetHash(),0), 1);
     CMutableTransaction u2 = fixture.MakeUpdate(tx2, "test", "two", ClaimIdHash(tx2.GetHash(),0), 2);
     fixture.IncrementBlocks(1);
-    BOOST_CHECK_EQUAL(Params().GetConsensus().nExtendedClaimExpirationForkHeight, chainActive.Height());
+    BOOST_CHECK_EQUAL(Params().GetConsensus().nExtendedClaimExpirationForkHeight, ::ChainActive().Height());
 
     BOOST_CHECK(fixture.is_best_claim("test", u1));
     BOOST_CHECK(fixture.best_claim_effective_amount_equals("test",3));
@@ -578,6 +578,7 @@ BOOST_AUTO_TEST_CASE(expiring_supports_test)
     CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), sName, sValue1, 1);
     fixture.IncrementBlocks(1); // 1, expires at 81
 
+    auto* pcoinsTip = &::ChainstateActive().CoinsTip();
     BOOST_CHECK(pcoinsTip->HaveCoin(COutPoint(tx1.GetHash(), 0)));
     BOOST_CHECK(!pclaimTrie->empty());
     BOOST_CHECK(fixture.queueEmpty());
@@ -696,7 +697,7 @@ BOOST_AUTO_TEST_CASE(expiring_supports_test)
     fixture.Spend(tx3);
     fixture.IncrementBlocks(1); // 64
 
-    blocks_to_invalidate.push_back(chainActive.Tip()->GetBlockHash());
+    blocks_to_invalidate.push_back(::ChainActive().Tip()->GetBlockHash());
 
     BOOST_CHECK(!pclaimTrie->empty());
     BOOST_CHECK(fixture.queueEmpty());
diff --git a/src/test/claimtriefixture.cpp b/src/test/claimtriefixture.cpp
index bc77b4b67..9222cf0a5 100644
--- a/src/test/claimtriefixture.cpp
+++ b/src/test/claimtriefixture.cpp
@@ -7,6 +7,7 @@
 #include <primitives/transaction.h>
 #include <test/claimtriefixture.h>
 #include <validation.h>
+#include <util/system.h>
 
 using namespace std;
 
@@ -19,7 +20,7 @@ BOOST_AUTO_TEST_CASE(claimtriefixture_noop)
 
 BOOST_AUTO_TEST_SUITE_END()
 
-CMutableTransaction BuildTransaction(const CTransaction& prev, uint32_t prevout, unsigned int numOutputs, int locktime)
+CMutableTransaction BuildTransaction(const CMutableTransaction& prev, uint32_t prevout, unsigned int numOutputs, int locktime)
 {
     CMutableTransaction tx;
     tx.nVersion = CTransaction::CURRENT_VERSION;
@@ -30,7 +31,7 @@ CMutableTransaction BuildTransaction(const CTransaction& prev, uint32_t prevout,
     tx.vin[0].scriptSig = CScript();
     if (locktime != 0) {
         // Use a relative locktime for validity X blocks in the future
-        tx.nLockTime = chainActive.Height() + locktime;
+        tx.nLockTime = ::ChainActive().Height() + locktime;
         tx.vin[0].nSequence = 0xffffffff - 1;
     } else {
         tx.nLockTime = 1 << 31; // Disable BIP68
@@ -78,7 +79,7 @@ ClaimTrieChainFixture::ClaimTrieChainFixture() : CClaimTrieCache(pclaimTrie),
     minRemovalWorkaroundHeight(-1), maxRemovalWorkaroundHeight(-1)
 {
     fRequireStandard = false;
-    BOOST_CHECK_EQUAL(nNextHeight, chainActive.Height() + 1);
+    BOOST_CHECK_EQUAL(nNextHeight, ::ChainActive().Height() + 1);
     setNormalizationForkHeight(1000000);
 
     gArgs.ForceSetArg("-limitancestorcount", "1000000");
@@ -97,7 +98,7 @@ ClaimTrieChainFixture::ClaimTrieChainFixture() : CClaimTrieCache(pclaimTrie),
 ClaimTrieChainFixture::~ClaimTrieChainFixture()
 {
     added_unchecked = false;
-    DecrementBlocks(chainActive.Height());
+    DecrementBlocks(::ChainActive().Height());
     auto& consensus = const_cast<Consensus::Params&>(Params().GetConsensus());
     if (normalization_original >= 0) {
         consensus.nNormalizedNameForkHeight = normalization_original;
@@ -124,7 +125,7 @@ ClaimTrieChainFixture::~ClaimTrieChainFixture()
 }
 
 void ClaimTrieChainFixture::setRemovalWorkaroundHeight(int targetMinusCurrent, int blocks = 1000) {
-    int target = chainActive.Height() + targetMinusCurrent;
+    int target = ::ChainActive().Height() + targetMinusCurrent;
     auto& consensus = const_cast<Consensus::Params&>(Params().GetConsensus());
     if (minRemovalWorkaroundHeight < 0) {
         minRemovalWorkaroundHeight = consensus.nMinRemovalWorkaroundHeight;
@@ -138,7 +139,7 @@ void ClaimTrieChainFixture::setRemovalWorkaroundHeight(int targetMinusCurrent, i
 
 void ClaimTrieChainFixture::setExpirationForkHeight(int targetMinusCurrent, int64_t preForkExpirationTime, int64_t postForkExpirationTime)
 {
-    int target = chainActive.Height() + targetMinusCurrent;
+    int target = ::ChainActive().Height() + targetMinusCurrent;
     auto& consensus = const_cast<Consensus::Params&>(Params().GetConsensus());
     if (expirationForkHeight < 0) {
         expirationForkHeight = consensus.nExtendedClaimExpirationForkHeight;
@@ -155,7 +156,7 @@ void ClaimTrieChainFixture::setExpirationForkHeight(int targetMinusCurrent, int6
 
 void ClaimTrieChainFixture::setNormalizationForkHeight(int targetMinusCurrent)
 {
-    int target = chainActive.Height() + targetMinusCurrent;
+    int target = ::ChainActive().Height() + targetMinusCurrent;
     auto& consensus = const_cast<Consensus::Params&>(Params().GetConsensus());
     if (normalization_original < 0)
         normalization_original = consensus.nNormalizedNameForkHeight;
@@ -165,7 +166,7 @@ void ClaimTrieChainFixture::setNormalizationForkHeight(int targetMinusCurrent)
 
 void ClaimTrieChainFixture::setHashForkHeight(int targetMinusCurrent)
 {
-    int target = chainActive.Height() + targetMinusCurrent;
+    int target = ::ChainActive().Height() + targetMinusCurrent;
     auto& consensus = const_cast<Consensus::Params&>(Params().GetConsensus());
     if (forkhash_original < 0)
         forkhash_original = consensus.nAllClaimsInMerkleForkHeight;
@@ -179,11 +180,11 @@ bool ClaimTrieChainFixture::CreateBlock(const std::unique_ptr<CBlockTemplate>& p
     {
         LOCK(cs_main);
         pblock->nVersion = 5;
-        pblock->hashPrevBlock = chainActive.Tip()->GetBlockHash();
-        pblock->nTime = chainActive.Tip()->GetBlockTime() + Params().GetConsensus().nPowTargetSpacing;
+        pblock->hashPrevBlock = ::ChainActive().Tip()->GetBlockHash();
+        pblock->nTime = ::ChainActive().Tip()->GetBlockTime() + Params().GetConsensus().nPowTargetSpacing;
         CMutableTransaction txCoinbase(*pblock->vtx[0]);
-        txCoinbase.vin[0].scriptSig = CScript() << int(chainActive.Height() + 1) << int(++unique_block_counter);
-        txCoinbase.vout[0].nValue = GetBlockSubsidy(chainActive.Height() + 1, Params().GetConsensus());
+        txCoinbase.vin[0].scriptSig = CScript() << int(::ChainActive().Height() + 1) << int(++unique_block_counter);
+        txCoinbase.vout[0].nValue = GetBlockSubsidy(::ChainActive().Height() + 1, Params().GetConsensus());
         pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
         pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
         for (uint32_t i = 0;; ++i) {
@@ -193,7 +194,7 @@ bool ClaimTrieChainFixture::CreateBlock(const std::unique_ptr<CBlockTemplate>& p
         }
     }
     auto success = ProcessNewBlock(Params(), std::make_shared<const CBlock>(*pblock), true, nullptr);
-    return success && pblock->GetHash() == chainActive.Tip()->GetBlockHash();
+    return success && pblock->GetHash() == ::ChainActive().Tip()->GetBlockHash();
 }
 
 bool ClaimTrieChainFixture::CreateCoinbases(unsigned int num_coinbases, std::vector<CTransaction>& coinbases)
@@ -220,7 +221,7 @@ void ClaimTrieChainFixture::CommitTx(const CMutableTransaction &tx, bool has_loc
         added_unchecked = true;
         TestMemPoolEntryHelper entry;
         LOCK(mempool.cs);
-        mempool.addUnchecked(tx.GetHash(), entry.Fee(0).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
+        mempool.addUnchecked(entry.Fee(0).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     } else {
         CValidationState state;
         CAmount txFeeRate = CAmount(0);
@@ -230,7 +231,7 @@ void ClaimTrieChainFixture::CommitTx(const CMutableTransaction &tx, bool has_loc
 }
 
 // spend a bid into some non claimtrie related unspent
-CMutableTransaction ClaimTrieChainFixture::Spend(const CTransaction &prev)
+CMutableTransaction ClaimTrieChainFixture::Spend(const CMutableTransaction &prev)
 {
     CMutableTransaction tx = BuildTransaction(prev, 0);
     tx.vout[0].scriptPubKey = CScript() << OP_TRUE;
@@ -241,7 +242,7 @@ CMutableTransaction ClaimTrieChainFixture::Spend(const CTransaction &prev)
 }
 
 // make claim at the current block
-CMutableTransaction ClaimTrieChainFixture::MakeClaim(const CTransaction& prev, const std::string& name, const std::string& value, CAmount quantity, int locktime)
+CMutableTransaction ClaimTrieChainFixture::MakeClaim(const CMutableTransaction& prev, const std::string& name, const std::string& value, CAmount quantity, int locktime)
 {
     uint32_t prevout = prev.vout.size() - 1;
     while (prevout > 0 && prev.vout[prevout].nValue < quantity)
@@ -258,13 +259,13 @@ CMutableTransaction ClaimTrieChainFixture::MakeClaim(const CTransaction& prev, c
     return tx;
 }
 
-CMutableTransaction ClaimTrieChainFixture::MakeClaim(const CTransaction& prev, const std::string& name, const std::string& value)
+CMutableTransaction ClaimTrieChainFixture::MakeClaim(const CMutableTransaction& prev, const std::string& name, const std::string& value)
 {
     return MakeClaim(prev, name, value, prev.vout[0].nValue, 0);
 }
 
 // make support at the current block
-CMutableTransaction ClaimTrieChainFixture::MakeSupport(const CTransaction &prev, const CTransaction &claimtx, const std::string& name, CAmount quantity)
+CMutableTransaction ClaimTrieChainFixture::MakeSupport(const CMutableTransaction &prev, const CMutableTransaction &claimtx, const std::string& name, CAmount quantity)
 {
     uint32_t prevout = prev.vout.size() - 1;
     while (prevout > 0 && prev.vout[prevout].nValue < quantity)
@@ -283,7 +284,7 @@ CMutableTransaction ClaimTrieChainFixture::MakeSupport(const CTransaction &prev,
 }
 
 // make update at the current block
-CMutableTransaction ClaimTrieChainFixture::MakeUpdate(const CTransaction &prev, const std::string& name, const std::string& value, const uint160& claimId, CAmount quantity)
+CMutableTransaction ClaimTrieChainFixture::MakeUpdate(const CMutableTransaction &prev, const std::string& name, const std::string& value, const uint160& claimId, CAmount quantity)
 {
     CMutableTransaction tx = BuildTransaction(prev, 0);
     if (prev.vout[0].nValue < quantity) {
@@ -298,28 +299,28 @@ CMutableTransaction ClaimTrieChainFixture::MakeUpdate(const CTransaction &prev,
     return tx;
 }
 
-CTransaction& ClaimTrieChainFixture::GetCoinbase()
+CMutableTransaction ClaimTrieChainFixture::GetCoinbase()
 {
-    return coinbase_txs.at(coinbase_txs_used++);
+    return CMutableTransaction(coinbase_txs.at(coinbase_txs_used++));
 }
 
 // create i blocks
 void ClaimTrieChainFixture::IncrementBlocks(int num_blocks, bool mark)
 {
     if (mark)
-        marks.push_back(chainActive.Height());
+        marks.push_back(::ChainActive().Height());
 
     for (int i = 0; i < num_blocks; ++i) {
         CScript coinbase_scriptpubkey;
-        coinbase_scriptpubkey << CScriptNum(chainActive.Height());
+        coinbase_scriptpubkey << CScriptNum(::ChainActive().Height());
         std::unique_ptr<CBlockTemplate> pblocktemplate = AssemblerForTest().CreateNewBlock(coinbase_scriptpubkey);
         BOOST_REQUIRE(pblocktemplate != nullptr);
         if (!added_unchecked)
             BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), num_txs_for_next_block + 1);
         BOOST_REQUIRE(CreateBlock(pblocktemplate));
         num_txs_for_next_block = 0;
-        expirationHeight = chainActive.Height();
-        nNextHeight = chainActive.Height() + 1;
+        expirationHeight = ::ChainActive().Height();
+        nNextHeight = ::ChainActive().Height() + 1;
     }
 }
 
@@ -329,15 +330,15 @@ void ClaimTrieChainFixture::DecrementBlocks(int num_blocks)
     CValidationState state;
     {
         LOCK(cs_main);
-        CBlockIndex* pblockindex = chainActive[chainActive.Height() - num_blocks + 1];
+        CBlockIndex* pblockindex = ::ChainActive()[::ChainActive().Height() - num_blocks + 1];
         BOOST_CHECK_EQUAL(InvalidateBlock(state, Params(), pblockindex), true);
     }
     BOOST_CHECK_EQUAL(state.IsValid(), true);
     BOOST_CHECK_EQUAL(ActivateBestChain(state, Params()), true);
     mempool.clear();
     num_txs_for_next_block = 0;
-    expirationHeight = chainActive.Height();
-    nNextHeight = chainActive.Height() + 1;
+    expirationHeight = ::ChainActive().Height();
+    nNextHeight = ::ChainActive().Height() + 1;
 }
 
 // decrement back to last mark
@@ -345,7 +346,7 @@ void ClaimTrieChainFixture::DecrementBlocks()
 {
     int mark = marks.back();
     marks.pop_back();
-    DecrementBlocks(chainActive.Height() - mark);
+    DecrementBlocks(::ChainActive().Height() - mark);
 }
 
 bool ClaimTrieChainFixture::queueEmpty() const
@@ -396,7 +397,7 @@ boost::test_tools::predicate_result negativeResult(const std::string& message)
 }
 
 // is a claim in queue
-boost::test_tools::predicate_result ClaimTrieChainFixture::is_claim_in_queue(const std::string& name, const CTransaction &tx)
+boost::test_tools::predicate_result ClaimTrieChainFixture::is_claim_in_queue(const std::string& name, const CMutableTransaction &tx)
 {
     COutPoint outPoint(tx.GetHash(), 0);
     int validAtHeight;
@@ -406,7 +407,7 @@ boost::test_tools::predicate_result ClaimTrieChainFixture::is_claim_in_queue(con
 }
 
 // check if tx is best claim based on outpoint
-boost::test_tools::predicate_result ClaimTrieChainFixture::is_best_claim(const std::string& name, const CTransaction &tx)
+boost::test_tools::predicate_result ClaimTrieChainFixture::is_best_claim(const std::string& name, const CMutableTransaction &tx)
 {
     CClaimValue val;
     COutPoint outPoint(tx.GetHash(), 0);
diff --git a/src/test/claimtriefixture.h b/src/test/claimtriefixture.h
index f60e1b88d..008a6afe6 100644
--- a/src/test/claimtriefixture.h
+++ b/src/test/claimtriefixture.h
@@ -17,18 +17,16 @@
 #include <rpc/claimrpchelp.h>
 #include <rpc/server.h>
 #include <streams.h>
-#include <test/test_bitcoin.h>
-#include <util.h>
+#include <test/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 #include <iostream>
 
-extern ::ArgsManager gArgs;
 extern std::vector<std::string> random_strings(std::size_t count);
 
-class CTransaction;
+class CMutableTransaction;
 CMutableTransaction BuildTransaction(const uint256& prevhash);
-CMutableTransaction BuildTransaction(const CTransaction& prev, uint32_t prevout=0, unsigned int numOutputs=1, int locktime=0);
+CMutableTransaction BuildTransaction(const CMutableTransaction& prev, uint32_t prevout=0, unsigned int numOutputs=1, int locktime=0);
 
 class BlockAssembler;
 BlockAssembler AssemblerForTest();
@@ -72,20 +70,20 @@ struct ClaimTrieChainFixture: public CClaimTrieCache
     void CommitTx(const CMutableTransaction &tx, bool has_locktime=false);
 
     // spend a bid into some non claimtrie related unspent
-    CMutableTransaction Spend(const CTransaction &prev);
+    CMutableTransaction Spend(const CMutableTransaction &prev);
 
     // make claim at the current block
-    CMutableTransaction MakeClaim(const CTransaction& prev, const std::string& name, const std::string& value, CAmount quantity, int locktime=0);
+    CMutableTransaction MakeClaim(const CMutableTransaction& prev, const std::string& name, const std::string& value, CAmount quantity, int locktime=0);
 
-    CMutableTransaction MakeClaim(const CTransaction& prev, const std::string& name, const std::string& value);
+    CMutableTransaction MakeClaim(const CMutableTransaction& prev, const std::string& name, const std::string& value);
 
     // make support at the current block
-    CMutableTransaction MakeSupport(const CTransaction &prev, const CTransaction &claimtx, const std::string& name, CAmount quantity);
+    CMutableTransaction MakeSupport(const CMutableTransaction &prev, const CMutableTransaction &claimtx, const std::string& name, CAmount quantity);
 
     // make update at the current block
-    CMutableTransaction MakeUpdate(const CTransaction &prev, const std::string& name, const std::string& value, const uint160& claimId, CAmount quantity);
+    CMutableTransaction MakeUpdate(const CMutableTransaction &prev, const std::string& name, const std::string& value, const uint160& claimId, CAmount quantity);
 
-    CTransaction& GetCoinbase();
+    CMutableTransaction GetCoinbase();
 
     // create i blocks
     void IncrementBlocks(int num_blocks, bool mark = false);
@@ -111,10 +109,10 @@ struct ClaimTrieChainFixture: public CClaimTrieCache
     int64_t nodeCount() const;
 
     // is a claim in queue
-    boost::test_tools::predicate_result is_claim_in_queue(const std::string& name, const CTransaction &tx);
+    boost::test_tools::predicate_result is_claim_in_queue(const std::string& name, const CMutableTransaction &tx);
 
     // check if tx is best claim based on outpoint
-    boost::test_tools::predicate_result is_best_claim(const std::string& name, const CTransaction &tx);
+    boost::test_tools::predicate_result is_best_claim(const std::string& name, const CMutableTransaction &tx);
 
     // check effective quantity of best claim
     boost::test_tools::predicate_result best_claim_effective_amount_equals(const std::string& name, CAmount amount);
diff --git a/src/test/claimtriehashfork_tests.cpp b/src/test/claimtriehashfork_tests.cpp
index 3be8d78d5..ad45a0759 100644
--- a/src/test/claimtriehashfork_tests.cpp
+++ b/src/test/claimtriehashfork_tests.cpp
@@ -156,11 +156,11 @@ BOOST_AUTO_TEST_CASE(hash_claims_children_fuzzer_test)
     auto names = random_strings(300);
     auto lastTx = MakeTransactionRef(fixture.GetCoinbase());
     for (const auto& name : names) {
-        auto tx = fixture.MakeClaim(*lastTx, name, "one", 1);
+        auto tx = fixture.MakeClaim(CMutableTransaction(*lastTx), name, "one", 1);
         lastTx = MakeTransactionRef(std::move(tx));
         if (++i % 5 == 0)
             for (std::size_t j = 0;  j < (i / 5); ++j) {
-                auto tx = fixture.MakeClaim(*lastTx, name, "one", 1);
+                auto tx = fixture.MakeClaim(CMutableTransaction(*lastTx), name, "one", 1);
                 lastTx = MakeTransactionRef(std::move(tx));
             }
         fixture.IncrementBlocks(1);
@@ -302,31 +302,31 @@ BOOST_AUTO_TEST_CASE(value_proof_test)
     CClaimTrieProof proof;
 
     BOOST_CHECK(fixture.getProofForName(sName1, ClaimIdHash(tx1.GetHash(), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName1));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName1));
     BOOST_CHECK_EQUAL(proof.outPoint, tx1OutPoint);
 
     BOOST_CHECK(fixture.getProofForName(sName2, ClaimIdHash(tx2.GetHash(), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName2));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName2));
     BOOST_CHECK_EQUAL(proof.outPoint, tx2OutPoint);
 
     BOOST_CHECK(fixture.getProofForName(sName3, ClaimIdHash(tx3.GetHash(), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName3));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName3));
     BOOST_CHECK_EQUAL(proof.outPoint, tx3OutPoint);
 
     BOOST_CHECK(fixture.getProofForName(sName4, ClaimIdHash(tx4.GetHash(), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName4));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName4));
     BOOST_CHECK_EQUAL(proof.outPoint, tx4OutPoint);
 
     BOOST_CHECK(fixture.getProofForName(sName5, ClaimIdHash(tx1.GetHash(), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName5));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName5));
     BOOST_CHECK_EQUAL(proof.hasValue, false);
 
     BOOST_CHECK(fixture.getProofForName(sName6, ClaimIdHash({}, 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName6));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName6));
     BOOST_CHECK_EQUAL(proof.hasValue, false);
 
     BOOST_CHECK(fixture.getProofForName(sName7, ClaimIdHash(uint256(fixture.getMerkleHash()), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName7));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName7));
     BOOST_CHECK_EQUAL(proof.hasValue, false);
 
     CMutableTransaction tx5 = fixture.MakeClaim(fixture.GetCoinbase(), sName7, sValue4);
@@ -338,23 +338,23 @@ BOOST_AUTO_TEST_CASE(value_proof_test)
     BOOST_CHECK_EQUAL(val.outPoint, tx5OutPoint);
 
     BOOST_CHECK(fixture.getProofForName(sName1, ClaimIdHash(tx1.GetHash(), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName1));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName1));
     BOOST_CHECK_EQUAL(proof.outPoint, tx1OutPoint);
 
     BOOST_CHECK(fixture.getProofForName(sName2, ClaimIdHash(tx2.GetHash(), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName2));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName2));
     BOOST_CHECK_EQUAL(proof.outPoint, tx2OutPoint);
 
     BOOST_CHECK(fixture.getProofForName(sName3, ClaimIdHash(tx3.GetHash(), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName3));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName3));
     BOOST_CHECK_EQUAL(proof.outPoint, tx3OutPoint);
 
     BOOST_CHECK(fixture.getProofForName(sName4, ClaimIdHash(tx4.GetHash(), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName4));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName4));
     BOOST_CHECK_EQUAL(proof.outPoint, tx4OutPoint);
 
     BOOST_CHECK(fixture.getProofForName(sName5, ClaimIdHash(tx5.GetHash(), 0), proof));
-    BOOST_CHECK(verify_proof(proof, chainActive.Tip()->hashClaimTrie, sName5));
+    BOOST_CHECK(verify_proof(proof, ::ChainActive().Tip()->hashClaimTrie, sName5));
     BOOST_CHECK_EQUAL(proof.hasValue, false);
 
     fixture.DecrementBlocks();
@@ -369,18 +369,18 @@ BOOST_AUTO_TEST_CASE(bogus_claimtrie_hash_test)
     std::string sName("test");
     std::string sValue1("test");
 
-    int orig_chain_height = chainActive.Height();
+    int orig_chain_height = ::ChainActive().Height();
 
     CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), sName, sValue1, 1);
 
     std::unique_ptr<CBlockTemplate> pblockTemp;
     BOOST_CHECK(pblockTemp = AssemblerForTest().CreateNewBlock(tx1.vout[0].scriptPubKey));
-    pblockTemp->block.hashPrevBlock = chainActive.Tip()->GetBlockHash();
+    pblockTemp->block.hashPrevBlock = ::ChainActive().Tip()->GetBlockHash();
     pblockTemp->block.nVersion = 5;
-    pblockTemp->block.nTime = chainActive.Tip()->GetBlockTime() + Params().GetConsensus().nPowTargetSpacing;
+    pblockTemp->block.nTime = ::ChainActive().Tip()->GetBlockTime() + Params().GetConsensus().nPowTargetSpacing;
     CMutableTransaction txCoinbase(*pblockTemp->block.vtx[0]);
-    txCoinbase.vin[0].scriptSig = CScript() << int(chainActive.Height() + 1) << 1;
-    txCoinbase.vout[0].nValue = GetBlockSubsidy(chainActive.Height() + 1, Params().GetConsensus());
+    txCoinbase.vin[0].scriptSig = CScript() << int(::ChainActive().Height() + 1) << 1;
+    txCoinbase.vout[0].nValue = GetBlockSubsidy(::ChainActive().Height() + 1, Params().GetConsensus());
     pblockTemp->block.vtx[0] = MakeTransactionRef(std::move(txCoinbase));
     pblockTemp->block.hashMerkleRoot = BlockMerkleRoot(pblockTemp->block);
     //create bogus hash
@@ -398,8 +398,8 @@ BOOST_AUTO_TEST_CASE(bogus_claimtrie_hash_test)
     bool success = ProcessNewBlock(Params(), std::make_shared<const CBlock>(pblockTemp->block), true, nullptr);
     // will process , but will not be connected
     BOOST_CHECK(success);
-    BOOST_CHECK(pblockTemp->block.GetHash() != chainActive.Tip()->GetBlockHash());
-    BOOST_CHECK_EQUAL(orig_chain_height, chainActive.Height());
+    BOOST_CHECK(pblockTemp->block.GetHash() != ::ChainActive().Tip()->GetBlockHash());
+    BOOST_CHECK_EQUAL(orig_chain_height, ::ChainActive().Height());
 }
 
 #ifndef MAC_OSX // can't find a random number generator that produces the same sequence on OSX
@@ -420,7 +420,7 @@ BOOST_AUTO_TEST_CASE(bogus_claimtrie_hash_test)
         std::vector<CMutableTransaction> existingSupports;
         std::string value(1024, 'c');
 
-        std::vector<CTransaction> cb {fixture.GetCoinbase()};
+        std::vector<CMutableTransaction> cb {fixture.GetCoinbase()};
         for (int i = 0; i < blocks; ++i) {
             for (int j = 0; j < claimsPerBlock; ++j) {
                 auto name = names[i * claimsPerBlock + j];
@@ -455,7 +455,8 @@ BOOST_AUTO_TEST_CASE(bogus_claimtrie_hash_test)
                     fixture.Spend(tx);
                     existingSupports.erase(existingSupports.begin() + tidx);
                 }
-                if (cb.back().GetValueOut() < 10 || cb.size() > 40000) {
+                auto tx = CTransaction(cb.back());
+                if (tx.GetValueOut() < 10 || cb.size() > 40000) {
                     cb.clear();
                     cb.push_back(fixture.GetCoinbase());
                 }
diff --git a/src/test/claimtrienormalization_tests.cpp b/src/test/claimtrienormalization_tests.cpp
index 6f127bf16..7f04e5ffc 100644
--- a/src/test/claimtrienormalization_tests.cpp
+++ b/src/test/claimtrienormalization_tests.cpp
@@ -5,8 +5,6 @@
 #include <test/claimtriefixture.h>
 #include <validation.h>
 
-extern ::CChainState g_chainstate;
-
 using namespace std;
 
 BOOST_FIXTURE_TEST_SUITE(claimtrienormalization_tests, RegTestingSetup)
@@ -159,7 +157,7 @@ BOOST_AUTO_TEST_CASE(claimtriebranching_normalization)
 
     // Roll forward to fork height again and check again that we're normalized
     fixture.IncrementBlocks(1);
-    BOOST_CHECK(chainActive.Height() == Params().GetConsensus().nNormalizedNameForkHeight);
+    BOOST_CHECK(::ChainActive().Height() == Params().GetConsensus().nNormalizedNameForkHeight);
     BOOST_CHECK(fixture.is_best_claim("normalizetest", tx1)); // collapsed tx2
     BOOST_CHECK(fixture.is_best_claim(invalidUtf8, tx10));
 
@@ -170,7 +168,7 @@ BOOST_AUTO_TEST_CASE(claimtriebranching_normalization)
 
     // Roll forward to fork height again and check again that we're normalized
     fixture.IncrementBlocks(1);
-    BOOST_CHECK(chainActive.Height() == Params().GetConsensus().nNormalizedNameForkHeight);
+    BOOST_CHECK(::ChainActive().Height() == Params().GetConsensus().nNormalizedNameForkHeight);
     BOOST_CHECK(fixture.is_best_claim("normalizetest", tx1)); // collapsed tx2
 }
 
@@ -203,7 +201,7 @@ BOOST_AUTO_TEST_CASE(claimtriecache_normalization)
     // cache), flattening all previously existing name clashes due to
     // the normalization
     fixture.setNormalizationForkHeight(1);
-    int currentHeight = chainActive.Height();
+    int currentHeight = ::ChainActive().Height();
 
     fixture.IncrementBlocks(1);
     // Ok normalization fix the name problem
@@ -211,15 +209,16 @@ BOOST_AUTO_TEST_CASE(claimtriecache_normalization)
     BOOST_CHECK(nval1.nHeight == currentHeight);
     BOOST_CHECK(lookupClaim == nval1);
 
-    CCoinsViewCache coins(pcoinsTip.get());
     CClaimTrieCache trieCache(pclaimTrie);
-    CBlockIndex* pindex = chainActive.Tip();
+    CBlockIndex* pindex = ::ChainActive().Tip();
+    CCoinsViewCache coins(&::ChainstateActive().CoinsTip());
+
     CBlock block;
     int amelieValidHeight;
     std::string removed;
     BOOST_CHECK(trieCache.shouldNormalize());
     BOOST_CHECK(ReadBlockFromDisk(block, pindex, Params().GetConsensus()));
-    BOOST_CHECK(g_chainstate.DisconnectBlock(block, pindex, coins, trieCache) == DisconnectResult::DISCONNECT_OK);
+    BOOST_CHECK(::ChainstateActive().DisconnectBlock(block, pindex, coins, trieCache) == DisconnectResult::DISCONNECT_OK);
     BOOST_CHECK(!trieCache.shouldNormalize());
     BOOST_CHECK(trieCache.removeClaim(ClaimIdHash(tx2.GetHash(), 0), COutPoint(tx2.GetHash(), 0), removed, amelieValidHeight));
 
@@ -301,7 +300,7 @@ BOOST_AUTO_TEST_CASE(normalization_removal_test)
     CMutableTransaction sx2 = fixture.MakeSupport(fixture.GetCoinbase(), tx2, "Ab", 1);
 
     CClaimTrieCache cache(pclaimTrie);
-    int height = chainActive.Height() + 1;
+    int height = ::ChainActive().Height() + 1;
     cache.addClaim("AB", COutPoint(tx1.GetHash(), 0), ClaimIdHash(tx1.GetHash(), 0), 1, height);
     cache.addClaim("Ab", COutPoint(tx2.GetHash(), 0), ClaimIdHash(tx2.GetHash(), 0), 2, height);
     cache.addClaim("aB", COutPoint(tx3.GetHash(), 0), ClaimIdHash(tx3.GetHash(), 0), 3, height);
diff --git a/src/test/claimtrierpc_tests.cpp b/src/test/claimtrierpc_tests.cpp
index 4487dffc1..4b6e6ae9d 100644
--- a/src/test/claimtrierpc_tests.cpp
+++ b/src/test/claimtrierpc_tests.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://opensource.org/licenses/mit-license.php
 
 #include <test/claimtriefixture.h>
-#include <utilstrencodings.h>
+#include <util/strencodings.h>
 #include <validation.h>
 
 using namespace std;
@@ -18,12 +18,12 @@ BOOST_AUTO_TEST_CASE(getnamesintrie_test)
     std::string sName1("test");
     std::string sValue1("test");
 
-    uint256 blockHash = chainActive.Tip()->GetBlockHash();
+    uint256 blockHash = ::ChainActive().Tip()->GetBlockHash();
 
     fixture.MakeClaim(fixture.GetCoinbase(), sName1, sValue1, 42);
     fixture.IncrementBlocks(1);
 
-    rpcfn_type getnamesintrie = tableRPC["getnamesintrie"]->actor;
+    auto getnamesintrie = tableRPC["getnamesintrie"];
     JSONRPCRequest req;
     req.params = UniValue(UniValue::VARR);
 
@@ -45,12 +45,12 @@ BOOST_AUTO_TEST_CASE(getvalueforname_test)
     CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), sName1, sValue1, 2);
     fixture.IncrementBlocks(1);
 
-    uint256 blockHash = chainActive.Tip()->GetBlockHash();
+    uint256 blockHash = ::ChainActive().Tip()->GetBlockHash();
 
     fixture.MakeSupport(fixture.GetCoinbase(), tx1, sName1, 3);
     fixture.IncrementBlocks(10);
 
-    rpcfn_type getvalueforname = tableRPC["getvalueforname"]->actor;
+    auto getvalueforname = tableRPC["getvalueforname"];
     JSONRPCRequest req;
     req.params = UniValue(UniValue::VARR);
     req.params.push_back(UniValue(sName1));
@@ -74,17 +74,17 @@ BOOST_AUTO_TEST_CASE(getclaimsforname_test)
     std::string sValue1("test1");
     std::string sValue2("test2");
 
-    int height = chainActive.Height();
+    int height = ::ChainActive().Height();
 
     CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), sName1, sValue1, 2);
     fixture.IncrementBlocks(1);
 
-    uint256 blockHash = chainActive.Tip()->GetBlockHash();
+    uint256 blockHash = ::ChainActive().Tip()->GetBlockHash();
 
     CMutableTransaction tx2 = fixture.MakeClaim(fixture.GetCoinbase(), sName1, sValue2, 3);
     fixture.IncrementBlocks(1);
 
-    rpcfn_type getclaimsforname = tableRPC["getclaimsforname"]->actor;
+    auto getclaimsforname = tableRPC["getclaimsforname"];
     JSONRPCRequest req;
     req.params = UniValue(UniValue::VARR);
     req.params.push_back(UniValue(sName1));
@@ -124,20 +124,20 @@ BOOST_AUTO_TEST_CASE(claim_rpcs_rollback2_test)
     std::string sValue1("test1");
     std::string sValue2("test2");
 
-    int height = chainActive.Height();
+    int height = ::ChainActive().Height();
 
     CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), sName1, sValue1, 1);
     fixture.IncrementBlocks(2);
     CMutableTransaction tx2 = fixture.MakeClaim(fixture.GetCoinbase(), sName1, sValue2, 2);
     fixture.IncrementBlocks(3);
 
-    uint256 blockHash = chainActive.Tip()->GetBlockHash();
+    uint256 blockHash = ::ChainActive().Tip()->GetBlockHash();
 
     CMutableTransaction tx3 = fixture.MakeSupport(fixture.GetCoinbase(), tx1, sValue1, 3);
     fixture.IncrementBlocks(1);
 
-    rpcfn_type getclaimsforname = tableRPC["getclaimsforname"]->actor;
-    rpcfn_type getvalueforname = tableRPC["getvalueforname"]->actor;
+    auto getclaimsforname = tableRPC["getclaimsforname"];
+    auto getvalueforname = tableRPC["getvalueforname"];
     JSONRPCRequest req;
     req.params = UniValue(UniValue::VARR);
     req.params.push_back(UniValue(sName1));
@@ -160,26 +160,26 @@ BOOST_AUTO_TEST_CASE(claim_rpcs_rollback3_test)
     std::string sValue1("test1");
     std::string sValue2("test2");
 
-    int height = chainActive.Height();
+    int height = ::ChainActive().Height();
 
     CMutableTransaction tx1 = fixture.MakeClaim(fixture.GetCoinbase(), sName1, sValue1, 3);
     fixture.IncrementBlocks(1);
     CMutableTransaction tx2 = fixture.MakeClaim(fixture.GetCoinbase(), sName1, sValue2, 2);
     fixture.IncrementBlocks(2);
 
-    uint256 blockHash = chainActive.Tip()->GetBlockHash();
+    uint256 blockHash = ::ChainActive().Tip()->GetBlockHash();
 
     CMutableTransaction tx3 = fixture.Spend(tx1); // abandon the claim
     fixture.IncrementBlocks(1);
 
-    rpcfn_type getclaimsforname = tableRPC["getclaimsforname"]->actor;
-    rpcfn_type getvalueforname = tableRPC["getvalueforname"]->actor;
-    rpcfn_type getblocktemplate = tableRPC["getblocktemplate"]->actor;
+    auto getclaimsforname = tableRPC["getclaimsforname"];
+    auto getvalueforname = tableRPC["getvalueforname"];
+    auto getblocktemplate = tableRPC["getblocktemplate"];
 
     JSONRPCRequest req;
     req.params = UniValue(UniValue::VARR);
     UniValue templateResults = getblocktemplate(req);
-    BOOST_CHECK_EQUAL(templateResults["claimtrie"].get_str(), chainActive.Tip()->hashClaimTrie.GetHex());
+    BOOST_CHECK_EQUAL(templateResults["claimtrie"].get_str(), ::ChainActive().Tip()->hashClaimTrie.GetHex());
 
     req.params.push_back(UniValue(sName1));
     req.params.push_back(blockHash.GetHex());
@@ -230,7 +230,7 @@ BOOST_AUTO_TEST_CASE(hash_bid_seq_claim_changes_test)
     auto tx3 = fixture.MakeClaim(fixture.GetCoinbase(), name, value4, 4);
     fixture.IncrementBlocks(1);
 
-    int height = chainActive.Height();
+    int height = ::ChainActive().Height();
 
     auto claimId1 = ClaimIdHash(tx1.GetHash(), 0);
     auto claimId2 = ClaimIdHash(tx2.GetHash(), 0);
@@ -242,7 +242,7 @@ BOOST_AUTO_TEST_CASE(hash_bid_seq_claim_changes_test)
     int claim3bid = 2, claim3seq = 2;
     int claim4bid = 0, claim4seq = 3;
 
-    auto getclaimsforname = tableRPC["getclaimsforname"]->actor;
+    auto getclaimsforname = tableRPC["getclaimsforname"];
 
     JSONRPCRequest req;
     req.params = UniValue(UniValue::VARR);
@@ -269,7 +269,7 @@ BOOST_AUTO_TEST_CASE(hash_bid_seq_claim_changes_test)
     BOOST_CHECK_EQUAL(claims[3][T_SEQUENCE].get_int(), claim1seq);
     BOOST_CHECK_EQUAL(claims[3][T_CLAIMID].get_str(), claimId1.GetHex());
 
-    auto getclaimbybid = tableRPC["getclaimbybid"]->actor;
+    auto getclaimbybid = tableRPC["getclaimbybid"];
     req.params = UniValue(UniValue::VARR);
     req.params.push_back(UniValue(name));
     req.params.push_back(UniValue(claim3bid));
@@ -281,7 +281,7 @@ BOOST_AUTO_TEST_CASE(hash_bid_seq_claim_changes_test)
     BOOST_CHECK_EQUAL(result[T_SEQUENCE].get_int(), claim3seq);
     BOOST_CHECK_EQUAL(result[T_CLAIMID].get_str(), claimId3.GetHex());
 
-    auto getclaimbyseq = tableRPC["getclaimbyseq"]->actor;
+    auto getclaimbyseq = tableRPC["getclaimbyseq"];
     req.params = UniValue(UniValue::VARR);
     req.params.push_back(UniValue(name));
     req.params.push_back(UniValue(claim2seq));
@@ -293,7 +293,7 @@ BOOST_AUTO_TEST_CASE(hash_bid_seq_claim_changes_test)
     BOOST_CHECK_EQUAL(result[T_SEQUENCE].get_int(), claim2seq);
     BOOST_CHECK_EQUAL(result[T_CLAIMID].get_str(), claimId2.GetHex());
 
-    auto getclaimbyid = tableRPC["getclaimbyid"]->actor;
+    auto getclaimbyid = tableRPC["getclaimbyid"];
     req.params = UniValue(UniValue::VARR);
     req.params.push_back(UniValue(claimId1.GetHex()));
 
@@ -315,9 +315,9 @@ BOOST_AUTO_TEST_CASE(hash_bid_seq_claim_changes_test)
     BOOST_CHECK_EQUAL(result[T_SEQUENCE].get_int(), claim3seq);
     BOOST_CHECK_EQUAL(result[T_CLAIMID].get_str(), claimId3.GetHex());
 
-    auto blockhash = chainActive.Tip()->GetBlockHash();
+    auto blockhash = ::ChainActive().Tip()->GetBlockHash();
 
-    auto getnameproof = tableRPC["getnameproof"]->actor;
+    auto getnameproof = tableRPC["getnameproof"];
     req.params = UniValue(UniValue::VARR);
     req.params.push_back(UniValue(name));
     req.params.push_back(UniValue(blockhash.GetHex()));
@@ -337,7 +337,7 @@ BOOST_AUTO_TEST_CASE(hash_bid_seq_claim_changes_test)
     claimHash = getValueHash(COutPoint(tx2.GetHash(), 0), result[T_LASTTAKEOVERHEIGHT].get_int());
     ValidatePairs(fixture, jsonToPairs(result[T_PAIRS]), claimHash);
 
-    auto getclaimproofbybid = tableRPC["getclaimproofbybid"]->actor;
+    auto getclaimproofbybid = tableRPC["getclaimproofbybid"];
     req.params = UniValue(UniValue::VARR);
     req.params.push_back(UniValue(name));
     req.params.push_back(UniValue(claim1bid));
@@ -346,7 +346,7 @@ BOOST_AUTO_TEST_CASE(hash_bid_seq_claim_changes_test)
     claimHash = getValueHash(COutPoint(tx1.GetHash(), 0), result[T_LASTTAKEOVERHEIGHT].get_int());
     ValidatePairs(fixture, jsonToPairs(result[T_PAIRS]), claimHash);
 
-    auto getclaimproofbyseq = tableRPC["getclaimproofbyseq"]->actor;
+    auto getclaimproofbyseq = tableRPC["getclaimproofbyseq"];
     req.params = UniValue(UniValue::VARR);
     req.params.push_back(UniValue(name));
     req.params.push_back(UniValue(claim4seq));
@@ -355,7 +355,7 @@ BOOST_AUTO_TEST_CASE(hash_bid_seq_claim_changes_test)
     claimHash = getValueHash(COutPoint(tx3.GetHash(), 0), result[T_LASTTAKEOVERHEIGHT].get_int());
     ValidatePairs(fixture, jsonToPairs(result[T_PAIRS]), claimHash);
 
-    auto getchangesinblock = tableRPC["getchangesinblock"]->actor;
+    auto getchangesinblock = tableRPC["getchangesinblock"];
     req.params = UniValue(UniValue::VARR);
     req.params.push_back(UniValue(blockhash.GetHex()));
 
@@ -376,7 +376,7 @@ BOOST_AUTO_TEST_CASE(claim_rpc_pending_amount_test)
     std::string sValue1("test1");
     std::string sValue2("test2");
 
-    rpcfn_type getclaimsforname = tableRPC["getclaimsforname"]->actor;
+    auto getclaimsforname = tableRPC["getclaimsforname"];
 
     JSONRPCRequest req;
     req.params = UniValue(UniValue::VARR);
diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp
index c2312df04..41646aafe 100644
--- a/src/test/coins_tests.cpp
+++ b/src/test/coins_tests.cpp
@@ -3,11 +3,13 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <attributes.h>
+#include <claimtrie/forks.h>
 #include <clientversion.h>
 #include <coins.h>
 #include <script/standard.h>
 #include <streams.h>
 #include <test/setup_common.h>
+#include <validation.h>
 #include <uint256.h>
 #include <undo.h>
 #include <util/strencodings.h>
diff --git a/src/test/hash_tests.cpp b/src/test/hash_tests.cpp
index d91fcb003..f6adeb615 100644
--- a/src/test/hash_tests.cpp
+++ b/src/test/hash_tests.cpp
@@ -5,6 +5,7 @@
 #include <clientversion.h>
 #include <crypto/siphash.h>
 #include <hash.h>
+#include <primitives/transaction.h>
 #include <util/strencodings.h>
 #include <test/setup_common.h>
 
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index d34fbbb08..10643d864 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -223,11 +223,11 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
         {
             BOOST_CHECK(!pblock->hashClaimTrie.IsNull());
             LOCK(cs_main);
-            pblock->hashPrevBlock = chainActive.Tip()->GetBlockHash();
+            pblock->hashPrevBlock = ::ChainActive().Tip()->GetBlockHash();
             pblock->nVersion = 5;
-            pblock->nTime = chainActive.Tip()->GetBlockTime() + chainparams.GetConsensus().nPowTargetSpacing;
+            pblock->nTime = ::ChainActive().Tip()->GetBlockTime() + chainparams.GetConsensus().nPowTargetSpacing;
             CMutableTransaction txCoinbase(*pblock->vtx[0]);
-            txCoinbase.vin[0].scriptSig = CScript() << int(chainActive.Height() + 1) << i;
+            txCoinbase.vin[0].scriptSig = CScript() << int(::ChainActive().Height() + 1) << i;
             txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
             txCoinbase.vout[0].scriptPubKey = CScript();
             pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
@@ -373,8 +373,8 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
     // subsidy changing
     int nHeight = ::ChainActive().Height();
     // Create an actual 209999-long block chain (without valid blocks).
-    while (chainActive.Tip()->nHeight < 209999) {
-        CBlockIndex* prev = chainActive.Tip();
+    while (::ChainActive().Tip()->nHeight < 209999) {
+        CBlockIndex* prev = ::ChainActive().Tip();
         CBlockIndex* next = new CBlockIndex();
         next->phashBlock = new uint256(InsecureRand256());
         next->hashClaimTrie = pblocktemplate->block.hashClaimTrie;
diff --git a/src/test/nameclaim_tests.cpp b/src/test/nameclaim_tests.cpp
index 96c6af4ed..d3e8abfd7 100644
--- a/src/test/nameclaim_tests.cpp
+++ b/src/test/nameclaim_tests.cpp
@@ -2,7 +2,7 @@
 #include <core_io.h>
 #include <boost/test/unit_test.hpp>
 #include <primitives/transaction.h>
-#include <test/test_bitcoin.h>
+#include <test/setup_common.h>
 
 BOOST_FIXTURE_TEST_SUITE(nameclaim_tests, BasicTestingSetup)
 
diff --git a/src/test/script_tests.1cpp b/src/test/script_tests.1cpp
new file mode 100644
index 000000000..84a70fe78
--- /dev/null
+++ b/src/test/script_tests.1cpp
@@ -0,0 +1,1665 @@
+// Copyright (c) 2011-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/data/script_tests.json.h>
+
+#include <core_io.h>
+#include <key.h>
+#include <script/script.h>
+#include <script/script_error.h>
+#include <script/sign.h>
+#include <script/signingprovider.h>
+#include <util/system.h>
+#include <util/strencodings.h>
+#include <test/setup_common.h>
+#include <rpc/util.h>
+#include <streams.h>
+
+#if defined(HAVE_CONSENSUS_LIB)
+#include <script/bitcoinconsensus.h>
+#endif
+
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+#include <univalue.h>
+
+// Uncomment if you want to output updated JSON tests.
+// #define UPDATE_JSON_TESTS
+
+static const unsigned int gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
+
+unsigned int ParseScriptFlags(std::string strFlags);
+std::string FormatScriptFlags(unsigned int flags);
+
+UniValue
+read_json(const std::string& jsondata)
+{
+    UniValue v;
+
+    if (!v.read(jsondata) || !v.isArray())
+    {
+        BOOST_ERROR("Parse error.");
+        return UniValue(UniValue::VARR);
+    }
+    return v.get_array();
+}
+
+struct ScriptErrorDesc
+{
+    ScriptError_t err;
+    const char *name;
+};
+
+static ScriptErrorDesc script_errors[]={
+    {SCRIPT_ERR_OK, "OK"},
+    {SCRIPT_ERR_UNKNOWN_ERROR, "UNKNOWN_ERROR"},
+    {SCRIPT_ERR_EVAL_FALSE, "EVAL_FALSE"},
+    {SCRIPT_ERR_OP_RETURN, "OP_RETURN"},
+    {SCRIPT_ERR_SCRIPT_SIZE, "SCRIPT_SIZE"},
+    {SCRIPT_ERR_PUSH_SIZE, "PUSH_SIZE"},
+    {SCRIPT_ERR_OP_COUNT, "OP_COUNT"},
+    {SCRIPT_ERR_STACK_SIZE, "STACK_SIZE"},
+    {SCRIPT_ERR_SIG_COUNT, "SIG_COUNT"},
+    {SCRIPT_ERR_PUBKEY_COUNT, "PUBKEY_COUNT"},
+    {SCRIPT_ERR_VERIFY, "VERIFY"},
+    {SCRIPT_ERR_EQUALVERIFY, "EQUALVERIFY"},
+    {SCRIPT_ERR_CHECKMULTISIGVERIFY, "CHECKMULTISIGVERIFY"},
+    {SCRIPT_ERR_CHECKSIGVERIFY, "CHECKSIGVERIFY"},
+    {SCRIPT_ERR_NUMEQUALVERIFY, "NUMEQUALVERIFY"},
+    {SCRIPT_ERR_BAD_OPCODE, "BAD_OPCODE"},
+    {SCRIPT_ERR_DISABLED_OPCODE, "DISABLED_OPCODE"},
+    {SCRIPT_ERR_INVALID_STACK_OPERATION, "INVALID_STACK_OPERATION"},
+    {SCRIPT_ERR_INVALID_ALTSTACK_OPERATION, "INVALID_ALTSTACK_OPERATION"},
+    {SCRIPT_ERR_UNBALANCED_CONDITIONAL, "UNBALANCED_CONDITIONAL"},
+    {SCRIPT_ERR_NEGATIVE_LOCKTIME, "NEGATIVE_LOCKTIME"},
+    {SCRIPT_ERR_UNSATISFIED_LOCKTIME, "UNSATISFIED_LOCKTIME"},
+    {SCRIPT_ERR_SIG_HASHTYPE, "SIG_HASHTYPE"},
+    {SCRIPT_ERR_SIG_DER, "SIG_DER"},
+    {SCRIPT_ERR_MINIMALDATA, "MINIMALDATA"},
+    {SCRIPT_ERR_SIG_PUSHONLY, "SIG_PUSHONLY"},
+    {SCRIPT_ERR_SIG_HIGH_S, "SIG_HIGH_S"},
+    {SCRIPT_ERR_SIG_NULLDUMMY, "SIG_NULLDUMMY"},
+    {SCRIPT_ERR_PUBKEYTYPE, "PUBKEYTYPE"},
+    {SCRIPT_ERR_CLEANSTACK, "CLEANSTACK"},
+    {SCRIPT_ERR_MINIMALIF, "MINIMALIF"},
+    {SCRIPT_ERR_SIG_NULLFAIL, "NULLFAIL"},
+    {SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS, "DISCOURAGE_UPGRADABLE_NOPS"},
+    {SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM, "DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM"},
+    {SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH, "WITNESS_PROGRAM_WRONG_LENGTH"},
+    {SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY, "WITNESS_PROGRAM_WITNESS_EMPTY"},
+    {SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH, "WITNESS_PROGRAM_MISMATCH"},
+    {SCRIPT_ERR_WITNESS_MALLEATED, "WITNESS_MALLEATED"},
+    {SCRIPT_ERR_WITNESS_MALLEATED_P2SH, "WITNESS_MALLEATED_P2SH"},
+    {SCRIPT_ERR_WITNESS_UNEXPECTED, "WITNESS_UNEXPECTED"},
+    {SCRIPT_ERR_WITNESS_PUBKEYTYPE, "WITNESS_PUBKEYTYPE"},
+    {SCRIPT_ERR_OP_CODESEPARATOR, "OP_CODESEPARATOR"},
+    {SCRIPT_ERR_SIG_FINDANDDELETE, "SIG_FINDANDDELETE"},
+};
+
+static const char *FormatScriptError(ScriptError_t err)
+{
+    for (unsigned int i=0; i<ARRAYLEN(script_errors); ++i)
+        if (script_errors[i].err == err)
+            return script_errors[i].name;
+    BOOST_ERROR("Unknown scripterror enumeration value, update script_errors in script_tests.cpp.");
+    return "";
+}
+
+static ScriptError_t ParseScriptError(const std::string &name)
+{
+    for (unsigned int i=0; i<ARRAYLEN(script_errors); ++i)
+        if (script_errors[i].name == name)
+            return script_errors[i].err;
+    BOOST_ERROR("Unknown scripterror \"" << name << "\" in test description");
+    return SCRIPT_ERR_UNKNOWN_ERROR;
+}
+
+BOOST_FIXTURE_TEST_SUITE(script_tests, BasicTestingSetup)
+
+CMutableTransaction BuildCreditingTransaction(const CScript& scriptPubKey, int nValue = 0)
+{
+    CMutableTransaction txCredit;
+    txCredit.nVersion = 1;
+    txCredit.nLockTime = 0;
+    txCredit.vin.resize(1);
+    txCredit.vout.resize(1);
+    txCredit.vin[0].prevout.SetNull();
+    txCredit.vin[0].scriptSig = CScript() << CScriptNum(0) << CScriptNum(0);
+    txCredit.vin[0].nSequence = CTxIn::SEQUENCE_FINAL;
+    txCredit.vout[0].scriptPubKey = scriptPubKey;
+    txCredit.vout[0].nValue = nValue;
+
+    return txCredit;
+}
+
+CMutableTransaction BuildSpendingTransaction(const CScript& scriptSig, const CScriptWitness& scriptWitness, const CTransaction& txCredit)
+{
+    CMutableTransaction txSpend;
+    txSpend.nVersion = 1;
+    txSpend.nLockTime = 0;
+    txSpend.vin.resize(1);
+    txSpend.vout.resize(1);
+    txSpend.vin[0].scriptWitness = scriptWitness;
+    txSpend.vin[0].prevout.hash = txCredit.GetHash();
+    txSpend.vin[0].prevout.n = 0;
+    txSpend.vin[0].scriptSig = scriptSig;
+    txSpend.vin[0].nSequence = CTxIn::SEQUENCE_FINAL;
+    txSpend.vout[0].scriptPubKey = CScript();
+    txSpend.vout[0].nValue = txCredit.vout[0].nValue;
+
+    return txSpend;
+}
+
+void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const CScriptWitness& scriptWitness, int flags, const std::string& message, int scriptError, CAmount nValue = 0)
+{
+    bool expect = (scriptError == SCRIPT_ERR_OK);
+    if (flags & SCRIPT_VERIFY_CLEANSTACK) {
+        flags |= SCRIPT_VERIFY_P2SH;
+        flags |= SCRIPT_VERIFY_WITNESS;
+    }
+    ScriptError err;
+    const CTransaction txCredit{BuildCreditingTransaction(scriptPubKey, nValue)};
+    CMutableTransaction tx = BuildSpendingTransaction(scriptSig, scriptWitness, txCredit);
+    CMutableTransaction tx2 = tx;
+    BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, &scriptWitness, flags, MutableTransactionSignatureChecker(&tx, 0, txCredit.vout[0].nValue), &err) == expect, message);
+    BOOST_CHECK_MESSAGE(err == scriptError, std::string(FormatScriptError(err)) + " where " + std::string(FormatScriptError((ScriptError_t)scriptError)) + " expected: " + message);
+
+    // Verify that removing flags from a passing test or adding flags to a failing test does not change the result.
+    for (int i = 0; i < 16; ++i) {
+        int extra_flags = InsecureRandBits(16);
+        int combined_flags = expect ? (flags & ~extra_flags) : (flags | extra_flags);
+        // Weed out some invalid flag combinations.
+        if (combined_flags & SCRIPT_VERIFY_CLEANSTACK && ~combined_flags & (SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS)) continue;
+        if (combined_flags & SCRIPT_VERIFY_WITNESS && ~combined_flags & SCRIPT_VERIFY_P2SH) continue;
+        BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, &scriptWitness, combined_flags, MutableTransactionSignatureChecker(&tx, 0, txCredit.vout[0].nValue), &err) == expect, message + strprintf(" (with flags %x)", combined_flags));
+    }
+
+#if defined(HAVE_CONSENSUS_LIB)
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << tx2;
+    int libconsensus_flags = flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_ALL;
+    if (libconsensus_flags == flags) {
+        int expectedSuccessCode = expect ? 1 : 0;
+        if (flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_WITNESS) {
+            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), txCredit.vout[0].nValue, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expectedSuccessCode, message);
+        } else {
+            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), 0, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expectedSuccessCode, message);
+            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expectedSuccessCode, message);
+        }
+    }
+#endif
+}
+
+void static NegateSignatureS(std::vector<unsigned char>& vchSig) {
+    // Parse the signature.
+    std::vector<unsigned char> r, s;
+    r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
+    s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
+
+    // Really ugly to implement mod-n negation here, but it would be feature creep to expose such functionality from libsecp256k1.
+    static const unsigned char order[33] = {
+        0x00,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
+        0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
+        0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x41
+    };
+    while (s.size() < 33) {
+        s.insert(s.begin(), 0x00);
+    }
+    int carry = 0;
+    for (int p = 32; p >= 1; p--) {
+        int n = (int)order[p] - s[p] - carry;
+        s[p] = (n + 256) & 0xFF;
+        carry = (n < 0);
+    }
+    assert(carry == 0);
+    if (s.size() > 1 && s[0] == 0 && s[1] < 0x80) {
+        s.erase(s.begin());
+    }
+
+    // Reconstruct the signature.
+    vchSig.clear();
+    vchSig.push_back(0x30);
+    vchSig.push_back(4 + r.size() + s.size());
+    vchSig.push_back(0x02);
+    vchSig.push_back(r.size());
+    vchSig.insert(vchSig.end(), r.begin(), r.end());
+    vchSig.push_back(0x02);
+    vchSig.push_back(s.size());
+    vchSig.insert(vchSig.end(), s.begin(), s.end());
+}
+
+namespace
+{
+const unsigned char vchKey0[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
+const unsigned char vchKey1[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0};
+const unsigned char vchKey2[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0};
+
+struct KeyData
+{
+    CKey key0, key0C, key1, key1C, key2, key2C;
+    CPubKey pubkey0, pubkey0C, pubkey0H;
+    CPubKey pubkey1, pubkey1C;
+    CPubKey pubkey2, pubkey2C;
+
+    KeyData()
+    {
+
+        key0.Set(vchKey0, vchKey0 + 32, false);
+        key0C.Set(vchKey0, vchKey0 + 32, true);
+        pubkey0 = key0.GetPubKey();
+        pubkey0H = key0.GetPubKey();
+        pubkey0C = key0C.GetPubKey();
+        *const_cast<unsigned char*>(&pubkey0H[0]) = 0x06 | (pubkey0H[64] & 1);
+
+        key1.Set(vchKey1, vchKey1 + 32, false);
+        key1C.Set(vchKey1, vchKey1 + 32, true);
+        pubkey1 = key1.GetPubKey();
+        pubkey1C = key1C.GetPubKey();
+
+        key2.Set(vchKey2, vchKey2 + 32, false);
+        key2C.Set(vchKey2, vchKey2 + 32, true);
+        pubkey2 = key2.GetPubKey();
+        pubkey2C = key2C.GetPubKey();
+    }
+};
+
+enum class WitnessMode {
+    NONE,
+    PKH,
+    SH
+};
+
+class TestBuilder
+{
+private:
+    //! Actually executed script
+    CScript script;
+    //! The P2SH redeemscript
+    CScript redeemscript;
+    //! The Witness embedded script
+    CScript witscript;
+    CScriptWitness scriptWitness;
+    CTransactionRef creditTx;
+    CMutableTransaction spendTx;
+    bool havePush;
+    std::vector<unsigned char> push;
+    std::string comment;
+    int flags;
+    int scriptError;
+    CAmount nValue;
+
+    void DoPush()
+    {
+        if (havePush) {
+            spendTx.vin[0].scriptSig << push;
+            havePush = false;
+        }
+    }
+
+    void DoPush(const std::vector<unsigned char>& data)
+    {
+         DoPush();
+         push = data;
+         havePush = true;
+    }
+
+public:
+    TestBuilder(const CScript& script_, const std::string& comment_, int flags_, bool P2SH = false, WitnessMode wm = WitnessMode::NONE, int witnessversion = 0, CAmount nValue_ = 0) : script(script_), havePush(false), comment(comment_), flags(flags_), scriptError(SCRIPT_ERR_OK), nValue(nValue_)
+    {
+        CScript scriptPubKey = script;
+        if (wm == WitnessMode::PKH) {
+            uint160 hash;
+            CHash160().Write(&script[1], script.size() - 1).Finalize(hash.begin());
+            script = CScript() << OP_DUP << OP_HASH160 << ToByteVector(hash) << OP_EQUALVERIFY << OP_CHECKSIG;
+            scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
+        } else if (wm == WitnessMode::SH) {
+            witscript = scriptPubKey;
+            uint256 hash;
+            CSHA256().Write(&witscript[0], witscript.size()).Finalize(hash.begin());
+            scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
+        }
+        if (P2SH) {
+            redeemscript = scriptPubKey;
+            scriptPubKey = CScript() << OP_HASH160 << ToByteVector(CScriptID(redeemscript)) << OP_EQUAL;
+        }
+        creditTx = MakeTransactionRef(BuildCreditingTransaction(scriptPubKey, nValue));
+        spendTx = BuildSpendingTransaction(CScript(), CScriptWitness(), *creditTx);
+    }
+
+    TestBuilder& ScriptError(ScriptError_t err)
+    {
+        scriptError = err;
+        return *this;
+    }
+
+    TestBuilder& Add(const CScript& _script)
+    {
+        DoPush();
+        spendTx.vin[0].scriptSig += _script;
+        return *this;
+    }
+
+    TestBuilder& Num(int num)
+    {
+        DoPush();
+        spendTx.vin[0].scriptSig << num;
+        return *this;
+    }
+
+    TestBuilder& Push(const std::string& hex)
+    {
+        DoPush(ParseHex(hex));
+        return *this;
+    }
+
+    TestBuilder& Push(const CScript& _script) {
+         DoPush(std::vector<unsigned char>(_script.begin(), _script.end()));
+        return *this;
+    }
+
+    TestBuilder& PushSig(const CKey& key, int nHashType = SIGHASH_ALL, unsigned int lenR = 32, unsigned int lenS = 32, SigVersion sigversion = SigVersion::BASE, CAmount amount = 0)
+    {
+        uint256 hash = SignatureHash(script, spendTx, 0, nHashType, amount, sigversion);
+        std::vector<unsigned char> vchSig, r, s;
+        uint32_t iter = 0;
+        do {
+            key.Sign(hash, vchSig, false, iter++);
+            if ((lenS == 33) != (vchSig[5 + vchSig[3]] == 33)) {
+                NegateSignatureS(vchSig);
+            }
+            r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
+            s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
+        } while (lenR != r.size() || lenS != s.size());
+        vchSig.push_back(static_cast<unsigned char>(nHashType));
+        DoPush(vchSig);
+        return *this;
+    }
+
+    TestBuilder& PushWitSig(const CKey& key, CAmount amount = -1, int nHashType = SIGHASH_ALL, unsigned int lenR = 32, unsigned int lenS = 32, SigVersion sigversion = SigVersion::WITNESS_V0)
+    {
+        if (amount == -1)
+            amount = nValue;
+        return PushSig(key, nHashType, lenR, lenS, sigversion, amount).AsWit();
+    }
+
+    TestBuilder& Push(const CPubKey& pubkey)
+    {
+        DoPush(std::vector<unsigned char>(pubkey.begin(), pubkey.end()));
+        return *this;
+    }
+
+    TestBuilder& PushRedeem()
+    {
+        DoPush(std::vector<unsigned char>(redeemscript.begin(), redeemscript.end()));
+        return *this;
+    }
+
+    TestBuilder& PushWitRedeem()
+    {
+        DoPush(std::vector<unsigned char>(witscript.begin(), witscript.end()));
+        return AsWit();
+    }
+
+    TestBuilder& EditPush(unsigned int pos, const std::string& hexin, const std::string& hexout)
+    {
+        assert(havePush);
+        std::vector<unsigned char> datain = ParseHex(hexin);
+        std::vector<unsigned char> dataout = ParseHex(hexout);
+        assert(pos + datain.size() <= push.size());
+        BOOST_CHECK_MESSAGE(std::vector<unsigned char>(push.begin() + pos, push.begin() + pos + datain.size()) == datain, comment);
+        push.erase(push.begin() + pos, push.begin() + pos + datain.size());
+        push.insert(push.begin() + pos, dataout.begin(), dataout.end());
+        return *this;
+    }
+
+    TestBuilder& DamagePush(unsigned int pos)
+    {
+        assert(havePush);
+        assert(pos < push.size());
+        push[pos] ^= 1;
+        return *this;
+    }
+
+    TestBuilder& Test()
+    {
+        TestBuilder copy = *this; // Make a copy so we can rollback the push.
+        DoPush();
+        DoTest(creditTx->vout[0].scriptPubKey, spendTx.vin[0].scriptSig, scriptWitness, flags, comment, scriptError, nValue);
+        *this = copy;
+        return *this;
+    }
+
+    TestBuilder& AsWit()
+    {
+        assert(havePush);
+        scriptWitness.stack.push_back(push);
+        havePush = false;
+        return *this;
+    }
+
+    UniValue GetJSON()
+    {
+        DoPush();
+        UniValue array(UniValue::VARR);
+        if (!scriptWitness.stack.empty()) {
+            UniValue wit(UniValue::VARR);
+            for (unsigned i = 0; i < scriptWitness.stack.size(); i++) {
+                wit.push_back(HexStr(scriptWitness.stack[i]));
+            }
+            wit.push_back(ValueFromAmount(nValue));
+            array.push_back(wit);
+        }
+        array.push_back(FormatScript(spendTx.vin[0].scriptSig));
+        array.push_back(FormatScript(creditTx->vout[0].scriptPubKey));
+        array.push_back(FormatScriptFlags(flags));
+        array.push_back(FormatScriptError((ScriptError_t)scriptError));
+        array.push_back(comment);
+        return array;
+    }
+
+    std::string GetComment() const
+    {
+        return comment;
+    }
+};
+
+std::string JSONPrettyPrint(const UniValue& univalue)
+{
+    std::string ret = univalue.write(4);
+    // Workaround for libunivalue pretty printer, which puts a space between commas and newlines
+    size_t pos = 0;
+    while ((pos = ret.find(" \n", pos)) != std::string::npos) {
+        ret.replace(pos, 2, "\n");
+        pos++;
+    }
+    return ret;
+}
+} // namespace
+
+BOOST_AUTO_TEST_CASE(script_build)
+{
+    const KeyData keys;
+
+    std::vector<TestBuilder> tests;
+
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "P2PK", 0
+                               ).PushSig(keys.key0));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "P2PK, bad sig", 0
+                               ).PushSig(keys.key0).DamagePush(10).ScriptError(SCRIPT_ERR_EVAL_FALSE));
+
+    tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1C.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
+                                "P2PKH", 0
+                               ).PushSig(keys.key1).Push(keys.pubkey1C));
+    tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey2C.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
+                                "P2PKH, bad pubkey", 0
+                               ).PushSig(keys.key2).Push(keys.pubkey2C).DamagePush(5).ScriptError(SCRIPT_ERR_EQUALVERIFY));
+
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
+                                "P2PK anyonecanpay", 0
+                               ).PushSig(keys.key1, SIGHASH_ALL | SIGHASH_ANYONECANPAY));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
+                                "P2PK anyonecanpay marked with normal hashtype", 0
+                               ).PushSig(keys.key1, SIGHASH_ALL | SIGHASH_ANYONECANPAY).EditPush(70, "81", "01").ScriptError(SCRIPT_ERR_EVAL_FALSE));
+
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
+                                "P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true
+                               ).PushSig(keys.key0).PushRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
+                                "P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true
+                               ).PushSig(keys.key0).PushRedeem().DamagePush(10).ScriptError(SCRIPT_ERR_EVAL_FALSE));
+
+    tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey0.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
+                                "P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true
+                               ).PushSig(keys.key0).Push(keys.pubkey0).PushRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
+                                "P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0, true
+                               ).PushSig(keys.key0).DamagePush(10).PushRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG,
+                                "P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH, true
+                               ).PushSig(keys.key0).DamagePush(10).PushRedeem().ScriptError(SCRIPT_ERR_EQUALVERIFY));
+
+    tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
+                                "3-of-3", 0
+                               ).Num(0).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
+    tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
+                                "3-of-3, 2 sigs", 0
+                               ).Num(0).PushSig(keys.key0).PushSig(keys.key1).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
+
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
+                                "P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true
+                               ).Num(0).PushSig(keys.key1).PushSig(keys.key2).PushRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
+                                "P2SH(2-of-3), 1 sig", SCRIPT_VERIFY_P2SH, true
+                               ).Num(0).PushSig(keys.key1).Num(0).PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
+
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "P2PK with too much R padding but no DERSIG", 0
+                               ).PushSig(keys.key1, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000"));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "P2PK with too much R padding", SCRIPT_VERIFY_DERSIG
+                               ).PushSig(keys.key1, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "P2PK with too much S padding but no DERSIG", 0
+                               ).PushSig(keys.key1, SIGHASH_ALL).EditPush(1, "44", "45").EditPush(37, "20", "2100"));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "P2PK with too much S padding", SCRIPT_VERIFY_DERSIG
+                               ).PushSig(keys.key1, SIGHASH_ALL).EditPush(1, "44", "45").EditPush(37, "20", "2100").ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "P2PK with too little R padding but no DERSIG", 0
+                               ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "P2PK with too little R padding", SCRIPT_VERIFY_DERSIG
+                               ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
+                                "P2PK NOT with bad sig with too much R padding but no DERSIG", 0
+                               ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").DamagePush(10));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
+                                "P2PK NOT with bad sig with too much R padding", SCRIPT_VERIFY_DERSIG
+                               ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").DamagePush(10).ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
+                                "P2PK NOT with too much R padding but no DERSIG", 0
+                               ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
+                                "P2PK NOT with too much R padding", SCRIPT_VERIFY_DERSIG
+                               ).PushSig(keys.key2, SIGHASH_ALL, 31, 32).EditPush(1, "43021F", "44022000").ScriptError(SCRIPT_ERR_SIG_DER));
+
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "BIP66 example 1, without DERSIG", 0
+                               ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
+                                "BIP66 example 2, without DERSIG", 0
+                               ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
+                                "BIP66 example 2, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "BIP66 example 3, without DERSIG", 0
+                               ).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "BIP66 example 3, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
+                                "BIP66 example 4, without DERSIG", 0
+                               ).Num(0));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
+                                "BIP66 example 4, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).Num(0));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "BIP66 example 5, without DERSIG", 0
+                               ).Num(1).ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
+                                "BIP66 example 5, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).Num(1).ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
+                                "BIP66 example 6, without DERSIG", 0
+                               ).Num(1));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
+                                "BIP66 example 6, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).Num(1).ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
+                                "BIP66 example 7, without DERSIG", 0
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
+                                "BIP66 example 7, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
+                                "BIP66 example 8, without DERSIG", 0
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
+                                "BIP66 example 8, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
+                                "BIP66 example 9, without DERSIG", 0
+                               ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
+                                "BIP66 example 9, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
+                                "BIP66 example 10, without DERSIG", 0
+                               ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220"));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
+                                "BIP66 example 10, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).Num(0).Num(0).PushSig(keys.key2, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").ScriptError(SCRIPT_ERR_SIG_DER));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
+                                "BIP66 example 11, without DERSIG", 0
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG,
+                                "BIP66 example 11, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0).ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
+                                "BIP66 example 12, without DERSIG", 0
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT,
+                                "BIP66 example 12, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL, 33, 32).EditPush(1, "45022100", "440220").Num(0));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
+                                "P2PK with multi-byte hashtype, without DERSIG", 0
+                               ).PushSig(keys.key2, SIGHASH_ALL).EditPush(70, "01", "0101"));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
+                                "P2PK with multi-byte hashtype, with DERSIG", SCRIPT_VERIFY_DERSIG
+                               ).PushSig(keys.key2, SIGHASH_ALL).EditPush(70, "01", "0101").ScriptError(SCRIPT_ERR_SIG_DER));
+
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
+                                "P2PK with high S but no LOW_S", 0
+                               ).PushSig(keys.key2, SIGHASH_ALL, 32, 33));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
+                                "P2PK with high S", SCRIPT_VERIFY_LOW_S
+                               ).PushSig(keys.key2, SIGHASH_ALL, 32, 33).ScriptError(SCRIPT_ERR_SIG_HIGH_S));
+
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
+                                "P2PK with hybrid pubkey but no STRICTENC", 0
+                               ).PushSig(keys.key0, SIGHASH_ALL));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
+                                "P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC
+                               ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
+                                "P2PK NOT with hybrid pubkey but no STRICTENC", 0
+                               ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
+                                "P2PK NOT with hybrid pubkey", SCRIPT_VERIFY_STRICTENC
+                               ).PushSig(keys.key0, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
+                                "P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0
+                               ).PushSig(keys.key0, SIGHASH_ALL).DamagePush(10));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
+                                "P2PK NOT with invalid hybrid pubkey", SCRIPT_VERIFY_STRICTENC
+                               ).PushSig(keys.key0, SIGHASH_ALL).DamagePush(10).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
+                                "1-of-2 with the second 1 hybrid pubkey and no STRICTENC", 0
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL));
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
+                                "1-of-2 with the second 1 hybrid pubkey", SCRIPT_VERIFY_STRICTENC
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL));
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0H) << OP_2 << OP_CHECKMULTISIG,
+                                "1-of-2 with the first 1 hybrid pubkey", SCRIPT_VERIFY_STRICTENC
+                               ).Num(0).PushSig(keys.key1, SIGHASH_ALL).ScriptError(SCRIPT_ERR_PUBKEYTYPE));
+
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
+                                "P2PK with undefined hashtype but no STRICTENC", 0
+                               ).PushSig(keys.key1, 5));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
+                                "P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC
+                               ).PushSig(keys.key1, 5).ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
+                                "P2PK NOT with invalid sig and undefined hashtype but no STRICTENC", 0
+                               ).PushSig(keys.key1, 5).DamagePush(10));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
+                                "P2PK NOT with invalid sig and undefined hashtype", SCRIPT_VERIFY_STRICTENC
+                               ).PushSig(keys.key1, 5).DamagePush(10).ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
+
+    tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
+                                "3-of-3 with nonzero dummy but no NULLDUMMY", 0
+                               ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
+    tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG,
+                                "3-of-3 with nonzero dummy", SCRIPT_VERIFY_NULLDUMMY
+                               ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).ScriptError(SCRIPT_ERR_SIG_NULLDUMMY));
+    tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG << OP_NOT,
+                                "3-of-3 NOT with invalid sig and nonzero dummy but no NULLDUMMY", 0
+                               ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).DamagePush(10));
+    tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG << OP_NOT,
+                                "3-of-3 NOT with invalid sig with nonzero dummy", SCRIPT_VERIFY_NULLDUMMY
+                               ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).DamagePush(10).ScriptError(SCRIPT_ERR_SIG_NULLDUMMY));
+
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
+                                "2-of-2 with two identical keys and sigs pushed using OP_DUP but no SIGPUSHONLY", 0
+                               ).Num(0).PushSig(keys.key1).Add(CScript() << OP_DUP));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
+                                "2-of-2 with two identical keys and sigs pushed using OP_DUP", SCRIPT_VERIFY_SIGPUSHONLY
+                               ).Num(0).PushSig(keys.key1).Add(CScript() << OP_DUP).ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
+                                "P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0, true
+                               ).PushSig(keys.key2).Add(CScript() << OP_NOP8).PushRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
+                                "P2PK with non-push scriptSig but with P2SH validation", 0
+                               ).PushSig(keys.key2).Add(CScript() << OP_NOP8));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
+                                "P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY", SCRIPT_VERIFY_P2SH, true
+                               ).PushSig(keys.key2).Add(CScript() << OP_NOP8).PushRedeem().ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
+                                "P2SH(P2PK) with non-push scriptSig but not P2SH", SCRIPT_VERIFY_SIGPUSHONLY, true
+                               ).PushSig(keys.key2).Add(CScript() << OP_NOP8).PushRedeem().ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
+    tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 << OP_CHECKMULTISIG,
+                                "2-of-2 with two identical keys and sigs pushed", SCRIPT_VERIFY_SIGPUSHONLY
+                               ).Num(0).PushSig(keys.key1).PushSig(keys.key1));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "P2PK with unnecessary input but no CLEANSTACK", SCRIPT_VERIFY_P2SH
+                               ).Num(11).PushSig(keys.key0));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "P2PK with unnecessary input", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH
+                               ).Num(11).PushSig(keys.key0).ScriptError(SCRIPT_ERR_CLEANSTACK));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "P2SH with unnecessary input but no CLEANSTACK", SCRIPT_VERIFY_P2SH, true
+                               ).Num(11).PushSig(keys.key0).PushRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "P2SH with unnecessary input", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true
+                               ).Num(11).PushSig(keys.key0).PushRedeem().ScriptError(SCRIPT_ERR_CLEANSTACK));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "P2SH with CLEANSTACK", SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true
+                               ).PushSig(keys.key0).PushRedeem());
+
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "Basic P2WSH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
+                                0, 1).PushWitSig(keys.key0).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
+                                "Basic P2WPKH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH,
+                                0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "Basic P2SH(P2WSH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
+                                0, 1).PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
+                                "Basic P2SH(P2WPKH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH,
+                                0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
+                                "Basic P2WSH with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
+                               ).PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
+                                "Basic P2WPKH with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
+                               ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
+                                "Basic P2SH(P2WSH) with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH
+                               ).PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
+                                "Basic P2SH(P2WPKH) with the wrong key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH
+                               ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
+                                "Basic P2WSH with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
+                               ).PushWitSig(keys.key0).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
+                                "Basic P2WPKH with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
+                               ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
+                                "Basic P2SH(P2WSH) with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, true, WitnessMode::SH
+                               ).PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
+                                "Basic P2SH(P2WPKH) with the wrong key but no WITNESS", SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH
+                               ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "Basic P2WSH with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
+                                0, 0).PushWitSig(keys.key0, 1).PushWitRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
+                                "Basic P2WPKH with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH,
+                                0, 0).PushWitSig(keys.key0, 1).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "Basic P2SH(P2WSH) with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
+                                0, 0).PushWitSig(keys.key0, 1).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
+                                "Basic P2SH(P2WPKH) with wrong value", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH,
+                                0, 0).PushWitSig(keys.key0, 1).Push(keys.pubkey0).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_EVAL_FALSE));
+
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
+                                "P2WPKH with future witness version", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH |
+                                SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM, false, WitnessMode::PKH, 1
+                               ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM));
+    {
+        CScript witscript = CScript() << ToByteVector(keys.pubkey0);
+        uint256 hash;
+        CSHA256().Write(&witscript[0], witscript.size()).Finalize(hash.begin());
+        std::vector<unsigned char> hashBytes = ToByteVector(hash);
+        hashBytes.pop_back();
+        tests.push_back(TestBuilder(CScript() << OP_0 << hashBytes,
+                                    "P2WPKH with wrong witness program length", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false
+                                   ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH));
+    }
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "P2WSH with empty witness", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
+                               ).ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY));
+    {
+        CScript witscript = CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG;
+        tests.push_back(TestBuilder(witscript,
+                                    "P2WSH with witness program mismatch", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH
+                                   ).PushWitSig(keys.key0).Push(witscript).DamagePush(0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH));
+    }
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
+                                "P2WPKH with witness program mismatch", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
+                               ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().Push("0").AsWit().ScriptError(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
+                                "P2WPKH with non-empty scriptSig", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::PKH
+                               ).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().Num(11).ScriptError(SCRIPT_ERR_WITNESS_MALLEATED));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1),
+                                "P2SH(P2WPKH) with superfluous push in scriptSig", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::PKH
+                               ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().Num(11).PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_MALLEATED_P2SH));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "P2PK with witness", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH
+                               ).PushSig(keys.key0).Push("0").AsWit().ScriptError(SCRIPT_ERR_WITNESS_UNEXPECTED));
+
+    // Compressed keys should pass SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
+                                "Basic P2WSH with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
+                                0, 1).PushWitSig(keys.key0C).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C),
+                                "Basic P2WPKH with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::PKH,
+                                0, 1).PushWitSig(keys.key0C).Push(keys.pubkey0C).AsWit());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
+                                "Basic P2SH(P2WSH) with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
+                                0, 1).PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0C),
+                                "Basic P2SH(P2WPKH) with compressed key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::PKH,
+                                0, 1).PushWitSig(keys.key0C).Push(keys.pubkey0C).AsWit().PushRedeem());
+
+    // Testing uncompressed key in witness with SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "Basic P2WSH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
+                                0, 1).PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
+                                "Basic P2WPKH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::PKH,
+                                0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
+                                "Basic P2SH(P2WSH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
+                                0, 1).PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
+                                "Basic P2SH(P2WPKH)", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::PKH,
+                                0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
+
+    // P2WSH 1-of-2 multisig with compressed keys
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2WSH CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2SH(P2WSH) CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2WSH CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2SH(P2WSH) CHECKMULTISIG with compressed keys", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem());
+
+    // P2WSH 1-of-2 multisig with first key uncompressed
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
+                                "P2WSH CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
+                                "P2SH(P2WSH) CHECKMULTISIG first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
+                                "P2WSH CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
+                                "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
+                                "P2WSH CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
+                                "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
+                                "P2WSH CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey0) << OP_2 << OP_CHECKMULTISIG,
+                                "P2SH(P2WSH) CHECKMULTISIG with first key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
+    // P2WSH 1-of-2 multisig with second key uncompressed
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2WSH CHECKMULTISIG with second key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2SH(P2WSH) CHECKMULTISIG second key uncompressed and signing with the first key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2WSH CHECKMULTISIG with second key uncompressed and signing with the first key should pass as the uncompressed key is not used", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the first key should pass as the uncompressed key is not used", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2WSH CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().PushRedeem());
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2WSH CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, false, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
+    tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << ToByteVector(keys.pubkey0C) << OP_2 << OP_CHECKMULTISIG,
+                                "P2SH(P2WSH) CHECKMULTISIG with second key uncompressed and signing with the second key", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS_PUBKEYTYPE, true, WitnessMode::SH,
+                                0, 1).Push(CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().PushRedeem().ScriptError(SCRIPT_ERR_WITNESS_PUBKEYTYPE));
+
+    std::set<std::string> tests_set;
+
+    {
+        UniValue json_tests = read_json(std::string(json_tests::script_tests, json_tests::script_tests + sizeof(json_tests::script_tests)));
+
+        for (unsigned int idx = 0; idx < json_tests.size(); idx++) {
+            const UniValue& tv = json_tests[idx];
+            tests_set.insert(JSONPrettyPrint(tv.get_array()));
+        }
+    }
+
+#ifdef UPDATE_JSON_TESTS
+    std::string strGen;
+#endif
+    for (TestBuilder& test : tests) {
+        test.Test();
+        std::string str = JSONPrettyPrint(test.GetJSON());
+#ifdef UPDATE_JSON_TESTS
+        strGen += str + ",\n";
+#else
+        if (tests_set.count(str) == 0) {
+            BOOST_CHECK_MESSAGE(false, "Missing auto script_valid test: " + test.GetComment());
+        }
+#endif
+    }
+
+#ifdef UPDATE_JSON_TESTS
+    FILE* file = fopen("script_tests.json.gen", "w");
+    fputs(strGen.c_str(), file);
+    fclose(file);
+#endif
+}
+
+BOOST_AUTO_TEST_CASE(script_json_test)
+{
+    // Read tests from test/data/script_tests.json
+    // Format is an array of arrays
+    // Inner arrays are [ ["wit"..., nValue]?, "scriptSig", "scriptPubKey", "flags", "expected_scripterror" ]
+    // ... where scriptSig and scriptPubKey are stringified
+    // scripts.
+    // If a witness is given, then the last value in the array should be the
+    // amount (nValue) to use in the crediting tx
+    UniValue tests = read_json(std::string(json_tests::script_tests, json_tests::script_tests + sizeof(json_tests::script_tests)));
+
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        UniValue test = tests[idx];
+        std::string strTest = test.write();
+        CScriptWitness witness;
+        CAmount nValue = 0;
+        unsigned int pos = 0;
+        if (test.size() > 0 && test[pos].isArray()) {
+            unsigned int i=0;
+            for (i = 0; i < test[pos].size()-1; i++) {
+                witness.stack.push_back(ParseHex(test[pos][i].get_str()));
+            }
+            nValue = AmountFromValue(test[pos][i]);
+            pos++;
+        }
+        if (test.size() < 4 + pos) // Allow size > 3; extra stuff ignored (useful for comments)
+        {
+            if (test.size() != 1) {
+                BOOST_ERROR("Bad test: " << strTest);
+            }
+            continue;
+        }
+        std::string scriptSigString = test[pos++].get_str();
+        CScript scriptSig = ParseScript(scriptSigString);
+        std::string scriptPubKeyString = test[pos++].get_str();
+        CScript scriptPubKey = ParseScript(scriptPubKeyString);
+        unsigned int scriptflags = ParseScriptFlags(test[pos++].get_str());
+        int scriptError = ParseScriptError(test[pos++].get_str());
+
+        DoTest(scriptPubKey, scriptSig, witness, scriptflags, strTest, scriptError, nValue);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(script_PushData)
+{
+    // Check that PUSHDATA1, PUSHDATA2, and PUSHDATA4 create the same value on
+    // the stack as the 1-75 opcodes do.
+    static const unsigned char direct[] = { 1, 0x5a };
+    static const unsigned char pushdata1[] = { OP_PUSHDATA1, 1, 0x5a };
+    static const unsigned char pushdata2[] = { OP_PUSHDATA2, 1, 0, 0x5a };
+    static const unsigned char pushdata4[] = { OP_PUSHDATA4, 1, 0, 0, 0, 0x5a };
+
+    ScriptError err;
+    std::vector<std::vector<unsigned char> > directStack;
+    BOOST_CHECK(EvalScript(directStack, CScript(direct, direct + sizeof(direct)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+
+    std::vector<std::vector<unsigned char> > pushdata1Stack;
+    BOOST_CHECK(EvalScript(pushdata1Stack, CScript(pushdata1, pushdata1 + sizeof(pushdata1)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
+    BOOST_CHECK(pushdata1Stack == directStack);
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+
+    std::vector<std::vector<unsigned char> > pushdata2Stack;
+    BOOST_CHECK(EvalScript(pushdata2Stack, CScript(pushdata2, pushdata2 + sizeof(pushdata2)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
+    BOOST_CHECK(pushdata2Stack == directStack);
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+
+    std::vector<std::vector<unsigned char> > pushdata4Stack;
+    BOOST_CHECK(EvalScript(pushdata4Stack, CScript(pushdata4, pushdata4 + sizeof(pushdata4)), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
+    BOOST_CHECK(pushdata4Stack == directStack);
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+
+    const std::vector<unsigned char> pushdata1_trunc{OP_PUSHDATA1, 1};
+    const std::vector<unsigned char> pushdata2_trunc{OP_PUSHDATA2, 1, 0};
+    const std::vector<unsigned char> pushdata4_trunc{OP_PUSHDATA4, 1, 0, 0, 0};
+
+    std::vector<std::vector<unsigned char>> stack_ignore;
+    BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata1_trunc.begin(), pushdata1_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
+    BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
+    BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata2_trunc.begin(), pushdata2_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
+    BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
+    BOOST_CHECK(!EvalScript(stack_ignore, CScript(pushdata4_trunc.begin(), pushdata4_trunc.end()), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SigVersion::BASE, &err));
+    BOOST_CHECK_EQUAL(err, SCRIPT_ERR_BAD_OPCODE);
+}
+
+BOOST_AUTO_TEST_CASE(script_cltv_truncated)
+{
+    const auto script_cltv_trunc = CScript() << OP_CHECKLOCKTIMEVERIFY;
+
+    std::vector<std::vector<unsigned char>> stack_ignore;
+    ScriptError err;
+    BOOST_CHECK(!EvalScript(stack_ignore, script_cltv_trunc, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, BaseSignatureChecker(), SigVersion::BASE, &err));
+    BOOST_CHECK_EQUAL(err, SCRIPT_ERR_INVALID_STACK_OPERATION);
+}
+
+static CScript
+sign_multisig(const CScript& scriptPubKey, const std::vector<CKey>& keys, const CTransaction& transaction)
+{
+    uint256 hash = SignatureHash(scriptPubKey, transaction, 0, SIGHASH_ALL, 0, SigVersion::BASE);
+
+    CScript result;
+    //
+    // NOTE: CHECKMULTISIG has an unfortunate bug; it requires
+    // one extra item on the stack, before the signatures.
+    // Putting OP_0 on the stack is the workaround;
+    // fixing the bug would mean splitting the block chain (old
+    // clients would not accept new CHECKMULTISIG transactions,
+    // and vice-versa)
+    //
+    result << OP_0;
+    for (const CKey &key : keys)
+    {
+        std::vector<unsigned char> vchSig;
+        BOOST_CHECK(key.Sign(hash, vchSig));
+        vchSig.push_back((unsigned char)SIGHASH_ALL);
+        result << vchSig;
+    }
+    return result;
+}
+static CScript
+sign_multisig(const CScript& scriptPubKey, const CKey& key, const CTransaction& transaction)
+{
+    std::vector<CKey> keys;
+    keys.push_back(key);
+    return sign_multisig(scriptPubKey, keys, transaction);
+}
+
+BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12)
+{
+    ScriptError err;
+    CKey key1, key2, key3;
+    key1.MakeNewKey(true);
+    key2.MakeNewKey(false);
+    key3.MakeNewKey(true);
+
+    CScript scriptPubKey12;
+    scriptPubKey12 << OP_1 << ToByteVector(key1.GetPubKey()) << ToByteVector(key2.GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
+
+    const CTransaction txFrom12{BuildCreditingTransaction(scriptPubKey12)};
+    CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom12);
+
+    CScript goodsig1 = sign_multisig(scriptPubKey12, key1, CTransaction(txTo12));
+    BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+    txTo12.vout[0].nValue = 2;
+    BOOST_CHECK(!VerifyScript(goodsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
+
+    CScript goodsig2 = sign_multisig(scriptPubKey12, key2, CTransaction(txTo12));
+    BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+
+    CScript badsig1 = sign_multisig(scriptPubKey12, key3, CTransaction(txTo12));
+    BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey12, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
+}
+
+BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23)
+{
+    ScriptError err;
+    CKey key1, key2, key3, key4;
+    key1.MakeNewKey(true);
+    key2.MakeNewKey(false);
+    key3.MakeNewKey(true);
+    key4.MakeNewKey(false);
+
+    CScript scriptPubKey23;
+    scriptPubKey23 << OP_2 << ToByteVector(key1.GetPubKey()) << ToByteVector(key2.GetPubKey()) << ToByteVector(key3.GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
+
+    const CTransaction txFrom23{BuildCreditingTransaction(scriptPubKey23)};
+    CMutableTransaction txTo23 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom23);
+
+    std::vector<CKey> keys;
+    keys.push_back(key1); keys.push_back(key2);
+    CScript goodsig1 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
+    BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+
+    keys.clear();
+    keys.push_back(key1); keys.push_back(key3);
+    CScript goodsig2 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
+    BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+
+    keys.clear();
+    keys.push_back(key2); keys.push_back(key3);
+    CScript goodsig3 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
+    BOOST_CHECK(VerifyScript(goodsig3, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+
+    keys.clear();
+    keys.push_back(key2); keys.push_back(key2); // Can't re-use sig
+    CScript badsig1 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
+    BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
+
+    keys.clear();
+    keys.push_back(key2); keys.push_back(key1); // sigs must be in correct order
+    CScript badsig2 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
+    BOOST_CHECK(!VerifyScript(badsig2, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
+
+    keys.clear();
+    keys.push_back(key3); keys.push_back(key2); // sigs must be in correct order
+    CScript badsig3 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
+    BOOST_CHECK(!VerifyScript(badsig3, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
+
+    keys.clear();
+    keys.push_back(key4); keys.push_back(key2); // sigs must match pubkeys
+    CScript badsig4 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
+    BOOST_CHECK(!VerifyScript(badsig4, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
+
+    keys.clear();
+    keys.push_back(key1); keys.push_back(key4); // sigs must match pubkeys
+    CScript badsig5 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
+    BOOST_CHECK(!VerifyScript(badsig5, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
+
+    keys.clear(); // Must have signatures
+    CScript badsig6 = sign_multisig(scriptPubKey23, keys, CTransaction(txTo23));
+    BOOST_CHECK(!VerifyScript(badsig6, scriptPubKey23, nullptr, gFlags, MutableTransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, ScriptErrorString(err));
+}
+
+/* Wrapper around ProduceSignature to combine two scriptsigs */
+SignatureData CombineSignatures(const CTxOut& txout, const CMutableTransaction& tx, const SignatureData& scriptSig1, const SignatureData& scriptSig2)
+{
+    SignatureData data;
+    data.MergeSignatureData(scriptSig1);
+    data.MergeSignatureData(scriptSig2);
+    ProduceSignature(DUMMY_SIGNING_PROVIDER, MutableTransactionSignatureCreator(&tx, 0, txout.nValue), txout.scriptPubKey, data);
+    return data;
+}
+
+BOOST_AUTO_TEST_CASE(script_combineSigs)
+{
+    // Test the ProduceSignature's ability to combine signatures function
+    FillableSigningProvider keystore;
+    std::vector<CKey> keys;
+    std::vector<CPubKey> pubkeys;
+    for (int i = 0; i < 3; i++)
+    {
+        CKey key;
+        key.MakeNewKey(i%2 == 1);
+        keys.push_back(key);
+        pubkeys.push_back(key.GetPubKey());
+        BOOST_CHECK(keystore.AddKey(key));
+    }
+
+    CMutableTransaction txFrom = BuildCreditingTransaction(GetScriptForDestination(PKHash(keys[0].GetPubKey())));
+    CMutableTransaction txTo = BuildSpendingTransaction(CScript(), CScriptWitness(), CTransaction(txFrom));
+    CScript& scriptPubKey = txFrom.vout[0].scriptPubKey;
+    SignatureData scriptSig;
+
+    SignatureData empty;
+    SignatureData combined = CombineSignatures(txFrom.vout[0], txTo, empty, empty);
+    BOOST_CHECK(combined.scriptSig.empty());
+
+    // Single signature case:
+    BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL)); // changes scriptSig
+    scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
+    combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
+    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
+    combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
+    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
+    SignatureData scriptSigCopy = scriptSig;
+    // Signing again will give a different, valid signature:
+    BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL));
+    scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
+    combined = CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
+    BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig || combined.scriptSig == scriptSig.scriptSig);
+
+    // P2SH, single-signature case:
+    CScript pkSingle; pkSingle << ToByteVector(keys[0].GetPubKey()) << OP_CHECKSIG;
+    BOOST_CHECK(keystore.AddCScript(pkSingle));
+    scriptPubKey = GetScriptForDestination(ScriptHash(pkSingle));
+    BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL));
+    scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
+    combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
+    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
+    combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
+    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
+    scriptSigCopy = scriptSig;
+    BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL));
+    scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
+    combined = CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
+    BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig || combined.scriptSig == scriptSig.scriptSig);
+
+    // Hardest case:  Multisig 2-of-3
+    scriptPubKey = GetScriptForMultisig(2, pubkeys);
+    BOOST_CHECK(keystore.AddCScript(scriptPubKey));
+    BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL));
+    scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
+    combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
+    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
+    combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
+    BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
+
+    // A couple of partially-signed versions:
+    std::vector<unsigned char> sig1;
+    uint256 hash1 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_ALL, 0, SigVersion::BASE);
+    BOOST_CHECK(keys[0].Sign(hash1, sig1));
+    sig1.push_back(SIGHASH_ALL);
+    std::vector<unsigned char> sig2;
+    uint256 hash2 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_NONE, 0, SigVersion::BASE);
+    BOOST_CHECK(keys[1].Sign(hash2, sig2));
+    sig2.push_back(SIGHASH_NONE);
+    std::vector<unsigned char> sig3;
+    uint256 hash3 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_SINGLE, 0, SigVersion::BASE);
+    BOOST_CHECK(keys[2].Sign(hash3, sig3));
+    sig3.push_back(SIGHASH_SINGLE);
+
+    // Not fussy about order (or even existence) of placeholders or signatures:
+    CScript partial1a = CScript() << OP_0 << sig1 << OP_0;
+    CScript partial1b = CScript() << OP_0 << OP_0 << sig1;
+    CScript partial2a = CScript() << OP_0 << sig2;
+    CScript partial2b = CScript() << sig2 << OP_0;
+    CScript partial3a = CScript() << sig3;
+    CScript partial3b = CScript() << OP_0 << OP_0 << sig3;
+    CScript partial3c = CScript() << OP_0 << sig3 << OP_0;
+    CScript complete12 = CScript() << OP_0 << sig1 << sig2;
+    CScript complete13 = CScript() << OP_0 << sig1 << sig3;
+    CScript complete23 = CScript() << OP_0 << sig2 << sig3;
+    SignatureData partial1_sigs;
+    partial1_sigs.signatures.emplace(keys[0].GetPubKey().GetID(), SigPair(keys[0].GetPubKey(), sig1));
+    SignatureData partial2_sigs;
+    partial2_sigs.signatures.emplace(keys[1].GetPubKey().GetID(), SigPair(keys[1].GetPubKey(), sig2));
+    SignatureData partial3_sigs;
+    partial3_sigs.signatures.emplace(keys[2].GetPubKey().GetID(), SigPair(keys[2].GetPubKey(), sig3));
+
+    combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial1_sigs);
+    BOOST_CHECK(combined.scriptSig == partial1a);
+    combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
+    BOOST_CHECK(combined.scriptSig == complete12);
+    combined = CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial1_sigs);
+    BOOST_CHECK(combined.scriptSig == complete12);
+    combined = CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
+    BOOST_CHECK(combined.scriptSig == complete12);
+    combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial1_sigs);
+    BOOST_CHECK(combined.scriptSig == complete13);
+    combined = CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial3_sigs);
+    BOOST_CHECK(combined.scriptSig == complete23);
+    combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial2_sigs);
+    BOOST_CHECK(combined.scriptSig == complete23);
+    combined = CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial3_sigs);
+    BOOST_CHECK(combined.scriptSig == partial3c);
+}
+
+BOOST_AUTO_TEST_CASE(script_standard_push)
+{
+    ScriptError err;
+    for (int i=0; i<67000; i++) {
+        CScript script;
+        script << i;
+        BOOST_CHECK_MESSAGE(script.IsPushOnly(), "Number " << i << " is not pure push.");
+        BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1, nullptr, SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err), "Number " << i << " push is not minimal data.");
+        BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+    }
+
+    for (unsigned int i=0; i<=MAX_SCRIPT_ELEMENT_SIZE; i++) {
+        std::vector<unsigned char> data(i, '\111');
+        CScript script;
+        script << data;
+        BOOST_CHECK_MESSAGE(script.IsPushOnly(), "Length " << i << " is not pure push.");
+        BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1, nullptr, SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err), "Length " << i << " push is not minimal data.");
+        BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts)
+{
+    // IsPushOnly returns false when given a script containing only pushes that
+    // are invalid due to truncation. IsPushOnly() is consensus critical
+    // because P2SH evaluation uses it, although this specific behavior should
+    // not be consensus critical as the P2SH evaluation would fail first due to
+    // the invalid push. Still, it doesn't hurt to test it explicitly.
+    static const unsigned char direct[] = { 1 };
+    BOOST_CHECK(!CScript(direct, direct+sizeof(direct)).IsPushOnly());
+}
+
+BOOST_AUTO_TEST_CASE(script_GetScriptAsm)
+{
+    BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2, true));
+    BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY, true));
+    BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2));
+    BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY));
+
+    std::string derSig("304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c5090");
+    std::string pubKey("03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2");
+    std::vector<unsigned char> vchPubKey = ToByteVector(ParseHex(pubKey));
+
+    BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey, true));
+    BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey, true));
+    BOOST_CHECK_EQUAL(derSig + "[ALL] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "01")) << vchPubKey, true));
+    BOOST_CHECK_EQUAL(derSig + "[NONE] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "02")) << vchPubKey, true));
+    BOOST_CHECK_EQUAL(derSig + "[SINGLE] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "03")) << vchPubKey, true));
+    BOOST_CHECK_EQUAL(derSig + "[ALL|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "81")) << vchPubKey, true));
+    BOOST_CHECK_EQUAL(derSig + "[NONE|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "82")) << vchPubKey, true));
+    BOOST_CHECK_EQUAL(derSig + "[SINGLE|ANYONECANPAY] " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "83")) << vchPubKey, true));
+
+    BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey));
+    BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey));
+    BOOST_CHECK_EQUAL(derSig + "01 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "01")) << vchPubKey));
+    BOOST_CHECK_EQUAL(derSig + "02 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "02")) << vchPubKey));
+    BOOST_CHECK_EQUAL(derSig + "03 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "03")) << vchPubKey));
+    BOOST_CHECK_EQUAL(derSig + "81 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "81")) << vchPubKey));
+    BOOST_CHECK_EQUAL(derSig + "82 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "82")) << vchPubKey));
+    BOOST_CHECK_EQUAL(derSig + "83 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "83")) << vchPubKey));
+}
+
+static CScript
+ScriptFromHex(const char* hex)
+{
+    std::vector<unsigned char> data = ParseHex(hex);
+    return CScript(data.begin(), data.end());
+}
+
+
+BOOST_AUTO_TEST_CASE(script_FindAndDelete)
+{
+    // Exercise the FindAndDelete functionality
+    CScript s;
+    CScript d;
+    CScript expect;
+
+    s = CScript() << OP_1 << OP_2;
+    d = CScript(); // delete nothing should be a no-op
+    expect = s;
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
+    BOOST_CHECK(s == expect);
+
+    s = CScript() << OP_1 << OP_2 << OP_3;
+    d = CScript() << OP_2;
+    expect = CScript() << OP_1 << OP_3;
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
+    BOOST_CHECK(s == expect);
+
+    s = CScript() << OP_3 << OP_1 << OP_3 << OP_3 << OP_4 << OP_3;
+    d = CScript() << OP_3;
+    expect = CScript() << OP_1 << OP_4;
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 4);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("0302ff03"); // PUSH 0x02ff03 onto stack
+    d = ScriptFromHex("0302ff03");
+    expect = CScript();
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("0302ff030302ff03"); // PUSH 0x2ff03 PUSH 0x2ff03
+    d = ScriptFromHex("0302ff03");
+    expect = CScript();
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("0302ff030302ff03");
+    d = ScriptFromHex("02");
+    expect = s; // FindAndDelete matches entire opcodes
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("0302ff030302ff03");
+    d = ScriptFromHex("ff");
+    expect = s;
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
+    BOOST_CHECK(s == expect);
+
+    // This is an odd edge case: strip of the push-three-bytes
+    // prefix, leaving 02ff03 which is push-two-bytes:
+    s = ScriptFromHex("0302ff030302ff03");
+    d = ScriptFromHex("03");
+    expect = CScript() << ParseHex("ff03") << ParseHex("ff03");
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
+    BOOST_CHECK(s == expect);
+
+    // Byte sequence that spans multiple opcodes:
+    s = ScriptFromHex("02feed5169"); // PUSH(0xfeed) OP_1 OP_VERIFY
+    d = ScriptFromHex("feed51");
+    expect = s;
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0); // doesn't match 'inside' opcodes
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("02feed5169"); // PUSH(0xfeed) OP_1 OP_VERIFY
+    d = ScriptFromHex("02feed51");
+    expect = ScriptFromHex("69");
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("516902feed5169");
+    d = ScriptFromHex("feed51");
+    expect = s;
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("516902feed5169");
+    d = ScriptFromHex("02feed51");
+    expect = ScriptFromHex("516969");
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
+    BOOST_CHECK(s == expect);
+
+    s = CScript() << OP_0 << OP_0 << OP_1 << OP_1;
+    d = CScript() << OP_0 << OP_1;
+    expect = CScript() << OP_0 << OP_1; // FindAndDelete is single-pass
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
+    BOOST_CHECK(s == expect);
+
+    s = CScript() << OP_0 << OP_0 << OP_1 << OP_0 << OP_1 << OP_1;
+    d = CScript() << OP_0 << OP_1;
+    expect = CScript() << OP_0 << OP_1; // FindAndDelete is single-pass
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
+    BOOST_CHECK(s == expect);
+
+    // Another weird edge case:
+    // End with invalid push (not enough data)...
+    s = ScriptFromHex("0003feed");
+    d = ScriptFromHex("03feed"); // ... can remove the invalid push
+    expect = ScriptFromHex("00");
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("0003feed");
+    d = ScriptFromHex("00");
+    expect = ScriptFromHex("03feed");
+    BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
+    BOOST_CHECK(s == expect);
+}
+
+BOOST_AUTO_TEST_CASE(script_HasValidOps)
+{
+    // Exercise the HasValidOps functionality
+    CScript script;
+    script = ScriptFromHex("76a9141234567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac"); // Normal script
+    BOOST_CHECK(script.HasValidOps());
+    script = ScriptFromHex("76a914ff34567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac");
+    BOOST_CHECK(script.HasValidOps());
+    script = ScriptFromHex("ff88ac"); // Script with OP_INVALIDOPCODE explicit
+    BOOST_CHECK(!script.HasValidOps());
+    script = ScriptFromHex("88acc0"); // Script with undefined opcode
+    BOOST_CHECK(!script.HasValidOps());
+}
+
+BOOST_AUTO_TEST_CASE(script_can_append_self)
+{
+    CScript s, d;
+
+    s = ScriptFromHex("00");
+    s += s;
+    d = ScriptFromHex("0000");
+    BOOST_CHECK(s == d);
+
+    // check doubling a script that's large enough to require reallocation
+    static const char hex[] = "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f";
+    s = CScript() << ParseHex(hex) << OP_CHECKSIG;
+    d = CScript() << ParseHex(hex) << OP_CHECKSIG << ParseHex(hex) << OP_CHECKSIG;
+    s += s;
+    BOOST_CHECK(s == d);
+}
+
+
+#if defined(HAVE_CONSENSUS_LIB)
+
+/* Test simple (successful) usage of bitcoinconsensus_verify_script */
+BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_returns_true)
+{
+    unsigned int libconsensus_flags = 0;
+    int nIn = 0;
+
+    CScript scriptPubKey;
+    CScript scriptSig;
+    CScriptWitness wit;
+
+    scriptPubKey << OP_1;
+    CTransaction creditTx = BuildCreditingTransaction(scriptPubKey, 1);
+    CTransaction spendTx = BuildSpendingTransaction(scriptSig, wit, creditTx);
+
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << spendTx;
+
+    bitcoinconsensus_error err;
+    int result = bitcoinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), nIn, libconsensus_flags, &err);
+    BOOST_CHECK_EQUAL(result, 1);
+    BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_OK);
+}
+
+/* Test bitcoinconsensus_verify_script returns invalid tx index err*/
+BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_tx_index_err)
+{
+    unsigned int libconsensus_flags = 0;
+    int nIn = 3;
+
+    CScript scriptPubKey;
+    CScript scriptSig;
+    CScriptWitness wit;
+
+    scriptPubKey << OP_EQUAL;
+    CTransaction creditTx = BuildCreditingTransaction(scriptPubKey, 1);
+    CTransaction spendTx = BuildSpendingTransaction(scriptSig, wit, creditTx);
+
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << spendTx;
+
+    bitcoinconsensus_error err;
+    int result = bitcoinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), nIn, libconsensus_flags, &err);
+    BOOST_CHECK_EQUAL(result, 0);
+    BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_TX_INDEX);
+}
+
+/* Test bitcoinconsensus_verify_script returns tx size mismatch err*/
+BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_tx_size)
+{
+    unsigned int libconsensus_flags = 0;
+    int nIn = 0;
+
+    CScript scriptPubKey;
+    CScript scriptSig;
+    CScriptWitness wit;
+
+    scriptPubKey << OP_EQUAL;
+    CTransaction creditTx = BuildCreditingTransaction(scriptPubKey, 1);
+    CTransaction spendTx = BuildSpendingTransaction(scriptSig, wit, creditTx);
+
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << spendTx;
+
+    bitcoinconsensus_error err;
+    int result = bitcoinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size() * 2, nIn, libconsensus_flags, &err);
+    BOOST_CHECK_EQUAL(result, 0);
+    BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_TX_SIZE_MISMATCH);
+}
+
+/* Test bitcoinconsensus_verify_script returns invalid tx serialization error */
+BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_tx_serialization)
+{
+    unsigned int libconsensus_flags = 0;
+    int nIn = 0;
+
+    CScript scriptPubKey;
+    CScript scriptSig;
+    CScriptWitness wit;
+
+    scriptPubKey << OP_EQUAL;
+    CTransaction creditTx = BuildCreditingTransaction(scriptPubKey, 1);
+    CTransaction spendTx = BuildSpendingTransaction(scriptSig, wit, creditTx);
+
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << 0xffffffff;
+
+    bitcoinconsensus_error err;
+    int result = bitcoinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), nIn, libconsensus_flags, &err);
+    BOOST_CHECK_EQUAL(result, 0);
+    BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_TX_DESERIALIZE);
+}
+
+/* Test bitcoinconsensus_verify_script returns amount required error */
+BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_amount_required_err)
+{
+    unsigned int libconsensus_flags = bitcoinconsensus_SCRIPT_FLAGS_VERIFY_WITNESS;
+    int nIn = 0;
+
+    CScript scriptPubKey;
+    CScript scriptSig;
+    CScriptWitness wit;
+
+    scriptPubKey << OP_EQUAL;
+    CTransaction creditTx = BuildCreditingTransaction(scriptPubKey, 1);
+    CTransaction spendTx = BuildSpendingTransaction(scriptSig, wit, creditTx);
+
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << spendTx;
+
+    bitcoinconsensus_error err;
+    int result = bitcoinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), nIn, libconsensus_flags, &err);
+    BOOST_CHECK_EQUAL(result, 0);
+    BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_AMOUNT_REQUIRED);
+}
+
+/* Test bitcoinconsensus_verify_script returns invalid flags err */
+BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_invalid_flags)
+{
+    unsigned int libconsensus_flags = 1 << 3;
+    int nIn = 0;
+
+    CScript scriptPubKey;
+    CScript scriptSig;
+    CScriptWitness wit;
+
+    scriptPubKey << OP_EQUAL;
+    CTransaction creditTx = BuildCreditingTransaction(scriptPubKey, 1);
+    CTransaction spendTx = BuildSpendingTransaction(scriptSig, wit, creditTx);
+
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << spendTx;
+
+    bitcoinconsensus_error err;
+    int result = bitcoinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), nIn, libconsensus_flags, &err);
+    BOOST_CHECK_EQUAL(result, 0);
+    BOOST_CHECK_EQUAL(err, bitcoinconsensus_ERR_INVALID_FLAGS);
+}
+
+#endif
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index d44000d8f..f24344cd8 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -1317,7 +1317,7 @@ BOOST_AUTO_TEST_CASE(script_claimScript)
     // Spend normal tx to make claim
     // Spend claim to update claim
     // Spend updated claim to abandon name
-    CBasicKeyStore keystore;
+    FillableSigningProvider keystore;
     std::vector<CKey> keys;
     std::vector<CPubKey> pubkeys;
     for (int i = 0; i < 4; i++)
@@ -1336,23 +1336,23 @@ BOOST_AUTO_TEST_CASE(script_claimScript)
     std::vector<unsigned char> vchName(sName.begin(), sName.end());
     std::vector<unsigned char> vchValue(sValue.begin(), sValue.end());
 
-    CMutableTransaction txOrig = BuildCreditingTransaction(GetScriptForDestination(keys[0].GetPubKey().GetID()));
+    CMutableTransaction txOrig = BuildCreditingTransaction(GetScriptForDestination(PKHash(keys[0].GetPubKey())));
 
-    CMutableTransaction txClaim0 = BuildSpendingTransaction(CScript(), wit, txOrig);
+    CMutableTransaction txClaim0 = BuildSpendingTransaction(CScript(), wit, CTransaction(txOrig));
     CScript txClaimOut0 = CScript() << OP_CLAIM_NAME << vchName << vchValue << OP_2DROP << OP_DROP;
-    txClaimOut0 = txClaimOut0 + GetScriptForDestination(keys[1].GetPubKey().GetID());
+    txClaimOut0 = txClaimOut0 + GetScriptForDestination(PKHash(keys[1].GetPubKey()));
     txClaim0.vout[0].scriptPubKey = txClaimOut0;
-    SignSignature(keystore, txOrig, txClaim0, 0, SIGHASH_ALL);
+    SignSignature(keystore, CTransaction(txOrig), txClaim0, 0, SIGHASH_ALL);
 
-    CMutableTransaction txClaim1 = BuildSpendingTransaction(CScript(), wit, txClaim0);
+    CMutableTransaction txClaim1 = BuildSpendingTransaction(CScript(), wit, CTransaction(txClaim0));
     CScript txClaimOut1 = CScript() << OP_CLAIM_NAME << vchName << vchValue << OP_2DROP << OP_DROP;
-    txClaimOut1 = txClaimOut1 + GetScriptForDestination(keys[2].GetPubKey().GetID());
+    txClaimOut1 = txClaimOut1 + GetScriptForDestination(PKHash(keys[2].GetPubKey()));
     txClaim1.vout[0].scriptPubKey = txClaimOut1;
-    SignSignature(keystore, txClaim0, txClaim1, 0, SIGHASH_ALL);
+    SignSignature(keystore, CTransaction(txClaim0), txClaim1, 0, SIGHASH_ALL);
 
-    CMutableTransaction txFinal = BuildSpendingTransaction(CScript(), wit, txClaim1);
-    txFinal.vout[0].scriptPubKey = GetScriptForDestination(keys[3].GetPubKey().GetID());
-    SignSignature(keystore, txClaim1, txFinal, 0, SIGHASH_ALL);
+    CMutableTransaction txFinal = BuildSpendingTransaction(CScript(), wit, CTransaction(txClaim1));
+    txFinal.vout[0].scriptPubKey = GetScriptForDestination(PKHash(keys[3].GetPubKey()));
+    SignSignature(keystore, CTransaction(txClaim1), txFinal, 0, SIGHASH_ALL);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_push)
diff --git a/src/test/serialize_tests.cpp b/src/test/serialize_tests.cpp
index b90be15fb..cdc809557 100644
--- a/src/test/serialize_tests.cpp
+++ b/src/test/serialize_tests.cpp
@@ -5,6 +5,7 @@
 #include <serialize.h>
 #include <streams.h>
 #include <hash.h>
+#include <primitives/transaction.h>
 #include <test/setup_common.h>
 #include <util/strencodings.h>
 
diff --git a/src/test/setup_common.cpp b/src/test/setup_common.cpp
index c53acdacf..036e506db 100644
--- a/src/test/setup_common.cpp
+++ b/src/test/setup_common.cpp
@@ -16,6 +16,7 @@
 #include <miner.h>
 #include <net.h>
 #include <noui.h>
+#include <policy/policy.h>
 #include <pow.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
@@ -31,9 +32,6 @@
 #include <validationinterface.h>
 
 #include <functional>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/unit_test_parameters.hpp>
-
 
 const std::function<std::string(const char*)> G_TRANSLATION_FUN = nullptr;
 
diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp
index a32f2cda9..26cd037cb 100644
--- a/src/test/sigopcount_tests.cpp
+++ b/src/test/sigopcount_tests.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <coins.h>
 #include <consensus/consensus.h>
 #include <consensus/tx_verify.h>
 #include <pubkey.h>
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 4f0adca03..05f78b929 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -23,8 +23,8 @@ static const sqlite::sqlite_config sharedConfig {
         nullptr, sqlite::Encoding::UTF8
 };
 
-CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe)
-    : db(fMemory ? ":memory:" : (GetDataDir() / "coins.sqlite").string(), sharedConfig)
+CCoinsViewDB::CCoinsViewDB(fs::path ldb_path, size_t nCacheSize, bool fMemory, bool fWipe)
+    : db(fMemory ? ":memory:" : (ldb_path / "coins.sqlite").string(), sharedConfig)
 {
     db << "PRAGMA cache_size=-" + std::to_string(nCacheSize >> 10); // in -KB
     db << "PRAGMA synchronous=OFF"; // don't disk sync after transaction commit
@@ -62,9 +62,7 @@ bool CCoinsViewDB::GetCoin(const COutPoint &outpoint, Coin &coin) const {
 bool CCoinsViewDB::HaveCoin(const COutPoint &outpoint) const {
     auto query = db << "SELECT 1 FROM coin "
                        "WHERE txID = ? and txN = ?" << outpoint.hash << outpoint.n;
-    for (auto&& row: query)
-        return true;
-    return false;
+    return query.begin() != query.end();
 }
 
 uint256 CCoinsViewDB::GetBestBlock() const {
@@ -380,12 +378,13 @@ bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams,
     return true;
 }
 
-bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos>> &list) {
-    if (list.empty()) return true;
+bool CBlockTreeDB::WriteTxIndex(const FlatFilePos& file, const std::vector<std::pair<uint256, uint32_t>>& txOffsets)
+{
+    if (txOffsets.empty()) return true;
     db << "begin";
     auto query = db << "INSERT OR REPLACE INTO tx_to_block VALUES(?,?,?,?)";
-    for (auto& kvp: list) {
-        query << kvp.first << kvp.second.nFile << kvp.second.nPos << kvp.second.nTxOffset;
+    for (auto& kvp: txOffsets) {
+        query << kvp.first << file.nFile << file.nPos << kvp.second;
         query++;
     }
     query.used(true);
@@ -397,10 +396,11 @@ bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos>
     return true;
 }
 
-bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
+bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, FlatFilePos &file, uint32_t& offset)
+{
     auto query = db << "SELECT file, blockPos, txPos FROM tx_to_block WHERE txID = ?" << txid;
     for (auto&& row: query) {
-        row >> pos.nFile >> pos.nPos >> pos.nTxOffset;
+        row >> file.nFile >> file.nPos >> offset;
         return true;
     }
     return false;
diff --git a/src/txdb.h b/src/txdb.h
index b57d4d01d..94cdab58f 100644
--- a/src/txdb.h
+++ b/src/txdb.h
@@ -8,6 +8,7 @@
 
 #include <coins.h>
 #include <chain.h>
+#include <flatfile.h>
 #include <primitives/block.h>
 
 #include <map>
@@ -64,32 +65,6 @@ static const int64_t max_filter_index_cache = 1024;
 //! Max memory allocated to coin DB specific cache (MiB)
 static const int64_t nMaxCoinsDBCache = 40;
 
-
-struct CDiskTxPos : public CDiskBlockPos
-{
-    unsigned int nTxOffset; // after header
-
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITEAS(CDiskBlockPos, *this);
-        READWRITE(VARINT(nTxOffset));
-    }
-
-    CDiskTxPos(const CDiskBlockPos &blockIn, unsigned int nTxOffsetIn) : CDiskBlockPos(blockIn.nFile, blockIn.nPos), nTxOffset(nTxOffsetIn) {
-    }
-
-    CDiskTxPos() {
-        SetNull();
-    }
-
-    void SetNull() {
-        CDiskBlockPos::SetNull();
-        nTxOffset = 0;
-    }
-};
-
 /** CCoinsView backed by the coin database (chainstate/) */
 class CCoinsViewDB final : public CCoinsView
 {
@@ -145,10 +120,10 @@ public:
     bool ReadLastBlockFile(int &nFile);
     bool WriteReindexing(bool fReindexing);
     void ReadReindexing(bool &fReindexing);
-    bool ReadTxIndex(const uint256 &txid, CDiskTxPos &pos);
-    bool WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos>> &list);
     bool WriteFlag(const std::string &name, bool fValue);
     bool ReadFlag(const std::string &name, bool &fValue);
+    bool ReadTxIndex(const uint256 &txid, FlatFilePos &file, uint32_t& offset);
+    bool WriteTxIndex(const FlatFilePos& file, const std::vector<std::pair<uint256, uint32_t>>& txOffsets);
     bool LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex);
 };
 
diff --git a/src/undo.h b/src/undo.h
index a1c0b3840..1451c5b8e 100644
--- a/src/undo.h
+++ b/src/undo.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2014 The Bitcoin Core developers
+// Copyright (c) 2009-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.
 
@@ -8,65 +8,96 @@
 
 #include <coins.h>
 #include <compressor.h>
+#include <consensus/consensus.h>
 #include <primitives/transaction.h>
 #include <serialize.h>
 #include <version.h>
 
 /** Undo information for a CTxIn
  *
- *  Contains the prevout's CTxOut being spent, and if this was the
- *  last output of the affected transaction, its metadata as well
- *  (coinbase or not, height, transaction version)
+ *  Contains the prevout's CTxOut being spent, and its metadata as well
+ *  (coinbase or not, height). The serialization contains a dummy value of
+ *  zero. This is compatible with older versions which expect to see
+ *  the transaction version there.
  */
-class CTxInUndo
+class TxInUndoSerializer
 {
-    uint32_t nDeprecated1 = 0;    // if the outpoint was the last unspent: its version
-    bool fDeprecated2 = false;    // whether the outpoint was the last unspent
+    const Coin* txout;
+
 public:
-    CTxOut txout;         // the txout data before being spent
-    bool fCoinBase;       // if the outpoint was the last unspent: whether it belonged to a coinbase
-    uint32_t nHeight; // if the outpoint was the last unspent: its height
-    uint32_t nClaimValidHeight;   // If the outpoint was a claim or support, the height at which the claim or support should be inserted into the trie
-    bool fIsClaim;        // if the outpoint was a claim or support
-
-    CTxInUndo() : txout(), fCoinBase(false), nHeight(0), nClaimValidHeight(0), fIsClaim(false) {}
-    CTxInUndo(const CTxOut &txoutIn, bool fCoinBaseIn = false, uint32_t nHeightIn = 0) :
-        txout(txoutIn), fCoinBase(fCoinBaseIn), nHeight(nHeightIn), nClaimValidHeight(0), fIsClaim(false) {}
-
-    ADD_SERIALIZE_METHODS;
-
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        if (ser_action.ForRead()) {
-            uint32_t nCode = 0;
-            READWRITE(VARINT(nCode)); // VARINT in this method is for legacy compatibility
-            nHeight = nCode >> 2U;
-            fCoinBase = nCode & 2U;
-            fDeprecated2 = nCode & 1U;
-        } else {
-            uint32_t nCode = (nHeight << 2U) | (fCoinBase ? 2U : 0U) | (fDeprecated2 ? 1U: 0U);
-            READWRITE(VARINT(nCode));
+    template<typename Stream>
+    void Serialize(Stream &s) const {
+        ::Serialize(s, VARINT(txout->nHeight * 2 + (txout->fCoinBase ? 1u : 0u)));
+        if (txout->nHeight > 0) {
+            // Required to maintain compatibility with older undo format.
+            ::Serialize(s, (unsigned char)0);
         }
-        if (fDeprecated2)
-            READWRITE(VARINT(nDeprecated1));
-        READWRITE(REF(CTxOutCompressor(REF(txout))));
-        READWRITE(VARINT(nClaimValidHeight));
-        READWRITE(fIsClaim);
+        ::Serialize(s, CTxOutCompressor(REF(txout->out)));
     }
+
+    explicit TxInUndoSerializer(const Coin* coin) : txout(coin) {}
 };
 
+class TxInUndoDeserializer
+{
+    Coin* txout;
+
+public:
+    template<typename Stream>
+    void Unserialize(Stream &s) {
+        unsigned int nCode = 0;
+        ::Unserialize(s, VARINT(nCode));
+        txout->nHeight = nCode / 2;
+        txout->fCoinBase = nCode & 1;
+        if (txout->nHeight > 0) {
+            // 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;
+            ::Unserialize(s, VARINT(nVersionDummy));
+        }
+        ::Unserialize(s, CTxOutCompressor(REF(txout->out)));
+    }
+
+    explicit TxInUndoDeserializer(Coin* coin) : txout(coin) {}
+};
+
+static const size_t MIN_TRANSACTION_INPUT_WEIGHT = WITNESS_SCALE_FACTOR * ::GetSerializeSize(CTxIn(), PROTOCOL_VERSION);
+static const size_t MAX_INPUTS_PER_BLOCK = MAX_BLOCK_WEIGHT / MIN_TRANSACTION_INPUT_WEIGHT;
+
 /** Undo information for a CTransaction */
 class CTxUndo
 {
 public:
     // undo information for all txins
-    std::vector<CTxInUndo> vprevout;
+    std::vector<Coin> vprevout;
+    // tx index to claim valid height
+    std::map<int, int> claimHeights;
 
-    ADD_SERIALIZE_METHODS;
+    template <typename Stream>
+    void Serialize(Stream& s) const {
+        // TODO: avoid reimplementing vector serializer
+        uint64_t count = vprevout.size();
+        ::Serialize(s, COMPACTSIZE(REF(count)));
+        for (const auto& prevout : vprevout) {
+            ::Serialize(s, TxInUndoSerializer(&prevout));
+        }
+        ::Serialize(s, claimHeights);
+    }
 
-    template <typename Stream, typename Operation>
-    inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(vprevout);
+    template <typename Stream>
+    void Unserialize(Stream& s) {
+        // TODO: avoid reimplementing vector deserializer
+        uint64_t count = 0;
+        ::Unserialize(s, COMPACTSIZE(count));
+        if (count > MAX_INPUTS_PER_BLOCK) {
+            throw std::ios_base::failure("Too many input undo records");
+        }
+        vprevout.resize(count);
+        for (auto& prevout : vprevout) {
+            ::Unserialize(s, TxInUndoDeserializer(&prevout));
+        }
+        ::Unserialize(s, claimHeights);
     }
 };
 
diff --git a/src/validation.cpp b/src/validation.cpp
index c73192543..a7bfc4831 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1090,15 +1090,16 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
     return AcceptToMemoryPoolWithTime(chainparams, pool, state, tx, pfMissingInputs, GetTime(), plTxnReplaced, bypass_limits, nAbsurdFee, test_accept);
 }
 
-bool FillTx(const uint256& tx_hash, const CDiskTxPos& postx, uint256& block_hash, CTransactionRef& tx) {
-    CAutoFile file(OpenBlockFile(postx, true), SER_DISK, CLIENT_VERSION);
+bool FillTx(const uint256& tx_hash, const FlatFilePos& pos, uint32_t offset, uint256& block_hash, CTransactionRef& tx)
+{
+    CAutoFile file(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
     if (file.IsNull()) {
         return error("%s: OpenBlockFile failed", __func__);
     }
     CBlockHeader header;
     try {
         file >> header;
-        if (fseek(file.Get(), postx.nTxOffset, SEEK_CUR)) {
+        if (fseek(file.Get(), offset, SEEK_CUR)) {
             return error("%s: fseek(...) failed", __func__);
         }
         file >> tx;
@@ -1120,15 +1121,16 @@ bool GetTransaction(const uint256& hash, CTransactionRef& txOut, const Consensus
 {
     LOCK(cs_main);
 
-    if (!block_index) {
+    if (!blockIndex) {
         CTransactionRef ptx = mempool.get(hash);
         if (ptx) {
             txOut = ptx;
             return true;
         }
         if (pblocktree) {
-            CDiskTxPos pos;
-            if (pblocktree->ReadTxIndex(hash, pos) && FillTx(hash, pos, hashBlock, ptx)) {
+            uint32_t offset;
+            FlatFilePos pos;
+            if (pblocktree->ReadTxIndex(hash, pos, offset) && FillTx(hash, pos, offset, hashBlock, ptx)) {
                 txOut = ptx;
                 return true;
             }
@@ -1139,7 +1141,7 @@ bool GetTransaction(const uint256& hash, CTransactionRef& txOut, const Consensus
             for (const auto& tx : block.vtx) {
                 if (tx->GetHash() == hash) {
                     txOut = tx;
-                    hashBlock = block_index->GetBlockHash();
+                    hashBlock = blockIndex->GetBlockHash();
                     return true;
                 }
             }
@@ -1149,11 +1151,6 @@ bool GetTransaction(const uint256& hash, CTransactionRef& txOut, const Consensus
     return false;
 }
 
-
-
-
-
-
 //////////////////////////////////////////////////////////////////////////////
 //
 // CBlock and CBlockIndex
@@ -1750,19 +1747,20 @@ int ApplyTxInUndo(unsigned int index, CTxUndo& txUndo, CCoinsViewCache& view, CC
         }
     }
 
-    // restore claim if applicable
-    if (undo.fIsClaim && !undo.txout.scriptPubKey.empty()) {
-        auto nValidHeight = undo.nClaimValidHeight;
-        CClaimScriptUndoSpendOp undoSpend(COutPoint(out.hash, out.n), undo.txout.nValue, undo.nHeight, nValidHeight);
-        ProcessClaim(undoSpend, trieCache, undo.txout.scriptPubKey);
+    if (!undo.out.scriptPubKey.empty()) {
+        auto it = txUndo.claimHeights.find(index);
+        // restore claim if applicable
+        if (it != txUndo.claimHeights.end()) {
+            CClaimScriptUndoSpendOp undoSpend(out, undo.out.nValue, undo.nHeight, it->second);
+            ProcessClaim(undoSpend, trieCache, undo.out.scriptPubKey);
+        }
     }
 
     // The potential_overwrite parameter to AddCoin is only allowed to be false if we know for
     // sure that the coin did not already exist in the cache. As we have queried for that above
     // using HaveCoin, we don't need to guess. When fClean is false, a coin already existed and
     // it is an overwrite.
-    Coin coin(undo.txout, int(undo.nHeight), undo.fCoinBase);
-    view.AddCoin(out, std::move(coin), !fClean);
+    view.AddCoin(out, std::move(undo), !fClean);
 
     return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;
 }
@@ -2213,9 +2211,9 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
     CAmount nFees = 0;
     int nInputs = 0;
     int64_t nSigOpsCost = 0;
-    CDiskTxPos pos(pindex->GetBlockPos(), GetSizeOfCompactSize(block.vtx.size()));
-    std::vector<std::pair<uint256, CDiskTxPos> > vPos;
-    vPos.reserve(block.vtx.size());
+    std::vector<std::pair<uint256, uint32_t>> txOffsets;
+    uint32_t offset = ::GetSizeOfCompactSize(block.vtx.size());
+    txOffsets.reserve(block.vtx.size());
     blockundo.vtxundo.reserve(block.vtx.size() - 1);
     std::vector<PrecomputedTransactionData> txdata;
     txdata.reserve(block.vtx.size()); // Required so that pointers to individual PrecomputedTransactionData don't get invalidated
@@ -2303,14 +2301,10 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
             blockundo.vtxundo.push_back(CTxUndo());
         }
         UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight);
-        if (i > 0 && !mClaimUndoHeights.empty())
-        {
-            auto& txinUndos = blockundo.vtxundo.back().vprevout;
+        if (i > 0 && !mClaimUndoHeights.empty()) {
+            auto& claimsHeights = blockundo.vtxundo.back().claimHeights;
             for (auto itHeight = mClaimUndoHeights.begin(); itHeight != mClaimUndoHeights.end(); ++itHeight)
-            {
-                txinUndos[itHeight->first].nClaimValidHeight = itHeight->second;
-                txinUndos[itHeight->first].fIsClaim = true;
-            }
+                claimsHeights[itHeight->first] = itHeight->second;
         }
 
         // The CTxUndo vector contains the heights at which claims should be put into the trie.
@@ -2324,17 +2318,18 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
         // in. Some OP_UPDATE_CLAIM's, for example, may be invalid, and so may never have been
         // inserted into the trie in the first place.
 
-        vPos.push_back(std::make_pair(tx.GetHash(), pos));
-        pos.nTxOffset += ::GetSerializeSize(tx, SER_DISK, CLIENT_VERSION);
+        offset += ::GetSerializeSize(tx, CLIENT_VERSION);
+        txOffsets.push_back(std::make_pair(tx.GetHash(), offset));
     }
 
     // TODO: if the "just check" flag is set, we should reduce the work done here. Incrementing blocks twice per mine is not efficient.
     assert(trieCache.incrementBlock());
 
     if (trieCache.getMerkleHash() != block.hashClaimTrie) {
-        return state.DoS(100, error("ConnectBlock() : the merkle root of the claim trie does not match "
-                               "(actual=%s vs block=%s on height=%d)", trieCache.getMerkleHash().GetHex(),
-                               block.hashClaimTrie.GetHex(), pindex->nHeight), REJECT_INVALID, "bad-claim-merkle-hash");
+        return state.Invalid(ValidationInvalidReason::CLAIMTRIE_HASH,
+                error("ConnectBlock() : the merkle root of the claim trie does not match "
+                        "(actual=%s vs block=%s on height=%d)", trieCache.getMerkleHash().GetHex(),
+                        block.hashClaimTrie.GetHex(), pindex->nHeight), REJECT_INVALID, "bad-claim-merkle-hash");
     }
 
     int64_t nTime3 = GetTimeMicros(); nTimeConnect += nTime3 - nTime2;
@@ -2355,12 +2350,10 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
     if (fJustCheck)
         return true;
 
-    if (pindex->pprev != nullptr) {
-        if (!WriteUndoDataForBlock(blockundo, state, pindex, chainparams))
-            return error("Unable to write to the Undo data block");
-        if (!pblocktree->WriteTxIndex(vPos))
-            return error("Unable to write to the TX Index");
-    }
+    if (pindex->pprev && !WriteUndoDataForBlock(blockundo, state, pindex, chainparams))
+        return false;
+    if (!pblocktree->WriteTxIndex(pindex->GetBlockPos(), txOffsets))
+        return false;
 
     if (!pindex->IsValid(BLOCK_VALID_SCRIPTS)) {
         pindex->RaiseValidity(BLOCK_VALID_SCRIPTS);
@@ -2576,12 +2569,13 @@ void static UpdateTip(const CBlockIndex* pindexNew, const CChainParams& chainPar
     auto currentTime = GetAdjustedTime();
     if (!warningMessages.empty() || !isInitialBlockDownload || lastBlockPrintTime < currentTime - 15 || LogAcceptCategory(BCLog::CLAIMS)) {
         lastBlockPrintTime = currentTime;
+        auto& cache = ::ChainstateActive().CoinsTip();
         LogPrintf("%s: new best=%s height=%d version=0x%08x log2_work=%.8g txb=%lu tx=%lu date='%s' progress=%f cache=%.1fMiB(%utxo)%s",
                 __func__, pindexNew->GetBlockHash().ToString(), pindexNew->nHeight, pindexNew->nVersion,
                 std::log(pindexNew->nChainWork.getdouble()) / std::log(2.0), (unsigned long) pindexNew->nTx,
                 (unsigned long) pindexNew->nChainTx, FormatISO8601DateTime(pindexNew->GetBlockTime()),
                 GuessVerificationProgress(chainParams.TxData(), pindexNew),
-                pcoinsTip->DynamicMemoryUsage() * (1.0 / (1U << 20U)), pcoinsTip->GetCacheSize(),
+                cache.DynamicMemoryUsage() * (1.0 / (1U << 20U)), cache.GetCacheSize(),
                 isInitialBlockDownload ? " IBD" : "");
         if (!warningMessages.empty())
             LogPrintf(" warning='%s'", warningMessages); /* Continued */
diff --git a/src/validation.h b/src/validation.h
index c72075591..f169c4596 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -689,9 +689,8 @@ public:
     bool AcceptBlock(const std::shared_ptr<const CBlock>& pblock, CValidationState& state, const CChainParams& chainparams, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     // Block (dis)connection on a given view:
-    DisconnectResult DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view);
-    bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex,
-                      CCoinsViewCache& view, const CChainParams& chainparams, bool fJustCheck = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    DisconnectResult DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view, CClaimTrieCache& trieCache);
+    bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& view, CClaimTrieCache& trieCache, const CChainParams& chainparams, bool fJustCheck = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     // Apply the effects of a block disconnection on the UTXO set.
     bool DisconnectTip(CValidationState& state, const CChainParams& chainparams, DisconnectedBlockTransactions* disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, ::mempool.cs);
diff --git a/src/versionbits.cpp b/src/versionbits.cpp
index cf1cedc72..2285579cd 100644
--- a/src/versionbits.cpp
+++ b/src/versionbits.cpp
@@ -187,12 +187,6 @@ public:
 
 ThresholdState VersionBitsState(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos pos, VersionBitsCache& cache)
 {
-    // Check if we've past a hardfork state for segwit.
-    if (pos == Consensus::DEPLOYMENT_SEGWIT) {
-        return pindexPrev != nullptr && pindexPrev->nHeight + 1 >= params.nWitnessForkHeight ?
-            ThresholdState::ACTIVE : ThresholdState::FAILED;
-    }
-
     return VersionBitsConditionChecker(pos).GetStateFor(pindexPrev, params, cache.caches[pos]);
 }
 
diff --git a/src/wallet/db.cpp b/src/wallet/db.cpp
index ae647c4b0..ce67d7fb1 100644
--- a/src/wallet/db.cpp
+++ b/src/wallet/db.cpp
@@ -77,17 +77,6 @@ bool IsWalletLoaded(const fs::path& wallet_path)
     LOCK(cs_db);
     auto env = g_dbenvs.find(env_directory.string());
     if (env == g_dbenvs.end()) return false;
-    auto db = env->second.m_databases.find(database_filename);
-    return db != env->second.m_databases.end();
-}
-
-std::shared_ptr<BerkeleyEnvironment> GetWalletEnv(const fs::path& wallet_path, std::string& database_filename)
-{
-    fs::path env_directory;
-    SplitWalletPath(wallet_path, env_directory, database_filename);
-    LOCK(cs_db);
-    auto env = g_dbenvs.find(env_directory.string());
-    if (env == g_dbenvs.end()) return false;
     auto database = env->second.lock();
     return database && database->IsDatabaseLoaded(database_filename);
 }
@@ -619,7 +608,6 @@ void BerkeleyBatch::Flush()
     if (env && env->dbenv) { // env is nullptr for dummy databases (i.e. in tests). Don't actually flush if env is nullptr so we don't segfault
         env->dbenv->txn_checkpoint(nMinutes ? gArgs.GetArg("-dblogsize", DEFAULT_WALLET_DBLOGSIZE) * 1024 : 0, nMinutes, 0);
     }
-    }
 }
 
 void BerkeleyDatabase::IncrementUpdateCounter()
@@ -687,32 +675,6 @@ void BerkeleyEnvironment::ReloadDbEnv()
     Open(true);
 }
 
-void BerkeleyEnvironment::ReloadDbEnv()
-{
-    // Make sure that no Db's are in use
-    AssertLockNotHeld(cs_db);
-    std::unique_lock<CCriticalSection> lock(cs_db);
-    m_db_in_use.wait(lock, [this](){
-        for (auto& count : mapFileUseCount) {
-            if (count.second > 0) return false;
-        }
-        return true;
-    });
-
-    std::vector<std::string> filenames;
-    for (auto it : mapDb) {
-        filenames.push_back(it.first);
-    }
-    // Close the individual Db's
-    for (const std::string& filename : filenames) {
-        CloseDb(filename);
-    }
-    // Reset the environment
-    Flush(true); // This will flush and close the environment
-    Reset();
-    Open(true);
-}
-
 bool BerkeleyBatch::Rewrite(BerkeleyDatabase& database, const char* pszSkip)
 {
     if (database.IsDummy()) {
diff --git a/src/wallet/db.h b/src/wallet/db.h
index c983c1934..94f41eaf1 100644
--- a/src/wallet/db.h
+++ b/src/wallet/db.h
@@ -169,8 +169,6 @@ public:
 
     void ReloadDbEnv();
 
-    void ReloadDbEnv();
-
     std::atomic<unsigned int> nUpdateCounter;
     unsigned int nLastSeen;
     unsigned int nLastFlushed;
diff --git a/src/wallet/init.cpp b/src/wallet/init.cpp
index 70fbb681a..89e4e068f 100644
--- a/src/wallet/init.cpp
+++ b/src/wallet/init.cpp
@@ -141,4 +141,5 @@ void WalletInit::Construct(InitInterfaces& interfaces) const
         wallets.pop_back();
         RemoveWallet(wallet);
         UnloadWallet(std::move(wallet));
+    }
 }
diff --git a/src/wallet/ismine.h b/src/wallet/ismine.h
index 41555fcb9..642a87792 100644
--- a/src/wallet/ismine.h
+++ b/src/wallet/ismine.h
@@ -20,9 +20,12 @@ enum isminetype : unsigned int
     ISMINE_NO         = 0,
     ISMINE_WATCH_ONLY = 1 << 0,
     ISMINE_SPENDABLE  = 1 << 1,
-    ISMINE_USED       = 1 << 2,
+    ISMINE_CLAIM      = 1 << 2,
+    ISMINE_SUPPORT    = 1 << 3,
+    ISMINE_USED       = 1 << 4,
+    ISMINE_STAKE      = ISMINE_CLAIM | ISMINE_SUPPORT,
     ISMINE_ALL        = ISMINE_WATCH_ONLY | ISMINE_SPENDABLE,
-    ISMINE_ALL_USED   = ISMINE_ALL | ISMINE_USED,
+    ISMINE_ALL_USED   = ISMINE_ALL | ISMINE_USED | ISMINE_STAKE,
     ISMINE_ENUM_ELEMENTS,
 };
 /** used for bitflags of isminetype */
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index da6b09d2a..aae365a31 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -10,6 +10,7 @@
 #include <init.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
+#include <nameclaim.h>
 #include <node/transaction.h>
 #include <outputtype.h>
 #include <policy/feerate.h>
@@ -20,6 +21,7 @@
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/sign.h>
+#include <validation.h>
 #include <util/bip32.h>
 #include <util/fees.h>
 #include <util/moneystr.h>
@@ -385,6 +387,8 @@ thoritative as long as it remains unspent and there are no other greater unspent
     CScript claimScript = CScript() << OP_CLAIM_NAME << vchName << vchValue << OP_2DROP << OP_DROP;
 
     pwallet->BlockUntilSyncedToCurrentChain();
+    auto locked_chain = pwallet->chain().lock();
+    LOCK(pwallet->cs_wallet);
     EnsureWalletIsUnlocked(pwallet);
 
     //Get new address
@@ -398,7 +402,7 @@ thoritative as long as it remains unspent and there are no other greater unspent
 
     CCoinControl cc;
     cc.m_change_type = pwallet->m_default_change_type;
-    auto tx = SendMoney(pwallet, dest, nAmount, false, cc, {}, {}, claimScript);
+    auto tx = SendMoney(*locked_chain, pwallet, dest, nAmount, false, cc, {}, claimScript);
     return tx->GetHash().GetHex();
 }
 
@@ -434,7 +438,8 @@ UniValue updateclaim(const JSONRPCRequest& request)
     CAmount nAmount = AmountFromValue(request.params[2]);
 
     pwallet->BlockUntilSyncedToCurrentChain();
-    LOCK2(cs_main, pwallet->cs_wallet);
+    auto locked_chain = pwallet->chain().lock();
+    LOCK(pwallet->cs_wallet);
     auto it = pwallet->mapWallet.find(hash);
     if (it == pwallet->mapWallet.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id");
@@ -480,7 +485,7 @@ UniValue updateclaim(const JSONRPCRequest& request)
                 cc.m_change_type = pwallet->m_default_change_type;
                 cc.Select(COutPoint(wtx.tx->GetHash(), i));
                 cc.fAllowOtherInputs = true; // when selecting a coin, that's the only one used without this flag (and we need to cover the fee)
-                wtxNew = SendMoney(pwallet, dest, nAmount, false, cc, {}, {}, updateScript);
+                wtxNew = SendMoney(*locked_chain, pwallet, dest, nAmount, false, cc, {}, updateScript);
                 break;
             }
         }
@@ -516,7 +521,8 @@ UniValue abandonclaim(const JSONRPCRequest& request)
     CTxDestination address = DecodeDestination(request.params[1].get_str());
 
     pwallet->BlockUntilSyncedToCurrentChain();
-    LOCK2(cs_main, pwallet->cs_wallet);
+    auto locked_chain = pwallet->chain().lock();
+    LOCK(pwallet->cs_wallet);
     auto it = pwallet->mapWallet.find(hash);
     if (it == pwallet->mapWallet.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id");
@@ -533,7 +539,7 @@ UniValue abandonclaim(const JSONRPCRequest& request)
             CCoinControl cc;
             cc.m_change_type = pwallet->m_default_change_type;
             cc.Select(COutPoint(wtx.tx->GetHash(), i));
-            wtxNew = SendMoney(pwallet, address, wtx.tx->vout[i].nValue, true, cc, {}, {});
+            wtxNew = SendMoney(*locked_chain, pwallet, address, wtx.tx->vout[i].nValue, true, cc, {});
             break;
         }
     }
@@ -546,7 +552,7 @@ static void MaybePushAddress(UniValue& entry, const CTxDestination &dest);
 
 extern std::string escapeNonUtf8(const std::string&);
 
-void ListNameClaims(const CWalletTx& wtx, CWallet* const pwallet, const std::string& strAccount, int nMinDepth,
+void ListNameClaims(interfaces::Chain::Lock& locked_chain, const CWalletTx& wtx, CWallet* const pwallet, int nMinDepth,
                     UniValue& ret, const bool include_supports, bool list_spent)
 {
     CAmount nFee;
@@ -554,15 +560,11 @@ void ListNameClaims(const CWalletTx& wtx, CWallet* const pwallet, const std::str
     std::list<COutputEntry> listSent;
     std::list<COutputEntry> listReceived;
 
-    wtx.GetAmounts(listReceived, listSent, nFee, strSentAccount, isminetype::ISMINE_ALL);
-
-    bool fAllAccounts = (strAccount == std::string("*"));
-    if (!fAllAccounts && wtx.strFromAccount != strAccount)
-        return;
+    wtx.GetAmounts(listReceived, listSent, nFee, isminetype::ISMINE_ALL);
 
     for (const auto& s: listSent)
     {
-        if (!list_spent && pwallet->IsSpent(wtx.GetHash(), s.vout))
+        if (!list_spent && pwallet->IsSpent(locked_chain, wtx.GetHash(), s.vout))
             continue;
 
         UniValue entry(UniValue::VOBJ);
@@ -611,27 +613,20 @@ void ListNameClaims(const CWalletTx& wtx, CWallet* const pwallet, const std::str
 
         CClaimTrieCache trieCache(pclaimTrie);
 
-        auto it = mapBlockIndex.find(wtx.hashBlock);
-        if (it != mapBlockIndex.end())
+        if (auto pindex = LookupBlockIndex(wtx.m_confirm.hashBlock))
         {
-            CBlockIndex* pindex = it->second;
-            if (pindex)
-            {
-                entry.pushKV("height", pindex->nHeight);
-                entry.pushKV("expiration height", pindex->nHeight + trieCache.expirationTime());
-                if (pindex->nHeight + trieCache.expirationTime() > chainActive.Height())
-                {
-                    entry.pushKV("expired", false);
-                    entry.pushKV("blocks to expiration", pindex->nHeight + trieCache.expirationTime() - chainActive.Height());
-                }
-                else
-                {
-                    entry.pushKV("expired", true);
-                }
+            entry.pushKV("height", pindex->nHeight);
+            entry.pushKV("expiration height", pindex->nHeight + trieCache.expirationTime());
+            if (pindex->nHeight + trieCache.expirationTime() > ::ChainActive().Height()) {
+                entry.pushKV("expired", false);
+                entry.pushKV("blocks to expiration", pindex->nHeight + trieCache.expirationTime() - ::ChainActive().Height());
+            }
+            else {
+                entry.pushKV("expired", true);
             }
         }
-        entry.pushKV("confirmations", wtx.GetDepthInMainChain());
-        entry.pushKV("is spent", pwallet->IsSpent(wtx.GetHash(), s.vout));
+        entry.pushKV("confirmations", wtx.GetDepthInMainChain(locked_chain));
+        entry.pushKV("is spent", pwallet->IsSpent(locked_chain, wtx.GetHash(), s.vout));
         if (op == OP_CLAIM_NAME)
         {
             entry.pushKV("is in name trie", trieCache.haveClaim(sName, COutPoint(wtx.GetHash(), s.vout)));
@@ -686,8 +681,6 @@ UniValue listnameclaims(const JSONRPCRequest& request)
             "  }\n"
             "]\n");
 
-    std::string strAccount = "*";
-
     auto include_supports = request.params.size() < 1 || request.params[0].get_bool();
     bool fListSpent = request.params.size() > 1 && !request.params[1].get_bool();
 
@@ -698,14 +691,15 @@ UniValue listnameclaims(const JSONRPCRequest& request)
 
     UniValue ret(UniValue::VARR);
     pwallet->BlockUntilSyncedToCurrentChain();
+    auto locked_chain = pwallet->chain().lock();
     LOCK2(cs_main, pwallet->cs_wallet);
     const auto& txOrdered = pwallet->wtxOrdered;
 
     for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
     {
-        auto *const pwtx = (*it).second.first;
-        if (pwtx != nullptr && pwtx->GetDepthInMainChain() >= nMinDepth)
-            ListNameClaims(*pwtx, pwallet, strAccount, 0, ret, include_supports, fListSpent);
+        auto *const pwtx = (*it).second;
+        if (pwtx != nullptr && pwtx->GetDepthInMainChain(*locked_chain) >= nMinDepth)
+            ListNameClaims(*locked_chain, *pwtx, pwallet, 0, ret, include_supports, fListSpent);
     }
 
     auto arrTmp = ret.getValues();
@@ -759,6 +753,7 @@ UniValue supportclaim(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("claimid must be maximum of length %d", claimLength));
 
     pwallet->BlockUntilSyncedToCurrentChain();
+    auto locked_chain = pwallet->chain().lock();
     LOCK2(cs_main, pwallet->cs_wallet);
     EnsureWalletIsUnlocked(pwallet);
 
@@ -799,7 +794,7 @@ UniValue supportclaim(const JSONRPCRequest& request)
     if (isTip) {
         CTransactionRef ref;
         uint256 block;
-        if (!GetTransaction(uint256(claimNsupports.claim.outPoint.hash), ref, Params().GetConsensus(), block, true))
+        if (!GetTransaction(uint256(claimNsupports.claim.outPoint.hash), ref, Params().GetConsensus(), block))
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Unable to locate the TX with the claim's output.");
         if (!ExtractDestination(ref->vout[claimNsupports.claim.outPoint.n].scriptPubKey, dest))
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Unable to extract the destination from the chosen claim.");
@@ -816,7 +811,7 @@ UniValue supportclaim(const JSONRPCRequest& request)
 
     CCoinControl cc;
     cc.m_change_type = pwallet->m_default_change_type;
-    auto tx = SendMoney(pwallet, dest, nAmount, false, cc, {}, {}, supportScript);
+    auto tx = SendMoney(*locked_chain, pwallet, dest, nAmount, false, cc, {}, supportScript);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("txId", tx->GetHash().GetHex());
@@ -850,7 +845,8 @@ UniValue abandonsupport(const JSONRPCRequest& request)
     CTxDestination address = DecodeDestination(request.params[1].get_str());
 
     pwallet->BlockUntilSyncedToCurrentChain();
-    LOCK2(cs_main, pwallet->cs_wallet);
+    auto locked_chain = pwallet->chain().lock();
+    LOCK(pwallet->cs_wallet);
     auto it = pwallet->mapWallet.find(hash);
     if (it == pwallet->mapWallet.end()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id");
@@ -867,7 +863,7 @@ UniValue abandonsupport(const JSONRPCRequest& request)
             CCoinControl cc;
             cc.m_change_type = pwallet->m_default_change_type;
             cc.Select(COutPoint(wtx.tx->GetHash(), i));
-            wtxNew = SendMoney(pwallet, address, wtx.tx->vout[i].nValue, true, cc, {}, {});
+            wtxNew = SendMoney(*locked_chain, pwallet, address, wtx.tx->vout[i].nValue, true, cc, {});
             break;
         }
     }
@@ -1574,7 +1570,7 @@ static UniValue addtimelockedaddress(const JSONRPCRequest& request)
     if (!request.params[2].isNull())
         label = LabelFromValue(request.params[2]);
 
-    LOCK2(cs_main, pwallet->cs_wallet);
+    LOCK(pwallet->cs_wallet);
 
     auto address = request.params[1].get_str();
     CTxDestination destination = DecodeDestination(address);
@@ -1881,12 +1877,6 @@ static void ListTransactions(interfaces::Chain::Lock& locked_chain, CWallet* con
 
     bool involvesWatchonly = wtx.IsFromMe(ISMINE_WATCH_ONLY);
 
-    bool list_sent = fAllAccounts;
-
-    if (IsDeprecatedRPCEnabled("accounts")) {
-        list_sent |= strAccount == strSentAccount;
-    }
-
     // Sent
     if (!filter_label)
     {
@@ -3059,8 +3049,8 @@ static UniValue getwalletinfo(const JSONRPCRequest& request)
     auto supports = pwallet->GetBalance(ISMINE_SUPPORT);
     obj.pushKV("balance",       ValueFromAmount(balance.m_mine_trusted));
     obj.pushKV("available_balance",       ValueFromAmount(balance.m_mine_trusted - claims.m_mine_trusted - supports.m_mine_trusted));
-    obj.pushKV("staked_claim_balance", ValueFromAmount(claims));
-    obj.pushKV("staked_support_balance",  ValueFromAmount(supports));
+    obj.pushKV("staked_claim_balance", ValueFromAmount(claims.m_mine_trusted));
+    obj.pushKV("staked_support_balance",  ValueFromAmount(supports.m_mine_trusted));
     obj.pushKV("unconfirmed_balance", ValueFromAmount(balance.m_mine_untrusted_pending));
     obj.pushKV("immature_balance",    ValueFromAmount(balance.m_mine_immature));
     obj.pushKV("txcount",       (int)pwallet->mapWallet.size());
@@ -3176,7 +3166,6 @@ static UniValue loadwallet(const JSONRPCRequest& request)
             + HelpExampleRpc("loadwallet", "\"test.dat\"")
                 },
             }.Check(request);
-    WalletLocation location(request.params[0].get_str());
 
     WalletLocation location(request.params[0].get_str());
 
@@ -4587,23 +4576,6 @@ UniValue sethdseed(const JSONRPCRequest& request)
     return NullUniValue;
 }
 
-            continue;
-        }
-
-        // Verify input looks sane. This will check that we have at most one uxto, witness or non-witness.
-        if (!input.IsSane()) {
-            throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "PSBT input is not sane.");
-        }
-
-        // If we have no utxo, grab it from the wallet.
-        if (!input.non_witness_utxo && input.witness_utxo.IsNull()) {
-        if (sigdata.witness) {
-            // Convert the non-witness utxo to witness
-            if (input.witness_utxo.IsNull() && input.non_witness_utxo) {
-                input.witness_utxo = input.non_witness_utxo->vout[txin.prevout.n];
-            }
-        }
-
 UniValue walletprocesspsbt(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
diff --git a/src/wallet/test/claim_rpc_tests.cpp b/src/wallet/test/claim_rpc_tests.cpp
index 1c99c165b..dfbfbd7ea 100644
--- a/src/wallet/test/claim_rpc_tests.cpp
+++ b/src/wallet/test/claim_rpc_tests.cpp
@@ -9,21 +9,20 @@
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <key_io.h>
+#include <psbt.h>
 #include <rpc/server.h>
-#include <test/test_bitcoin.h>
+#include <test/setup_common.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
-#include <wallet/test/wallet_test_fixture.h>
+#include <wallet/test/init_test_fixture.h>
 #include <policy/policy.h>
 
 #include <boost/test/unit_test.hpp>
 #include <univalue.h>
 
-struct CatchWalletTestSetup: public TestingSetup {
-    CatchWalletTestSetup() : TestingSetup(CBaseChainParams::REGTEST) {
-        RegisterWalletRPCCommands(tableRPC);
-
-        rpcfn_type rpc_method = tableRPC["createwallet"]->actor;
+struct CatchWalletTestSetup: public InitWalletDirTestingSetup {
+    CatchWalletTestSetup() : InitWalletDirTestingSetup(CBaseChainParams::REGTEST) {
+        auto rpc_method = tableRPC["createwallet"];
         JSONRPCRequest req;
         req.params = UniValue(UniValue::VARR);
         req.params.push_back("tester_wallet");
@@ -31,7 +30,7 @@ struct CatchWalletTestSetup: public TestingSetup {
         BOOST_CHECK_EQUAL(results["name"].get_str(), "tester_wallet");
     }
     ~CatchWalletTestSetup() override {
-        rpcfn_type rpc_method = tableRPC["unloadwallet"]->actor;
+        auto rpc_method = tableRPC["unloadwallet"];
         JSONRPCRequest req;
         req.URI = "/wallet/tester_wallet";
         req.params = UniValue(UniValue::VARR);
@@ -42,7 +41,7 @@ struct CatchWalletTestSetup: public TestingSetup {
 BOOST_FIXTURE_TEST_SUITE(claim_rpc_tests, CatchWalletTestSetup)
 
 double AvailableBalance() {
-    rpcfn_type rpc_method = tableRPC["getbalance"]->actor;
+    auto rpc_method = tableRPC["getbalance"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -52,7 +51,7 @@ double AvailableBalance() {
 
 uint256 ClaimAName(const std::string& name, const std::string& data, const std::string& price, bool isUpdate = false) {
     // pass a txid as name for update
-    rpcfn_type rpc_method = tableRPC[isUpdate ? "updateclaim" : "claimname"]->actor;
+    auto rpc_method = tableRPC[isUpdate ? "updateclaim" : "claimname"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -73,7 +72,7 @@ uint256 ClaimAName(const std::string& name, const std::string& data, const std::
 
 uint256 SupportAName(const std::string& name, const std::string& claimId, const std::string& price) {
     // pass a txid as name for update
-    rpcfn_type rpc_method = tableRPC["supportclaim"]->actor;
+    auto rpc_method = tableRPC["supportclaim"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -89,7 +88,7 @@ uint256 SupportAName(const std::string& name, const std::string& claimId, const
 }
 
 UniValue LookupAllNames() {
-    rpcfn_type rpc_method = tableRPC["listnameclaims"]->actor;
+    auto rpc_method = tableRPC["listnameclaims"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -97,7 +96,7 @@ UniValue LookupAllNames() {
 }
 
 std::vector<uint256> generateBlock(int blocks = 1) {
-    rpcfn_type rpc_method = tableRPC["generate"]->actor;
+    auto rpc_method = tableRPC["generate"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -115,7 +114,7 @@ std::vector<uint256> generateBlock(int blocks = 1) {
 }
 
 void rollbackBlock(const std::vector<uint256>& ids) {
-    rpcfn_type rpc_method = tableRPC["invalidateblock"]->actor;
+    auto rpc_method = tableRPC["invalidateblock"];
     for (auto it = ids.rbegin(); it != ids.rend(); ++it) {
         JSONRPCRequest req;
         req.URI = "/wallet/tester_wallet";
@@ -129,7 +128,7 @@ void rollbackBlock(const std::vector<uint256>& ids) {
 }
 
 uint256 AbandonAClaim(const uint256& txid, bool isSupport = false) {
-    rpcfn_type pre_rpc_method = tableRPC["getrawchangeaddress"]->actor;
+    auto pre_rpc_method = tableRPC["getrawchangeaddress"];
     JSONRPCRequest pre_req;
     pre_req.URI = "/wallet/tester_wallet";
     pre_req.params = UniValue(UniValue::VARR);
@@ -137,7 +136,7 @@ uint256 AbandonAClaim(const uint256& txid, bool isSupport = false) {
     UniValue adr_hash = pre_rpc_method(pre_req);
 
     // pass a txid as name for update
-    rpcfn_type rpc_method = tableRPC[isSupport ? "abandonsupport" : "abandonclaim"]->actor;
+    auto rpc_method = tableRPC[isSupport ? "abandonsupport" : "abandonclaim"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -156,7 +155,7 @@ uint256 AbandonAClaim(const uint256& txid, bool isSupport = false) {
 }
 
 void ValidateBalance(double claims, double supports) {
-    rpcfn_type rpc_method = tableRPC["getwalletinfo"]->actor;
+    auto rpc_method = tableRPC["getwalletinfo"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -295,7 +294,7 @@ BOOST_AUTO_TEST_CASE(claim_op_runthrough_bech32)
 }
 
 std::vector<COutPoint> SpendableCoins() {
-    rpcfn_type rpc_method = tableRPC["listunspent"]->actor;
+    auto rpc_method = tableRPC["listunspent"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -307,7 +306,7 @@ std::vector<COutPoint> SpendableCoins() {
 }
 
 CTxDestination NewAddress(OutputType t) {
-    rpcfn_type rpc_method = tableRPC["getnewaddress"]->actor;
+    auto rpc_method = tableRPC["getnewaddress"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -318,7 +317,7 @@ CTxDestination NewAddress(OutputType t) {
 }
 
 std::string SignRawTransaction(const std::string& tx) {
-    rpcfn_type rpc_method = tableRPC["signrawtransactionwithwallet"]->actor;
+    auto rpc_method = tableRPC["signrawtransactionwithwallet"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -332,7 +331,7 @@ std::string SignRawTransaction(const std::string& tx) {
 }
 
 std::string SendRawTransaction(const std::string& tx) {
-    rpcfn_type rpc_method = tableRPC["sendrawtransaction"]->actor;
+    auto rpc_method = tableRPC["sendrawtransaction"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -343,7 +342,7 @@ std::string SendRawTransaction(const std::string& tx) {
 }
 
 std::string FundRawTransaction(const std::string& tx) {
-    rpcfn_type rpc_method = tableRPC["fundrawtransaction"]->actor;
+    auto rpc_method = tableRPC["fundrawtransaction"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -354,7 +353,7 @@ std::string FundRawTransaction(const std::string& tx) {
 
 std::string ProcessPsbt(const PartiallySignedTransaction& pst) {
     BOOST_CHECK(pst.IsSane());
-    rpcfn_type rpc_method = tableRPC["walletprocesspsbt"]->actor;
+    auto rpc_method = tableRPC["walletprocesspsbt"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -369,7 +368,7 @@ std::string ProcessPsbt(const PartiallySignedTransaction& pst) {
 }
 
 std::string FinalizePsbt(const std::string& pst) {
-    rpcfn_type rpc_method = tableRPC["finalizepsbt"]->actor;
+    auto rpc_method = tableRPC["finalizepsbt"];
     JSONRPCRequest req;
     req.URI = "/wallet/tester_wallet";
     req.params = UniValue(UniValue::VARR);
@@ -397,7 +396,7 @@ BOOST_AUTO_TEST_CASE(can_sign_all_addr)
                 + GetScriptForDestination(destination);
         CTxOut out(100000, scriptPubKey);
         claimTx.vout.push_back(out);
-        auto hex = EncodeHexTx(claimTx);
+        auto hex = EncodeHexTx(CTransaction(claimTx));
         hex = SignRawTransaction(hex);
         txids.push_back(SendRawTransaction(hex));
         CTxIn spendIn(uint256S(txids.back()), 0);
@@ -405,7 +404,7 @@ BOOST_AUTO_TEST_CASE(can_sign_all_addr)
         CTxOut spendOut(90000, GetScriptForDestination(destination2));
         spendTx.vin.push_back(spendIn);
         spendTx.vout.push_back(spendOut);
-        hex = EncodeHexTx(spendTx);
+        hex = EncodeHexTx(CTransaction(spendTx));
         spends.push_back(hex);
     }
     generateBlock(1);
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 0c7522121..8e55754a4 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -244,7 +244,7 @@ BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup)
     auto chain = interfaces::MakeChain();
 
     CWallet wallet(chain.get(), WalletLocation(), WalletDatabase::CreateDummy());
-    CWalletTx wtx(&wallet, m_coinbase_txns.back());
+    CWalletTx wtx(&wallet, MakeTransactionRef(m_coinbase_txns.back()));
 
     auto locked_chain = chain->lock();
     LockAssertion lock(::cs_main);
@@ -516,47 +516,4 @@ BOOST_FIXTURE_TEST_CASE(dummy_input_size_test, TestChain100Setup)
     BOOST_CHECK_EQUAL(CalculateNestedKeyhashInputSize(true), DUMMY_NESTED_P2WPKH_INPUT_SIZE);
 }
 
-// Explicit calculation which is used to test the wallet constant
-// We get the same virtual size due to rounding(weight/4) for both use_max_sig values
-static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
-{
-    // Generate ephemeral valid pubkey
-    CKey key;
-    key.MakeNewKey(true);
-    CPubKey pubkey = key.GetPubKey();
-
-    // Generate pubkey hash
-    uint160 key_hash(Hash160(pubkey.begin(), pubkey.end()));
-
-    // Create inner-script to enter into keystore. Key hash can't be 0...
-    CScript inner_script = CScript() << OP_0 << std::vector<unsigned char>(key_hash.begin(), key_hash.end());
-
-    // Create outer P2SH script for the output
-    uint160 script_id(Hash160(inner_script.begin(), inner_script.end()));
-    CScript script_pubkey = CScript() << OP_HASH160 << std::vector<unsigned char>(script_id.begin(), script_id.end()) << OP_EQUAL;
-
-    // Add inner-script to key store and key to watchonly
-    CBasicKeyStore keystore;
-    keystore.AddCScript(inner_script);
-    keystore.AddKeyPubKey(key, pubkey);
-
-    // Fill in dummy signatures for fee calculation.
-    SignatureData sig_data;
-
-    if (!ProduceSignature(keystore, use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR : DUMMY_SIGNATURE_CREATOR, script_pubkey, sig_data)) {
-        // We're hand-feeding it correct arguments; shouldn't happen
-        assert(false);
-    }
-
-    CTxIn tx_in;
-    UpdateInput(tx_in, sig_data);
-    return (size_t)GetVirtualTransactionInputSize(tx_in);
-}
-
-BOOST_FIXTURE_TEST_CASE(dummy_input_size_test, TestChain100Setup)
-{
-    BOOST_CHECK_EQUAL(CalculateNestedKeyhashInputSize(false), DUMMY_NESTED_P2WPKH_INPUT_SIZE);
-    BOOST_CHECK_EQUAL(CalculateNestedKeyhashInputSize(true), DUMMY_NESTED_P2WPKH_INPUT_SIZE);
-}
-
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 663195421..cc1b99fbd 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -126,29 +126,6 @@ static void ReleaseWallet(CWallet* wallet)
     g_wallet_release_cv.notify_all();
 }
 
-void UnloadWallet(std::shared_ptr<CWallet>&& wallet)
-{
-    // Mark wallet for unloading.
-    CWallet* pwallet = wallet.get();
-    {
-        std::lock_guard<std::mutex> lock(g_wallet_release_mutex);
-        auto it = g_unloading_wallet_set.insert(pwallet);
-        assert(it.second);
-    }
-    // The wallet can be in use so it's not possible to explicitly unload here.
-    // Notify the unload intent so that all remaining shared pointers are
-    // released.
-    pwallet->NotifyUnload();
-    // Time to ditch our shared_ptr and wait for ReleaseWallet call.
-    wallet.reset();
-    {
-        std::unique_lock<std::mutex> lock(g_wallet_release_mutex);
-        while (g_unloading_wallet_set.count(pwallet) == 1) {
-            g_wallet_release_cv.wait(lock);
-        }
-    }
-}
-
 void UnloadWallet(std::shared_ptr<CWallet>&& wallet)
 {
     // Mark wallet for unloading.
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 97cb06ac3..a4ebfca22 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -95,9 +95,6 @@ constexpr CAmount HIGH_MAX_TX_FEE{100 * HIGH_TX_FEE_PER_KB};
 //! Pre-calculated constants for input size estimation in *virtual size*
 static constexpr size_t DUMMY_NESTED_P2WPKH_INPUT_SIZE = 91;
 
-//! Pre-calculated constants for input size estimation in *virtual size*
-static constexpr size_t DUMMY_NESTED_P2WPKH_INPUT_SIZE = 91;
-
 class CCoinControl;
 class COutput;
 class CScript;
@@ -885,10 +882,10 @@ private:
      */
     uint256 m_last_block_processed GUARDED_BY(cs_wallet);
 
+public:
     //! Fetches a key from the keypool
     bool GetKeyFromPool(CPubKey &key, bool internal = false);
 
-public:
     /*
      * Main wallet lock.
      * This lock protects all the fields added by CWallet.
@@ -913,8 +910,6 @@ public:
 
     const WalletLocation& GetLocation() const { return m_location; }
 
-    const WalletLocation& GetLocation() const { return m_location; }
-
     /** Get a name for this wallet for logging/debugging purposes.
      */
     const std::string& GetName() const { return m_location.GetName(); }
diff --git a/src/wallet/walletutil.cpp b/src/wallet/walletutil.cpp
index baf8e7057..04c2407a8 100644
--- a/src/wallet/walletutil.cpp
+++ b/src/wallet/walletutil.cpp
@@ -102,14 +102,3 @@ bool WalletLocation::Exists() const
 {
     return fs::symlink_status(m_path).type() != fs::file_not_found;
 }
-
-WalletLocation::WalletLocation(const std::string& name)
-    : m_name(name)
-    , m_path(fs::absolute(name, GetWalletDir()))
-{
-}
-
-bool WalletLocation::Exists() const
-{
-    return fs::symlink_status(m_path).type() != fs::file_not_found;
-}
diff --git a/src/wallet/walletutil.h b/src/wallet/walletutil.h
index db1e54e00..ba2f91384 100644
--- a/src/wallet/walletutil.h
+++ b/src/wallet/walletutil.h
@@ -35,24 +35,4 @@ public:
     bool Exists() const;
 };
 
-//! The WalletLocation class provides wallet information.
-class WalletLocation final
-{
-    std::string m_name;
-    fs::path m_path;
-
-public:
-    explicit WalletLocation() {}
-    explicit WalletLocation(const std::string& name);
-
-    //! Get wallet name.
-    const std::string& GetName() const { return m_name; }
-
-    //! Get wallet absolute path.
-    const fs::path& GetPath() const { return m_path; }
-
-    //! Return whether the wallet exists.
-    bool Exists() const;
-};
-
 #endif // BITCOIN_WALLET_WALLETUTIL_H