diff --git a/DoS_tests.cpp b/DoS_tests.cpp
new file mode 100644
index 0000000..ce7abb9
--- /dev/null
+++ b/DoS_tests.cpp
@@ -0,0 +1,385 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+// Unit tests for denial-of-service detection/prevention code
+
+#include <chainparams.h>
+#include <keystore.h>
+#include <net.h>
+#include <net_processing.h>
+#include <pow.h>
+#include <script/sign.h>
+#include <serialize.h>
+#include <util.h>
+#include <validation.h>
+
+#include <test/test_salemcash.h>
+
+#include <stdint.h>
+
+#include <boost/test/unit_test.hpp>
+
+// Tests these internal-to-net_processing.cpp methods:
+extern bool AddOrphanTx(const CTransactionRef& tx, NodeId peer);
+extern void EraseOrphansFor(NodeId peer);
+extern unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans);
+struct COrphanTx {
+    CTransactionRef tx;
+    NodeId fromPeer;
+    int64_t nTimeExpire;
+};
+extern std::map<uint256, COrphanTx> mapOrphanTransactions;
+
+CService ip(uint32_t i)
+{
+    struct in_addr s;
+    s.s_addr = i;
+    return CService(CNetAddr(s), Params().GetDefaultPort());
+}
+
+static NodeId id = 0;
+
+void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds);
+
+BOOST_FIXTURE_TEST_SUITE(DoS_tests, TestingSetup)
+
+// Test eviction of an outbound peer whose chain never advances
+// Mock a node connection, and use mocktime to simulate a peer
+// which never sends any headers messages.  PeerLogic should
+// decide to evict that outbound peer, after the appropriate timeouts.
+// Note that we protect 4 outbound nodes from being subject to
+// this logic; this test takes advantage of that protection only
+// being applied to nodes which send headers with sufficient
+// work.
+BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
+{
+    std::atomic<bool> interruptDummy(false);
+
+    // Mock an outbound peer
+    CAddress addr1(ip(0xa0b0c001), NODE_NONE);
+    CNode dummyNode1(id++, ServiceFlags(NODE_NETWORK|NODE_WITNESS), 0, INVALID_SOCKET, addr1, 0, 0, CAddress(), "", /*fInboundIn=*/ false);
+    dummyNode1.SetSendVersion(PROTOCOL_VERSION);
+
+    peerLogic->InitializeNode(&dummyNode1);
+    dummyNode1.nVersion = 1;
+    dummyNode1.fSuccessfullyConnected = true;
+
+    // This test requires that we have a chain with non-zero work.
+    LOCK(cs_main);
+    BOOST_CHECK(chainActive.Tip() != nullptr);
+    BOOST_CHECK(chainActive.Tip()->nChainWork > 0);
+
+    // Test starts here
+    LOCK(dummyNode1.cs_sendProcessing);
+    peerLogic->SendMessages(&dummyNode1, interruptDummy); // should result in getheaders
+    LOCK(dummyNode1.cs_vSend);
+    BOOST_CHECK(dummyNode1.vSendMsg.size() > 0);
+    dummyNode1.vSendMsg.clear();
+
+    int64_t nStartTime = GetTime();
+    // Wait 21 minutes
+    SetMockTime(nStartTime+21*60);
+    peerLogic->SendMessages(&dummyNode1, interruptDummy); // should result in getheaders
+    BOOST_CHECK(dummyNode1.vSendMsg.size() > 0);
+    // Wait 3 more minutes
+    SetMockTime(nStartTime+24*60);
+    peerLogic->SendMessages(&dummyNode1, interruptDummy); // should result in disconnect
+    BOOST_CHECK(dummyNode1.fDisconnect == true);
+    SetMockTime(0);
+
+    bool dummy;
+    peerLogic->FinalizeNode(dummyNode1.GetId(), dummy);
+}
+
+void AddRandomOutboundPeer(std::vector<CNode *> &vNodes, PeerLogicValidation &peerLogic)
+{
+    CAddress addr(ip(GetRandInt(0xffffffff)), NODE_NONE);
+    vNodes.emplace_back(new CNode(id++, ServiceFlags(NODE_NETWORK|NODE_WITNESS), 0, INVALID_SOCKET, addr, 0, 0, CAddress(), "", /*fInboundIn=*/ false));
+    CNode &node = *vNodes.back();
+    node.SetSendVersion(PROTOCOL_VERSION);
+
+    peerLogic.InitializeNode(&node);
+    node.nVersion = 1;
+    node.fSuccessfullyConnected = true;
+
+    CConnmanTest::AddNode(node);
+}
+
+BOOST_AUTO_TEST_CASE(stale_tip_peer_management)
+{
+    const Consensus::Params& consensusParams = Params().GetConsensus();
+    constexpr int nMaxOutbound = 8;
+    CConnman::Options options;
+    options.nMaxConnections = 125;
+    options.nMaxOutbound = nMaxOutbound;
+    options.nMaxFeeler = 1;
+
+    connman->Init(options);
+    std::vector<CNode *> vNodes;
+
+    // Mock some outbound peers
+    for (int i=0; i<nMaxOutbound; ++i) {
+        AddRandomOutboundPeer(vNodes, *peerLogic);
+    }
+
+    peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
+
+    // No nodes should be marked for disconnection while we have no extra peers
+    for (const CNode *node : vNodes) {
+        BOOST_CHECK(node->fDisconnect == false);
+    }
+
+    SetMockTime(GetTime() + 3*consensusParams.nPowTargetSpacing + 1);
+
+    // Now tip should definitely be stale, and we should look for an extra
+    // outbound peer
+    peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
+    BOOST_CHECK(connman->GetTryNewOutboundPeer());
+
+    // Still no peers should be marked for disconnection
+    for (const CNode *node : vNodes) {
+        BOOST_CHECK(node->fDisconnect == false);
+    }
+
+    // If we add one more peer, something should get marked for eviction
+    // on the next check (since we're mocking the time to be in the future, the
+    // required time connected check should be satisfied).
+    AddRandomOutboundPeer(vNodes, *peerLogic);
+
+    peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
+    for (int i=0; i<nMaxOutbound; ++i) {
+        BOOST_CHECK(vNodes[i]->fDisconnect == false);
+    }
+    // Last added node should get marked for eviction
+    BOOST_CHECK(vNodes.back()->fDisconnect == true);
+
+    vNodes.back()->fDisconnect = false;
+
+    // Update the last announced block time for the last
+    // peer, and check that the next newest node gets evicted.
+    UpdateLastBlockAnnounceTime(vNodes.back()->GetId(), GetTime());
+
+    peerLogic->CheckForStaleTipAndEvictPeers(consensusParams);
+    for (int i=0; i<nMaxOutbound-1; ++i) {
+        BOOST_CHECK(vNodes[i]->fDisconnect == false);
+    }
+    BOOST_CHECK(vNodes[nMaxOutbound-1]->fDisconnect == true);
+    BOOST_CHECK(vNodes.back()->fDisconnect == false);
+
+    bool dummy;
+    for (const CNode *node : vNodes) {
+        peerLogic->FinalizeNode(node->GetId(), dummy);
+    }
+
+    CConnmanTest::ClearNodes();
+}
+
+BOOST_AUTO_TEST_CASE(DoS_banning)
+{
+    std::atomic<bool> interruptDummy(false);
+
+    connman->ClearBanned();
+    CAddress addr1(ip(0xa0b0c001), NODE_NONE);
+    CNode dummyNode1(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr1, 0, 0, CAddress(), "", true);
+    dummyNode1.SetSendVersion(PROTOCOL_VERSION);
+    peerLogic->InitializeNode(&dummyNode1);
+    dummyNode1.nVersion = 1;
+    dummyNode1.fSuccessfullyConnected = true;
+    {
+        LOCK(cs_main);
+        Misbehaving(dummyNode1.GetId(), 100); // Should get banned
+    }
+    LOCK(dummyNode1.cs_sendProcessing);
+    peerLogic->SendMessages(&dummyNode1, interruptDummy);
+    BOOST_CHECK(connman->IsBanned(addr1));
+    BOOST_CHECK(!connman->IsBanned(ip(0xa0b0c001|0x0000ff00))); // Different IP, not banned
+
+    CAddress addr2(ip(0xa0b0c002), NODE_NONE);
+    CNode dummyNode2(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr2, 1, 1, CAddress(), "", true);
+    dummyNode2.SetSendVersion(PROTOCOL_VERSION);
+    peerLogic->InitializeNode(&dummyNode2);
+    dummyNode2.nVersion = 1;
+    dummyNode2.fSuccessfullyConnected = true;
+    {
+        LOCK(cs_main);
+        Misbehaving(dummyNode2.GetId(), 50);
+    }
+    LOCK(dummyNode2.cs_sendProcessing);
+    peerLogic->SendMessages(&dummyNode2, interruptDummy);
+    BOOST_CHECK(!connman->IsBanned(addr2)); // 2 not banned yet...
+    BOOST_CHECK(connman->IsBanned(addr1));  // ... but 1 still should be
+    {
+        LOCK(cs_main);
+        Misbehaving(dummyNode2.GetId(), 50);
+    }
+    peerLogic->SendMessages(&dummyNode2, interruptDummy);
+    BOOST_CHECK(connman->IsBanned(addr2));
+
+    bool dummy;
+    peerLogic->FinalizeNode(dummyNode1.GetId(), dummy);
+    peerLogic->FinalizeNode(dummyNode2.GetId(), dummy);
+}
+
+BOOST_AUTO_TEST_CASE(DoS_banscore)
+{
+    std::atomic<bool> interruptDummy(false);
+
+    connman->ClearBanned();
+    gArgs.ForceSetArg("-banscore", "111"); // because 11 is my favorite number
+    CAddress addr1(ip(0xa0b0c001), NODE_NONE);
+    CNode dummyNode1(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr1, 3, 1, CAddress(), "", true);
+    dummyNode1.SetSendVersion(PROTOCOL_VERSION);
+    peerLogic->InitializeNode(&dummyNode1);
+    dummyNode1.nVersion = 1;
+    dummyNode1.fSuccessfullyConnected = true;
+    {
+        LOCK(cs_main);
+        Misbehaving(dummyNode1.GetId(), 100);
+    }
+    LOCK(dummyNode1.cs_sendProcessing);
+    peerLogic->SendMessages(&dummyNode1, interruptDummy);
+    BOOST_CHECK(!connman->IsBanned(addr1));
+    {
+        LOCK(cs_main);
+        Misbehaving(dummyNode1.GetId(), 10);
+    }
+    peerLogic->SendMessages(&dummyNode1, interruptDummy);
+    BOOST_CHECK(!connman->IsBanned(addr1));
+    {
+        LOCK(cs_main);
+        Misbehaving(dummyNode1.GetId(), 1);
+    }
+    peerLogic->SendMessages(&dummyNode1, interruptDummy);
+    BOOST_CHECK(connman->IsBanned(addr1));
+    gArgs.ForceSetArg("-banscore", std::to_string(DEFAULT_BANSCORE_THRESHOLD));
+
+    bool dummy;
+    peerLogic->FinalizeNode(dummyNode1.GetId(), dummy);
+}
+
+BOOST_AUTO_TEST_CASE(DoS_bantime)
+{
+    std::atomic<bool> interruptDummy(false);
+
+    connman->ClearBanned();
+    int64_t nStartTime = GetTime();
+    SetMockTime(nStartTime); // Overrides future calls to GetTime()
+
+    CAddress addr(ip(0xa0b0c001), NODE_NONE);
+    CNode dummyNode(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr, 4, 4, CAddress(), "", true);
+    dummyNode.SetSendVersion(PROTOCOL_VERSION);
+    peerLogic->InitializeNode(&dummyNode);
+    dummyNode.nVersion = 1;
+    dummyNode.fSuccessfullyConnected = true;
+
+    {
+        LOCK(cs_main);
+        Misbehaving(dummyNode.GetId(), 100);
+    }
+    LOCK(dummyNode.cs_sendProcessing);
+    peerLogic->SendMessages(&dummyNode, interruptDummy);
+    BOOST_CHECK(connman->IsBanned(addr));
+
+    SetMockTime(nStartTime+60*60);
+    BOOST_CHECK(connman->IsBanned(addr));
+
+    SetMockTime(nStartTime+60*60*24+1);
+    BOOST_CHECK(!connman->IsBanned(addr));
+
+    bool dummy;
+    peerLogic->FinalizeNode(dummyNode.GetId(), dummy);
+}
+
+CTransactionRef RandomOrphan()
+{
+    std::map<uint256, COrphanTx>::iterator it;
+    LOCK(cs_main);
+    it = mapOrphanTransactions.lower_bound(InsecureRand256());
+    if (it == mapOrphanTransactions.end())
+        it = mapOrphanTransactions.begin();
+    return it->second.tx;
+}
+
+BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
+{
+    CKey key;
+    key.MakeNewKey(true);
+    CBasicKeyStore keystore;
+    keystore.AddKey(key);
+
+    // 50 orphan transactions:
+    for (int i = 0; i < 50; i++)
+    {
+        CMutableTransaction tx;
+        tx.vin.resize(1);
+        tx.vin[0].prevout.n = 0;
+        tx.vin[0].prevout.hash = InsecureRand256();
+        tx.vin[0].scriptSig << OP_1;
+        tx.vout.resize(1);
+        tx.vout[0].nValue = 1*CENT;
+        tx.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
+
+        AddOrphanTx(MakeTransactionRef(tx), i);
+    }
+
+    // ... and 50 that depend on other orphans:
+    for (int i = 0; i < 50; i++)
+    {
+        CTransactionRef txPrev = RandomOrphan();
+
+        CMutableTransaction tx;
+        tx.vin.resize(1);
+        tx.vin[0].prevout.n = 0;
+        tx.vin[0].prevout.hash = txPrev->GetHash();
+        tx.vout.resize(1);
+        tx.vout[0].nValue = 1*CENT;
+        tx.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
+        SignSignature(keystore, *txPrev, tx, 0, SIGHASH_ALL);
+
+        AddOrphanTx(MakeTransactionRef(tx), i);
+    }
+
+    // This really-big orphan should be ignored:
+    for (int i = 0; i < 10; i++)
+    {
+        CTransactionRef txPrev = RandomOrphan();
+
+        CMutableTransaction tx;
+        tx.vout.resize(1);
+        tx.vout[0].nValue = 1*CENT;
+        tx.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
+        tx.vin.resize(2777);
+        for (unsigned int j = 0; j < tx.vin.size(); j++)
+        {
+            tx.vin[j].prevout.n = j;
+            tx.vin[j].prevout.hash = txPrev->GetHash();
+        }
+        SignSignature(keystore, *txPrev, tx, 0, SIGHASH_ALL);
+        // Re-use same signature for other inputs
+        // (they don't have to be valid for this test)
+        for (unsigned int j = 1; j < tx.vin.size(); j++)
+            tx.vin[j].scriptSig = tx.vin[0].scriptSig;
+
+        BOOST_CHECK(!AddOrphanTx(MakeTransactionRef(tx), i));
+    }
+
+    LOCK(cs_main);
+    // Test EraseOrphansFor:
+    for (NodeId i = 0; i < 3; i++)
+    {
+        size_t sizeBefore = mapOrphanTransactions.size();
+        EraseOrphansFor(i);
+        BOOST_CHECK(mapOrphanTransactions.size() < sizeBefore);
+    }
+
+    // Test LimitOrphanTxSize() function:
+    LimitOrphanTxSize(40);
+    BOOST_CHECK(mapOrphanTransactions.size() <= 40);
+    LimitOrphanTxSize(10);
+    BOOST_CHECK(mapOrphanTransactions.size() <= 10);
+    LimitOrphanTxSize(0);
+    BOOST_CHECK(mapOrphanTransactions.empty());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..7bae8b3
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,6 @@
+all:
+	$(MAKE) -C .. salemcash_test
+clean:
+	$(MAKE) -C .. salemcash_test_clean
+check:
+	$(MAKE) -C .. salemcash_test_check
diff --git a/README.md b/README.md
index cdecb69..1ee5572 100644
--- a/README.md
+++ b/README.md
@@ -1,83 +1,55 @@
-The SalemCash Core
-==================
-
-Setup
----------------------
-SalemCash Core is the original SalemCash client and it builds the backbone of the network. It downloads and, by default, stores the entire history of Bitcoin transactions (which is currently more than 100 GBs); depending on the speed of your computer and network connection, the synchronization process can take anywhere from a few hours to a day or more.
-
-To download the SalemCash Core, visit [SalemCashcore.org](https://salemcashcore.org/en/releases/).
-
-Running
----------------------
-The following are some helpful notes on how to run Bitcoin on your native platform.
-
-### Unix
-
-Unpack the files into a directory and run:
-
-- `bin/SalemCash-qt` (GUI) or
-- `bin/SalemCashd` (headless)
-
-### Windows
-
-Unpack the files into a directory, and then run SalemCash-qt.exe.
-
-### OS X
-
-Drag SalemCash-Core to your applications folder, and then run SalemCash-Core.
-
-### Need Help?
-
-* See the documentation at the [Bitcoin Wiki](https://en.salemcash.it/wiki/Main_Page)
-for help and more information.
-* Ask for help on [#SalemCash](http://webchat.freenode.net?channels=SalemCash) on Freenode. If you don't have an IRC client use [webchat here](http://webchat.freenode.net?channels=SalemCash).
-* Ask for help on the [SalemCashTalk](https://salemcashtalk.org/) forums, in the [Technical Support board](https://salemcashtalk.org/index.php?board=4.0).
-
-Building
----------------------
-The following are developer notes on how to build SalemCash on your native platform. They are not complete guides, but include notes on the necessary libraries, compile flags, etc.
-
-- [Dependencies](dependencies.md)
-- [OS X Build Notes](build-osx.md)
-- [Unix Build Notes](build-unix.md)
-- [Windows Build Notes](build-windows.md)
-- [OpenBSD Build Notes](build-openbsd.md)
-- [NetBSD Build Notes](build-netbsd.md)
-- [Gitian Building Guide](gitian-building.md)
-
-Development
----------------------
-The SalemCash repo's [root README](/README.md) contains relevant information on the development process and automated testing.
-
-- [Developer Notes](developer-notes.md)
-- [Release Notes](release-notes.md)
-- [Release Process](release-process.md)
-- [Source Code Documentation (External Link)](https://dev.visucore.com/SalemCash/doxygen/)
-- [Translation Process](translation_process.md)
-- [Translation Strings Policy](translation_strings_policy.md)
-- [Travis CI](travis-ci.md)
-- [Unauthenticated REST Interface](REST-interface.md)
-- [Shared Libraries](shared-libraries.md)
-- [BIPS](bips.md)
-- [Dnsseed Policy](dnsseed-policy.md)
-- [Benchmarking](benchmarking.md)
-
-### Resources
-* Discuss on the [SalemCashTalk](https://salemcashtalk.org/) forums, in the [Development & Technical Discussion board](https://salemcashtalk.org/index.php?board=6.0).
-* Discuss project-specific development on #SalemCash-core-dev on Freenode. If you don't have an IRC client use [webchat here](http://webchat.freenode.net/?channels=salemcash-core-dev).
-* Discuss general SalemCash development on #SalemCash-dev on Freenode. If you don't have an IRC client use [webchat here](http://webchat.freenode.net/?channels=salemcash-dev).
-
-### Miscellaneous
-- [Assets Attribution](assets-attribution.md)
-- [Files](files.md)
-- [Fuzz-testing](fuzzing.md)
-- [Reduce Traffic](reduce-traffic.md)
-- [Tor Support](tor.md)
-- [Init Scripts (systemd/upstart/openrc)](init.md)
-- [ZMQ](zmq.md)
-
-License
----------------------
-Distributed under the [MIT software license](/COPYING).
-This product includes software developed by the OpenSSL Project for use in the [OpenSSL Toolkit](https://www.openssl.org/). This product includes
-cryptographic software written by Eric Young ([eay@cryptsoft.com](mailto:eay@cryptsoft.com)), and UPnP software written by Thomas Bernard.
+### Compiling/running unit tests
+
+Unit tests will be automatically compiled if dependencies were met in `./configure`
+and tests weren't explicitly disabled.
+
+After configuring, they can be run with `make check`.
+
+To run the salemcashd tests manually, launch `src/test/test_salemcash`. To recompile
+after a test file was modified, run `make` and then run the test again. If you
+modify a non-test file, use `make -C src/test` to recompile only what's needed
+to run the salemcashd tests.
+
+To add more bitcoind tests, add `BOOST_AUTO_TEST_CASE` functions to the existing
+.cpp files in the `test/` directory or add new .cpp files that
+implement new BOOST_AUTO_TEST_SUITE sections.
+
+To run the salemcash-qt tests manually, launch `src/qt/test/test_salemcash-qt`
+
+To add more salemcash-qt tests, add them to the `src/qt/test/` directory and
+the `src/qt/test/test_main.cpp` file.
+
+### Running individual tests
+
+test_salemcash has some built-in command-line arguments; for
+example, to run just the getarg_tests verbosely:
+
+    test_salemcash --log_level=all --run_test=getarg_tests
+
+... or to run just the doubledash test:
+
+    test_salemcash --run_test=getarg_tests/doubledash
+
+Run `test_salemcash --help` for the full list.
+
+### Note on adding test cases
+
+The sources in this directory are unit test cases.  Boost includes a
+unit testing framework, and since salemcash already uses boost, it makes
+sense to simply use this framework rather than require developers to
+configure some other framework (we want as few impediments to creating
+unit tests as possible).
+
+The build system is setup to compile an executable called `test_salemcash`
+that runs all of the unit tests.  The main source file is called
+test_salemcash.cpp. To add a new unit test file to our test suite you need 
+to add the file to `src/Makefile.test.include`. The pattern is to create 
+one test file for each class or source file for which you want to create 
+unit tests.  The file naming convention is `<source_filename>_tests.cpp` 
+and such files should wrap their tests in a test suite 
+called `<source_filename>_tests`. For an example of this pattern, 
+examine `uint256_tests.cpp`.
+
+For further reading, I found the following website to be helpful in
+explaining how the boost unit test framework works:
+[http://www.alittlemadness.com/2009/03/31/c-unit-testing-with-boosttest/](http://archive.is/dRBGf).
diff --git a/addrman_tests.cpp b/addrman_tests.cpp
new file mode 100644
index 0000000..6852610
--- /dev/null
+++ b/addrman_tests.cpp
@@ -0,0 +1,690 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#include <addrman.h>
+#include <test/test_salemcash.h>
+#include <string>
+#include <boost/test/unit_test.hpp>
+
+#include <hash.h>
+#include <netbase.h>
+#include <random.h>
+
+class CAddrManTest : public CAddrMan
+{
+    uint64_t state;
+
+public:
+    explicit CAddrManTest(bool makeDeterministic = true)
+    {
+        state = 1;
+
+        if (makeDeterministic) {
+            //  Set addrman addr placement to be deterministic.
+            MakeDeterministic();
+        }
+    }
+
+    //! Ensure that bucket placement is always the same for testing purposes.
+    void MakeDeterministic()
+    {
+        nKey.SetNull();
+        insecure_rand = FastRandomContext(true);
+    }
+
+    int RandomInt(int nMax) override
+    {
+        state = (CHashWriter(SER_GETHASH, 0) << state).GetHash().GetCheapHash();
+        return (unsigned int)(state % nMax);
+    }
+
+    CAddrInfo* Find(const CNetAddr& addr, int* pnId = nullptr)
+    {
+        return CAddrMan::Find(addr, pnId);
+    }
+
+    CAddrInfo* Create(const CAddress& addr, const CNetAddr& addrSource, int* pnId = nullptr)
+    {
+        return CAddrMan::Create(addr, addrSource, pnId);
+    }
+
+    void Delete(int nId)
+    {
+        CAddrMan::Delete(nId);
+    }
+
+    // Simulates connection failure so that we can test eviction of offline nodes
+    void SimConnFail(CService& addr)
+    {
+         int64_t nLastSuccess = 1;
+         Good_(addr, true, nLastSuccess); // Set last good connection in the deep past.
+
+         bool count_failure = false;
+         int64_t nLastTry = GetAdjustedTime()-61;
+         Attempt(addr, count_failure, nLastTry);
+     }
+};
+
+static CNetAddr ResolveIP(const char* ip)
+{
+    CNetAddr addr;
+    BOOST_CHECK_MESSAGE(LookupHost(ip, addr, false), strprintf("failed to resolve: %s", ip));
+    return addr;
+}
+
+static CNetAddr ResolveIP(std::string ip)
+{
+    return ResolveIP(ip.c_str());
+}
+
+static CService ResolveService(const char* ip, int port = 0)
+{
+    CService serv;
+    BOOST_CHECK_MESSAGE(Lookup(ip, serv, port, false), strprintf("failed to resolve: %s:%i", ip, port));
+    return serv;
+}
+
+static CService ResolveService(std::string ip, int port = 0)
+{
+    return ResolveService(ip.c_str(), port);
+}
+
+BOOST_FIXTURE_TEST_SUITE(addrman_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(addrman_simple)
+{
+    CAddrManTest addrman;
+
+    CNetAddr source = ResolveIP("252.2.2.2");
+
+    // Test: Does Addrman respond correctly when empty.
+    BOOST_CHECK_EQUAL(addrman.size(), 0);
+    CAddrInfo addr_null = addrman.Select();
+    BOOST_CHECK_EQUAL(addr_null.ToString(), "[::]:0");
+
+    // Test: Does Addrman::Add work as expected.
+    CService addr1 = ResolveService("250.1.1.1", 8333);
+    BOOST_CHECK(addrman.Add(CAddress(addr1, NODE_NONE), source));
+    BOOST_CHECK_EQUAL(addrman.size(), 1);
+    CAddrInfo addr_ret1 = addrman.Select();
+    BOOST_CHECK_EQUAL(addr_ret1.ToString(), "250.1.1.1:8333");
+
+    // Test: Does IP address deduplication work correctly.
+    //  Expected dup IP should not be added.
+    CService addr1_dup = ResolveService("250.1.1.1", 8333);
+    BOOST_CHECK(!addrman.Add(CAddress(addr1_dup, NODE_NONE), source));
+    BOOST_CHECK_EQUAL(addrman.size(), 1);
+
+
+    // Test: New table has one addr and we add a diff addr we should
+    //  have at least one addr.
+    // Note that addrman's size cannot be tested reliably after insertion, as
+    // hash collisions may occur. But we can always be sure of at least one
+    // success.
+
+    CService addr2 = ResolveService("250.1.1.2", 8333);
+    BOOST_CHECK(addrman.Add(CAddress(addr2, NODE_NONE), source));
+    BOOST_CHECK(addrman.size() >= 1);
+
+    // Test: AddrMan::Clear() should empty the new table.
+    addrman.Clear();
+    BOOST_CHECK_EQUAL(addrman.size(), 0);
+    CAddrInfo addr_null2 = addrman.Select();
+    BOOST_CHECK_EQUAL(addr_null2.ToString(), "[::]:0");
+
+    // Test: AddrMan::Add multiple addresses works as expected
+    std::vector<CAddress> vAddr;
+    vAddr.push_back(CAddress(ResolveService("250.1.1.3", 8333), NODE_NONE));
+    vAddr.push_back(CAddress(ResolveService("250.1.1.4", 8333), NODE_NONE));
+    BOOST_CHECK(addrman.Add(vAddr, source));
+    BOOST_CHECK(addrman.size() >= 1);
+}
+
+BOOST_AUTO_TEST_CASE(addrman_ports)
+{
+    CAddrManTest addrman;
+
+    CNetAddr source = ResolveIP("252.2.2.2");
+
+    BOOST_CHECK_EQUAL(addrman.size(), 0);
+
+    // Test 7; Addr with same IP but diff port does not replace existing addr.
+    CService addr1 = ResolveService("250.1.1.1", 8333);
+    addrman.Add(CAddress(addr1, NODE_NONE), source);
+    BOOST_CHECK_EQUAL(addrman.size(), 1);
+
+    CService addr1_port = ResolveService("250.1.1.1", 8334);
+    addrman.Add(CAddress(addr1_port, NODE_NONE), source);
+    BOOST_CHECK_EQUAL(addrman.size(), 1);
+    CAddrInfo addr_ret2 = addrman.Select();
+    BOOST_CHECK_EQUAL(addr_ret2.ToString(), "250.1.1.1:8333");
+
+    // Test: Add same IP but diff port to tried table, it doesn't get added.
+    //  Perhaps this is not ideal behavior but it is the current behavior.
+    addrman.Good(CAddress(addr1_port, NODE_NONE));
+    BOOST_CHECK_EQUAL(addrman.size(), 1);
+    bool newOnly = true;
+    CAddrInfo addr_ret3 = addrman.Select(newOnly);
+    BOOST_CHECK_EQUAL(addr_ret3.ToString(), "250.1.1.1:8333");
+}
+
+
+BOOST_AUTO_TEST_CASE(addrman_select)
+{
+    CAddrManTest addrman;
+
+    CNetAddr source = ResolveIP("252.2.2.2");
+
+    // Test: Select from new with 1 addr in new.
+    CService addr1 = ResolveService("250.1.1.1", 8333);
+    addrman.Add(CAddress(addr1, NODE_NONE), source);
+    BOOST_CHECK_EQUAL(addrman.size(), 1);
+
+    bool newOnly = true;
+    CAddrInfo addr_ret1 = addrman.Select(newOnly);
+    BOOST_CHECK_EQUAL(addr_ret1.ToString(), "250.1.1.1:8333");
+
+    // Test: move addr to tried, select from new expected nothing returned.
+    addrman.Good(CAddress(addr1, NODE_NONE));
+    BOOST_CHECK_EQUAL(addrman.size(), 1);
+    CAddrInfo addr_ret2 = addrman.Select(newOnly);
+    BOOST_CHECK_EQUAL(addr_ret2.ToString(), "[::]:0");
+
+    CAddrInfo addr_ret3 = addrman.Select();
+    BOOST_CHECK_EQUAL(addr_ret3.ToString(), "250.1.1.1:8333");
+
+    BOOST_CHECK_EQUAL(addrman.size(), 1);
+
+
+    // Add three addresses to new table.
+    CService addr2 = ResolveService("250.3.1.1", 8333);
+    CService addr3 = ResolveService("250.3.2.2", 9999);
+    CService addr4 = ResolveService("250.3.3.3", 9999);
+
+    addrman.Add(CAddress(addr2, NODE_NONE), ResolveService("250.3.1.1", 8333));
+    addrman.Add(CAddress(addr3, NODE_NONE), ResolveService("250.3.1.1", 8333));
+    addrman.Add(CAddress(addr4, NODE_NONE), ResolveService("250.4.1.1", 8333));
+
+    // Add three addresses to tried table.
+    CService addr5 = ResolveService("250.4.4.4", 8333);
+    CService addr6 = ResolveService("250.4.5.5", 7777);
+    CService addr7 = ResolveService("250.4.6.6", 8333);
+
+    addrman.Add(CAddress(addr5, NODE_NONE), ResolveService("250.3.1.1", 8333));
+    addrman.Good(CAddress(addr5, NODE_NONE));
+    addrman.Add(CAddress(addr6, NODE_NONE), ResolveService("250.3.1.1", 8333));
+    addrman.Good(CAddress(addr6, NODE_NONE));
+    addrman.Add(CAddress(addr7, NODE_NONE), ResolveService("250.1.1.3", 8333));
+    addrman.Good(CAddress(addr7, NODE_NONE));
+
+    // Test: 6 addrs + 1 addr from last test = 7.
+    BOOST_CHECK_EQUAL(addrman.size(), 7);
+
+    // Test: Select pulls from new and tried regardless of port number.
+    std::set<uint16_t> ports;
+    for (int i = 0; i < 20; ++i) {
+        ports.insert(addrman.Select().GetPort());
+    }
+    BOOST_CHECK_EQUAL(ports.size(), 3);
+}
+
+BOOST_AUTO_TEST_CASE(addrman_new_collisions)
+{
+    CAddrManTest addrman;
+
+    CNetAddr source = ResolveIP("252.2.2.2");
+
+    BOOST_CHECK_EQUAL(addrman.size(), 0);
+
+    for (unsigned int i = 1; i < 18; i++) {
+        CService addr = ResolveService("250.1.1." + std::to_string(i));
+        addrman.Add(CAddress(addr, NODE_NONE), source);
+
+        //Test: No collision in new table yet.
+        BOOST_CHECK_EQUAL(addrman.size(), i);
+    }
+
+    //Test: new table collision!
+    CService addr1 = ResolveService("250.1.1.18");
+    addrman.Add(CAddress(addr1, NODE_NONE), source);
+    BOOST_CHECK_EQUAL(addrman.size(), 17);
+
+    CService addr2 = ResolveService("250.1.1.19");
+    addrman.Add(CAddress(addr2, NODE_NONE), source);
+    BOOST_CHECK_EQUAL(addrman.size(), 18);
+}
+
+BOOST_AUTO_TEST_CASE(addrman_tried_collisions)
+{
+    CAddrManTest addrman;
+
+    CNetAddr source = ResolveIP("252.2.2.2");
+
+    BOOST_CHECK_EQUAL(addrman.size(), 0);
+
+    for (unsigned int i = 1; i < 80; i++) {
+        CService addr = ResolveService("250.1.1." + std::to_string(i));
+        addrman.Add(CAddress(addr, NODE_NONE), source);
+        addrman.Good(CAddress(addr, NODE_NONE));
+
+        //Test: No collision in tried table yet.
+        BOOST_CHECK_EQUAL(addrman.size(), i);
+    }
+
+    //Test: tried table collision!
+    CService addr1 = ResolveService("250.1.1.80");
+    addrman.Add(CAddress(addr1, NODE_NONE), source);
+    BOOST_CHECK_EQUAL(addrman.size(), 79);
+
+    CService addr2 = ResolveService("250.1.1.81");
+    addrman.Add(CAddress(addr2, NODE_NONE), source);
+    BOOST_CHECK_EQUAL(addrman.size(), 80);
+}
+
+BOOST_AUTO_TEST_CASE(addrman_find)
+{
+    CAddrManTest addrman;
+
+    BOOST_CHECK_EQUAL(addrman.size(), 0);
+
+    CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
+    CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
+    CAddress addr3 = CAddress(ResolveService("251.255.2.1", 8333), NODE_NONE);
+
+    CNetAddr source1 = ResolveIP("250.1.2.1");
+    CNetAddr source2 = ResolveIP("250.1.2.2");
+
+    addrman.Add(addr1, source1);
+    addrman.Add(addr2, source2);
+    addrman.Add(addr3, source1);
+
+    // Test: ensure Find returns an IP matching what we searched on.
+    CAddrInfo* info1 = addrman.Find(addr1);
+    BOOST_REQUIRE(info1);
+    BOOST_CHECK_EQUAL(info1->ToString(), "250.1.2.1:8333");
+
+    // Test 18; Find does not discriminate by port number.
+    CAddrInfo* info2 = addrman.Find(addr2);
+    BOOST_REQUIRE(info2);
+    BOOST_CHECK_EQUAL(info2->ToString(), info1->ToString());
+
+    // Test: Find returns another IP matching what we searched on.
+    CAddrInfo* info3 = addrman.Find(addr3);
+    BOOST_REQUIRE(info3);
+    BOOST_CHECK_EQUAL(info3->ToString(), "251.255.2.1:8333");
+}
+
+BOOST_AUTO_TEST_CASE(addrman_create)
+{
+    CAddrManTest addrman;
+
+    BOOST_CHECK_EQUAL(addrman.size(), 0);
+
+    CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
+    CNetAddr source1 = ResolveIP("250.1.2.1");
+
+    int nId;
+    CAddrInfo* pinfo = addrman.Create(addr1, source1, &nId);
+
+    // Test: The result should be the same as the input addr.
+    BOOST_CHECK_EQUAL(pinfo->ToString(), "250.1.2.1:8333");
+
+    CAddrInfo* info2 = addrman.Find(addr1);
+    BOOST_CHECK_EQUAL(info2->ToString(), "250.1.2.1:8333");
+}
+
+
+BOOST_AUTO_TEST_CASE(addrman_delete)
+{
+    CAddrManTest addrman;
+
+    BOOST_CHECK_EQUAL(addrman.size(), 0);
+
+    CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
+    CNetAddr source1 = ResolveIP("250.1.2.1");
+
+    int nId;
+    addrman.Create(addr1, source1, &nId);
+
+    // Test: Delete should actually delete the addr.
+    BOOST_CHECK_EQUAL(addrman.size(), 1);
+    addrman.Delete(nId);
+    BOOST_CHECK_EQUAL(addrman.size(), 0);
+    CAddrInfo* info2 = addrman.Find(addr1);
+    BOOST_CHECK(info2 == nullptr);
+}
+
+BOOST_AUTO_TEST_CASE(addrman_getaddr)
+{
+    CAddrManTest addrman;
+
+    // Test: Sanity check, GetAddr should never return anything if addrman
+    //  is empty.
+    BOOST_CHECK_EQUAL(addrman.size(), 0);
+    std::vector<CAddress> vAddr1 = addrman.GetAddr();
+    BOOST_CHECK_EQUAL(vAddr1.size(), 0);
+
+    CAddress addr1 = CAddress(ResolveService("250.250.2.1", 8333), NODE_NONE);
+    addr1.nTime = GetAdjustedTime(); // Set time so isTerrible = false
+    CAddress addr2 = CAddress(ResolveService("250.251.2.2", 9999), NODE_NONE);
+    addr2.nTime = GetAdjustedTime();
+    CAddress addr3 = CAddress(ResolveService("251.252.2.3", 8333), NODE_NONE);
+    addr3.nTime = GetAdjustedTime();
+    CAddress addr4 = CAddress(ResolveService("252.253.3.4", 8333), NODE_NONE);
+    addr4.nTime = GetAdjustedTime();
+    CAddress addr5 = CAddress(ResolveService("252.254.4.5", 8333), NODE_NONE);
+    addr5.nTime = GetAdjustedTime();
+    CNetAddr source1 = ResolveIP("250.1.2.1");
+    CNetAddr source2 = ResolveIP("250.2.3.3");
+
+    // Test: Ensure GetAddr works with new addresses.
+    addrman.Add(addr1, source1);
+    addrman.Add(addr2, source2);
+    addrman.Add(addr3, source1);
+    addrman.Add(addr4, source2);
+    addrman.Add(addr5, source1);
+
+    // GetAddr returns 23% of addresses, 23% of 5 is 1 rounded down.
+    BOOST_CHECK_EQUAL(addrman.GetAddr().size(), 1);
+
+    // Test: Ensure GetAddr works with new and tried addresses.
+    addrman.Good(CAddress(addr1, NODE_NONE));
+    addrman.Good(CAddress(addr2, NODE_NONE));
+    BOOST_CHECK_EQUAL(addrman.GetAddr().size(), 1);
+
+    // Test: Ensure GetAddr still returns 23% when addrman has many addrs.
+    for (unsigned int i = 1; i < (8 * 256); i++) {
+        int octet1 = i % 256;
+        int octet2 = i >> 8 % 256;
+        std::string strAddr = std::to_string(octet1) + "." + std::to_string(octet2) + ".1.23";
+        CAddress addr = CAddress(ResolveService(strAddr), NODE_NONE);
+
+        // Ensure that for all addrs in addrman, isTerrible == false.
+        addr.nTime = GetAdjustedTime();
+        addrman.Add(addr, ResolveIP(strAddr));
+        if (i % 8 == 0)
+            addrman.Good(addr);
+    }
+    std::vector<CAddress> vAddr = addrman.GetAddr();
+
+    size_t percent23 = (addrman.size() * 23) / 100;
+    BOOST_CHECK_EQUAL(vAddr.size(), percent23);
+    BOOST_CHECK_EQUAL(vAddr.size(), 461);
+    // (Addrman.size() < number of addresses added) due to address collisions.
+    BOOST_CHECK_EQUAL(addrman.size(), 2006);
+}
+
+
+BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket)
+{
+    CAddrManTest addrman;
+
+    CAddress addr1 = CAddress(ResolveService("250.1.1.1", 8333), NODE_NONE);
+    CAddress addr2 = CAddress(ResolveService("250.1.1.1", 9999), NODE_NONE);
+
+    CNetAddr source1 = ResolveIP("250.1.1.1");
+
+
+    CAddrInfo info1 = CAddrInfo(addr1, source1);
+
+    uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
+    uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
+
+
+    BOOST_CHECK_EQUAL(info1.GetTriedBucket(nKey1), 40);
+
+    // Test: Make sure key actually randomizes bucket placement. A fail on
+    //  this test could be a security issue.
+    BOOST_CHECK(info1.GetTriedBucket(nKey1) != info1.GetTriedBucket(nKey2));
+
+    // Test: Two addresses with same IP but different ports can map to
+    //  different buckets because they have different keys.
+    CAddrInfo info2 = CAddrInfo(addr2, source1);
+
+    BOOST_CHECK(info1.GetKey() != info2.GetKey());
+    BOOST_CHECK(info1.GetTriedBucket(nKey1) != info2.GetTriedBucket(nKey1));
+
+    std::set<int> buckets;
+    for (int i = 0; i < 255; i++) {
+        CAddrInfo infoi = CAddrInfo(
+            CAddress(ResolveService("250.1.1." + std::to_string(i)), NODE_NONE),
+            ResolveIP("250.1.1." + std::to_string(i)));
+        int bucket = infoi.GetTriedBucket(nKey1);
+        buckets.insert(bucket);
+    }
+    // Test: IP addresses in the same group (\16 prefix for IPv4) should
+    //  never get more than 8 buckets
+    BOOST_CHECK_EQUAL(buckets.size(), 8);
+
+    buckets.clear();
+    for (int j = 0; j < 255; j++) {
+        CAddrInfo infoj = CAddrInfo(
+            CAddress(ResolveService("250." + std::to_string(j) + ".1.1"), NODE_NONE),
+            ResolveIP("250." + std::to_string(j) + ".1.1"));
+        int bucket = infoj.GetTriedBucket(nKey1);
+        buckets.insert(bucket);
+    }
+    // Test: IP addresses in the different groups should map to more than
+    //  8 buckets.
+    BOOST_CHECK_EQUAL(buckets.size(), 160);
+}
+
+BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket)
+{
+    CAddrManTest addrman;
+
+    CAddress addr1 = CAddress(ResolveService("250.1.2.1", 8333), NODE_NONE);
+    CAddress addr2 = CAddress(ResolveService("250.1.2.1", 9999), NODE_NONE);
+
+    CNetAddr source1 = ResolveIP("250.1.2.1");
+
+    CAddrInfo info1 = CAddrInfo(addr1, source1);
+
+    uint256 nKey1 = (uint256)(CHashWriter(SER_GETHASH, 0) << 1).GetHash();
+    uint256 nKey2 = (uint256)(CHashWriter(SER_GETHASH, 0) << 2).GetHash();
+
+    // Test: Make sure the buckets are what we expect
+    BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1), 786);
+    BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1, source1), 786);
+
+    // Test: Make sure key actually randomizes bucket placement. A fail on
+    //  this test could be a security issue.
+    BOOST_CHECK(info1.GetNewBucket(nKey1) != info1.GetNewBucket(nKey2));
+
+    // Test: Ports should not affect bucket placement in the addr
+    CAddrInfo info2 = CAddrInfo(addr2, source1);
+    BOOST_CHECK(info1.GetKey() != info2.GetKey());
+    BOOST_CHECK_EQUAL(info1.GetNewBucket(nKey1), info2.GetNewBucket(nKey1));
+
+    std::set<int> buckets;
+    for (int i = 0; i < 255; i++) {
+        CAddrInfo infoi = CAddrInfo(
+            CAddress(ResolveService("250.1.1." + std::to_string(i)), NODE_NONE),
+            ResolveIP("250.1.1." + std::to_string(i)));
+        int bucket = infoi.GetNewBucket(nKey1);
+        buckets.insert(bucket);
+    }
+    // Test: IP addresses in the same group (\16 prefix for IPv4) should
+    //  always map to the same bucket.
+    BOOST_CHECK_EQUAL(buckets.size(), 1);
+
+    buckets.clear();
+    for (int j = 0; j < 4 * 255; j++) {
+        CAddrInfo infoj = CAddrInfo(CAddress(
+                                        ResolveService(
+                                            std::to_string(250 + (j / 255)) + "." + std::to_string(j % 256) + ".1.1"), NODE_NONE),
+            ResolveIP("251.4.1.1"));
+        int bucket = infoj.GetNewBucket(nKey1);
+        buckets.insert(bucket);
+    }
+    // Test: IP addresses in the same source groups should map to no more
+    //  than 64 buckets.
+    BOOST_CHECK(buckets.size() <= 64);
+
+    buckets.clear();
+    for (int p = 0; p < 255; p++) {
+        CAddrInfo infoj = CAddrInfo(
+            CAddress(ResolveService("250.1.1.1"), NODE_NONE),
+            ResolveIP("250." + std::to_string(p) + ".1.1"));
+        int bucket = infoj.GetNewBucket(nKey1);
+        buckets.insert(bucket);
+    }
+    // Test: IP addresses in the different source groups should map to more
+    //  than 64 buckets.
+    BOOST_CHECK(buckets.size() > 64);
+}
+
+
+BOOST_AUTO_TEST_CASE(addrman_selecttriedcollision)
+{
+    CAddrManTest addrman;
+
+    // Set addrman addr placement to be deterministic.
+    addrman.MakeDeterministic();
+
+    BOOST_CHECK(addrman.size() == 0);
+
+    // Empty addrman should return blank addrman info.
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+
+    // Add twenty two addresses.
+    CNetAddr source = ResolveIP("252.2.2.2");
+    for (unsigned int i = 1; i < 23; i++) {
+        CService addr = ResolveService("250.1.1."+std::to_string(i));
+        addrman.Add(CAddress(addr, NODE_NONE), source);
+        addrman.Good(addr);
+
+        // No collisions yet.
+        BOOST_CHECK(addrman.size() == i);
+        BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+    }
+
+    // Ensure Good handles duplicates well.
+    for (unsigned int i = 1; i < 23; i++) {
+        CService addr = ResolveService("250.1.1."+std::to_string(i));
+        addrman.Good(addr);
+
+        BOOST_CHECK(addrman.size() == 22);
+        BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+    }
+
+}
+
+BOOST_AUTO_TEST_CASE(addrman_noevict)
+{
+    CAddrManTest addrman;
+
+    // Set addrman addr placement to be deterministic.
+    addrman.MakeDeterministic();
+
+    // Add twenty two addresses.
+    CNetAddr source = ResolveIP("252.2.2.2");
+    for (unsigned int i = 1; i < 23; i++) {
+        CService addr = ResolveService("250.1.1."+std::to_string(i));
+        addrman.Add(CAddress(addr, NODE_NONE), source);
+        addrman.Good(addr);
+
+        // No collision yet.
+        BOOST_CHECK(addrman.size() == i);
+        BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+    }
+
+    // Collision between 23 and 19.
+    CService addr23 = ResolveService("250.1.1.23");
+    addrman.Add(CAddress(addr23, NODE_NONE), source);
+    addrman.Good(addr23);
+
+    BOOST_CHECK(addrman.size() == 23);
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "250.1.1.19:0");
+
+    // 23 should be discarded and 19 not evicted.
+    addrman.ResolveCollisions();
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+
+    // Lets create two collisions.
+    for (unsigned int i = 24; i < 33; i++) {
+        CService addr = ResolveService("250.1.1."+std::to_string(i));
+        addrman.Add(CAddress(addr, NODE_NONE), source);
+        addrman.Good(addr);
+
+        BOOST_CHECK(addrman.size() == i);
+        BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+    }
+
+    // Cause a collision.
+    CService addr33 = ResolveService("250.1.1.33");
+    addrman.Add(CAddress(addr33, NODE_NONE), source);
+    addrman.Good(addr33);
+    BOOST_CHECK(addrman.size() == 33);
+
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "250.1.1.27:0");
+
+    // Cause a second collision.
+    addrman.Add(CAddress(addr23, NODE_NONE), source);
+    addrman.Good(addr23);
+    BOOST_CHECK(addrman.size() == 33);
+
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() != "[::]:0");
+    addrman.ResolveCollisions();
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+}
+
+BOOST_AUTO_TEST_CASE(addrman_evictionworks)
+{
+    CAddrManTest addrman;
+
+    // Set addrman addr placement to be deterministic.
+    addrman.MakeDeterministic();
+
+    BOOST_CHECK(addrman.size() == 0);
+
+    // Empty addrman should return blank addrman info.
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+
+    // Add twenty two addresses.
+    CNetAddr source = ResolveIP("252.2.2.2");
+    for (unsigned int i = 1; i < 23; i++) {
+        CService addr = ResolveService("250.1.1."+std::to_string(i));
+        addrman.Add(CAddress(addr, NODE_NONE), source);
+        addrman.Good(addr);
+
+        // No collision yet.
+        BOOST_CHECK(addrman.size() == i);
+        BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+    }
+
+    // Collision between 23 and 19.
+    CService addr = ResolveService("250.1.1.23");
+    addrman.Add(CAddress(addr, NODE_NONE), source);
+    addrman.Good(addr);
+
+    BOOST_CHECK(addrman.size() == 23);
+    CAddrInfo info = addrman.SelectTriedCollision();
+    BOOST_CHECK(info.ToString() == "250.1.1.19:0");
+
+    // Ensure test of address fails, so that it is evicted.
+    addrman.SimConnFail(info);
+
+    // Should swap 23 for 19.
+    addrman.ResolveCollisions();
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+
+    // If 23 was swapped for 19, then this should cause no collisions.
+    addrman.Add(CAddress(addr, NODE_NONE), source);
+    addrman.Good(addr);
+
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+
+    // If we insert 19 is should collide with 23.
+    CService addr19 = ResolveService("250.1.1.19");
+    addrman.Add(CAddress(addr19, NODE_NONE), source);
+    addrman.Good(addr19);
+
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "250.1.1.23:0");
+
+    addrman.ResolveCollisions();
+    BOOST_CHECK(addrman.SelectTriedCollision().ToString() == "[::]:0");
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/allocator_tests.cpp b/allocator_tests.cpp
new file mode 100644
index 0000000..3235f5a
--- /dev/null
+++ b/allocator_tests.cpp
@@ -0,0 +1,234 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <iostream>
+#include <util.h>
+#include <support/allocators/secure.h>
+#include <test/test_salemcash.h>
+#include <boost/test/unit_test.hpp>
+using namespace std;
+
+BOOST_FIXTURE_TEST_SUITE(allocator_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(arena_tests)
+{
+    // Fake memory base address for testing
+    // without actually using memory.
+    void *synth_base = reinterpret_cast<void*>(0x08000000);
+    const size_t synth_size = 1024*1024;
+    Arena b(synth_base, synth_size, 16);
+    void *chunk = b.alloc(1000);
+#ifdef ARENA_DEBUG
+    b.walk();
+#endif
+    BOOST_CHECK(chunk != nullptr);
+    BOOST_CHECK(b.stats().used == 1008); // Aligned to 16
+    BOOST_CHECK(b.stats().total == synth_size); // Nothing has disappeared?
+    b.free(chunk);
+#ifdef ARENA_DEBUG
+    b.walk();
+#endif
+    BOOST_CHECK(b.stats().used == 0);
+    BOOST_CHECK(b.stats().free == synth_size);
+    try { // Test exception on double-free
+        b.free(chunk);
+        BOOST_CHECK(0);
+    } catch(std::runtime_error &)
+    {
+    }
+
+    void *a0 = b.alloc(128);
+    void *a1 = b.alloc(256);
+    void *a2 = b.alloc(512);
+    BOOST_CHECK(b.stats().used == 896);
+    BOOST_CHECK(b.stats().total == synth_size);
+#ifdef ARENA_DEBUG
+    b.walk();
+#endif
+    b.free(a0);
+#ifdef ARENA_DEBUG
+    b.walk();
+#endif
+    BOOST_CHECK(b.stats().used == 768);
+    b.free(a1);
+    BOOST_CHECK(b.stats().used == 512);
+    void *a3 = b.alloc(128);
+#ifdef ARENA_DEBUG
+    b.walk();
+#endif
+    BOOST_CHECK(b.stats().used == 640);
+    b.free(a2);
+    BOOST_CHECK(b.stats().used == 128);
+    b.free(a3);
+    BOOST_CHECK(b.stats().used == 0);
+    BOOST_CHECK_EQUAL(b.stats().chunks_used, 0);
+    BOOST_CHECK(b.stats().total == synth_size);
+    BOOST_CHECK(b.stats().free == synth_size);
+    BOOST_CHECK_EQUAL(b.stats().chunks_free, 1);
+
+    std::vector<void*> addr;
+    BOOST_CHECK(b.alloc(0) == nullptr); // allocating 0 always returns nullptr
+#ifdef ARENA_DEBUG
+    b.walk();
+#endif
+    // Sweeping allocate all memory
+    for (int x=0; x<1024; ++x)
+        addr.push_back(b.alloc(1024));
+    BOOST_CHECK(b.stats().free == 0);
+    BOOST_CHECK(b.alloc(1024) == nullptr); // memory is full, this must return nullptr
+    BOOST_CHECK(b.alloc(0) == nullptr);
+    for (int x=0; x<1024; ++x)
+        b.free(addr[x]);
+    addr.clear();
+    BOOST_CHECK(b.stats().total == synth_size);
+    BOOST_CHECK(b.stats().free == synth_size);
+
+    // Now in the other direction...
+    for (int x=0; x<1024; ++x)
+        addr.push_back(b.alloc(1024));
+    for (int x=0; x<1024; ++x)
+        b.free(addr[1023-x]);
+    addr.clear();
+
+    // Now allocate in smaller unequal chunks, then deallocate haphazardly
+    // Not all the chunks will succeed allocating, but freeing nullptr is
+    // allowed so that is no problem.
+    for (int x=0; x<2048; ++x)
+        addr.push_back(b.alloc(x+1));
+    for (int x=0; x<2048; ++x)
+        b.free(addr[((x*23)%2048)^242]);
+    addr.clear();
+
+    // Go entirely wild: free and alloc interleaved,
+    // generate targets and sizes using pseudo-randomness.
+    for (int x=0; x<2048; ++x)
+        addr.push_back(0);
+    uint32_t s = 0x12345678;
+    for (int x=0; x<5000; ++x) {
+        int idx = s & (addr.size()-1);
+        if (s & 0x80000000) {
+            b.free(addr[idx]);
+            addr[idx] = 0;
+        } else if(!addr[idx]) {
+            addr[idx] = b.alloc((s >> 16) & 2047);
+        }
+        bool lsb = s & 1;
+        s >>= 1;
+        if (lsb)
+            s ^= 0xf00f00f0; // LFSR period 0xf7ffffe0
+    }
+    for (void *ptr: addr)
+        b.free(ptr);
+    addr.clear();
+
+    BOOST_CHECK(b.stats().total == synth_size);
+    BOOST_CHECK(b.stats().free == synth_size);
+}
+
+/** Mock LockedPageAllocator for testing */
+class TestLockedPageAllocator: public LockedPageAllocator
+{
+public:
+    TestLockedPageAllocator(int count_in, int lockedcount_in): count(count_in), lockedcount(lockedcount_in) {}
+    void* AllocateLocked(size_t len, bool *lockingSuccess) override
+    {
+        *lockingSuccess = false;
+        if (count > 0) {
+            --count;
+
+            if (lockedcount > 0) {
+                --lockedcount;
+                *lockingSuccess = true;
+            }
+
+            return reinterpret_cast<void*>(0x08000000 + (count<<24)); // Fake address, do not actually use this memory
+        }
+        return 0;
+    }
+    void FreeLocked(void* addr, size_t len) override
+    {
+    }
+    size_t GetLimit() override
+    {
+        return std::numeric_limits<size_t>::max();
+    }
+private:
+    int count;
+    int lockedcount;
+};
+
+BOOST_AUTO_TEST_CASE(lockedpool_tests_mock)
+{
+    // Test over three virtual arenas, of which one will succeed being locked
+    std::unique_ptr<LockedPageAllocator> x(new TestLockedPageAllocator(3, 1));
+    LockedPool pool(std::move(x));
+    BOOST_CHECK(pool.stats().total == 0);
+    BOOST_CHECK(pool.stats().locked == 0);
+
+    // Ensure unreasonable requests are refused without allocating anything
+    void *invalid_toosmall = pool.alloc(0);
+    BOOST_CHECK(invalid_toosmall == nullptr);
+    BOOST_CHECK(pool.stats().used == 0);
+    BOOST_CHECK(pool.stats().free == 0);
+    void *invalid_toobig = pool.alloc(LockedPool::ARENA_SIZE+1);
+    BOOST_CHECK(invalid_toobig == nullptr);
+    BOOST_CHECK(pool.stats().used == 0);
+    BOOST_CHECK(pool.stats().free == 0);
+
+    void *a0 = pool.alloc(LockedPool::ARENA_SIZE / 2);
+    BOOST_CHECK(a0);
+    BOOST_CHECK(pool.stats().locked == LockedPool::ARENA_SIZE);
+    void *a1 = pool.alloc(LockedPool::ARENA_SIZE / 2);
+    BOOST_CHECK(a1);
+    void *a2 = pool.alloc(LockedPool::ARENA_SIZE / 2);
+    BOOST_CHECK(a2);
+    void *a3 = pool.alloc(LockedPool::ARENA_SIZE / 2);
+    BOOST_CHECK(a3);
+    void *a4 = pool.alloc(LockedPool::ARENA_SIZE / 2);
+    BOOST_CHECK(a4);
+    void *a5 = pool.alloc(LockedPool::ARENA_SIZE / 2);
+    BOOST_CHECK(a5);
+    // We've passed a count of three arenas, so this allocation should fail
+    void *a6 = pool.alloc(16);
+    BOOST_CHECK(!a6);
+
+    pool.free(a0);
+    pool.free(a2);
+    pool.free(a4);
+    pool.free(a1);
+    pool.free(a3);
+    pool.free(a5);
+    BOOST_CHECK(pool.stats().total == 3*LockedPool::ARENA_SIZE);
+    BOOST_CHECK(pool.stats().locked == LockedPool::ARENA_SIZE);
+    BOOST_CHECK(pool.stats().used == 0);
+}
+
+// These tests used the live LockedPoolManager object, this is also used
+// by other tests so the conditions are somewhat less controllable and thus the
+// tests are somewhat more error-prone.
+BOOST_AUTO_TEST_CASE(lockedpool_tests_live)
+{
+    LockedPoolManager &pool = LockedPoolManager::Instance();
+    LockedPool::Stats initial = pool.stats();
+
+    void *a0 = pool.alloc(16);
+    BOOST_CHECK(a0);
+    // Test reading and writing the allocated memory
+    *((uint32_t*)a0) = 0x1234;
+    BOOST_CHECK(*((uint32_t*)a0) == 0x1234);
+
+    pool.free(a0);
+    try { // Test exception on double-free
+        pool.free(a0);
+        BOOST_CHECK(0);
+    } catch(std::runtime_error &)
+    {
+    }
+    // If more than one new arena was allocated for the above tests, something is wrong
+    BOOST_CHECK(pool.stats().total <= (initial.total + LockedPool::ARENA_SIZE));
+    // Usage must be back to where it started
+    BOOST_CHECK(pool.stats().used == initial.used);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/amount_tests.cpp b/amount_tests.cpp
new file mode 100644
index 0000000..5002d6a
--- /dev/null
+++ b/amount_tests.cpp
@@ -0,0 +1,108 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <amount.h>
+#include <policy/feerate.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(amount_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(MoneyRangeTest)
+{
+    BOOST_CHECK_EQUAL(MoneyRange(CAmount(-1)), false);
+    BOOST_CHECK_EQUAL(MoneyRange(MAX_MONEY + CAmount(1)), false);
+    BOOST_CHECK_EQUAL(MoneyRange(CAmount(1)), true);
+}
+
+BOOST_AUTO_TEST_CASE(GetFeeTest)
+{
+    CFeeRate feeRate, altFeeRate;
+
+    feeRate = CFeeRate(0);
+    // Must always return 0
+    BOOST_CHECK_EQUAL(feeRate.GetFee(0), 0);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(1e5), 0);
+
+    feeRate = CFeeRate(1000);
+    // Must always just return the arg
+    BOOST_CHECK_EQUAL(feeRate.GetFee(0), 0);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(1), 1);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(121), 121);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(999), 999);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(1e3), 1e3);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(9e3), 9e3);
+
+    feeRate = CFeeRate(-1000);
+    // Must always just return -1 * arg
+    BOOST_CHECK_EQUAL(feeRate.GetFee(0), 0);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(1), -1);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(121), -121);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(999), -999);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(1e3), -1e3);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(9e3), -9e3);
+
+    feeRate = CFeeRate(123);
+    // Truncates the result, if not integer
+    BOOST_CHECK_EQUAL(feeRate.GetFee(0), 0);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(8), 1); // Special case: returns 1 instead of 0
+    BOOST_CHECK_EQUAL(feeRate.GetFee(9), 1);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(121), 14);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(122), 15);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(999), 122);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(1e3), 123);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(9e3), 1107);
+
+    feeRate = CFeeRate(-123);
+    // Truncates the result, if not integer
+    BOOST_CHECK_EQUAL(feeRate.GetFee(0), 0);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(8), -1); // Special case: returns -1 instead of 0
+    BOOST_CHECK_EQUAL(feeRate.GetFee(9), -1);
+
+    // check alternate constructor
+    feeRate = CFeeRate(1000);
+    altFeeRate = CFeeRate(feeRate);
+    BOOST_CHECK_EQUAL(feeRate.GetFee(100), altFeeRate.GetFee(100));
+
+    // Check full constructor
+    // default value
+    BOOST_CHECK(CFeeRate(CAmount(-1), 1000) == CFeeRate(-1));
+    BOOST_CHECK(CFeeRate(CAmount(0), 1000) == CFeeRate(0));
+    BOOST_CHECK(CFeeRate(CAmount(1), 1000) == CFeeRate(1));
+    // lost precision (can only resolve satoshis per kB)
+    BOOST_CHECK(CFeeRate(CAmount(1), 1001) == CFeeRate(0));
+    BOOST_CHECK(CFeeRate(CAmount(2), 1001) == CFeeRate(1));
+    // some more integer checks
+    BOOST_CHECK(CFeeRate(CAmount(26), 789) == CFeeRate(32));
+    BOOST_CHECK(CFeeRate(CAmount(27), 789) == CFeeRate(34));
+    // Maximum size in bytes, should not crash
+    CFeeRate(MAX_MONEY, std::numeric_limits<size_t>::max() >> 1).GetFeePerK();
+}
+
+BOOST_AUTO_TEST_CASE(BinaryOperatorTest)
+{
+    CFeeRate a, b;
+    a = CFeeRate(1);
+    b = CFeeRate(2);
+    BOOST_CHECK(a < b);
+    BOOST_CHECK(b > a);
+    BOOST_CHECK(a == a);
+    BOOST_CHECK(a <= b);
+    BOOST_CHECK(a <= a);
+    BOOST_CHECK(b >= a);
+    BOOST_CHECK(b >= b);
+    // a should be 0.00000002 SCS/kB now
+    a += a;
+    BOOST_CHECK(a == b);
+}
+
+BOOST_AUTO_TEST_CASE(ToStringTest)
+{
+    CFeeRate feeRate;
+    feeRate = CFeeRate(1);
+    BOOST_CHECK_EQUAL(feeRate.ToString(), "0.00000001 SCS/kB");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/arith_uint256_tests.cpp b/arith_uint256_tests.cpp
new file mode 100644
index 0000000..291eca2
--- /dev/null
+++ b/arith_uint256_tests.cpp
@@ -0,0 +1,567 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <boost/test/unit_test.hpp>
+#include <stdint.h>
+#include <sstream>
+#include <iomanip>
+#include <limits>
+#include <cmath>
+#include <uint256.h>
+#include <arith_uint256.h>
+#include <string>
+#include <version.h>
+#include <test/test_salemcash.h>
+
+BOOST_FIXTURE_TEST_SUITE(arith_uint256_tests, BasicTestingSetup)
+
+/// Convert vector to arith_uint256, via uint256 blob
+inline arith_uint256 arith_uint256V(const std::vector<unsigned char>& vch)
+{
+    return UintToArith256(uint256(vch));
+}
+
+const unsigned char R1Array[] =
+    "\x9c\x52\x4a\xdb\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
+    "\x22\x81\xaa\xb5\x33\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d";
+const char R1ArrayHex[] = "7D1DE5EAF9B156D53208F033B5AA8122D2d2355d5e12292b121156cfdb4a529c";
+const double R1Ldouble = 0.4887374590559308955; // R1L equals roughly R1Ldouble * 2^256
+const arith_uint256 R1L = arith_uint256V(std::vector<unsigned char>(R1Array,R1Array+32));
+const uint64_t R1LLow64 = 0x121156cfdb4a529cULL;
+
+const unsigned char R2Array[] =
+    "\x70\x32\x1d\x7c\x47\xa5\x6b\x40\x26\x7e\x0a\xc3\xa6\x9c\xb6\xbf"
+    "\x13\x30\x47\xa3\x19\x2d\xda\x71\x49\x13\x72\xf0\xb4\xca\x81\xd7";
+const arith_uint256 R2L = arith_uint256V(std::vector<unsigned char>(R2Array,R2Array+32));
+
+const char R1LplusR2L[] = "549FB09FEA236A1EA3E31D4D58F1B1369288D204211CA751527CFC175767850C";
+
+const unsigned char ZeroArray[] =
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
+const arith_uint256 ZeroL = arith_uint256V(std::vector<unsigned char>(ZeroArray,ZeroArray+32));
+
+const unsigned char OneArray[] =
+    "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
+const arith_uint256 OneL = arith_uint256V(std::vector<unsigned char>(OneArray,OneArray+32));
+
+const unsigned char MaxArray[] =
+    "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+    "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
+const arith_uint256 MaxL = arith_uint256V(std::vector<unsigned char>(MaxArray,MaxArray+32));
+
+const arith_uint256 HalfL = (OneL << 255);
+std::string ArrayToString(const unsigned char A[], unsigned int width)
+{
+    std::stringstream Stream;
+    Stream << std::hex;
+    for (unsigned int i = 0; i < width; ++i)
+    {
+        Stream<<std::setw(2)<<std::setfill('0')<<(unsigned int)A[width-i-1];
+    }
+    return Stream.str();
+}
+
+BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
+{
+    BOOST_CHECK(1 == 0+1);
+    // constructor arith_uint256(vector<char>):
+    BOOST_CHECK(R1L.ToString() == ArrayToString(R1Array,32));
+    BOOST_CHECK(R2L.ToString() == ArrayToString(R2Array,32));
+    BOOST_CHECK(ZeroL.ToString() == ArrayToString(ZeroArray,32));
+    BOOST_CHECK(OneL.ToString() == ArrayToString(OneArray,32));
+    BOOST_CHECK(MaxL.ToString() == ArrayToString(MaxArray,32));
+    BOOST_CHECK(OneL.ToString() != ArrayToString(ZeroArray,32));
+
+    // == and !=
+    BOOST_CHECK(R1L != R2L);
+    BOOST_CHECK(ZeroL != OneL);
+    BOOST_CHECK(OneL != ZeroL);
+    BOOST_CHECK(MaxL != ZeroL);
+    BOOST_CHECK(~MaxL == ZeroL);
+    BOOST_CHECK( ((R1L ^ R2L) ^ R1L) == R2L);
+
+    uint64_t Tmp64 = 0xc4dab720d9c7acaaULL;
+    for (unsigned int i = 0; i < 256; ++i)
+    {
+        BOOST_CHECK(ZeroL != (OneL << i));
+        BOOST_CHECK((OneL << i) != ZeroL);
+        BOOST_CHECK(R1L != (R1L ^ (OneL << i)));
+        BOOST_CHECK(((arith_uint256(Tmp64) ^ (OneL << i) ) != Tmp64 ));
+    }
+    BOOST_CHECK(ZeroL == (OneL << 256));
+
+    // String Constructor and Copy Constructor
+    BOOST_CHECK(arith_uint256("0x"+R1L.ToString()) == R1L);
+    BOOST_CHECK(arith_uint256("0x"+R2L.ToString()) == R2L);
+    BOOST_CHECK(arith_uint256("0x"+ZeroL.ToString()) == ZeroL);
+    BOOST_CHECK(arith_uint256("0x"+OneL.ToString()) == OneL);
+    BOOST_CHECK(arith_uint256("0x"+MaxL.ToString()) == MaxL);
+    BOOST_CHECK(arith_uint256(R1L.ToString()) == R1L);
+    BOOST_CHECK(arith_uint256("   0x"+R1L.ToString()+"   ") == R1L);
+    BOOST_CHECK(arith_uint256("") == ZeroL);
+    BOOST_CHECK(R1L == arith_uint256(R1ArrayHex));
+    BOOST_CHECK(arith_uint256(R1L) == R1L);
+    BOOST_CHECK((arith_uint256(R1L^R2L)^R2L) == R1L);
+    BOOST_CHECK(arith_uint256(ZeroL) == ZeroL);
+    BOOST_CHECK(arith_uint256(OneL) == OneL);
+
+    // uint64_t constructor
+    BOOST_CHECK( (R1L & arith_uint256("0xffffffffffffffff")) == arith_uint256(R1LLow64));
+    BOOST_CHECK(ZeroL == arith_uint256(0));
+    BOOST_CHECK(OneL == arith_uint256(1));
+    BOOST_CHECK(arith_uint256("0xffffffffffffffff") == arith_uint256(0xffffffffffffffffULL));
+
+    // Assignment (from base_uint)
+    arith_uint256 tmpL = ~ZeroL; BOOST_CHECK(tmpL == ~ZeroL);
+    tmpL = ~OneL; BOOST_CHECK(tmpL == ~OneL);
+    tmpL = ~R1L; BOOST_CHECK(tmpL == ~R1L);
+    tmpL = ~R2L; BOOST_CHECK(tmpL == ~R2L);
+    tmpL = ~MaxL; BOOST_CHECK(tmpL == ~MaxL);
+}
+
+void shiftArrayRight(unsigned char* to, const unsigned char* from, unsigned int arrayLength, unsigned int bitsToShift)
+{
+    for (unsigned int T=0; T < arrayLength; ++T)
+    {
+        unsigned int F = (T+bitsToShift/8);
+        if (F < arrayLength)
+            to[T]  = from[F] >> (bitsToShift%8);
+        else
+            to[T] = 0;
+        if (F + 1 < arrayLength)
+            to[T] |= from[(F+1)] << (8-bitsToShift%8);
+    }
+}
+
+void shiftArrayLeft(unsigned char* to, const unsigned char* from, unsigned int arrayLength, unsigned int bitsToShift)
+{
+    for (unsigned int T=0; T < arrayLength; ++T)
+    {
+        if (T >= bitsToShift/8)
+        {
+            unsigned int F = T-bitsToShift/8;
+            to[T]  = from[F] << (bitsToShift%8);
+            if (T >= bitsToShift/8+1)
+                to[T] |= from[F-1] >> (8-bitsToShift%8);
+        }
+        else {
+            to[T] = 0;
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE( shifts ) { // "<<"  ">>"  "<<="  ">>="
+    unsigned char TmpArray[32];
+    arith_uint256 TmpL;
+    for (unsigned int i = 0; i < 256; ++i)
+    {
+        shiftArrayLeft(TmpArray, OneArray, 32, i);
+        BOOST_CHECK(arith_uint256V(std::vector<unsigned char>(TmpArray,TmpArray+32)) == (OneL << i));
+        TmpL = OneL; TmpL <<= i;
+        BOOST_CHECK(TmpL == (OneL << i));
+        BOOST_CHECK((HalfL >> (255-i)) == (OneL << i));
+        TmpL = HalfL; TmpL >>= (255-i);
+        BOOST_CHECK(TmpL == (OneL << i));
+
+        shiftArrayLeft(TmpArray, R1Array, 32, i);
+        BOOST_CHECK(arith_uint256V(std::vector<unsigned char>(TmpArray,TmpArray+32)) == (R1L << i));
+        TmpL = R1L; TmpL <<= i;
+        BOOST_CHECK(TmpL == (R1L << i));
+
+        shiftArrayRight(TmpArray, R1Array, 32, i);
+        BOOST_CHECK(arith_uint256V(std::vector<unsigned char>(TmpArray,TmpArray+32)) == (R1L >> i));
+        TmpL = R1L; TmpL >>= i;
+        BOOST_CHECK(TmpL == (R1L >> i));
+
+        shiftArrayLeft(TmpArray, MaxArray, 32, i);
+        BOOST_CHECK(arith_uint256V(std::vector<unsigned char>(TmpArray,TmpArray+32)) == (MaxL << i));
+        TmpL = MaxL; TmpL <<= i;
+        BOOST_CHECK(TmpL == (MaxL << i));
+
+        shiftArrayRight(TmpArray, MaxArray, 32, i);
+        BOOST_CHECK(arith_uint256V(std::vector<unsigned char>(TmpArray,TmpArray+32)) == (MaxL >> i));
+        TmpL = MaxL; TmpL >>= i;
+        BOOST_CHECK(TmpL == (MaxL >> i));
+    }
+    arith_uint256 c1L = arith_uint256(0x0123456789abcdefULL);
+    arith_uint256 c2L = c1L << 128;
+    for (unsigned int i = 0; i < 128; ++i) {
+        BOOST_CHECK((c1L << i) == (c2L >> (128-i)));
+    }
+    for (unsigned int i = 128; i < 256; ++i) {
+        BOOST_CHECK((c1L << i) == (c2L << (i-128)));
+    }
+}
+
+BOOST_AUTO_TEST_CASE( unaryOperators ) // !    ~    -
+{
+    BOOST_CHECK(!ZeroL);
+    BOOST_CHECK(!(!OneL));
+    for (unsigned int i = 0; i < 256; ++i)
+        BOOST_CHECK(!(!(OneL<<i)));
+    BOOST_CHECK(!(!R1L));
+    BOOST_CHECK(!(!MaxL));
+
+    BOOST_CHECK(~ZeroL == MaxL);
+
+    unsigned char TmpArray[32];
+    for (unsigned int i = 0; i < 32; ++i) { TmpArray[i] = ~R1Array[i]; }
+    BOOST_CHECK(arith_uint256V(std::vector<unsigned char>(TmpArray,TmpArray+32)) == (~R1L));
+
+    BOOST_CHECK(-ZeroL == ZeroL);
+    BOOST_CHECK(-R1L == (~R1L)+1);
+    for (unsigned int i = 0; i < 256; ++i)
+        BOOST_CHECK(-(OneL<<i) == (MaxL << i));
+}
+
+
+// Check if doing _A_ _OP_ _B_ results in the same as applying _OP_ onto each
+// element of Aarray and Barray, and then converting the result into an arith_uint256.
+#define CHECKBITWISEOPERATOR(_A_,_B_,_OP_)                              \
+    for (unsigned int i = 0; i < 32; ++i) { TmpArray[i] = _A_##Array[i] _OP_ _B_##Array[i]; } \
+    BOOST_CHECK(arith_uint256V(std::vector<unsigned char>(TmpArray,TmpArray+32)) == (_A_##L _OP_ _B_##L));
+
+#define CHECKASSIGNMENTOPERATOR(_A_,_B_,_OP_)                           \
+    TmpL = _A_##L; TmpL _OP_##= _B_##L; BOOST_CHECK(TmpL == (_A_##L _OP_ _B_##L));
+
+BOOST_AUTO_TEST_CASE( bitwiseOperators )
+{
+    unsigned char TmpArray[32];
+
+    CHECKBITWISEOPERATOR(R1,R2,|)
+    CHECKBITWISEOPERATOR(R1,R2,^)
+    CHECKBITWISEOPERATOR(R1,R2,&)
+    CHECKBITWISEOPERATOR(R1,Zero,|)
+    CHECKBITWISEOPERATOR(R1,Zero,^)
+    CHECKBITWISEOPERATOR(R1,Zero,&)
+    CHECKBITWISEOPERATOR(R1,Max,|)
+    CHECKBITWISEOPERATOR(R1,Max,^)
+    CHECKBITWISEOPERATOR(R1,Max,&)
+    CHECKBITWISEOPERATOR(Zero,R1,|)
+    CHECKBITWISEOPERATOR(Zero,R1,^)
+    CHECKBITWISEOPERATOR(Zero,R1,&)
+    CHECKBITWISEOPERATOR(Max,R1,|)
+    CHECKBITWISEOPERATOR(Max,R1,^)
+    CHECKBITWISEOPERATOR(Max,R1,&)
+
+    arith_uint256 TmpL;
+    CHECKASSIGNMENTOPERATOR(R1,R2,|)
+    CHECKASSIGNMENTOPERATOR(R1,R2,^)
+    CHECKASSIGNMENTOPERATOR(R1,R2,&)
+    CHECKASSIGNMENTOPERATOR(R1,Zero,|)
+    CHECKASSIGNMENTOPERATOR(R1,Zero,^)
+    CHECKASSIGNMENTOPERATOR(R1,Zero,&)
+    CHECKASSIGNMENTOPERATOR(R1,Max,|)
+    CHECKASSIGNMENTOPERATOR(R1,Max,^)
+    CHECKASSIGNMENTOPERATOR(R1,Max,&)
+    CHECKASSIGNMENTOPERATOR(Zero,R1,|)
+    CHECKASSIGNMENTOPERATOR(Zero,R1,^)
+    CHECKASSIGNMENTOPERATOR(Zero,R1,&)
+    CHECKASSIGNMENTOPERATOR(Max,R1,|)
+    CHECKASSIGNMENTOPERATOR(Max,R1,^)
+    CHECKASSIGNMENTOPERATOR(Max,R1,&)
+
+    uint64_t Tmp64 = 0xe1db685c9a0b47a2ULL;
+    TmpL = R1L; TmpL |= Tmp64;  BOOST_CHECK(TmpL == (R1L | arith_uint256(Tmp64)));
+    TmpL = R1L; TmpL |= 0; BOOST_CHECK(TmpL == R1L);
+    TmpL ^= 0; BOOST_CHECK(TmpL == R1L);
+    TmpL ^= Tmp64;  BOOST_CHECK(TmpL == (R1L ^ arith_uint256(Tmp64)));
+}
+
+BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
+{
+    arith_uint256 TmpL;
+    for (unsigned int i = 0; i < 256; ++i) {
+        TmpL= OneL<< i;
+        BOOST_CHECK( TmpL >= ZeroL && TmpL > ZeroL && ZeroL < TmpL && ZeroL <= TmpL);
+        BOOST_CHECK( TmpL >= 0 && TmpL > 0 && 0 < TmpL && 0 <= TmpL);
+        TmpL |= R1L;
+        BOOST_CHECK( TmpL >= R1L ); BOOST_CHECK( (TmpL == R1L) != (TmpL > R1L)); BOOST_CHECK( (TmpL == R1L) || !( TmpL <= R1L));
+        BOOST_CHECK( R1L <= TmpL ); BOOST_CHECK( (R1L == TmpL) != (R1L < TmpL)); BOOST_CHECK( (TmpL == R1L) || !( R1L >= TmpL));
+        BOOST_CHECK(! (TmpL < R1L)); BOOST_CHECK(! (R1L > TmpL));
+    }
+}
+
+BOOST_AUTO_TEST_CASE( plusMinus )
+{
+    arith_uint256 TmpL = 0;
+    BOOST_CHECK(R1L+R2L == arith_uint256(R1LplusR2L));
+    TmpL += R1L;
+    BOOST_CHECK(TmpL == R1L);
+    TmpL += R2L;
+    BOOST_CHECK(TmpL == R1L + R2L);
+    BOOST_CHECK(OneL+MaxL == ZeroL);
+    BOOST_CHECK(MaxL+OneL == ZeroL);
+    for (unsigned int i = 1; i < 256; ++i) {
+        BOOST_CHECK( (MaxL >> i) + OneL == (HalfL >> (i-1)) );
+        BOOST_CHECK( OneL + (MaxL >> i) == (HalfL >> (i-1)) );
+        TmpL = (MaxL>>i); TmpL += OneL;
+        BOOST_CHECK( TmpL == (HalfL >> (i-1)) );
+        TmpL = (MaxL>>i); TmpL += 1;
+        BOOST_CHECK( TmpL == (HalfL >> (i-1)) );
+        TmpL = (MaxL>>i);
+        BOOST_CHECK( TmpL++ == (MaxL>>i) );
+        BOOST_CHECK( TmpL == (HalfL >> (i-1)));
+    }
+    BOOST_CHECK(arith_uint256(0xbedc77e27940a7ULL) + 0xee8d836fce66fbULL == arith_uint256(0xbedc77e27940a7ULL + 0xee8d836fce66fbULL));
+    TmpL = arith_uint256(0xbedc77e27940a7ULL); TmpL += 0xee8d836fce66fbULL;
+    BOOST_CHECK(TmpL == arith_uint256(0xbedc77e27940a7ULL+0xee8d836fce66fbULL));
+    TmpL -= 0xee8d836fce66fbULL;  BOOST_CHECK(TmpL == 0xbedc77e27940a7ULL);
+    TmpL = R1L;
+    BOOST_CHECK(++TmpL == R1L+1);
+
+    BOOST_CHECK(R1L -(-R2L) == R1L+R2L);
+    BOOST_CHECK(R1L -(-OneL) == R1L+OneL);
+    BOOST_CHECK(R1L - OneL == R1L+(-OneL));
+    for (unsigned int i = 1; i < 256; ++i) {
+        BOOST_CHECK((MaxL>>i) - (-OneL)  == (HalfL >> (i-1)));
+        BOOST_CHECK((HalfL >> (i-1)) - OneL == (MaxL>>i));
+        TmpL = (HalfL >> (i-1));
+        BOOST_CHECK(TmpL-- == (HalfL >> (i-1)));
+        BOOST_CHECK(TmpL == (MaxL >> i));
+        TmpL = (HalfL >> (i-1));
+        BOOST_CHECK(--TmpL == (MaxL >> i));
+    }
+    TmpL = R1L;
+    BOOST_CHECK(--TmpL == R1L-1);
+}
+
+BOOST_AUTO_TEST_CASE( multiply )
+{
+    BOOST_CHECK((R1L * R1L).ToString() == "62a38c0486f01e45879d7910a7761bf30d5237e9873f9bff3642a732c4d84f10");
+    BOOST_CHECK((R1L * R2L).ToString() == "de37805e9986996cfba76ff6ba51c008df851987d9dd323f0e5de07760529c40");
+    BOOST_CHECK((R1L * ZeroL) == ZeroL);
+    BOOST_CHECK((R1L * OneL) == R1L);
+    BOOST_CHECK((R1L * MaxL) == -R1L);
+    BOOST_CHECK((R2L * R1L) == (R1L * R2L));
+    BOOST_CHECK((R2L * R2L).ToString() == "ac8c010096767d3cae5005dec28bb2b45a1d85ab7996ccd3e102a650f74ff100");
+    BOOST_CHECK((R2L * ZeroL) == ZeroL);
+    BOOST_CHECK((R2L * OneL) == R2L);
+    BOOST_CHECK((R2L * MaxL) == -R2L);
+
+    BOOST_CHECK(MaxL * MaxL == OneL);
+
+    BOOST_CHECK((R1L * 0) == 0);
+    BOOST_CHECK((R1L * 1) == R1L);
+    BOOST_CHECK((R1L * 3).ToString() == "7759b1c0ed14047f961ad09b20ff83687876a0181a367b813634046f91def7d4");
+    BOOST_CHECK((R2L * 0x87654321UL).ToString() == "23f7816e30c4ae2017257b7a0fa64d60402f5234d46e746b61c960d09a26d070");
+}
+
+BOOST_AUTO_TEST_CASE( divide )
+{
+    arith_uint256 D1L("AD7133AC1977FA2B7");
+    arith_uint256 D2L("ECD751716");
+    BOOST_CHECK((R1L / D1L).ToString() == "00000000000000000b8ac01106981635d9ed112290f8895545a7654dde28fb3a");
+    BOOST_CHECK((R1L / D2L).ToString() == "000000000873ce8efec5b67150bad3aa8c5fcb70e947586153bf2cec7c37c57a");
+    BOOST_CHECK(R1L / OneL == R1L);
+    BOOST_CHECK(R1L / MaxL == ZeroL);
+    BOOST_CHECK(MaxL / R1L == 2);
+    BOOST_CHECK_THROW(R1L / ZeroL, uint_error);
+    BOOST_CHECK((R2L / D1L).ToString() == "000000000000000013e1665895a1cc981de6d93670105a6b3ec3b73141b3a3c5");
+    BOOST_CHECK((R2L / D2L).ToString() == "000000000e8f0abe753bb0afe2e9437ee85d280be60882cf0bd1aaf7fa3cc2c4");
+    BOOST_CHECK(R2L / OneL == R2L);
+    BOOST_CHECK(R2L / MaxL == ZeroL);
+    BOOST_CHECK(MaxL / R2L == 1);
+    BOOST_CHECK_THROW(R2L / ZeroL, uint_error);
+}
+
+
+bool almostEqual(double d1, double d2)
+{
+    return fabs(d1-d2) <= 4*fabs(d1)*std::numeric_limits<double>::epsilon();
+}
+
+BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex size() GetLow64 GetSerializeSize, Serialize, Unserialize
+{
+    BOOST_CHECK(R1L.GetHex() == R1L.ToString());
+    BOOST_CHECK(R2L.GetHex() == R2L.ToString());
+    BOOST_CHECK(OneL.GetHex() == OneL.ToString());
+    BOOST_CHECK(MaxL.GetHex() == MaxL.ToString());
+    arith_uint256 TmpL(R1L);
+    BOOST_CHECK(TmpL == R1L);
+    TmpL.SetHex(R2L.ToString());   BOOST_CHECK(TmpL == R2L);
+    TmpL.SetHex(ZeroL.ToString()); BOOST_CHECK(TmpL == 0);
+    TmpL.SetHex(HalfL.ToString()); BOOST_CHECK(TmpL == HalfL);
+
+    TmpL.SetHex(R1L.ToString());
+    BOOST_CHECK(R1L.size() == 32);
+    BOOST_CHECK(R2L.size() == 32);
+    BOOST_CHECK(ZeroL.size() == 32);
+    BOOST_CHECK(MaxL.size() == 32);
+    BOOST_CHECK(R1L.GetLow64()  == R1LLow64);
+    BOOST_CHECK(HalfL.GetLow64() ==0x0000000000000000ULL);
+    BOOST_CHECK(OneL.GetLow64() ==0x0000000000000001ULL);
+
+    for (unsigned int i = 0; i < 255; ++i)
+    {
+        BOOST_CHECK((OneL << i).getdouble() == ldexp(1.0,i));
+    }
+    BOOST_CHECK(ZeroL.getdouble() == 0.0);
+    for (int i = 256; i > 53; --i)
+        BOOST_CHECK(almostEqual((R1L>>(256-i)).getdouble(), ldexp(R1Ldouble,i)));
+    uint64_t R1L64part = (R1L>>192).GetLow64();
+    for (int i = 53; i > 0; --i) // doubles can store all integers in {0,...,2^54-1} exactly
+    {
+        BOOST_CHECK((R1L>>(256-i)).getdouble() == (double)(R1L64part >> (64-i)));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(bignum_SetCompact)
+{
+    arith_uint256 num;
+    bool fNegative;
+    bool fOverflow;
+    num.SetCompact(0, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x00123456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x01003456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x02000056, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x03000000, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x04000000, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x00923456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x01803456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x02800056, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x03800000, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x04800000, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x01123456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000012");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x01120000U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    // Make sure that we don't generate compacts with the 0x00800000 bit set
+    num = 0x80;
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x02008000U);
+
+    num.SetCompact(0x01fedcba, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "000000000000000000000000000000000000000000000000000000000000007e");
+    BOOST_CHECK_EQUAL(num.GetCompact(true), 0x01fe0000U);
+    BOOST_CHECK_EQUAL(fNegative, true);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x02123456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000001234");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x02123400U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x03123456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000123456");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x03123456U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x04123456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000012345600");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x04123456U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x04923456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000012345600");
+    BOOST_CHECK_EQUAL(num.GetCompact(true), 0x04923456U);
+    BOOST_CHECK_EQUAL(fNegative, true);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x05009234, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000092340000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x05009234U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0x20123456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(num.GetHex(), "1234560000000000000000000000000000000000000000000000000000000000");
+    BOOST_CHECK_EQUAL(num.GetCompact(), 0x20123456U);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, false);
+
+    num.SetCompact(0xff123456, &fNegative, &fOverflow);
+    BOOST_CHECK_EQUAL(fNegative, false);
+    BOOST_CHECK_EQUAL(fOverflow, true);
+}
+
+
+BOOST_AUTO_TEST_CASE( getmaxcoverage ) // some more tests just to get 100% coverage
+{
+    // ~R1L give a base_uint<256>
+    BOOST_CHECK((~~R1L >> 10) == (R1L >> 10));
+    BOOST_CHECK((~~R1L << 10) == (R1L << 10));
+    BOOST_CHECK(!(~~R1L < R1L));
+    BOOST_CHECK(~~R1L <= R1L);
+    BOOST_CHECK(!(~~R1L > R1L));
+    BOOST_CHECK(~~R1L >= R1L);
+    BOOST_CHECK(!(R1L < ~~R1L));
+    BOOST_CHECK(R1L <= ~~R1L);
+    BOOST_CHECK(!(R1L > ~~R1L));
+    BOOST_CHECK(R1L >= ~~R1L);
+
+    BOOST_CHECK(~~R1L + R2L == R1L + ~~R2L);
+    BOOST_CHECK(~~R1L - R2L == R1L - ~~R2L);
+    BOOST_CHECK(~R1L != R1L); BOOST_CHECK(R1L != ~R1L);
+    unsigned char TmpArray[32];
+    CHECKBITWISEOPERATOR(~R1,R2,|)
+    CHECKBITWISEOPERATOR(~R1,R2,^)
+    CHECKBITWISEOPERATOR(~R1,R2,&)
+    CHECKBITWISEOPERATOR(R1,~R2,|)
+    CHECKBITWISEOPERATOR(R1,~R2,^)
+    CHECKBITWISEOPERATOR(R1,~R2,&)
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/base32_tests.cpp b/base32_tests.cpp
new file mode 100644
index 0000000..bd04ae5
--- /dev/null
+++ b/base32_tests.cpp
@@ -0,0 +1,25 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <utilstrencodings.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(base32_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(base32_testvectors)
+{
+    static const std::string vstrIn[]  = {"","f","fo","foo","foob","fooba","foobar"};
+    static const std::string vstrOut[] = {"","my======","mzxq====","mzxw6===","mzxw6yq=","mzxw6ytb","mzxw6ytboi======"};
+    for (unsigned int i=0; i<sizeof(vstrIn)/sizeof(vstrIn[0]); i++)
+    {
+        std::string strEnc = EncodeBase32(vstrIn[i]);
+        BOOST_CHECK_EQUAL(strEnc, vstrOut[i]);
+        std::string strDec = DecodeBase32(vstrOut[i]);
+        BOOST_CHECK_EQUAL(strDec, vstrIn[i]);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/base58_tests.cpp b/base58_tests.cpp
new file mode 100644
index 0000000..2837ed7
--- /dev/null
+++ b/base58_tests.cpp
@@ -0,0 +1,69 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/data/base58_encode_decode.json.h>
+
+#include <base58.h>
+#include <test/test_salemcash.h>
+#include <utilstrencodings.h>
+
+#include <univalue.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+extern UniValue read_json(const std::string& jsondata);
+
+BOOST_FIXTURE_TEST_SUITE(base58_tests, BasicTestingSetup)
+
+// Goal: test low-level base58 encoding functionality
+BOOST_AUTO_TEST_CASE(base58_EncodeBase58)
+{
+    UniValue tests = read_json(std::string(json_tests::base58_encode_decode, json_tests::base58_encode_decode + sizeof(json_tests::base58_encode_decode)));
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        UniValue test = tests[idx];
+        std::string strTest = test.write();
+        if (test.size() < 2) // Allow for extra stuff (useful for comments)
+        {
+            BOOST_ERROR("Bad test: " << strTest);
+            continue;
+        }
+        std::vector<unsigned char> sourcedata = ParseHex(test[0].get_str());
+        std::string base58string = test[1].get_str();
+        BOOST_CHECK_MESSAGE(
+                    EncodeBase58(sourcedata.data(), sourcedata.data() + sourcedata.size()) == base58string,
+                    strTest);
+    }
+}
+
+// Goal: test low-level base58 decoding functionality
+BOOST_AUTO_TEST_CASE(base58_DecodeBase58)
+{
+    UniValue tests = read_json(std::string(json_tests::base58_encode_decode, json_tests::base58_encode_decode + sizeof(json_tests::base58_encode_decode)));
+    std::vector<unsigned char> result;
+
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        UniValue test = tests[idx];
+        std::string strTest = test.write();
+        if (test.size() < 2) // Allow for extra stuff (useful for comments)
+        {
+            BOOST_ERROR("Bad test: " << strTest);
+            continue;
+        }
+        std::vector<unsigned char> expected = ParseHex(test[0].get_str());
+        std::string base58string = test[1].get_str();
+        BOOST_CHECK_MESSAGE(DecodeBase58(base58string, result), strTest);
+        BOOST_CHECK_MESSAGE(result.size() == expected.size() && std::equal(result.begin(), result.end(), expected.begin()), strTest);
+    }
+
+    BOOST_CHECK(!DecodeBase58("invalid", result));
+
+    // check that DecodeBase58 skips whitespace, but still fails with unexpected non-whitespace at the end.
+    BOOST_CHECK(!DecodeBase58(" \t\n\v\f\r skip \r\f\v\n\t a", result));
+    BOOST_CHECK( DecodeBase58(" \t\n\v\f\r skip \r\f\v\n\t ", result));
+    std::vector<unsigned char> expected = ParseHex("971a55");
+    BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/base64_tests.cpp b/base64_tests.cpp
new file mode 100644
index 0000000..1f1eba9
--- /dev/null
+++ b/base64_tests.cpp
@@ -0,0 +1,25 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <utilstrencodings.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(base64_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(base64_testvectors)
+{
+    static const std::string vstrIn[]  = {"","f","fo","foo","foob","fooba","foobar"};
+    static const std::string vstrOut[] = {"","Zg==","Zm8=","Zm9v","Zm9vYg==","Zm9vYmE=","Zm9vYmFy"};
+    for (unsigned int i=0; i<sizeof(vstrIn)/sizeof(vstrIn[0]); i++)
+    {
+        std::string strEnc = EncodeBase64(vstrIn[i]);
+        BOOST_CHECK_EQUAL(strEnc, vstrOut[i]);
+        std::string strDec = DecodeBase64(strEnc);
+        BOOST_CHECK_EQUAL(strDec, vstrIn[i]);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bech32_tests.cpp b/bech32_tests.cpp
new file mode 100644
index 0000000..3b953ff
--- /dev/null
+++ b/bech32_tests.cpp
@@ -0,0 +1,67 @@
+// Copyright (c) 2017 Pieter Wuille
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <bech32.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(bech32_tests, BasicTestingSetup)
+
+bool CaseInsensitiveEqual(const std::string &s1, const std::string &s2)
+{
+    if (s1.size() != s2.size()) return false;
+    for (size_t i = 0; i < s1.size(); ++i) {
+        char c1 = s1[i];
+        if (c1 >= 'A' && c1 <= 'Z') c1 -= ('A' - 'a');
+        char c2 = s2[i];
+        if (c2 >= 'A' && c2 <= 'Z') c2 -= ('A' - 'a');
+        if (c1 != c2) return false;
+    }
+    return true;
+}
+
+BOOST_AUTO_TEST_CASE(bip173_testvectors_valid)
+{
+    static const std::string CASES[] = {
+        "A12UEL5L",
+        "a12uel5l",
+        "an83characterlonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1tt5tgs",
+        "abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw",
+        "11qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqc8247j",
+        "split1checkupstagehandshakeupstreamerranterredcaperred2y9e3w",
+        "?1ezyfcl",
+    };
+    for (const std::string& str : CASES) {
+        auto ret = bech32::Decode(str);
+        BOOST_CHECK(!ret.first.empty());
+        std::string recode = bech32::Encode(ret.first, ret.second);
+        BOOST_CHECK(!recode.empty());
+        BOOST_CHECK(CaseInsensitiveEqual(str, recode));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(bip173_testvectors_invalid)
+{
+    static const std::string CASES[] = {
+        " 1nwldj5",
+        "\x7f""1axkwrx",
+        "\x80""1eym55h",
+        "an84characterslonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1569pvx",
+        "pzry9x0s0muk",
+        "1pzry9x0s0muk",
+        "x1b4n0q5v",
+        "li1dgmt3",
+        "de1lg7wt\xff",
+        "A1G7SGD8",
+        "10a06t8",
+        "1qzzfhee",
+    };
+    for (const std::string& str : CASES) {
+        auto ret = bech32::Decode(str);
+        BOOST_CHECK(ret.first.empty());
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bip32_tests.cpp b/bip32_tests.cpp
new file mode 100644
index 0000000..1eab866
--- /dev/null
+++ b/bip32_tests.cpp
@@ -0,0 +1,154 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <boost/test/unit_test.hpp>
+
+#include <key.h>
+#include <key_io.h>
+#include <uint256.h>
+#include <util.h>
+#include <utilstrencodings.h>
+#include <test/test_salemcash.h>
+
+#include <string>
+#include <vector>
+
+struct TestDerivation {
+    std::string pub;
+    std::string prv;
+    unsigned int nChild;
+};
+
+struct TestVector {
+    std::string strHexMaster;
+    std::vector<TestDerivation> vDerive;
+
+    explicit TestVector(std::string strHexMasterIn) : strHexMaster(strHexMasterIn) {}
+
+    TestVector& operator()(std::string pub, std::string prv, unsigned int nChild) {
+        vDerive.push_back(TestDerivation());
+        TestDerivation &der = vDerive.back();
+        der.pub = pub;
+        der.prv = prv;
+        der.nChild = nChild;
+        return *this;
+    }
+};
+
+TestVector test1 =
+  TestVector("000102030405060708090a0b0c0d0e0f")
+    ("xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
+     "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
+     0x80000000)
+    ("xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw",
+     "xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7",
+     1)
+    ("xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ",
+     "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs",
+     0x80000002)
+    ("xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5",
+     "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM",
+     2)
+    ("xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV",
+     "xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334",
+     1000000000)
+    ("xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy",
+     "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76",
+     0);
+
+TestVector test2 =
+  TestVector("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542")
+    ("xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB",
+     "xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U",
+     0)
+    ("xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH",
+     "xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt",
+     0xFFFFFFFF)
+    ("xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a",
+     "xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9",
+     1)
+    ("xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon",
+     "xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef",
+     0xFFFFFFFE)
+    ("xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL",
+     "xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc",
+     2)
+    ("xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt",
+     "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j",
+     0);
+
+TestVector test3 =
+  TestVector("4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be")
+    ("xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhRoP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13",
+     "xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6",
+      0x80000000)
+    ("xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y",
+     "xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L",
+      0);
+
+void RunTest(const TestVector &test) {
+    std::vector<unsigned char> seed = ParseHex(test.strHexMaster);
+    CExtKey key;
+    CExtPubKey pubkey;
+    key.SetMaster(seed.data(), seed.size());
+    pubkey = key.Neuter();
+    for (const TestDerivation &derive : test.vDerive) {
+        unsigned char data[74];
+        key.Encode(data);
+        pubkey.Encode(data);
+
+        // Test private key
+        BOOST_CHECK(EncodeExtKey(key) == derive.prv);
+        BOOST_CHECK(DecodeExtKey(derive.prv) == key); //ensure a base58 decoded key also matches
+
+        // Test public key
+        BOOST_CHECK(EncodeExtPubKey(pubkey) == derive.pub);
+        BOOST_CHECK(DecodeExtPubKey(derive.pub) == pubkey); //ensure a base58 decoded pubkey also matches
+
+        // Derive new keys
+        CExtKey keyNew;
+        BOOST_CHECK(key.Derive(keyNew, derive.nChild));
+        CExtPubKey pubkeyNew = keyNew.Neuter();
+        if (!(derive.nChild & 0x80000000)) {
+            // Compare with public derivation
+            CExtPubKey pubkeyNew2;
+            BOOST_CHECK(pubkey.Derive(pubkeyNew2, derive.nChild));
+            BOOST_CHECK(pubkeyNew == pubkeyNew2);
+        }
+        key = keyNew;
+        pubkey = pubkeyNew;
+
+        CDataStream ssPub(SER_DISK, CLIENT_VERSION);
+        ssPub << pubkeyNew;
+        BOOST_CHECK(ssPub.size() == 75);
+
+        CDataStream ssPriv(SER_DISK, CLIENT_VERSION);
+        ssPriv << keyNew;
+        BOOST_CHECK(ssPriv.size() == 75);
+
+        CExtPubKey pubCheck;
+        CExtKey privCheck;
+        ssPub >> pubCheck;
+        ssPriv >> privCheck;
+
+        BOOST_CHECK(pubCheck == pubkeyNew);
+        BOOST_CHECK(privCheck == keyNew);
+    }
+}
+
+BOOST_FIXTURE_TEST_SUITE(bip32_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(bip32_test1) {
+    RunTest(test1);
+}
+
+BOOST_AUTO_TEST_CASE(bip32_test2) {
+    RunTest(test2);
+}
+
+BOOST_AUTO_TEST_CASE(bip32_test3) {
+    RunTest(test3);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/blockchain_tests.cpp b/blockchain_tests.cpp
new file mode 100644
index 0000000..253768b
--- /dev/null
+++ b/blockchain_tests.cpp
@@ -0,0 +1,126 @@
+#include <boost/test/unit_test.hpp>
+
+#include "stdlib.h"
+
+#include "rpc/blockchain.cpp"
+#include "test/test_salemcash.h"
+
+/* Equality between doubles is imprecise. Comparison should be done
+ * with a small threshold of tolerance, rather than exact equality.
+ */
+bool DoubleEquals(double a, double b, double epsilon)
+{
+    return std::abs(a - b) < epsilon;
+}
+
+CBlockIndex* CreateBlockIndexWithNbits(uint32_t nbits)
+{
+    CBlockIndex* block_index = new CBlockIndex();
+    block_index->nHeight = 46367;
+    block_index->nTime = 1269211443;
+    block_index->nBits = nbits;
+    return block_index;
+}
+
+CChain CreateChainWithNbits(uint32_t nbits)
+{
+    CBlockIndex* block_index = CreateBlockIndexWithNbits(nbits);
+    CChain chain;
+    chain.SetTip(block_index);
+    return chain;
+}
+
+void RejectDifficultyMismatch(double difficulty, double expected_difficulty) {
+     BOOST_CHECK_MESSAGE(
+        DoubleEquals(difficulty, expected_difficulty, 0.00001),
+        "Difficulty was " + std::to_string(difficulty)
+            + " but was expected to be " + std::to_string(expected_difficulty));
+}
+
+/* Given a BlockIndex with the provided nbits,
+ * verify that the expected difficulty results.
+ */
+void TestDifficulty(uint32_t nbits, double expected_difficulty)
+{
+    CBlockIndex* block_index = CreateBlockIndexWithNbits(nbits);
+    /* Since we are passing in block index explicitly,
+     * there is no need to set up anything within the chain itself.
+     */
+    CChain chain;
+
+    double difficulty = GetDifficulty(chain, block_index);
+    delete block_index;
+
+    RejectDifficultyMismatch(difficulty, expected_difficulty);
+}
+
+BOOST_FIXTURE_TEST_SUITE(blockchain_difficulty_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(get_difficulty_for_very_low_target)
+{
+    TestDifficulty(0x1f111111, 0.000001);
+}
+
+BOOST_AUTO_TEST_CASE(get_difficulty_for_low_target)
+{
+    TestDifficulty(0x1ef88f6f, 0.000016);
+}
+
+BOOST_AUTO_TEST_CASE(get_difficulty_for_mid_target)
+{
+    TestDifficulty(0x1df88f6f, 0.004023);
+}
+
+BOOST_AUTO_TEST_CASE(get_difficulty_for_high_target)
+{
+    TestDifficulty(0x1cf88f6f, 1.029916);
+}
+
+BOOST_AUTO_TEST_CASE(get_difficulty_for_very_high_target)
+{
+    TestDifficulty(0x12345678, 5913134931067755359633408.0);
+}
+
+// Verify that difficulty is 1.0 for an empty chain.
+BOOST_AUTO_TEST_CASE(get_difficulty_for_null_tip)
+{
+    CChain chain;
+    double difficulty = GetDifficulty(chain, nullptr);
+    RejectDifficultyMismatch(difficulty, 1.0);
+}
+
+/* Verify that if difficulty is based upon the block index
+ * in the chain, if no block index is explicitly specified.
+ */
+BOOST_AUTO_TEST_CASE(get_difficulty_for_null_block_index)
+{
+    CChain chain = CreateChainWithNbits(0x1df88f6f);
+
+    double difficulty = GetDifficulty(chain, nullptr);
+    delete chain.Tip();
+
+    double expected_difficulty = 0.004023;
+
+    RejectDifficultyMismatch(difficulty, expected_difficulty);
+}
+
+/* Verify that difficulty is based upon the explicitly specified
+ * block index rather than being taken from the provided chain,
+ * when both are present.
+ */
+BOOST_AUTO_TEST_CASE(get_difficulty_for_block_index_overrides_tip)
+{
+    CChain chain = CreateChainWithNbits(0x1df88f6f);
+    /* This block index's nbits should be used
+     * instead of the chain's when calculating difficulty.
+     */
+    CBlockIndex* override_block_index = CreateBlockIndexWithNbits(0x12345678);
+
+    double difficulty = GetDifficulty(chain, override_block_index);
+    delete chain.Tip();
+    delete override_block_index;
+
+    RejectDifficultyMismatch(difficulty, 5913134931067755359633408.0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/blockencodings_tests.cpp b/blockencodings_tests.cpp
new file mode 100644
index 0000000..c5c4dca
--- /dev/null
+++ b/blockencodings_tests.cpp
@@ -0,0 +1,343 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <blockencodings.h>
+#include <consensus/merkle.h>
+#include <chainparams.h>
+#include <random.h>
+
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+std::vector<std::pair<uint256, CTransactionRef>> extra_txn;
+
+struct RegtestingSetup : public TestingSetup {
+    RegtestingSetup() : TestingSetup(CBaseChainParams::REGTEST) {}
+};
+
+BOOST_FIXTURE_TEST_SUITE(blockencodings_tests, RegtestingSetup)
+
+static CBlock BuildBlockTestCase() {
+    CBlock block;
+    CMutableTransaction tx;
+    tx.vin.resize(1);
+    tx.vin[0].scriptSig.resize(10);
+    tx.vout.resize(1);
+    tx.vout[0].nValue = 42;
+
+    block.vtx.resize(3);
+    block.vtx[0] = MakeTransactionRef(tx);
+    block.nVersion = 42;
+    block.hashPrevBlock = InsecureRand256();
+    block.nBits = 0x207fffff;
+
+    tx.vin[0].prevout.hash = InsecureRand256();
+    tx.vin[0].prevout.n = 0;
+    block.vtx[1] = MakeTransactionRef(tx);
+
+    tx.vin.resize(10);
+    for (size_t i = 0; i < tx.vin.size(); i++) {
+        tx.vin[i].prevout.hash = InsecureRand256();
+        tx.vin[i].prevout.n = 0;
+    }
+    block.vtx[2] = MakeTransactionRef(tx);
+
+    bool mutated;
+    block.hashMerkleRoot = BlockMerkleRoot(block, &mutated);
+    assert(!mutated);
+    while (!CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;
+    return block;
+}
+
+// Number of shared use_counts we expect for a tx we haven't touched
+// == 2 (mempool + our copy from the GetSharedTx call)
+#define SHARED_TX_OFFSET 2
+
+BOOST_AUTO_TEST_CASE(SimpleRoundTripTest)
+{
+    CTxMemPool pool;
+    TestMemPoolEntryHelper entry;
+    CBlock block(BuildBlockTestCase());
+
+    pool.addUnchecked(block.vtx[2]->GetHash(), entry.FromTx(*block.vtx[2]));
+    LOCK(pool.cs);
+    BOOST_CHECK_EQUAL(pool.mapTx.find(block.vtx[2]->GetHash())->GetSharedTx().use_count(), SHARED_TX_OFFSET + 0);
+
+    // Do a simple ShortTxIDs RT
+    {
+        CBlockHeaderAndShortTxIDs shortIDs(block, true);
+
+        CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+        stream << shortIDs;
+
+        CBlockHeaderAndShortTxIDs shortIDs2;
+        stream >> shortIDs2;
+
+        PartiallyDownloadedBlock partialBlock(&pool);
+        BOOST_CHECK(partialBlock.InitData(shortIDs2, extra_txn) == READ_STATUS_OK);
+        BOOST_CHECK( partialBlock.IsTxAvailable(0));
+        BOOST_CHECK(!partialBlock.IsTxAvailable(1));
+        BOOST_CHECK( partialBlock.IsTxAvailable(2));
+
+        BOOST_CHECK_EQUAL(pool.mapTx.find(block.vtx[2]->GetHash())->GetSharedTx().use_count(), SHARED_TX_OFFSET + 1);
+
+        size_t poolSize = pool.size();
+        pool.removeRecursive(*block.vtx[2]);
+        BOOST_CHECK_EQUAL(pool.size(), poolSize - 1);
+
+        CBlock block2;
+        {
+            PartiallyDownloadedBlock tmp = partialBlock;
+            BOOST_CHECK(partialBlock.FillBlock(block2, {}) == READ_STATUS_INVALID); // No transactions
+            partialBlock = tmp;
+        }
+
+        // Wrong transaction
+        {
+            PartiallyDownloadedBlock tmp = partialBlock;
+            partialBlock.FillBlock(block2, {block.vtx[2]}); // Current implementation doesn't check txn here, but don't require that
+            partialBlock = tmp;
+        }
+        bool mutated;
+        BOOST_CHECK(block.hashMerkleRoot != BlockMerkleRoot(block2, &mutated));
+
+        CBlock block3;
+        BOOST_CHECK(partialBlock.FillBlock(block3, {block.vtx[1]}) == READ_STATUS_OK);
+        BOOST_CHECK_EQUAL(block.GetHash().ToString(), block3.GetHash().ToString());
+        BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block3, &mutated).ToString());
+        BOOST_CHECK(!mutated);
+    }
+}
+
+class TestHeaderAndShortIDs {
+    // Utility to encode custom CBlockHeaderAndShortTxIDs
+public:
+    CBlockHeader header;
+    uint64_t nonce;
+    std::vector<uint64_t> shorttxids;
+    std::vector<PrefilledTransaction> prefilledtxn;
+
+    explicit TestHeaderAndShortIDs(const CBlockHeaderAndShortTxIDs& orig) {
+        CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+        stream << orig;
+        stream >> *this;
+    }
+    explicit TestHeaderAndShortIDs(const CBlock& block) :
+        TestHeaderAndShortIDs(CBlockHeaderAndShortTxIDs(block, true)) {}
+
+    uint64_t GetShortID(const uint256& txhash) const {
+        CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+        stream << *this;
+        CBlockHeaderAndShortTxIDs base;
+        stream >> base;
+        return base.GetShortID(txhash);
+    }
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(header);
+        READWRITE(nonce);
+        size_t shorttxids_size = shorttxids.size();
+        READWRITE(VARINT(shorttxids_size));
+        shorttxids.resize(shorttxids_size);
+        for (size_t i = 0; i < shorttxids.size(); i++) {
+            uint32_t lsb = shorttxids[i] & 0xffffffff;
+            uint16_t msb = (shorttxids[i] >> 32) & 0xffff;
+            READWRITE(lsb);
+            READWRITE(msb);
+            shorttxids[i] = (uint64_t(msb) << 32) | uint64_t(lsb);
+        }
+        READWRITE(prefilledtxn);
+    }
+};
+
+BOOST_AUTO_TEST_CASE(NonCashbasePreforwardRTTest)
+{
+    CTxMemPool pool;
+    TestMemPoolEntryHelper entry;
+    CBlock block(BuildBlockTestCase());
+
+    pool.addUnchecked(block.vtx[2]->GetHash(), entry.FromTx(*block.vtx[2]));
+    LOCK(pool.cs);
+    BOOST_CHECK_EQUAL(pool.mapTx.find(block.vtx[2]->GetHash())->GetSharedTx().use_count(), SHARED_TX_OFFSET + 0);
+
+    uint256 txhash;
+
+    // Test with pre-forwarding tx 1, but not coinbase
+    {
+        TestHeaderAndShortIDs shortIDs(block);
+        shortIDs.prefilledtxn.resize(1);
+        shortIDs.prefilledtxn[0] = {1, block.vtx[1]};
+        shortIDs.shorttxids.resize(2);
+        shortIDs.shorttxids[0] = shortIDs.GetShortID(block.vtx[0]->GetHash());
+        shortIDs.shorttxids[1] = shortIDs.GetShortID(block.vtx[2]->GetHash());
+
+        CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+        stream << shortIDs;
+
+        CBlockHeaderAndShortTxIDs shortIDs2;
+        stream >> shortIDs2;
+
+        PartiallyDownloadedBlock partialBlock(&pool);
+        BOOST_CHECK(partialBlock.InitData(shortIDs2, extra_txn) == READ_STATUS_OK);
+        BOOST_CHECK(!partialBlock.IsTxAvailable(0));
+        BOOST_CHECK( partialBlock.IsTxAvailable(1));
+        BOOST_CHECK( partialBlock.IsTxAvailable(2));
+
+        BOOST_CHECK_EQUAL(pool.mapTx.find(block.vtx[2]->GetHash())->GetSharedTx().use_count(), SHARED_TX_OFFSET + 1);
+
+        CBlock block2;
+        {
+            PartiallyDownloadedBlock tmp = partialBlock;
+            BOOST_CHECK(partialBlock.FillBlock(block2, {}) == READ_STATUS_INVALID); // No transactions
+            partialBlock = tmp;
+        }
+
+        // Wrong transaction
+        {
+            PartiallyDownloadedBlock tmp = partialBlock;
+            partialBlock.FillBlock(block2, {block.vtx[1]}); // Current implementation doesn't check txn here, but don't require that
+            partialBlock = tmp;
+        }
+        bool mutated;
+        BOOST_CHECK(block.hashMerkleRoot != BlockMerkleRoot(block2, &mutated));
+
+        CBlock block3;
+        PartiallyDownloadedBlock partialBlockCopy = partialBlock;
+        BOOST_CHECK(partialBlock.FillBlock(block3, {block.vtx[0]}) == READ_STATUS_OK);
+        BOOST_CHECK_EQUAL(block.GetHash().ToString(), block3.GetHash().ToString());
+        BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block3, &mutated).ToString());
+        BOOST_CHECK(!mutated);
+
+        txhash = block.vtx[2]->GetHash();
+        block.vtx.clear();
+        block2.vtx.clear();
+        block3.vtx.clear();
+        BOOST_CHECK_EQUAL(pool.mapTx.find(txhash)->GetSharedTx().use_count(), SHARED_TX_OFFSET + 1); // + 1 because of partialBlockCopy.
+    }
+    BOOST_CHECK_EQUAL(pool.mapTx.find(txhash)->GetSharedTx().use_count(), SHARED_TX_OFFSET + 0);
+}
+
+BOOST_AUTO_TEST_CASE(SufficientPreforwardRTTest)
+{
+    CTxMemPool pool;
+    TestMemPoolEntryHelper entry;
+    CBlock block(BuildBlockTestCase());
+
+    pool.addUnchecked(block.vtx[1]->GetHash(), entry.FromTx(*block.vtx[1]));
+    LOCK(pool.cs);
+    BOOST_CHECK_EQUAL(pool.mapTx.find(block.vtx[1]->GetHash())->GetSharedTx().use_count(), SHARED_TX_OFFSET + 0);
+
+    uint256 txhash;
+
+    // Test with pre-forwarding coinbase + tx 2 with tx 1 in mempool
+    {
+        TestHeaderAndShortIDs shortIDs(block);
+        shortIDs.prefilledtxn.resize(2);
+        shortIDs.prefilledtxn[0] = {0, block.vtx[0]};
+        shortIDs.prefilledtxn[1] = {1, block.vtx[2]}; // id == 1 as it is 1 after index 1
+        shortIDs.shorttxids.resize(1);
+        shortIDs.shorttxids[0] = shortIDs.GetShortID(block.vtx[1]->GetHash());
+
+        CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+        stream << shortIDs;
+
+        CBlockHeaderAndShortTxIDs shortIDs2;
+        stream >> shortIDs2;
+
+        PartiallyDownloadedBlock partialBlock(&pool);
+        BOOST_CHECK(partialBlock.InitData(shortIDs2, extra_txn) == READ_STATUS_OK);
+        BOOST_CHECK( partialBlock.IsTxAvailable(0));
+        BOOST_CHECK( partialBlock.IsTxAvailable(1));
+        BOOST_CHECK( partialBlock.IsTxAvailable(2));
+
+        BOOST_CHECK_EQUAL(pool.mapTx.find(block.vtx[1]->GetHash())->GetSharedTx().use_count(), SHARED_TX_OFFSET + 1);
+
+        CBlock block2;
+        PartiallyDownloadedBlock partialBlockCopy = partialBlock;
+        BOOST_CHECK(partialBlock.FillBlock(block2, {}) == READ_STATUS_OK);
+        BOOST_CHECK_EQUAL(block.GetHash().ToString(), block2.GetHash().ToString());
+        bool mutated;
+        BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block2, &mutated).ToString());
+        BOOST_CHECK(!mutated);
+
+        txhash = block.vtx[1]->GetHash();
+        block.vtx.clear();
+        block2.vtx.clear();
+        BOOST_CHECK_EQUAL(pool.mapTx.find(txhash)->GetSharedTx().use_count(), SHARED_TX_OFFSET + 1); // + 1 because of partialBlockCopy.
+    }
+    BOOST_CHECK_EQUAL(pool.mapTx.find(txhash)->GetSharedTx().use_count(), SHARED_TX_OFFSET + 0);
+}
+
+BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest)
+{
+    CTxMemPool pool;
+    CMutableTransaction coinbase;
+    coinbase.vin.resize(1);
+    coinbase.vin[0].scriptSig.resize(10);
+    coinbase.vout.resize(1);
+    coinbase.vout[0].nValue = 42;
+
+    CBlock block;
+    block.vtx.resize(1);
+    block.vtx[0] = MakeTransactionRef(std::move(coinbase));
+    block.nVersion = 42;
+    block.hashPrevBlock = InsecureRand256();
+    block.nBits = 0x207fffff;
+
+    bool mutated;
+    block.hashMerkleRoot = BlockMerkleRoot(block, &mutated);
+    assert(!mutated);
+    while (!CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;
+
+    // Test simple header round-trip with only coinbase
+    {
+        CBlockHeaderAndShortTxIDs shortIDs(block, false);
+
+        CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+        stream << shortIDs;
+
+        CBlockHeaderAndShortTxIDs shortIDs2;
+        stream >> shortIDs2;
+
+        PartiallyDownloadedBlock partialBlock(&pool);
+        BOOST_CHECK(partialBlock.InitData(shortIDs2, extra_txn) == READ_STATUS_OK);
+        BOOST_CHECK(partialBlock.IsTxAvailable(0));
+
+        CBlock block2;
+        std::vector<CTransactionRef> vtx_missing;
+        BOOST_CHECK(partialBlock.FillBlock(block2, vtx_missing) == READ_STATUS_OK);
+        BOOST_CHECK_EQUAL(block.GetHash().ToString(), block2.GetHash().ToString());
+        BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block2, &mutated).ToString());
+        BOOST_CHECK(!mutated);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(TransactionsRequestSerializationTest) {
+    BlockTransactionsRequest req1;
+    req1.blockhash = InsecureRand256();
+    req1.indexes.resize(4);
+    req1.indexes[0] = 0;
+    req1.indexes[1] = 1;
+    req1.indexes[2] = 3;
+    req1.indexes[3] = 4;
+
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << req1;
+
+    BlockTransactionsRequest req2;
+    stream >> req2;
+
+    BOOST_CHECK_EQUAL(req1.blockhash.ToString(), req2.blockhash.ToString());
+    BOOST_CHECK_EQUAL(req1.indexes.size(), req2.indexes.size());
+    BOOST_CHECK_EQUAL(req1.indexes[0], req2.indexes[0]);
+    BOOST_CHECK_EQUAL(req1.indexes[1], req2.indexes[1]);
+    BOOST_CHECK_EQUAL(req1.indexes[2], req2.indexes[2]);
+    BOOST_CHECK_EQUAL(req1.indexes[3], req2.indexes[3]);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bloom_tests.cpp b/bloom_tests.cpp
new file mode 100644
index 0000000..ba83142
--- /dev/null
+++ b/bloom_tests.cpp
@@ -0,0 +1,536 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <bloom.h>
+
+#include <clientversion.h>
+#include <key.h>
+#include <key_io.h>
+#include <merkleblock.h>
+#include <primitives/block.h>
+#include <random.h>
+#include <serialize.h>
+#include <streams.h>
+#include <uint256.h>
+#include <util.h>
+#include <utilstrencodings.h>
+#include <test/test_salemcash.h>
+
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(bloom_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize)
+{
+    CBloomFilter filter(3, 0.01, 0, BLOOM_UPDATE_ALL);
+
+    filter.insert(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8"));
+    BOOST_CHECK_MESSAGE( filter.contains(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8")), "Bloom filter doesn't contain just-inserted object!");
+    // One bit different in first byte
+    BOOST_CHECK_MESSAGE(!filter.contains(ParseHex("19108ad8ed9bb6274d3980bab5a85c048f0950c8")), "Bloom filter contains something it shouldn't!");
+
+    filter.insert(ParseHex("b5a2c786d9ef4658287ced5914b37a1b4aa32eee"));
+    BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b5a2c786d9ef4658287ced5914b37a1b4aa32eee")), "Bloom filter doesn't contain just-inserted object (2)!");
+
+    filter.insert(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5"));
+    BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")), "Bloom filter doesn't contain just-inserted object (3)!");
+
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << filter;
+
+    std::vector<unsigned char> vch = ParseHex("03614e9b050000000000000001");
+    std::vector<char> expected(vch.size());
+
+    for (unsigned int i = 0; i < vch.size(); i++)
+        expected[i] = (char)vch[i];
+
+    BOOST_CHECK_EQUAL_COLLECTIONS(stream.begin(), stream.end(), expected.begin(), expected.end());
+
+    BOOST_CHECK_MESSAGE( filter.contains(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8")), "Bloom filter doesn't contain just-inserted object!");
+    filter.clear();
+    BOOST_CHECK_MESSAGE( !filter.contains(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8")), "Bloom filter should be empty!");
+}
+
+BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize_with_tweak)
+{
+    // Same test as bloom_create_insert_serialize, but we add a nTweak of 100
+    CBloomFilter filter(3, 0.01, 2147483649UL, BLOOM_UPDATE_ALL);
+
+    filter.insert(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8"));
+    BOOST_CHECK_MESSAGE( filter.contains(ParseHex("99108ad8ed9bb6274d3980bab5a85c048f0950c8")), "Bloom filter doesn't contain just-inserted object!");
+    // One bit different in first byte
+    BOOST_CHECK_MESSAGE(!filter.contains(ParseHex("19108ad8ed9bb6274d3980bab5a85c048f0950c8")), "Bloom filter contains something it shouldn't!");
+
+    filter.insert(ParseHex("b5a2c786d9ef4658287ced5914b37a1b4aa32eee"));
+    BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b5a2c786d9ef4658287ced5914b37a1b4aa32eee")), "Bloom filter doesn't contain just-inserted object (2)!");
+
+    filter.insert(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5"));
+    BOOST_CHECK_MESSAGE(filter.contains(ParseHex("b9300670b4c5366e95b2699e8b18bc75e5f729c5")), "Bloom filter doesn't contain just-inserted object (3)!");
+
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << filter;
+
+    std::vector<unsigned char> vch = ParseHex("03ce4299050000000100008001");
+    std::vector<char> expected(vch.size());
+
+    for (unsigned int i = 0; i < vch.size(); i++)
+        expected[i] = (char)vch[i];
+
+    BOOST_CHECK_EQUAL_COLLECTIONS(stream.begin(), stream.end(), expected.begin(), expected.end());
+}
+
+BOOST_AUTO_TEST_CASE(bloom_create_insert_key)
+{
+    std::string strSecret = std::string("5Kg1gnAjaLfKiwhhPpGS3QfRg2m6awQvaj98JCZBZQ5SuS2F15C");
+    CKey key = DecodeSecret(strSecret);
+    CPubKey pubkey = key.GetPubKey();
+    std::vector<unsigned char> vchPubKey(pubkey.begin(), pubkey.end());
+
+    CBloomFilter filter(2, 0.001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(vchPubKey);
+    uint160 hash = pubkey.GetID();
+    filter.insert(std::vector<unsigned char>(hash.begin(), hash.end()));
+
+    CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+    stream << filter;
+
+    std::vector<unsigned char> vch = ParseHex("038fc16b080000000000000001");
+    std::vector<char> expected(vch.size());
+
+    for (unsigned int i = 0; i < vch.size(); i++)
+        expected[i] = (char)vch[i];
+
+    BOOST_CHECK_EQUAL_COLLECTIONS(stream.begin(), stream.end(), expected.begin(), expected.end());
+}
+
+BOOST_AUTO_TEST_CASE(bloom_match)
+{
+    // Random real transaction (b4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b)
+    CDataStream stream(ParseHex("01000000010b26e9b7735eb6aabdf358bab62f9816a21ba9ebdb719d5299e88607d722c190000000008b4830450220070aca44506c5cef3a16ed519d7c3c39f8aab192c4e1c90d065f37b8a4af6141022100a8e160b856c2d43d27d8fba71e5aef6405b8643ac4cb7cb3c462aced7f14711a0141046d11fee51b0e60666d5049a9101a72741df480b96ee26488a4d3466b95c9a40ac5eeef87e10a5cd336c19a84565f80fa6c547957b7700ff4dfbdefe76036c339ffffffff021bff3d11000000001976a91404943fdd508053c75000106d3bc6e2754dbcff1988ac2f15de00000000001976a914a266436d2965547608b9e15d9032a7b9d64fa43188ac00000000"), SER_DISK, CLIENT_VERSION);
+    CTransaction tx(deserialize, stream);
+
+    // and one which spends it (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
+    unsigned char ch[] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f, 0xcd, 0x4f, 0x85, 0x65, 0xef, 0x40, 0x6d, 0xd5, 0xd6, 0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8, 0x20, 0x27, 0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f, 0x74, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77, 0x37, 0x57, 0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f, 0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c, 0x02, 0x21, 0x00, 0xd2, 0x5b, 0x5c, 0x87, 0x04, 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e, 0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27, 0xc4, 0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2, 0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a, 0x6c, 0xf9, 0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34, 0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff, 0x9a, 0x2e, 0xe1, 0x97, 0x8d, 0xd7, 0xfd, 0x01, 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b, 0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb, 0x0f, 0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b, 0xa7, 0x94, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef, 0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0, 0x39, 0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93, 0xed, 0x51, 0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43, 0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00};
+    std::vector<unsigned char> vch(ch, ch + sizeof(ch) -1);
+    CDataStream spendStream(vch, SER_DISK, CLIENT_VERSION);
+    CTransaction spendingTx(deserialize, spendStream);
+
+    CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(uint256S("0xb4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b"));
+    BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match tx hash");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    // byte-reversed tx hash
+    filter.insert(ParseHex("6bff7fcd4f8565ef406dd5d63d4ff94f318fe82027fd4dc451b04474019f74b4"));
+    BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match manually serialized tx hash");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(ParseHex("30450220070aca44506c5cef3a16ed519d7c3c39f8aab192c4e1c90d065f37b8a4af6141022100a8e160b856c2d43d27d8fba71e5aef6405b8643ac4cb7cb3c462aced7f14711a01"));
+    BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match input signature");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(ParseHex("046d11fee51b0e60666d5049a9101a72741df480b96ee26488a4d3466b95c9a40ac5eeef87e10a5cd336c19a84565f80fa6c547957b7700ff4dfbdefe76036c339"));
+    BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match input pub key");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(ParseHex("04943fdd508053c75000106d3bc6e2754dbcff19"));
+    BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match output address");
+    BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(spendingTx), "Simple Bloom filter didn't add output");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(ParseHex("a266436d2965547608b9e15d9032a7b9d64fa431"));
+    BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match output address");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(COutPoint(uint256S("0x90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"), 0));
+    BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match COutPoint");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    COutPoint prevOutPoint(uint256S("0x90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"), 0);
+    {
+        std::vector<unsigned char> data(32 + sizeof(unsigned int));
+        memcpy(data.data(), prevOutPoint.hash.begin(), 32);
+        memcpy(data.data()+32, &prevOutPoint.n, sizeof(unsigned int));
+        filter.insert(data);
+    }
+    BOOST_CHECK_MESSAGE(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match manually serialized COutPoint");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(uint256S("00000009e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436"));
+    BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched random tx hash");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(ParseHex("0000006d2965547608b9e15d9032a7b9d64fa431"));
+    BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched random address");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(COutPoint(uint256S("0x90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"), 1));
+    BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched COutPoint for an output we didn't care about");
+
+    filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    filter.insert(COutPoint(uint256S("0x000000d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"), 0));
+    BOOST_CHECK_MESSAGE(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched COutPoint for an output we didn't care about");
+}
+
+BOOST_AUTO_TEST_CASE(merkle_block_1)
+{
+    CBlock block = getBlock13b8a();
+    CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    // Match the last transaction
+    filter.insert(uint256S("0x74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20"));
+
+    CMerkleBlock merkleBlock(block, filter);
+    BOOST_CHECK_EQUAL(merkleBlock.header.GetHash().GetHex(), block.GetHash().GetHex());
+
+    BOOST_CHECK_EQUAL(merkleBlock.vMatchedTxn.size(), 1);
+    std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0x74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 8);
+
+    std::vector<uint256> vMatched;
+    std::vector<unsigned int> vIndex;
+    BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
+    BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
+    for (unsigned int i = 0; i < vMatched.size(); i++)
+        BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
+
+    // Also match the 8th transaction
+    filter.insert(uint256S("0xdd1fd2a6fc16404faf339881a90adbde7f4f728691ac62e8f168809cdfae1053"));
+    merkleBlock = CMerkleBlock(block, filter);
+    BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 2);
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[1] == pair);
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0xdd1fd2a6fc16404faf339881a90adbde7f4f728691ac62e8f168809cdfae1053"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 7);
+
+    BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
+    BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
+    for (unsigned int i = 0; i < vMatched.size(); i++)
+        BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
+}
+
+BOOST_AUTO_TEST_CASE(merkle_block_2)
+{
+    // Random real block (000000005a4ded781e667e06ceefafb71410b511fe0d5adc3e5a27ecbec34ae6)
+    // With 4 txes
+    CBlock block;
+    CDataStream stream(ParseHex("0100000075616236cc2126035fadb38deb65b9102cc2c41c09cdf29fc051906800000000fe7d5e12ef0ff901f6050211249919b1c0653771832b3a80c66cea42847f0ae1d4d26e49ffff001d00f0a4410401000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0804ffff001d029105ffffffff0100f2052a010000004341046d8709a041d34357697dfcb30a9d05900a6294078012bf3bb09c6f9b525f1d16d5503d7905db1ada9501446ea00728668fc5719aa80be2fdfc8a858a4dbdd4fbac00000000010000000255605dc6f5c3dc148b6da58442b0b2cd422be385eab2ebea4119ee9c268d28350000000049483045022100aa46504baa86df8a33b1192b1b9367b4d729dc41e389f2c04f3e5c7f0559aae702205e82253a54bf5c4f65b7428551554b2045167d6d206dfe6a2e198127d3f7df1501ffffffff55605dc6f5c3dc148b6da58442b0b2cd422be385eab2ebea4119ee9c268d2835010000004847304402202329484c35fa9d6bb32a55a70c0982f606ce0e3634b69006138683bcd12cbb6602200c28feb1e2555c3210f1dddb299738b4ff8bbe9667b68cb8764b5ac17b7adf0001ffffffff0200e1f505000000004341046a0765b5865641ce08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a68aee3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0cac00180d8f000000004341044a656f065871a353f216ca26cef8dde2f03e8c16202d2e8ad769f02032cb86a5eb5e56842e92e19141d60a01928f8dd2c875a390f67c1f6c94cfc617c0ea45afac0000000001000000025f9a06d3acdceb56be1bfeaa3e8a25e62d182fa24fefe899d1c17f1dad4c2028000000004847304402205d6058484157235b06028c30736c15613a28bdb768ee628094ca8b0030d4d6eb0220328789c9a2ec27ddaec0ad5ef58efded42e6ea17c2e1ce838f3d6913f5e95db601ffffffff5f9a06d3acdceb56be1bfeaa3e8a25e62d182fa24fefe899d1c17f1dad4c2028010000004a493046022100c45af050d3cea806cedd0ab22520c53ebe63b987b8954146cdca42487b84bdd6022100b9b027716a6b59e640da50a864d6dd8a0ef24c76ce62391fa3eabaf4d2886d2d01ffffffff0200e1f505000000004341046a0765b5865641ce08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a68aee3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0cac00180d8f000000004341046a0765b5865641ce08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a68aee3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0cac000000000100000002e2274e5fea1bf29d963914bd301aa63b64daaf8a3e88f119b5046ca5738a0f6b0000000048473044022016e7a727a061ea2254a6c358376aaa617ac537eb836c77d646ebda4c748aac8b0220192ce28bf9f2c06a6467e6531e27648d2b3e2e2bae85159c9242939840295ba501ffffffffe2274e5fea1bf29d963914bd301aa63b64daaf8a3e88f119b5046ca5738a0f6b010000004a493046022100b7a1a755588d4190118936e15cd217d133b0e4a53c3c15924010d5648d8925c9022100aaef031874db2114f2d869ac2de4ae53908fbfea5b2b1862e181626bb9005c9f01ffffffff0200e1f505000000004341044a656f065871a353f216ca26cef8dde2f03e8c16202d2e8ad769f02032cb86a5eb5e56842e92e19141d60a01928f8dd2c875a390f67c1f6c94cfc617c0ea45afac00180d8f000000004341046a0765b5865641ce08dd39690aade26dfbf5511430ca428a3089261361cef170e3929a68aee3d8d4848b0c5111b0a37b82b86ad559fd2a745b44d8e8d9dfdc0cac00000000"), SER_NETWORK, PROTOCOL_VERSION);
+    stream >> block;
+
+    CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    // Match the first transaction
+    filter.insert(uint256S("0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70"));
+
+    CMerkleBlock merkleBlock(block, filter);
+    BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
+    std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 0);
+
+    std::vector<uint256> vMatched;
+    std::vector<unsigned int> vIndex;
+    BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
+    BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
+    for (unsigned int i = 0; i < vMatched.size(); i++)
+        BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
+
+    // Match an output from the second transaction (the pubkey for address 1DZTzaBHUDM7T3QvUKBz4qXMRpkg8jsfB5)
+    // This should match the third transaction because it spends the output matched
+    // It also matches the fourth transaction, which spends to the pubkey again
+    filter.insert(ParseHex("044a656f065871a353f216ca26cef8dde2f03e8c16202d2e8ad769f02032cb86a5eb5e56842e92e19141d60a01928f8dd2c875a390f67c1f6c94cfc617c0ea45af"));
+
+    merkleBlock = CMerkleBlock(block, filter);
+    BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 4);
+
+    BOOST_CHECK(pair == merkleBlock.vMatchedTxn[0]);
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[1].second == uint256S("0x28204cad1d7fc1d199e8ef4fa22f182de6258a3eaafe1bbe56ebdcacd3069a5f"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[1].first == 1);
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[2].second == uint256S("0x6b0f8a73a56c04b519f1883e8aafda643ba61a30bd1439969df21bea5f4e27e2"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[2].first == 2);
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[3].second == uint256S("0x3c1d7e82342158e4109df2e0b6348b6e84e403d8b4046d7007663ace63cddb23"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[3].first == 3);
+
+    BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
+    BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
+    for (unsigned int i = 0; i < vMatched.size(); i++)
+        BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
+}
+
+BOOST_AUTO_TEST_CASE(merkle_block_2_with_update_none)
+{
+    // Random real block (000000005a4ded781e667e06ceefafb71410b511fe0d5adc3e5a27ecbec34ae6)
+    // With 4 txes
+    CBlock block;
+    CDataStream stream(ParseHex("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"), SER_NETWORK, PROTOCOL_VERSION);
+    stream >> block;
+
+    CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_NONE);
+    // Match the first transaction
+    filter.insert(uint256S("0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70"));
+
+    CMerkleBlock merkleBlock(block, filter);
+    BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
+    std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 0);
+
+    std::vector<uint256> vMatched;
+    std::vector<unsigned int> vIndex;
+    BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
+    BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
+    for (unsigned int i = 0; i < vMatched.size(); i++)
+        BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
+
+    // Match an output from the second transaction (the pubkey for address 1DZTzaBHUDM7T3QvUKBz4qXMRpkg8jsfB5)
+    // This should not match the third transaction though it spends the output matched
+    // It will match the fourth transaction, which has another pay-to-pubkey output to the same address
+    filter.insert(ParseHex("044a656f065871a353f216ca26cef8dde2f03e8c16202d2e8ad769f02032cb86a5eb5e56842e92e19141d60a01928f8dd2c875a390f67c1f6c94cfc617c0ea45af"));
+
+    merkleBlock = CMerkleBlock(block, filter);
+    BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 3);
+
+    BOOST_CHECK(pair == merkleBlock.vMatchedTxn[0]);
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[1].second == uint256S("0x28204cad1d7fc1d199e8ef4fa22f182de6258a3eaafe1bbe56ebdcacd3069a5f"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[1].first == 1);
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[2].second == uint256S("0x3c1d7e82342158e4109df2e0b6348b6e84e403d8b4046d7007663ace63cddb23"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[2].first == 3);
+
+    BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
+    BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
+    for (unsigned int i = 0; i < vMatched.size(); i++)
+        BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
+}
+
+BOOST_AUTO_TEST_CASE(merkle_block_3_and_serialize)
+{
+    // Random real block (000000000000dab0130bbcc991d3d7ae6b81aa6f50a798888dfe62337458dc45)
+    // With one tx
+    CBlock block;
+    CDataStream stream(ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff08044c86041b020a02ffffffff0100f2052a01000000434104ecd3229b0571c3be876feaac0442a9f13c5a572742927af1dc623353ecf8c202225f64868137a18cdd85cbbb4c74fbccfd4f49639cf1bdc94a5672bb15ad5d4cac00000000"), SER_NETWORK, PROTOCOL_VERSION);
+    stream >> block;
+
+    CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    // Match the only transaction
+    filter.insert(uint256S("0x63194f18be0af63f2c6bc9dc0f777cbefed3d9415c4af83f3ee3a3d669c00cb5"));
+
+    CMerkleBlock merkleBlock(block, filter);
+    BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0x63194f18be0af63f2c6bc9dc0f777cbefed3d9415c4af83f3ee3a3d669c00cb5"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 0);
+
+    std::vector<uint256> vMatched;
+    std::vector<unsigned int> vIndex;
+    BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
+    BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
+    for (unsigned int i = 0; i < vMatched.size(); i++)
+        BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
+
+    CDataStream merkleStream(SER_NETWORK, PROTOCOL_VERSION);
+    merkleStream << merkleBlock;
+
+    std::vector<unsigned char> vch = ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101");
+    std::vector<char> expected(vch.size());
+
+    for (unsigned int i = 0; i < vch.size(); i++)
+        expected[i] = (char)vch[i];
+
+    BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(), expected.end(), merkleStream.begin(), merkleStream.end());
+}
+
+BOOST_AUTO_TEST_CASE(merkle_block_4)
+{
+    // Random real block (000000000000b731f2eef9e8c63173adfb07e41bd53eb0ef0a6b720d6cb6dea4)
+    // With 7 txes
+    CBlock block;
+    CDataStream stream(ParseHex("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"), SER_NETWORK, PROTOCOL_VERSION);
+    stream >> block;
+
+    CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
+    // Match the last transaction
+    filter.insert(uint256S("0x0a2a92f0bda4727d0a13eaddf4dd9ac6b5c61a1429e6b2b818f19b15df0ac154"));
+
+    CMerkleBlock merkleBlock(block, filter);
+    BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
+    std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0x0a2a92f0bda4727d0a13eaddf4dd9ac6b5c61a1429e6b2b818f19b15df0ac154"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 6);
+
+    std::vector<uint256> vMatched;
+    std::vector<unsigned int> vIndex;
+    BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
+    BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
+    for (unsigned int i = 0; i < vMatched.size(); i++)
+        BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
+
+    // Also match the 4th transaction
+    filter.insert(uint256S("0x02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"));
+    merkleBlock = CMerkleBlock(block, filter);
+    BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 2);
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0x02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"));
+    BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 3);
+
+    BOOST_CHECK(merkleBlock.vMatchedTxn[1] == pair);
+
+    BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
+    BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
+    for (unsigned int i = 0; i < vMatched.size(); i++)
+        BOOST_CHECK(vMatched[i] == merkleBlock.vMatchedTxn[i].second);
+}
+
+BOOST_AUTO_TEST_CASE(merkle_block_4_test_p2pubkey_only)
+{
+    // Random real block (000000000000b731f2eef9e8c63173adfb07e41bd53eb0ef0a6b720d6cb6dea4)
+    // With 7 txes
+    CBlock block;
+    CDataStream stream(ParseHex("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"), SER_NETWORK, PROTOCOL_VERSION);
+    stream >> block;
+
+    CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_P2PUBKEY_ONLY);
+    // Match the generation pubkey
+    filter.insert(ParseHex("04eaafc2314def4ca98ac970241bcab022b9c1e1f4ea423a20f134c876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce13ad1357231a2252247d97a46a91"));
+    // ...and the output address of the 4th transaction
+    filter.insert(ParseHex("b6efd80d99179f4f4ff6f4dd0a007d018c385d21"));
+
+    CMerkleBlock merkleBlock(block, filter);
+    BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
+
+    // We should match the generation outpoint
+    BOOST_CHECK(filter.contains(COutPoint(uint256S("0x147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b"), 0)));
+    // ... but not the 4th transaction's output (its not pay-2-pubkey)
+    BOOST_CHECK(!filter.contains(COutPoint(uint256S("0x02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"), 0)));
+}
+
+BOOST_AUTO_TEST_CASE(merkle_block_4_test_update_none)
+{
+    // Random real block (000000000000b731f2eef9e8c63173adfb07e41bd53eb0ef0a6b720d6cb6dea4)
+    // With 7 txes
+    CBlock block;
+    CDataStream stream(ParseHex("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"), SER_NETWORK, PROTOCOL_VERSION);
+    stream >> block;
+
+    CBloomFilter filter(10, 0.000001, 0, BLOOM_UPDATE_NONE);
+    // Match the generation pubkey
+    filter.insert(ParseHex("04eaafc2314def4ca98ac970241bcab022b9c1e1f4ea423a20f134c876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce13ad1357231a2252247d97a46a91"));
+    // ...and the output address of the 4th transaction
+    filter.insert(ParseHex("b6efd80d99179f4f4ff6f4dd0a007d018c385d21"));
+
+    CMerkleBlock merkleBlock(block, filter);
+    BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
+
+    // We shouldn't match any outpoints (UPDATE_NONE)
+    BOOST_CHECK(!filter.contains(COutPoint(uint256S("0x147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b"), 0)));
+    BOOST_CHECK(!filter.contains(COutPoint(uint256S("0x02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"), 0)));
+}
+
+static std::vector<unsigned char> RandomData()
+{
+    uint256 r = InsecureRand256();
+    return std::vector<unsigned char>(r.begin(), r.end());
+}
+
+BOOST_AUTO_TEST_CASE(rolling_bloom)
+{
+    // last-100-entry, 1% false positive:
+    CRollingBloomFilter rb1(100, 0.01);
+
+    // Overfill:
+    static const int DATASIZE=399;
+    std::vector<unsigned char> data[DATASIZE];
+    for (int i = 0; i < DATASIZE; i++) {
+        data[i] = RandomData();
+        rb1.insert(data[i]);
+    }
+    // Last 100 guaranteed to be remembered:
+    for (int i = 299; i < DATASIZE; i++) {
+        BOOST_CHECK(rb1.contains(data[i]));
+    }
+
+    // false positive rate is 1%, so we should get about 100 hits if
+    // testing 10,000 random keys. We get worst-case false positive
+    // behavior when the filter is as full as possible, which is
+    // when we've inserted one minus an integer multiple of nElement*2.
+    unsigned int nHits = 0;
+    for (int i = 0; i < 10000; i++) {
+        if (rb1.contains(RandomData()))
+            ++nHits;
+    }
+    // Run test_bitcoin with --log_level=message to see BOOST_TEST_MESSAGEs:
+    BOOST_TEST_MESSAGE("RollingBloomFilter got " << nHits << " false positives (~100 expected)");
+
+    // Insanely unlikely to get a fp count outside this range:
+    BOOST_CHECK(nHits > 25);
+    BOOST_CHECK(nHits < 175);
+
+    BOOST_CHECK(rb1.contains(data[DATASIZE-1]));
+    rb1.reset();
+    BOOST_CHECK(!rb1.contains(data[DATASIZE-1]));
+
+    // Now roll through data, make sure last 100 entries
+    // are always remembered:
+    for (int i = 0; i < DATASIZE; i++) {
+        if (i >= 100)
+            BOOST_CHECK(rb1.contains(data[i-100]));
+        rb1.insert(data[i]);
+        BOOST_CHECK(rb1.contains(data[i]));
+    }
+
+    // Insert 999 more random entries:
+    for (int i = 0; i < 999; i++) {
+        std::vector<unsigned char> d = RandomData();
+        rb1.insert(d);
+        BOOST_CHECK(rb1.contains(d));
+    }
+    // Sanity check to make sure the filter isn't just filling up:
+    nHits = 0;
+    for (int i = 0; i < DATASIZE; i++) {
+        if (rb1.contains(data[i]))
+            ++nHits;
+    }
+    // Expect about 5 false positives, more than 100 means
+    // something is definitely broken.
+    BOOST_TEST_MESSAGE("RollingBloomFilter got " << nHits << " false positives (~5 expected)");
+    BOOST_CHECK(nHits < 100);
+
+    // last-1000-entry, 0.01% false positive:
+    CRollingBloomFilter rb2(1000, 0.001);
+    for (int i = 0; i < DATASIZE; i++) {
+        rb2.insert(data[i]);
+    }
+    // ... room for all of them:
+    for (int i = 0; i < DATASIZE; i++) {
+        BOOST_CHECK(rb2.contains(data[i]));
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bswap_tests.cpp b/bswap_tests.cpp
new file mode 100644
index 0000000..18dd025
--- /dev/null
+++ b/bswap_tests.cpp
@@ -0,0 +1,26 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <compat/byteswap.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(bswap_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(bswap_tests)
+{
+	// Sibling in salemcash/src/qt/test/compattests.cpp
+	uint16_t u1 = 0x1234;
+	uint32_t u2 = 0x56789abc;
+	uint64_t u3 = 0xdef0123456789abc;
+	uint16_t e1 = 0x3412;
+	uint32_t e2 = 0xbc9a7856;
+	uint64_t e3 = 0xbc9a78563412f0de;
+	BOOST_CHECK(bswap_16(u1) == e1);
+	BOOST_CHECK(bswap_32(u2) == e2);
+	BOOST_CHECK(bswap_64(u3) == e3);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/cash_tests.cpp b/cash_tests.cpp
new file mode 100644
index 0000000..a8d8ca3
--- /dev/null
+++ b/cash_tests.cpp
@@ -0,0 +1,858 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <cash.h>
+#include <script/standard.h>
+#include <uint256.h>
+#include <undo.h>
+#include <utilstrencodings.h>
+#include <test/test_bitcoin.h>
+#include <validation.h>
+#include <consensus/validation.h>
+
+#include <vector>
+#include <map>
+
+#include <boost/test/unit_test.hpp>
+
+int ApplyTxInUndo(Cash&& undo, CCashViewCache& view, const COutPoint& out);
+void UpdateCash(const CTransaction& tx, CCashViewCache& inputs, CTxUndo &txundo, int nHeight);
+
+namespace
+{
+//! equality test
+bool operator==(const Cash &a, const Cash &b) {
+    // Empty Cash objects are always equal.
+    if (a.IsSpent() && b.IsSpent()) return true;
+    return a.fCashBase == b.fCashBase &&
+           a.nHeight == b.nHeight &&
+           a.out == b.out;
+}
+
+class CCashViewTest : public CCashView
+{
+    uint256 hashBestBlock_;
+    std::map<COutPoint, Cash> map_;
+
+public:
+    bool GetCash(const COutPoint& outpoint, Cash& cash) const override
+    {
+        std::map<COutPoint, Cash>::const_iterator it = map_.find(outpoint);
+        if (it == map_.end()) {
+            return false;
+        }
+        cash = it->second;
+        if (cash.IsSpent() && InsecureRandBool() == 0) {
+            // Randomly return false in case of an empty entry.
+            return false;
+        }
+        return true;
+    }
+
+    uint256 GetBestBlock() const override { return hashBestBlock_; }
+
+    bool BatchWrite(CCashMap& mapCash, const uint256& hashBlock) override
+    {
+        for (CCashMap::iterator it = mapCash.begin(); it != mapCash.end(); ) {
+            if (it->second.flags & CCashCacheEntry::DIRTY) {
+                // Same optimization used in CCashViewDB is to only write dirty entries.
+                map_[it->first] = it->second.cash;
+                if (it->second.cash.IsSpent() && InsecureRandRange(3) == 0) {
+                    // Randomly delete empty entries on write.
+                    map_.erase(it->first);
+                }
+            }
+            mapCash.erase(it++);
+        }
+        if (!hashBlock.IsNull())
+            hashBestBlock_ = hashBlock;
+        return true;
+    }
+};
+
+class CCashViewCacheTest : public CCashViewCache
+{
+public:
+    explicit CCashViewCacheTest(CCashView* _base) : CCashViewCache(_base) {}
+
+    void SelfTest() const
+    {
+        // Manually recompute the dynamic usage of the whole data, and compare it.
+        size_t ret = memusage::DynamicUsage(cacheCash);
+        size_t count = 0;
+        for (const auto& entry : cacheCash) {
+            ret += entry.second.cash.DynamicMemoryUsage();
+            ++count;
+        }
+        BOOST_CHECK_EQUAL(GetCacheSize(), count);
+        BOOST_CHECK_EQUAL(DynamicMemoryUsage(), ret);
+    }
+
+    CCashMap& map() const { return cacheCash; }
+    size_t& usage() const { return cachedCashUsage; }
+};
+
+} // namespace
+
+BOOST_FIXTURE_TEST_SUITE(cash_tests, BasicTestingSetup)
+
+static const unsigned int NUM_SIMULATION_ITERATIONS = 40000;
+
+// This is a large randomized insert/remove simulation test on a variable-size
+// stack of caches on top of CCoinsViewTest.
+//
+// It will randomly create/update/delete Cash entries to a tip of caches, with
+// txids picked from a limited list of random 256-bit hashes. Occasionally, a
+// new tip is added to the stack of caches, or the tip is flushed and removed.
+//
+// During the process, booleans are kept to make sure that the randomized
+// operation hits all branches.
+BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
+{
+    // Various coverage trackers.
+    bool removed_all_caches = false;
+    bool reached_4_caches = false;
+    bool added_an_entry = false;
+    bool added_an_unspendable_entry = false;
+    bool removed_an_entry = false;
+    bool updated_an_entry = false;
+    bool found_an_entry = false;
+    bool missed_an_entry = false;
+    bool uncached_an_entry = false;
+
+    // A simple map to track what we expect the cache stack to represent.
+    std::map<COutPoint, Cash> result;
+
+    // The cache stack.
+    CCashViewTest base; // A CCoinsViewTest at the bottom.
+    std::vector<CCashViewCacheTest*> stack; // A stack of CCashViewCaches on top.
+    stack.push_back(new CCashViewCacheTest(&base)); // Start with one cache.
+
+    // Use a limited set of random transaction ids, so we do test overwriting entries.
+    std::vector<uint256> txids;
+    txids.resize(NUM_SIMULATION_ITERATIONS / 8);
+    for (unsigned int i = 0; i < txids.size(); i++) {
+        txids[i] = InsecureRand256();
+    }
+
+    for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
+        // Do a random modification.
+        {
+            uint256 txid = txids[InsecureRandRange(txids.size())]; // txid we're going to modify in this iteration.
+            Cash& cash = result[COutPoint(txid, 0)];
+
+            // Determine whether to test HaveCash before or after Access* (or both). As these functions
+            // can influence each other's behaviour by pulling things into the cache, all combinations
+            // are tested.
+            bool test_havecash_before = InsecureRandBits(2) == 0;
+            bool test_havecash_after = InsecureRandBits(2) == 0;
+
+            bool result_havecash = test_havecash_before ? stack.back()->HaveCash(COutPoint(txid, 0)) : false;
+            const Cash& entry = (InsecureRandRange(500) == 0) ? AccessByTxid(*stack.back(), txid) : stack.back()->AccessCoin(COutPoint(txid, 0));
+            BOOST_CHECK(cash == entry);
+            BOOST_CHECK(!test_havecash_before || result_havecash == !entry.IsSpent());
+
+            if (test_havecash_after) {
+                bool ret = stack.back()->HaveCash(COutPoint(txid, 0));
+                BOOST_CHECK(ret == !entry.IsSpent());
+            }
+
+            if (InsecureRandRange(5) == 0 || cash.IsSpent()) {
+                Cash newcash;
+                newcash.out.nValue = InsecureRand32();
+                newcash.nHeight = 1;
+                if (InsecureRandRange(16) == 0 && cash.IsSpent()) {
+                    newcash.out.scriptPubKey.assign(1 + InsecureRandBits(6), OP_RETURN);
+                    BOOST_CHECK(newcash.out.scriptPubKey.IsUnspendable());
+                    added_an_unspendable_entry = true;
+                } else {
+                    newcash.out.scriptPubKey.assign(InsecureRandBits(6), 0); // Random sizes so we can test memory usage accounting
+                    (cash.IsSpent() ? added_an_entry : updated_an_entry) = true;
+                    cash = newcash;
+                }
+                stack.back()->AddCash(COutPoint(txid, 0), std::move(newcoin), !cash.IsSpent() || InsecureRand32() & 1);
+            } else {
+                removed_an_entry = true;
+                cash.Clear();
+                stack.back()->SpendCash(COutPoint(txid, 0));
+            }
+        }
+
+        // One every 10 iterations, remove a random entry from the cache
+        if (InsecureRandRange(10) == 0) {
+            COutPoint out(txids[InsecureRand32() % txids.size()], 0);
+            int cacheid = InsecureRand32() % stack.size();
+            stack[cacheid]->Uncache(out);
+            uncached_an_entry |= !stack[cacheid]->HaveCashInCache(out);
+        }
+
+        // Once every 1000 iterations and at the end, verify the full cache.
+        if (InsecureRandRange(1000) == 1 || i == NUM_SIMULATION_ITERATIONS - 1) {
+            for (const auto& entry : result) {
+                bool have = stack.back()->HaveCash(entry.first);
+                const Cash& cash = stack.back()->AccessCoin(entry.first);
+                BOOST_CHECK(have == !cash.IsSpent());
+                BOOST_CHECK(cash == entry.second);
+                if (cash.IsSpent()) {
+                    missed_an_entry = true;
+                } else {
+                    BOOST_CHECK(stack.back()->HaveCashInCache(entry.first));
+                    found_an_entry = true;
+                }
+            }
+            for (const CCashViewCacheTest *test : stack) {
+                test->SelfTest();
+            }
+        }
+
+        if (InsecureRandRange(100) == 0) {
+            // Every 100 iterations, flush an intermediate cache
+            if (stack.size() > 1 && InsecureRandBool() == 0) {
+                unsigned int flushIndex = InsecureRandRange(stack.size() - 1);
+                stack[flushIndex]->Flush();
+            }
+        }
+        if (InsecureRandRange(100) == 0) {
+            // Every 100 iterations, change the cache stack.
+            if (stack.size() > 0 && InsecureRandBool() == 0) {
+                //Remove the top cache
+                stack.back()->Flush();
+                delete stack.back();
+                stack.pop_back();
+            }
+            if (stack.size() == 0 || (stack.size() < 4 && InsecureRandBool())) {
+                //Add a new cache
+                CCashView* tip = &base;
+                if (stack.size() > 0) {
+                    tip = stack.back();
+                } else {
+                    removed_all_caches = true;
+                }
+                stack.push_back(new CCashViewCacheTest(tip));
+                if (stack.size() == 4) {
+                    reached_4_caches = true;
+                }
+            }
+        }
+    }
+
+    // Clean up the stack.
+    while (stack.size() > 0) {
+        delete stack.back();
+        stack.pop_back();
+    }
+
+    // Verify coverage.
+    BOOST_CHECK(removed_all_caches);
+    BOOST_CHECK(reached_4_caches);
+    BOOST_CHECK(added_an_entry);
+    BOOST_CHECK(added_an_unspendable_entry);
+    BOOST_CHECK(removed_an_entry);
+    BOOST_CHECK(updated_an_entry);
+    BOOST_CHECK(found_an_entry);
+    BOOST_CHECK(missed_an_entry);
+    BOOST_CHECK(uncached_an_entry);
+}
+
+// Store of all necessary tx and undo data for next test
+typedef std::map<COutPoint, std::tuple<CTransaction,CTxUndo,Cash>> UtxoData;
+UtxoData utxoData;
+
+UtxoData::iterator FindRandomFrom(const std::set<COutPoint> &utxoSet) {
+    assert(utxoSet.size());
+    auto utxoSetIt = utxoSet.lower_bound(COutPoint(InsecureRand256(), 0));
+    if (utxoSetIt == utxoSet.end()) {
+        utxoSetIt = utxoSet.begin();
+    }
+    auto utxoDataIt = utxoData.find(*utxoSetIt);
+    assert(utxoDataIt != utxoData.end());
+    return utxoDataIt;
+}
+
+
+// This test is similar to the previous test
+// except the emphasis is on testing the functionality of UpdateCash
+// random txs are created and UpdateCash is used to update the cache stack
+// In particular it is tested that spending a duplicate cashbase tx
+// has the expected effect (the other duplicate is overwritten at all cache levels)
+BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
+{
+    bool spent_a_duplicate_cashbase = false;
+    // A simple map to track what we expect the cache stack to represent.
+    std::map<COutPoint, Cash> result;
+
+    // The cache stack.
+    CCashViewTest base; // A CCashViewTest at the bottom.
+    std::vector<CCashViewCacheTest*> stack; // A stack of CCashViewCaches on top.
+    stack.push_back(new CCashViewCacheTest(&base)); // Start with one cache.
+
+    // Track the txids we've used in various sets
+    std::set<COutPoint> cashbase_cash;
+    std::set<COutPoint> disconnected_cash;
+    std::set<COutPoint> duplicate_cash;
+    std::set<COutPoint> utxoset;
+
+    for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
+        uint32_t randiter = InsecureRand32();
+
+        // 19/20 txs add a new transaction
+        if (randiter % 20 < 19) {
+            CMutableTransaction tx;
+            tx.vin.resize(1);
+            tx.vout.resize(1);
+            tx.vout[0].nValue = i; //Keep txs unique unless intended to duplicate
+            tx.vout[0].scriptPubKey.assign(InsecureRand32() & 0x3F, 0); // Random sizes so we can test memory usage accounting
+            unsigned int height = InsecureRand32();
+            Coin old_coin;
+
+            // 2/20 times create a new cashbase
+            if (randiter % 20 < 2 || cashbase_cash.size() < 10) {
+                // 1/10 of those times create a duplicate cashbase
+                if (InsecureRandRange(10) == 0 && cashbase_cash.size()) {
+                    auto utxod = FindRandomFrom(cashbase_cash);
+                    // Reuse the exact same cashbase
+                    tx = std::get<0>(utxod->second);
+                    // shouldn't be available for reconnection if it's been duplicated
+                    disconnected_cash.erase(utxod->first);
+
+                    duplicate_cash.insert(utxod->first);
+                }
+                else {
+                    cashbase_cash.insert(COutPoint(tx.GetHash(), 0));
+                }
+                assert(CTransaction(tx).IsCoinBase());
+            }
+
+            // 17/20 times reconnect previous or add a regular tx
+            else {
+
+                COutPoint prevout;
+                // 1/20 times reconnect a previously disconnected tx
+                if (randiter % 20 == 2 && disconnected_cash.size()) {
+                    auto utxod = FindRandomFrom(disconnected_cash);
+                    tx = std::get<0>(utxod->second);
+                    prevout = tx.vin[0].prevout;
+                    if (!CTransaction(tx).IsCoinBase() && !utxoset.count(prevout)) {
+                        disconnected_cash.erase(utxod->first);
+                        continue;
+                    }
+
+                    // If this tx is already IN the UTXO, then it must be a cashbase, and it must be a duplicate
+                    if (utxoset.count(utxod->first)) {
+                        assert(CTransaction(tx).IsCoinBase());
+                        assert(duplicate_cash.count(utxod->first));
+                    }
+                    disconnected_cash.erase(utxod->first);
+                }
+
+                // 16/20 times create a regular tx
+                else {
+                    auto utxod = FindRandomFrom(utxoset);
+                    prevout = utxod->first;
+
+                    // Construct the tx to spend the cash of prevouthash
+                    tx.vin[0].prevout = prevout;
+                    assert(!CTransaction(tx).IsCoinBase());
+                }
+                // In this simple test cash only have two states, spent or unspent, save the unspent state to restore
+                old_coin = result[prevout];
+                // Update the expected result of prevouthash to know these coins are spent
+                result[prevout].Clear();
+
+                utxoset.erase(prevout);
+
+                // The test is designed to ensure spending a duplicate cashbase will work properly
+                // if that ever happens and not resurrect the previously overwritten cashbase
+                if (duplicate_cash.count(prevout)) {
+                    spent_a_duplicate_cashbase = true;
+                }
+
+            }
+            // Update the expected result to know about the new output coins
+            assert(tx.vout.size() == 1);
+            const COutPoint outpoint(tx.GetHash(), 0);
+            result[outpoint] = Cash(tx.vout[0], height, CTransaction(tx).IsCoinBase());
+
+            // Call UpdateCash on the top cache
+            CTxUndo undo;
+            UpdateCash(tx, *(stack.back()), undo, height);
+
+            // Update the utxo set for future spends
+            utxoset.insert(outpoint);
+
+            // Track this tx and undo info to use later
+            utxoData.emplace(outpoint, std::make_tuple(tx,undo,old_coin));
+        } else if (utxoset.size()) {
+            //1/20 times undo a previous transaction
+            auto utxod = FindRandomFrom(utxoset);
+
+            CTransaction &tx = std::get<0>(utxod->second);
+            CTxUndo &undo = std::get<1>(utxod->second);
+            Cash &orig_cash = std::get<2>(utxod->second);
+
+            // Update the expected result
+            // Remove new outputs
+            result[utxod->first].Clear();
+            // If not coinbase restore prevout
+            if (!tx.IsCoinBase()) {
+                result[tx.vin[0].prevout] = orig_coin;
+            }
+
+            // Disconnect the tx from the current UTXO
+            // See code in DisconnectBlock
+            // remove outputs
+            stack.back()->SpendCoin(utxod->first);
+            // restore inputs
+            if (!tx.IsCoinBase()) {
+                const COutPoint &out = tx.vin[0].prevout;
+                Cash cash = undo.vprevout[0];
+                ApplyTxInUndo(std::move(cash), *(stack.back()), out);
+            }
+            // Store as a candidate for reconnection
+            disconnected_cash.insert(utxod->first);
+
+            // Update the utxoset
+            utxoset.erase(utxod->first);
+            if (!tx.IsCoinBase())
+                utxoset.insert(tx.vin[0].prevout);
+        }
+
+        // Once every 1000 iterations and at the end, verify the full cache.
+        if (InsecureRandRange(1000) == 1 || i == NUM_SIMULATION_ITERATIONS - 1) {
+            for (const auto& entry : result) {
+                bool have = stack.back()->HaveCoin(entry.first);
+                const Cash& cash = stack.back()->AccessCoin(entry.first);
+                BOOST_CHECK(have == !cash.IsSpent());
+                BOOST_CHECK(cash == entry.second);
+            }
+        }
+
+        // One every 10 iterations, remove a random entry from the cache
+        if (utxoset.size() > 1 && InsecureRandRange(30) == 0) {
+            stack[InsecureRand32() % stack.size()]->Uncache(FindRandomFrom(utxoset)->first);
+        }
+        if (disconnected_cash.size() > 1 && InsecureRandRange(30) == 0) {
+            stack[InsecureRand32() % stack.size()]->Uncache(FindRandomFrom(disconnected_coins)->first);
+        }
+        if (duplicate_cash.size() > 1 && InsecureRandRange(30) == 0) {
+            stack[InsecureRand32() % stack.size()]->Uncache(FindRandomFrom(duplicate_cash)->first);
+        }
+
+        if (InsecureRandRange(100) == 0) {
+            // Every 100 iterations, flush an intermediate cache
+            if (stack.size() > 1 && InsecureRandBool() == 0) {
+                unsigned int flushIndex = InsecureRandRange(stack.size() - 1);
+                stack[flushIndex]->Flush();
+            }
+        }
+        if (InsecureRandRange(100) == 0) {
+            // Every 100 iterations, change the cache stack.
+            if (stack.size() > 0 && InsecureRandBool() == 0) {
+                stack.back()->Flush();
+                delete stack.back();
+                stack.pop_back();
+            }
+            if (stack.size() == 0 || (stack.size() < 4 && InsecureRandBool())) {
+                CCashView* tip = &base;
+                if (stack.size() > 0) {
+                    tip = stack.back();
+                }
+                stack.push_back(new CCashViewCacheTest(tip));
+            }
+        }
+    }
+
+    // Clean up the stack.
+    while (stack.size() > 0) {
+        delete stack.back();
+        stack.pop_back();
+    }
+
+    // Verify coverage.
+    BOOST_CHECK(spent_a_duplicate_coinbase);
+}
+
+BOOST_AUTO_TEST_CASE(ccash_serialization)
+{
+    // Good example
+    CDataStream ss1(ParseHex("97f23c835800816115944e077fe7c803cfa57f29b36bf87c1d35"), SER_DISK, CLIENT_VERSION);
+    Cash cc1;
+    ss1 >> cc1;
+    BOOST_CHECK_EQUAL(cc1.fCashBase, false);
+    BOOST_CHECK_EQUAL(cc1.nHeight, 203998);
+    BOOST_CHECK_EQUAL(cc1.out.nValue, 60000000000ULL);
+    BOOST_CHECK_EQUAL(HexStr(cc1.out.scriptPubKey), HexStr(GetScriptForDestination(CKeyID(uint160(ParseHex("816115944e077fe7c803cfa57f29b36bf87c1d35"))))));
+
+    // Good example
+    CDataStream ss2(ParseHex("8ddf77bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4"), SER_DISK, CLIENT_VERSION);
+    Cash cc2;
+    ss2 >> cc2;
+    BOOST_CHECK_EQUAL(cc2.fCashBase, true);
+    BOOST_CHECK_EQUAL(cc2.nHeight, 120891);
+    BOOST_CHECK_EQUAL(cc2.out.nValue, 110397);
+    BOOST_CHECK_EQUAL(HexStr(cc2.out.scriptPubKey), HexStr(GetScriptForDestination(CKeyID(uint160(ParseHex("8c988f1a4a4de2161e0f50aac7f17e7f9555caa4"))))));
+
+    // Smallest possible example
+    CDataStream ss3(ParseHex("000006"), SER_DISK, CLIENT_VERSION);
+    Cash cc3;
+    ss3 >> cc3;
+    BOOST_CHECK_EQUAL(cc3.fCashBase, false);
+    BOOST_CHECK_EQUAL(cc3.nHeight, 0);
+    BOOST_CHECK_EQUAL(cc3.out.nValue, 0);
+    BOOST_CHECK_EQUAL(cc3.out.scriptPubKey.size(), 0);
+
+    // scriptPubKey that ends beyond the end of the stream
+    CDataStream ss4(ParseHex("000007"), SER_DISK, CLIENT_VERSION);
+    try {
+        Cash cc4;
+        ss4 >> cc4;
+        BOOST_CHECK_MESSAGE(false, "We should have thrown");
+    } catch (const std::ios_base::failure& e) {
+    }
+
+    // Very large scriptPubKey (3*10^9 bytes) past the end of the stream
+    CDataStream tmp(SER_DISK, CLIENT_VERSION);
+    uint64_t x = 3000000000ULL;
+    tmp << VARINT(x);
+    BOOST_CHECK_EQUAL(HexStr(tmp.begin(), tmp.end()), "8a95c0bb00");
+    CDataStream ss5(ParseHex("00008a95c0bb00"), SER_DISK, CLIENT_VERSION);
+    try {
+        Coin cc5;
+        ss5 >> cc5;
+        BOOST_CHECK_MESSAGE(false, "We should have thrown");
+    } catch (const std::ios_base::failure& e) {
+    }
+}
+
+const static COutPoint OUTPOINT;
+const static CAmount PRUNED = -1;
+const static CAmount ABSENT = -2;
+const static CAmount FAIL = -3;
+const static CAmount VALUE1 = 100;
+const static CAmount VALUE2 = 200;
+const static CAmount VALUE3 = 300;
+const static char DIRTY = CCashCacheEntry::DIRTY;
+const static char FRESH = CCashCacheEntry::FRESH;
+const static char NO_ENTRY = -1;
+
+const static auto FLAGS = {char(0), FRESH, DIRTY, char(DIRTY | FRESH)};
+const static auto CLEAN_FLAGS = {char(0), FRESH};
+const static auto ABSENT_FLAGS = {NO_ENTRY};
+
+void SetCashValue(CAmount value, Cash& cash)
+{
+    assert(value != ABSENT);
+    cash.Clear();
+    assert(cash.IsSpent());
+    if (value != PRUNED) {
+        cash.out.nValue = value;
+        cash.nHeight = 1;
+        assert(!cash.IsSpent());
+    }
+}
+
+size_t InsertCashMapEntry(CCashMap& map, CAmount value, char flags)
+{
+    if (value == ABSENT) {
+        assert(flags == NO_ENTRY);
+        return 0;
+    }
+    assert(flags != NO_ENTRY);
+    CCashCacheEntry entry;
+    entry.flags = flags;
+    SetCashValue(value, entry.cash);
+    auto inserted = map.emplace(OUTPOINT, std::move(entry));
+    assert(inserted.second);
+    return inserted.first->second.cash.DynamicMemoryUsage();
+}
+
+void GetCashMapEntry(const CCashMap& map, CAmount& value, char& flags)
+{
+    auto it = map.find(OUTPOINT);
+    if (it == map.end()) {
+        value = ABSENT;
+        flags = NO_ENTRY;
+    } else {
+        if (it->second.cash.IsSpent()) {
+            value = PRUNED;
+        } else {
+            value = it->second.cash.out.nValue;
+        }
+        flags = it->second.flags;
+        assert(flags != NO_ENTRY);
+    }
+}
+
+void WriteCashViewEntry(CCashView& view, CAmount value, char flags)
+{
+    CCashMap map;
+    InsertCashMapEntry(map, value, flags);
+    view.BatchWrite(map, {});
+}
+
+class SingleEntryCacheTest
+{
+public:
+    SingleEntryCacheTest(CAmount base_value, CAmount cache_value, char cache_flags)
+    {
+        WriteCoinsViewEntry(base, base_value, base_value == ABSENT ? NO_ENTRY : DIRTY);
+        cache.usage() += InsertCoinsMapEntry(cache.map(), cache_value, cache_flags);
+    }
+
+    CCashView root;
+    CCashViewCacheTest base{&root};
+    CCashViewCacheTest cache{&base};
+};
+
+void CheckAccessCash(CAmount base_value, CAmount cache_value, CAmount expected_value, char cache_flags, char expected_flags)
+{
+    SingleEntryCacheTest test(base_value, cache_value, cache_flags);
+    test.cache.AccessCash(OUTPOINT);
+    test.cache.SelfTest();
+
+    CAmount result_value;
+    char result_flags;
+    GetCoinsMapEntry(test.cache.map(), result_value, result_flags);
+    BOOST_CHECK_EQUAL(result_value, expected_value);
+    BOOST_CHECK_EQUAL(result_flags, expected_flags);
+}
+
+BOOST_AUTO_TEST_CASE(ccash_access)
+{
+    /* Check AccessCash behavior, requesting the cash from a cache view layered on
+     * top of a base view, and checking the resulting entry in the cache after
+     * the access.
+     *
+     *               Base    Cache   Result  Cache        Result
+     *               Value   Value   Value   Flags        Flags
+     */
+    CheckAccessCash(ABSENT, ABSENT, ABSENT, NO_ENTRY   , NO_ENTRY   );
+    CheckAccessCash(ABSENT, PRUNED, PRUNED, 0          , 0          );
+    CheckAccessCash(ABSENT, PRUNED, PRUNED, FRESH      , FRESH      );
+    CheckAccessCash(ABSENT, PRUNED, PRUNED, DIRTY      , DIRTY      );
+    CheckAccessCash(ABSENT, PRUNED, PRUNED, DIRTY|FRESH, DIRTY|FRESH);
+    CheckAccessCash(ABSENT, VALUE2, VALUE2, 0          , 0          );
+    CheckAccessCash(ABSENT, VALUE2, VALUE2, FRESH      , FRESH      );
+    CheckAccessCash(ABSENT, VALUE2, VALUE2, DIRTY      , DIRTY      );
+    CheckAccessCash(ABSENT, VALUE2, VALUE2, DIRTY|FRESH, DIRTY|FRESH);
+    CheckAccessCash(PRUNED, ABSENT, ABSENT, NO_ENTRY   , NO_ENTRY   );
+    CheckAccessCash(PRUNED, PRUNED, PRUNED, 0          , 0          );
+    CheckAccessCash(PRUNED, PRUNED, PRUNED, FRESH      , FRESH      );
+    CheckAccessCash(PRUNED, PRUNED, PRUNED, DIRTY      , DIRTY      );
+    CheckAccessCash(PRUNED, PRUNED, PRUNED, DIRTY|FRESH, DIRTY|FRESH);
+    CheckAccessCash(PRUNED, VALUE2, VALUE2, 0          , 0          );
+    CheckAccessCash(PRUNED, VALUE2, VALUE2, FRESH      , FRESH      );
+    CheckAccessCash(PRUNED, VALUE2, VALUE2, DIRTY      , DIRTY      );
+    CheckAccessCash(PRUNED, VALUE2, VALUE2, DIRTY|FRESH, DIRTY|FRESH);
+    CheckAccessCash(VALUE1, ABSENT, VALUE1, NO_ENTRY   , 0          );
+    CheckAccessCash(VALUE1, PRUNED, PRUNED, 0          , 0          );
+    CheckAccessCash(VALUE1, PRUNED, PRUNED, FRESH      , FRESH      );
+    CheckAccessCash(VALUE1, PRUNED, PRUNED, DIRTY      , DIRTY      );
+    CheckAccessCash(VALUE1, PRUNED, PRUNED, DIRTY|FRESH, DIRTY|FRESH);
+    CheckAccessCash(VALUE1, VALUE2, VALUE2, 0          , 0          );
+    CheckAccessCash(VALUE1, VALUE2, VALUE2, FRESH      , FRESH      );
+    CheckAccessCash(VALUE1, VALUE2, VALUE2, DIRTY      , DIRTY      );
+    CheckAccessCash(VALUE1, VALUE2, VALUE2, DIRTY|FRESH, DIRTY|FRESH);
+}
+
+void CheckSpendCash(CAmount base_value, CAmount cache_value, CAmount expected_value, char cache_flags, char expected_flags)
+{
+    SingleEntryCacheTest test(base_value, cache_value, cache_flags);
+    test.cache.SpendCash(OUTPOINT);
+    test.cache.SelfTest();
+
+    CAmount result_value;
+    char result_flags;
+    GetCashMapEntry(test.cache.map(), result_value, result_flags);
+    BOOST_CHECK_EQUAL(result_value, expected_value);
+    BOOST_CHECK_EQUAL(result_flags, expected_flags);
+};
+
+BOOST_AUTO_TEST_CASE(ccash_spend)
+{
+    /* Check SpendCash behavior, requesting the Cash from a cache view layered on
+     * top of a base view, spending, and then checking
+     * the resulting entry in the cache after the modification.
+     *
+     *              Base    Cache   Result  Cache        Result
+     *              Value   Value   Value   Flags        Flags
+     */
+    CheckSpendCash(ABSENT, ABSENT, ABSENT, NO_ENTRY   , NO_ENTRY   );
+    CheckSpendCash(ABSENT, PRUNED, PRUNED, 0          , DIRTY      );
+    CheckSpendCash(ABSENT, PRUNED, ABSENT, FRESH      , NO_ENTRY   );
+    CheckSpendCash(ABSENT, PRUNED, PRUNED, DIRTY      , DIRTY      );
+    CheckSpendCash(ABSENT, PRUNED, ABSENT, DIRTY|FRESH, NO_ENTRY   );
+    CheckSpendCash(ABSENT, VALUE2, PRUNED, 0          , DIRTY      );
+    CheckSpendCash(ABSENT, VALUE2, ABSENT, FRESH      , NO_ENTRY   );
+    CheckSpendCash(ABSENT, VALUE2, PRUNED, DIRTY      , DIRTY      );
+    CheckSpendCash(ABSENT, VALUE2, ABSENT, DIRTY|FRESH, NO_ENTRY   );
+    CheckSpendCash(PRUNED, ABSENT, ABSENT, NO_ENTRY   , NO_ENTRY   );
+    CheckSpendCash(PRUNED, PRUNED, PRUNED, 0          , DIRTY      );
+    CheckSpendCash(PRUNED, PRUNED, ABSENT, FRESH      , NO_ENTRY   );
+    CheckSpendCash(PRUNED, PRUNED, PRUNED, DIRTY      , DIRTY      );
+    CheckSpendCash(PRUNED, PRUNED, ABSENT, DIRTY|FRESH, NO_ENTRY   );
+    CheckSpendCash(PRUNED, VALUE2, PRUNED, 0          , DIRTY      );
+    CheckSpendCash(PRUNED, VALUE2, ABSENT, FRESH      , NO_ENTRY   );
+    CheckSpendCash(PRUNED, VALUE2, PRUNED, DIRTY      , DIRTY      );
+    CheckSpendCash(PRUNED, VALUE2, ABSENT, DIRTY|FRESH, NO_ENTRY   );
+    CheckSpendCash(VALUE1, ABSENT, PRUNED, NO_ENTRY   , DIRTY      );
+    CheckSpendCash(VALUE1, PRUNED, PRUNED, 0          , DIRTY      );
+    CheckSpendCash(VALUE1, PRUNED, ABSENT, FRESH      , NO_ENTRY   );
+    CheckSpendCash(VALUE1, PRUNED, PRUNED, DIRTY      , DIRTY      );
+    CheckSpendCash(VALUE1, PRUNED, ABSENT, DIRTY|FRESH, NO_ENTRY   );
+    CheckSpendCash(VALUE1, VALUE2, PRUNED, 0          , DIRTY      );
+    CheckSpendCash(VALUE1, VALUE2, ABSENT, FRESH      , NO_ENTRY   );
+    CheckSpendCash(VALUE1, VALUE2, PRUNED, DIRTY      , DIRTY      );
+    CheckSpendCash(VALUE1, VALUE2, ABSENT, DIRTY|FRESH, NO_ENTRY   );
+}
+
+void CheckAddCashBase(CAmount base_value, CAmount cache_value, CAmount modify_value, CAmount expected_value, char cache_flags, char expected_flags, bool cashbase)
+{
+    SingleEntryCacheTest test(base_value, cache_value, cache_flags);
+
+    CAmount result_value;
+    char result_flags;
+    try {
+        CTxOut output;
+        output.nValue = modify_value;
+        test.cache.AddCoin(OUTPOINT, Cash(std::move(output), 1, cashbase), cashbase);
+        test.cache.SelfTest();
+        GetCashMapEntry(test.cache.map(), result_value, result_flags);
+    } catch (std::logic_error& e) {
+        result_value = FAIL;
+        result_flags = NO_ENTRY;
+    }
+
+    BOOST_CHECK_EQUAL(result_value, expected_value);
+    BOOST_CHECK_EQUAL(result_flags, expected_flags);
+}
+
+// Simple wrapper for CheckAddCashBase function above that loops through
+// different possible base_values, making sure each one gives the same results.
+// This wrapper lets the cash_add test below be shorter and less repetitive,
+// while still verifying that the CashViewCache::AddCash implementation
+// ignores base values.
+template <typename... Args>
+void CheckAddCash(Args&&... args)
+{
+    for (CAmount base_value : {ABSENT, PRUNED, VALUE1})
+        CheckAddCashBase(base_value, std::forward<Args>(args)...);
+}
+
+BOOST_AUTO_TEST_CASE(ccash_add)
+{
+    /* Check AddCash behavior, requesting a new cash from a cache view,
+     * writing a modification to the cash, and then checking the resulting
+     * entry in the cache after the modification. Verify behavior with the
+     * with the AddCash potential_overwrite argument set to false, and to true.
+     *
+     *           Cache   Write   Result  Cache        Result       potential_overwrite
+     *           Value   Value   Value   Flags        Flags
+     */
+    CheckAddCash(ABSENT, VALUE3, VALUE3, NO_ENTRY   , DIRTY|FRESH, false);
+    CheckAddCash(ABSENT, VALUE3, VALUE3, NO_ENTRY   , DIRTY      , true );
+    CheckAddCash(PRUNED, VALUE3, VALUE3, 0          , DIRTY|FRESH, false);
+    CheckAddCash(PRUNED, VALUE3, VALUE3, 0          , DIRTY      , true );
+    CheckAddCash(PRUNED, VALUE3, VALUE3, FRESH      , DIRTY|FRESH, false);
+    CheckAddCash(PRUNED, VALUE3, VALUE3, FRESH      , DIRTY|FRESH, true );
+    CheckAddCash(PRUNED, VALUE3, VALUE3, DIRTY      , DIRTY      , false);
+    CheckAddCash(PRUNED, VALUE3, VALUE3, DIRTY      , DIRTY      , true );
+    CheckAddCash(PRUNED, VALUE3, VALUE3, DIRTY|FRESH, DIRTY|FRESH, false);
+    CheckAddCash(PRUNED, VALUE3, VALUE3, DIRTY|FRESH, DIRTY|FRESH, true );
+    CheckAddCash(VALUE2, VALUE3, FAIL  , 0          , NO_ENTRY   , false);
+    CheckAddCash(VALUE2, VALUE3, VALUE3, 0          , DIRTY      , true );
+    CheckAddCash(VALUE2, VALUE3, FAIL  , FRESH      , NO_ENTRY   , false);
+    CheckAddCash(VALUE2, VALUE3, VALUE3, FRESH      , DIRTY|FRESH, true );
+    CheckAddCash(VALUE2, VALUE3, FAIL  , DIRTY      , NO_ENTRY   , false);
+    CheckAddCash(VALUE2, VALUE3, VALUE3, DIRTY      , DIRTY      , true );
+    CheckAddCash(VALUE2, VALUE3, FAIL  , DIRTY|FRESH, NO_ENTRY   , false);
+    CheckAddCash(VALUE2, VALUE3, VALUE3, DIRTY|FRESH, DIRTY|FRESH, true );
+}
+
+void CheckWriteCash(CAmount parent_value, CAmount child_value, CAmount expected_value, char parent_flags, char child_flags, char expected_flags)
+{
+    SingleEntryCacheTest test(ABSENT, parent_value, parent_flags);
+
+    CAmount result_value;
+    char result_flags;
+    try {
+        WriteCashViewEntry(test.cache, child_value, child_flags);
+        test.cache.SelfTest();
+        GetCashMapEntry(test.cache.map(), result_value, result_flags);
+    } catch (std::logic_error& e) {
+        result_value = FAIL;
+        result_flags = NO_ENTRY;
+    }
+
+    BOOST_CHECK_EQUAL(result_value, expected_value);
+    BOOST_CHECK_EQUAL(result_flags, expected_flags);
+}
+
+BOOST_AUTO_TEST_CASE(ccash_write)
+{
+    /* Check BatchWrite behavior, flushing one entry from a child cache to a
+     * parent cache, and checking the resulting entry in the parent cache
+     * after the write.
+     *
+     *              Parent  Child   Result  Parent       Child        Result
+     *              Value   Value   Value   Flags        Flags        Flags
+     */
+    CheckWriteCash(ABSENT, ABSENT, ABSENT, NO_ENTRY   , NO_ENTRY   , NO_ENTRY   );
+    CheckWriteCash(ABSENT, PRUNED, PRUNED, NO_ENTRY   , DIRTY      , DIRTY      );
+    CheckWriteCash(ABSENT, PRUNED, ABSENT, NO_ENTRY   , DIRTY|FRESH, NO_ENTRY   );
+    CheckWriteCash(ABSENT, VALUE2, VALUE2, NO_ENTRY   , DIRTY      , DIRTY      );
+    CheckWriteCash(ABSENT, VALUE2, VALUE2, NO_ENTRY   , DIRTY|FRESH, DIRTY|FRESH);
+    CheckWriteCash(PRUNED, ABSENT, PRUNED, 0          , NO_ENTRY   , 0          );
+    CheckWriteCash(PRUNED, ABSENT, PRUNED, FRESH      , NO_ENTRY   , FRESH      );
+    CheckWriteCash(PRUNED, ABSENT, PRUNED, DIRTY      , NO_ENTRY   , DIRTY      );
+    CheckWriteCash(PRUNED, ABSENT, PRUNED, DIRTY|FRESH, NO_ENTRY   , DIRTY|FRESH);
+    CheckWriteCash(PRUNED, PRUNED, PRUNED, 0          , DIRTY      , DIRTY      );
+    CheckWriteCash(PRUNED, PRUNED, PRUNED, 0          , DIRTY|FRESH, DIRTY      );
+    CheckWriteCash(PRUNED, PRUNED, ABSENT, FRESH      , DIRTY      , NO_ENTRY   );
+    CheckWriteCash(PRUNED, PRUNED, ABSENT, FRESH      , DIRTY|FRESH, NO_ENTRY   );
+    CheckWriteCash(PRUNED, PRUNED, PRUNED, DIRTY      , DIRTY      , DIRTY      );
+    CheckWriteCash(PRUNED, PRUNED, PRUNED, DIRTY      , DIRTY|FRESH, DIRTY      );
+    CheckWriteCash(PRUNED, PRUNED, ABSENT, DIRTY|FRESH, DIRTY      , NO_ENTRY   );
+    CheckWriteCash(PRUNED, PRUNED, ABSENT, DIRTY|FRESH, DIRTY|FRESH, NO_ENTRY   );
+    CheckWriteCash(PRUNED, VALUE2, VALUE2, 0          , DIRTY      , DIRTY      );
+    CheckWriteCash(PRUNED, VALUE2, VALUE2, 0          , DIRTY|FRESH, DIRTY      );
+    CheckWriteCash(PRUNED, VALUE2, VALUE2, FRESH      , DIRTY      , DIRTY|FRESH);
+    CheckWriteCash(PRUNED, VALUE2, VALUE2, FRESH      , DIRTY|FRESH, DIRTY|FRESH);
+    CheckWriteCash(PRUNED, VALUE2, VALUE2, DIRTY      , DIRTY      , DIRTY      );
+    CheckWriteCash(PRUNED, VALUE2, VALUE2, DIRTY      , DIRTY|FRESH, DIRTY      );
+    CheckWriteCash(PRUNED, VALUE2, VALUE2, DIRTY|FRESH, DIRTY      , DIRTY|FRESH);
+    CheckWriteCash(PRUNED, VALUE2, VALUE2, DIRTY|FRESH, DIRTY|FRESH, DIRTY|FRESH);
+    CheckWriteCash(VALUE1, ABSENT, VALUE1, 0          , NO_ENTRY   , 0          );
+    CheckWriteCash(VALUE1, ABSENT, VALUE1, FRESH      , NO_ENTRY   , FRESH      );
+    CheckWriteCash(VALUE1, ABSENT, VALUE1, DIRTY      , NO_ENTRY   , DIRTY      );
+    CheckWriteCash(VALUE1, ABSENT, VALUE1, DIRTY|FRESH, NO_ENTRY   , DIRTY|FRESH);
+    CheckWriteCash(VALUE1, PRUNED, PRUNED, 0          , DIRTY      , DIRTY      );
+    CheckWriteCash(VALUE1, PRUNED, FAIL  , 0          , DIRTY|FRESH, NO_ENTRY   );
+    CheckWriteCash(VALUE1, PRUNED, ABSENT, FRESH      , DIRTY      , NO_ENTRY   );
+    CheckWriteCash(VALUE1, PRUNED, FAIL  , FRESH      , DIRTY|FRESH, NO_ENTRY   );
+    CheckWriteCash(VALUE1, PRUNED, PRUNED, DIRTY      , DIRTY      , DIRTY      );
+    CheckWriteCash(VALUE1, PRUNED, FAIL  , DIRTY      , DIRTY|FRESH, NO_ENTRY   );
+    CheckWriteCash(VALUE1, PRUNED, ABSENT, DIRTY|FRESH, DIRTY      , NO_ENTRY   );
+    CheckWriteCash(VALUE1, PRUNED, FAIL  , DIRTY|FRESH, DIRTY|FRESH, NO_ENTRY   );
+    CheckWriteCash(VALUE1, VALUE2, VALUE2, 0          , DIRTY      , DIRTY      );
+    CheckWriteCash(VALUE1, VALUE2, FAIL  , 0          , DIRTY|FRESH, NO_ENTRY   );
+    CheckWriteCash(VALUE1, VALUE2, VALUE2, FRESH      , DIRTY      , DIRTY|FRESH);
+    CheckWriteCash(VALUE1, VALUE2, FAIL  , FRESH      , DIRTY|FRESH, NO_ENTRY   );
+    CheckWriteCash(VALUE1, VALUE2, VALUE2, DIRTY      , DIRTY      , DIRTY      );
+    CheckWriteCash(VALUE1, VALUE2, FAIL  , DIRTY      , DIRTY|FRESH, NO_ENTRY   );
+    CheckWriteCash(VALUE1, VALUE2, VALUE2, DIRTY|FRESH, DIRTY      , DIRTY|FRESH);
+    CheckWriteCash(VALUE1, VALUE2, FAIL  , DIRTY|FRESH, DIRTY|FRESH, NO_ENTRY   );
+
+    // The checks above omit cases where the child flags are not DIRTY, since
+    // they would be too repetitive (the parent cache is never updated in these
+    // cases). The loop below covers these cases and makes sure the parent cache
+    // is always left unchanged.
+    for (CAmount parent_value : {ABSENT, PRUNED, VALUE1})
+        for (CAmount child_value : {ABSENT, PRUNED, VALUE2})
+            for (char parent_flags : parent_value == ABSENT ? ABSENT_FLAGS : FLAGS)
+                for (char child_flags : child_value == ABSENT ? ABSENT_FLAGS : CLEAN_FLAGS)
+                    CheckWriteCoins(parent_value, child_value, parent_value, parent_flags, child_flags, parent_flags);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/checkqueue_tests.cpp b/checkqueue_tests.cpp
new file mode 100644
index 0000000..4e182cf
--- /dev/null
+++ b/checkqueue_tests.cpp
@@ -0,0 +1,445 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <util.h>
+#include <utiltime.h>
+#include <validation.h>
+
+#include <test/test_bitcoin.h>
+#include <checkqueue.h>
+#include <boost/test/unit_test.hpp>
+#include <boost/thread.hpp>
+#include <atomic>
+#include <thread>
+#include <vector>
+#include <mutex>
+#include <condition_variable>
+
+#include <unordered_set>
+#include <memory>
+#include <random.h>
+
+// BasicTestingSetup not sufficient because nScriptCheckThreads is not set
+// otherwise.
+BOOST_FIXTURE_TEST_SUITE(checkqueue_tests, TestingSetup)
+
+static const unsigned int QUEUE_BATCH_SIZE = 128;
+
+struct FakeCheck {
+    bool operator()()
+    {
+        return true;
+    }
+    void swap(FakeCheck& x){};
+};
+
+struct FakeCheckCheckCompletion {
+    static std::atomic<size_t> n_calls;
+    bool operator()()
+    {
+        n_calls.fetch_add(1, std::memory_order_relaxed);
+        return true;
+    }
+    void swap(FakeCheckCheckCompletion& x){};
+};
+
+struct FailingCheck {
+    bool fails;
+    FailingCheck(bool _fails) : fails(_fails){};
+    FailingCheck() : fails(true){};
+    bool operator()()
+    {
+        return !fails;
+    }
+    void swap(FailingCheck& x)
+    {
+        std::swap(fails, x.fails);
+    };
+};
+
+struct UniqueCheck {
+    static std::mutex m;
+    static std::unordered_multiset<size_t> results;
+    size_t check_id;
+    UniqueCheck(size_t check_id_in) : check_id(check_id_in){};
+    UniqueCheck() : check_id(0){};
+    bool operator()()
+    {
+        std::lock_guard<std::mutex> l(m);
+        results.insert(check_id);
+        return true;
+    }
+    void swap(UniqueCheck& x) { std::swap(x.check_id, check_id); };
+};
+
+
+struct MemoryCheck {
+    static std::atomic<size_t> fake_allocated_memory;
+    bool b {false};
+    bool operator()()
+    {
+        return true;
+    }
+    MemoryCheck(){};
+    MemoryCheck(const MemoryCheck& x)
+    {
+        // We have to do this to make sure that destructor calls are paired
+        //
+        // Really, copy constructor should be deletable, but CCheckQueue breaks
+        // if it is deleted because of internal push_back.
+        fake_allocated_memory.fetch_add(b, std::memory_order_relaxed);
+    };
+    MemoryCheck(bool b_) : b(b_)
+    {
+        fake_allocated_memory.fetch_add(b, std::memory_order_relaxed);
+    };
+    ~MemoryCheck()
+    {
+        fake_allocated_memory.fetch_sub(b, std::memory_order_relaxed);
+    };
+    void swap(MemoryCheck& x) { std::swap(b, x.b); };
+};
+
+struct FrozenCleanupCheck {
+    static std::atomic<uint64_t> nFrozen;
+    static std::condition_variable cv;
+    static std::mutex m;
+    // Freezing can't be the default initialized behavior given how the queue
+    // swaps in default initialized Checks.
+    bool should_freeze {false};
+    bool operator()()
+    {
+        return true;
+    }
+    FrozenCleanupCheck() {}
+    ~FrozenCleanupCheck()
+    {
+        if (should_freeze) {
+            std::unique_lock<std::mutex> l(m);
+            nFrozen.store(1, std::memory_order_relaxed);
+            cv.notify_one();
+            cv.wait(l, []{ return nFrozen.load(std::memory_order_relaxed) == 0;});
+        }
+    }
+    void swap(FrozenCleanupCheck& x){std::swap(should_freeze, x.should_freeze);};
+};
+
+// Static Allocations
+std::mutex FrozenCleanupCheck::m{};
+std::atomic<uint64_t> FrozenCleanupCheck::nFrozen{0};
+std::condition_variable FrozenCleanupCheck::cv{};
+std::mutex UniqueCheck::m;
+std::unordered_multiset<size_t> UniqueCheck::results;
+std::atomic<size_t> FakeCheckCheckCompletion::n_calls{0};
+std::atomic<size_t> MemoryCheck::fake_allocated_memory{0};
+
+// Queue Typedefs
+typedef CCheckQueue<FakeCheckCheckCompletion> Correct_Queue;
+typedef CCheckQueue<FakeCheck> Standard_Queue;
+typedef CCheckQueue<FailingCheck> Failing_Queue;
+typedef CCheckQueue<UniqueCheck> Unique_Queue;
+typedef CCheckQueue<MemoryCheck> Memory_Queue;
+typedef CCheckQueue<FrozenCleanupCheck> FrozenCleanup_Queue;
+
+
+/** This test case checks that the CCheckQueue works properly
+ * with each specified size_t Checks pushed.
+ */
+void Correct_Queue_range(std::vector<size_t> range)
+{
+    auto small_queue = std::unique_ptr<Correct_Queue>(new Correct_Queue {QUEUE_BATCH_SIZE});
+    boost::thread_group tg;
+    for (auto x = 0; x < nScriptCheckThreads; ++x) {
+       tg.create_thread([&]{small_queue->Thread();});
+    }
+    // Make vChecks here to save on malloc (this test can be slow...)
+    std::vector<FakeCheckCheckCompletion> vChecks;
+    for (auto i : range) {
+        size_t total = i;
+        FakeCheckCheckCompletion::n_calls = 0;
+        CCheckQueueControl<FakeCheckCheckCompletion> control(small_queue.get());
+        while (total) {
+            vChecks.resize(std::min(total, (size_t) InsecureRandRange(10)));
+            total -= vChecks.size();
+            control.Add(vChecks);
+        }
+        BOOST_REQUIRE(control.Wait());
+        if (FakeCheckCheckCompletion::n_calls != i) {
+            BOOST_REQUIRE_EQUAL(FakeCheckCheckCompletion::n_calls, i);
+            BOOST_TEST_MESSAGE("Failure on trial " << i << " expected, got " << FakeCheckCheckCompletion::n_calls);
+        }
+    }
+    tg.interrupt_all();
+    tg.join_all();
+}
+
+/** Test that 0 checks is correct
+ */
+BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Zero)
+{
+    std::vector<size_t> range;
+    range.push_back((size_t)0);
+    Correct_Queue_range(range);
+}
+/** Test that 1 check is correct
+ */
+BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_One)
+{
+    std::vector<size_t> range;
+    range.push_back((size_t)1);
+    Correct_Queue_range(range);
+}
+/** Test that MAX check is correct
+ */
+BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Max)
+{
+    std::vector<size_t> range;
+    range.push_back(100000);
+    Correct_Queue_range(range);
+}
+/** Test that random numbers of checks are correct
+ */
+BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Random)
+{
+    std::vector<size_t> range;
+    range.reserve(100000/1000);
+    for (size_t i = 2; i < 100000; i += std::max((size_t)1, (size_t)InsecureRandRange(std::min((size_t)1000, ((size_t)100000) - i))))
+        range.push_back(i);
+    Correct_Queue_range(range);
+}
+
+
+/** Test that failing checks are caught */
+BOOST_AUTO_TEST_CASE(test_CheckQueue_Catches_Failure)
+{
+    auto fail_queue = std::unique_ptr<Failing_Queue>(new Failing_Queue {QUEUE_BATCH_SIZE});
+
+    boost::thread_group tg;
+    for (auto x = 0; x < nScriptCheckThreads; ++x) {
+       tg.create_thread([&]{fail_queue->Thread();});
+    }
+
+    for (size_t i = 0; i < 1001; ++i) {
+        CCheckQueueControl<FailingCheck> control(fail_queue.get());
+        size_t remaining = i;
+        while (remaining) {
+            size_t r = InsecureRandRange(10);
+
+            std::vector<FailingCheck> vChecks;
+            vChecks.reserve(r);
+            for (size_t k = 0; k < r && remaining; k++, remaining--)
+                vChecks.emplace_back(remaining == 1);
+            control.Add(vChecks);
+        }
+        bool success = control.Wait();
+        if (i > 0) {
+            BOOST_REQUIRE(!success);
+        } else if (i == 0) {
+            BOOST_REQUIRE(success);
+        }
+    }
+    tg.interrupt_all();
+    tg.join_all();
+}
+// Test that a block validation which fails does not interfere with
+// future blocks, ie, the bad state is cleared.
+BOOST_AUTO_TEST_CASE(test_CheckQueue_Recovers_From_Failure)
+{
+    auto fail_queue = std::unique_ptr<Failing_Queue>(new Failing_Queue {QUEUE_BATCH_SIZE});
+    boost::thread_group tg;
+    for (auto x = 0; x < nScriptCheckThreads; ++x) {
+       tg.create_thread([&]{fail_queue->Thread();});
+    }
+
+    for (auto times = 0; times < 10; ++times) {
+        for (bool end_fails : {true, false}) {
+            CCheckQueueControl<FailingCheck> control(fail_queue.get());
+            {
+                std::vector<FailingCheck> vChecks;
+                vChecks.resize(100, false);
+                vChecks[99] = end_fails;
+                control.Add(vChecks);
+            }
+            bool r =control.Wait();
+            BOOST_REQUIRE(r != end_fails);
+        }
+    }
+    tg.interrupt_all();
+    tg.join_all();
+}
+
+// Test that unique checks are actually all called individually, rather than
+// just one check being called repeatedly. Test that checks are not called
+// more than once as well
+BOOST_AUTO_TEST_CASE(test_CheckQueue_UniqueCheck)
+{
+    auto queue = std::unique_ptr<Unique_Queue>(new Unique_Queue {QUEUE_BATCH_SIZE});
+    boost::thread_group tg;
+    for (auto x = 0; x < nScriptCheckThreads; ++x) {
+       tg.create_thread([&]{queue->Thread();});
+
+    }
+
+    size_t COUNT = 100000;
+    size_t total = COUNT;
+    {
+        CCheckQueueControl<UniqueCheck> control(queue.get());
+        while (total) {
+            size_t r = InsecureRandRange(10);
+            std::vector<UniqueCheck> vChecks;
+            for (size_t k = 0; k < r && total; k++)
+                vChecks.emplace_back(--total);
+            control.Add(vChecks);
+        }
+    }
+    bool r = true;
+    BOOST_REQUIRE_EQUAL(UniqueCheck::results.size(), COUNT);
+    for (size_t i = 0; i < COUNT; ++i)
+        r = r && UniqueCheck::results.count(i) == 1;
+    BOOST_REQUIRE(r);
+    tg.interrupt_all();
+    tg.join_all();
+}
+
+
+// Test that blocks which might allocate lots of memory free their memory aggressively.
+//
+// This test attempts to catch a pathological case where by lazily freeing
+// checks might mean leaving a check un-swapped out, and decreasing by 1 each
+// time could leave the data hanging across a sequence of blocks.
+BOOST_AUTO_TEST_CASE(test_CheckQueue_Memory)
+{
+    auto queue = std::unique_ptr<Memory_Queue>(new Memory_Queue {QUEUE_BATCH_SIZE});
+    boost::thread_group tg;
+    for (auto x = 0; x < nScriptCheckThreads; ++x) {
+       tg.create_thread([&]{queue->Thread();});
+    }
+    for (size_t i = 0; i < 1000; ++i) {
+        size_t total = i;
+        {
+            CCheckQueueControl<MemoryCheck> control(queue.get());
+            while (total) {
+                size_t r = InsecureRandRange(10);
+                std::vector<MemoryCheck> vChecks;
+                for (size_t k = 0; k < r && total; k++) {
+                    total--;
+                    // Each iteration leaves data at the front, back, and middle
+                    // to catch any sort of deallocation failure
+                    vChecks.emplace_back(total == 0 || total == i || total == i/2);
+                }
+                control.Add(vChecks);
+            }
+        }
+        BOOST_REQUIRE_EQUAL(MemoryCheck::fake_allocated_memory, 0);
+    }
+    tg.interrupt_all();
+    tg.join_all();
+}
+
+// Test that a new verification cannot occur until all checks
+// have been destructed
+BOOST_AUTO_TEST_CASE(test_CheckQueue_FrozenCleanup)
+{
+    auto queue = std::unique_ptr<FrozenCleanup_Queue>(new FrozenCleanup_Queue {QUEUE_BATCH_SIZE});
+    boost::thread_group tg;
+    bool fails = false;
+    for (auto x = 0; x < nScriptCheckThreads; ++x) {
+        tg.create_thread([&]{queue->Thread();});
+    }
+    std::thread t0([&]() {
+        CCheckQueueControl<FrozenCleanupCheck> control(queue.get());
+        std::vector<FrozenCleanupCheck> vChecks(1);
+        // Freezing can't be the default initialized behavior given how the queue
+        // swaps in default initialized Checks (otherwise freezing destructor
+        // would get called twice).
+        vChecks[0].should_freeze = true;
+        control.Add(vChecks);
+        control.Wait(); // Hangs here
+    });
+    {
+        std::unique_lock<std::mutex> l(FrozenCleanupCheck::m);
+        // Wait until the queue has finished all jobs and frozen
+        FrozenCleanupCheck::cv.wait(l, [](){return FrozenCleanupCheck::nFrozen == 1;});
+    }
+    // Try to get control of the queue a bunch of times
+    for (auto x = 0; x < 100 && !fails; ++x) {
+        fails = queue->ControlMutex.try_lock();
+    }
+    {
+        // Unfreeze (we need lock n case of spurious wakeup)
+        std::unique_lock<std::mutex> l(FrozenCleanupCheck::m);
+        FrozenCleanupCheck::nFrozen = 0;
+    }
+    // Awaken frozen destructor
+    FrozenCleanupCheck::cv.notify_one();
+    // Wait for control to finish
+    t0.join();
+    tg.interrupt_all();
+    tg.join_all();
+    BOOST_REQUIRE(!fails);
+}
+
+
+/** Test that CCheckQueueControl is threadsafe */
+BOOST_AUTO_TEST_CASE(test_CheckQueueControl_Locks)
+{
+    auto queue = std::unique_ptr<Standard_Queue>(new Standard_Queue{QUEUE_BATCH_SIZE});
+    {
+        boost::thread_group tg;
+        std::atomic<int> nThreads {0};
+        std::atomic<int> fails {0};
+        for (size_t i = 0; i < 3; ++i) {
+            tg.create_thread(
+                    [&]{
+                    CCheckQueueControl<FakeCheck> control(queue.get());
+                    // While sleeping, no other thread should execute to this point
+                    auto observed = ++nThreads;
+                    MilliSleep(10);
+                    fails += observed  != nThreads;
+                    });
+        }
+        tg.join_all();
+        BOOST_REQUIRE_EQUAL(fails, 0);
+    }
+    {
+        boost::thread_group tg;
+        std::mutex m;
+        std::condition_variable cv;
+        bool has_lock{false};
+        bool has_tried{false};
+        bool done{false};
+        bool done_ack{false};
+        {
+            std::unique_lock<std::mutex> l(m);
+            tg.create_thread([&]{
+                    CCheckQueueControl<FakeCheck> control(queue.get());
+                    std::unique_lock<std::mutex> ll(m);
+                    has_lock = true;
+                    cv.notify_one();
+                    cv.wait(ll, [&]{return has_tried;});
+                    done = true;
+                    cv.notify_one();
+                    // Wait until the done is acknowledged
+                    //
+                    cv.wait(ll, [&]{return done_ack;});
+                    });
+            // Wait for thread to get the lock
+            cv.wait(l, [&](){return has_lock;});
+            bool fails = false;
+            for (auto x = 0; x < 100 && !fails; ++x) {
+                fails = queue->ControlMutex.try_lock();
+            }
+            has_tried = true;
+            cv.notify_one();
+            cv.wait(l, [&](){return done;});
+            // Acknowledge the done
+            done_ack = true;
+            cv.notify_one();
+            BOOST_REQUIRE(!fails);
+        }
+        tg.join_all();
+    }
+}
+BOOST_AUTO_TEST_SUITE_END()
+
diff --git a/compress_tests.cpp b/compress_tests.cpp
new file mode 100644
index 0000000..394834a
--- /dev/null
+++ b/compress_tests.cpp
@@ -0,0 +1,65 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <compressor.h>
+#include <util.h>
+#include <test/test_salemcash.h>
+
+#include <stdint.h>
+
+#include <boost/test/unit_test.hpp>
+
+// amounts 0.00000001 .. 0.00100000
+#define NUM_MULTIPLES_UNIT 100000
+
+// amounts 0.01 .. 100.00
+#define NUM_MULTIPLES_CENT 10000
+
+// amounts 1 .. 10000
+#define NUM_MULTIPLES_1BTC 10000
+
+// amounts 50 .. 21000000
+#define NUM_MULTIPLES_50BTC 420000
+
+BOOST_FIXTURE_TEST_SUITE(compress_tests, BasicTestingSetup)
+
+bool static TestEncode(uint64_t in) {
+    return in == CTxOutCompressor::DecompressAmount(CTxOutCompressor::CompressAmount(in));
+}
+
+bool static TestDecode(uint64_t in) {
+    return in == CTxOutCompressor::CompressAmount(CTxOutCompressor::DecompressAmount(in));
+}
+
+bool static TestPair(uint64_t dec, uint64_t enc) {
+    return CTxOutCompressor::CompressAmount(dec) == enc &&
+           CTxOutCompressor::DecompressAmount(enc) == dec;
+}
+
+BOOST_AUTO_TEST_CASE(compress_amounts)
+{
+    BOOST_CHECK(TestPair(            0,       0x0));
+    BOOST_CHECK(TestPair(            1,       0x1));
+    BOOST_CHECK(TestPair(         CENT,       0x7));
+    BOOST_CHECK(TestPair(         CASH,       0x9));
+    BOOST_CHECK(TestPair(      50*CASH,      0x32));
+    BOOST_CHECK(TestPair(21000000*CASH, 0x1406f40));
+
+    for (uint64_t i = 1; i <= NUM_MULTIPLES_UNIT; i++)
+        BOOST_CHECK(TestEncode(i));
+
+    for (uint64_t i = 1; i <= NUM_MULTIPLES_CENT; i++)
+        BOOST_CHECK(TestEncode(i * CENT));
+
+    for (uint64_t i = 1; i <= NUM_MULTIPLES_1SCS; i++)
+        BOOST_CHECK(TestEncode(i * CASH));
+
+    for (uint64_t i = 1; i <= NUM_MULTIPLES_50SCS; i++)
+        BOOST_CHECK(TestEncode(i * 50 * CASH));
+
+    for (uint64_t i = 0; i < 100000; i++)
+        BOOST_CHECK(TestDecode(i));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/crypto_tests.cpp b/crypto_tests.cpp
new file mode 100644
index 0000000..67fea04
--- /dev/null
+++ b/crypto_tests.cpp
@@ -0,0 +1,549 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <crypto/aes.h>
+#include <crypto/chacha20.h>
+#include <crypto/ripemd160.h>
+#include <crypto/sha1.h>
+#include <crypto/sha256.h>
+#include <crypto/sha512.h>
+#include <crypto/hmac_sha256.h>
+#include <crypto/hmac_sha512.h>
+#include <random.h>
+#include <utilstrencodings.h>
+#include <test/test_salemcash.h>
+
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+#include <openssl/aes.h>
+#include <openssl/evp.h>
+
+BOOST_FIXTURE_TEST_SUITE(crypto_tests, BasicTestingSetup)
+
+template<typename Hasher, typename In, typename Out>
+void TestVector(const Hasher &h, const In &in, const Out &out) {
+    Out hash;
+    BOOST_CHECK(out.size() == h.OUTPUT_SIZE);
+    hash.resize(out.size());
+    {
+        // Test that writing the whole input string at once works.
+        Hasher(h).Write((unsigned char*)&in[0], in.size()).Finalize(&hash[0]);
+        BOOST_CHECK(hash == out);
+    }
+    for (int i=0; i<32; i++) {
+        // Test that writing the string broken up in random pieces works.
+        Hasher hasher(h);
+        size_t pos = 0;
+        while (pos < in.size()) {
+            size_t len = InsecureRandRange((in.size() - pos + 1) / 2 + 1);
+            hasher.Write((unsigned char*)&in[pos], len);
+            pos += len;
+            if (pos > 0 && pos + 2 * out.size() > in.size() && pos < in.size()) {
+                // Test that writing the rest at once to a copy of a hasher works.
+                Hasher(hasher).Write((unsigned char*)&in[pos], in.size() - pos).Finalize(&hash[0]);
+                BOOST_CHECK(hash == out);
+            }
+        }
+        hasher.Finalize(&hash[0]);
+        BOOST_CHECK(hash == out);
+    }
+}
+
+void TestSHA1(const std::string &in, const std::string &hexout) { TestVector(CSHA1(), in, ParseHex(hexout));}
+void TestSHA256(const std::string &in, const std::string &hexout) { TestVector(CSHA256(), in, ParseHex(hexout));}
+void TestSHA512(const std::string &in, const std::string &hexout) { TestVector(CSHA512(), in, ParseHex(hexout));}
+void TestRIPEMD160(const std::string &in, const std::string &hexout) { TestVector(CRIPEMD160(), in, ParseHex(hexout));}
+
+void TestHMACSHA256(const std::string &hexkey, const std::string &hexin, const std::string &hexout) {
+    std::vector<unsigned char> key = ParseHex(hexkey);
+    TestVector(CHMAC_SHA256(key.data(), key.size()), ParseHex(hexin), ParseHex(hexout));
+}
+
+void TestHMACSHA512(const std::string &hexkey, const std::string &hexin, const std::string &hexout) {
+    std::vector<unsigned char> key = ParseHex(hexkey);
+    TestVector(CHMAC_SHA512(key.data(), key.size()), ParseHex(hexin), ParseHex(hexout));
+}
+
+void TestAES128(const std::string &hexkey, const std::string &hexin, const std::string &hexout)
+{
+    std::vector<unsigned char> key = ParseHex(hexkey);
+    std::vector<unsigned char> in = ParseHex(hexin);
+    std::vector<unsigned char> correctout = ParseHex(hexout);
+    std::vector<unsigned char> buf, buf2;
+
+    assert(key.size() == 16);
+    assert(in.size() == 16);
+    assert(correctout.size() == 16);
+    AES128Encrypt enc(key.data());
+    buf.resize(correctout.size());
+    buf2.resize(correctout.size());
+    enc.Encrypt(buf.data(), in.data());
+    BOOST_CHECK_EQUAL(HexStr(buf), HexStr(correctout));
+    AES128Decrypt dec(key.data());
+    dec.Decrypt(buf2.data(), buf.data());
+    BOOST_CHECK_EQUAL(HexStr(buf2), HexStr(in));
+}
+
+void TestAES256(const std::string &hexkey, const std::string &hexin, const std::string &hexout)
+{
+    std::vector<unsigned char> key = ParseHex(hexkey);
+    std::vector<unsigned char> in = ParseHex(hexin);
+    std::vector<unsigned char> correctout = ParseHex(hexout);
+    std::vector<unsigned char> buf;
+
+    assert(key.size() == 32);
+    assert(in.size() == 16);
+    assert(correctout.size() == 16);
+    AES256Encrypt enc(key.data());
+    buf.resize(correctout.size());
+    enc.Encrypt(buf.data(), in.data());
+    BOOST_CHECK(buf == correctout);
+    AES256Decrypt dec(key.data());
+    dec.Decrypt(buf.data(), buf.data());
+    BOOST_CHECK(buf == in);
+}
+
+void TestAES128CBC(const std::string &hexkey, const std::string &hexiv, bool pad, const std::string &hexin, const std::string &hexout)
+{
+    std::vector<unsigned char> key = ParseHex(hexkey);
+    std::vector<unsigned char> iv = ParseHex(hexiv);
+    std::vector<unsigned char> in = ParseHex(hexin);
+    std::vector<unsigned char> correctout = ParseHex(hexout);
+    std::vector<unsigned char> realout(in.size() + AES_BLOCKSIZE);
+
+    // Encrypt the plaintext and verify that it equals the cipher
+    AES128CBCEncrypt enc(key.data(), iv.data(), pad);
+    int size = enc.Encrypt(in.data(), in.size(), realout.data());
+    realout.resize(size);
+    BOOST_CHECK(realout.size() == correctout.size());
+    BOOST_CHECK_MESSAGE(realout == correctout, HexStr(realout) + std::string(" != ") + hexout);
+
+    // Decrypt the cipher and verify that it equals the plaintext
+    std::vector<unsigned char> decrypted(correctout.size());
+    AES128CBCDecrypt dec(key.data(), iv.data(), pad);
+    size = dec.Decrypt(correctout.data(), correctout.size(), decrypted.data());
+    decrypted.resize(size);
+    BOOST_CHECK(decrypted.size() == in.size());
+    BOOST_CHECK_MESSAGE(decrypted == in, HexStr(decrypted) + std::string(" != ") + hexin);
+
+    // Encrypt and re-decrypt substrings of the plaintext and verify that they equal each-other
+    for(std::vector<unsigned char>::iterator i(in.begin()); i != in.end(); ++i)
+    {
+        std::vector<unsigned char> sub(i, in.end());
+        std::vector<unsigned char> subout(sub.size() + AES_BLOCKSIZE);
+        int _size = enc.Encrypt(sub.data(), sub.size(), subout.data());
+        if (_size != 0)
+        {
+            subout.resize(_size);
+            std::vector<unsigned char> subdecrypted(subout.size());
+            _size = dec.Decrypt(subout.data(), subout.size(), subdecrypted.data());
+            subdecrypted.resize(_size);
+            BOOST_CHECK(decrypted.size() == in.size());
+            BOOST_CHECK_MESSAGE(subdecrypted == sub, HexStr(subdecrypted) + std::string(" != ") + HexStr(sub));
+        }
+    }
+}
+
+void TestAES256CBC(const std::string &hexkey, const std::string &hexiv, bool pad, const std::string &hexin, const std::string &hexout)
+{
+    std::vector<unsigned char> key = ParseHex(hexkey);
+    std::vector<unsigned char> iv = ParseHex(hexiv);
+    std::vector<unsigned char> in = ParseHex(hexin);
+    std::vector<unsigned char> correctout = ParseHex(hexout);
+    std::vector<unsigned char> realout(in.size() + AES_BLOCKSIZE);
+
+    // Encrypt the plaintext and verify that it equals the cipher
+    AES256CBCEncrypt enc(key.data(), iv.data(), pad);
+    int size = enc.Encrypt(in.data(), in.size(), realout.data());
+    realout.resize(size);
+    BOOST_CHECK(realout.size() == correctout.size());
+    BOOST_CHECK_MESSAGE(realout == correctout, HexStr(realout) + std::string(" != ") + hexout);
+
+    // Decrypt the cipher and verify that it equals the plaintext
+    std::vector<unsigned char> decrypted(correctout.size());
+    AES256CBCDecrypt dec(key.data(), iv.data(), pad);
+    size = dec.Decrypt(correctout.data(), correctout.size(), decrypted.data());
+    decrypted.resize(size);
+    BOOST_CHECK(decrypted.size() == in.size());
+    BOOST_CHECK_MESSAGE(decrypted == in, HexStr(decrypted) + std::string(" != ") + hexin);
+
+    // Encrypt and re-decrypt substrings of the plaintext and verify that they equal each-other
+    for(std::vector<unsigned char>::iterator i(in.begin()); i != in.end(); ++i)
+    {
+        std::vector<unsigned char> sub(i, in.end());
+        std::vector<unsigned char> subout(sub.size() + AES_BLOCKSIZE);
+        int _size = enc.Encrypt(sub.data(), sub.size(), subout.data());
+        if (_size != 0)
+        {
+            subout.resize(_size);
+            std::vector<unsigned char> subdecrypted(subout.size());
+            _size = dec.Decrypt(subout.data(), subout.size(), subdecrypted.data());
+            subdecrypted.resize(_size);
+            BOOST_CHECK(decrypted.size() == in.size());
+            BOOST_CHECK_MESSAGE(subdecrypted == sub, HexStr(subdecrypted) + std::string(" != ") + HexStr(sub));
+        }
+    }
+}
+
+void TestChaCha20(const std::string &hexkey, uint64_t nonce, uint64_t seek, const std::string& hexout)
+{
+    std::vector<unsigned char> key = ParseHex(hexkey);
+    ChaCha20 rng(key.data(), key.size());
+    rng.SetIV(nonce);
+    rng.Seek(seek);
+    std::vector<unsigned char> out = ParseHex(hexout);
+    std::vector<unsigned char> outres;
+    outres.resize(out.size());
+    rng.Output(outres.data(), outres.size());
+    BOOST_CHECK(out == outres);
+}
+
+std::string LongTestString(void) {
+    std::string ret;
+    for (int i=0; i<200000; i++) {
+        ret += (unsigned char)(i);
+        ret += (unsigned char)(i >> 4);
+        ret += (unsigned char)(i >> 8);
+        ret += (unsigned char)(i >> 12);
+        ret += (unsigned char)(i >> 16);
+    }
+    return ret;
+}
+
+const std::string test1 = LongTestString();
+
+BOOST_AUTO_TEST_CASE(ripemd160_testvectors) {
+    TestRIPEMD160("", "9c1185a5c5e9fc54612808977ee8f548b2258d31");
+    TestRIPEMD160("abc", "8eb208f7e05d987a9b044a8e98c6b087f15a0bfc");
+    TestRIPEMD160("message digest", "5d0689ef49d2fae572b881b123a85ffa21595f36");
+    TestRIPEMD160("secure hash algorithm", "20397528223b6a5f4cbc2808aba0464e645544f9");
+    TestRIPEMD160("RIPEMD160 is considered to be safe", "a7d78608c7af8a8e728778e81576870734122b66");
+    TestRIPEMD160("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+                  "12a053384a9c0c88e405a06c27dcf49ada62eb2b");
+    TestRIPEMD160("For this sample, this 63-byte string will be used as input data",
+                  "de90dbfee14b63fb5abf27c2ad4a82aaa5f27a11");
+    TestRIPEMD160("This is exactly 64 bytes long, not counting the terminating byte",
+                  "eda31d51d3a623b81e19eb02e24ff65d27d67b37");
+    TestRIPEMD160(std::string(1000000, 'a'), "52783243c1697bdbe16d37f97f68f08325dc1528");
+    TestRIPEMD160(test1, "464243587bd146ea835cdf57bdae582f25ec45f1");
+}
+
+BOOST_AUTO_TEST_CASE(sha1_testvectors) {
+    TestSHA1("", "da39a3ee5e6b4b0d3255bfef95601890afd80709");
+    TestSHA1("abc", "a9993e364706816aba3e25717850c26c9cd0d89d");
+    TestSHA1("message digest", "c12252ceda8be8994d5fa0290a47231c1d16aae3");
+    TestSHA1("secure hash algorithm", "d4d6d2f0ebe317513bbd8d967d89bac5819c2f60");
+    TestSHA1("SHA1 is considered to be safe", "f2b6650569ad3a8720348dd6ea6c497dee3a842a");
+    TestSHA1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+             "84983e441c3bd26ebaae4aa1f95129e5e54670f1");
+    TestSHA1("For this sample, this 63-byte string will be used as input data",
+             "4f0ea5cd0585a23d028abdc1a6684e5a8094dc49");
+    TestSHA1("This is exactly 64 bytes long, not counting the terminating byte",
+             "fb679f23e7d1ce053313e66e127ab1b444397057");
+    TestSHA1(std::string(1000000, 'a'), "34aa973cd4c4daa4f61eeb2bdbad27316534016f");
+    TestSHA1(test1, "b7755760681cbfd971451668f32af5774f4656b5");
+}
+
+BOOST_AUTO_TEST_CASE(sha256_testvectors) {
+    TestSHA256("", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
+    TestSHA256("abc", "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
+    TestSHA256("message digest",
+               "f7846f55cf23e14eebeab5b4e1550cad5b509e3348fbc4efa3a1413d393cb650");
+    TestSHA256("secure hash algorithm",
+               "f30ceb2bb2829e79e4ca9753d35a8ecc00262d164cc077080295381cbd643f0d");
+    TestSHA256("SHA256 is considered to be safe",
+               "6819d915c73f4d1e77e4e1b52d1fa0f9cf9beaead3939f15874bd988e2a23630");
+    TestSHA256("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+               "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1");
+    TestSHA256("For this sample, this 63-byte string will be used as input data",
+               "f08a78cbbaee082b052ae0708f32fa1e50c5c421aa772ba5dbb406a2ea6be342");
+    TestSHA256("This is exactly 64 bytes long, not counting the terminating byte",
+               "ab64eff7e88e2e46165e29f2bce41826bd4c7b3552f6b382a9e7d3af47c245f8");
+    TestSHA256("As Bitcoin relies on 80 byte header hashes, we want to have an example for that.",
+               "7406e8de7d6e4fffc573daef05aefb8806e7790f55eab5576f31349743cca743");
+    TestSHA256(std::string(1000000, 'a'),
+               "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0");
+    TestSHA256(test1, "a316d55510b49662420f49d145d42fb83f31ef8dc016aa4e32df049991a91e26");
+}
+
+BOOST_AUTO_TEST_CASE(sha512_testvectors) {
+    TestSHA512("",
+               "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce"
+               "47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
+    TestSHA512("abc",
+               "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a"
+               "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f");
+    TestSHA512("message digest",
+               "107dbf389d9e9f71a3a95f6c055b9251bc5268c2be16d6c13492ea45b0199f33"
+               "09e16455ab1e96118e8a905d5597b72038ddb372a89826046de66687bb420e7c");
+    TestSHA512("secure hash algorithm",
+               "7746d91f3de30c68cec0dd693120a7e8b04d8073cb699bdce1a3f64127bca7a3"
+               "d5db502e814bb63c063a7a5043b2df87c61133395f4ad1edca7fcf4b30c3236e");
+    TestSHA512("SHA512 is considered to be safe",
+               "099e6468d889e1c79092a89ae925a9499b5408e01b66cb5b0a3bd0dfa51a9964"
+               "6b4a3901caab1318189f74cd8cf2e941829012f2449df52067d3dd5b978456c2");
+    TestSHA512("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+               "204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c335"
+               "96fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445");
+    TestSHA512("For this sample, this 63-byte string will be used as input data",
+               "b3de4afbc516d2478fe9b518d063bda6c8dd65fc38402dd81d1eb7364e72fb6e"
+               "6663cf6d2771c8f5a6da09601712fb3d2a36c6ffea3e28b0818b05b0a8660766");
+    TestSHA512("This is exactly 64 bytes long, not counting the terminating byte",
+               "70aefeaa0e7ac4f8fe17532d7185a289bee3b428d950c14fa8b713ca09814a38"
+               "7d245870e007a80ad97c369d193e41701aa07f3221d15f0e65a1ff970cedf030");
+    TestSHA512("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmno"
+               "ijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
+               "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018"
+               "501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909");
+    TestSHA512(std::string(1000000, 'a'),
+               "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973eb"
+               "de0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b");
+    TestSHA512(test1,
+               "40cac46c147e6131c5193dd5f34e9d8bb4951395f27b08c558c65ff4ba2de594"
+               "37de8c3ef5459d76a52cedc02dc499a3c9ed9dedbfb3281afd9653b8a112fafc");
+}
+
+BOOST_AUTO_TEST_CASE(hmac_sha256_testvectors) {
+    // test cases 1, 2, 3, 4, 6 and 7 of RFC 4231
+    TestHMACSHA256("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+                   "4869205468657265",
+                   "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
+    TestHMACSHA256("4a656665",
+                   "7768617420646f2079612077616e7420666f72206e6f7468696e673f",
+                   "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843");
+    TestHMACSHA256("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                   "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+                   "dddddddddddddddddddddddddddddddddddd",
+                   "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe");
+    TestHMACSHA256("0102030405060708090a0b0c0d0e0f10111213141516171819",
+                   "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd"
+                   "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+                   "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b");
+    TestHMACSHA256("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaa",
+                   "54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a"
+                   "65204b6579202d2048617368204b6579204669727374",
+                   "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54");
+    TestHMACSHA256("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaa",
+                   "5468697320697320612074657374207573696e672061206c6172676572207468"
+                   "616e20626c6f636b2d73697a65206b657920616e642061206c61726765722074"
+                   "68616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565"
+                   "647320746f20626520686173686564206265666f7265206265696e6720757365"
+                   "642062792074686520484d414320616c676f726974686d2e",
+                   "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2");
+    // Test case with key length 63 bytes.
+    TestHMACSHA256("4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a6566",
+                   "7768617420646f2079612077616e7420666f72206e6f7468696e673f",
+                   "9de4b546756c83516720a4ad7fe7bdbeac4298c6fdd82b15f895a6d10b0769a6");
+    // Test case with key length 64 bytes.
+    TestHMACSHA256("4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665",
+                   "7768617420646f2079612077616e7420666f72206e6f7468696e673f",
+                   "528c609a4c9254c274585334946b7c2661bad8f1fc406b20f6892478d19163dd");
+    // Test case with key length 65 bytes.
+    TestHMACSHA256("4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a",
+                   "7768617420646f2079612077616e7420666f72206e6f7468696e673f",
+                   "d06af337f359a2330deffb8e3cbe4b5b7aa8ca1f208528cdbd245d5dc63c4483");
+}
+
+BOOST_AUTO_TEST_CASE(hmac_sha512_testvectors) {
+    // test cases 1, 2, 3, 4, 6 and 7 of RFC 4231
+    TestHMACSHA512("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+                   "4869205468657265",
+                   "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cde"
+                   "daa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854");
+    TestHMACSHA512("4a656665",
+                   "7768617420646f2079612077616e7420666f72206e6f7468696e673f",
+                   "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea250554"
+                   "9758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737");
+    TestHMACSHA512("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                   "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+                   "dddddddddddddddddddddddddddddddddddd",
+                   "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39"
+                   "bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb");
+    TestHMACSHA512("0102030405060708090a0b0c0d0e0f10111213141516171819",
+                   "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd"
+                   "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+                   "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3db"
+                   "a91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd");
+    TestHMACSHA512("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaa",
+                   "54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a"
+                   "65204b6579202d2048617368204b6579204669727374",
+                   "80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f352"
+                   "6b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598");
+    TestHMACSHA512("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                   "aaaaaa",
+                   "5468697320697320612074657374207573696e672061206c6172676572207468"
+                   "616e20626c6f636b2d73697a65206b657920616e642061206c61726765722074"
+                   "68616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565"
+                   "647320746f20626520686173686564206265666f7265206265696e6720757365"
+                   "642062792074686520484d414320616c676f726974686d2e",
+                   "e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944"
+                   "b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58");
+    // Test case with key length 127 bytes.
+    TestHMACSHA512("4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a6566",
+                   "7768617420646f2079612077616e7420666f72206e6f7468696e673f",
+                   "267424dfb8eeb999f3e5ec39a4fe9fd14c923e6187e0897063e5c9e02b2e624a"
+                   "c04413e762977df71a9fb5d562b37f89dfdfb930fce2ed1fa783bbc2a203d80e");
+    // Test case with key length 128 bytes.
+    TestHMACSHA512("4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665",
+                   "7768617420646f2079612077616e7420666f72206e6f7468696e673f",
+                   "43aaac07bb1dd97c82c04df921f83b16a68d76815cd1a30d3455ad43a3d80484"
+                   "2bb35462be42cc2e4b5902de4d204c1c66d93b47d1383e3e13a3788687d61258");
+    // Test case with key length 129 bytes.
+    TestHMACSHA512("4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a6566654a6566654a6566654a6566654a6566654a6566654a6566654a656665"
+                   "4a",
+                   "7768617420646f2079612077616e7420666f72206e6f7468696e673f",
+                   "0b273325191cfc1b4b71d5075c8fcad67696309d292b1dad2cd23983a35feb8e"
+                   "fb29795e79f2ef27f68cb1e16d76178c307a67beaad9456fac5fdffeadb16e2c");
+}
+
+BOOST_AUTO_TEST_CASE(aes_testvectors) {
+    // AES test vectors from FIPS 197.
+    TestAES128("000102030405060708090a0b0c0d0e0f", "00112233445566778899aabbccddeeff", "69c4e0d86a7b0430d8cdb78070b4c55a");
+    TestAES256("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", "00112233445566778899aabbccddeeff", "8ea2b7ca516745bfeafc49904b496089");
+
+    // AES-ECB test vectors from NIST sp800-38a.
+    TestAES128("2b7e151628aed2a6abf7158809cf4f3c", "6bc1bee22e409f96e93d7e117393172a", "3ad77bb40d7a3660a89ecaf32466ef97");
+    TestAES128("2b7e151628aed2a6abf7158809cf4f3c", "ae2d8a571e03ac9c9eb76fac45af8e51", "f5d3d58503b9699de785895a96fdbaaf");
+    TestAES128("2b7e151628aed2a6abf7158809cf4f3c", "30c81c46a35ce411e5fbc1191a0a52ef", "43b1cd7f598ece23881b00e3ed030688");
+    TestAES128("2b7e151628aed2a6abf7158809cf4f3c", "f69f2445df4f9b17ad2b417be66c3710", "7b0c785e27e8ad3f8223207104725dd4");
+    TestAES256("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", "6bc1bee22e409f96e93d7e117393172a", "f3eed1bdb5d2a03c064b5a7e3db181f8");
+    TestAES256("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", "ae2d8a571e03ac9c9eb76fac45af8e51", "591ccb10d410ed26dc5ba74a31362870");
+    TestAES256("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", "30c81c46a35ce411e5fbc1191a0a52ef", "b6ed21b99ca6f4f9f153e7b1beafed1d");
+    TestAES256("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", "f69f2445df4f9b17ad2b417be66c3710", "23304b7a39f9f3ff067d8d8f9e24ecc7");
+}
+
+BOOST_AUTO_TEST_CASE(aes_cbc_testvectors) {
+
+    // NIST AES CBC 128-bit encryption test-vectors
+    TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c", "000102030405060708090A0B0C0D0E0F", false, \
+                  "6bc1bee22e409f96e93d7e117393172a", "7649abac8119b246cee98e9b12e9197d");
+    TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c", "7649ABAC8119B246CEE98E9B12E9197D", false, \
+                  "ae2d8a571e03ac9c9eb76fac45af8e51", "5086cb9b507219ee95db113a917678b2");
+    TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c", "5086cb9b507219ee95db113a917678b2", false, \
+                  "30c81c46a35ce411e5fbc1191a0a52ef", "73bed6b8e3c1743b7116e69e22229516");
+    TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c", "73bed6b8e3c1743b7116e69e22229516", false, \
+                  "f69f2445df4f9b17ad2b417be66c3710", "3ff1caa1681fac09120eca307586e1a7");
+
+    // The same vectors with padding enabled
+    TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c", "000102030405060708090A0B0C0D0E0F", true, \
+                  "6bc1bee22e409f96e93d7e117393172a", "7649abac8119b246cee98e9b12e9197d8964e0b149c10b7b682e6e39aaeb731c");
+    TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c", "7649ABAC8119B246CEE98E9B12E9197D", true, \
+                  "ae2d8a571e03ac9c9eb76fac45af8e51", "5086cb9b507219ee95db113a917678b255e21d7100b988ffec32feeafaf23538");
+    TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c", "5086cb9b507219ee95db113a917678b2", true, \
+                  "30c81c46a35ce411e5fbc1191a0a52ef", "73bed6b8e3c1743b7116e69e22229516f6eccda327bf8e5ec43718b0039adceb");
+    TestAES128CBC("2b7e151628aed2a6abf7158809cf4f3c", "73bed6b8e3c1743b7116e69e22229516", true, \
+                  "f69f2445df4f9b17ad2b417be66c3710", "3ff1caa1681fac09120eca307586e1a78cb82807230e1321d3fae00d18cc2012");
+
+    // NIST AES CBC 256-bit encryption test-vectors
+    TestAES256CBC("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", \
+                  "000102030405060708090A0B0C0D0E0F", false, "6bc1bee22e409f96e93d7e117393172a", \
+                  "f58c4c04d6e5f1ba779eabfb5f7bfbd6");
+    TestAES256CBC("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", \
+                  "F58C4C04D6E5F1BA779EABFB5F7BFBD6", false, "ae2d8a571e03ac9c9eb76fac45af8e51", \
+                  "9cfc4e967edb808d679f777bc6702c7d");
+    TestAES256CBC("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", \
+                  "9CFC4E967EDB808D679F777BC6702C7D", false, "30c81c46a35ce411e5fbc1191a0a52ef",
+                  "39f23369a9d9bacfa530e26304231461");
+    TestAES256CBC("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", \
+                  "39F23369A9D9BACFA530E26304231461", false, "f69f2445df4f9b17ad2b417be66c3710", \
+                  "b2eb05e2c39be9fcda6c19078c6a9d1b");
+
+    // The same vectors with padding enabled
+    TestAES256CBC("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", \
+                  "000102030405060708090A0B0C0D0E0F", true, "6bc1bee22e409f96e93d7e117393172a", \
+                  "f58c4c04d6e5f1ba779eabfb5f7bfbd6485a5c81519cf378fa36d42b8547edc0");
+    TestAES256CBC("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", \
+                  "F58C4C04D6E5F1BA779EABFB5F7BFBD6", true, "ae2d8a571e03ac9c9eb76fac45af8e51", \
+                  "9cfc4e967edb808d679f777bc6702c7d3a3aa5e0213db1a9901f9036cf5102d2");
+    TestAES256CBC("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", \
+                  "9CFC4E967EDB808D679F777BC6702C7D", true, "30c81c46a35ce411e5fbc1191a0a52ef",
+                  "39f23369a9d9bacfa530e263042314612f8da707643c90a6f732b3de1d3f5cee");
+    TestAES256CBC("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4", \
+                  "39F23369A9D9BACFA530E26304231461", true, "f69f2445df4f9b17ad2b417be66c3710", \
+                  "b2eb05e2c39be9fcda6c19078c6a9d1b3f461796d6b0d6b2e0c2a72b4d80e644");
+}
+
+
+BOOST_AUTO_TEST_CASE(chacha20_testvector)
+{
+    // Test vector from RFC 7539
+    TestChaCha20("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", 0x4a000000UL, 1,
+                 "224f51f3401bd9e12fde276fb8631ded8c131f823d2c06e27e4fcaec9ef3cf788a3b0aa372600a92b57974cded2b9334794cb"
+                 "a40c63e34cdea212c4cf07d41b769a6749f3f630f4122cafe28ec4dc47e26d4346d70b98c73f3e9c53ac40c5945398b6eda1a"
+                 "832c89c167eacd901d7e2bf363");
+
+    // Test vectors from https://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04#section-7
+    TestChaCha20("0000000000000000000000000000000000000000000000000000000000000000", 0, 0,
+                 "76b8e0ada0f13d90405d6ae55386bd28bdd219b8a08ded1aa836efcc8b770dc7da41597c5157488d7724e03fb8d84a376a43b"
+                 "8f41518a11cc387b669b2ee6586");
+    TestChaCha20("0000000000000000000000000000000000000000000000000000000000000001", 0, 0,
+                 "4540f05a9f1fb296d7736e7b208e3c96eb4fe1834688d2604f450952ed432d41bbe2a0b6ea7566d2a5d1e7e20d42af2c53d79"
+                 "2b1c43fea817e9ad275ae546963");
+    TestChaCha20("0000000000000000000000000000000000000000000000000000000000000000", 0x0100000000000000ULL, 0,
+                 "de9cba7bf3d69ef5e786dc63973f653a0b49e015adbff7134fcb7df137821031e85a050278a7084527214f73efc7fa5b52770"
+                 "62eb7a0433e445f41e3");
+    TestChaCha20("0000000000000000000000000000000000000000000000000000000000000000", 1, 0,
+                 "ef3fdfd6c61578fbf5cf35bd3dd33b8009631634d21e42ac33960bd138e50d32111e4caf237ee53ca8ad6426194a88545ddc4"
+                 "97a0b466e7d6bbdb0041b2f586b");
+    TestChaCha20("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", 0x0706050403020100ULL, 0,
+                 "f798a189f195e66982105ffb640bb7757f579da31602fc93ec01ac56f85ac3c134a4547b733b46413042c9440049176905d3b"
+                 "e59ea1c53f15916155c2be8241a38008b9a26bc35941e2444177c8ade6689de95264986d95889fb60e84629c9bd9a5acb1cc1"
+                 "18be563eb9b3a4a472f82e09a7e778492b562ef7130e88dfe031c79db9d4f7c7a899151b9a475032b63fc385245fe054e3dd5"
+                 "a97a5f576fe064025d3ce042c566ab2c507b138db853e3d6959660996546cc9c4a6eafdc777c040d70eaf46f76dad3979e5c5"
+                 "360c3317166a1c894c94a371876a94df7628fe4eaaf2ccb27d5aaae0ad7ad0f9d4b6ad3b54098746d4524d38407a6deb3ab78"
+                 "fab78c9");
+}
+
+BOOST_AUTO_TEST_CASE(countbits_tests)
+{
+    FastRandomContext ctx;
+    for (int i = 0; i <= 64; ++i) {
+        if (i == 0) {
+            // Check handling of zero.
+            BOOST_CHECK_EQUAL(CountBits(0), 0);
+        } else if (i < 10) {
+            for (uint64_t j = 1 << (i - 1); (j >> i) == 0; ++j) {
+                // Exhaustively test up to 10 bits
+                BOOST_CHECK_EQUAL(CountBits(j), i);
+            }
+        } else {
+            for (int k = 0; k < 1000; k++) {
+                // Randomly test 1000 samples of each length above 10 bits.
+                uint64_t j = ((uint64_t)1) << (i - 1) | ctx.randbits(i - 1);
+                BOOST_CHECK_EQUAL(CountBits(j), i);
+            }
+        }
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/cuckoocache_tests.cpp b/cuckoocache_tests.cpp
new file mode 100644
index 0000000..e7dc0db
--- /dev/null
+++ b/cuckoocache_tests.cpp
@@ -0,0 +1,380 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#include <boost/test/unit_test.hpp>
+#include <cuckoocache.h>
+#include <script/sigcache.h>
+#include <test/test_salemcash.h>
+#include <random.h>
+#include <thread>
+
+/** Test Suite for CuckooCache
+ *
+ *  1) All tests should have a deterministic result (using insecure rand
+ *  with deterministic seeds)
+ *  2) Some test methods are templated to allow for easier testing
+ *  against new versions / comparing
+ *  3) Results should be treated as a regression test, i.e., did the behavior
+ *  change significantly from what was expected. This can be OK, depending on
+ *  the nature of the change, but requires updating the tests to reflect the new
+ *  expected behavior. For example improving the hit rate may cause some tests
+ *  using BOOST_CHECK_CLOSE to fail.
+ *
+ */
+FastRandomContext local_rand_ctx(true);
+
+BOOST_AUTO_TEST_SUITE(cuckoocache_tests);
+
+
+/** insecure_GetRandHash fills in a uint256 from local_rand_ctx
+ */
+void insecure_GetRandHash(uint256& t)
+{
+    uint32_t* ptr = (uint32_t*)t.begin();
+    for (uint8_t j = 0; j < 8; ++j)
+        *(ptr++) = local_rand_ctx.rand32();
+}
+
+
+
+/* Test that no values not inserted into the cache are read out of it.
+ *
+ * There are no repeats in the first 200000 insecure_GetRandHash calls
+ */
+BOOST_AUTO_TEST_CASE(test_cuckoocache_no_fakes)
+{
+    local_rand_ctx = FastRandomContext(true);
+    CuckooCache::cache<uint256, SignatureCacheHasher> cc{};
+    size_t megabytes = 4;
+    cc.setup_bytes(megabytes << 20);
+    uint256 v;
+    for (int x = 0; x < 100000; ++x) {
+        insecure_GetRandHash(v);
+        cc.insert(v);
+    }
+    for (int x = 0; x < 100000; ++x) {
+        insecure_GetRandHash(v);
+        BOOST_CHECK(!cc.contains(v, false));
+    }
+};
+
+/** This helper returns the hit rate when megabytes*load worth of entries are
+ * inserted into a megabytes sized cache
+ */
+template <typename Cache>
+double test_cache(size_t megabytes, double load)
+{
+    local_rand_ctx = FastRandomContext(true);
+    std::vector<uint256> hashes;
+    Cache set{};
+    size_t bytes = megabytes * (1 << 20);
+    set.setup_bytes(bytes);
+    uint32_t n_insert = static_cast<uint32_t>(load * (bytes / sizeof(uint256)));
+    hashes.resize(n_insert);
+    for (uint32_t i = 0; i < n_insert; ++i) {
+        uint32_t* ptr = (uint32_t*)hashes[i].begin();
+        for (uint8_t j = 0; j < 8; ++j)
+            *(ptr++) = local_rand_ctx.rand32();
+    }
+    /** We make a copy of the hashes because future optimizations of the
+     * cuckoocache may overwrite the inserted element, so the test is
+     * "future proofed".
+     */
+    std::vector<uint256> hashes_insert_copy = hashes;
+    /** Do the insert */
+    for (uint256& h : hashes_insert_copy)
+        set.insert(h);
+    /** Count the hits */
+    uint32_t count = 0;
+    for (uint256& h : hashes)
+        count += set.contains(h, false);
+    double hit_rate = ((double)count) / ((double)n_insert);
+    return hit_rate;
+}
+
+/** The normalized hit rate for a given load.
+ *
+ * The semantics are a little confusing, so please see the below
+ * explanation.
+ *
+ * Examples:
+ *
+ * 1) at load 0.5, we expect a perfect hit rate, so we multiply by
+ * 1.0
+ * 2) at load 2.0, we expect to see half the entries, so a perfect hit rate
+ * would be 0.5. Therefore, if we see a hit rate of 0.4, 0.4*2.0 = 0.8 is the
+ * normalized hit rate.
+ *
+ * This is basically the right semantics, but has a bit of a glitch depending on
+ * how you measure around load 1.0 as after load 1.0 your normalized hit rate
+ * becomes effectively perfect, ignoring freshness.
+ */
+double normalize_hit_rate(double hits, double load)
+{
+    return hits * std::max(load, 1.0);
+}
+
+/** Check the hit rate on loads ranging from 0.1 to 2.0 */
+BOOST_AUTO_TEST_CASE(cuckoocache_hit_rate_ok)
+{
+    /** Arbitrarily selected Hit Rate threshold that happens to work for this test
+     * as a lower bound on performance.
+     */
+    double HitRateThresh = 0.98;
+    size_t megabytes = 4;
+    for (double load = 0.1; load < 2; load *= 2) {
+        double hits = test_cache<CuckooCache::cache<uint256, SignatureCacheHasher>>(megabytes, load);
+        BOOST_CHECK(normalize_hit_rate(hits, load) > HitRateThresh);
+    }
+}
+
+
+/** This helper checks that erased elements are preferentially inserted onto and
+ * that the hit rate of "fresher" keys is reasonable*/
+template <typename Cache>
+void test_cache_erase(size_t megabytes)
+{
+    double load = 1;
+    local_rand_ctx = FastRandomContext(true);
+    std::vector<uint256> hashes;
+    Cache set{};
+    size_t bytes = megabytes * (1 << 20);
+    set.setup_bytes(bytes);
+    uint32_t n_insert = static_cast<uint32_t>(load * (bytes / sizeof(uint256)));
+    hashes.resize(n_insert);
+    for (uint32_t i = 0; i < n_insert; ++i) {
+        uint32_t* ptr = (uint32_t*)hashes[i].begin();
+        for (uint8_t j = 0; j < 8; ++j)
+            *(ptr++) = local_rand_ctx.rand32();
+    }
+    /** We make a copy of the hashes because future optimizations of the
+     * cuckoocache may overwrite the inserted element, so the test is
+     * "future proofed".
+     */
+    std::vector<uint256> hashes_insert_copy = hashes;
+
+    /** Insert the first half */
+    for (uint32_t i = 0; i < (n_insert / 2); ++i)
+        set.insert(hashes_insert_copy[i]);
+    /** Erase the first quarter */
+    for (uint32_t i = 0; i < (n_insert / 4); ++i)
+        set.contains(hashes[i], true);
+    /** Insert the second half */
+    for (uint32_t i = (n_insert / 2); i < n_insert; ++i)
+        set.insert(hashes_insert_copy[i]);
+
+    /** elements that we marked as erased but are still there */
+    size_t count_erased_but_contained = 0;
+    /** elements that we did not erase but are older */
+    size_t count_stale = 0;
+    /** elements that were most recently inserted */
+    size_t count_fresh = 0;
+
+    for (uint32_t i = 0; i < (n_insert / 4); ++i)
+        count_erased_but_contained += set.contains(hashes[i], false);
+    for (uint32_t i = (n_insert / 4); i < (n_insert / 2); ++i)
+        count_stale += set.contains(hashes[i], false);
+    for (uint32_t i = (n_insert / 2); i < n_insert; ++i)
+        count_fresh += set.contains(hashes[i], false);
+
+    double hit_rate_erased_but_contained = double(count_erased_but_contained) / (double(n_insert) / 4.0);
+    double hit_rate_stale = double(count_stale) / (double(n_insert) / 4.0);
+    double hit_rate_fresh = double(count_fresh) / (double(n_insert) / 2.0);
+
+    // Check that our hit_rate_fresh is perfect
+    BOOST_CHECK_EQUAL(hit_rate_fresh, 1.0);
+    // Check that we have a more than 2x better hit rate on stale elements than
+    // erased elements.
+    BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained);
+}
+
+BOOST_AUTO_TEST_CASE(cuckoocache_erase_ok)
+{
+    size_t megabytes = 4;
+    test_cache_erase<CuckooCache::cache<uint256, SignatureCacheHasher>>(megabytes);
+}
+
+template <typename Cache>
+void test_cache_erase_parallel(size_t megabytes)
+{
+    double load = 1;
+    local_rand_ctx = FastRandomContext(true);
+    std::vector<uint256> hashes;
+    Cache set{};
+    size_t bytes = megabytes * (1 << 20);
+    set.setup_bytes(bytes);
+    uint32_t n_insert = static_cast<uint32_t>(load * (bytes / sizeof(uint256)));
+    hashes.resize(n_insert);
+    for (uint32_t i = 0; i < n_insert; ++i) {
+        uint32_t* ptr = (uint32_t*)hashes[i].begin();
+        for (uint8_t j = 0; j < 8; ++j)
+            *(ptr++) = local_rand_ctx.rand32();
+    }
+    /** We make a copy of the hashes because future optimizations of the
+     * cuckoocache may overwrite the inserted element, so the test is
+     * "future proofed".
+     */
+    std::vector<uint256> hashes_insert_copy = hashes;
+    boost::shared_mutex mtx;
+
+    {
+        /** Grab lock to make sure we release inserts */
+        boost::unique_lock<boost::shared_mutex> l(mtx);
+        /** Insert the first half */
+        for (uint32_t i = 0; i < (n_insert / 2); ++i)
+            set.insert(hashes_insert_copy[i]);
+    }
+
+    /** Spin up 3 threads to run contains with erase.
+     */
+    std::vector<std::thread> threads;
+    /** Erase the first quarter */
+    for (uint32_t x = 0; x < 3; ++x)
+        /** Each thread is emplaced with x copy-by-value
+        */
+        threads.emplace_back([&, x] {
+            boost::shared_lock<boost::shared_mutex> l(mtx);
+            size_t ntodo = (n_insert/4)/3;
+            size_t start = ntodo*x;
+            size_t end = ntodo*(x+1);
+            for (uint32_t i = start; i < end; ++i)
+                set.contains(hashes[i], true);
+        });
+
+    /** Wait for all threads to finish
+     */
+    for (std::thread& t : threads)
+        t.join();
+    /** Grab lock to make sure we observe erases */
+    boost::unique_lock<boost::shared_mutex> l(mtx);
+    /** Insert the second half */
+    for (uint32_t i = (n_insert / 2); i < n_insert; ++i)
+        set.insert(hashes_insert_copy[i]);
+
+    /** elements that we marked erased but that are still there */
+    size_t count_erased_but_contained = 0;
+    /** elements that we did not erase but are older */
+    size_t count_stale = 0;
+    /** elements that were most recently inserted */
+    size_t count_fresh = 0;
+
+    for (uint32_t i = 0; i < (n_insert / 4); ++i)
+        count_erased_but_contained += set.contains(hashes[i], false);
+    for (uint32_t i = (n_insert / 4); i < (n_insert / 2); ++i)
+        count_stale += set.contains(hashes[i], false);
+    for (uint32_t i = (n_insert / 2); i < n_insert; ++i)
+        count_fresh += set.contains(hashes[i], false);
+
+    double hit_rate_erased_but_contained = double(count_erased_but_contained) / (double(n_insert) / 4.0);
+    double hit_rate_stale = double(count_stale) / (double(n_insert) / 4.0);
+    double hit_rate_fresh = double(count_fresh) / (double(n_insert) / 2.0);
+
+    // Check that our hit_rate_fresh is perfect
+    BOOST_CHECK_EQUAL(hit_rate_fresh, 1.0);
+    // Check that we have a more than 2x better hit rate on stale elements than
+    // erased elements.
+    BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained);
+}
+BOOST_AUTO_TEST_CASE(cuckoocache_erase_parallel_ok)
+{
+    size_t megabytes = 4;
+    test_cache_erase_parallel<CuckooCache::cache<uint256, SignatureCacheHasher>>(megabytes);
+}
+
+
+template <typename Cache>
+void test_cache_generations()
+{
+    // This test checks that for a simulation of network activity, the fresh hit
+    // rate is never below 99%, and the number of times that it is worse than
+    // 99.9% are less than 1% of the time.
+    double min_hit_rate = 0.99;
+    double tight_hit_rate = 0.999;
+    double max_rate_less_than_tight_hit_rate = 0.01;
+    // A cache that meets this specification is therefore shown to have a hit
+    // rate of at least tight_hit_rate * (1 - max_rate_less_than_tight_hit_rate) +
+    // min_hit_rate*max_rate_less_than_tight_hit_rate = 0.999*99%+0.99*1% == 99.89%
+    // hit rate with low variance.
+
+    // We use deterministic values, but this test has also passed on many
+    // iterations with non-deterministic values, so it isn't "overfit" to the
+    // specific entropy in FastRandomContext(true) and implementation of the
+    // cache.
+    local_rand_ctx = FastRandomContext(true);
+
+    // block_activity models a chunk of network activity. n_insert elements are
+    // added to the cache. The first and last n/4 are stored for removal later
+    // and the middle n/2 are not stored. This models a network which uses half
+    // the signatures of recently (since the last block) added transactions
+    // immediately and never uses the other half.
+    struct block_activity {
+        std::vector<uint256> reads;
+        block_activity(uint32_t n_insert, Cache& c) : reads()
+        {
+            std::vector<uint256> inserts;
+            inserts.resize(n_insert);
+            reads.reserve(n_insert / 2);
+            for (uint32_t i = 0; i < n_insert; ++i) {
+                uint32_t* ptr = (uint32_t*)inserts[i].begin();
+                for (uint8_t j = 0; j < 8; ++j)
+                    *(ptr++) = local_rand_ctx.rand32();
+            }
+            for (uint32_t i = 0; i < n_insert / 4; ++i)
+                reads.push_back(inserts[i]);
+            for (uint32_t i = n_insert - (n_insert / 4); i < n_insert; ++i)
+                reads.push_back(inserts[i]);
+            for (auto h : inserts)
+                c.insert(h);
+        }
+    };
+
+    const uint32_t BLOCK_SIZE = 1000;
+    // We expect window size 60 to perform reasonably given that each epoch
+    // stores 45% of the cache size (~472k).
+    const uint32_t WINDOW_SIZE = 60;
+    const uint32_t POP_AMOUNT = (BLOCK_SIZE / WINDOW_SIZE) / 2;
+    const double load = 10;
+    const size_t megabytes = 4;
+    const size_t bytes = megabytes * (1 << 20);
+    const uint32_t n_insert = static_cast<uint32_t>(load * (bytes / sizeof(uint256)));
+
+    std::vector<block_activity> hashes;
+    Cache set{};
+    set.setup_bytes(bytes);
+    hashes.reserve(n_insert / BLOCK_SIZE);
+    std::deque<block_activity> last_few;
+    uint32_t out_of_tight_tolerance = 0;
+    uint32_t total = n_insert / BLOCK_SIZE;
+    // we use the deque last_few to model a sliding window of blocks. at each
+    // step, each of the last WINDOW_SIZE block_activities checks the cache for
+    // POP_AMOUNT of the hashes that they inserted, and marks these erased.
+    for (uint32_t i = 0; i < total; ++i) {
+        if (last_few.size() == WINDOW_SIZE)
+            last_few.pop_front();
+        last_few.emplace_back(BLOCK_SIZE, set);
+        uint32_t count = 0;
+        for (auto& act : last_few)
+            for (uint32_t k = 0; k < POP_AMOUNT; ++k) {
+                count += set.contains(act.reads.back(), true);
+                act.reads.pop_back();
+            }
+        // We use last_few.size() rather than WINDOW_SIZE for the correct
+        // behavior on the first WINDOW_SIZE iterations where the deque is not
+        // full yet.
+        double hit = (double(count)) / (last_few.size() * POP_AMOUNT);
+        // Loose Check that hit rate is above min_hit_rate
+        BOOST_CHECK(hit > min_hit_rate);
+        // Tighter check, count number of times we are less than tight_hit_rate
+        // (and implicitly, greater than min_hit_rate)
+        out_of_tight_tolerance += hit < tight_hit_rate;
+    }
+    // Check that being out of tolerance happens less than
+    // max_rate_less_than_tight_hit_rate of the time
+    BOOST_CHECK(double(out_of_tight_tolerance) / double(total) < max_rate_less_than_tight_hit_rate);
+}
+BOOST_AUTO_TEST_CASE(cuckoocache_generations)
+{
+    test_cache_generations<CuckooCache::cache<uint256, SignatureCacheHasher>>();
+}
+
+BOOST_AUTO_TEST_SUITE_END();
diff --git a/dbwrapper_tests.cpp b/dbwrapper_tests.cpp
new file mode 100644
index 0000000..1d682a0
--- /dev/null
+++ b/dbwrapper_tests.cpp
@@ -0,0 +1,320 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <dbwrapper.h>
+#include <uint256.h>
+#include <random.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+// Test if a string consists entirely of null characters
+bool is_null_key(const std::vector<unsigned char>& key) {
+    bool isnull = true;
+
+    for (unsigned int i = 0; i < key.size(); i++)
+        isnull &= (key[i] == '\x00');
+
+    return isnull;
+}
+ 
+BOOST_FIXTURE_TEST_SUITE(dbwrapper_tests, BasicTestingSetup)
+                       
+BOOST_AUTO_TEST_CASE(dbwrapper)
+{
+    // Perform tests both obfuscated and non-obfuscated.
+    for (bool obfuscate : {false, true}) {
+        fs::path ph = fs::temp_directory_path() / fs::unique_path();
+        CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
+        char key = 'k';
+        uint256 in = InsecureRand256();
+        uint256 res;
+
+        // Ensure that we're doing real obfuscation when obfuscate=true
+        BOOST_CHECK(obfuscate != is_null_key(dbwrapper_private::GetObfuscateKey(dbw)));
+
+        BOOST_CHECK(dbw.Write(key, in));
+        BOOST_CHECK(dbw.Read(key, res));
+        BOOST_CHECK_EQUAL(res.ToString(), in.ToString());
+    }
+}
+
+// Test batch operations
+BOOST_AUTO_TEST_CASE(dbwrapper_batch)
+{
+    // Perform tests both obfuscated and non-obfuscated.
+    for (bool obfuscate : {false, true}) {
+        fs::path ph = fs::temp_directory_path() / fs::unique_path();
+        CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
+
+        char key = 'i';
+        uint256 in = InsecureRand256();
+        char key2 = 'j';
+        uint256 in2 = InsecureRand256();
+        char key3 = 'k';
+        uint256 in3 = InsecureRand256();
+
+        uint256 res;
+        CDBBatch batch(dbw);
+
+        batch.Write(key, in);
+        batch.Write(key2, in2);
+        batch.Write(key3, in3);
+
+        // Remove key3 before it's even been written
+        batch.Erase(key3);
+
+        dbw.WriteBatch(batch);
+
+        BOOST_CHECK(dbw.Read(key, res));
+        BOOST_CHECK_EQUAL(res.ToString(), in.ToString());
+        BOOST_CHECK(dbw.Read(key2, res));
+        BOOST_CHECK_EQUAL(res.ToString(), in2.ToString());
+
+        // key3 should've never been written
+        BOOST_CHECK(dbw.Read(key3, res) == false);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(dbwrapper_iterator)
+{
+    // Perform tests both obfuscated and non-obfuscated.
+    for (bool obfuscate : {false, true}) {
+        fs::path ph = fs::temp_directory_path() / fs::unique_path();
+        CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
+
+        // The two keys are intentionally chosen for ordering
+        char key = 'j';
+        uint256 in = InsecureRand256();
+        BOOST_CHECK(dbw.Write(key, in));
+        char key2 = 'k';
+        uint256 in2 = InsecureRand256();
+        BOOST_CHECK(dbw.Write(key2, in2));
+
+        std::unique_ptr<CDBIterator> it(const_cast<CDBWrapper&>(dbw).NewIterator());
+
+        // Be sure to seek past the obfuscation key (if it exists)
+        it->Seek(key);
+
+        char key_res;
+        uint256 val_res;
+
+        it->GetKey(key_res);
+        it->GetValue(val_res);
+        BOOST_CHECK_EQUAL(key_res, key);
+        BOOST_CHECK_EQUAL(val_res.ToString(), in.ToString());
+
+        it->Next();
+
+        it->GetKey(key_res);
+        it->GetValue(val_res);
+        BOOST_CHECK_EQUAL(key_res, key2);
+        BOOST_CHECK_EQUAL(val_res.ToString(), in2.ToString());
+
+        it->Next();
+        BOOST_CHECK_EQUAL(it->Valid(), false);
+    }
+}
+
+// Test that we do not obfuscation if there is existing data.
+BOOST_AUTO_TEST_CASE(existing_data_no_obfuscate)
+{
+    // We're going to share this fs::path between two wrappers
+    fs::path ph = fs::temp_directory_path() / fs::unique_path();
+    create_directories(ph);
+
+    // Set up a non-obfuscated wrapper to write some initial data.
+    std::unique_ptr<CDBWrapper> dbw = MakeUnique<CDBWrapper>(ph, (1 << 10), false, false, false);
+    char key = 'k';
+    uint256 in = InsecureRand256();
+    uint256 res;
+
+    BOOST_CHECK(dbw->Write(key, in));
+    BOOST_CHECK(dbw->Read(key, res));
+    BOOST_CHECK_EQUAL(res.ToString(), in.ToString());
+
+    // Call the destructor to free leveldb LOCK
+    dbw.reset();
+
+    // Now, set up another wrapper that wants to obfuscate the same directory
+    CDBWrapper odbw(ph, (1 << 10), false, false, true);
+
+    // Check that the key/val we wrote with unobfuscated wrapper exists and 
+    // is readable.
+    uint256 res2;
+    BOOST_CHECK(odbw.Read(key, res2));
+    BOOST_CHECK_EQUAL(res2.ToString(), in.ToString());
+
+    BOOST_CHECK(!odbw.IsEmpty()); // There should be existing data
+    BOOST_CHECK(is_null_key(dbwrapper_private::GetObfuscateKey(odbw))); // The key should be an empty string
+
+    uint256 in2 = InsecureRand256();
+    uint256 res3;
+ 
+    // Check that we can write successfully
+    BOOST_CHECK(odbw.Write(key, in2));
+    BOOST_CHECK(odbw.Read(key, res3));
+    BOOST_CHECK_EQUAL(res3.ToString(), in2.ToString());
+}
+                        
+// Ensure that we start obfuscating during a reindex.
+BOOST_AUTO_TEST_CASE(existing_data_reindex)
+{
+    // We're going to share this fs::path between two wrappers
+    fs::path ph = fs::temp_directory_path() / fs::unique_path();
+    create_directories(ph);
+
+    // Set up a non-obfuscated wrapper to write some initial data.
+    std::unique_ptr<CDBWrapper> dbw = MakeUnique<CDBWrapper>(ph, (1 << 10), false, false, false);
+    char key = 'k';
+    uint256 in = InsecureRand256();
+    uint256 res;
+
+    BOOST_CHECK(dbw->Write(key, in));
+    BOOST_CHECK(dbw->Read(key, res));
+    BOOST_CHECK_EQUAL(res.ToString(), in.ToString());
+
+    // Call the destructor to free leveldb LOCK
+    dbw.reset();
+
+    // Simulate a -reindex by wiping the existing data store
+    CDBWrapper odbw(ph, (1 << 10), false, true, true);
+
+    // Check that the key/val we wrote with unobfuscated wrapper doesn't exist
+    uint256 res2;
+    BOOST_CHECK(!odbw.Read(key, res2));
+    BOOST_CHECK(!is_null_key(dbwrapper_private::GetObfuscateKey(odbw)));
+
+    uint256 in2 = InsecureRand256();
+    uint256 res3;
+ 
+    // Check that we can write successfully
+    BOOST_CHECK(odbw.Write(key, in2));
+    BOOST_CHECK(odbw.Read(key, res3));
+    BOOST_CHECK_EQUAL(res3.ToString(), in2.ToString());
+}
+
+BOOST_AUTO_TEST_CASE(iterator_ordering)
+{
+    fs::path ph = fs::temp_directory_path() / fs::unique_path();
+    CDBWrapper dbw(ph, (1 << 20), true, false, false);
+    for (int x=0x00; x<256; ++x) {
+        uint8_t key = x;
+        uint32_t value = x*x;
+        if (!(x & 1)) BOOST_CHECK(dbw.Write(key, value));
+    }
+
+    // Check that creating an iterator creates a snapshot
+    std::unique_ptr<CDBIterator> it(const_cast<CDBWrapper&>(dbw).NewIterator());
+
+    for (int x=0x00; x<256; ++x) {
+        uint8_t key = x;
+        uint32_t value = x*x;
+        if (x & 1) BOOST_CHECK(dbw.Write(key, value));
+    }
+
+    for (int seek_start : {0x00, 0x80}) {
+        it->Seek((uint8_t)seek_start);
+        for (int x=seek_start; x<255; ++x) {
+            uint8_t key;
+            uint32_t value;
+            BOOST_CHECK(it->Valid());
+            if (!it->Valid()) // Avoid spurious errors about invalid iterator's key and value in case of failure
+                break;
+            BOOST_CHECK(it->GetKey(key));
+            if (x & 1) {
+                BOOST_CHECK_EQUAL(key, x + 1);
+                continue;
+            }
+            BOOST_CHECK(it->GetValue(value));
+            BOOST_CHECK_EQUAL(key, x);
+            BOOST_CHECK_EQUAL(value, x*x);
+            it->Next();
+        }
+        BOOST_CHECK(!it->Valid());
+    }
+}
+
+struct StringContentsSerializer {
+    // Used to make two serialized objects the same while letting them have different lengths
+    // This is a terrible idea
+    std::string str;
+    StringContentsSerializer() {}
+    explicit StringContentsSerializer(const std::string& inp) : str(inp) {}
+
+    StringContentsSerializer& operator+=(const std::string& s) {
+        str += s;
+        return *this;
+    }
+    StringContentsSerializer& operator+=(const StringContentsSerializer& s) { return *this += s.str; }
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        if (ser_action.ForRead()) {
+            str.clear();
+            char c = 0;
+            while (true) {
+                try {
+                    READWRITE(c);
+                    str.push_back(c);
+                } catch (const std::ios_base::failure& e) {
+                    break;
+                }
+            }
+        } else {
+            for (size_t i = 0; i < str.size(); i++)
+                READWRITE(str[i]);
+        }
+    }
+};
+
+BOOST_AUTO_TEST_CASE(iterator_string_ordering)
+{
+    char buf[10];
+
+    fs::path ph = fs::temp_directory_path() / fs::unique_path();
+    CDBWrapper dbw(ph, (1 << 20), true, false, false);
+    for (int x=0x00; x<10; ++x) {
+        for (int y = 0; y < 10; y++) {
+            snprintf(buf, sizeof(buf), "%d", x);
+            StringContentsSerializer key(buf);
+            for (int z = 0; z < y; z++)
+                key += key;
+            uint32_t value = x*x;
+            BOOST_CHECK(dbw.Write(key, value));
+        }
+    }
+
+    std::unique_ptr<CDBIterator> it(const_cast<CDBWrapper&>(dbw).NewIterator());
+    for (int seek_start : {0, 5}) {
+        snprintf(buf, sizeof(buf), "%d", seek_start);
+        StringContentsSerializer seek_key(buf);
+        it->Seek(seek_key);
+        for (int x=seek_start; x<10; ++x) {
+            for (int y = 0; y < 10; y++) {
+                snprintf(buf, sizeof(buf), "%d", x);
+                std::string exp_key(buf);
+                for (int z = 0; z < y; z++)
+                    exp_key += exp_key;
+                StringContentsSerializer key;
+                uint32_t value;
+                BOOST_CHECK(it->Valid());
+                if (!it->Valid()) // Avoid spurious errors about invalid iterator's key and value in case of failure
+                    break;
+                BOOST_CHECK(it->GetKey(key));
+                BOOST_CHECK(it->GetValue(value));
+                BOOST_CHECK_EQUAL(key.str, exp_key);
+                BOOST_CHECK_EQUAL(value, x*x);
+                it->Next();
+            }
+        }
+        BOOST_CHECK(!it->Valid());
+    }
+}
+
+
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/getarg_tests.cpp b/getarg_tests.cpp
new file mode 100644
index 0000000..e02905c
--- /dev/null
+++ b/getarg_tests.cpp
@@ -0,0 +1,161 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <util.h>
+#include <test/test_salemcash.h>
+
+#include <string>
+#include <vector>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(getarg_tests, BasicTestingSetup)
+
+static void ResetArgs(const std::string& strArg)
+{
+    std::vector<std::string> vecArg;
+    if (strArg.size())
+      boost::split(vecArg, strArg, boost::is_space(), boost::token_compress_on);
+
+    // Insert dummy executable name:
+    vecArg.insert(vecArg.begin(), "testsalemcash");
+
+    // Convert to char*:
+    std::vector<const char*> vecChar;
+    for (std::string& s : vecArg)
+        vecChar.push_back(s.c_str());
+
+    gArgs.ParseParameters(vecChar.size(), vecChar.data());
+}
+
+BOOST_AUTO_TEST_CASE(boolarg)
+{
+    ResetArgs("-foo");
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
+
+    BOOST_CHECK(!gArgs.GetBoolArg("-fo", false));
+    BOOST_CHECK(gArgs.GetBoolArg("-fo", true));
+
+    BOOST_CHECK(!gArgs.GetBoolArg("-fooo", false));
+    BOOST_CHECK(gArgs.GetBoolArg("-fooo", true));
+
+    ResetArgs("-foo=0");
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
+
+    ResetArgs("-foo=1");
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
+
+    // New 0.6 feature: auto-map -nosomething to !-something:
+    ResetArgs("-nofoo");
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
+
+    ResetArgs("-nofoo=1");
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
+
+    ResetArgs("-foo -nofoo");  // -nofoo should win
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
+
+    ResetArgs("-foo=1 -nofoo=1");  // -nofoo should win
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
+
+    ResetArgs("-foo=0 -nofoo=0");  // -nofoo=0 should win
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
+
+    // New 0.6 feature: treat -- same as -:
+    ResetArgs("--foo=1");
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
+
+    ResetArgs("--nofoo=1");
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
+
+}
+
+BOOST_AUTO_TEST_CASE(stringarg)
+{
+    ResetArgs("");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", "eleven"), "eleven");
+
+    ResetArgs("-foo -bar");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", "eleven"), "");
+
+    ResetArgs("-foo=");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", "eleven"), "");
+
+    ResetArgs("-foo=11");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "11");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", "eleven"), "11");
+
+    ResetArgs("-foo=eleven");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "eleven");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", "eleven"), "eleven");
+
+}
+
+BOOST_AUTO_TEST_CASE(intarg)
+{
+    ResetArgs("");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", 11), 11);
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", 0), 0);
+
+    ResetArgs("-foo -bar");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", 11), 0);
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-bar", 11), 0);
+
+    ResetArgs("-foo=11 -bar=12");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", 0), 11);
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-bar", 11), 12);
+
+    ResetArgs("-foo=NaN -bar=NotANumber");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", 1), 0);
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-bar", 11), 0);
+}
+
+BOOST_AUTO_TEST_CASE(doubledash)
+{
+    ResetArgs("--foo");
+    BOOST_CHECK_EQUAL(gArgs.GetBoolArg("-foo", false), true);
+
+    ResetArgs("--foo=verbose --bar=1");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-foo", ""), "verbose");
+    BOOST_CHECK_EQUAL(gArgs.GetArg("-bar", 0), 1);
+}
+
+BOOST_AUTO_TEST_CASE(boolargno)
+{
+    ResetArgs("-nofoo");
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
+
+    ResetArgs("-nofoo=1");
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
+
+    ResetArgs("-nofoo=0");
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
+
+    ResetArgs("-foo --nofoo"); // --nofoo should win
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", true));
+    BOOST_CHECK(!gArgs.GetBoolArg("-foo", false));
+
+    ResetArgs("-nofoo -foo"); // foo always wins:
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", true));
+    BOOST_CHECK(gArgs.GetBoolArg("-foo", false));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/hash_tests.cpp b/hash_tests.cpp
new file mode 100644
index 0000000..ef280cb
--- /dev/null
+++ b/hash_tests.cpp
@@ -0,0 +1,150 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <hash.h>
+#include <utilstrencodings.h>
+#include <test/test_salemcash.h>
+
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(hash_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(murmurhash3)
+{
+
+#define T(expected, seed, data) BOOST_CHECK_EQUAL(MurmurHash3(seed, ParseHex(data)), expected)
+
+    // Test MurmurHash3 with various inputs. Of course this is retested in the
+    // bloom filter tests - they would fail if MurmurHash3() had any problems -
+    // but is useful for those trying to implement SalemCash libraries as a
+    // source of test data for their MurmurHash3() primitive during
+    // development.
+    //
+    // The magic number 0xFBA4C795 comes from CBloomFilter::Hash()
+
+    T(0x00000000, 0x00000000, "");
+    T(0x6a396f08, 0xFBA4C795, "");
+    T(0x81f16f39, 0xffffffff, "");
+
+    T(0x514e28b7, 0x00000000, "00");
+    T(0xea3f0b17, 0xFBA4C795, "00");
+    T(0xfd6cf10d, 0x00000000, "ff");
+
+    T(0x16c6b7ab, 0x00000000, "0011");
+    T(0x8eb51c3d, 0x00000000, "001122");
+    T(0xb4471bf8, 0x00000000, "00112233");
+    T(0xe2301fa8, 0x00000000, "0011223344");
+    T(0xfc2e4a15, 0x00000000, "001122334455");
+    T(0xb074502c, 0x00000000, "00112233445566");
+    T(0x8034d2a0, 0x00000000, "0011223344556677");
+    T(0xb4698def, 0x00000000, "001122334455667788");
+
+#undef T
+}
+
+/*
+   SipHash-2-4 output with
+   k = 00 01 02 ...
+   and
+   in = (empty string)
+   in = 00 (1 byte)
+   in = 00 01 (2 bytes)
+   in = 00 01 02 (3 bytes)
+   ...
+   in = 00 01 02 ... 3e (63 bytes)
+
+   from: https://131002.net/siphash/siphash24.c
+*/
+uint64_t siphash_4_2_testvec[] = {
+    0x726fdb47dd0e0e31, 0x74f839c593dc67fd, 0x0d6c8009d9a94f5a, 0x85676696d7fb7e2d,
+    0xcf2794e0277187b7, 0x18765564cd99a68d, 0xcbc9466e58fee3ce, 0xab0200f58b01d137,
+    0x93f5f5799a932462, 0x9e0082df0ba9e4b0, 0x7a5dbbc594ddb9f3, 0xf4b32f46226bada7,
+    0x751e8fbc860ee5fb, 0x14ea5627c0843d90, 0xf723ca908e7af2ee, 0xa129ca6149be45e5,
+    0x3f2acc7f57c29bdb, 0x699ae9f52cbe4794, 0x4bc1b3f0968dd39c, 0xbb6dc91da77961bd,
+    0xbed65cf21aa2ee98, 0xd0f2cbb02e3b67c7, 0x93536795e3a33e88, 0xa80c038ccd5ccec8,
+    0xb8ad50c6f649af94, 0xbce192de8a85b8ea, 0x17d835b85bbb15f3, 0x2f2e6163076bcfad,
+    0xde4daaaca71dc9a5, 0xa6a2506687956571, 0xad87a3535c49ef28, 0x32d892fad841c342,
+    0x7127512f72f27cce, 0xa7f32346f95978e3, 0x12e0b01abb051238, 0x15e034d40fa197ae,
+    0x314dffbe0815a3b4, 0x027990f029623981, 0xcadcd4e59ef40c4d, 0x9abfd8766a33735c,
+    0x0e3ea96b5304a7d0, 0xad0c42d6fc585992, 0x187306c89bc215a9, 0xd4a60abcf3792b95,
+    0xf935451de4f21df2, 0xa9538f0419755787, 0xdb9acddff56ca510, 0xd06c98cd5c0975eb,
+    0xe612a3cb9ecba951, 0xc766e62cfcadaf96, 0xee64435a9752fe72, 0xa192d576b245165a,
+    0x0a8787bf8ecb74b2, 0x81b3e73d20b49b6f, 0x7fa8220ba3b2ecea, 0x245731c13ca42499,
+    0xb78dbfaf3a8d83bd, 0xea1ad565322a1a0b, 0x60e61c23a3795013, 0x6606d7e446282b93,
+    0x6ca4ecb15c5f91e1, 0x9f626da15c9625f3, 0xe51b38608ef25f57, 0x958a324ceb064572
+};
+
+BOOST_AUTO_TEST_CASE(siphash)
+{
+    CSipHasher hasher(0x0706050403020100ULL, 0x0F0E0D0C0B0A0908ULL);
+    BOOST_CHECK_EQUAL(hasher.Finalize(),  0x726fdb47dd0e0e31ull);
+    static const unsigned char t0[1] = {0};
+    hasher.Write(t0, 1);
+    BOOST_CHECK_EQUAL(hasher.Finalize(),  0x74f839c593dc67fdull);
+    static const unsigned char t1[7] = {1,2,3,4,5,6,7};
+    hasher.Write(t1, 7);
+    BOOST_CHECK_EQUAL(hasher.Finalize(),  0x93f5f5799a932462ull);
+    hasher.Write(0x0F0E0D0C0B0A0908ULL);
+    BOOST_CHECK_EQUAL(hasher.Finalize(),  0x3f2acc7f57c29bdbull);
+    static const unsigned char t2[2] = {16,17};
+    hasher.Write(t2, 2);
+    BOOST_CHECK_EQUAL(hasher.Finalize(),  0x4bc1b3f0968dd39cull);
+    static const unsigned char t3[9] = {18,19,20,21,22,23,24,25,26};
+    hasher.Write(t3, 9);
+    BOOST_CHECK_EQUAL(hasher.Finalize(),  0x2f2e6163076bcfadull);
+    static const unsigned char t4[5] = {27,28,29,30,31};
+    hasher.Write(t4, 5);
+    BOOST_CHECK_EQUAL(hasher.Finalize(),  0x7127512f72f27cceull);
+    hasher.Write(0x2726252423222120ULL);
+    BOOST_CHECK_EQUAL(hasher.Finalize(),  0x0e3ea96b5304a7d0ull);
+    hasher.Write(0x2F2E2D2C2B2A2928ULL);
+    BOOST_CHECK_EQUAL(hasher.Finalize(),  0xe612a3cb9ecba951ull);
+
+    BOOST_CHECK_EQUAL(SipHashUint256(0x0706050403020100ULL, 0x0F0E0D0C0B0A0908ULL, uint256S("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100")), 0x7127512f72f27cceull);
+
+    // Check test vectors from spec, one byte at a time
+    CSipHasher hasher2(0x0706050403020100ULL, 0x0F0E0D0C0B0A0908ULL);
+    for (uint8_t x=0; x<ARRAYLEN(siphash_4_2_testvec); ++x)
+    {
+        BOOST_CHECK_EQUAL(hasher2.Finalize(), siphash_4_2_testvec[x]);
+        hasher2.Write(&x, 1);
+    }
+    // Check test vectors from spec, eight bytes at a time
+    CSipHasher hasher3(0x0706050403020100ULL, 0x0F0E0D0C0B0A0908ULL);
+    for (uint8_t x=0; x<ARRAYLEN(siphash_4_2_testvec); x+=8)
+    {
+        BOOST_CHECK_EQUAL(hasher3.Finalize(), siphash_4_2_testvec[x]);
+        hasher3.Write(uint64_t(x)|(uint64_t(x+1)<<8)|(uint64_t(x+2)<<16)|(uint64_t(x+3)<<24)|
+                     (uint64_t(x+4)<<32)|(uint64_t(x+5)<<40)|(uint64_t(x+6)<<48)|(uint64_t(x+7)<<56));
+    }
+
+    CHashWriter ss(SER_DISK, CLIENT_VERSION);
+    CMutableTransaction tx;
+    // Note these tests were originally written with tx.nVersion=1
+    // and the test would be affected by default tx version bumps if not fixed.
+    tx.nVersion = 1;
+    ss << tx;
+    BOOST_CHECK_EQUAL(SipHashUint256(1, 2, ss.GetHash()), 0x79751e980c2a0a35ULL);
+
+    // Check consistency between CSipHasher and SipHashUint256[Extra].
+    FastRandomContext ctx;
+    for (int i = 0; i < 16; ++i) {
+        uint64_t k1 = ctx.rand64();
+        uint64_t k2 = ctx.rand64();
+        uint256 x = InsecureRand256();
+        uint32_t n = ctx.rand32();
+        uint8_t nb[4];
+        WriteLE32(nb, n);
+        CSipHasher sip256(k1, k2);
+        sip256.Write(x.begin(), 32);
+        CSipHasher sip288 = sip256;
+        sip288.Write(nb, 4);
+        BOOST_CHECK_EQUAL(SipHashUint256(k1, k2, x), sip256.Finalize());
+        BOOST_CHECK_EQUAL(SipHashUint256Extra(k1, k2, x, n), sip288.Finalize());
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/key_io_tests.cpp b/key_io_tests.cpp
new file mode 100644
index 0000000..3ea1cbf
--- /dev/null
+++ b/key_io_tests.cpp
@@ -0,0 +1,149 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/data/key_io_invalid.json.h>
+#include <test/data/key_io_valid.json.h>
+
+#include <key.h>
+#include <key_io.h>
+#include <script/script.h>
+#include <utilstrencodings.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <univalue.h>
+
+extern UniValue read_json(const std::string& jsondata);
+
+BOOST_FIXTURE_TEST_SUITE(key_io_tests, BasicTestingSetup)
+
+// Goal: check that parsed keys match test payload
+BOOST_AUTO_TEST_CASE(key_io_valid_parse)
+{
+    UniValue tests = read_json(std::string(json_tests::key_io_valid, json_tests::key_io_valid + sizeof(json_tests::key_io_valid)));
+    CKey privkey;
+    CTxDestination destination;
+    SelectParams(CBaseChainParams::MAIN);
+
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        UniValue test = tests[idx];
+        std::string strTest = test.write();
+        if (test.size() < 3) { // Allow for extra stuff (useful for comments)
+            BOOST_ERROR("Bad test: " << strTest);
+            continue;
+        }
+        std::string exp_base58string = test[0].get_str();
+        std::vector<unsigned char> exp_payload = ParseHex(test[1].get_str());
+        const UniValue &metadata = test[2].get_obj();
+        bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
+        SelectParams(find_value(metadata, "chain").get_str());
+        bool try_case_flip = find_value(metadata, "tryCaseFlip").isNull() ? false : find_value(metadata, "tryCaseFlip").get_bool();
+        if (isPrivkey) {
+            bool isCompressed = find_value(metadata, "isCompressed").get_bool();
+            // Must be valid private key
+            privkey = DecodeSecret(exp_base58string);
+            BOOST_CHECK_MESSAGE(privkey.IsValid(), "!IsValid:" + strTest);
+            BOOST_CHECK_MESSAGE(privkey.IsCompressed() == isCompressed, "compressed mismatch:" + strTest);
+            BOOST_CHECK_MESSAGE(privkey.size() == exp_payload.size() && std::equal(privkey.begin(), privkey.end(), exp_payload.begin()), "key mismatch:" + strTest);
+
+            // Private key must be invalid public key
+            destination = DecodeDestination(exp_base58string);
+            BOOST_CHECK_MESSAGE(!IsValidDestination(destination), "IsValid privkey as pubkey:" + strTest);
+        } else {
+            // Must be valid public key
+            destination = DecodeDestination(exp_base58string);
+            CScript script = GetScriptForDestination(destination);
+            BOOST_CHECK_MESSAGE(IsValidDestination(destination), "!IsValid:" + strTest);
+            BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
+
+            // Try flipped case version
+            for (char& c : exp_base58string) {
+                if (c >= 'a' && c <= 'z') {
+                    c = (c - 'a') + 'A';
+                } else if (c >= 'A' && c <= 'Z') {
+                    c = (c - 'A') + 'a';
+                }
+            }
+            destination = DecodeDestination(exp_base58string);
+            BOOST_CHECK_MESSAGE(IsValidDestination(destination) == try_case_flip, "!IsValid case flipped:" + strTest);
+            if (IsValidDestination(destination)) {
+                script = GetScriptForDestination(destination);
+                BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
+            }
+
+            // Public key must be invalid private key
+            privkey = DecodeSecret(exp_base58string);
+            BOOST_CHECK_MESSAGE(!privkey.IsValid(), "IsValid pubkey as privkey:" + strTest);
+        }
+    }
+}
+
+// Goal: check that generated keys match test vectors
+BOOST_AUTO_TEST_CASE(key_io_valid_gen)
+{
+    UniValue tests = read_json(std::string(json_tests::key_io_valid, json_tests::key_io_valid + sizeof(json_tests::key_io_valid)));
+
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        UniValue test = tests[idx];
+        std::string strTest = test.write();
+        if (test.size() < 3) // Allow for extra stuff (useful for comments)
+        {
+            BOOST_ERROR("Bad test: " << strTest);
+            continue;
+        }
+        std::string exp_base58string = test[0].get_str();
+        std::vector<unsigned char> exp_payload = ParseHex(test[1].get_str());
+        const UniValue &metadata = test[2].get_obj();
+        bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
+        SelectParams(find_value(metadata, "chain").get_str());
+        if (isPrivkey) {
+            bool isCompressed = find_value(metadata, "isCompressed").get_bool();
+            CKey key;
+            key.Set(exp_payload.begin(), exp_payload.end(), isCompressed);
+            assert(key.IsValid());
+            BOOST_CHECK_MESSAGE(EncodeSecret(key) == exp_base58string, "result mismatch: " + strTest);
+        } else {
+            CTxDestination dest;
+            CScript exp_script(exp_payload.begin(), exp_payload.end());
+            ExtractDestination(exp_script, dest);
+            std::string address = EncodeDestination(dest);
+
+            BOOST_CHECK_EQUAL(address, exp_base58string);
+        }
+    }
+
+    SelectParams(CBaseChainParams::MAIN);
+}
+
+
+// Goal: check that base58 parsing code is robust against a variety of corrupted data
+BOOST_AUTO_TEST_CASE(key_io_invalid)
+{
+    UniValue tests = read_json(std::string(json_tests::key_io_invalid, json_tests::key_io_invalid + sizeof(json_tests::key_io_invalid))); // Negative testcases
+    CKey privkey;
+    CTxDestination destination;
+
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        UniValue test = tests[idx];
+        std::string strTest = test.write();
+        if (test.size() < 1) // Allow for extra stuff (useful for comments)
+        {
+            BOOST_ERROR("Bad test: " << strTest);
+            continue;
+        }
+        std::string exp_base58string = test[0].get_str();
+
+        // must be invalid as public and as private key
+        for (auto chain : { CBaseChainParams::MAIN, CBaseChainParams::TESTNET, CBaseChainParams::REGTEST }) {
+            SelectParams(chain);
+            destination = DecodeDestination(exp_base58string);
+            BOOST_CHECK_MESSAGE(!IsValidDestination(destination), "IsValid pubkey in mainnet:" + strTest);
+            privkey = DecodeSecret(exp_base58string);
+            BOOST_CHECK_MESSAGE(!privkey.IsValid(), "IsValid privkey in mainnet:" + strTest);
+        }
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/key_tests.cpp b/key_tests.cpp
new file mode 100644
index 0000000..18d23d8
--- /dev/null
+++ b/key_tests.cpp
@@ -0,0 +1,155 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <key.h>
+
+#include <key_io.h>
+#include <script/script.h>
+#include <uint256.h>
+#include <util.h>
+#include <utilstrencodings.h>
+#include <test/test_salemcash.h>
+
+#include <string>
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+static const std::string strSecret1 = "5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjHHfmFiWtmAbrj";
+static const std::string strSecret2 = "5KC4ejrDjv152FGwP386VD1i2NYc5KkfSMyv1nGy1VGDxGHqVY3";
+static const std::string strSecret1C = "Kwr371tjA9u2rFSMZjTNun2PXXP3WPZu2afRHTcta6KxEUdm1vEw";
+static const std::string strSecret2C = "L3Hq7a8FEQwJkW1M2GNKDW28546Vp5miewcCzSqUD9kCAXrJdS3g";
+static const std::string addr1 = "1QFqqMUD55ZV3PJEJZtaKCsQmjLT6JkjvJ";
+static const std::string addr2 = "1F5y5E5FMc5YzdJtB9hLaUe43GDxEKXENJ";
+static const std::string addr1C = "1NoJrossxPBKfCHuJXT4HadJrXRE9Fxiqs";
+static const std::string addr2C = "1CRj2HyM1CXWzHAXLQtiGLyggNT9WQqsDs";
+
+static const std::string strAddressBad = "1HV9Lc3sNHZxwj4Zk6fB38tEmBryq2cBiF";
+
+
+BOOST_FIXTURE_TEST_SUITE(key_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(key_test1)
+{
+    CKey key1  = DecodeSecret(strSecret1);
+    BOOST_CHECK(key1.IsValid() && !key1.IsCompressed());
+    CKey key2  = DecodeSecret(strSecret2);
+    BOOST_CHECK(key2.IsValid() && !key2.IsCompressed());
+    CKey key1C = DecodeSecret(strSecret1C);
+    BOOST_CHECK(key1C.IsValid() && key1C.IsCompressed());
+    CKey key2C = DecodeSecret(strSecret2C);
+    BOOST_CHECK(key2C.IsValid() && key2C.IsCompressed());
+    CKey bad_key = DecodeSecret(strAddressBad);
+    BOOST_CHECK(!bad_key.IsValid());
+
+    CPubKey pubkey1  = key1. GetPubKey();
+    CPubKey pubkey2  = key2. GetPubKey();
+    CPubKey pubkey1C = key1C.GetPubKey();
+    CPubKey pubkey2C = key2C.GetPubKey();
+
+    BOOST_CHECK(key1.VerifyPubKey(pubkey1));
+    BOOST_CHECK(!key1.VerifyPubKey(pubkey1C));
+    BOOST_CHECK(!key1.VerifyPubKey(pubkey2));
+    BOOST_CHECK(!key1.VerifyPubKey(pubkey2C));
+
+    BOOST_CHECK(!key1C.VerifyPubKey(pubkey1));
+    BOOST_CHECK(key1C.VerifyPubKey(pubkey1C));
+    BOOST_CHECK(!key1C.VerifyPubKey(pubkey2));
+    BOOST_CHECK(!key1C.VerifyPubKey(pubkey2C));
+
+    BOOST_CHECK(!key2.VerifyPubKey(pubkey1));
+    BOOST_CHECK(!key2.VerifyPubKey(pubkey1C));
+    BOOST_CHECK(key2.VerifyPubKey(pubkey2));
+    BOOST_CHECK(!key2.VerifyPubKey(pubkey2C));
+
+    BOOST_CHECK(!key2C.VerifyPubKey(pubkey1));
+    BOOST_CHECK(!key2C.VerifyPubKey(pubkey1C));
+    BOOST_CHECK(!key2C.VerifyPubKey(pubkey2));
+    BOOST_CHECK(key2C.VerifyPubKey(pubkey2C));
+
+    BOOST_CHECK(DecodeDestination(addr1)  == CTxDestination(pubkey1.GetID()));
+    BOOST_CHECK(DecodeDestination(addr2)  == CTxDestination(pubkey2.GetID()));
+    BOOST_CHECK(DecodeDestination(addr1C) == CTxDestination(pubkey1C.GetID()));
+    BOOST_CHECK(DecodeDestination(addr2C) == CTxDestination(pubkey2C.GetID()));
+
+    for (int n=0; n<16; n++)
+    {
+        std::string strMsg = strprintf("Very secret message %i: 11", n);
+        uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
+
+        // normal signatures
+
+        std::vector<unsigned char> sign1, sign2, sign1C, sign2C;
+
+        BOOST_CHECK(key1.Sign (hashMsg, sign1));
+        BOOST_CHECK(key2.Sign (hashMsg, sign2));
+        BOOST_CHECK(key1C.Sign(hashMsg, sign1C));
+        BOOST_CHECK(key2C.Sign(hashMsg, sign2C));
+
+        BOOST_CHECK( pubkey1.Verify(hashMsg, sign1));
+        BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2));
+        BOOST_CHECK( pubkey1.Verify(hashMsg, sign1C));
+        BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2C));
+
+        BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1));
+        BOOST_CHECK( pubkey2.Verify(hashMsg, sign2));
+        BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1C));
+        BOOST_CHECK( pubkey2.Verify(hashMsg, sign2C));
+
+        BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1));
+        BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2));
+        BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1C));
+        BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2C));
+
+        BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1));
+        BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2));
+        BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1C));
+        BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2C));
+
+        // compact signatures (with key recovery)
+
+        std::vector<unsigned char> csign1, csign2, csign1C, csign2C;
+
+        BOOST_CHECK(key1.SignCompact (hashMsg, csign1));
+        BOOST_CHECK(key2.SignCompact (hashMsg, csign2));
+        BOOST_CHECK(key1C.SignCompact(hashMsg, csign1C));
+        BOOST_CHECK(key2C.SignCompact(hashMsg, csign2C));
+
+        CPubKey rkey1, rkey2, rkey1C, rkey2C;
+
+        BOOST_CHECK(rkey1.RecoverCompact (hashMsg, csign1));
+        BOOST_CHECK(rkey2.RecoverCompact (hashMsg, csign2));
+        BOOST_CHECK(rkey1C.RecoverCompact(hashMsg, csign1C));
+        BOOST_CHECK(rkey2C.RecoverCompact(hashMsg, csign2C));
+
+        BOOST_CHECK(rkey1  == pubkey1);
+        BOOST_CHECK(rkey2  == pubkey2);
+        BOOST_CHECK(rkey1C == pubkey1C);
+        BOOST_CHECK(rkey2C == pubkey2C);
+    }
+
+    // test deterministic signing
+
+    std::vector<unsigned char> detsig, detsigc;
+    std::string strMsg = "Very deterministic message";
+    uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
+    BOOST_CHECK(key1.Sign(hashMsg, detsig));
+    BOOST_CHECK(key1C.Sign(hashMsg, detsigc));
+    BOOST_CHECK(detsig == detsigc);
+    BOOST_CHECK(detsig == ParseHex("304402205dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d022014ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
+    BOOST_CHECK(key2.Sign(hashMsg, detsig));
+    BOOST_CHECK(key2C.Sign(hashMsg, detsigc));
+    BOOST_CHECK(detsig == detsigc);
+    BOOST_CHECK(detsig == ParseHex("3044022052d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd5022061d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
+    BOOST_CHECK(key1.SignCompact(hashMsg, detsig));
+    BOOST_CHECK(key1C.SignCompact(hashMsg, detsigc));
+    BOOST_CHECK(detsig == ParseHex("1c5dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d14ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
+    BOOST_CHECK(detsigc == ParseHex("205dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d14ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
+    BOOST_CHECK(key2.SignCompact(hashMsg, detsig));
+    BOOST_CHECK(key2C.SignCompact(hashMsg, detsigc));
+    BOOST_CHECK(detsig == ParseHex("1c52d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd561d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
+    BOOST_CHECK(detsigc == ParseHex("2052d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd561d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/limitedmap_tests.cpp b/limitedmap_tests.cpp
new file mode 100644
index 0000000..8cf496d
--- /dev/null
+++ b/limitedmap_tests.cpp
@@ -0,0 +1,101 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <limitedmap.h>
+
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(limitedmap_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(limitedmap_test)
+{
+    // create a limitedmap capped at 10 items
+    limitedmap<int, int> map(10);
+
+    // check that the max size is 10
+    BOOST_CHECK(map.max_size() == 10);
+
+    // check that it's empty
+    BOOST_CHECK(map.size() == 0);
+
+    // insert (-1, -1)
+    map.insert(std::pair<int, int>(-1, -1));
+
+    // make sure that the size is updated
+    BOOST_CHECK(map.size() == 1);
+
+    // make sure that the new item is in the map
+    BOOST_CHECK(map.count(-1) == 1);
+
+    // insert 10 new items
+    for (int i = 0; i < 10; i++) {
+        map.insert(std::pair<int, int>(i, i + 1));
+    }
+
+    // make sure that the map now contains 10 items...
+    BOOST_CHECK(map.size() == 10);
+
+    // ...and that the first item has been discarded
+    BOOST_CHECK(map.count(-1) == 0);
+
+    // iterate over the map, both with an index and an iterator
+    limitedmap<int, int>::const_iterator it = map.begin();
+    for (int i = 0; i < 10; i++) {
+        // make sure the item is present
+        BOOST_CHECK(map.count(i) == 1);
+
+        // use the iterator to check for the expected key and value
+        BOOST_CHECK(it->first == i);
+        BOOST_CHECK(it->second == i + 1);
+        
+        // use find to check for the value
+        BOOST_CHECK(map.find(i)->second == i + 1);
+        
+        // update and recheck
+        map.update(it, i + 2);
+        BOOST_CHECK(map.find(i)->second == i + 2);
+
+        it++;
+    }
+
+    // check that we've exhausted the iterator
+    BOOST_CHECK(it == map.end());
+
+    // resize the map to 5 items
+    map.max_size(5);
+
+    // check that the max size and size are now 5
+    BOOST_CHECK(map.max_size() == 5);
+    BOOST_CHECK(map.size() == 5);
+
+    // check that items less than 5 have been discarded
+    // and items greater than 5 are retained
+    for (int i = 0; i < 10; i++) {
+        if (i < 5) {
+            BOOST_CHECK(map.count(i) == 0);
+        } else {
+            BOOST_CHECK(map.count(i) == 1);
+        }
+    }
+
+    // erase some items not in the map
+    for (int i = 100; i < 1000; i += 100) {
+        map.erase(i);
+    }
+
+    // check that the size is unaffected
+    BOOST_CHECK(map.size() == 5);
+
+    // erase the remaining elements
+    for (int i = 5; i < 10; i++) {
+        map.erase(i);
+    }
+
+    // check that the map is now empty
+    BOOST_CHECK(map.empty());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/main_tests.cpp b/main_tests.cpp
new file mode 100644
index 0000000..75372a9
--- /dev/null
+++ b/main_tests.cpp
@@ -0,0 +1,77 @@
+// Copyright (c) 2018 The SalemCash 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 <validation.h>
+#include <net.h>
+
+#include <test/test_salemcash.h>
+
+#include <boost/signals2/signal.hpp>
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(main_tests, TestingSetup)
+
+static void TestBlockSubsidyHalvings(const Consensus::Params& consensusParams)
+{
+    int maxHalvings = 64;
+    CAmount nInitialSubsidy = 50 * CASH;
+
+    CAmount nPreviousSubsidy = nInitialSubsidy * 2; // for height == 0
+    BOOST_CHECK_EQUAL(nPreviousSubsidy, nInitialSubsidy * 2);
+    for (int nHalvings = 0; nHalvings < maxHalvings; nHalvings++) {
+        int nHeight = nHalvings * consensusParams.nSubsidyHalvingInterval;
+        CAmount nSubsidy = GetBlockSubsidy(nHeight, consensusParams);
+        BOOST_CHECK(nSubsidy <= nInitialSubsidy);
+        BOOST_CHECK_EQUAL(nSubsidy, nPreviousSubsidy / 2);
+        nPreviousSubsidy = nSubsidy;
+    }
+    BOOST_CHECK_EQUAL(GetBlockSubsidy(maxHalvings * consensusParams.nSubsidyHalvingInterval, consensusParams), 0);
+}
+
+static void TestBlockSubsidyHalvings(int nSubsidyHalvingInterval)
+{
+    Consensus::Params consensusParams;
+    consensusParams.nSubsidyHalvingInterval = nSubsidyHalvingInterval;
+    TestBlockSubsidyHalvings(consensusParams);
+}
+
+BOOST_AUTO_TEST_CASE(block_subsidy_test)
+{
+    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    TestBlockSubsidyHalvings(chainParams->GetConsensus()); // As in main
+    TestBlockSubsidyHalvings(150); // As in regtest
+    TestBlockSubsidyHalvings(1000); // Just another interval
+}
+
+BOOST_AUTO_TEST_CASE(subsidy_limit_test)
+{
+    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    CAmount nSum = 0;
+    for (int nHeight = 0; nHeight < 14000000; nHeight += 1000) {
+        CAmount nSubsidy = GetBlockSubsidy(nHeight, chainParams->GetConsensus());
+        BOOST_CHECK(nSubsidy <= 50 * COIN);
+        nSum += nSubsidy * 1000;
+        BOOST_CHECK(MoneyRange(nSum));
+    }
+    BOOST_CHECK_EQUAL(nSum, 2099999997690000ULL);
+}
+
+bool ReturnFalse() { return false; }
+bool ReturnTrue() { return true; }
+
+BOOST_AUTO_TEST_CASE(test_combiner_all)
+{
+    boost::signals2::signal<bool (), CombinerAll> Test;
+    BOOST_CHECK(Test());
+    Test.connect(&ReturnFalse);
+    BOOST_CHECK(!Test());
+    Test.connect(&ReturnTrue);
+    BOOST_CHECK(!Test());
+    Test.disconnect(&ReturnFalse);
+    BOOST_CHECK(Test());
+    Test.disconnect(&ReturnTrue);
+    BOOST_CHECK(Test());
+}
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/mempool_tests.cpp b/mempool_tests.cpp
new file mode 100644
index 0000000..b10a205
--- /dev/null
+++ b/mempool_tests.cpp
@@ -0,0 +1,574 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <policy/policy.h>
+#include <txmempool.h>
+#include <util.h>
+
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+#include <list>
+#include <vector>
+
+BOOST_FIXTURE_TEST_SUITE(mempool_tests, TestingSetup)
+
+BOOST_AUTO_TEST_CASE(MempoolRemoveTest)
+{
+    // Test CTxMemPool::remove functionality
+
+    TestMemPoolEntryHelper entry;
+    // Parent transaction with three children,
+    // and three grand-children:
+    CMutableTransaction txParent;
+    txParent.vin.resize(1);
+    txParent.vin[0].scriptSig = CScript() << OP_11;
+    txParent.vout.resize(3);
+    for (int i = 0; i < 3; i++)
+    {
+        txParent.vout[i].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+        txParent.vout[i].nValue = 33000LL;
+    }
+    CMutableTransaction txChild[3];
+    for (int i = 0; i < 3; i++)
+    {
+        txChild[i].vin.resize(1);
+        txChild[i].vin[0].scriptSig = CScript() << OP_11;
+        txChild[i].vin[0].prevout.hash = txParent.GetHash();
+        txChild[i].vin[0].prevout.n = i;
+        txChild[i].vout.resize(1);
+        txChild[i].vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+        txChild[i].vout[0].nValue = 11000LL;
+    }
+    CMutableTransaction txGrandChild[3];
+    for (int i = 0; i < 3; i++)
+    {
+        txGrandChild[i].vin.resize(1);
+        txGrandChild[i].vin[0].scriptSig = CScript() << OP_11;
+        txGrandChild[i].vin[0].prevout.hash = txChild[i].GetHash();
+        txGrandChild[i].vin[0].prevout.n = 0;
+        txGrandChild[i].vout.resize(1);
+        txGrandChild[i].vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+        txGrandChild[i].vout[0].nValue = 11000LL;
+    }
+
+
+    CTxMemPool testPool;
+
+    // Nothing in pool, remove should do nothing:
+    unsigned int poolSize = testPool.size();
+    testPool.removeRecursive(txParent);
+    BOOST_CHECK_EQUAL(testPool.size(), poolSize);
+
+    // Just the parent:
+    testPool.addUnchecked(txParent.GetHash(), entry.FromTx(txParent));
+    poolSize = testPool.size();
+    testPool.removeRecursive(txParent);
+    BOOST_CHECK_EQUAL(testPool.size(), poolSize - 1);
+    
+    // Parent, children, grandchildren:
+    testPool.addUnchecked(txParent.GetHash(), entry.FromTx(txParent));
+    for (int i = 0; i < 3; i++)
+    {
+        testPool.addUnchecked(txChild[i].GetHash(), entry.FromTx(txChild[i]));
+        testPool.addUnchecked(txGrandChild[i].GetHash(), entry.FromTx(txGrandChild[i]));
+    }
+    // Remove Child[0], GrandChild[0] should be removed:
+    poolSize = testPool.size();
+    testPool.removeRecursive(txChild[0]);
+    BOOST_CHECK_EQUAL(testPool.size(), poolSize - 2);
+    // ... make sure grandchild and child are gone:
+    poolSize = testPool.size();
+    testPool.removeRecursive(txGrandChild[0]);
+    BOOST_CHECK_EQUAL(testPool.size(), poolSize);
+    poolSize = testPool.size();
+    testPool.removeRecursive(txChild[0]);
+    BOOST_CHECK_EQUAL(testPool.size(), poolSize);
+    // Remove parent, all children/grandchildren should go:
+    poolSize = testPool.size();
+    testPool.removeRecursive(txParent);
+    BOOST_CHECK_EQUAL(testPool.size(), poolSize - 5);
+    BOOST_CHECK_EQUAL(testPool.size(), 0);
+
+    // Add children and grandchildren, but NOT the parent (simulate the parent being in a block)
+    for (int i = 0; i < 3; i++)
+    {
+        testPool.addUnchecked(txChild[i].GetHash(), entry.FromTx(txChild[i]));
+        testPool.addUnchecked(txGrandChild[i].GetHash(), entry.FromTx(txGrandChild[i]));
+    }
+    // Now remove the parent, as might happen if a block-re-org occurs but the parent cannot be
+    // put into the mempool (maybe because it is non-standard):
+    poolSize = testPool.size();
+    testPool.removeRecursive(txParent);
+    BOOST_CHECK_EQUAL(testPool.size(), poolSize - 6);
+    BOOST_CHECK_EQUAL(testPool.size(), 0);
+}
+
+template<typename name>
+void CheckSort(CTxMemPool &pool, std::vector<std::string> &sortedOrder)
+{
+    BOOST_CHECK_EQUAL(pool.size(), sortedOrder.size());
+    typename CTxMemPool::indexed_transaction_set::index<name>::type::iterator it = pool.mapTx.get<name>().begin();
+    int count=0;
+    for (; it != pool.mapTx.get<name>().end(); ++it, ++count) {
+        BOOST_CHECK_EQUAL(it->GetTx().GetHash().ToString(), sortedOrder[count]);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(MempoolIndexingTest)
+{
+    CTxMemPool pool;
+    TestMemPoolEntryHelper entry;
+
+    /* 3rd highest fee */
+    CMutableTransaction tx1 = CMutableTransaction();
+    tx1.vout.resize(1);
+    tx1.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx1.vout[0].nValue = 10 * COIN;
+    pool.addUnchecked(tx1.GetHash(), entry.Fee(10000LL).FromTx(tx1));
+
+    /* highest fee */
+    CMutableTransaction tx2 = CMutableTransaction();
+    tx2.vout.resize(1);
+    tx2.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx2.vout[0].nValue = 2 * COIN;
+    pool.addUnchecked(tx2.GetHash(), entry.Fee(20000LL).FromTx(tx2));
+
+    /* lowest fee */
+    CMutableTransaction tx3 = CMutableTransaction();
+    tx3.vout.resize(1);
+    tx3.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx3.vout[0].nValue = 5 * COIN;
+    pool.addUnchecked(tx3.GetHash(), entry.Fee(0LL).FromTx(tx3));
+
+    /* 2nd highest fee */
+    CMutableTransaction tx4 = CMutableTransaction();
+    tx4.vout.resize(1);
+    tx4.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx4.vout[0].nValue = 6 * COIN;
+    pool.addUnchecked(tx4.GetHash(), entry.Fee(15000LL).FromTx(tx4));
+
+    /* equal fee rate to tx1, but newer */
+    CMutableTransaction tx5 = CMutableTransaction();
+    tx5.vout.resize(1);
+    tx5.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx5.vout[0].nValue = 11 * CASH;
+    entry.nTime = 1;
+    pool.addUnchecked(tx5.GetHash(), entry.Fee(10000LL).FromTx(tx5));
+    BOOST_CHECK_EQUAL(pool.size(), 5);
+
+    std::vector<std::string> sortedOrder;
+    sortedOrder.resize(5);
+    sortedOrder[0] = tx3.GetHash().ToString(); // 0
+    sortedOrder[1] = tx5.GetHash().ToString(); // 10000
+    sortedOrder[2] = tx1.GetHash().ToString(); // 10000
+    sortedOrder[3] = tx4.GetHash().ToString(); // 15000
+    sortedOrder[4] = tx2.GetHash().ToString(); // 20000
+    LOCK(pool.cs);
+    CheckSort<descendant_score>(pool, sortedOrder);
+
+    /* low fee but with high fee child */
+    /* tx6 -> tx7 -> tx8, tx9 -> tx10 */
+    CMutableTransaction tx6 = CMutableTransaction();
+    tx6.vout.resize(1);
+    tx6.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx6.vout[0].nValue = 20 * COIN;
+    pool.addUnchecked(tx6.GetHash(), entry.Fee(0LL).FromTx(tx6));
+    BOOST_CHECK_EQUAL(pool.size(), 6);
+    // Check that at this point, tx6 is sorted low
+    sortedOrder.insert(sortedOrder.begin(), tx6.GetHash().ToString());
+    CheckSort<descendant_score>(pool, sortedOrder);
+
+    CTxMemPool::setEntries setAncestors;
+    setAncestors.insert(pool.mapTx.find(tx6.GetHash()));
+    CMutableTransaction tx7 = CMutableTransaction();
+    tx7.vin.resize(1);
+    tx7.vin[0].prevout = COutPoint(tx6.GetHash(), 0);
+    tx7.vin[0].scriptSig = CScript() << OP_11;
+    tx7.vout.resize(2);
+    tx7.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx7.vout[0].nValue = 10 * CASH;
+    tx7.vout[1].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx7.vout[1].nValue = 1 * CASH;
+
+    CTxMemPool::setEntries setAncestorsCalculated;
+    std::string dummy;
+    BOOST_CHECK_EQUAL(pool.CalculateMemPoolAncestors(entry.Fee(2000000LL).FromTx(tx7), setAncestorsCalculated, 100, 1000000, 1000, 1000000, dummy), true);
+    BOOST_CHECK(setAncestorsCalculated == setAncestors);
+
+    pool.addUnchecked(tx7.GetHash(), entry.FromTx(tx7), setAncestors);
+    BOOST_CHECK_EQUAL(pool.size(), 7);
+
+    // Now tx6 should be sorted higher (high fee child): tx7, tx6, tx2, ...
+    sortedOrder.erase(sortedOrder.begin());
+    sortedOrder.push_back(tx6.GetHash().ToString());
+    sortedOrder.push_back(tx7.GetHash().ToString());
+    CheckSort<descendant_score>(pool, sortedOrder);
+
+    /* low fee child of tx7 */
+    CMutableTransaction tx8 = CMutableTransaction();
+    tx8.vin.resize(1);
+    tx8.vin[0].prevout = COutPoint(tx7.GetHash(), 0);
+    tx8.vin[0].scriptSig = CScript() << OP_11;
+    tx8.vout.resize(1);
+    tx8.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx8.vout[0].nValue = 10 * CASH;
+    setAncestors.insert(pool.mapTx.find(tx7.GetHash()));
+    pool.addUnchecked(tx8.GetHash(), entry.Fee(0LL).Time(2).FromTx(tx8), setAncestors);
+
+    // Now tx8 should be sorted low, but tx6/tx both high
+    sortedOrder.insert(sortedOrder.begin(), tx8.GetHash().ToString());
+    CheckSort<descendant_score>(pool, sortedOrder);
+
+    /* low fee child of tx7 */
+    CMutableTransaction tx9 = CMutableTransaction();
+    tx9.vin.resize(1);
+    tx9.vin[0].prevout = COutPoint(tx7.GetHash(), 1);
+    tx9.vin[0].scriptSig = CScript() << OP_11;
+    tx9.vout.resize(1);
+    tx9.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx9.vout[0].nValue = 1 * CASH;
+    pool.addUnchecked(tx9.GetHash(), entry.Fee(0LL).Time(3).FromTx(tx9), setAncestors);
+
+    // tx9 should be sorted low
+    BOOST_CHECK_EQUAL(pool.size(), 9);
+    sortedOrder.insert(sortedOrder.begin(), tx9.GetHash().ToString());
+    CheckSort<descendant_score>(pool, sortedOrder);
+
+    std::vector<std::string> snapshotOrder = sortedOrder;
+
+    setAncestors.insert(pool.mapTx.find(tx8.GetHash()));
+    setAncestors.insert(pool.mapTx.find(tx9.GetHash()));
+    /* tx10 depends on tx8 and tx9 and has a high fee*/
+    CMutableTransaction tx10 = CMutableTransaction();
+    tx10.vin.resize(2);
+    tx10.vin[0].prevout = COutPoint(tx8.GetHash(), 0);
+    tx10.vin[0].scriptSig = CScript() << OP_11;
+    tx10.vin[1].prevout = COutPoint(tx9.GetHash(), 0);
+    tx10.vin[1].scriptSig = CScript() << OP_11;
+    tx10.vout.resize(1);
+    tx10.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx10.vout[0].nValue = 10 * CASH;
+
+    setAncestorsCalculated.clear();
+    BOOST_CHECK_EQUAL(pool.CalculateMemPoolAncestors(entry.Fee(200000LL).Time(4).FromTx(tx10), setAncestorsCalculated, 100, 1000000, 1000, 1000000, dummy), true);
+    BOOST_CHECK(setAncestorsCalculated == setAncestors);
+
+    pool.addUnchecked(tx10.GetHash(), entry.FromTx(tx10), setAncestors);
+
+    /**
+     *  tx8 and tx9 should both now be sorted higher
+     *  Final order after tx10 is added:
+     *
+     *  tx3 = 0 (1)
+     *  tx5 = 10000 (1)
+     *  tx1 = 10000 (1)
+     *  tx4 = 15000 (1)
+     *  tx2 = 20000 (1)
+     *  tx9 = 200k (2 txs)
+     *  tx8 = 200k (2 txs)
+     *  tx10 = 200k (1 tx)
+     *  tx6 = 2.2M (5 txs)
+     *  tx7 = 2.2M (4 txs)
+     */
+    sortedOrder.erase(sortedOrder.begin(), sortedOrder.begin()+2); // take out tx9, tx8 from the beginning
+    sortedOrder.insert(sortedOrder.begin()+5, tx9.GetHash().ToString());
+    sortedOrder.insert(sortedOrder.begin()+6, tx8.GetHash().ToString());
+    sortedOrder.insert(sortedOrder.begin()+7, tx10.GetHash().ToString()); // tx10 is just before tx6
+    CheckSort<descendant_score>(pool, sortedOrder);
+
+    // there should be 10 transactions in the mempool
+    BOOST_CHECK_EQUAL(pool.size(), 10);
+
+    // Now try removing tx10 and verify the sort order returns to normal
+    pool.removeRecursive(pool.mapTx.find(tx10.GetHash())->GetTx());
+    CheckSort<descendant_score>(pool, snapshotOrder);
+
+    pool.removeRecursive(pool.mapTx.find(tx9.GetHash())->GetTx());
+    pool.removeRecursive(pool.mapTx.find(tx8.GetHash())->GetTx());
+}
+
+BOOST_AUTO_TEST_CASE(MempoolAncestorIndexingTest)
+{
+    CTxMemPool pool;
+    TestMemPoolEntryHelper entry;
+
+    /* 3rd highest fee */
+    CMutableTransaction tx1 = CMutableTransaction();
+    tx1.vout.resize(1);
+    tx1.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx1.vout[0].nValue = 10 * CASH;
+    pool.addUnchecked(tx1.GetHash(), entry.Fee(10000LL).FromTx(tx1));
+
+    /* highest fee */
+    CMutableTransaction tx2 = CMutableTransaction();
+    tx2.vout.resize(1);
+    tx2.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx2.vout[0].nValue = 2 * CASH;
+    pool.addUnchecked(tx2.GetHash(), entry.Fee(20000LL).FromTx(tx2));
+    uint64_t tx2Size = GetVirtualTransactionSize(tx2);
+
+    /* lowest fee */
+    CMutableTransaction tx3 = CMutableTransaction();
+    tx3.vout.resize(1);
+    tx3.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx3.vout[0].nValue = 5 * CASH;
+    pool.addUnchecked(tx3.GetHash(), entry.Fee(0LL).FromTx(tx3));
+
+    /* 2nd highest fee */
+    CMutableTransaction tx4 = CMutableTransaction();
+    tx4.vout.resize(1);
+    tx4.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx4.vout[0].nValue = 6 * CASH;
+    pool.addUnchecked(tx4.GetHash(), entry.Fee(15000LL).FromTx(tx4));
+
+    /* equal fee rate to tx1, but newer */
+    CMutableTransaction tx5 = CMutableTransaction();
+    tx5.vout.resize(1);
+    tx5.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx5.vout[0].nValue = 11 * CASH;
+    pool.addUnchecked(tx5.GetHash(), entry.Fee(10000LL).FromTx(tx5));
+    BOOST_CHECK_EQUAL(pool.size(), 5);
+
+    std::vector<std::string> sortedOrder;
+    sortedOrder.resize(5);
+    sortedOrder[0] = tx2.GetHash().ToString(); // 20000
+    sortedOrder[1] = tx4.GetHash().ToString(); // 15000
+    // tx1 and tx5 are both 10000
+    // Ties are broken by hash, not timestamp, so determine which
+    // hash comes first.
+    if (tx1.GetHash() < tx5.GetHash()) {
+        sortedOrder[2] = tx1.GetHash().ToString();
+        sortedOrder[3] = tx5.GetHash().ToString();
+    } else {
+        sortedOrder[2] = tx5.GetHash().ToString();
+        sortedOrder[3] = tx1.GetHash().ToString();
+    }
+    sortedOrder[4] = tx3.GetHash().ToString(); // 0
+
+    LOCK(pool.cs);
+    CheckSort<ancestor_score>(pool, sortedOrder);
+
+    /* low fee parent with high fee child */
+    /* tx6 (0) -> tx7 (high) */
+    CMutableTransaction tx6 = CMutableTransaction();
+    tx6.vout.resize(1);
+    tx6.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx6.vout[0].nValue = 20 * CASH;
+    uint64_t tx6Size = GetVirtualTransactionSize(tx6);
+
+    pool.addUnchecked(tx6.GetHash(), entry.Fee(0LL).FromTx(tx6));
+    BOOST_CHECK_EQUAL(pool.size(), 6);
+    // Ties are broken by hash
+    if (tx3.GetHash() < tx6.GetHash())
+        sortedOrder.push_back(tx6.GetHash().ToString());
+    else
+        sortedOrder.insert(sortedOrder.end()-1,tx6.GetHash().ToString());
+
+    CheckSort<ancestor_score>(pool, sortedOrder);
+
+    CMutableTransaction tx7 = CMutableTransaction();
+    tx7.vin.resize(1);
+    tx7.vin[0].prevout = COutPoint(tx6.GetHash(), 0);
+    tx7.vin[0].scriptSig = CScript() << OP_11;
+    tx7.vout.resize(1);
+    tx7.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx7.vout[0].nValue = 10 * CASH;
+    uint64_t tx7Size = GetVirtualTransactionSize(tx7);
+
+    /* set the fee to just below tx2's feerate when including ancestor */
+    CAmount fee = (20000/tx2Size)*(tx7Size + tx6Size) - 1;
+
+    pool.addUnchecked(tx7.GetHash(), entry.Fee(fee).FromTx(tx7));
+    BOOST_CHECK_EQUAL(pool.size(), 7);
+    sortedOrder.insert(sortedOrder.begin()+1, tx7.GetHash().ToString());
+    CheckSort<ancestor_score>(pool, sortedOrder);
+
+    /* after tx6 is mined, tx7 should move up in the sort */
+    std::vector<CTransactionRef> vtx;
+    vtx.push_back(MakeTransactionRef(tx6));
+    pool.removeForBlock(vtx, 1);
+
+    sortedOrder.erase(sortedOrder.begin()+1);
+    // Ties are broken by hash
+    if (tx3.GetHash() < tx6.GetHash())
+        sortedOrder.pop_back();
+    else
+        sortedOrder.erase(sortedOrder.end()-2);
+    sortedOrder.insert(sortedOrder.begin(), tx7.GetHash().ToString());
+    CheckSort<ancestor_score>(pool, sortedOrder);
+
+    // High-fee parent, low-fee child
+    // tx7 -> tx8
+    CMutableTransaction tx8 = CMutableTransaction();
+    tx8.vin.resize(1);
+    tx8.vin[0].prevout  = COutPoint(tx7.GetHash(), 0);
+    tx8.vin[0].scriptSig = CScript() << OP_11;
+    tx8.vout.resize(1);
+    tx8.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;
+    tx8.vout[0].nValue = 10*CASH;
+
+    // Check that we sort by min(feerate, ancestor_feerate):
+    // set the fee so that the ancestor feerate is above tx1/5,
+    // but the transaction's own feerate is lower
+    pool.addUnchecked(tx8.GetHash(), entry.Fee(5000LL).FromTx(tx8));
+    sortedOrder.insert(sortedOrder.end()-1, tx8.GetHash().ToString());
+    CheckSort<ancestor_score>(pool, sortedOrder);
+}
+
+
+BOOST_AUTO_TEST_CASE(MempoolSizeLimitTest)
+{
+    CTxMemPool pool;
+    TestMemPoolEntryHelper entry;
+
+    CMutableTransaction tx1 = CMutableTransaction();
+    tx1.vin.resize(1);
+    tx1.vin[0].scriptSig = CScript() << OP_1;
+    tx1.vout.resize(1);
+    tx1.vout[0].scriptPubKey = CScript() << OP_1 << OP_EQUAL;
+    tx1.vout[0].nValue = 10 * CASH;
+    pool.addUnchecked(tx1.GetHash(), entry.Fee(10000LL).FromTx(tx1));
+
+    CMutableTransaction tx2 = CMutableTransaction();
+    tx2.vin.resize(1);
+    tx2.vin[0].scriptSig = CScript() << OP_2;
+    tx2.vout.resize(1);
+    tx2.vout[0].scriptPubKey = CScript() << OP_2 << OP_EQUAL;
+    tx2.vout[0].nValue = 10 * CASH;
+    pool.addUnchecked(tx2.GetHash(), entry.Fee(5000LL).FromTx(tx2));
+
+    pool.TrimToSize(pool.DynamicMemoryUsage()); // should do nothing
+    BOOST_CHECK(pool.exists(tx1.GetHash()));
+    BOOST_CHECK(pool.exists(tx2.GetHash()));
+
+    pool.TrimToSize(pool.DynamicMemoryUsage() * 3 / 4); // should remove the lower-feerate transaction
+    BOOST_CHECK(pool.exists(tx1.GetHash()));
+    BOOST_CHECK(!pool.exists(tx2.GetHash()));
+
+    pool.addUnchecked(tx2.GetHash(), entry.FromTx(tx2));
+    CMutableTransaction tx3 = CMutableTransaction();
+    tx3.vin.resize(1);
+    tx3.vin[0].prevout = COutPoint(tx2.GetHash(), 0);
+    tx3.vin[0].scriptSig = CScript() << OP_2;
+    tx3.vout.resize(1);
+    tx3.vout[0].scriptPubKey = CScript() << OP_3 << OP_EQUAL;
+    tx3.vout[0].nValue = 10 * CASH;
+    pool.addUnchecked(tx3.GetHash(), entry.Fee(20000LL).FromTx(tx3));
+
+    pool.TrimToSize(pool.DynamicMemoryUsage() * 3 / 4); // tx3 should pay for tx2 (CPFP)
+    BOOST_CHECK(!pool.exists(tx1.GetHash()));
+    BOOST_CHECK(pool.exists(tx2.GetHash()));
+    BOOST_CHECK(pool.exists(tx3.GetHash()));
+
+    pool.TrimToSize(GetVirtualTransactionSize(tx1)); // mempool is limited to tx1's size in memory usage, so nothing fits
+    BOOST_CHECK(!pool.exists(tx1.GetHash()));
+    BOOST_CHECK(!pool.exists(tx2.GetHash()));
+    BOOST_CHECK(!pool.exists(tx3.GetHash()));
+
+    CFeeRate maxFeeRateRemoved(25000, GetVirtualTransactionSize(tx3) + GetVirtualTransactionSize(tx2));
+    BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(), maxFeeRateRemoved.GetFeePerK() + 1000);
+
+    CMutableTransaction tx4 = CMutableTransaction();
+    tx4.vin.resize(2);
+    tx4.vin[0].prevout.SetNull();
+    tx4.vin[0].scriptSig = CScript() << OP_4;
+    tx4.vin[1].prevout.SetNull();
+    tx4.vin[1].scriptSig = CScript() << OP_4;
+    tx4.vout.resize(2);
+    tx4.vout[0].scriptPubKey = CScript() << OP_4 << OP_EQUAL;
+    tx4.vout[0].nValue = 10 * CASH;
+    tx4.vout[1].scriptPubKey = CScript() << OP_4 << OP_EQUAL;
+    tx4.vout[1].nValue = 10 * CASH;
+
+    CMutableTransaction tx5 = CMutableTransaction();
+    tx5.vin.resize(2);
+    tx5.vin[0].prevout = COutPoint(tx4.GetHash(), 0);
+    tx5.vin[0].scriptSig = CScript() << OP_4;
+    tx5.vin[1].prevout.SetNull();
+    tx5.vin[1].scriptSig = CScript() << OP_5;
+    tx5.vout.resize(2);
+    tx5.vout[0].scriptPubKey = CScript() << OP_5 << OP_EQUAL;
+    tx5.vout[0].nValue = 10 * CASH;
+    tx5.vout[1].scriptPubKey = CScript() << OP_5 << OP_EQUAL;
+    tx5.vout[1].nValue = 10 * CASH;
+
+    CMutableTransaction tx6 = CMutableTransaction();
+    tx6.vin.resize(2);
+    tx6.vin[0].prevout = COutPoint(tx4.GetHash(), 1);
+    tx6.vin[0].scriptSig = CScript() << OP_4;
+    tx6.vin[1].prevout.SetNull();
+    tx6.vin[1].scriptSig = CScript() << OP_6;
+    tx6.vout.resize(2);
+    tx6.vout[0].scriptPubKey = CScript() << OP_6 << OP_EQUAL;
+    tx6.vout[0].nValue = 10 * CASH;
+    tx6.vout[1].scriptPubKey = CScript() << OP_6 << OP_EQUAL;
+    tx6.vout[1].nValue = 10 * CASH;
+
+    CMutableTransaction tx7 = CMutableTransaction();
+    tx7.vin.resize(2);
+    tx7.vin[0].prevout = COutPoint(tx5.GetHash(), 0);
+    tx7.vin[0].scriptSig = CScript() << OP_5;
+    tx7.vin[1].prevout = COutPoint(tx6.GetHash(), 0);
+    tx7.vin[1].scriptSig = CScript() << OP_6;
+    tx7.vout.resize(2);
+    tx7.vout[0].scriptPubKey = CScript() << OP_7 << OP_EQUAL;
+    tx7.vout[0].nValue = 10 * CASH;
+    tx7.vout[1].scriptPubKey = CScript() << OP_7 << OP_EQUAL;
+    tx7.vout[1].nValue = 10 * CASH;
+
+    pool.addUnchecked(tx4.GetHash(), entry.Fee(7000LL).FromTx(tx4));
+    pool.addUnchecked(tx5.GetHash(), entry.Fee(1000LL).FromTx(tx5));
+    pool.addUnchecked(tx6.GetHash(), entry.Fee(1100LL).FromTx(tx6));
+    pool.addUnchecked(tx7.GetHash(), entry.Fee(9000LL).FromTx(tx7));
+
+    // we only require this to remove, at max, 2 txn, because it's not clear what we're really optimizing for aside from that
+    pool.TrimToSize(pool.DynamicMemoryUsage() - 1);
+    BOOST_CHECK(pool.exists(tx4.GetHash()));
+    BOOST_CHECK(pool.exists(tx6.GetHash()));
+    BOOST_CHECK(!pool.exists(tx7.GetHash()));
+
+    if (!pool.exists(tx5.GetHash()))
+        pool.addUnchecked(tx5.GetHash(), entry.Fee(1000LL).FromTx(tx5));
+    pool.addUnchecked(tx7.GetHash(), entry.Fee(9000LL).FromTx(tx7));
+
+    pool.TrimToSize(pool.DynamicMemoryUsage() / 2); // should maximize mempool size by only removing 5/7
+    BOOST_CHECK(pool.exists(tx4.GetHash()));
+    BOOST_CHECK(!pool.exists(tx5.GetHash()));
+    BOOST_CHECK(pool.exists(tx6.GetHash()));
+    BOOST_CHECK(!pool.exists(tx7.GetHash()));
+
+    pool.addUnchecked(tx5.GetHash(), entry.Fee(1000LL).FromTx(tx5));
+    pool.addUnchecked(tx7.GetHash(), entry.Fee(9000LL).FromTx(tx7));
+
+    std::vector<CTransactionRef> vtx;
+    SetMockTime(42);
+    SetMockTime(42 + CTxMemPool::ROLLING_FEE_HALFLIFE);
+    BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(), maxFeeRateRemoved.GetFeePerK() + 1000);
+    // ... we should keep the same min fee until we get a block
+    pool.removeForBlock(vtx, 1);
+    SetMockTime(42 + 2*CTxMemPool::ROLLING_FEE_HALFLIFE);
+    BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(), llround((maxFeeRateRemoved.GetFeePerK() + 1000)/2.0));
+    // ... then feerate should drop 1/2 each halflife
+
+    SetMockTime(42 + 2*CTxMemPool::ROLLING_FEE_HALFLIFE + CTxMemPool::ROLLING_FEE_HALFLIFE/2);
+    BOOST_CHECK_EQUAL(pool.GetMinFee(pool.DynamicMemoryUsage() * 5 / 2).GetFeePerK(), llround((maxFeeRateRemoved.GetFeePerK() + 1000)/4.0));
+    // ... with a 1/2 halflife when mempool is < 1/2 its target size
+
+    SetMockTime(42 + 2*CTxMemPool::ROLLING_FEE_HALFLIFE + CTxMemPool::ROLLING_FEE_HALFLIFE/2 + CTxMemPool::ROLLING_FEE_HALFLIFE/4);
+    BOOST_CHECK_EQUAL(pool.GetMinFee(pool.DynamicMemoryUsage() * 9 / 2).GetFeePerK(), llround((maxFeeRateRemoved.GetFeePerK() + 1000)/8.0));
+    // ... with a 1/4 halflife when mempool is < 1/4 its target size
+
+    SetMockTime(42 + 7*CTxMemPool::ROLLING_FEE_HALFLIFE + CTxMemPool::ROLLING_FEE_HALFLIFE/2 + CTxMemPool::ROLLING_FEE_HALFLIFE/4);
+    BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(), 1000);
+    // ... but feerate should never drop below 1000
+
+    SetMockTime(42 + 8*CTxMemPool::ROLLING_FEE_HALFLIFE + CTxMemPool::ROLLING_FEE_HALFLIFE/2 + CTxMemPool::ROLLING_FEE_HALFLIFE/4);
+    BOOST_CHECK_EQUAL(pool.GetMinFee(1).GetFeePerK(), 0);
+    // ... unless it has gone all the way to 0 (after getting past 1000/2)
+
+    SetMockTime(0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/merkle_tests.cpp b/merkle_tests.cpp
new file mode 100644
index 0000000..35ff5b0
--- /dev/null
+++ b/merkle_tests.cpp
@@ -0,0 +1,135 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <consensus/merkle.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(merkle_tests, TestingSetup)
+
+// Older version of the merkle root computation code, for comparison.
+static uint256 BlockBuildMerkleTree(const CBlock& block, bool* fMutated, std::vector<uint256>& vMerkleTree)
+{
+    vMerkleTree.clear();
+    vMerkleTree.reserve(block.vtx.size() * 2 + 16); // Safe upper bound for the number of total nodes.
+    for (std::vector<CTransactionRef>::const_iterator it(block.vtx.begin()); it != block.vtx.end(); ++it)
+        vMerkleTree.push_back((*it)->GetHash());
+    int j = 0;
+    bool mutated = false;
+    for (int nSize = block.vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
+    {
+        for (int i = 0; i < nSize; i += 2)
+        {
+            int i2 = std::min(i+1, nSize-1);
+            if (i2 == i + 1 && i2 + 1 == nSize && vMerkleTree[j+i] == vMerkleTree[j+i2]) {
+                // Two identical hashes at the end of the list at a particular level.
+                mutated = true;
+            }
+            vMerkleTree.push_back(Hash(vMerkleTree[j+i].begin(), vMerkleTree[j+i].end(),
+                                       vMerkleTree[j+i2].begin(), vMerkleTree[j+i2].end()));
+        }
+        j += nSize;
+    }
+    if (fMutated) {
+        *fMutated = mutated;
+    }
+    return (vMerkleTree.empty() ? uint256() : vMerkleTree.back());
+}
+
+// Older version of the merkle branch computation code, for comparison.
+static std::vector<uint256> BlockGetMerkleBranch(const CBlock& block, const std::vector<uint256>& vMerkleTree, int nIndex)
+{
+    std::vector<uint256> vMerkleBranch;
+    int j = 0;
+    for (int nSize = block.vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
+    {
+        int i = std::min(nIndex^1, nSize-1);
+        vMerkleBranch.push_back(vMerkleTree[j+i]);
+        nIndex >>= 1;
+        j += nSize;
+    }
+    return vMerkleBranch;
+}
+
+static inline int ctz(uint32_t i) {
+    if (i == 0) return 0;
+    int j = 0;
+    while (!(i & 1)) {
+        j++;
+        i >>= 1;
+    }
+    return j;
+}
+
+BOOST_AUTO_TEST_CASE(merkle_test)
+{
+    for (int i = 0; i < 32; i++) {
+        // Try 32 block sizes: all sizes from 0 to 16 inclusive, and then 15 random sizes.
+        int ntx = (i <= 16) ? i : 17 + (InsecureRandRange(4000));
+        // Try up to 3 mutations.
+        for (int mutate = 0; mutate <= 3; mutate++) {
+            int duplicate1 = mutate >= 1 ? 1 << ctz(ntx) : 0; // The last how many transactions to duplicate first.
+            if (duplicate1 >= ntx) break; // Duplication of the entire tree results in a different root (it adds a level).
+            int ntx1 = ntx + duplicate1; // The resulting number of transactions after the first duplication.
+            int duplicate2 = mutate >= 2 ? 1 << ctz(ntx1) : 0; // Likewise for the second mutation.
+            if (duplicate2 >= ntx1) break;
+            int ntx2 = ntx1 + duplicate2;
+            int duplicate3 = mutate >= 3 ? 1 << ctz(ntx2) : 0; // And for the third mutation.
+            if (duplicate3 >= ntx2) break;
+            int ntx3 = ntx2 + duplicate3;
+            // Build a block with ntx different transactions.
+            CBlock block;
+            block.vtx.resize(ntx);
+            for (int j = 0; j < ntx; j++) {
+                CMutableTransaction mtx;
+                mtx.nLockTime = j;
+                block.vtx[j] = MakeTransactionRef(std::move(mtx));
+            }
+            // Compute the root of the block before mutating it.
+            bool unmutatedMutated = false;
+            uint256 unmutatedRoot = BlockMerkleRoot(block, &unmutatedMutated);
+            BOOST_CHECK(unmutatedMutated == false);
+            // Optionally mutate by duplicating the last transactions, resulting in the same merkle root.
+            block.vtx.resize(ntx3);
+            for (int j = 0; j < duplicate1; j++) {
+                block.vtx[ntx + j] = block.vtx[ntx + j - duplicate1];
+            }
+            for (int j = 0; j < duplicate2; j++) {
+                block.vtx[ntx1 + j] = block.vtx[ntx1 + j - duplicate2];
+            }
+            for (int j = 0; j < duplicate3; j++) {
+                block.vtx[ntx2 + j] = block.vtx[ntx2 + j - duplicate3];
+            }
+            // Compute the merkle root and merkle tree using the old mechanism.
+            bool oldMutated = false;
+            std::vector<uint256> merkleTree;
+            uint256 oldRoot = BlockBuildMerkleTree(block, &oldMutated, merkleTree);
+            // Compute the merkle root using the new mechanism.
+            bool newMutated = false;
+            uint256 newRoot = BlockMerkleRoot(block, &newMutated);
+            BOOST_CHECK(oldRoot == newRoot);
+            BOOST_CHECK(newRoot == unmutatedRoot);
+            BOOST_CHECK((newRoot == uint256()) == (ntx == 0));
+            BOOST_CHECK(oldMutated == newMutated);
+            BOOST_CHECK(newMutated == !!mutate);
+            // If no mutation was done (once for every ntx value), try up to 16 branches.
+            if (mutate == 0) {
+                for (int loop = 0; loop < std::min(ntx, 16); loop++) {
+                    // If ntx <= 16, try all branches. Otherwise, try 16 random ones.
+                    int mtx = loop;
+                    if (ntx > 16) {
+                        mtx = InsecureRandRange(ntx);
+                    }
+                    std::vector<uint256> newBranch = BlockMerkleBranch(block, mtx);
+                    std::vector<uint256> oldBranch = BlockGetMerkleBranch(block, merkleTree, mtx);
+                    BOOST_CHECK(oldBranch == newBranch);
+                    BOOST_CHECK(ComputeMerkleRootFromBranch(block.vtx[mtx]->GetHash(), newBranch, mtx) == oldRoot);
+                }
+            }
+        }
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/merkleblock_tests.cpp b/merkleblock_tests.cpp
new file mode 100644
index 0000000..4ffbd58
--- /dev/null
+++ b/merkleblock_tests.cpp
@@ -0,0 +1,78 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <merkleblock.h>
+#include <uint256.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+BOOST_FIXTURE_TEST_SUITE(merkleblock_tests, BasicTestingSetup)
+
+/**
+ * Create a CMerkleBlock using a list of txids which will be found in the
+ * given block.
+ */
+BOOST_AUTO_TEST_CASE(merkleblock_construct_from_txids_found)
+{
+    CBlock block = getBlock13b8a();
+
+    std::set<uint256> txids;
+
+    // Last txn in block.
+    uint256 txhash1 = uint256S("0x74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20");
+
+    // Second txn in block.
+    uint256 txhash2 = uint256S("0xf9fc751cb7dc372406a9f8d738d5e6f8f63bab71986a39cf36ee70ee17036d07");
+
+    txids.insert(txhash1);
+    txids.insert(txhash2);
+
+    CMerkleBlock merkleBlock(block, txids);
+
+    BOOST_CHECK_EQUAL(merkleBlock.header.GetHash().GetHex(), block.GetHash().GetHex());
+
+    // vMatchedTxn is only used when bloom filter is specified.
+    BOOST_CHECK_EQUAL(merkleBlock.vMatchedTxn.size(), 0);
+
+    std::vector<uint256> vMatched;
+    std::vector<unsigned int> vIndex;
+
+    BOOST_CHECK_EQUAL(merkleBlock.txn.ExtractMatches(vMatched, vIndex).GetHex(), block.hashMerkleRoot.GetHex());
+    BOOST_CHECK_EQUAL(vMatched.size(), 2);
+
+    // Ordered by occurrence in depth-first tree traversal.
+    BOOST_CHECK_EQUAL(vMatched[0].ToString(), txhash2.ToString());
+    BOOST_CHECK_EQUAL(vIndex[0], 1);
+
+    BOOST_CHECK_EQUAL(vMatched[1].ToString(), txhash1.ToString());
+    BOOST_CHECK_EQUAL(vIndex[1], 8);
+}
+
+
+/**
+ * Create a CMerkleBlock using a list of txids which will not be found in the
+ * given block.
+ */
+BOOST_AUTO_TEST_CASE(merkleblock_construct_from_txids_not_found)
+{
+    CBlock block = getBlock13b8a();
+
+    std::set<uint256> txids2;
+    txids2.insert(uint256S("0xc0ffee00003bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20"));
+    CMerkleBlock merkleBlock(block, txids2);
+
+    BOOST_CHECK_EQUAL(merkleBlock.header.GetHash().GetHex(), block.GetHash().GetHex());
+    BOOST_CHECK_EQUAL(merkleBlock.vMatchedTxn.size(), 0);
+
+    std::vector<uint256> vMatched;
+    std::vector<unsigned int> vIndex;
+
+    BOOST_CHECK_EQUAL(merkleBlock.txn.ExtractMatches(vMatched, vIndex).GetHex(), block.hashMerkleRoot.GetHex());
+    BOOST_CHECK_EQUAL(vMatched.size(), 0);
+    BOOST_CHECK_EQUAL(vIndex.size(), 0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/miner_tests.cpp b/miner_tests.cpp
new file mode 100644
index 0000000..0868707
--- /dev/null
+++ b/miner_tests.cpp
@@ -0,0 +1,523 @@
+// Copyright (c) 2018 The SalemCash 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 <cash.h>
+#include <consensus/consensus.h>
+#include <consensus/merkle.h>
+#include <consensus/tx_verify.h>
+#include <consensus/validation.h>
+#include <validation.h>
+#include <miner.h>
+#include <policy/policy.h>
+#include <pubkey.h>
+#include <script/standard.h>
+#include <txmempool.h>
+#include <uint256.h>
+#include <util.h>
+#include <utilstrencodings.h>
+
+#include <test/test_salemcash.h>
+
+#include <memory>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(miner_tests, TestingSetup)
+
+// BOOST_CHECK_EXCEPTION predicates to check the specific validation error
+class HasReason {
+public:
+    HasReason(const std::string& reason) : m_reason(reason) {}
+    bool operator() (const std::runtime_error& e) const {
+        return std::string(e.what()).find(m_reason) != std::string::npos;
+    };
+private:
+    const std::string m_reason;
+};
+
+static CFeeRate blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE);
+
+static BlockAssembler AssemblerForTest(const CChainParams& params) {
+    BlockAssembler::Options options;
+
+    options.nBlockMaxWeight = MAX_BLOCK_WEIGHT;
+    options.blockMinFeeRate = blockMinFeeRate;
+    return BlockAssembler(params, options);
+}
+
+static
+struct {
+    unsigned char extranonce;
+    unsigned int nonce;
+} blockinfo[] = {
+    {4, 0xa4a3e223}, {2, 0x15c32f9e}, {1, 0x0375b547}, {1, 0x7004a8a5},
+    {2, 0xce440296}, {2, 0x52cfe198}, {1, 0x77a72cd0}, {2, 0xbb5d6f84},
+    {2, 0x83f30c2c}, {1, 0x48a73d5b}, {1, 0xef7dcd01}, {2, 0x6809c6c4},
+    {2, 0x0883ab3c}, {1, 0x087bbbe2}, {2, 0x2104a814}, {2, 0xdffb6daa},
+    {1, 0xee8a0a08}, {2, 0xba4237c1}, {1, 0xa70349dc}, {1, 0x344722bb},
+    {3, 0xd6294733}, {2, 0xec9f5c94}, {2, 0xca2fbc28}, {1, 0x6ba4f406},
+    {2, 0x015d4532}, {1, 0x6e119b7c}, {2, 0x43e8f314}, {2, 0x27962f38},
+    {2, 0xb571b51b}, {2, 0xb36bee23}, {2, 0xd17924a8}, {2, 0x6bc212d9},
+    {1, 0x630d4948}, {2, 0x9a4c4ebb}, {2, 0x554be537}, {1, 0xd63ddfc7},
+    {2, 0xa10acc11}, {1, 0x759a8363}, {2, 0xfb73090d}, {1, 0xe82c6a34},
+    {1, 0xe33e92d7}, {3, 0x658ef5cb}, {2, 0xba32ff22}, {5, 0x0227a10c},
+    {1, 0xa9a70155}, {5, 0xd096d809}, {1, 0x37176174}, {1, 0x830b8d0f},
+    {1, 0xc6e3910e}, {2, 0x823f3ca8}, {1, 0x99850849}, {1, 0x7521fb81},
+    {1, 0xaacaabab}, {1, 0xd645a2eb}, {5, 0x7aea1781}, {5, 0x9d6e4b78},
+    {1, 0x4ce90fd8}, {1, 0xabdc832d}, {6, 0x4a34f32a}, {2, 0xf2524c1c},
+    {2, 0x1bbeb08a}, {1, 0xad47f480}, {1, 0x9f026aeb}, {1, 0x15a95049},
+    {2, 0xd1cb95b2}, {2, 0xf84bbda5}, {1, 0x0fa62cd1}, {1, 0xe05f9169},
+    {1, 0x78d194a9}, {5, 0x3e38147b}, {5, 0x737ba0d4}, {1, 0x63378e10},
+    {1, 0x6d5f91cf}, {2, 0x88612eb8}, {2, 0xe9639484}, {1, 0xb7fabc9d},
+    {2, 0x19b01592}, {1, 0x5a90dd31}, {2, 0x5bd7e028}, {2, 0x94d00323},
+    {1, 0xa9b9c01a}, {1, 0x3a40de61}, {1, 0x56e7eec7}, {5, 0x859f7ef6},
+    {1, 0xfd8e5630}, {1, 0x2b0c9f7f}, {1, 0xba700e26}, {1, 0x7170a408},
+    {1, 0x70de86a8}, {1, 0x74d64cd5}, {1, 0x49e738a1}, {2, 0x6910b602},
+    {0, 0x643c565f}, {1, 0x54264b3f}, {2, 0x97ea6396}, {2, 0x55174459},
+    {2, 0x03e8779a}, {1, 0x98f34d8f}, {1, 0xc07b2b07}, {1, 0xdfe29668},
+    {1, 0x3141c7c1}, {1, 0xb3b595f4}, {1, 0x735abf08}, {5, 0x623bfbce},
+    {2, 0xd351e722}, {1, 0xf4ca48c9}, {1, 0x5b19c670}, {1, 0xa164bf0e},
+    {2, 0xbbbeb305}, {2, 0xfe1c810a},
+};
+
+CBlockIndex CreateBlockIndex(int nHeight)
+{
+    CBlockIndex index;
+    index.nHeight = nHeight;
+    index.pprev = chainActive.Tip();
+    return index;
+}
+
+bool TestSequenceLocks(const CTransaction &tx, int flags)
+{
+    LOCK(mempool.cs);
+    return CheckSequenceLocks(tx, flags);
+}
+
+// Test suite for ancestor feerate transaction selection.
+// Implemented as an additional function, rather than a separate test case,
+// to allow reusing the blockchain created in CreateNewBlock_validity.
+void TestPackageSelection(const CChainParams& chainparams, CScript scriptPubKey, std::vector<CTransactionRef>& txFirst)
+{
+    // Test the ancestor feerate transaction selection.
+    TestMemPoolEntryHelper entry;
+
+    // Test that a medium fee transaction will be selected after a higher fee
+    // rate package with a low fee rate parent.
+    CMutableTransaction tx;
+    tx.vin.resize(1);
+    tx.vin[0].scriptSig = CScript() << OP_1;
+    tx.vin[0].prevout.hash = txFirst[0]->GetHash();
+    tx.vin[0].prevout.n = 0;
+    tx.vout.resize(1);
+    tx.vout[0].nValue = 5000000000LL - 1000;
+    // This tx has a low fee: 1000 satoshis
+    uint256 hashParentTx = tx.GetHash(); // save this txid for later use
+    mempool.addUnchecked(hashParentTx, entry.Fee(1000).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
+
+    // This tx has a medium fee: 10000 satoshis
+    tx.vin[0].prevout.hash = txFirst[1]->GetHash();
+    tx.vout[0].nValue = 5000000000LL - 10000;
+    uint256 hashMediumFeeTx = tx.GetHash();
+    mempool.addUnchecked(hashMediumFeeTx, entry.Fee(10000).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
+
+    // This tx has a high fee, but depends on the first transaction
+    tx.vin[0].prevout.hash = hashParentTx;
+    tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 50k satoshi fee
+    uint256 hashHighFeeTx = tx.GetHash();
+    mempool.addUnchecked(hashHighFeeTx, entry.Fee(50000).Time(GetTime()).SpendsCashbase(false).FromTx(tx));
+
+    std::unique_ptr<CBlockTemplate> pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
+    BOOST_CHECK(pblocktemplate->block.vtx[1]->GetHash() == hashParentTx);
+    BOOST_CHECK(pblocktemplate->block.vtx[2]->GetHash() == hashHighFeeTx);
+    BOOST_CHECK(pblocktemplate->block.vtx[3]->GetHash() == hashMediumFeeTx);
+
+    // Test that a package below the block min tx fee doesn't get included
+    tx.vin[0].prevout.hash = hashHighFeeTx;
+    tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 0 fee
+    uint256 hashFreeTx = tx.GetHash();
+    mempool.addUnchecked(hashFreeTx, entry.Fee(0).FromTx(tx));
+    size_t freeTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
+
+    // Calculate a fee on child transaction that will put the package just
+    // below the block min tx fee (assuming 1 child tx of the same size).
+    CAmount feeToUse = blockMinFeeRate.GetFee(2*freeTxSize) - 1;
+
+    tx.vin[0].prevout.hash = hashFreeTx;
+    tx.vout[0].nValue = 5000000000LL - 1000 - 50000 - feeToUse;
+    uint256 hashLowFeeTx = tx.GetHash();
+    mempool.addUnchecked(hashLowFeeTx, entry.Fee(feeToUse).FromTx(tx));
+    pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
+    // Verify that the free tx and the low fee tx didn't get selected
+    for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {
+        BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeTx);
+        BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashLowFeeTx);
+    }
+
+    // Test that packages above the min relay fee do get included, even if one
+    // of the transactions is below the min relay fee
+    // Remove the low fee transaction and replace with a higher fee transaction
+    mempool.removeRecursive(tx);
+    tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
+    hashLowFeeTx = tx.GetHash();
+    mempool.addUnchecked(hashLowFeeTx, entry.Fee(feeToUse+2).FromTx(tx));
+    pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
+    BOOST_CHECK(pblocktemplate->block.vtx[4]->GetHash() == hashFreeTx);
+    BOOST_CHECK(pblocktemplate->block.vtx[5]->GetHash() == hashLowFeeTx);
+
+    // Test that transaction selection properly updates ancestor fee
+    // calculations as ancestor transactions get included in a block.
+    // Add a 0-fee transaction that has 2 outputs.
+    tx.vin[0].prevout.hash = txFirst[2]->GetHash();
+    tx.vout.resize(2);
+    tx.vout[0].nValue = 5000000000LL - 100000000;
+    tx.vout[1].nValue = 100000000; // 1BTC output
+    uint256 hashFreeTx2 = tx.GetHash();
+    mempool.addUnchecked(hashFreeTx2, entry.Fee(0).SpendsCashbase(true).FromTx(tx));
+
+    // This tx can't be mined by itself
+    tx.vin[0].prevout.hash = hashFreeTx2;
+    tx.vout.resize(1);
+    feeToUse = blockMinFeeRate.GetFee(freeTxSize);
+    tx.vout[0].nValue = 5000000000LL - 100000000 - feeToUse;
+    uint256 hashLowFeeTx2 = tx.GetHash();
+    mempool.addUnchecked(hashLowFeeTx2, entry.Fee(feeToUse).SpendsCashbase(false).FromTx(tx));
+    pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
+
+    // Verify that this tx isn't selected.
+    for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {
+        BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeTx2);
+        BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashLowFeeTx2);
+    }
+
+    // This tx will be mineable, and should cause hashLowFeeTx2 to be selected
+    // as well.
+    tx.vin[0].prevout.n = 1;
+    tx.vout[0].nValue = 100000000 - 10000; // 10k satoshi fee
+    mempool.addUnchecked(tx.GetHash(), entry.Fee(10000).FromTx(tx));
+    pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
+    BOOST_CHECK(pblocktemplate->block.vtx[8]->GetHash() == hashLowFeeTx2);
+}
+
+// NOTE: These tests rely on CreateNewBlock doing its own self-validation!
+BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
+{
+    // Note that by default, these tests run with size accounting enabled.
+    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const CChainParams& chainparams = *chainParams;
+    CScript scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
+    std::unique_ptr<CBlockTemplate> pblocktemplate;
+    CMutableTransaction tx,tx2;
+    CScript script;
+    uint256 hash;
+    TestMemPoolEntryHelper entry;
+    entry.nFee = 11;
+    entry.nHeight = 11;
+
+    fCheckpointsEnabled = false;
+
+    // Simple block creation, nothing special yet:
+    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
+
+    // We can't make transactions until we have inputs
+    // Therefore, load 100 blocks :)
+    int baseheight = 0;
+    std::vector<CTransactionRef> txFirst;
+    for (unsigned int i = 0; i < sizeof(blockinfo)/sizeof(*blockinfo); ++i)
+    {
+        CBlock *pblock = &pblocktemplate->block; // pointer for convenience
+        {
+            LOCK(cs_main);
+            pblock->nVersion = 1;
+            pblock->nTime = chainActive.Tip()->GetMedianTimePast()+1;
+            CMutableTransaction txCoinbase(*pblock->vtx[0]);
+            txCoinbase.nVersion = 1;
+            txCoinbase.vin[0].scriptSig = CScript();
+            txCoinbase.vin[0].scriptSig.push_back(blockinfo[i].extranonce);
+            txCoinbase.vin[0].scriptSig.push_back(chainActive.Height());
+            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));
+            if (txFirst.size() == 0)
+                baseheight = chainActive.Height();
+            if (txFirst.size() < 4)
+                txFirst.push_back(pblock->vtx[0]);
+            pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
+            pblock->nNonce = blockinfo[i].nonce;
+        }
+        std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(*pblock);
+        BOOST_CHECK(ProcessNewBlock(chainparams, shared_pblock, true, nullptr));
+        pblock->hashPrevBlock = pblock->GetHash();
+    }
+
+    LOCK(cs_main);
+
+    // Just to make sure we can still make simple blocks
+    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
+
+    const CAmount BLOCKSUBSIDY = 50*CASH;
+    const CAmount LOWFEE = CENT;
+    const CAmount HIGHFEE = CASH;
+    const CAmount HIGHERFEE = 4*CASH;
+
+    // block sigops > limit: 1000 CHECKMULTISIG + 1
+    tx.vin.resize(1);
+    // NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
+    tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;
+    tx.vin[0].prevout.hash = txFirst[0]->GetHash();
+    tx.vin[0].prevout.n = 0;
+    tx.vout.resize(1);
+    tx.vout[0].nValue = BLOCKSUBSIDY;
+    for (unsigned int i = 0; i < 1001; ++i)
+    {
+        tx.vout[0].nValue -= LOWFEE;
+        hash = tx.GetHash();
+        bool spendsCoinbase = i == 0; // only first tx spends coinbase
+        // If we don't set the # of sig ops in the CTxMemPoolEntry, template creation fails
+        mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCashbase(spendsCoinbase).FromTx(tx));
+        tx.vin[0].prevout.hash = hash;
+    }
+
+    BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-blk-sigops"));
+    mempool.clear();
+
+    tx.vin[0].prevout.hash = txFirst[0]->GetHash();
+    tx.vout[0].nValue = BLOCKSUBSIDY;
+    for (unsigned int i = 0; i < 1001; ++i)
+    {
+        tx.vout[0].nValue -= LOWFEE;
+        hash = tx.GetHash();
+        bool spendsCashbase = i == 0; // only first tx spends coinbase
+        // If we do set the # of sig ops in the CTxMemPoolEntry, template creation passes
+        mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCashbase(spendsCoinbase).SigOpsCost(80).FromTx(tx));
+        tx.vin[0].prevout.hash = hash;
+    }
+    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
+    mempool.clear();
+
+    // block size > limit
+    tx.vin[0].scriptSig = CScript();
+    // 18 * (520char + DROP) + OP_1 = 9433 bytes
+    std::vector<unsigned char> vchData(520);
+    for (unsigned int i = 0; i < 18; ++i)
+        tx.vin[0].scriptSig << vchData << OP_DROP;
+    tx.vin[0].scriptSig << OP_1;
+    tx.vin[0].prevout.hash = txFirst[0]->GetHash();
+    tx.vout[0].nValue = BLOCKSUBSIDY;
+    for (unsigned int i = 0; i < 128; ++i)
+    {
+        tx.vout[0].nValue -= LOWFEE;
+        hash = tx.GetHash();
+        bool spendsCashbase = i == 0; // only first tx spends coinbase
+        mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCashbase(spendsCoinbase).FromTx(tx));
+        tx.vin[0].prevout.hash = hash;
+    }
+    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
+    mempool.clear();
+
+    // orphan in mempool, template creation fails
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).FromTx(tx));
+    BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
+    mempool.clear();
+
+    // child with higher feerate than parent
+    tx.vin[0].scriptSig = CScript() << OP_1;
+    tx.vin[0].prevout.hash = txFirst[1]->GetHash();
+    tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Fee(HIGHFEE).Time(GetTime()).SpendsCashbase(true).FromTx(tx));
+    tx.vin[0].prevout.hash = hash;
+    tx.vin.resize(2);
+    tx.vin[1].scriptSig = CScript() << OP_1;
+    tx.vin[1].prevout.hash = txFirst[0]->GetHash();
+    tx.vin[1].prevout.n = 0;
+    tx.vout[0].nValue = tx.vout[0].nValue+BLOCKSUBSIDY-HIGHERFEE; //First txn output + fresh coinbase - new txn fee
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Fee(HIGHERFEE).Time(GetTime()).SpendsCashbase(true).FromTx(tx));
+    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
+    mempool.clear();
+
+    // coinbase in mempool, template creation fails
+    tx.vin.resize(1);
+    tx.vin[0].prevout.SetNull();
+    tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
+    tx.vout[0].nValue = 0;
+    hash = tx.GetHash();
+    // give it a fee so it'll get mined
+    mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCashbase(false).FromTx(tx));
+    // Should throw bad-cb-multiple
+    BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-cb-multiple"));
+    mempool.clear();
+
+    // double spend txn pair in mempool, template creation fails
+    tx.vin[0].prevout.hash = txFirst[0]->GetHash();
+    tx.vin[0].scriptSig = CScript() << OP_1;
+    tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
+    tx.vout[0].scriptPubKey = CScript() << OP_1;
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Fee(HIGHFEE).Time(GetTime()).SpendsCashbase(true).FromTx(tx));
+    tx.vout[0].scriptPubKey = CScript() << OP_2;
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Fee(HIGHFEE).Time(GetTime()).SpendsCashbase(true).FromTx(tx));
+    BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
+    mempool.clear();
+
+    // 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();
+        CBlockIndex* next = new CBlockIndex();
+        next->phashBlock = new uint256(InsecureRand256());
+        pcashTip->SetBestBlock(next->GetBlockHash());
+        next->pprev = prev;
+        next->nHeight = prev->nHeight + 1;
+        next->BuildSkip();
+        chainActive.SetTip(next);
+    }
+    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
+    // Extend to a 210000-long block chain.
+    while (chainActive.Tip()->nHeight < 210000) {
+        CBlockIndex* prev = chainActive.Tip();
+        CBlockIndex* next = new CBlockIndex();
+        next->phashBlock = new uint256(InsecureRand256());
+        pcashTip->SetBestBlock(next->GetBlockHash());
+        next->pprev = prev;
+        next->nHeight = prev->nHeight + 1;
+        next->BuildSkip();
+        chainActive.SetTip(next);
+    }
+    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
+
+    // invalid p2sh txn in mempool, template creation fails
+    tx.vin[0].prevout.hash = txFirst[0]->GetHash();
+    tx.vin[0].prevout.n = 0;
+    tx.vin[0].scriptSig = CScript() << OP_1;
+    tx.vout[0].nValue = BLOCKSUBSIDY-LOWFEE;
+    script = CScript() << OP_0;
+    tx.vout[0].scriptPubKey = GetScriptForDestination(CScriptID(script));
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCashbase(true).FromTx(tx));
+    tx.vin[0].prevout.hash = hash;
+    tx.vin[0].scriptSig = CScript() << std::vector<unsigned char>(script.begin(), script.end());
+    tx.vout[0].nValue -= LOWFEE;
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCashbase(false).FromTx(tx));
+    // Should throw block-validation-failed
+    BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("block-validation-failed"));
+    mempool.clear();
+
+    // Delete the dummy blocks again.
+    while (chainActive.Tip()->nHeight > nHeight) {
+        CBlockIndex* del = chainActive.Tip();
+        chainActive.SetTip(del->pprev);
+        pcashTip->SetBestBlock(del->pprev->GetBlockHash());
+        delete del->phashBlock;
+        delete del;
+    }
+
+    // non-final txs in mempool
+    SetMockTime(chainActive.Tip()->GetMedianTimePast()+1);
+    int flags = LOCKTIME_VERIFY_SEQUENCE|LOCKTIME_MEDIAN_TIME_PAST;
+    // height map
+    std::vector<int> prevheights;
+
+    // relative height locked
+    tx.nVersion = 2;
+    tx.vin.resize(1);
+    prevheights.resize(1);
+    tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction
+    tx.vin[0].prevout.n = 0;
+    tx.vin[0].scriptSig = CScript() << OP_1;
+    tx.vin[0].nSequence = chainActive.Tip()->nHeight + 1; // txFirst[0] is the 2nd block
+    prevheights[0] = baseheight + 1;
+    tx.vout.resize(1);
+    tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
+    tx.vout[0].scriptPubKey = CScript() << OP_1;
+    tx.nLockTime = 0;
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Fee(HIGHFEE).Time(GetTime()).SpendsCashbase(true).FromTx(tx));
+    BOOST_CHECK(CheckFinalTx(tx, flags)); // Locktime passes
+    BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
+    BOOST_CHECK(SequenceLocks(tx, flags, &prevheights, CreateBlockIndex(chainActive.Tip()->nHeight + 2))); // Sequence locks pass on 2nd block
+
+    // relative time locked
+    tx.vin[0].prevout.hash = txFirst[1]->GetHash();
+    tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((chainActive.Tip()->GetMedianTimePast()+1-chainActive[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block
+    prevheights[0] = baseheight + 2;
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Time(GetTime()).FromTx(tx));
+    BOOST_CHECK(CheckFinalTx(tx, flags)); // Locktime passes
+    BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
+
+    for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
+        chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast
+    BOOST_CHECK(SequenceLocks(tx, flags, &prevheights, CreateBlockIndex(chainActive.Tip()->nHeight + 1))); // Sequence locks pass 512 seconds later
+    for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
+        chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime -= 512; //undo tricked MTP
+
+    // absolute height locked
+    tx.vin[0].prevout.hash = txFirst[2]->GetHash();
+    tx.vin[0].nSequence = CTxIn::SEQUENCE_FINAL - 1;
+    prevheights[0] = baseheight + 3;
+    tx.nLockTime = chainActive.Tip()->nHeight + 1;
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Time(GetTime()).FromTx(tx));
+    BOOST_CHECK(!CheckFinalTx(tx, flags)); // Locktime fails
+    BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
+    BOOST_CHECK(IsFinalTx(tx, chainActive.Tip()->nHeight + 2, chainActive.Tip()->GetMedianTimePast())); // Locktime passes on 2nd block
+
+    // absolute time locked
+    tx.vin[0].prevout.hash = txFirst[3]->GetHash();
+    tx.nLockTime = chainActive.Tip()->GetMedianTimePast();
+    prevheights.resize(1);
+    prevheights[0] = baseheight + 4;
+    hash = tx.GetHash();
+    mempool.addUnchecked(hash, entry.Time(GetTime()).FromTx(tx));
+    BOOST_CHECK(!CheckFinalTx(tx, flags)); // Locktime fails
+    BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
+    BOOST_CHECK(IsFinalTx(tx, chainActive.Tip()->nHeight + 2, chainActive.Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later
+
+    // mempool-dependent transactions (not added)
+    tx.vin[0].prevout.hash = hash;
+    prevheights[0] = chainActive.Tip()->nHeight + 1;
+    tx.nLockTime = 0;
+    tx.vin[0].nSequence = 0;
+    BOOST_CHECK(CheckFinalTx(tx, flags)); // Locktime passes
+    BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
+    tx.vin[0].nSequence = 1;
+    BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
+    tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
+    BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
+    tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
+    BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
+
+    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
+
+    // None of the of the absolute height/time locked tx should have made
+    // it into the template because we still check IsFinalTx in CreateNewBlock,
+    // but relative locked txs will if inconsistently added to mempool.
+    // For now these will still generate a valid template until BIP68 soft fork
+    BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 3);
+    // However if we advance height by 1 and time by 512, all of them should be mined
+    for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
+        chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast
+    chainActive.Tip()->nHeight++;
+    SetMockTime(chainActive.Tip()->GetMedianTimePast() + 1);
+
+    BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
+    BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5);
+
+    chainActive.Tip()->nHeight--;
+    SetMockTime(0);
+    mempool.clear();
+
+    TestPackageSelection(chainparams, scriptPubKey, txFirst);
+
+    fCheckpointsEnabled = true;
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/multisig_tests.cpp b/multisig_tests.cpp
new file mode 100644
index 0000000..3c9b583
--- /dev/null
+++ b/multisig_tests.cpp
@@ -0,0 +1,217 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <key.h>
+#include <keystore.h>
+#include <policy/policy.h>
+#include <script/script.h>
+#include <script/script_error.h>
+#include <script/interpreter.h>
+#include <script/sign.h>
+#include <script/ismine.h>
+#include <uint256.h>
+#include <test/test_salemcash.h>
+
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(multisig_tests, BasicTestingSetup)
+
+CScript
+sign_multisig(CScript scriptPubKey, std::vector<CKey> keys, CTransaction transaction, int whichIn)
+{
+    uint256 hash = SignatureHash(scriptPubKey, transaction, whichIn, SIGHASH_ALL, 0, SIGVERSION_BASE);
+
+    CScript result;
+    result << OP_0; // CHECKMULTISIG bug workaround
+    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;
+}
+
+BOOST_AUTO_TEST_CASE(multisig_verify)
+{
+    unsigned int flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
+
+    ScriptError err;
+    CKey key[4];
+    CAmount amount = 0;
+    for (int i = 0; i < 4; i++)
+        key[i].MakeNewKey(true);
+
+    CScript a_and_b;
+    a_and_b << OP_2 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
+
+    CScript a_or_b;
+    a_or_b << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
+
+    CScript escrow;
+    escrow << OP_2 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << ToByteVector(key[2].GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
+
+    CMutableTransaction txFrom;  // Funding transaction
+    txFrom.vout.resize(3);
+    txFrom.vout[0].scriptPubKey = a_and_b;
+    txFrom.vout[1].scriptPubKey = a_or_b;
+    txFrom.vout[2].scriptPubKey = escrow;
+
+    CMutableTransaction txTo[3]; // Spending transaction
+    for (int i = 0; i < 3; i++)
+    {
+        txTo[i].vin.resize(1);
+        txTo[i].vout.resize(1);
+        txTo[i].vin[0].prevout.n = i;
+        txTo[i].vin[0].prevout.hash = txFrom.GetHash();
+        txTo[i].vout[0].nValue = 1;
+    }
+
+    std::vector<CKey> keys;
+    CScript s;
+
+    // Test a AND b:
+    keys.assign(1,key[0]);
+    keys.push_back(key[1]);
+    s = sign_multisig(a_and_b, keys, txTo[0], 0);
+    BOOST_CHECK(VerifyScript(s, a_and_b, nullptr, flags, MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+
+    for (int i = 0; i < 4; i++)
+    {
+        keys.assign(1,key[i]);
+        s = sign_multisig(a_and_b, keys, txTo[0], 0);
+        BOOST_CHECK_MESSAGE(!VerifyScript(s, a_and_b, nullptr, flags, MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err), strprintf("a&b 1: %d", i));
+        BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, ScriptErrorString(err));
+
+        keys.assign(1,key[1]);
+        keys.push_back(key[i]);
+        s = sign_multisig(a_and_b, keys, txTo[0], 0);
+        BOOST_CHECK_MESSAGE(!VerifyScript(s, a_and_b, nullptr, flags, MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err), strprintf("a&b 2: %d", i));
+        BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
+    }
+
+    // Test a OR b:
+    for (int i = 0; i < 4; i++)
+    {
+        keys.assign(1,key[i]);
+        s = sign_multisig(a_or_b, keys, txTo[1], 0);
+        if (i == 0 || i == 1)
+        {
+            BOOST_CHECK_MESSAGE(VerifyScript(s, a_or_b, nullptr, flags, MutableTransactionSignatureChecker(&txTo[1], 0, amount), &err), strprintf("a|b: %d", i));
+            BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+        }
+        else
+        {
+            BOOST_CHECK_MESSAGE(!VerifyScript(s, a_or_b, nullptr, flags, MutableTransactionSignatureChecker(&txTo[1], 0, amount), &err), strprintf("a|b: %d", i));
+            BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
+        }
+    }
+    s.clear();
+    s << OP_0 << OP_1;
+    BOOST_CHECK(!VerifyScript(s, a_or_b, nullptr, flags, MutableTransactionSignatureChecker(&txTo[1], 0, amount), &err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_SIG_DER, ScriptErrorString(err));
+
+
+    for (int i = 0; i < 4; i++)
+        for (int j = 0; j < 4; j++)
+        {
+            keys.assign(1,key[i]);
+            keys.push_back(key[j]);
+            s = sign_multisig(escrow, keys, txTo[2], 0);
+            if (i < j && i < 3 && j < 3)
+            {
+                BOOST_CHECK_MESSAGE(VerifyScript(s, escrow, nullptr, flags, MutableTransactionSignatureChecker(&txTo[2], 0, amount), &err), strprintf("escrow 1: %d %d", i, j));
+                BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+            }
+            else
+            {
+                BOOST_CHECK_MESSAGE(!VerifyScript(s, escrow, nullptr, flags, MutableTransactionSignatureChecker(&txTo[2], 0, amount), &err), strprintf("escrow 2: %d %d", i, j));
+                BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err));
+            }
+        }
+}
+
+BOOST_AUTO_TEST_CASE(multisig_IsStandard)
+{
+    CKey key[4];
+    for (int i = 0; i < 4; i++)
+        key[i].MakeNewKey(true);
+
+    txnouttype whichType;
+
+    CScript a_and_b;
+    a_and_b << OP_2 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
+    BOOST_CHECK(::IsStandard(a_and_b, whichType));
+
+    CScript a_or_b;
+    a_or_b  << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
+    BOOST_CHECK(::IsStandard(a_or_b, whichType));
+
+    CScript escrow;
+    escrow << OP_2 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << ToByteVector(key[2].GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
+    BOOST_CHECK(::IsStandard(escrow, whichType));
+
+    CScript one_of_four;
+    one_of_four << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << ToByteVector(key[2].GetPubKey()) << ToByteVector(key[3].GetPubKey()) << OP_4 << OP_CHECKMULTISIG;
+    BOOST_CHECK(!::IsStandard(one_of_four, whichType));
+
+    CScript malformed[6];
+    malformed[0] << OP_3 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
+    malformed[1] << OP_2 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
+    malformed[2] << OP_0 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
+    malformed[3] << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_0 << OP_CHECKMULTISIG;
+    malformed[4] << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_CHECKMULTISIG;
+    malformed[5] << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey());
+
+    for (int i = 0; i < 6; i++)
+        BOOST_CHECK(!::IsStandard(malformed[i], whichType));
+}
+
+BOOST_AUTO_TEST_CASE(multisig_Sign)
+{
+    // Test SignSignature() (and therefore the version of Solver() that signs transactions)
+    CBasicKeyStore keystore;
+    CKey key[4];
+    for (int i = 0; i < 4; i++)
+    {
+        key[i].MakeNewKey(true);
+        keystore.AddKey(key[i]);
+    }
+
+    CScript a_and_b;
+    a_and_b << OP_2 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
+
+    CScript a_or_b;
+    a_or_b  << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
+
+    CScript escrow;
+    escrow << OP_2 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << ToByteVector(key[2].GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
+
+    CMutableTransaction txFrom;  // Funding transaction
+    txFrom.vout.resize(3);
+    txFrom.vout[0].scriptPubKey = a_and_b;
+    txFrom.vout[1].scriptPubKey = a_or_b;
+    txFrom.vout[2].scriptPubKey = escrow;
+
+    CMutableTransaction txTo[3]; // Spending transaction
+    for (int i = 0; i < 3; i++)
+    {
+        txTo[i].vin.resize(1);
+        txTo[i].vout.resize(1);
+        txTo[i].vin[0].prevout.n = i;
+        txTo[i].vin[0].prevout.hash = txFrom.GetHash();
+        txTo[i].vout[0].nValue = 1;
+    }
+
+    for (int i = 0; i < 3; i++)
+    {
+        BOOST_CHECK_MESSAGE(SignSignature(keystore, txFrom, txTo[i], 0, SIGHASH_ALL), strprintf("SignSignature %d", i));
+    }
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/net_tests.cpp b/net_tests.cpp
new file mode 100644
index 0000000..ca1506e
--- /dev/null
+++ b/net_tests.cpp
@@ -0,0 +1,188 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#include <addrman.h>
+#include <test/test_salemcash.h>
+#include <string>
+#include <boost/test/unit_test.hpp>
+#include <hash.h>
+#include <serialize.h>
+#include <streams.h>
+#include <net.h>
+#include <netbase.h>
+#include <chainparams.h>
+#include <util.h>
+
+class CAddrManSerializationMock : public CAddrMan
+{
+public:
+    virtual void Serialize(CDataStream& s) const = 0;
+
+    //! Ensure that bucket placement is always the same for testing purposes.
+    void MakeDeterministic()
+    {
+        nKey.SetNull();
+        insecure_rand = FastRandomContext(true);
+    }
+};
+
+class CAddrManUncorrupted : public CAddrManSerializationMock
+{
+public:
+    void Serialize(CDataStream& s) const override
+    {
+        CAddrMan::Serialize(s);
+    }
+};
+
+class CAddrManCorrupted : public CAddrManSerializationMock
+{
+public:
+    void Serialize(CDataStream& s) const override
+    {
+        // Produces corrupt output that claims addrman has 20 addrs when it only has one addr.
+        unsigned char nVersion = 1;
+        s << nVersion;
+        s << ((unsigned char)32);
+        s << nKey;
+        s << 10; // nNew
+        s << 10; // nTried
+
+        int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT ^ (1 << 30);
+        s << nUBuckets;
+
+        CService serv;
+        Lookup("252.1.1.1", serv, 7777, false);
+        CAddress addr = CAddress(serv, NODE_NONE);
+        CNetAddr resolved;
+        LookupHost("252.2.2.2", resolved, false);
+        CAddrInfo info = CAddrInfo(addr, resolved);
+        s << info;
+    }
+};
+
+CDataStream AddrmanToStream(CAddrManSerializationMock& _addrman)
+{
+    CDataStream ssPeersIn(SER_DISK, CLIENT_VERSION);
+    ssPeersIn << FLATDATA(Params().MessageStart());
+    ssPeersIn << _addrman;
+    std::string str = ssPeersIn.str();
+    std::vector<unsigned char> vchData(str.begin(), str.end());
+    return CDataStream(vchData, SER_DISK, CLIENT_VERSION);
+}
+
+BOOST_FIXTURE_TEST_SUITE(net_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(cnode_listen_port)
+{
+    // test default
+    unsigned short port = GetListenPort();
+    BOOST_CHECK(port == Params().GetDefaultPort());
+    // test set port
+    unsigned short altPort = 12345;
+    gArgs.SoftSetArg("-port", std::to_string(altPort));
+    port = GetListenPort();
+    BOOST_CHECK(port == altPort);
+}
+
+BOOST_AUTO_TEST_CASE(caddrdb_read)
+{
+    CAddrManUncorrupted addrmanUncorrupted;
+    addrmanUncorrupted.MakeDeterministic();
+
+    CService addr1, addr2, addr3;
+    Lookup("250.7.1.1", addr1, 8333, false);
+    Lookup("250.7.2.2", addr2, 9999, false);
+    Lookup("250.7.3.3", addr3, 9999, false);
+
+    // Add three addresses to new table.
+    CService source;
+    Lookup("252.5.1.1", source, 8333, false);
+    addrmanUncorrupted.Add(CAddress(addr1, NODE_NONE), source);
+    addrmanUncorrupted.Add(CAddress(addr2, NODE_NONE), source);
+    addrmanUncorrupted.Add(CAddress(addr3, NODE_NONE), source);
+
+    // Test that the de-serialization does not throw an exception.
+    CDataStream ssPeers1 = AddrmanToStream(addrmanUncorrupted);
+    bool exceptionThrown = false;
+    CAddrMan addrman1;
+
+    BOOST_CHECK(addrman1.size() == 0);
+    try {
+        unsigned char pchMsgTmp[4];
+        ssPeers1 >> FLATDATA(pchMsgTmp);
+        ssPeers1 >> addrman1;
+    } catch (const std::exception& e) {
+        exceptionThrown = true;
+    }
+
+    BOOST_CHECK(addrman1.size() == 3);
+    BOOST_CHECK(exceptionThrown == false);
+
+    // Test that CAddrDB::Read creates an addrman with the correct number of addrs.
+    CDataStream ssPeers2 = AddrmanToStream(addrmanUncorrupted);
+
+    CAddrMan addrman2;
+    CAddrDB adb;
+    BOOST_CHECK(addrman2.size() == 0);
+    adb.Read(addrman2, ssPeers2);
+    BOOST_CHECK(addrman2.size() == 3);
+}
+
+
+BOOST_AUTO_TEST_CASE(caddrdb_read_corrupted)
+{
+    CAddrManCorrupted addrmanCorrupted;
+    addrmanCorrupted.MakeDeterministic();
+
+    // Test that the de-serialization of corrupted addrman throws an exception.
+    CDataStream ssPeers1 = AddrmanToStream(addrmanCorrupted);
+    bool exceptionThrown = false;
+    CAddrMan addrman1;
+    BOOST_CHECK(addrman1.size() == 0);
+    try {
+        unsigned char pchMsgTmp[4];
+        ssPeers1 >> FLATDATA(pchMsgTmp);
+        ssPeers1 >> addrman1;
+    } catch (const std::exception& e) {
+        exceptionThrown = true;
+    }
+    // Even through de-serialization failed addrman is not left in a clean state.
+    BOOST_CHECK(addrman1.size() == 1);
+    BOOST_CHECK(exceptionThrown);
+
+    // Test that CAddrDB::Read leaves addrman in a clean state if de-serialization fails.
+    CDataStream ssPeers2 = AddrmanToStream(addrmanCorrupted);
+
+    CAddrMan addrman2;
+    CAddrDB adb;
+    BOOST_CHECK(addrman2.size() == 0);
+    adb.Read(addrman2, ssPeers2);
+    BOOST_CHECK(addrman2.size() == 0);
+}
+
+BOOST_AUTO_TEST_CASE(cnode_simple_test)
+{
+    SOCKET hSocket = INVALID_SOCKET;
+    NodeId id = 0;
+    int height = 0;
+
+    in_addr ipv4Addr;
+    ipv4Addr.s_addr = 0xa0b0c001;
+    
+    CAddress addr = CAddress(CService(ipv4Addr, 7777), NODE_NETWORK);
+    std::string pszDest;
+    bool fInboundIn = false;
+
+    // Test that fFeeler is false by default.
+    std::unique_ptr<CNode> pnode1(new CNode(id++, NODE_NETWORK, height, hSocket, addr, 0, 0, CAddress(), pszDest, fInboundIn));
+    BOOST_CHECK(pnode1->fInbound == false);
+    BOOST_CHECK(pnode1->fFeeler == false);
+
+    fInboundIn = true;
+    std::unique_ptr<CNode> pnode2(new CNode(id++, NODE_NETWORK, height, hSocket, addr, 1, 1, CAddress(), pszDest, fInboundIn));
+    BOOST_CHECK(pnode2->fInbound == true);
+    BOOST_CHECK(pnode2->fFeeler == false);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/netbase_tests.cpp b/netbase_tests.cpp
new file mode 100644
index 0000000..5fba94a
--- /dev/null
+++ b/netbase_tests.cpp
@@ -0,0 +1,305 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <netbase.h>
+#include <test/test_salemcash.h>
+#include <utilstrencodings.h>
+
+#include <string>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(netbase_tests, BasicTestingSetup)
+
+static CNetAddr ResolveIP(const char* ip)
+{
+    CNetAddr addr;
+    LookupHost(ip, addr, false);
+    return addr;
+}
+
+static CSubNet ResolveSubNet(const char* subnet)
+{
+    CSubNet ret;
+    LookupSubNet(subnet, ret);
+    return ret;
+}
+
+static CNetAddr CreateInternal(const char* host)
+{
+    CNetAddr addr;
+    addr.SetInternal(host);
+    return addr;
+}
+
+BOOST_AUTO_TEST_CASE(netbase_networks)
+{
+    BOOST_CHECK(ResolveIP("127.0.0.1").GetNetwork()                              == NET_UNROUTABLE);
+    BOOST_CHECK(ResolveIP("::1").GetNetwork()                                    == NET_UNROUTABLE);
+    BOOST_CHECK(ResolveIP("8.8.8.8").GetNetwork()                                == NET_IPV4);
+    BOOST_CHECK(ResolveIP("2001::8888").GetNetwork()                             == NET_IPV6);
+    BOOST_CHECK(ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").GetNetwork() == NET_TOR);
+    BOOST_CHECK(CreateInternal("foo.com").GetNetwork()                           == NET_INTERNAL);
+
+}
+
+BOOST_AUTO_TEST_CASE(netbase_properties)
+{
+
+    BOOST_CHECK(ResolveIP("127.0.0.1").IsIPv4());
+    BOOST_CHECK(ResolveIP("::FFFF:192.168.1.1").IsIPv4());
+    BOOST_CHECK(ResolveIP("::1").IsIPv6());
+    BOOST_CHECK(ResolveIP("10.0.0.1").IsRFC1918());
+    BOOST_CHECK(ResolveIP("192.168.1.1").IsRFC1918());
+    BOOST_CHECK(ResolveIP("172.31.255.255").IsRFC1918());
+    BOOST_CHECK(ResolveIP("2001:0DB8::").IsRFC3849());
+    BOOST_CHECK(ResolveIP("169.254.1.1").IsRFC3927());
+    BOOST_CHECK(ResolveIP("2002::1").IsRFC3964());
+    BOOST_CHECK(ResolveIP("FC00::").IsRFC4193());
+    BOOST_CHECK(ResolveIP("2001::2").IsRFC4380());
+    BOOST_CHECK(ResolveIP("2001:10::").IsRFC4843());
+    BOOST_CHECK(ResolveIP("FE80::").IsRFC4862());
+    BOOST_CHECK(ResolveIP("64:FF9B::").IsRFC6052());
+    BOOST_CHECK(ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").IsTor());
+    BOOST_CHECK(ResolveIP("127.0.0.1").IsLocal());
+    BOOST_CHECK(ResolveIP("::1").IsLocal());
+    BOOST_CHECK(ResolveIP("8.8.8.8").IsRoutable());
+    BOOST_CHECK(ResolveIP("2001::1").IsRoutable());
+    BOOST_CHECK(ResolveIP("127.0.0.1").IsValid());
+    BOOST_CHECK(CreateInternal("FD6B:88C0:8724:edb1:8e4:3588:e546:35ca").IsInternal());
+    BOOST_CHECK(CreateInternal("bar.com").IsInternal());
+
+}
+
+bool static TestSplitHost(std::string test, std::string host, int port)
+{
+    std::string hostOut;
+    int portOut = -1;
+    SplitHostPort(test, portOut, hostOut);
+    return hostOut == host && port == portOut;
+}
+
+BOOST_AUTO_TEST_CASE(netbase_splithost)
+{
+    BOOST_CHECK(TestSplitHost("www.salemcash.org", "www.salemcash.org", -1));
+    BOOST_CHECK(TestSplitHost("[www.salemcash.org]", "www.salemcash.org", -1));
+    BOOST_CHECK(TestSplitHost("www.salemcash.org:80", "www.salemcashorg", 80));
+    BOOST_CHECK(TestSplitHost("[www.salemcash.org]:80", "www.salemcash.org", 80));
+    BOOST_CHECK(TestSplitHost("127.0.0.1", "127.0.0.1", -1));
+    BOOST_CHECK(TestSplitHost("127.0.0.1:8333", "127.0.0.1", 8333));
+    BOOST_CHECK(TestSplitHost("[127.0.0.1]", "127.0.0.1", -1));
+    BOOST_CHECK(TestSplitHost("[127.0.0.1]:8333", "127.0.0.1", 8333));
+    BOOST_CHECK(TestSplitHost("::ffff:127.0.0.1", "::ffff:127.0.0.1", -1));
+    BOOST_CHECK(TestSplitHost("[::ffff:127.0.0.1]:8333", "::ffff:127.0.0.1", 8333));
+    BOOST_CHECK(TestSplitHost("[::]:8333", "::", 8333));
+    BOOST_CHECK(TestSplitHost("::8333", "::8333", -1));
+    BOOST_CHECK(TestSplitHost(":8333", "", 8333));
+    BOOST_CHECK(TestSplitHost("[]:8333", "", 8333));
+    BOOST_CHECK(TestSplitHost("", "", -1));
+}
+
+bool static TestParse(std::string src, std::string canon)
+{
+    CService addr(LookupNumeric(src.c_str(), 65535));
+    return canon == addr.ToString();
+}
+
+BOOST_AUTO_TEST_CASE(netbase_lookupnumeric)
+{
+    BOOST_CHECK(TestParse("127.0.0.1", "127.0.0.1:65535"));
+    BOOST_CHECK(TestParse("127.0.0.1:8333", "127.0.0.1:8333"));
+    BOOST_CHECK(TestParse("::ffff:127.0.0.1", "127.0.0.1:65535"));
+    BOOST_CHECK(TestParse("::", "[::]:65535"));
+    BOOST_CHECK(TestParse("[::]:8333", "[::]:8333"));
+    BOOST_CHECK(TestParse("[127.0.0.1]", "127.0.0.1:65535"));
+    BOOST_CHECK(TestParse(":::", "[::]:0"));
+
+    // verify that an internal address fails to resolve
+    BOOST_CHECK(TestParse("[fd6b:88c0:8724:1:2:3:4:5]", "[::]:0"));
+    // and that a one-off resolves correctly
+    BOOST_CHECK(TestParse("[fd6c:88c0:8724:1:2:3:4:5]", "[fd6c:88c0:8724:1:2:3:4:5]:65535"));
+}
+
+BOOST_AUTO_TEST_CASE(onioncat_test)
+{
+
+    // values from https://web.archive.org/web/20121122003543/http://www.cypherpunk.at/onioncat/wiki/OnionCat
+    CNetAddr addr1(ResolveIP("5wyqrzbvrdsumnok.onion"));
+    CNetAddr addr2(ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca"));
+    BOOST_CHECK(addr1 == addr2);
+    BOOST_CHECK(addr1.IsTor());
+    BOOST_CHECK(addr1.ToStringIP() == "5wyqrzbvrdsumnok.onion");
+    BOOST_CHECK(addr1.IsRoutable());
+
+}
+
+BOOST_AUTO_TEST_CASE(subnet_test)
+{
+
+    BOOST_CHECK(ResolveSubNet("1.2.3.0/24") == ResolveSubNet("1.2.3.0/255.255.255.0"));
+    BOOST_CHECK(ResolveSubNet("1.2.3.0/24") != ResolveSubNet("1.2.4.0/255.255.255.0"));
+    BOOST_CHECK(ResolveSubNet("1.2.3.0/24").Match(ResolveIP("1.2.3.4")));
+    BOOST_CHECK(!ResolveSubNet("1.2.2.0/24").Match(ResolveIP("1.2.3.4")));
+    BOOST_CHECK(ResolveSubNet("1.2.3.4").Match(ResolveIP("1.2.3.4")));
+    BOOST_CHECK(ResolveSubNet("1.2.3.4/32").Match(ResolveIP("1.2.3.4")));
+    BOOST_CHECK(!ResolveSubNet("1.2.3.4").Match(ResolveIP("5.6.7.8")));
+    BOOST_CHECK(!ResolveSubNet("1.2.3.4/32").Match(ResolveIP("5.6.7.8")));
+    BOOST_CHECK(ResolveSubNet("::ffff:127.0.0.1").Match(ResolveIP("127.0.0.1")));
+    BOOST_CHECK(ResolveSubNet("1:2:3:4:5:6:7:8").Match(ResolveIP("1:2:3:4:5:6:7:8")));
+    BOOST_CHECK(!ResolveSubNet("1:2:3:4:5:6:7:8").Match(ResolveIP("1:2:3:4:5:6:7:9")));
+    BOOST_CHECK(ResolveSubNet("1:2:3:4:5:6:7:0/112").Match(ResolveIP("1:2:3:4:5:6:7:1234")));
+    BOOST_CHECK(ResolveSubNet("192.168.0.1/24").Match(ResolveIP("192.168.0.2")));
+    BOOST_CHECK(ResolveSubNet("192.168.0.20/29").Match(ResolveIP("192.168.0.18")));
+    BOOST_CHECK(ResolveSubNet("1.2.2.1/24").Match(ResolveIP("1.2.2.4")));
+    BOOST_CHECK(ResolveSubNet("1.2.2.110/31").Match(ResolveIP("1.2.2.111")));
+    BOOST_CHECK(ResolveSubNet("1.2.2.20/26").Match(ResolveIP("1.2.2.63")));
+    // All-Matching IPv6 Matches arbitrary IPv4 and IPv6
+    BOOST_CHECK(ResolveSubNet("::/0").Match(ResolveIP("1:2:3:4:5:6:7:1234")));
+    BOOST_CHECK(ResolveSubNet("::/0").Match(ResolveIP("1.2.3.4")));
+    // All-Matching IPv4 does not Match IPv6
+    BOOST_CHECK(!ResolveSubNet("0.0.0.0/0").Match(ResolveIP("1:2:3:4:5:6:7:1234")));
+    // Invalid subnets Match nothing (not even invalid addresses)
+    BOOST_CHECK(!CSubNet().Match(ResolveIP("1.2.3.4")));
+    BOOST_CHECK(!ResolveSubNet("").Match(ResolveIP("4.5.6.7")));
+    BOOST_CHECK(!ResolveSubNet("bloop").Match(ResolveIP("0.0.0.0")));
+    BOOST_CHECK(!ResolveSubNet("bloop").Match(ResolveIP("hab")));
+    // Check valid/invalid
+    BOOST_CHECK(ResolveSubNet("1.2.3.0/0").IsValid());
+    BOOST_CHECK(!ResolveSubNet("1.2.3.0/-1").IsValid());
+    BOOST_CHECK(ResolveSubNet("1.2.3.0/32").IsValid());
+    BOOST_CHECK(!ResolveSubNet("1.2.3.0/33").IsValid());
+    BOOST_CHECK(ResolveSubNet("1:2:3:4:5:6:7:8/0").IsValid());
+    BOOST_CHECK(ResolveSubNet("1:2:3:4:5:6:7:8/33").IsValid());
+    BOOST_CHECK(!ResolveSubNet("1:2:3:4:5:6:7:8/-1").IsValid());
+    BOOST_CHECK(ResolveSubNet("1:2:3:4:5:6:7:8/128").IsValid());
+    BOOST_CHECK(!ResolveSubNet("1:2:3:4:5:6:7:8/129").IsValid());
+    BOOST_CHECK(!ResolveSubNet("fuzzy").IsValid());
+
+    //CNetAddr constructor test
+    BOOST_CHECK(CSubNet(ResolveIP("127.0.0.1")).IsValid());
+    BOOST_CHECK(CSubNet(ResolveIP("127.0.0.1")).Match(ResolveIP("127.0.0.1")));
+    BOOST_CHECK(!CSubNet(ResolveIP("127.0.0.1")).Match(ResolveIP("127.0.0.2")));
+    BOOST_CHECK(CSubNet(ResolveIP("127.0.0.1")).ToString() == "127.0.0.1/32");
+
+    CSubNet subnet = CSubNet(ResolveIP("1.2.3.4"), 32);
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/32");
+    subnet = CSubNet(ResolveIP("1.2.3.4"), 8);
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/8");
+    subnet = CSubNet(ResolveIP("1.2.3.4"), 0);
+    BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/0");
+
+    subnet = CSubNet(ResolveIP("1.2.3.4"), ResolveIP("255.255.255.255"));
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/32");
+    subnet = CSubNet(ResolveIP("1.2.3.4"), ResolveIP("255.0.0.0"));
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/8");
+    subnet = CSubNet(ResolveIP("1.2.3.4"), ResolveIP("0.0.0.0"));
+    BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/0");
+
+    BOOST_CHECK(CSubNet(ResolveIP("1:2:3:4:5:6:7:8")).IsValid());
+    BOOST_CHECK(CSubNet(ResolveIP("1:2:3:4:5:6:7:8")).Match(ResolveIP("1:2:3:4:5:6:7:8")));
+    BOOST_CHECK(!CSubNet(ResolveIP("1:2:3:4:5:6:7:8")).Match(ResolveIP("1:2:3:4:5:6:7:9")));
+    BOOST_CHECK(CSubNet(ResolveIP("1:2:3:4:5:6:7:8")).ToString() == "1:2:3:4:5:6:7:8/128");
+
+    subnet = ResolveSubNet("1.2.3.4/255.255.255.255");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/32");
+    subnet = ResolveSubNet("1.2.3.4/255.255.255.254");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/31");
+    subnet = ResolveSubNet("1.2.3.4/255.255.255.252");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.4/30");
+    subnet = ResolveSubNet("1.2.3.4/255.255.255.248");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/29");
+    subnet = ResolveSubNet("1.2.3.4/255.255.255.240");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/28");
+    subnet = ResolveSubNet("1.2.3.4/255.255.255.224");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/27");
+    subnet = ResolveSubNet("1.2.3.4/255.255.255.192");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/26");
+    subnet = ResolveSubNet("1.2.3.4/255.255.255.128");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/25");
+    subnet = ResolveSubNet("1.2.3.4/255.255.255.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.3.0/24");
+    subnet = ResolveSubNet("1.2.3.4/255.255.254.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.2.0/23");
+    subnet = ResolveSubNet("1.2.3.4/255.255.252.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/22");
+    subnet = ResolveSubNet("1.2.3.4/255.255.248.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/21");
+    subnet = ResolveSubNet("1.2.3.4/255.255.240.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/20");
+    subnet = ResolveSubNet("1.2.3.4/255.255.224.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/19");
+    subnet = ResolveSubNet("1.2.3.4/255.255.192.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/18");
+    subnet = ResolveSubNet("1.2.3.4/255.255.128.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/17");
+    subnet = ResolveSubNet("1.2.3.4/255.255.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/16");
+    subnet = ResolveSubNet("1.2.3.4/255.254.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/15");
+    subnet = ResolveSubNet("1.2.3.4/255.252.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/14");
+    subnet = ResolveSubNet("1.2.3.4/255.248.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/13");
+    subnet = ResolveSubNet("1.2.3.4/255.240.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/12");
+    subnet = ResolveSubNet("1.2.3.4/255.224.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/11");
+    subnet = ResolveSubNet("1.2.3.4/255.192.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/10");
+    subnet = ResolveSubNet("1.2.3.4/255.128.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/9");
+    subnet = ResolveSubNet("1.2.3.4/255.0.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.0.0.0/8");
+    subnet = ResolveSubNet("1.2.3.4/254.0.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/7");
+    subnet = ResolveSubNet("1.2.3.4/252.0.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/6");
+    subnet = ResolveSubNet("1.2.3.4/248.0.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/5");
+    subnet = ResolveSubNet("1.2.3.4/240.0.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/4");
+    subnet = ResolveSubNet("1.2.3.4/224.0.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/3");
+    subnet = ResolveSubNet("1.2.3.4/192.0.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/2");
+    subnet = ResolveSubNet("1.2.3.4/128.0.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/1");
+    subnet = ResolveSubNet("1.2.3.4/0.0.0.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "0.0.0.0/0");
+
+    subnet = ResolveSubNet("1:2:3:4:5:6:7:8/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1:2:3:4:5:6:7:8/128");
+    subnet = ResolveSubNet("1:2:3:4:5:6:7:8/ffff:0000:0000:0000:0000:0000:0000:0000");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1::/16");
+    subnet = ResolveSubNet("1:2:3:4:5:6:7:8/0000:0000:0000:0000:0000:0000:0000:0000");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "::/0");
+    subnet = ResolveSubNet("1.2.3.4/255.255.232.0");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1.2.0.0/255.255.232.0");
+    subnet = ResolveSubNet("1:2:3:4:5:6:7:8/ffff:ffff:ffff:fffe:ffff:ffff:ffff:ff0f");
+    BOOST_CHECK_EQUAL(subnet.ToString(), "1:2:3:4:5:6:7:8/ffff:ffff:ffff:fffe:ffff:ffff:ffff:ff0f");
+
+}
+
+BOOST_AUTO_TEST_CASE(netbase_getgroup)
+{
+
+    BOOST_CHECK(ResolveIP("127.0.0.1").GetGroup() == std::vector<unsigned char>({0})); // Local -> !Routable()
+    BOOST_CHECK(ResolveIP("257.0.0.1").GetGroup() == std::vector<unsigned char>({0})); // !Valid -> !Routable()
+    BOOST_CHECK(ResolveIP("10.0.0.1").GetGroup() == std::vector<unsigned char>({0})); // RFC1918 -> !Routable()
+    BOOST_CHECK(ResolveIP("169.254.1.1").GetGroup() == std::vector<unsigned char>({0})); // RFC3927 -> !Routable()
+    BOOST_CHECK(ResolveIP("1.2.3.4").GetGroup() == std::vector<unsigned char>({(unsigned char)NET_IPV4, 1, 2})); // IPv4
+    BOOST_CHECK(ResolveIP("::FFFF:0:102:304").GetGroup() == std::vector<unsigned char>({(unsigned char)NET_IPV4, 1, 2})); // RFC6145
+    BOOST_CHECK(ResolveIP("64:FF9B::102:304").GetGroup() == std::vector<unsigned char>({(unsigned char)NET_IPV4, 1, 2})); // RFC6052
+    BOOST_CHECK(ResolveIP("2002:102:304:9999:9999:9999:9999:9999").GetGroup() == std::vector<unsigned char>({(unsigned char)NET_IPV4, 1, 2})); // RFC3964
+    BOOST_CHECK(ResolveIP("2001:0:9999:9999:9999:9999:FEFD:FCFB").GetGroup() == std::vector<unsigned char>({(unsigned char)NET_IPV4, 1, 2})); // RFC4380
+    BOOST_CHECK(ResolveIP("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").GetGroup() == std::vector<unsigned char>({(unsigned char)NET_TOR, 239})); // Tor
+    BOOST_CHECK(ResolveIP("2001:470:abcd:9999:9999:9999:9999:9999").GetGroup() == std::vector<unsigned char>({(unsigned char)NET_IPV6, 32, 1, 4, 112, 175})); //he.net
+    BOOST_CHECK(ResolveIP("2001:2001:9999:9999:9999:9999:9999:9999").GetGroup() == std::vector<unsigned char>({(unsigned char)NET_IPV6, 32, 1, 32, 1})); //IPv6
+
+    // baz.net sha256 hash: 12929400eb4607c4ac075f087167e75286b179c693eb059a01774b864e8fe505
+    std::vector<unsigned char> internal_group = {NET_INTERNAL, 0x12, 0x92, 0x94, 0x00, 0xeb, 0x46, 0x07, 0xc4, 0xac, 0x07};
+    BOOST_CHECK(CreateInternal("baz.net").GetGroup() == internal_group);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/pmt_tests.cpp b/pmt_tests.cpp
new file mode 100644
index 0000000..eda8dd2
--- /dev/null
+++ b/pmt_tests.cpp
@@ -0,0 +1,126 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <consensus/merkle.h>
+#include <merkleblock.h>
+#include <serialize.h>
+#include <streams.h>
+#include <uint256.h>
+#include <arith_uint256.h>
+#include <version.h>
+#include <test/test_salemcash.h>
+
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+class CPartialMerkleTreeTester : public CPartialMerkleTree
+{
+public:
+    // flip one bit in one of the hashes - this should break the authentication
+    void Damage() {
+        unsigned int n = InsecureRandRange(vHash.size());
+        int bit = InsecureRandBits(8);
+        *(vHash[n].begin() + (bit>>3)) ^= 1<<(bit&7);
+    }
+};
+
+BOOST_FIXTURE_TEST_SUITE(pmt_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(pmt_test1)
+{
+    SeedInsecureRand(false);
+    static const unsigned int nTxCounts[] = {1, 4, 7, 17, 56, 100, 127, 256, 312, 513, 1000, 4095};
+
+    for (int i = 0; i < 12; i++) {
+        unsigned int nTx = nTxCounts[i];
+
+        // build a block with some dummy transactions
+        CBlock block;
+        for (unsigned int j=0; j<nTx; j++) {
+            CMutableTransaction tx;
+            tx.nLockTime = j; // actual transaction data doesn't matter; just make the nLockTime's unique
+            block.vtx.push_back(MakeTransactionRef(std::move(tx)));
+        }
+
+        // calculate actual merkle root and height
+        uint256 merkleRoot1 = BlockMerkleRoot(block);
+        std::vector<uint256> vTxid(nTx, uint256());
+        for (unsigned int j=0; j<nTx; j++)
+            vTxid[j] = block.vtx[j]->GetHash();
+        int nHeight = 1, nTx_ = nTx;
+        while (nTx_ > 1) {
+            nTx_ = (nTx_+1)/2;
+            nHeight++;
+        }
+
+        // check with random subsets with inclusion chances 1, 1/2, 1/4, ..., 1/128
+        for (int att = 1; att < 15; att++) {
+            // build random subset of txid's
+            std::vector<bool> vMatch(nTx, false);
+            std::vector<uint256> vMatchTxid1;
+            for (unsigned int j=0; j<nTx; j++) {
+                bool fInclude = InsecureRandBits(att / 2) == 0;
+                vMatch[j] = fInclude;
+                if (fInclude)
+                    vMatchTxid1.push_back(vTxid[j]);
+            }
+
+            // build the partial merkle tree
+            CPartialMerkleTree pmt1(vTxid, vMatch);
+
+            // serialize
+            CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+            ss << pmt1;
+
+            // verify CPartialMerkleTree's size guarantees
+            unsigned int n = std::min<unsigned int>(nTx, 1 + vMatchTxid1.size()*nHeight);
+            BOOST_CHECK(ss.size() <= 10 + (258*n+7)/8);
+
+            // deserialize into a tester copy
+            CPartialMerkleTreeTester pmt2;
+            ss >> pmt2;
+
+            // extract merkle root and matched txids from copy
+            std::vector<uint256> vMatchTxid2;
+            std::vector<unsigned int> vIndex;
+            uint256 merkleRoot2 = pmt2.ExtractMatches(vMatchTxid2, vIndex);
+
+            // check that it has the same merkle root as the original, and a valid one
+            BOOST_CHECK(merkleRoot1 == merkleRoot2);
+            BOOST_CHECK(!merkleRoot2.IsNull());
+
+            // check that it contains the matched transactions (in the same order!)
+            BOOST_CHECK(vMatchTxid1 == vMatchTxid2);
+
+            // check that random bit flips break the authentication
+            for (int j=0; j<4; j++) {
+                CPartialMerkleTreeTester pmt3(pmt2);
+                pmt3.Damage();
+                std::vector<uint256> vMatchTxid3;
+                uint256 merkleRoot3 = pmt3.ExtractMatches(vMatchTxid3, vIndex);
+                BOOST_CHECK(merkleRoot3 != merkleRoot1);
+            }
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(pmt_malleability)
+{
+    std::vector<uint256> vTxid = {
+        ArithToUint256(1), ArithToUint256(2),
+        ArithToUint256(3), ArithToUint256(4),
+        ArithToUint256(5), ArithToUint256(6),
+        ArithToUint256(7), ArithToUint256(8),
+        ArithToUint256(9), ArithToUint256(10),
+        ArithToUint256(9), ArithToUint256(10),
+    };
+    std::vector<bool> vMatch = {false, false, false, false, false, false, false, false, false, true, true, false};
+
+    CPartialMerkleTree tree(vTxid, vMatch);
+    std::vector<unsigned int> vIndex;
+    BOOST_CHECK(tree.ExtractMatches(vTxid, vIndex).IsNull());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/policyestimator_tests.cpp b/policyestimator_tests.cpp
new file mode 100644
index 0000000..4525da2
--- /dev/null
+++ b/policyestimator_tests.cpp
@@ -0,0 +1,182 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <policy/policy.h>
+#include <policy/fees.h>
+#include <txmempool.h>
+#include <uint256.h>
+#include <util.h>
+
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(policyestimator_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(BlockPolicyEstimates)
+{
+    CBlockPolicyEstimator feeEst;
+    CTxMemPool mpool(&feeEst);
+    TestMemPoolEntryHelper entry;
+    CAmount basefee(2000);
+    CAmount deltaFee(100);
+    std::vector<CAmount> feeV;
+
+    // Populate vectors of increasing fees
+    for (int j = 0; j < 10; j++) {
+        feeV.push_back(basefee * (j+1));
+    }
+
+    // Store the hashes of transactions that have been
+    // added to the mempool by their associate fee
+    // txHashes[j] is populated with transactions either of
+    // fee = basefee * (j+1)
+    std::vector<uint256> txHashes[10];
+
+    // Create a transaction template
+    CScript garbage;
+    for (unsigned int i = 0; i < 128; i++)
+        garbage.push_back('X');
+    CMutableTransaction tx;
+    tx.vin.resize(1);
+    tx.vin[0].scriptSig = garbage;
+    tx.vout.resize(1);
+    tx.vout[0].nValue=0LL;
+    CFeeRate baseRate(basefee, GetVirtualTransactionSize(tx));
+
+    // Create a fake block
+    std::vector<CTransactionRef> block;
+    int blocknum = 0;
+
+    // Loop through 200 blocks
+    // At a decay .9952 and 4 fee transactions per block
+    // This makes the tx count about 2.5 per bucket, well above the 0.1 threshold
+    while (blocknum < 200) {
+        for (int j = 0; j < 10; j++) { // For each fee
+            for (int k = 0; k < 4; k++) { // add 4 fee txs
+                tx.vin[0].prevout.n = 10000*blocknum+100*j+k; // make transaction unique
+                uint256 hash = tx.GetHash();
+                mpool.addUnchecked(hash, entry.Fee(feeV[j]).Time(GetTime()).Height(blocknum).FromTx(tx));
+                txHashes[j].push_back(hash);
+            }
+        }
+        //Create blocks where higher fee txs are included more often
+        for (int h = 0; h <= blocknum%10; h++) {
+            // 10/10 blocks add highest fee transactions
+            // 9/10 blocks add 2nd highest and so on until ...
+            // 1/10 blocks add lowest fee transactions
+            while (txHashes[9-h].size()) {
+                CTransactionRef ptx = mpool.get(txHashes[9-h].back());
+                if (ptx)
+                    block.push_back(ptx);
+                txHashes[9-h].pop_back();
+            }
+        }
+        mpool.removeForBlock(block, ++blocknum);
+        block.clear();
+        // Check after just a few txs that combining buckets works as expected
+        if (blocknum == 3) {
+            // At this point we should need to combine 3 buckets to get enough data points
+            // So estimateFee(1) should fail and estimateFee(2) should return somewhere around
+            // 9*baserate.  estimateFee(2) %'s are 100,100,90 = average 97%
+            BOOST_CHECK(feeEst.estimateFee(1) == CFeeRate(0));
+            BOOST_CHECK(feeEst.estimateFee(2).GetFeePerK() < 9*baseRate.GetFeePerK() + deltaFee);
+            BOOST_CHECK(feeEst.estimateFee(2).GetFeePerK() > 9*baseRate.GetFeePerK() - deltaFee);
+        }
+    }
+
+    std::vector<CAmount> origFeeEst;
+    // Highest feerate is 10*baseRate and gets in all blocks,
+    // second highest feerate is 9*baseRate and gets in 9/10 blocks = 90%,
+    // third highest feerate is 8*base rate, and gets in 8/10 blocks = 80%,
+    // so estimateFee(1) would return 10*baseRate but is hardcoded to return failure
+    // Second highest feerate has 100% chance of being included by 2 blocks,
+    // so estimateFee(2) should return 9*baseRate etc...
+    for (int i = 1; i < 10;i++) {
+        origFeeEst.push_back(feeEst.estimateFee(i).GetFeePerK());
+        if (i > 2) { // Fee estimates should be monotonically decreasing
+            BOOST_CHECK(origFeeEst[i-1] <= origFeeEst[i-2]);
+        }
+        int mult = 11-i;
+        if (i % 2 == 0) { //At scale 2, test logic is only correct for even targets
+            BOOST_CHECK(origFeeEst[i-1] < mult*baseRate.GetFeePerK() + deltaFee);
+            BOOST_CHECK(origFeeEst[i-1] > mult*baseRate.GetFeePerK() - deltaFee);
+        }
+    }
+    // Fill out rest of the original estimates
+    for (int i = 10; i <= 48; i++) {
+        origFeeEst.push_back(feeEst.estimateFee(i).GetFeePerK());
+    }
+
+    // Mine 50 more blocks with no transactions happening, estimates shouldn't change
+    // We haven't decayed the moving average enough so we still have enough data points in every bucket
+    while (blocknum < 250)
+        mpool.removeForBlock(block, ++blocknum);
+
+    BOOST_CHECK(feeEst.estimateFee(1) == CFeeRate(0));
+    for (int i = 2; i < 10;i++) {
+        BOOST_CHECK(feeEst.estimateFee(i).GetFeePerK() < origFeeEst[i-1] + deltaFee);
+        BOOST_CHECK(feeEst.estimateFee(i).GetFeePerK() > origFeeEst[i-1] - deltaFee);
+    }
+
+
+    // Mine 15 more blocks with lots of transactions happening and not getting mined
+    // Estimates should go up
+    while (blocknum < 265) {
+        for (int j = 0; j < 10; j++) { // For each fee multiple
+            for (int k = 0; k < 4; k++) { // add 4 fee txs
+                tx.vin[0].prevout.n = 10000*blocknum+100*j+k;
+                uint256 hash = tx.GetHash();
+                mpool.addUnchecked(hash, entry.Fee(feeV[j]).Time(GetTime()).Height(blocknum).FromTx(tx));
+                txHashes[j].push_back(hash);
+            }
+        }
+        mpool.removeForBlock(block, ++blocknum);
+    }
+
+    for (int i = 1; i < 10;i++) {
+        BOOST_CHECK(feeEst.estimateFee(i) == CFeeRate(0) || feeEst.estimateFee(i).GetFeePerK() > origFeeEst[i-1] - deltaFee);
+    }
+
+    // Mine all those transactions
+    // Estimates should still not be below original
+    for (int j = 0; j < 10; j++) {
+        while(txHashes[j].size()) {
+            CTransactionRef ptx = mpool.get(txHashes[j].back());
+            if (ptx)
+                block.push_back(ptx);
+            txHashes[j].pop_back();
+        }
+    }
+    mpool.removeForBlock(block, 266);
+    block.clear();
+    BOOST_CHECK(feeEst.estimateFee(1) == CFeeRate(0));
+    for (int i = 2; i < 10;i++) {
+        BOOST_CHECK(feeEst.estimateFee(i) == CFeeRate(0) || feeEst.estimateFee(i).GetFeePerK() > origFeeEst[i-1] - deltaFee);
+    }
+
+    // Mine 400 more blocks where everything is mined every block
+    // Estimates should be below original estimates
+    while (blocknum < 665) {
+        for (int j = 0; j < 10; j++) { // For each fee multiple
+            for (int k = 0; k < 4; k++) { // add 4 fee txs
+                tx.vin[0].prevout.n = 10000*blocknum+100*j+k;
+                uint256 hash = tx.GetHash();
+                mpool.addUnchecked(hash, entry.Fee(feeV[j]).Time(GetTime()).Height(blocknum).FromTx(tx));
+                CTransactionRef ptx = mpool.get(hash);
+                if (ptx)
+                    block.push_back(ptx);
+
+            }
+        }
+        mpool.removeForBlock(block, ++blocknum);
+        block.clear();
+    }
+    BOOST_CHECK(feeEst.estimateFee(1) == CFeeRate(0));
+    for (int i = 2; i < 9; i++) { // At 9, the original estimate was already at the bottom (b/c scale = 2)
+        BOOST_CHECK(feeEst.estimateFee(i).GetFeePerK() < origFeeEst[i-1] - deltaFee);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/pow_tests.cpp b/pow_tests.cpp
new file mode 100644
index 0000000..efd2501
--- /dev/null
+++ b/pow_tests.cpp
@@ -0,0 +1,86 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <chain.h>
+#include <chainparams.h>
+#include <pow.h>
+#include <random.h>
+#include <util.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
+
+/* Test calculation of next difficulty target with no constraints applying */
+BOOST_AUTO_TEST_CASE(get_next_work)
+{
+    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    int64_t nLastRetargetTime = 1261130161; // Block #30240
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 32255;
+    pindexLast.nTime = 1262152739;  // Block #32255
+    pindexLast.nBits = 0x1d00ffff;
+    BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1d00d86a);
+}
+
+/* Test the constraint on the upper bound for next work */
+BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)
+{
+    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    int64_t nLastRetargetTime = 1231006505; // Block #0
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 2015;
+    pindexLast.nTime = 1233061996;  // Block #2015
+    pindexLast.nBits = 0x1d00ffff;
+    BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1d00ffff);
+}
+
+/* Test the constraint on the lower bound for actual time taken */
+BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)
+{
+    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    int64_t nLastRetargetTime = 1279008237; // Block #66528
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 68543;
+    pindexLast.nTime = 1279297671;  // Block #68543
+    pindexLast.nBits = 0x1c05a3f4;
+    BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1c0168fd);
+}
+
+/* Test the constraint on the upper bound for actual time taken */
+BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)
+{
+    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    int64_t nLastRetargetTime = 1263163443; // NOTE: Not an actual block time
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 46367;
+    pindexLast.nTime = 1269211443;  // Block #46367
+    pindexLast.nBits = 0x1c387f6f;
+    BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1d00e1fd);
+}
+
+BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)
+{
+    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    std::vector<CBlockIndex> blocks(10000);
+    for (int i = 0; i < 10000; i++) {
+        blocks[i].pprev = i ? &blocks[i - 1] : nullptr;
+        blocks[i].nHeight = i;
+        blocks[i].nTime = 1269211443 + i * chainParams->GetConsensus().nPowTargetSpacing;
+        blocks[i].nBits = 0x207fffff; /* target 0x7fffff000... */
+        blocks[i].nChainWork = i ? blocks[i - 1].nChainWork + GetBlockProof(blocks[i - 1]) : arith_uint256(0);
+    }
+
+    for (int j = 0; j < 1000; j++) {
+        CBlockIndex *p1 = &blocks[InsecureRandRange(10000)];
+        CBlockIndex *p2 = &blocks[InsecureRandRange(10000)];
+        CBlockIndex *p3 = &blocks[InsecureRandRange(10000)];
+
+        int64_t tdiff = GetBlockProofEquivalentTime(*p1, *p2, *p3, chainParams->GetConsensus());
+        BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime());
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/prevector_tests.cpp b/prevector_tests.cpp
new file mode 100644
index 0000000..c12b449
--- /dev/null
+++ b/prevector_tests.cpp
@@ -0,0 +1,267 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <vector>
+#include <prevector.h>
+
+#include <reverse_iterator.h>
+#include <serialize.h>
+#include <streams.h>
+
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(PrevectorTests, TestingSetup)
+
+template<unsigned int N, typename T>
+class prevector_tester {
+    typedef std::vector<T> realtype;
+    realtype real_vector;
+    realtype real_vector_alt;
+
+    typedef prevector<N, T> pretype;
+    pretype pre_vector;
+    pretype pre_vector_alt;
+
+    typedef typename pretype::size_type Size;
+    bool passed = true;
+    FastRandomContext rand_cache;
+    uint256 rand_seed;
+
+
+    template <typename A, typename B>
+        void local_check_equal(A a, B b)
+        {
+            local_check(a == b);
+        }
+    void local_check(bool b) 
+    {
+        passed &= b;
+    }
+    void test() {
+        const pretype& const_pre_vector = pre_vector;
+        local_check_equal(real_vector.size(), pre_vector.size());
+        local_check_equal(real_vector.empty(), pre_vector.empty());
+        for (Size s = 0; s < real_vector.size(); s++) {
+             local_check(real_vector[s] == pre_vector[s]);
+             local_check(&(pre_vector[s]) == &(pre_vector.begin()[s]));
+             local_check(&(pre_vector[s]) == &*(pre_vector.begin() + s));
+             local_check(&(pre_vector[s]) == &*((pre_vector.end() + s) - real_vector.size()));
+        }
+        // local_check(realtype(pre_vector) == real_vector);
+        local_check(pretype(real_vector.begin(), real_vector.end()) == pre_vector);
+        local_check(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector);
+        size_t pos = 0;
+        for (const T& v : pre_vector) {
+             local_check(v == real_vector[pos++]);
+        }
+        for (const T& v : reverse_iterate(pre_vector)) {
+             local_check(v == real_vector[--pos]);
+        }
+        for (const T& v : const_pre_vector) {
+             local_check(v == real_vector[pos++]);
+        }
+        for (const T& v : reverse_iterate(const_pre_vector)) {
+             local_check(v == real_vector[--pos]);
+        }
+        CDataStream ss1(SER_DISK, 0);
+        CDataStream ss2(SER_DISK, 0);
+        ss1 << real_vector;
+        ss2 << pre_vector;
+        local_check_equal(ss1.size(), ss2.size());
+        for (Size s = 0; s < ss1.size(); s++) {
+            local_check_equal(ss1[s], ss2[s]);
+        }
+    }
+
+public:
+    void resize(Size s) {
+        real_vector.resize(s);
+        local_check_equal(real_vector.size(), s);
+        pre_vector.resize(s);
+        local_check_equal(pre_vector.size(), s);
+        test();
+    }
+
+    void reserve(Size s) {
+        real_vector.reserve(s);
+        local_check(real_vector.capacity() >= s);
+        pre_vector.reserve(s);
+        local_check(pre_vector.capacity() >= s);
+        test();
+    }
+
+    void insert(Size position, const T& value) {
+        real_vector.insert(real_vector.begin() + position, value);
+        pre_vector.insert(pre_vector.begin() + position, value);
+        test();
+    }
+
+    void insert(Size position, Size count, const T& value) {
+        real_vector.insert(real_vector.begin() + position, count, value);
+        pre_vector.insert(pre_vector.begin() + position, count, value);
+        test();
+    }
+
+    template<typename I>
+    void insert_range(Size position, I first, I last) {
+        real_vector.insert(real_vector.begin() + position, first, last);
+        pre_vector.insert(pre_vector.begin() + position, first, last);
+        test();
+    }
+
+    void erase(Size position) {
+        real_vector.erase(real_vector.begin() + position);
+        pre_vector.erase(pre_vector.begin() + position);
+        test();
+    }
+
+    void erase(Size first, Size last) {
+        real_vector.erase(real_vector.begin() + first, real_vector.begin() + last);
+        pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last);
+        test();
+    }
+
+    void update(Size pos, const T& value) {
+        real_vector[pos] = value;
+        pre_vector[pos] = value;
+        test();
+    }
+
+    void push_back(const T& value) {
+        real_vector.push_back(value);
+        pre_vector.push_back(value);
+        test();
+    }
+
+    void pop_back() {
+        real_vector.pop_back();
+        pre_vector.pop_back();
+        test();
+    }
+
+    void clear() {
+        real_vector.clear();
+        pre_vector.clear();
+    }
+
+    void assign(Size n, const T& value) {
+        real_vector.assign(n, value);
+        pre_vector.assign(n, value);
+    }
+
+    Size size() const {
+        return real_vector.size();
+    }
+
+    Size capacity() const {
+        return pre_vector.capacity();
+    }
+
+    void shrink_to_fit() {
+        pre_vector.shrink_to_fit();
+        test();
+    }
+
+    void swap() {
+        real_vector.swap(real_vector_alt);
+        pre_vector.swap(pre_vector_alt);
+        test();
+    }
+
+    void move() {
+        real_vector = std::move(real_vector_alt);
+        real_vector_alt.clear();
+        pre_vector = std::move(pre_vector_alt);
+        pre_vector_alt.clear();
+    }
+
+    void copy() {
+        real_vector = real_vector_alt;
+        pre_vector = pre_vector_alt;
+    }
+
+    ~prevector_tester() {
+        BOOST_CHECK_MESSAGE(passed, "insecure_rand: " + rand_seed.ToString());
+    }
+
+    prevector_tester() {
+        SeedInsecureRand();
+        rand_seed = insecure_rand_seed;
+        rand_cache = insecure_rand_ctx;
+    }
+};
+
+BOOST_AUTO_TEST_CASE(PrevectorTestInt)
+{
+    for (int j = 0; j < 64; j++) {
+        prevector_tester<8, int> test;
+        for (int i = 0; i < 2048; i++) {
+            if (InsecureRandBits(2) == 0) {
+                test.insert(InsecureRandRange(test.size() + 1), InsecureRand32());
+            }
+            if (test.size() > 0 && InsecureRandBits(2) == 1) {
+                test.erase(InsecureRandRange(test.size()));
+            }
+            if (InsecureRandBits(3) == 2) {
+                int new_size = std::max(0, std::min(30, (int)test.size() + (int)InsecureRandRange(5) - 2));
+                test.resize(new_size);
+            }
+            if (InsecureRandBits(3) == 3) {
+                test.insert(InsecureRandRange(test.size() + 1), 1 + InsecureRandBool(), InsecureRand32());
+            }
+            if (InsecureRandBits(3) == 4) {
+                int del = std::min<int>(test.size(), 1 + (InsecureRandBool()));
+                int beg = InsecureRandRange(test.size() + 1 - del);
+                test.erase(beg, beg + del);
+            }
+            if (InsecureRandBits(4) == 5) {
+                test.push_back(InsecureRand32());
+            }
+            if (test.size() > 0 && InsecureRandBits(4) == 6) {
+                test.pop_back();
+            }
+            if (InsecureRandBits(5) == 7) {
+                int values[4];
+                int num = 1 + (InsecureRandBits(2));
+                for (int k = 0; k < num; k++) {
+                    values[k] = InsecureRand32();
+                }
+                test.insert_range(InsecureRandRange(test.size() + 1), values, values + num);
+            }
+            if (InsecureRandBits(5) == 8) {
+                int del = std::min<int>(test.size(), 1 + (InsecureRandBits(2)));
+                int beg = InsecureRandRange(test.size() + 1 - del);
+                test.erase(beg, beg + del);
+            }
+            if (InsecureRandBits(5) == 9) {
+                test.reserve(InsecureRandBits(5));
+            }
+            if (InsecureRandBits(6) == 10) {
+                test.shrink_to_fit();
+            }
+            if (test.size() > 0) {
+                test.update(InsecureRandRange(test.size()), InsecureRand32());
+            }
+            if (InsecureRandBits(10) == 11) {
+                test.clear();
+            }
+            if (InsecureRandBits(9) == 12) {
+                test.assign(InsecureRandBits(5), InsecureRand32());
+            }
+            if (InsecureRandBits(3) == 3) {
+                test.swap();
+            }
+            if (InsecureRandBits(4) == 8) {
+                test.copy();
+            }
+            if (InsecureRandBits(5) == 18) {
+                test.move();
+            }
+        }
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/raii_event_tests.cpp b/raii_event_tests.cpp
new file mode 100644
index 0000000..fb1a277
--- /dev/null
+++ b/raii_event_tests.cpp
@@ -0,0 +1,94 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <event2/event.h>
+
+#ifdef EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED
+// It would probably be ideal to define dummy test(s) that report skipped, but boost::test doesn't seem to make that practical (at least not in versions available with common distros)
+
+#include <map>
+#include <stdlib.h>
+
+#include <support/events.h>
+
+#include <test/test_salemcash.h>
+
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+static std::map<void*, short> tags;
+static std::map<void*, uint16_t> orders;
+static uint16_t tagSequence = 0;
+
+static void* tag_malloc(size_t sz) {
+    void* mem = malloc(sz);
+    if (!mem) return mem;
+    tags[mem]++;
+    orders[mem] = tagSequence++;
+    return mem;
+}
+
+static void tag_free(void* mem) {
+    tags[mem]--;
+    orders[mem] = tagSequence++;
+    free(mem);
+}
+
+BOOST_FIXTURE_TEST_SUITE(raii_event_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(raii_event_creation)
+{
+    event_set_mem_functions(tag_malloc, realloc, tag_free);
+    
+    void* base_ptr = nullptr;
+    {
+        auto base = obtain_event_base();
+        base_ptr = (void*)base.get();
+        BOOST_CHECK(tags[base_ptr] == 1);
+    }
+    BOOST_CHECK(tags[base_ptr] == 0);
+    
+    void* event_ptr = nullptr;
+    {
+        auto base = obtain_event_base();
+        auto event = obtain_event(base.get(), -1, 0, nullptr, nullptr);
+
+        base_ptr = (void*)base.get();
+        event_ptr = (void*)event.get();
+
+        BOOST_CHECK(tags[base_ptr] == 1);
+        BOOST_CHECK(tags[event_ptr] == 1);
+    }
+    BOOST_CHECK(tags[base_ptr] == 0);
+    BOOST_CHECK(tags[event_ptr] == 0);
+    
+    event_set_mem_functions(malloc, realloc, free);
+}
+
+BOOST_AUTO_TEST_CASE(raii_event_order)
+{
+    event_set_mem_functions(tag_malloc, realloc, tag_free);
+    
+    void* base_ptr = nullptr;
+    void* event_ptr = nullptr;
+    {
+        auto base = obtain_event_base();
+        auto event = obtain_event(base.get(), -1, 0, nullptr, nullptr);
+
+        base_ptr = (void*)base.get();
+        event_ptr = (void*)event.get();
+
+        // base should have allocated before event
+        BOOST_CHECK(orders[base_ptr] < orders[event_ptr]);
+    }
+    // base should be freed after event
+    BOOST_CHECK(orders[base_ptr] > orders[event_ptr]);
+
+    event_set_mem_functions(malloc, realloc, free);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+#endif  // EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED
diff --git a/random_tests.cpp b/random_tests.cpp
new file mode 100644
index 0000000..f475461
--- /dev/null
+++ b/random_tests.cpp
@@ -0,0 +1,82 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <random.h>
+
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <random>
+#include <algorithm>
+
+BOOST_FIXTURE_TEST_SUITE(random_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(osrandom_tests)
+{
+    BOOST_CHECK(Random_SanityCheck());
+}
+
+BOOST_AUTO_TEST_CASE(fastrandom_tests)
+{
+    // Check that deterministic FastRandomContexts are deterministic
+    FastRandomContext ctx1(true);
+    FastRandomContext ctx2(true);
+
+    BOOST_CHECK_EQUAL(ctx1.rand32(), ctx2.rand32());
+    BOOST_CHECK_EQUAL(ctx1.rand32(), ctx2.rand32());
+    BOOST_CHECK_EQUAL(ctx1.rand64(), ctx2.rand64());
+    BOOST_CHECK_EQUAL(ctx1.randbits(3), ctx2.randbits(3));
+    BOOST_CHECK(ctx1.randbytes(17) == ctx2.randbytes(17));
+    BOOST_CHECK(ctx1.rand256() == ctx2.rand256());
+    BOOST_CHECK_EQUAL(ctx1.randbits(7), ctx2.randbits(7));
+    BOOST_CHECK(ctx1.randbytes(128) == ctx2.randbytes(128));
+    BOOST_CHECK_EQUAL(ctx1.rand32(), ctx2.rand32());
+    BOOST_CHECK_EQUAL(ctx1.randbits(3), ctx2.randbits(3));
+    BOOST_CHECK(ctx1.rand256() == ctx2.rand256());
+    BOOST_CHECK(ctx1.randbytes(50) == ctx2.randbytes(50));
+
+    // Check that a nondeterministic ones are not
+    FastRandomContext ctx3;
+    FastRandomContext ctx4;
+    BOOST_CHECK(ctx3.rand64() != ctx4.rand64()); // extremely unlikely to be equal
+    BOOST_CHECK(ctx3.rand256() != ctx4.rand256());
+    BOOST_CHECK(ctx3.randbytes(7) != ctx4.randbytes(7));
+}
+
+BOOST_AUTO_TEST_CASE(fastrandom_randbits)
+{
+    FastRandomContext ctx1;
+    FastRandomContext ctx2;
+    for (int bits = 0; bits < 63; ++bits) {
+        for (int j = 0; j < 1000; ++j) {
+            uint64_t rangebits = ctx1.randbits(bits);
+            BOOST_CHECK_EQUAL(rangebits >> bits, 0);
+            uint64_t range = ((uint64_t)1) << bits | rangebits;
+            uint64_t rand = ctx2.randrange(range);
+            BOOST_CHECK(rand < range);
+        }
+    }
+}
+
+/** Does-it-compile test for compatibility with standard C++11 RNG interface. */
+BOOST_AUTO_TEST_CASE(stdrandom_test)
+{
+    FastRandomContext ctx;
+    std::uniform_int_distribution<int> distribution(3, 9);
+    for (int i = 0; i < 100; ++i) {
+        int x = distribution(ctx);
+        BOOST_CHECK(x >= 3);
+        BOOST_CHECK(x <= 9);
+
+        std::vector<int> test{1,2,3,4,5,6,7,8,9,10};
+        std::shuffle(test.begin(), test.end(), ctx);
+        for (int j = 1; j <= 10; ++j) {
+            BOOST_CHECK(std::find(test.begin(), test.end(), j) != test.end());
+        }
+    }
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/reverselock_tests.cpp b/reverselock_tests.cpp
new file mode 100644
index 0000000..7a13d35
--- /dev/null
+++ b/reverselock_tests.cpp
@@ -0,0 +1,60 @@
+// Copyright (c) 2018 The Salemcash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <reverselock.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(reverselock_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(reverselock_basics)
+{
+    boost::mutex mutex;
+    boost::unique_lock<boost::mutex> lock(mutex);
+
+    BOOST_CHECK(lock.owns_lock());
+    {
+        reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
+        BOOST_CHECK(!lock.owns_lock());
+    }
+    BOOST_CHECK(lock.owns_lock());
+}
+
+BOOST_AUTO_TEST_CASE(reverselock_errors)
+{
+    boost::mutex mutex;
+    boost::unique_lock<boost::mutex> lock(mutex);
+
+    // Make sure trying to reverse lock an unlocked lock fails
+    lock.unlock();
+
+    BOOST_CHECK(!lock.owns_lock());
+
+    bool failed = false;
+    try {
+        reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
+    } catch(...) {
+        failed = true;
+    }
+
+    BOOST_CHECK(failed);
+    BOOST_CHECK(!lock.owns_lock());
+
+    // Locking the original lock after it has been taken by a reverse lock
+    // makes no sense. Ensure that the original lock no longer owns the lock
+    // after giving it to a reverse one.
+
+    lock.lock();
+    BOOST_CHECK(lock.owns_lock());
+    {
+        reverse_lock<boost::unique_lock<boost::mutex> > rlock(lock);
+        BOOST_CHECK(!lock.owns_lock());
+    }
+
+    BOOST_CHECK(failed);
+    BOOST_CHECK(lock.owns_lock());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/rpc_tests.cpp b/rpc_tests.cpp
new file mode 100644
index 0000000..b4f74f8
--- /dev/null
+++ b/rpc_tests.cpp
@@ -0,0 +1,339 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <rpc/server.h>
+#include <rpc/client.h>
+
+#include <core_io.h>
+#include <key_io.h>
+#include <netbase.h>
+
+#include <test/test_salemcash.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <univalue.h>
+
+UniValue CallRPC(std::string args)
+{
+    std::vector<std::string> vArgs;
+    boost::split(vArgs, args, boost::is_any_of(" \t"));
+    std::string strMethod = vArgs[0];
+    vArgs.erase(vArgs.begin());
+    JSONRPCRequest request;
+    request.strMethod = strMethod;
+    request.params = RPCConvertValues(strMethod, vArgs);
+    request.fHelp = false;
+    BOOST_CHECK(tableRPC[strMethod]);
+    rpcfn_type method = tableRPC[strMethod]->actor;
+    try {
+        UniValue result = (*method)(request);
+        return result;
+    }
+    catch (const UniValue& objError) {
+        throw std::runtime_error(find_value(objError, "message").get_str());
+    }
+}
+
+
+BOOST_FIXTURE_TEST_SUITE(rpc_tests, TestingSetup)
+
+BOOST_AUTO_TEST_CASE(rpc_rawparams)
+{
+    // Test raw transaction API argument handling
+    UniValue r;
+
+    BOOST_CHECK_THROW(CallRPC("getrawtransaction"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC("getrawtransaction not_hex"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC("getrawtransaction a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed not_int"), std::runtime_error);
+
+    BOOST_CHECK_THROW(CallRPC("createrawtransaction"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC("createrawtransaction null null"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC("createrawtransaction not_array"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC("createrawtransaction {} {}"), std::runtime_error);
+    BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [] {}"));
+    BOOST_CHECK_THROW(CallRPC("createrawtransaction [] {} extra"), std::runtime_error);
+
+    BOOST_CHECK_THROW(CallRPC("decoderawtransaction"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC("decoderawtransaction null"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC("decoderawtransaction DEADBEEF"), std::runtime_error);
+    std::string rawtx = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("decoderawtransaction ")+rawtx));
+    BOOST_CHECK_EQUAL(find_value(r.get_obj(), "size").get_int(), 193);
+    BOOST_CHECK_EQUAL(find_value(r.get_obj(), "version").get_int(), 1);
+    BOOST_CHECK_EQUAL(find_value(r.get_obj(), "locktime").get_int(), 0);
+    BOOST_CHECK_THROW(CallRPC(std::string("decoderawtransaction ")+rawtx+" extra"), std::runtime_error);
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("decoderawtransaction ")+rawtx+" false"));
+    BOOST_CHECK_THROW(r = CallRPC(std::string("decoderawtransaction ")+rawtx+" false extra"), std::runtime_error);
+
+    // Only check failure cases for sendrawtransaction, there's no network to send to...
+    BOOST_CHECK_THROW(CallRPC("sendrawtransaction"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC("sendrawtransaction null"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC("sendrawtransaction DEADBEEF"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC(std::string("sendrawtransaction ")+rawtx+" extra"), std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(rpc_togglenetwork)
+{
+    UniValue r;
+
+    r = CallRPC("getnetworkinfo");
+    bool netState = find_value(r.get_obj(), "networkactive").get_bool();
+    BOOST_CHECK_EQUAL(netState, true);
+
+    BOOST_CHECK_NO_THROW(CallRPC("setnetworkactive false"));
+    r = CallRPC("getnetworkinfo");
+    int numConnection = find_value(r.get_obj(), "connections").get_int();
+    BOOST_CHECK_EQUAL(numConnection, 0);
+
+    netState = find_value(r.get_obj(), "networkactive").get_bool();
+    BOOST_CHECK_EQUAL(netState, false);
+
+    BOOST_CHECK_NO_THROW(CallRPC("setnetworkactive true"));
+    r = CallRPC("getnetworkinfo");
+    netState = find_value(r.get_obj(), "networkactive").get_bool();
+    BOOST_CHECK_EQUAL(netState, true);
+}
+
+BOOST_AUTO_TEST_CASE(rpc_rawsign)
+{
+    UniValue r;
+    // input is a 1-of-2 multisig (so is output):
+    std::string prevout =
+      "[{\"txid\":\"b4cc287e58f87cdae59417329f710f3ecd75a4ee1d2872b7248f50977c8493f3\","
+      "\"vout\":1,\"scriptPubKey\":\"a914b10c9df5f7edf436c697f02f1efdba4cf399615187\","
+      "\"redeemScript\":\"512103debedc17b3df2badbcdd86d5feb4562b86fe182e5998abd8bcd4f122c6155b1b21027e940bb73ab8732bfdf7f9216ecefca5b94d6df834e77e108f68e66f126044c052ae\"}]";
+    r = CallRPC(std::string("createrawtransaction ")+prevout+" "+
+      "{\"3HqAe9LtNBjnsfM4CyYaWTnvCaUYT7v4oZ\":11}");
+    std::string notsigned = r.get_str();
+    std::string privkey1 = "\"KzsXybp9jX64P5ekX1KUxRQ79Jht9uzW7LorgwE65i5rWACL6LQe\"";
+    std::string privkey2 = "\"Kyhdf5LuKTRx4ge69ybABsiUAWjVRK4XGxAKk2FQLp2HjGMy87Z4\"";
+    r = CallRPC(std::string("signrawtransactionwithkey ")+notsigned+" [] "+prevout);
+    BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == false);
+    r = CallRPC(std::string("signrawtransactionwithkey ")+notsigned+" ["+privkey1+","+privkey2+"] "+prevout);
+    BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == true);
+}
+
+BOOST_AUTO_TEST_CASE(rpc_createraw_op_return)
+{
+    BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"68656c6c6f776f726c64\"}"));
+
+    // Allow more than one data transaction output
+    BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"68656c6c6f776f726c64\",\"data\":\"68656c6c6f776f726c64\"}"));
+
+    // Key not "data" (bad address)
+    BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"somedata\":\"68656c6c6f776f726c64\"}"), std::runtime_error);
+
+    // Bad hex encoding of data output
+    BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"12345\"}"), std::runtime_error);
+    BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"12345g\"}"), std::runtime_error);
+
+    // Data 81 bytes long
+    BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081\"}"));
+}
+
+BOOST_AUTO_TEST_CASE(rpc_format_monetary_values)
+{
+    BOOST_CHECK(ValueFromAmount(0LL).write() == "0.00000000");
+    BOOST_CHECK(ValueFromAmount(1LL).write() == "0.00000001");
+    BOOST_CHECK(ValueFromAmount(17622195LL).write() == "0.17622195");
+    BOOST_CHECK(ValueFromAmount(50000000LL).write() == "0.50000000");
+    BOOST_CHECK(ValueFromAmount(89898989LL).write() == "0.89898989");
+    BOOST_CHECK(ValueFromAmount(100000000LL).write() == "1.00000000");
+    BOOST_CHECK(ValueFromAmount(2099999999999990LL).write() == "20999999.99999990");
+    BOOST_CHECK(ValueFromAmount(2099999999999999LL).write() == "20999999.99999999");
+
+    BOOST_CHECK_EQUAL(ValueFromAmount(0).write(), "0.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount((CASH/10000)*123456789).write(), "12345.67890000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(-CASH).write(), "-1.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(-CASH/10).write(), "-0.10000000");
+
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH*100000000).write(), "100000000.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH*10000000).write(), "10000000.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH*1000000).write(), "1000000.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH*100000).write(), "100000.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH*10000).write(), "10000.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH*1000).write(), "1000.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH*100).write(), "100.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH*10).write(), "10.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH).write(), "1.00000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH/10).write(), "0.10000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH/100).write(), "0.01000000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH/1000).write(), "0.00100000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH/10000).write(), "0.00010000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH/100000).write(), "0.00001000");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH/1000000).write(), "0.00000100");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH/10000000).write(), "0.00000010");
+    BOOST_CHECK_EQUAL(ValueFromAmount(CASH/100000000).write(), "0.00000001");
+}
+
+static UniValue ValueFromString(const std::string &str)
+{
+    UniValue value;
+    BOOST_CHECK(value.setNumStr(str));
+    return value;
+}
+
+BOOST_AUTO_TEST_CASE(rpc_parse_monetary_values)
+{
+    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("-0.00000001")), UniValue);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0")), 0LL);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000000")), 0LL);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000001")), 1LL);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.17622195")), 17622195LL);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.5")), 50000000LL);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.50000000")), 50000000LL);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.89898989")), 89898989LL);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("1.00000000")), 100000000LL);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("20999999.9999999")), 2099999999999990LL);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("20999999.99999999")), 2099999999999999LL);
+
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("1e-8")), CASH/100000000);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.1e-7")), CASH/100000000);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.01e-6")), CASH/100000000);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.0000000000000000000000000000000000000000000000000000000000000000000000000001e+68")), CASH/100000000);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("10000000000000000000000000000000000000000000000000000000000000000e-64")), CASH);
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000e64")), CASH);
+
+    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e-9")), UniValue); //should fail
+    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("0.000000019")), UniValue); //should fail
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.00000001000000")), 1LL); //should pass, cut trailing 0
+    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("19e-9")), UniValue); //should fail
+    BOOST_CHECK_EQUAL(AmountFromValue(ValueFromString("0.19e-6")), 19); //should pass, leading 0 is present
+
+    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("92233720368.54775808")), UniValue); //overflow error
+    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e+11")), UniValue); //overflow error
+    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("1e11")), UniValue); //overflow error signless
+    BOOST_CHECK_THROW(AmountFromValue(ValueFromString("93e+9")), UniValue); //overflow error
+}
+
+BOOST_AUTO_TEST_CASE(json_parse_errors)
+{
+    // Valid
+    BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0").get_real(), 1.0);
+    // Valid, with leading or trailing whitespace
+    BOOST_CHECK_EQUAL(ParseNonRFCJSONValue(" 1.0").get_real(), 1.0);
+    BOOST_CHECK_EQUAL(ParseNonRFCJSONValue("1.0 ").get_real(), 1.0);
+
+    BOOST_CHECK_THROW(AmountFromValue(ParseNonRFCJSONValue(".19e-6")), std::runtime_error); //should fail, missing leading 0, therefore invalid JSON
+    BOOST_CHECK_EQUAL(AmountFromValue(ParseNonRFCJSONValue("0.00000000000000000000000000000000000001e+30 ")), 1);
+    // Invalid, initial garbage
+    BOOST_CHECK_THROW(ParseNonRFCJSONValue("[1.0"), std::runtime_error);
+    BOOST_CHECK_THROW(ParseNonRFCJSONValue("a1.0"), std::runtime_error);
+    // Invalid, trailing garbage
+    BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0sds"), std::runtime_error);
+    BOOST_CHECK_THROW(ParseNonRFCJSONValue("1.0]"), std::runtime_error);
+    // BTC addresses should fail parsing
+    BOOST_CHECK_THROW(ParseNonRFCJSONValue("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"), std::runtime_error);
+    BOOST_CHECK_THROW(ParseNonRFCJSONValue("3J98t1WpEZ73CNmQviecrnyiWrnqRhWNL"), std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(rpc_ban)
+{
+    BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
+
+    UniValue r;
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0 add")));
+    BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.0:8334")), std::runtime_error); //portnumber for setban not allowed
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
+    UniValue ar = r.get_array();
+    UniValue o1 = ar[0].get_obj();
+    UniValue adr = find_value(o1, "address");
+    BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/32");
+    BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0 remove")));
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
+    ar = r.get_array();
+    BOOST_CHECK_EQUAL(ar.size(), 0);
+
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/24 add 1607731200 true")));
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
+    ar = r.get_array();
+    o1 = ar[0].get_obj();
+    adr = find_value(o1, "address");
+    UniValue banned_until = find_value(o1, "banned_until");
+    BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
+    BOOST_CHECK_EQUAL(banned_until.get_int64(), 1607731200); // absolute time check
+
+    BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
+
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/24 add 200")));
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
+    ar = r.get_array();
+    o1 = ar[0].get_obj();
+    adr = find_value(o1, "address");
+    banned_until = find_value(o1, "banned_until");
+    BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
+    int64_t now = GetTime();
+    BOOST_CHECK(banned_until.get_int64() > now);
+    BOOST_CHECK(banned_until.get_int64()-now <= 200);
+
+    // must throw an exception because 127.0.0.1 is in already banned subnet range
+    BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.1 add")), std::runtime_error);
+
+    BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0/24 remove")));
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
+    ar = r.get_array();
+    BOOST_CHECK_EQUAL(ar.size(), 0);
+
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/255.255.0.0 add")));
+    BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.1.1 add")), std::runtime_error);
+
+    BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
+    ar = r.get_array();
+    BOOST_CHECK_EQUAL(ar.size(), 0);
+
+
+    BOOST_CHECK_THROW(r = CallRPC(std::string("setban test add")), std::runtime_error); //invalid IP
+
+    //IPv6 tests
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban FE80:0000:0000:0000:0202:B3FF:FE1E:8329 add")));
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
+    ar = r.get_array();
+    o1 = ar[0].get_obj();
+    adr = find_value(o1, "address");
+    BOOST_CHECK_EQUAL(adr.get_str(), "fe80::202:b3ff:fe1e:8329/128");
+
+    BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 2001:db8::/ffff:fffc:0:0:0:0:0:0 add")));
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
+    ar = r.get_array();
+    o1 = ar[0].get_obj();
+    adr = find_value(o1, "address");
+    BOOST_CHECK_EQUAL(adr.get_str(), "2001:db8::/30");
+
+    BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128 add")));
+    BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
+    ar = r.get_array();
+    o1 = ar[0].get_obj();
+    adr = find_value(o1, "address");
+    BOOST_CHECK_EQUAL(adr.get_str(), "2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128");
+}
+
+BOOST_AUTO_TEST_CASE(rpc_convert_values_generatetoaddress)
+{
+    UniValue result;
+
+    BOOST_CHECK_NO_THROW(result = RPCConvertValues("generatetoaddress", {"101", "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a"}));
+    BOOST_CHECK_EQUAL(result[0].get_int(), 101);
+    BOOST_CHECK_EQUAL(result[1].get_str(), "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a");
+
+    BOOST_CHECK_NO_THROW(result = RPCConvertValues("generatetoaddress", {"101", "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU"}));
+    BOOST_CHECK_EQUAL(result[0].get_int(), 101);
+    BOOST_CHECK_EQUAL(result[1].get_str(), "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU");
+
+    BOOST_CHECK_NO_THROW(result = RPCConvertValues("generatetoaddress", {"1", "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a", "9"}));
+    BOOST_CHECK_EQUAL(result[0].get_int(), 1);
+    BOOST_CHECK_EQUAL(result[1].get_str(), "mkESjLZW66TmHhiFX8MCaBjrhZ543PPh9a");
+    BOOST_CHECK_EQUAL(result[2].get_int(), 9);
+
+    BOOST_CHECK_NO_THROW(result = RPCConvertValues("generatetoaddress", {"1", "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU", "9"}));
+    BOOST_CHECK_EQUAL(result[0].get_int(), 1);
+    BOOST_CHECK_EQUAL(result[1].get_str(), "mhMbmE2tE9xzJYCV9aNC8jKWN31vtGrguU");
+    BOOST_CHECK_EQUAL(result[2].get_int(), 9);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/sanity_tests.cpp b/sanity_tests.cpp
new file mode 100644
index 0000000..83444af
--- /dev/null
+++ b/sanity_tests.cpp
@@ -0,0 +1,20 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <compat/sanity.h>
+#include <key.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(sanity_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(basic_sanity)
+{
+  BOOST_CHECK_MESSAGE(glibc_sanity_test() == true, "libc sanity test");
+  BOOST_CHECK_MESSAGE(glibcxx_sanity_test() == true, "stdlib sanity test");
+  BOOST_CHECK_MESSAGE(ECC_InitSanityCheck() == true, "openssl ECC test");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/scheduler_tests.cpp b/scheduler_tests.cpp
new file mode 100644
index 0000000..44e4fd9
--- /dev/null
+++ b/scheduler_tests.cpp
@@ -0,0 +1,115 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <random.h>
+#include <scheduler.h>
+
+#include <test/test_salemcash.h>
+
+#include <boost/bind.hpp>
+#include <boost/thread.hpp>
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_SUITE(scheduler_tests)
+
+static void microTask(CScheduler& s, boost::mutex& mutex, int& counter, int delta, boost::chrono::system_clock::time_point rescheduleTime)
+{
+    {
+        boost::unique_lock<boost::mutex> lock(mutex);
+        counter += delta;
+    }
+    boost::chrono::system_clock::time_point noTime = boost::chrono::system_clock::time_point::min();
+    if (rescheduleTime != noTime) {
+        CScheduler::Function f = boost::bind(&microTask, boost::ref(s), boost::ref(mutex), boost::ref(counter), -delta + 1, noTime);
+        s.schedule(f, rescheduleTime);
+    }
+}
+
+static void MicroSleep(uint64_t n)
+{
+#if defined(HAVE_WORKING_BOOST_SLEEP_FOR)
+    boost::this_thread::sleep_for(boost::chrono::microseconds(n));
+#elif defined(HAVE_WORKING_BOOST_SLEEP)
+    boost::this_thread::sleep(boost::posix_time::microseconds(n));
+#else
+    //should never get here
+    #error missing boost sleep implementation
+#endif
+}
+
+BOOST_AUTO_TEST_CASE(manythreads)
+{
+    // Stress test: hundreds of microsecond-scheduled tasks,
+    // serviced by 10 threads.
+    //
+    // So... ten shared counters, which if all the tasks execute
+    // properly will sum to the number of tasks done.
+    // Each task adds or subtracts a random amount from one of the
+    // counters, and then schedules another task 0-1000
+    // microseconds in the future to subtract or add from
+    // the counter -random_amount+1, so in the end the shared
+    // counters should sum to the number of initial tasks performed.
+    CScheduler microTasks;
+
+    boost::mutex counterMutex[10];
+    int counter[10] = { 0 };
+    FastRandomContext rng(42);
+    auto zeroToNine = [](FastRandomContext& rc) -> int { return rc.randrange(10); }; // [0, 9]
+    auto randomMsec = [](FastRandomContext& rc) -> int { return -11 + (int)rc.randrange(1012); }; // [-11, 1000]
+    auto randomDelta = [](FastRandomContext& rc) -> int { return -1000 + (int)rc.randrange(2001); }; // [-1000, 1000]
+
+    boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now();
+    boost::chrono::system_clock::time_point now = start;
+    boost::chrono::system_clock::time_point first, last;
+    size_t nTasks = microTasks.getQueueInfo(first, last);
+    BOOST_CHECK(nTasks == 0);
+
+    for (int i = 0; i < 100; i++) {
+        boost::chrono::system_clock::time_point t = now + boost::chrono::microseconds(randomMsec(rng));
+        boost::chrono::system_clock::time_point tReschedule = now + boost::chrono::microseconds(500 + randomMsec(rng));
+        int whichCounter = zeroToNine(rng);
+        CScheduler::Function f = boost::bind(&microTask, boost::ref(microTasks),
+                                             boost::ref(counterMutex[whichCounter]), boost::ref(counter[whichCounter]),
+                                             randomDelta(rng), tReschedule);
+        microTasks.schedule(f, t);
+    }
+    nTasks = microTasks.getQueueInfo(first, last);
+    BOOST_CHECK(nTasks == 100);
+    BOOST_CHECK(first < last);
+    BOOST_CHECK(last > now);
+
+    // As soon as these are created they will start running and servicing the queue
+    boost::thread_group microThreads;
+    for (int i = 0; i < 5; i++)
+        microThreads.create_thread(boost::bind(&CScheduler::serviceQueue, &microTasks));
+
+    MicroSleep(600);
+    now = boost::chrono::system_clock::now();
+
+    // More threads and more tasks:
+    for (int i = 0; i < 5; i++)
+        microThreads.create_thread(boost::bind(&CScheduler::serviceQueue, &microTasks));
+    for (int i = 0; i < 100; i++) {
+        boost::chrono::system_clock::time_point t = now + boost::chrono::microseconds(randomMsec(rng));
+        boost::chrono::system_clock::time_point tReschedule = now + boost::chrono::microseconds(500 + randomMsec(rng));
+        int whichCounter = zeroToNine(rng);
+        CScheduler::Function f = boost::bind(&microTask, boost::ref(microTasks),
+                                             boost::ref(counterMutex[whichCounter]), boost::ref(counter[whichCounter]),
+                                             randomDelta(rng), tReschedule);
+        microTasks.schedule(f, t);
+    }
+
+    // Drain the task queue then exit threads
+    microTasks.stop(true);
+    microThreads.join_all(); // ... wait until all the threads are done
+
+    int counterSum = 0;
+    for (int i = 0; i < 10; i++) {
+        BOOST_CHECK(counter[i] != 0);
+        counterSum += counter[i];
+    }
+    BOOST_CHECK_EQUAL(counterSum, 200);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/script_P2SH_tests.cpp b/script_P2SH_tests.cpp
new file mode 100644
index 0000000..3e418ce
--- /dev/null
+++ b/script_P2SH_tests.cpp
@@ -0,0 +1,369 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <consensus/tx_verify.h>
+#include <core_io.h>
+#include <key.h>
+#include <keystore.h>
+#include <validation.h>
+#include <policy/policy.h>
+#include <script/script.h>
+#include <script/script_error.h>
+#include <script/sign.h>
+#include <script/ismine.h>
+#include <test/test_salemcash.h>
+
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+// Helpers:
+static std::vector<unsigned char>
+Serialize(const CScript& s)
+{
+    std::vector<unsigned char> sSerialized(s.begin(), s.end());
+    return sSerialized;
+}
+
+static bool
+Verify(const CScript& scriptSig, const CScript& scriptPubKey, bool fStrict, ScriptError& err)
+{
+    // Create dummy to/from transactions:
+    CMutableTransaction txFrom;
+    txFrom.vout.resize(1);
+    txFrom.vout[0].scriptPubKey = scriptPubKey;
+
+    CMutableTransaction txTo;
+    txTo.vin.resize(1);
+    txTo.vout.resize(1);
+    txTo.vin[0].prevout.n = 0;
+    txTo.vin[0].prevout.hash = txFrom.GetHash();
+    txTo.vin[0].scriptSig = scriptSig;
+    txTo.vout[0].nValue = 1;
+
+    return VerifyScript(scriptSig, scriptPubKey, nullptr, fStrict ? SCRIPT_VERIFY_P2SH : SCRIPT_VERIFY_NONE, MutableTransactionSignatureChecker(&txTo, 0, txFrom.vout[0].nValue), &err);
+}
+
+
+BOOST_FIXTURE_TEST_SUITE(script_P2SH_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(sign)
+{
+    LOCK(cs_main);
+    // Pay-to-script-hash looks like this:
+    // scriptSig:    <sig> <sig...> <serialized_script>
+    // scriptPubKey: HASH160 <hash> EQUAL
+
+    // Test SignSignature() (and therefore the version of Solver() that signs transactions)
+    CBasicKeyStore keystore;
+    CKey key[4];
+    for (int i = 0; i < 4; i++)
+    {
+        key[i].MakeNewKey(true);
+        keystore.AddKey(key[i]);
+    }
+
+    // 8 Scripts: checking all combinations of
+    // different keys, straight/P2SH, pubkey/pubkeyhash
+    CScript standardScripts[4];
+    standardScripts[0] << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
+    standardScripts[1] = GetScriptForDestination(key[1].GetPubKey().GetID());
+    standardScripts[2] << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
+    standardScripts[3] = GetScriptForDestination(key[2].GetPubKey().GetID());
+    CScript evalScripts[4];
+    for (int i = 0; i < 4; i++)
+    {
+        keystore.AddCScript(standardScripts[i]);
+        evalScripts[i] = GetScriptForDestination(CScriptID(standardScripts[i]));
+    }
+
+    CMutableTransaction txFrom;  // Funding transaction:
+    std::string reason;
+    txFrom.vout.resize(8);
+    for (int i = 0; i < 4; i++)
+    {
+        txFrom.vout[i].scriptPubKey = evalScripts[i];
+        txFrom.vout[i].nValue = CASH;
+        txFrom.vout[i+4].scriptPubKey = standardScripts[i];
+        txFrom.vout[i+4].nValue = CASH;
+    }
+    BOOST_CHECK(IsStandardTx(txFrom, reason));
+
+    CMutableTransaction txTo[8]; // Spending transactions
+    for (int i = 0; i < 8; i++)
+    {
+        txTo[i].vin.resize(1);
+        txTo[i].vout.resize(1);
+        txTo[i].vin[0].prevout.n = i;
+        txTo[i].vin[0].prevout.hash = txFrom.GetHash();
+        txTo[i].vout[0].nValue = 1;
+        BOOST_CHECK_MESSAGE(IsMine(keystore, txFrom.vout[i].scriptPubKey), strprintf("IsMine %d", i));
+    }
+    for (int i = 0; i < 8; i++)
+    {
+        BOOST_CHECK_MESSAGE(SignSignature(keystore, txFrom, txTo[i], 0, SIGHASH_ALL), strprintf("SignSignature %d", i));
+    }
+    // All of the above should be OK, and the txTos have valid signatures
+    // Check to make sure signature verification fails if we use the wrong ScriptSig:
+    for (int i = 0; i < 8; i++) {
+        PrecomputedTransactionData txdata(txTo[i]);
+        for (int j = 0; j < 8; j++)
+        {
+            CScript sigSave = txTo[i].vin[0].scriptSig;
+            txTo[i].vin[0].scriptSig = txTo[j].vin[0].scriptSig;
+            bool sigOK = CScriptCheck(txFrom.vout[txTo[i].vin[0].prevout.n], txTo[i], 0, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, false, &txdata)();
+            if (i == j)
+                BOOST_CHECK_MESSAGE(sigOK, strprintf("VerifySignature %d %d", i, j));
+            else
+                BOOST_CHECK_MESSAGE(!sigOK, strprintf("VerifySignature %d %d", i, j));
+            txTo[i].vin[0].scriptSig = sigSave;
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(norecurse)
+{
+    ScriptError err;
+    // Make sure only the outer pay-to-script-hash does the
+    // extra-validation thing:
+    CScript invalidAsScript;
+    invalidAsScript << OP_INVALIDOPCODE << OP_INVALIDOPCODE;
+
+    CScript p2sh = GetScriptForDestination(CScriptID(invalidAsScript));
+
+    CScript scriptSig;
+    scriptSig << Serialize(invalidAsScript);
+
+    // Should not verify, because it will try to execute OP_INVALIDOPCODE
+    BOOST_CHECK(!Verify(scriptSig, p2sh, true, err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_BAD_OPCODE, ScriptErrorString(err));
+
+    // Try to recur, and verification should succeed because
+    // the inner HASH160 <> EQUAL should only check the hash:
+    CScript p2sh2 = GetScriptForDestination(CScriptID(p2sh));
+    CScript scriptSig2;
+    scriptSig2 << Serialize(invalidAsScript) << Serialize(p2sh);
+
+    BOOST_CHECK(Verify(scriptSig2, p2sh2, true, err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+}
+
+BOOST_AUTO_TEST_CASE(set)
+{
+    LOCK(cs_main);
+    // Test the CScript::Set* methods
+    CBasicKeyStore keystore;
+    CKey key[4];
+    std::vector<CPubKey> keys;
+    for (int i = 0; i < 4; i++)
+    {
+        key[i].MakeNewKey(true);
+        keystore.AddKey(key[i]);
+        keys.push_back(key[i].GetPubKey());
+    }
+
+    CScript inner[4];
+    inner[0] = GetScriptForDestination(key[0].GetPubKey().GetID());
+    inner[1] = GetScriptForMultisig(2, std::vector<CPubKey>(keys.begin(), keys.begin()+2));
+    inner[2] = GetScriptForMultisig(1, std::vector<CPubKey>(keys.begin(), keys.begin()+2));
+    inner[3] = GetScriptForMultisig(2, std::vector<CPubKey>(keys.begin(), keys.begin()+3));
+
+    CScript outer[4];
+    for (int i = 0; i < 4; i++)
+    {
+        outer[i] = GetScriptForDestination(CScriptID(inner[i]));
+        keystore.AddCScript(inner[i]);
+    }
+
+    CMutableTransaction txFrom;  // Funding transaction:
+    std::string reason;
+    txFrom.vout.resize(4);
+    for (int i = 0; i < 4; i++)
+    {
+        txFrom.vout[i].scriptPubKey = outer[i];
+        txFrom.vout[i].nValue = CENT;
+    }
+    BOOST_CHECK(IsStandardTx(txFrom, reason));
+
+    CMutableTransaction txTo[4]; // Spending transactions
+    for (int i = 0; i < 4; i++)
+    {
+        txTo[i].vin.resize(1);
+        txTo[i].vout.resize(1);
+        txTo[i].vin[0].prevout.n = i;
+        txTo[i].vin[0].prevout.hash = txFrom.GetHash();
+        txTo[i].vout[0].nValue = 1*CENT;
+        txTo[i].vout[0].scriptPubKey = inner[i];
+        BOOST_CHECK_MESSAGE(IsMine(keystore, txFrom.vout[i].scriptPubKey), strprintf("IsMine %d", i));
+    }
+    for (int i = 0; i < 4; i++)
+    {
+        BOOST_CHECK_MESSAGE(SignSignature(keystore, txFrom, txTo[i], 0, SIGHASH_ALL), strprintf("SignSignature %d", i));
+        BOOST_CHECK_MESSAGE(IsStandardTx(txTo[i], reason), strprintf("txTo[%d].IsStandard", i));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(is)
+{
+    // Test CScript::IsPayToScriptHash()
+    uint160 dummy;
+    CScript p2sh;
+    p2sh << OP_HASH160 << ToByteVector(dummy) << OP_EQUAL;
+    BOOST_CHECK(p2sh.IsPayToScriptHash());
+
+    // Not considered pay-to-script-hash if using one of the OP_PUSHDATA opcodes:
+    static const unsigned char direct[] =    { OP_HASH160, 20, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, OP_EQUAL };
+    BOOST_CHECK(CScript(direct, direct+sizeof(direct)).IsPayToScriptHash());
+    static const unsigned char pushdata1[] = { OP_HASH160, OP_PUSHDATA1, 20, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, OP_EQUAL };
+    BOOST_CHECK(!CScript(pushdata1, pushdata1+sizeof(pushdata1)).IsPayToScriptHash());
+    static const unsigned char pushdata2[] = { OP_HASH160, OP_PUSHDATA2, 20,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, OP_EQUAL };
+    BOOST_CHECK(!CScript(pushdata2, pushdata2+sizeof(pushdata2)).IsPayToScriptHash());
+    static const unsigned char pushdata4[] = { OP_HASH160, OP_PUSHDATA4, 20,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, OP_EQUAL };
+    BOOST_CHECK(!CScript(pushdata4, pushdata4+sizeof(pushdata4)).IsPayToScriptHash());
+
+    CScript not_p2sh;
+    BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
+
+    not_p2sh.clear(); not_p2sh << OP_HASH160 << ToByteVector(dummy) << ToByteVector(dummy) << OP_EQUAL;
+    BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
+
+    not_p2sh.clear(); not_p2sh << OP_NOP << ToByteVector(dummy) << OP_EQUAL;
+    BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
+
+    not_p2sh.clear(); not_p2sh << OP_HASH160 << ToByteVector(dummy) << OP_CHECKSIG;
+    BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
+}
+
+BOOST_AUTO_TEST_CASE(switchover)
+{
+    // Test switch over code
+    CScript notValid;
+    ScriptError err;
+    notValid << OP_11 << OP_12 << OP_EQUALVERIFY;
+    CScript scriptSig;
+    scriptSig << Serialize(notValid);
+
+    CScript fund = GetScriptForDestination(CScriptID(notValid));
+
+
+    // Validation should succeed under old rules (hash is correct):
+    BOOST_CHECK(Verify(scriptSig, fund, false, err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+    // Fail under new:
+    BOOST_CHECK(!Verify(scriptSig, fund, true, err));
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EQUALVERIFY, ScriptErrorString(err));
+}
+
+BOOST_AUTO_TEST_CASE(AreInputsStandard)
+{
+    LOCK(cs_main);
+    CCashView cashDummy;
+    CCashViewCache cash(&cashDummy);
+    CBasicKeyStore keystore;
+    CKey key[6];
+    std::vector<CPubKey> keys;
+    for (int i = 0; i < 6; i++)
+    {
+        key[i].MakeNewKey(true);
+        keystore.AddKey(key[i]);
+    }
+    for (int i = 0; i < 3; i++)
+        keys.push_back(key[i].GetPubKey());
+
+    CMutableTransaction txFrom;
+    txFrom.vout.resize(7);
+
+    // First three are standard:
+    CScript pay1 = GetScriptForDestination(key[0].GetPubKey().GetID());
+    keystore.AddCScript(pay1);
+    CScript pay1of3 = GetScriptForMultisig(1, keys);
+
+    txFrom.vout[0].scriptPubKey = GetScriptForDestination(CScriptID(pay1)); // P2SH (OP_CHECKSIG)
+    txFrom.vout[0].nValue = 1000;
+    txFrom.vout[1].scriptPubKey = pay1; // ordinary OP_CHECKSIG
+    txFrom.vout[1].nValue = 2000;
+    txFrom.vout[2].scriptPubKey = pay1of3; // ordinary OP_CHECKMULTISIG
+    txFrom.vout[2].nValue = 3000;
+
+    // vout[3] is complicated 1-of-3 AND 2-of-3
+    // ... that is OK if wrapped in P2SH:
+    CScript oneAndTwo;
+    oneAndTwo << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << ToByteVector(key[2].GetPubKey());
+    oneAndTwo << OP_3 << OP_CHECKMULTISIGVERIFY;
+    oneAndTwo << OP_2 << ToByteVector(key[3].GetPubKey()) << ToByteVector(key[4].GetPubKey()) << ToByteVector(key[5].GetPubKey());
+    oneAndTwo << OP_3 << OP_CHECKMULTISIG;
+    keystore.AddCScript(oneAndTwo);
+    txFrom.vout[3].scriptPubKey = GetScriptForDestination(CScriptID(oneAndTwo));
+    txFrom.vout[3].nValue = 4000;
+
+    // vout[4] is max sigops:
+    CScript fifteenSigops; fifteenSigops << OP_1;
+    for (unsigned i = 0; i < MAX_P2SH_SIGOPS; i++)
+        fifteenSigops << ToByteVector(key[i%3].GetPubKey());
+    fifteenSigops << OP_15 << OP_CHECKMULTISIG;
+    keystore.AddCScript(fifteenSigops);
+    txFrom.vout[4].scriptPubKey = GetScriptForDestination(CScriptID(fifteenSigops));
+    txFrom.vout[4].nValue = 5000;
+
+    // vout[5/6] are non-standard because they exceed MAX_P2SH_SIGOPS
+    CScript sixteenSigops; sixteenSigops << OP_16 << OP_CHECKMULTISIG;
+    keystore.AddCScript(sixteenSigops);
+    txFrom.vout[5].scriptPubKey = GetScriptForDestination(CScriptID(fifteenSigops));
+    txFrom.vout[5].nValue = 5000;
+    CScript twentySigops; twentySigops << OP_CHECKMULTISIG;
+    keystore.AddCScript(twentySigops);
+    txFrom.vout[6].scriptPubKey = GetScriptForDestination(CScriptID(twentySigops));
+    txFrom.vout[6].nValue = 6000;
+
+    AddCash(cash, txFrom, 0);
+
+    CMutableTransaction txTo;
+    txTo.vout.resize(1);
+    txTo.vout[0].scriptPubKey = GetScriptForDestination(key[1].GetPubKey().GetID());
+
+    txTo.vin.resize(5);
+    for (int i = 0; i < 5; i++)
+    {
+        txTo.vin[i].prevout.n = i;
+        txTo.vin[i].prevout.hash = txFrom.GetHash();
+    }
+    BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL));
+    BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 1, SIGHASH_ALL));
+    BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 2, SIGHASH_ALL));
+    // SignSignature doesn't know how to sign these. We're
+    // not testing validating signatures, so just create
+    // dummy signatures that DO include the correct P2SH scripts:
+    txTo.vin[3].scriptSig << OP_11 << OP_11 << std::vector<unsigned char>(oneAndTwo.begin(), oneAndTwo.end());
+    txTo.vin[4].scriptSig << std::vector<unsigned char>(fifteenSigops.begin(), fifteenSigops.end());
+
+    BOOST_CHECK(::AreInputsStandard(txTo, coins));
+    // 22 P2SH sigops for all inputs (1 for vin[0], 6 for vin[3], 15 for vin[4]
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(txTo, coins), 22U);
+
+    CMutableTransaction txToNonStd1;
+    txToNonStd1.vout.resize(1);
+    txToNonStd1.vout[0].scriptPubKey = GetScriptForDestination(key[1].GetPubKey().GetID());
+    txToNonStd1.vout[0].nValue = 1000;
+    txToNonStd1.vin.resize(1);
+    txToNonStd1.vin[0].prevout.n = 5;
+    txToNonStd1.vin[0].prevout.hash = txFrom.GetHash();
+    txToNonStd1.vin[0].scriptSig << std::vector<unsigned char>(sixteenSigops.begin(), sixteenSigops.end());
+
+    BOOST_CHECK(!::AreInputsStandard(txToNonStd1, coins));
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(txToNonStd1, coins), 16U);
+
+    CMutableTransaction txToNonStd2;
+    txToNonStd2.vout.resize(1);
+    txToNonStd2.vout[0].scriptPubKey = GetScriptForDestination(key[1].GetPubKey().GetID());
+    txToNonStd2.vout[0].nValue = 1000;
+    txToNonStd2.vin.resize(1);
+    txToNonStd2.vin[0].prevout.n = 6;
+    txToNonStd2.vin[0].prevout.hash = txFrom.GetHash();
+    txToNonStd2.vin[0].scriptSig << std::vector<unsigned char>(twentySigops.begin(), twentySigops.end());
+
+    BOOST_CHECK(!::AreInputsStandard(txToNonStd2, coins));
+    BOOST_CHECK_EQUAL(GetP2SHSigOpCount(txToNonStd2, coins), 20U);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/script_standard_tests.cpp b/script_standard_tests.cpp
new file mode 100644
index 0000000..c9ba7b0
--- /dev/null
+++ b/script_standard_tests.cpp
@@ -0,0 +1,736 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <key.h>
+#include <keystore.h>
+#include <script/ismine.h>
+#include <script/script.h>
+#include <script/script_error.h>
+#include <script/standard.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+BOOST_FIXTURE_TEST_SUITE(script_standard_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(script_standard_Solver_success)
+{
+    CKey keys[3];
+    CPubKey pubkeys[3];
+    for (int i = 0; i < 3; i++) {
+        keys[i].MakeNewKey(true);
+        pubkeys[i] = keys[i].GetPubKey();
+    }
+
+    CScript s;
+    txnouttype whichType;
+    std::vector<std::vector<unsigned char> > solutions;
+
+    // TX_PUBKEY
+    s.clear();
+    s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
+    BOOST_CHECK(Solver(s, whichType, solutions));
+    BOOST_CHECK_EQUAL(whichType, TX_PUBKEY);
+    BOOST_CHECK_EQUAL(solutions.size(), 1);
+    BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));
+
+    // TX_PUBKEYHASH
+    s.clear();
+    s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+    BOOST_CHECK(Solver(s, whichType, solutions));
+    BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH);
+    BOOST_CHECK_EQUAL(solutions.size(), 1);
+    BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
+
+    // TX_SCRIPTHASH
+    CScript redeemScript(s); // initialize with leftover P2PKH script
+    s.clear();
+    s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
+    BOOST_CHECK(Solver(s, whichType, solutions));
+    BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH);
+    BOOST_CHECK_EQUAL(solutions.size(), 1);
+    BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));
+
+    // TX_MULTISIG
+    s.clear();
+    s << OP_1 <<
+        ToByteVector(pubkeys[0]) <<
+        ToByteVector(pubkeys[1]) <<
+        OP_2 << OP_CHECKMULTISIG;
+    BOOST_CHECK(Solver(s, whichType, solutions));
+    BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
+    BOOST_CHECK_EQUAL(solutions.size(), 4);
+    BOOST_CHECK(solutions[0] == std::vector<unsigned char>({1}));
+    BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
+    BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
+    BOOST_CHECK(solutions[3] == std::vector<unsigned char>({2}));
+
+    s.clear();
+    s << OP_2 <<
+        ToByteVector(pubkeys[0]) <<
+        ToByteVector(pubkeys[1]) <<
+        ToByteVector(pubkeys[2]) <<
+        OP_3 << OP_CHECKMULTISIG;
+    BOOST_CHECK(Solver(s, whichType, solutions));
+    BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
+    BOOST_CHECK_EQUAL(solutions.size(), 5);
+    BOOST_CHECK(solutions[0] == std::vector<unsigned char>({2}));
+    BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
+    BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
+    BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
+    BOOST_CHECK(solutions[4] == std::vector<unsigned char>({3}));
+
+    // TX_NULL_DATA
+    s.clear();
+    s << OP_RETURN <<
+        std::vector<unsigned char>({0}) <<
+        std::vector<unsigned char>({75}) <<
+        std::vector<unsigned char>({255});
+    BOOST_CHECK(Solver(s, whichType, solutions));
+    BOOST_CHECK_EQUAL(whichType, TX_NULL_DATA);
+    BOOST_CHECK_EQUAL(solutions.size(), 0);
+
+    // TX_WITNESS_V0_KEYHASH
+    s.clear();
+    s << OP_0 << ToByteVector(pubkeys[0].GetID());
+    BOOST_CHECK(Solver(s, whichType, solutions));
+    BOOST_CHECK_EQUAL(whichType, TX_WITNESS_V0_KEYHASH);
+    BOOST_CHECK_EQUAL(solutions.size(), 1);
+    BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
+
+    // TX_WITNESS_V0_SCRIPTHASH
+    uint256 scriptHash;
+    CSHA256().Write(&redeemScript[0], redeemScript.size())
+        .Finalize(scriptHash.begin());
+
+    s.clear();
+    s << OP_0 << ToByteVector(scriptHash);
+    BOOST_CHECK(Solver(s, whichType, solutions));
+    BOOST_CHECK_EQUAL(whichType, TX_WITNESS_V0_SCRIPTHASH);
+    BOOST_CHECK_EQUAL(solutions.size(), 1);
+    BOOST_CHECK(solutions[0] == ToByteVector(scriptHash));
+
+    // TX_NONSTANDARD
+    s.clear();
+    s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
+    BOOST_CHECK(!Solver(s, whichType, solutions));
+    BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
+}
+
+BOOST_AUTO_TEST_CASE(script_standard_Solver_failure)
+{
+    CKey key;
+    CPubKey pubkey;
+    key.MakeNewKey(true);
+    pubkey = key.GetPubKey();
+
+    CScript s;
+    txnouttype whichType;
+    std::vector<std::vector<unsigned char> > solutions;
+
+    // TX_PUBKEY with incorrectly sized pubkey
+    s.clear();
+    s << std::vector<unsigned char>(30, 0x01) << OP_CHECKSIG;
+    BOOST_CHECK(!Solver(s, whichType, solutions));
+
+    // TX_PUBKEYHASH with incorrectly sized key hash
+    s.clear();
+    s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY << OP_CHECKSIG;
+    BOOST_CHECK(!Solver(s, whichType, solutions));
+
+    // TX_SCRIPTHASH with incorrectly sized script hash
+    s.clear();
+    s << OP_HASH160 << std::vector<unsigned char>(21, 0x01) << OP_EQUAL;
+    BOOST_CHECK(!Solver(s, whichType, solutions));
+
+    // TX_MULTISIG 0/2
+    s.clear();
+    s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
+    BOOST_CHECK(!Solver(s, whichType, solutions));
+
+    // TX_MULTISIG 2/1
+    s.clear();
+    s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
+    BOOST_CHECK(!Solver(s, whichType, solutions));
+
+    // TX_MULTISIG n = 2 with 1 pubkey
+    s.clear();
+    s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
+    BOOST_CHECK(!Solver(s, whichType, solutions));
+
+    // TX_MULTISIG n = 1 with 0 pubkeys
+    s.clear();
+    s << OP_1 << OP_1 << OP_CHECKMULTISIG;
+    BOOST_CHECK(!Solver(s, whichType, solutions));
+
+    // TX_NULL_DATA with other opcodes
+    s.clear();
+    s << OP_RETURN << std::vector<unsigned char>({75}) << OP_ADD;
+    BOOST_CHECK(!Solver(s, whichType, solutions));
+
+    // TX_WITNESS with incorrect program size
+    s.clear();
+    s << OP_0 << std::vector<unsigned char>(19, 0x01);
+    BOOST_CHECK(!Solver(s, whichType, solutions));
+}
+
+BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
+{
+    CKey key;
+    CPubKey pubkey;
+    key.MakeNewKey(true);
+    pubkey = key.GetPubKey();
+
+    CScript s;
+    CTxDestination address;
+
+    // TX_PUBKEY
+    s.clear();
+    s << ToByteVector(pubkey) << OP_CHECKSIG;
+    BOOST_CHECK(ExtractDestination(s, address));
+    BOOST_CHECK(boost::get<CKeyID>(&address) &&
+                *boost::get<CKeyID>(&address) == pubkey.GetID());
+
+    // TX_PUBKEYHASH
+    s.clear();
+    s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+    BOOST_CHECK(ExtractDestination(s, address));
+    BOOST_CHECK(boost::get<CKeyID>(&address) &&
+                *boost::get<CKeyID>(&address) == pubkey.GetID());
+
+    // TX_SCRIPTHASH
+    CScript redeemScript(s); // initialize with leftover P2PKH script
+    s.clear();
+    s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
+    BOOST_CHECK(ExtractDestination(s, address));
+    BOOST_CHECK(boost::get<CScriptID>(&address) &&
+                *boost::get<CScriptID>(&address) == CScriptID(redeemScript));
+
+    // TX_MULTISIG
+    s.clear();
+    s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
+    BOOST_CHECK(!ExtractDestination(s, address));
+
+    // TX_NULL_DATA
+    s.clear();
+    s << OP_RETURN << std::vector<unsigned char>({75});
+    BOOST_CHECK(!ExtractDestination(s, address));
+
+    // TX_WITNESS_V0_KEYHASH
+    s.clear();
+    s << OP_0 << ToByteVector(pubkey.GetID());
+    BOOST_CHECK(ExtractDestination(s, address));
+    WitnessV0KeyHash keyhash;
+    CHash160().Write(pubkey.begin(), pubkey.size()).Finalize(keyhash.begin());
+    BOOST_CHECK(boost::get<WitnessV0KeyHash>(&address) && *boost::get<WitnessV0KeyHash>(&address) == keyhash);
+
+    // TX_WITNESS_V0_SCRIPTHASH
+    s.clear();
+    WitnessV0ScriptHash scripthash;
+    CSHA256().Write(redeemScript.data(), redeemScript.size()).Finalize(scripthash.begin());
+    s << OP_0 << ToByteVector(scripthash);
+    BOOST_CHECK(ExtractDestination(s, address));
+    BOOST_CHECK(boost::get<WitnessV0ScriptHash>(&address) && *boost::get<WitnessV0ScriptHash>(&address) == scripthash);
+
+    // TX_WITNESS with unknown version
+    s.clear();
+    s << OP_1 << ToByteVector(pubkey);
+    BOOST_CHECK(ExtractDestination(s, address));
+    WitnessUnknown unk;
+    unk.length = 33;
+    unk.version = 1;
+    std::copy(pubkey.begin(), pubkey.end(), unk.program);
+    BOOST_CHECK(boost::get<WitnessUnknown>(&address) && *boost::get<WitnessUnknown>(&address) == unk);
+}
+
+BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
+{
+    CKey keys[3];
+    CPubKey pubkeys[3];
+    for (int i = 0; i < 3; i++) {
+        keys[i].MakeNewKey(true);
+        pubkeys[i] = keys[i].GetPubKey();
+    }
+
+    CScript s;
+    txnouttype whichType;
+    std::vector<CTxDestination> addresses;
+    int nRequired;
+
+    // TX_PUBKEY
+    s.clear();
+    s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
+    BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
+    BOOST_CHECK_EQUAL(whichType, TX_PUBKEY);
+    BOOST_CHECK_EQUAL(addresses.size(), 1);
+    BOOST_CHECK_EQUAL(nRequired, 1);
+    BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
+                *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
+
+    // TX_PUBKEYHASH
+    s.clear();
+    s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+    BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
+    BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH);
+    BOOST_CHECK_EQUAL(addresses.size(), 1);
+    BOOST_CHECK_EQUAL(nRequired, 1);
+    BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
+                *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
+
+    // TX_SCRIPTHASH
+    CScript redeemScript(s); // initialize with leftover P2PKH script
+    s.clear();
+    s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
+    BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
+    BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH);
+    BOOST_CHECK_EQUAL(addresses.size(), 1);
+    BOOST_CHECK_EQUAL(nRequired, 1);
+    BOOST_CHECK(boost::get<CScriptID>(&addresses[0]) &&
+                *boost::get<CScriptID>(&addresses[0]) == CScriptID(redeemScript));
+
+    // TX_MULTISIG
+    s.clear();
+    s << OP_2 <<
+        ToByteVector(pubkeys[0]) <<
+        ToByteVector(pubkeys[1]) <<
+        OP_2 << OP_CHECKMULTISIG;
+    BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
+    BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
+    BOOST_CHECK_EQUAL(addresses.size(), 2);
+    BOOST_CHECK_EQUAL(nRequired, 2);
+    BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
+                *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
+    BOOST_CHECK(boost::get<CKeyID>(&addresses[1]) &&
+                *boost::get<CKeyID>(&addresses[1]) == pubkeys[1].GetID());
+
+    // TX_NULL_DATA
+    s.clear();
+    s << OP_RETURN << std::vector<unsigned char>({75});
+    BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
+}
+
+BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_)
+{
+    CKey keys[3];
+    CPubKey pubkeys[3];
+    for (int i = 0; i < 3; i++) {
+        keys[i].MakeNewKey(true);
+        pubkeys[i] = keys[i].GetPubKey();
+    }
+
+    CScript expected, result;
+
+    // CKeyID
+    expected.clear();
+    expected << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+    result = GetScriptForDestination(pubkeys[0].GetID());
+    BOOST_CHECK(result == expected);
+
+    // CScriptID
+    CScript redeemScript(result);
+    expected.clear();
+    expected << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
+    result = GetScriptForDestination(CScriptID(redeemScript));
+    BOOST_CHECK(result == expected);
+
+    // CNoDestination
+    expected.clear();
+    result = GetScriptForDestination(CNoDestination());
+    BOOST_CHECK(result == expected);
+
+    // GetScriptForRawPubKey
+    expected.clear();
+    expected << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
+    result = GetScriptForRawPubKey(pubkeys[0]);
+    BOOST_CHECK(result == expected);
+
+    // GetScriptForMultisig
+    expected.clear();
+    expected << OP_2 <<
+        ToByteVector(pubkeys[0]) <<
+        ToByteVector(pubkeys[1]) <<
+        ToByteVector(pubkeys[2]) <<
+        OP_3 << OP_CHECKMULTISIG;
+    result = GetScriptForMultisig(2, std::vector<CPubKey>(pubkeys, pubkeys + 3));
+    BOOST_CHECK(result == expected);
+
+    // GetScriptForWitness
+    CScript witnessScript;
+
+    witnessScript << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
+    expected.clear();
+    expected << OP_0 << ToByteVector(pubkeys[0].GetID());
+    result = GetScriptForWitness(witnessScript);
+    BOOST_CHECK(result == expected);
+
+    witnessScript.clear();
+    witnessScript << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+    result = GetScriptForWitness(witnessScript);
+    BOOST_CHECK(result == expected);
+
+    witnessScript.clear();
+    witnessScript << OP_1 << ToByteVector(pubkeys[0]) << OP_1 << OP_CHECKMULTISIG;
+
+    uint256 scriptHash;
+    CSHA256().Write(&witnessScript[0], witnessScript.size())
+        .Finalize(scriptHash.begin());
+
+    expected.clear();
+    expected << OP_0 << ToByteVector(scriptHash);
+    result = GetScriptForWitness(witnessScript);
+    BOOST_CHECK(result == expected);
+}
+
+BOOST_AUTO_TEST_CASE(script_standard_IsMine)
+{
+    CKey keys[2];
+    CPubKey pubkeys[2];
+    for (int i = 0; i < 2; i++) {
+        keys[i].MakeNewKey(true);
+        pubkeys[i] = keys[i].GetPubKey();
+    }
+
+    CKey uncompressedKey;
+    uncompressedKey.MakeNewKey(false);
+    CPubKey uncompressedPubkey = uncompressedKey.GetPubKey();
+
+    CScript scriptPubKey;
+    isminetype result;
+    bool isInvalid;
+
+    // P2PK compressed
+    {
+        CBasicKeyStore keystore;
+        scriptPubKey.clear();
+        scriptPubKey << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
+
+        // Keystore does not have key
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has key
+        keystore.AddKey(keys[0]);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // P2PK uncompressed
+    {
+        CBasicKeyStore keystore;
+        scriptPubKey.clear();
+        scriptPubKey << ToByteVector(uncompressedPubkey) << OP_CHECKSIG;
+
+        // Keystore does not have key
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has key
+        keystore.AddKey(uncompressedKey);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // P2PKH compressed
+    {
+        CBasicKeyStore keystore;
+        scriptPubKey.clear();
+        scriptPubKey << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+
+        // Keystore does not have key
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has key
+        keystore.AddKey(keys[0]);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // P2PKH uncompressed
+    {
+        CBasicKeyStore keystore;
+        scriptPubKey.clear();
+        scriptPubKey << OP_DUP << OP_HASH160 << ToByteVector(uncompressedPubkey.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+
+        // Keystore does not have key
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has key
+        keystore.AddKey(uncompressedKey);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // P2SH
+    {
+        CBasicKeyStore keystore;
+
+        CScript redeemScript;
+        redeemScript << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
+
+        // Keystore does not have redeemScript or key
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has redeemScript but no key
+        keystore.AddCScript(redeemScript);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has redeemScript and key
+        keystore.AddKey(keys[0]);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // P2WPKH compressed
+    {
+        CBasicKeyStore keystore;
+        keystore.AddKey(keys[0]);
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_0 << ToByteVector(pubkeys[0].GetID());
+
+        // Keystore implicitly has key and P2SH redeemScript
+        keystore.AddCScript(scriptPubKey);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // P2WPKH uncompressed
+    {
+        CBasicKeyStore keystore;
+        keystore.AddKey(uncompressedKey);
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_0 << ToByteVector(uncompressedPubkey.GetID());
+
+        // Keystore has key, but no P2SH redeemScript
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has key and P2SH redeemScript
+        keystore.AddCScript(scriptPubKey);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(isInvalid);
+    }
+
+    // scriptPubKey multisig
+    {
+        CBasicKeyStore keystore;
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_2 <<
+            ToByteVector(uncompressedPubkey) <<
+            ToByteVector(pubkeys[1]) <<
+            OP_2 << OP_CHECKMULTISIG;
+
+        // Keystore does not have any keys
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has 1/2 keys
+        keystore.AddKey(uncompressedKey);
+
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has 2/2 keys
+        keystore.AddKey(keys[1]);
+
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // P2SH multisig
+    {
+        CBasicKeyStore keystore;
+        keystore.AddKey(uncompressedKey);
+        keystore.AddKey(keys[1]);
+
+        CScript redeemScript;
+        redeemScript << OP_2 <<
+            ToByteVector(uncompressedPubkey) <<
+            ToByteVector(pubkeys[1]) <<
+            OP_2 << OP_CHECKMULTISIG;
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
+
+        // Keystore has no redeemScript
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has redeemScript
+        keystore.AddCScript(redeemScript);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // P2WSH multisig with compressed keys
+    {
+        CBasicKeyStore keystore;
+        keystore.AddKey(keys[0]);
+        keystore.AddKey(keys[1]);
+
+        CScript witnessScript;
+        witnessScript << OP_2 <<
+            ToByteVector(pubkeys[0]) <<
+            ToByteVector(pubkeys[1]) <<
+            OP_2 << OP_CHECKMULTISIG;
+
+        uint256 scriptHash;
+        CSHA256().Write(&witnessScript[0], witnessScript.size())
+            .Finalize(scriptHash.begin());
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_0 << ToByteVector(scriptHash);
+
+        // Keystore has keys, but no witnessScript or P2SH redeemScript
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has keys and witnessScript, but no P2SH redeemScript
+        keystore.AddCScript(witnessScript);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has keys, witnessScript, P2SH redeemScript
+        keystore.AddCScript(scriptPubKey);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // P2WSH multisig with uncompressed key
+    {
+        CBasicKeyStore keystore;
+        keystore.AddKey(uncompressedKey);
+        keystore.AddKey(keys[1]);
+
+        CScript witnessScript;
+        witnessScript << OP_2 <<
+            ToByteVector(uncompressedPubkey) <<
+            ToByteVector(pubkeys[1]) <<
+            OP_2 << OP_CHECKMULTISIG;
+
+        uint256 scriptHash;
+        CSHA256().Write(&witnessScript[0], witnessScript.size())
+            .Finalize(scriptHash.begin());
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_0 << ToByteVector(scriptHash);
+
+        // Keystore has keys, but no witnessScript or P2SH redeemScript
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has keys and witnessScript, but no P2SH redeemScript
+        keystore.AddCScript(witnessScript);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has keys, witnessScript, P2SH redeemScript
+        keystore.AddCScript(scriptPubKey);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(isInvalid);
+    }
+
+    // P2WSH multisig wrapped in P2SH
+    {
+        CBasicKeyStore keystore;
+
+        CScript witnessScript;
+        witnessScript << OP_2 <<
+            ToByteVector(pubkeys[0]) <<
+            ToByteVector(pubkeys[1]) <<
+            OP_2 << OP_CHECKMULTISIG;
+
+        uint256 scriptHash;
+        CSHA256().Write(&witnessScript[0], witnessScript.size())
+            .Finalize(scriptHash.begin());
+
+        CScript redeemScript;
+        redeemScript << OP_0 << ToByteVector(scriptHash);
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
+
+        // Keystore has no witnessScript, P2SH redeemScript, or keys
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has witnessScript and P2SH redeemScript, but no keys
+        keystore.AddCScript(redeemScript);
+        keystore.AddCScript(witnessScript);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has keys, witnessScript, P2SH redeemScript
+        keystore.AddKey(keys[0]);
+        keystore.AddKey(keys[1]);
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // OP_RETURN
+    {
+        CBasicKeyStore keystore;
+        keystore.AddKey(keys[0]);
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_RETURN << ToByteVector(pubkeys[0]);
+
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+    }
+
+    // Nonstandard
+    {
+        CBasicKeyStore keystore;
+        keystore.AddKey(keys[0]);
+
+        scriptPubKey.clear();
+        scriptPubKey << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
+
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/script_tests.cpp b/script_tests.cpp
new file mode 100644
index 0000000..71af9b9
--- /dev/null
+++ b/script_tests.cpp
@@ -0,0 +1,1482 @@
+// Copyright (c) 2018 The SalemCash 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 <keystore.h>
+#include <script/script.h>
+#include <script/script_error.h>
+#include <script/sign.h>
+#include <util.h>
+#include <utilstrencodings.h>
+#include <test/test_salemcash.h>
+#include <rpc/server.h>
+
+#if defined(HAVE_CONSENSUS_LIB)
+#include <script/salemcashconsensus.h>
+#endif
+
+#include <fstream>
+#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"},
+};
+
+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 "";
+}
+
+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 CMutableTransaction& 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;
+    CMutableTransaction 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 & salemcashconsensus_SCRIPT_FLAGS_VERIFY_ALL;
+    if (libconsensus_flags == flags) {
+        if (flags & salemcashconsensus_SCRIPT_FLAGS_VERIFY_WITNESS) {
+            BOOST_CHECK_MESSAGE(salemcashconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), txCredit.vout[0].nValue, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect, message);
+        } else {
+            BOOST_CHECK_MESSAGE(salemcashconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), 0, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect, message);
+            BOOST_CHECK_MESSAGE(salemcashconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect,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 WitnessMode {
+    WITNESS_NONE,
+    WITNESS_PKH,
+    WITNESS_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 = WITNESS_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 == WITNESS_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 == WITNESS_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, 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, WITNESS_SH,
+                                0, 1).PushWitSig(keys.key0).PushWitRedeem());
+    tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0),
+                                "Basic P2WPKH", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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, WITNESS_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()));
+        }
+    }
+
+    std::string strGen;
+
+    for (TestBuilder& test : tests) {
+        test.Test();
+        std::string str = JSONPrettyPrint(test.GetJSON());
+#ifndef UPDATE_JSON_TESTS
+        if (tests_set.count(str) == 0) {
+            BOOST_CHECK_MESSAGE(false, "Missing auto script_valid test: " + test.GetComment());
+        }
+#endif
+        strGen += str + ",\n";
+    }
+
+#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[0], &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[0], &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[0], &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[0], &pushdata4[sizeof(pushdata4)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SIGVERSION_BASE, &err));
+    BOOST_CHECK(pushdata4Stack == directStack);
+    BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+}
+
+CScript
+sign_multisig(CScript scriptPubKey, std::vector<CKey> keys, 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;
+}
+CScript
+sign_multisig(CScript scriptPubKey, const CKey &key, 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;
+
+    CMutableTransaction txFrom12 = BuildCreditingTransaction(scriptPubKey12);
+    CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom12);
+
+    CScript goodsig1 = sign_multisig(scriptPubKey12, key1, 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, 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, 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;
+
+    CMutableTransaction 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, 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, 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, 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, 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, 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, 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, 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, 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, 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));
+}
+
+BOOST_AUTO_TEST_CASE(script_combineSigs)
+{
+    // Test the CombineSignatures function
+    CAmount amount = 0;
+    CBasicKeyStore 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());
+        keystore.AddKey(key);
+    }
+
+    CMutableTransaction txFrom = BuildCreditingTransaction(GetScriptForDestination(keys[0].GetPubKey().GetID()));
+    CMutableTransaction txTo = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom);
+    CScript& scriptPubKey = txFrom.vout[0].scriptPubKey;
+    CScript& scriptSig = txTo.vin[0].scriptSig;
+
+    SignatureData empty;
+    SignatureData combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), empty, empty);
+    BOOST_CHECK(combined.scriptSig.empty());
+
+    // Single signature case:
+    SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL); // changes scriptSig
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSig), empty);
+    BOOST_CHECK(combined.scriptSig == scriptSig);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), empty, SignatureData(scriptSig));
+    BOOST_CHECK(combined.scriptSig == scriptSig);
+    CScript scriptSigCopy = scriptSig;
+    // Signing again will give a different, valid signature:
+    SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSigCopy), SignatureData(scriptSig));
+    BOOST_CHECK(combined.scriptSig == scriptSigCopy || combined.scriptSig == scriptSig);
+
+    // P2SH, single-signature case:
+    CScript pkSingle; pkSingle << ToByteVector(keys[0].GetPubKey()) << OP_CHECKSIG;
+    keystore.AddCScript(pkSingle);
+    scriptPubKey = GetScriptForDestination(CScriptID(pkSingle));
+    SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSig), empty);
+    BOOST_CHECK(combined.scriptSig == scriptSig);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), empty, SignatureData(scriptSig));
+    BOOST_CHECK(combined.scriptSig == scriptSig);
+    scriptSigCopy = scriptSig;
+    SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSigCopy), SignatureData(scriptSig));
+    BOOST_CHECK(combined.scriptSig == scriptSigCopy || combined.scriptSig == scriptSig);
+    // dummy scriptSigCopy with placeholder, should always choose non-placeholder:
+    scriptSigCopy = CScript() << OP_0 << std::vector<unsigned char>(pkSingle.begin(), pkSingle.end());
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSigCopy), SignatureData(scriptSig));
+    BOOST_CHECK(combined.scriptSig == scriptSig);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSig), SignatureData(scriptSigCopy));
+    BOOST_CHECK(combined.scriptSig == scriptSig);
+
+    // Hardest case:  Multisig 2-of-3
+    scriptPubKey = GetScriptForMultisig(2, pubkeys);
+    keystore.AddCScript(scriptPubKey);
+    SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(scriptSig), empty);
+    BOOST_CHECK(combined.scriptSig == scriptSig);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), empty, SignatureData(scriptSig));
+    BOOST_CHECK(combined.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;
+
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial1a), SignatureData(partial1b));
+    BOOST_CHECK(combined.scriptSig == partial1a);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial1a), SignatureData(partial2a));
+    BOOST_CHECK(combined.scriptSig == complete12);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial2a), SignatureData(partial1a));
+    BOOST_CHECK(combined.scriptSig == complete12);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial1b), SignatureData(partial2b));
+    BOOST_CHECK(combined.scriptSig == complete12);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial3b), SignatureData(partial1b));
+    BOOST_CHECK(combined.scriptSig == complete13);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial2a), SignatureData(partial3a));
+    BOOST_CHECK(combined.scriptSig == complete23);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial3b), SignatureData(partial2b));
+    BOOST_CHECK(combined.scriptSig == complete23);
+    combined = CombineSignatures(scriptPubKey, MutableTransactionSignatureChecker(&txTo, 0, amount), SignatureData(partial3b), SignatureData(partial3a));
+    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(s.FindAndDelete(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(s.FindAndDelete(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(s.FindAndDelete(d), 4);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("0302ff03"); // PUSH 0x02ff03 onto stack
+    d = ScriptFromHex("0302ff03");
+    expect = CScript();
+    BOOST_CHECK_EQUAL(s.FindAndDelete(d), 1);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("0302ff030302ff03"); // PUSH 0x2ff03 PUSH 0x2ff03
+    d = ScriptFromHex("0302ff03");
+    expect = CScript();
+    BOOST_CHECK_EQUAL(s.FindAndDelete(d), 2);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("0302ff030302ff03");
+    d = ScriptFromHex("02");
+    expect = s; // FindAndDelete matches entire opcodes
+    BOOST_CHECK_EQUAL(s.FindAndDelete(d), 0);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("0302ff030302ff03");
+    d = ScriptFromHex("ff");
+    expect = s;
+    BOOST_CHECK_EQUAL(s.FindAndDelete(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(s.FindAndDelete(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(s.FindAndDelete(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(s.FindAndDelete(d), 1);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("516902feed5169");
+    d = ScriptFromHex("feed51");
+    expect = s;
+    BOOST_CHECK_EQUAL(s.FindAndDelete(d), 0);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("516902feed5169");
+    d = ScriptFromHex("02feed51");
+    expect = ScriptFromHex("516969");
+    BOOST_CHECK_EQUAL(s.FindAndDelete(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(s.FindAndDelete(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(s.FindAndDelete(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(s.FindAndDelete(d), 1);
+    BOOST_CHECK(s == expect);
+
+    s = ScriptFromHex("0003feed");
+    d = ScriptFromHex("00");
+    expect = ScriptFromHex("03feed");
+    BOOST_CHECK_EQUAL(s.FindAndDelete(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);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/scriptnum10.h b/scriptnum10.h
new file mode 100644
index 0000000..37c44ee
--- /dev/null
+++ b/scriptnum10.h
@@ -0,0 +1,182 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef SALEMCASH_TEST_SCRIPTNUM10_H
+#define SALEMCASH_TEST_SCRIPTNUM10_H
+
+#include <algorithm>
+#include <limits>
+#include <stdexcept>
+#include <stdint.h>
+#include <string>
+#include <vector>
+#include <assert.h>
+
+class scriptnum10_error : public std::runtime_error
+{
+public:
+    explicit scriptnum10_error(const std::string& str) : std::runtime_error(str) {}
+};
+
+class CScriptNum10
+{
+/**
+ * The ScriptNum implementation from SalemCash 0.10.0, for cross-comparison.
+ */
+public:
+
+    explicit CScriptNum10(const int64_t& n)
+    {
+        m_value = n;
+    }
+
+    static const size_t nDefaultMaxNumSize = 4;
+
+    explicit CScriptNum10(const std::vector<unsigned char>& vch, bool fRequireMinimal,
+                        const size_t nMaxNumSize = nDefaultMaxNumSize)
+    {
+        if (vch.size() > nMaxNumSize) {
+            throw scriptnum10_error("script number overflow");
+        }
+        if (fRequireMinimal && vch.size() > 0) {
+            // Check that the number is encoded with the minimum possible
+            // number of bytes.
+            //
+            // If the most-significant-byte - excluding the sign bit - is zero
+            // then we're not minimal. Note how this test also rejects the
+            // negative-zero encoding, 0x80.
+            if ((vch.back() & 0x7f) == 0) {
+                // One exception: if there's more than one byte and the most
+                // significant bit of the second-most-significant-byte is set
+                // it would conflict with the sign bit. An example of this case
+                // is +-255, which encode to 0xff00 and 0xff80 respectively.
+                // (big-endian).
+                if (vch.size() <= 1 || (vch[vch.size() - 2] & 0x80) == 0) {
+                    throw scriptnum10_error("non-minimally encoded script number");
+                }
+            }
+        }
+        m_value = set_vch(vch);
+    }
+
+    inline bool operator==(const int64_t& rhs) const    { return m_value == rhs; }
+    inline bool operator!=(const int64_t& rhs) const    { return m_value != rhs; }
+    inline bool operator<=(const int64_t& rhs) const    { return m_value <= rhs; }
+    inline bool operator< (const int64_t& rhs) const    { return m_value <  rhs; }
+    inline bool operator>=(const int64_t& rhs) const    { return m_value >= rhs; }
+    inline bool operator> (const int64_t& rhs) const    { return m_value >  rhs; }
+
+    inline bool operator==(const CScriptNum10& rhs) const { return operator==(rhs.m_value); }
+    inline bool operator!=(const CScriptNum10& rhs) const { return operator!=(rhs.m_value); }
+    inline bool operator<=(const CScriptNum10& rhs) const { return operator<=(rhs.m_value); }
+    inline bool operator< (const CScriptNum10& rhs) const { return operator< (rhs.m_value); }
+    inline bool operator>=(const CScriptNum10& rhs) const { return operator>=(rhs.m_value); }
+    inline bool operator> (const CScriptNum10& rhs) const { return operator> (rhs.m_value); }
+
+    inline CScriptNum10 operator+(   const int64_t& rhs)    const { return CScriptNum10(m_value + rhs);}
+    inline CScriptNum10 operator-(   const int64_t& rhs)    const { return CScriptNum10(m_value - rhs);}
+    inline CScriptNum10 operator+(   const CScriptNum10& rhs) const { return operator+(rhs.m_value);   }
+    inline CScriptNum10 operator-(   const CScriptNum10& rhs) const { return operator-(rhs.m_value);   }
+
+    inline CScriptNum10& operator+=( const CScriptNum10& rhs)       { return operator+=(rhs.m_value);  }
+    inline CScriptNum10& operator-=( const CScriptNum10& rhs)       { return operator-=(rhs.m_value);  }
+
+    inline CScriptNum10 operator-()                         const
+    {
+        assert(m_value != std::numeric_limits<int64_t>::min());
+        return CScriptNum10(-m_value);
+    }
+
+    inline CScriptNum10& operator=( const int64_t& rhs)
+    {
+        m_value = rhs;
+        return *this;
+    }
+
+    inline CScriptNum10& operator+=( const int64_t& rhs)
+    {
+        assert(rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) ||
+                           (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs));
+        m_value += rhs;
+        return *this;
+    }
+
+    inline CScriptNum10& operator-=( const int64_t& rhs)
+    {
+        assert(rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) ||
+                           (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs));
+        m_value -= rhs;
+        return *this;
+    }
+
+    int getint() const
+    {
+        if (m_value > std::numeric_limits<int>::max())
+            return std::numeric_limits<int>::max();
+        else if (m_value < std::numeric_limits<int>::min())
+            return std::numeric_limits<int>::min();
+        return m_value;
+    }
+
+    std::vector<unsigned char> getvch() const
+    {
+        return serialize(m_value);
+    }
+
+    static std::vector<unsigned char> serialize(const int64_t& value)
+    {
+        if(value == 0)
+            return std::vector<unsigned char>();
+
+        std::vector<unsigned char> result;
+        const bool neg = value < 0;
+        uint64_t absvalue = neg ? -value : value;
+
+        while(absvalue)
+        {
+            result.push_back(absvalue & 0xff);
+            absvalue >>= 8;
+        }
+
+//    - If the most significant byte is >= 0x80 and the value is positive, push a
+//    new zero-byte to make the significant byte < 0x80 again.
+
+//    - If the most significant byte is >= 0x80 and the value is negative, push a
+//    new 0x80 byte that will be popped off when converting to an integral.
+
+//    - If the most significant byte is < 0x80 and the value is negative, add
+//    0x80 to it, since it will be subtracted and interpreted as a negative when
+//    converting to an integral.
+
+        if (result.back() & 0x80)
+            result.push_back(neg ? 0x80 : 0);
+        else if (neg)
+            result.back() |= 0x80;
+
+        return result;
+    }
+
+private:
+    static int64_t set_vch(const std::vector<unsigned char>& vch)
+    {
+      if (vch.empty())
+          return 0;
+
+      int64_t result = 0;
+      for (size_t i = 0; i != vch.size(); ++i)
+          result |= static_cast<int64_t>(vch[i]) << 8*i;
+
+      // If the input vector's most significant byte is 0x80, remove it from
+      // the result's msb and return a negative.
+      if (vch.back() & 0x80)
+          return -((int64_t)(result & ~(0x80ULL << (8 * (vch.size() - 1)))));
+
+      return result;
+    }
+
+    int64_t m_value;
+};
+
+
+#endif // SALEMCASH_TEST_BIGNUM_H
diff --git a/scriptnum_tests.cpp b/scriptnum_tests.cpp
new file mode 100644
index 0000000..8c22bec
--- /dev/null
+++ b/scriptnum_tests.cpp
@@ -0,0 +1,200 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/scriptnum10.h>
+#include <script/script.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+#include <limits.h>
+#include <stdint.h>
+
+BOOST_FIXTURE_TEST_SUITE(scriptnum_tests, BasicTestingSetup)
+
+/** A selection of numbers that do not trigger int64_t overflow
+ *  when added/subtracted. */
+static const int64_t values[] = { 0, 1, -2, 127, 128, -255, 256, (1LL << 15) - 1, -(1LL << 16), (1LL << 24) - 1, (1LL << 31), 1 - (1LL << 32), 1LL << 40 };
+
+static const int64_t offsets[] = { 1, 0x79, 0x80, 0x81, 0xFF, 0x7FFF, 0x8000, 0xFFFF, 0x10000};
+
+static bool verify(const CScriptNum10& bignum, const CScriptNum& scriptnum)
+{
+    return bignum.getvch() == scriptnum.getvch() && bignum.getint() == scriptnum.getint();
+}
+
+static void CheckCreateVch(const int64_t& num)
+{
+    CScriptNum10 bignum(num);
+    CScriptNum scriptnum(num);
+    BOOST_CHECK(verify(bignum, scriptnum));
+
+    CScriptNum10 bignum2(bignum.getvch(), false);
+    CScriptNum scriptnum2(scriptnum.getvch(), false);
+    BOOST_CHECK(verify(bignum2, scriptnum2));
+
+    CScriptNum10 bignum3(scriptnum2.getvch(), false);
+    CScriptNum scriptnum3(bignum2.getvch(), false);
+    BOOST_CHECK(verify(bignum3, scriptnum3));
+}
+
+static void CheckCreateInt(const int64_t& num)
+{
+    CScriptNum10 bignum(num);
+    CScriptNum scriptnum(num);
+    BOOST_CHECK(verify(bignum, scriptnum));
+    BOOST_CHECK(verify(CScriptNum10(bignum.getint()), CScriptNum(scriptnum.getint())));
+    BOOST_CHECK(verify(CScriptNum10(scriptnum.getint()), CScriptNum(bignum.getint())));
+    BOOST_CHECK(verify(CScriptNum10(CScriptNum10(scriptnum.getint()).getint()), CScriptNum(CScriptNum(bignum.getint()).getint())));
+}
+
+
+static void CheckAdd(const int64_t& num1, const int64_t& num2)
+{
+    const CScriptNum10 bignum1(num1);
+    const CScriptNum10 bignum2(num2);
+    const CScriptNum scriptnum1(num1);
+    const CScriptNum scriptnum2(num2);
+    CScriptNum10 bignum3(num1);
+    CScriptNum10 bignum4(num1);
+    CScriptNum scriptnum3(num1);
+    CScriptNum scriptnum4(num1);
+
+    // int64_t overflow is undefined.
+    bool invalid = (((num2 > 0) && (num1 > (std::numeric_limits<int64_t>::max() - num2))) ||
+                    ((num2 < 0) && (num1 < (std::numeric_limits<int64_t>::min() - num2))));
+    if (!invalid)
+    {
+        BOOST_CHECK(verify(bignum1 + bignum2, scriptnum1 + scriptnum2));
+        BOOST_CHECK(verify(bignum1 + bignum2, scriptnum1 + num2));
+        BOOST_CHECK(verify(bignum1 + bignum2, scriptnum2 + num1));
+    }
+}
+
+static void CheckNegate(const int64_t& num)
+{
+    const CScriptNum10 bignum(num);
+    const CScriptNum scriptnum(num);
+
+    // -INT64_MIN is undefined
+    if (num != std::numeric_limits<int64_t>::min())
+        BOOST_CHECK(verify(-bignum, -scriptnum));
+}
+
+static void CheckSubtract(const int64_t& num1, const int64_t& num2)
+{
+    const CScriptNum10 bignum1(num1);
+    const CScriptNum10 bignum2(num2);
+    const CScriptNum scriptnum1(num1);
+    const CScriptNum scriptnum2(num2);
+
+    // int64_t overflow is undefined.
+    bool invalid = ((num2 > 0 && num1 < std::numeric_limits<int64_t>::min() + num2) ||
+                    (num2 < 0 && num1 > std::numeric_limits<int64_t>::max() + num2));
+    if (!invalid)
+    {
+        BOOST_CHECK(verify(bignum1 - bignum2, scriptnum1 - scriptnum2));
+        BOOST_CHECK(verify(bignum1 - bignum2, scriptnum1 - num2));
+    }
+
+    invalid = ((num1 > 0 && num2 < std::numeric_limits<int64_t>::min() + num1) ||
+               (num1 < 0 && num2 > std::numeric_limits<int64_t>::max() + num1));
+    if (!invalid)
+    {
+        BOOST_CHECK(verify(bignum2 - bignum1, scriptnum2 - scriptnum1));
+        BOOST_CHECK(verify(bignum2 - bignum1, scriptnum2 - num1));
+    }
+}
+
+static void CheckCompare(const int64_t& num1, const int64_t& num2)
+{
+    const CScriptNum10 bignum1(num1);
+    const CScriptNum10 bignum2(num2);
+    const CScriptNum scriptnum1(num1);
+    const CScriptNum scriptnum2(num2);
+
+    BOOST_CHECK((bignum1 == bignum1) == (scriptnum1 == scriptnum1));
+    BOOST_CHECK((bignum1 != bignum1) ==  (scriptnum1 != scriptnum1));
+    BOOST_CHECK((bignum1 < bignum1) ==  (scriptnum1 < scriptnum1));
+    BOOST_CHECK((bignum1 > bignum1) ==  (scriptnum1 > scriptnum1));
+    BOOST_CHECK((bignum1 >= bignum1) ==  (scriptnum1 >= scriptnum1));
+    BOOST_CHECK((bignum1 <= bignum1) ==  (scriptnum1 <= scriptnum1));
+
+    BOOST_CHECK((bignum1 == bignum1) == (scriptnum1 == num1));
+    BOOST_CHECK((bignum1 != bignum1) ==  (scriptnum1 != num1));
+    BOOST_CHECK((bignum1 < bignum1) ==  (scriptnum1 < num1));
+    BOOST_CHECK((bignum1 > bignum1) ==  (scriptnum1 > num1));
+    BOOST_CHECK((bignum1 >= bignum1) ==  (scriptnum1 >= num1));
+    BOOST_CHECK((bignum1 <= bignum1) ==  (scriptnum1 <= num1));
+
+    BOOST_CHECK((bignum1 == bignum2) ==  (scriptnum1 == scriptnum2));
+    BOOST_CHECK((bignum1 != bignum2) ==  (scriptnum1 != scriptnum2));
+    BOOST_CHECK((bignum1 < bignum2) ==  (scriptnum1 < scriptnum2));
+    BOOST_CHECK((bignum1 > bignum2) ==  (scriptnum1 > scriptnum2));
+    BOOST_CHECK((bignum1 >= bignum2) ==  (scriptnum1 >= scriptnum2));
+    BOOST_CHECK((bignum1 <= bignum2) ==  (scriptnum1 <= scriptnum2));
+
+    BOOST_CHECK((bignum1 == bignum2) ==  (scriptnum1 == num2));
+    BOOST_CHECK((bignum1 != bignum2) ==  (scriptnum1 != num2));
+    BOOST_CHECK((bignum1 < bignum2) ==  (scriptnum1 < num2));
+    BOOST_CHECK((bignum1 > bignum2) ==  (scriptnum1 > num2));
+    BOOST_CHECK((bignum1 >= bignum2) ==  (scriptnum1 >= num2));
+    BOOST_CHECK((bignum1 <= bignum2) ==  (scriptnum1 <= num2));
+}
+
+static void RunCreate(const int64_t& num)
+{
+    CheckCreateInt(num);
+    CScriptNum scriptnum(num);
+    if (scriptnum.getvch().size() <= CScriptNum::nDefaultMaxNumSize)
+        CheckCreateVch(num);
+    else
+    {
+        BOOST_CHECK_THROW (CheckCreateVch(num), scriptnum10_error);
+    }
+}
+
+static void RunOperators(const int64_t& num1, const int64_t& num2)
+{
+    CheckAdd(num1, num2);
+    CheckSubtract(num1, num2);
+    CheckNegate(num1);
+    CheckCompare(num1, num2);
+}
+
+BOOST_AUTO_TEST_CASE(creation)
+{
+    for(size_t i = 0; i < sizeof(values) / sizeof(values[0]); ++i)
+    {
+        for(size_t j = 0; j < sizeof(offsets) / sizeof(offsets[0]); ++j)
+        {
+            RunCreate(values[i]);
+            RunCreate(values[i] + offsets[j]);
+            RunCreate(values[i] - offsets[j]);
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(operators)
+{
+    for(size_t i = 0; i < sizeof(values) / sizeof(values[0]); ++i)
+    {
+        for(size_t j = 0; j < sizeof(offsets) / sizeof(offsets[0]); ++j)
+        {
+            RunOperators(values[i], values[i]);
+            RunOperators(values[i], -values[i]);
+            RunOperators(values[i], values[j]);
+            RunOperators(values[i], -values[j]);
+            RunOperators(values[i] + values[j], values[j]);
+            RunOperators(values[i] + values[j], -values[j]);
+            RunOperators(values[i] - values[j], values[j]);
+            RunOperators(values[i] - values[j], -values[j]);
+            RunOperators(values[i] + values[j], values[i] + values[j]);
+            RunOperators(values[i] + values[j], values[i] - values[j]);
+            RunOperators(values[i] - values[j], values[i] + values[j]);
+            RunOperators(values[i] - values[j], values[i] - values[j]);
+        }
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/serialize_tests.cpp b/serialize_tests.cpp
new file mode 100644
index 0000000..4b789b4
--- /dev/null
+++ b/serialize_tests.cpp
@@ -0,0 +1,368 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <serialize.h>
+#include <streams.h>
+#include <hash.h>
+#include <test/test_salemcash.h>
+
+#include <stdint.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(serialize_tests, BasicTestingSetup)
+
+class CSerializeMethodsTestSingle
+{
+protected:
+    int intval;
+    bool boolval;
+    std::string stringval;
+    const char* charstrval;
+    CTransactionRef txval;
+public:
+    CSerializeMethodsTestSingle() = default;
+    CSerializeMethodsTestSingle(int intvalin, bool boolvalin, std::string stringvalin, const char* charstrvalin, CTransaction txvalin) : intval(intvalin), boolval(boolvalin), stringval(std::move(stringvalin)), charstrval(charstrvalin), txval(MakeTransactionRef(txvalin)){}
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(intval);
+        READWRITE(boolval);
+        READWRITE(stringval);
+        READWRITE(FLATDATA(charstrval));
+        READWRITE(txval);
+    }
+
+    bool operator==(const CSerializeMethodsTestSingle& rhs)
+    {
+        return  intval == rhs.intval && \
+                boolval == rhs.boolval && \
+                stringval == rhs.stringval && \
+                strcmp(charstrval, rhs.charstrval) == 0 && \
+                *txval == *rhs.txval;
+    }
+};
+
+class CSerializeMethodsTestMany : public CSerializeMethodsTestSingle
+{
+public:
+    using CSerializeMethodsTestSingle::CSerializeMethodsTestSingle;
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(intval, boolval, stringval, FLATDATA(charstrval), txval);
+    }
+};
+
+BOOST_AUTO_TEST_CASE(sizes)
+{
+    BOOST_CHECK_EQUAL(sizeof(char), GetSerializeSize(char(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(int8_t), GetSerializeSize(int8_t(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(uint8_t), GetSerializeSize(uint8_t(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(int16_t), GetSerializeSize(int16_t(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(uint16_t), GetSerializeSize(uint16_t(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(int32_t), GetSerializeSize(int32_t(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(uint32_t), GetSerializeSize(uint32_t(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(int64_t), GetSerializeSize(int64_t(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(uint64_t), GetSerializeSize(uint64_t(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(float), GetSerializeSize(float(0), 0));
+    BOOST_CHECK_EQUAL(sizeof(double), GetSerializeSize(double(0), 0));
+    // Bool is serialized as char
+    BOOST_CHECK_EQUAL(sizeof(char), GetSerializeSize(bool(0), 0));
+
+    // Sanity-check GetSerializeSize and c++ type matching
+    BOOST_CHECK_EQUAL(GetSerializeSize(char(0), 0), 1);
+    BOOST_CHECK_EQUAL(GetSerializeSize(int8_t(0), 0), 1);
+    BOOST_CHECK_EQUAL(GetSerializeSize(uint8_t(0), 0), 1);
+    BOOST_CHECK_EQUAL(GetSerializeSize(int16_t(0), 0), 2);
+    BOOST_CHECK_EQUAL(GetSerializeSize(uint16_t(0), 0), 2);
+    BOOST_CHECK_EQUAL(GetSerializeSize(int32_t(0), 0), 4);
+    BOOST_CHECK_EQUAL(GetSerializeSize(uint32_t(0), 0), 4);
+    BOOST_CHECK_EQUAL(GetSerializeSize(int64_t(0), 0), 8);
+    BOOST_CHECK_EQUAL(GetSerializeSize(uint64_t(0), 0), 8);
+    BOOST_CHECK_EQUAL(GetSerializeSize(float(0), 0), 4);
+    BOOST_CHECK_EQUAL(GetSerializeSize(double(0), 0), 8);
+    BOOST_CHECK_EQUAL(GetSerializeSize(bool(0), 0), 1);
+}
+
+BOOST_AUTO_TEST_CASE(floats_conversion)
+{
+    // Choose values that map unambiguously to binary floating point to avoid
+    // rounding issues at the compiler side.
+    BOOST_CHECK_EQUAL(ser_uint32_to_float(0x00000000), 0.0F);
+    BOOST_CHECK_EQUAL(ser_uint32_to_float(0x3f000000), 0.5F);
+    BOOST_CHECK_EQUAL(ser_uint32_to_float(0x3f800000), 1.0F);
+    BOOST_CHECK_EQUAL(ser_uint32_to_float(0x40000000), 2.0F);
+    BOOST_CHECK_EQUAL(ser_uint32_to_float(0x40800000), 4.0F);
+    BOOST_CHECK_EQUAL(ser_uint32_to_float(0x44444444), 785.066650390625F);
+
+    BOOST_CHECK_EQUAL(ser_float_to_uint32(0.0F), 0x00000000);
+    BOOST_CHECK_EQUAL(ser_float_to_uint32(0.5F), 0x3f000000);
+    BOOST_CHECK_EQUAL(ser_float_to_uint32(1.0F), 0x3f800000);
+    BOOST_CHECK_EQUAL(ser_float_to_uint32(2.0F), 0x40000000);
+    BOOST_CHECK_EQUAL(ser_float_to_uint32(4.0F), 0x40800000);
+    BOOST_CHECK_EQUAL(ser_float_to_uint32(785.066650390625F), 0x44444444);
+}
+
+BOOST_AUTO_TEST_CASE(doubles_conversion)
+{
+    // Choose values that map unambiguously to binary floating point to avoid
+    // rounding issues at the compiler side.
+    BOOST_CHECK_EQUAL(ser_uint64_to_double(0x0000000000000000ULL), 0.0);
+    BOOST_CHECK_EQUAL(ser_uint64_to_double(0x3fe0000000000000ULL), 0.5);
+    BOOST_CHECK_EQUAL(ser_uint64_to_double(0x3ff0000000000000ULL), 1.0);
+    BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4000000000000000ULL), 2.0);
+    BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4010000000000000ULL), 4.0);
+    BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4088888880000000ULL), 785.066650390625);
+
+    BOOST_CHECK_EQUAL(ser_double_to_uint64(0.0), 0x0000000000000000ULL);
+    BOOST_CHECK_EQUAL(ser_double_to_uint64(0.5), 0x3fe0000000000000ULL);
+    BOOST_CHECK_EQUAL(ser_double_to_uint64(1.0), 0x3ff0000000000000ULL);
+    BOOST_CHECK_EQUAL(ser_double_to_uint64(2.0), 0x4000000000000000ULL);
+    BOOST_CHECK_EQUAL(ser_double_to_uint64(4.0), 0x4010000000000000ULL);
+    BOOST_CHECK_EQUAL(ser_double_to_uint64(785.066650390625), 0x4088888880000000ULL);
+}
+/*
+Python code to generate the below hashes:
+
+    def reversed_hex(x):
+        return binascii.hexlify(''.join(reversed(x)))
+    def dsha256(x):
+        return hashlib.sha256(hashlib.sha256(x).digest()).digest()
+
+    reversed_hex(dsha256(''.join(struct.pack('<f', x) for x in range(0,1000)))) == '8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85099d7f3fe0c'
+    reversed_hex(dsha256(''.join(struct.pack('<d', x) for x in range(0,1000)))) == '43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96'
+*/
+BOOST_AUTO_TEST_CASE(floats)
+{
+    CDataStream ss(SER_DISK, 0);
+    // encode
+    for (int i = 0; i < 1000; i++) {
+        ss << float(i);
+    }
+    BOOST_CHECK(Hash(ss.begin(), ss.end()) == uint256S("8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85099d7f3fe0c"));
+
+    // decode
+    for (int i = 0; i < 1000; i++) {
+        float j;
+        ss >> j;
+        BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(doubles)
+{
+    CDataStream ss(SER_DISK, 0);
+    // encode
+    for (int i = 0; i < 1000; i++) {
+        ss << double(i);
+    }
+    BOOST_CHECK(Hash(ss.begin(), ss.end()) == uint256S("43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96"));
+
+    // decode
+    for (int i = 0; i < 1000; i++) {
+        double j;
+        ss >> j;
+        BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(varints)
+{
+    // encode
+
+    CDataStream ss(SER_DISK, 0);
+    CDataStream::size_type size = 0;
+    for (int i = 0; i < 100000; i++) {
+        ss << VARINT(i, VarIntMode::NONNEGATIVE_SIGNED);
+        size += ::GetSerializeSize(VARINT(i, VarIntMode::NONNEGATIVE_SIGNED), 0, 0);
+        BOOST_CHECK(size == ss.size());
+    }
+
+    for (uint64_t i = 0;  i < 100000000000ULL; i += 999999937) {
+        ss << VARINT(i);
+        size += ::GetSerializeSize(VARINT(i), 0, 0);
+        BOOST_CHECK(size == ss.size());
+    }
+
+    // decode
+    for (int i = 0; i < 100000; i++) {
+        int j = -1;
+        ss >> VARINT(j, VarIntMode::NONNEGATIVE_SIGNED);
+        BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
+    }
+
+    for (uint64_t i = 0;  i < 100000000000ULL; i += 999999937) {
+        uint64_t j = -1;
+        ss >> VARINT(j);
+        BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(varints_bitpatterns)
+{
+    CDataStream ss(SER_DISK, 0);
+    ss << VARINT(0, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "00"); ss.clear();
+    ss << VARINT(0x7f, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "7f"); ss.clear();
+    ss << VARINT((int8_t)0x7f, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "7f"); ss.clear();
+    ss << VARINT(0x80, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "8000"); ss.clear();
+    ss << VARINT((uint8_t)0x80); BOOST_CHECK_EQUAL(HexStr(ss), "8000"); ss.clear();
+    ss << VARINT(0x1234, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "a334"); ss.clear();
+    ss << VARINT((int16_t)0x1234, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "a334"); ss.clear();
+    ss << VARINT(0xffff, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "82fe7f"); ss.clear();
+    ss << VARINT((uint16_t)0xffff); BOOST_CHECK_EQUAL(HexStr(ss), "82fe7f"); ss.clear();
+    ss << VARINT(0x123456, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "c7e756"); ss.clear();
+    ss << VARINT((int32_t)0x123456, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "c7e756"); ss.clear();
+    ss << VARINT(0x80123456U); BOOST_CHECK_EQUAL(HexStr(ss), "86ffc7e756"); ss.clear();
+    ss << VARINT((uint32_t)0x80123456U); BOOST_CHECK_EQUAL(HexStr(ss), "86ffc7e756"); ss.clear();
+    ss << VARINT(0xffffffff); BOOST_CHECK_EQUAL(HexStr(ss), "8efefefe7f"); ss.clear();
+    ss << VARINT(0x7fffffffffffffffLL, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "fefefefefefefefe7f"); ss.clear();
+    ss << VARINT(0xffffffffffffffffULL); BOOST_CHECK_EQUAL(HexStr(ss), "80fefefefefefefefe7f"); ss.clear();
+}
+
+BOOST_AUTO_TEST_CASE(compactsize)
+{
+    CDataStream ss(SER_DISK, 0);
+    std::vector<char>::size_type i, j;
+
+    for (i = 1; i <= MAX_SIZE; i *= 2)
+    {
+        WriteCompactSize(ss, i-1);
+        WriteCompactSize(ss, i);
+    }
+    for (i = 1; i <= MAX_SIZE; i *= 2)
+    {
+        j = ReadCompactSize(ss);
+        BOOST_CHECK_MESSAGE((i-1) == j, "decoded:" << j << " expected:" << (i-1));
+        j = ReadCompactSize(ss);
+        BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
+    }
+}
+
+static bool isCanonicalException(const std::ios_base::failure& ex)
+{
+    std::ios_base::failure expectedException("non-canonical ReadCompactSize()");
+
+    // The string returned by what() can be different for different platforms.
+    // Instead of directly comparing the ex.what() with an expected string,
+    // create an instance of exception to see if ex.what() matches 
+    // the expected explanatory string returned by the exception instance. 
+    return strcmp(expectedException.what(), ex.what()) == 0;
+}
+
+
+BOOST_AUTO_TEST_CASE(noncanonical)
+{
+    // Write some non-canonical CompactSize encodings, and
+    // make sure an exception is thrown when read back.
+    CDataStream ss(SER_DISK, 0);
+    std::vector<char>::size_type n;
+
+    // zero encoded with three bytes:
+    ss.write("\xfd\x00\x00", 3);
+    BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
+
+    // 0xfc encoded with three bytes:
+    ss.write("\xfd\xfc\x00", 3);
+    BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
+
+    // 0xfd encoded with three bytes is OK:
+    ss.write("\xfd\xfd\x00", 3);
+    n = ReadCompactSize(ss);
+    BOOST_CHECK(n == 0xfd);
+
+    // zero encoded with five bytes:
+    ss.write("\xfe\x00\x00\x00\x00", 5);
+    BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
+
+    // 0xffff encoded with five bytes:
+    ss.write("\xfe\xff\xff\x00\x00", 5);
+    BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
+
+    // zero encoded with nine bytes:
+    ss.write("\xff\x00\x00\x00\x00\x00\x00\x00\x00", 9);
+    BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
+
+    // 0x01ffffff encoded with nine bytes:
+    ss.write("\xff\xff\xff\xff\x01\x00\x00\x00\x00", 9);
+    BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
+}
+
+BOOST_AUTO_TEST_CASE(insert_delete)
+{
+    // Test inserting/deleting bytes.
+    CDataStream ss(SER_DISK, 0);
+    BOOST_CHECK_EQUAL(ss.size(), 0);
+
+    ss.write("\x00\x01\x02\xff", 4);
+    BOOST_CHECK_EQUAL(ss.size(), 4);
+
+    char c = (char)11;
+
+    // Inserting at beginning/end/middle:
+    ss.insert(ss.begin(), c);
+    BOOST_CHECK_EQUAL(ss.size(), 5);
+    BOOST_CHECK_EQUAL(ss[0], c);
+    BOOST_CHECK_EQUAL(ss[1], 0);
+
+    ss.insert(ss.end(), c);
+    BOOST_CHECK_EQUAL(ss.size(), 6);
+    BOOST_CHECK_EQUAL(ss[4], (char)0xff);
+    BOOST_CHECK_EQUAL(ss[5], c);
+
+    ss.insert(ss.begin()+2, c);
+    BOOST_CHECK_EQUAL(ss.size(), 7);
+    BOOST_CHECK_EQUAL(ss[2], c);
+
+    // Delete at beginning/end/middle
+    ss.erase(ss.begin());
+    BOOST_CHECK_EQUAL(ss.size(), 6);
+    BOOST_CHECK_EQUAL(ss[0], 0);
+
+    ss.erase(ss.begin()+ss.size()-1);
+    BOOST_CHECK_EQUAL(ss.size(), 5);
+    BOOST_CHECK_EQUAL(ss[4], (char)0xff);
+
+    ss.erase(ss.begin()+1);
+    BOOST_CHECK_EQUAL(ss.size(), 4);
+    BOOST_CHECK_EQUAL(ss[0], 0);
+    BOOST_CHECK_EQUAL(ss[1], 1);
+    BOOST_CHECK_EQUAL(ss[2], 2);
+    BOOST_CHECK_EQUAL(ss[3], (char)0xff);
+
+    // Make sure GetAndClear does the right thing:
+    CSerializeData d;
+    ss.GetAndClear(d);
+    BOOST_CHECK_EQUAL(ss.size(), 0);
+}
+
+BOOST_AUTO_TEST_CASE(class_methods)
+{
+    int intval(100);
+    bool boolval(true);
+    std::string stringval("testing");
+    const char* charstrval("testing charstr");
+    CMutableTransaction txval;
+    CSerializeMethodsTestSingle methodtest1(intval, boolval, stringval, charstrval, txval);
+    CSerializeMethodsTestMany methodtest2(intval, boolval, stringval, charstrval, txval);
+    CSerializeMethodsTestSingle methodtest3;
+    CSerializeMethodsTestMany methodtest4;
+    CDataStream ss(SER_DISK, PROTOCOL_VERSION);
+    BOOST_CHECK(methodtest1 == methodtest2);
+    ss << methodtest1;
+    ss >> methodtest4;
+    ss << methodtest2;
+    ss >> methodtest3;
+    BOOST_CHECK(methodtest1 == methodtest2);
+    BOOST_CHECK(methodtest2 == methodtest3);
+    BOOST_CHECK(methodtest3 == methodtest4);
+
+    CDataStream ss2(SER_DISK, PROTOCOL_VERSION, intval, boolval, stringval, FLATDATA(charstrval), txval);
+    ss2 >> methodtest3;
+    BOOST_CHECK(methodtest3 == methodtest4);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/sighash_tests.cpp b/sighash_tests.cpp
new file mode 100644
index 0000000..740ad89
--- /dev/null
+++ b/sighash_tests.cpp
@@ -0,0 +1,211 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <consensus/tx_verify.h>
+#include <consensus/validation.h>
+#include <test/data/sighash.json.h>
+#include <hash.h>
+#include <script/interpreter.h>
+#include <script/script.h>
+#include <serialize.h>
+#include <streams.h>
+#include <test/test_salemcash.h>
+#include <util.h>
+#include <utilstrencodings.h>
+#include <version.h>
+
+#include <iostream>
+
+#include <boost/test/unit_test.hpp>
+
+#include <univalue.h>
+
+extern UniValue read_json(const std::string& jsondata);
+
+// Old script.cpp SignatureHash function
+uint256 static SignatureHashOld(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType)
+{
+    static const uint256 one(uint256S("0000000000000000000000000000000000000000000000000000000000000001"));
+    if (nIn >= txTo.vin.size())
+    {
+        return one;
+    }
+    CMutableTransaction txTmp(txTo);
+
+    // In case concatenating two scripts ends up with two codeseparators,
+    // or an extra one at the end, this prevents all those possible incompatibilities.
+    scriptCode.FindAndDelete(CScript(OP_CODESEPARATOR));
+
+    // Blank out other inputs' signatures
+    for (unsigned int i = 0; i < txTmp.vin.size(); i++)
+        txTmp.vin[i].scriptSig = CScript();
+    txTmp.vin[nIn].scriptSig = scriptCode;
+
+    // Blank out some of the outputs
+    if ((nHashType & 0x1f) == SIGHASH_NONE)
+    {
+        // Wildcard payee
+        txTmp.vout.clear();
+
+        // Let the others update at will
+        for (unsigned int i = 0; i < txTmp.vin.size(); i++)
+            if (i != nIn)
+                txTmp.vin[i].nSequence = 0;
+    }
+    else if ((nHashType & 0x1f) == SIGHASH_SINGLE)
+    {
+        // Only lock-in the txout payee at same index as txin
+        unsigned int nOut = nIn;
+        if (nOut >= txTmp.vout.size())
+        {
+            return one;
+        }
+        txTmp.vout.resize(nOut+1);
+        for (unsigned int i = 0; i < nOut; i++)
+            txTmp.vout[i].SetNull();
+
+        // Let the others update at will
+        for (unsigned int i = 0; i < txTmp.vin.size(); i++)
+            if (i != nIn)
+                txTmp.vin[i].nSequence = 0;
+    }
+
+    // Blank out other inputs completely, not recommended for open transactions
+    if (nHashType & SIGHASH_ANYONECANPAY)
+    {
+        txTmp.vin[0] = txTmp.vin[nIn];
+        txTmp.vin.resize(1);
+    }
+
+    // Serialize and hash
+    CHashWriter ss(SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS);
+    ss << txTmp << nHashType;
+    return ss.GetHash();
+}
+
+void static RandomScript(CScript &script) {
+    static const opcodetype oplist[] = {OP_FALSE, OP_1, OP_2, OP_3, OP_CHECKSIG, OP_IF, OP_VERIF, OP_RETURN, OP_CODESEPARATOR};
+    script = CScript();
+    int ops = (InsecureRandRange(10));
+    for (int i=0; i<ops; i++)
+        script << oplist[InsecureRandRange(sizeof(oplist)/sizeof(oplist[0]))];
+}
+
+void static RandomTransaction(CMutableTransaction &tx, bool fSingle) {
+    tx.nVersion = InsecureRand32();
+    tx.vin.clear();
+    tx.vout.clear();
+    tx.nLockTime = (InsecureRandBool()) ? InsecureRand32() : 0;
+    int ins = (InsecureRandBits(2)) + 1;
+    int outs = fSingle ? ins : (InsecureRandBits(2)) + 1;
+    for (int in = 0; in < ins; in++) {
+        tx.vin.push_back(CTxIn());
+        CTxIn &txin = tx.vin.back();
+        txin.prevout.hash = InsecureRand256();
+        txin.prevout.n = InsecureRandBits(2);
+        RandomScript(txin.scriptSig);
+        txin.nSequence = (InsecureRandBool()) ? InsecureRand32() : (unsigned int)-1;
+    }
+    for (int out = 0; out < outs; out++) {
+        tx.vout.push_back(CTxOut());
+        CTxOut &txout = tx.vout.back();
+        txout.nValue = InsecureRandRange(100000000);
+        RandomScript(txout.scriptPubKey);
+    }
+}
+
+BOOST_FIXTURE_TEST_SUITE(sighash_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(sighash_test)
+{
+    SeedInsecureRand(false);
+
+    #if defined(PRINT_SIGHASH_JSON)
+    std::cout << "[\n";
+    std::cout << "\t[\"raw_transaction, script, input_index, hashType, signature_hash (result)\"],\n";
+    int nRandomTests = 500;
+    #else
+    int nRandomTests = 50000;
+    #endif
+    for (int i=0; i<nRandomTests; i++) {
+        int nHashType = InsecureRand32();
+        CMutableTransaction txTo;
+        RandomTransaction(txTo, (nHashType & 0x1f) == SIGHASH_SINGLE);
+        CScript scriptCode;
+        RandomScript(scriptCode);
+        int nIn = InsecureRandRange(txTo.vin.size());
+
+        uint256 sh, sho;
+        sho = SignatureHashOld(scriptCode, txTo, nIn, nHashType);
+        sh = SignatureHash(scriptCode, txTo, nIn, nHashType, 0, SIGVERSION_BASE);
+        #if defined(PRINT_SIGHASH_JSON)
+        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+        ss << txTo;
+
+        std::cout << "\t[\"" ;
+        std::cout << HexStr(ss.begin(), ss.end()) << "\", \"";
+        std::cout << HexStr(scriptCode) << "\", ";
+        std::cout << nIn << ", ";
+        std::cout << nHashType << ", \"";
+        std::cout << sho.GetHex() << "\"]";
+        if (i+1 != nRandomTests) {
+          std::cout << ",";
+        }
+        std::cout << "\n";
+        #endif
+        BOOST_CHECK(sh == sho);
+    }
+    #if defined(PRINT_SIGHASH_JSON)
+    std::cout << "]\n";
+    #endif
+}
+
+// Goal: check that SignatureHash generates correct hash
+BOOST_AUTO_TEST_CASE(sighash_from_data)
+{
+    UniValue tests = read_json(std::string(json_tests::sighash, json_tests::sighash + sizeof(json_tests::sighash)));
+
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        UniValue test = tests[idx];
+        std::string strTest = test.write();
+        if (test.size() < 1) // Allow for extra stuff (useful for comments)
+        {
+            BOOST_ERROR("Bad test: " << strTest);
+            continue;
+        }
+        if (test.size() == 1) continue; // comment
+
+        std::string raw_tx, raw_script, sigHashHex;
+        int nIn, nHashType;
+        uint256 sh;
+        CTransactionRef tx;
+        CScript scriptCode = CScript();
+
+        try {
+          // deserialize test data
+          raw_tx = test[0].get_str();
+          raw_script = test[1].get_str();
+          nIn = test[2].get_int();
+          nHashType = test[3].get_int();
+          sigHashHex = test[4].get_str();
+
+          CDataStream stream(ParseHex(raw_tx), SER_NETWORK, PROTOCOL_VERSION);
+          stream >> tx;
+
+          CValidationState state;
+          BOOST_CHECK_MESSAGE(CheckTransaction(*tx, state), strTest);
+          BOOST_CHECK(state.IsValid());
+
+          std::vector<unsigned char> raw = ParseHex(raw_script);
+          scriptCode.insert(scriptCode.end(), raw.begin(), raw.end());
+        } catch (...) {
+          BOOST_ERROR("Bad test, couldn't deserialize data: " << strTest);
+          continue;
+        }
+
+        sh = SignatureHash(scriptCode, *tx, nIn, nHashType, 0, SIGVERSION_BASE);
+        BOOST_CHECK_MESSAGE(sh.GetHex() == sigHashHex, strTest);
+    }
+}
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/sigopcount_tests.cpp b/sigopcount_tests.cpp
new file mode 100644
index 0000000..0138de4
--- /dev/null
+++ b/sigopcount_tests.cpp
@@ -0,0 +1,232 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <consensus/tx_verify.h>
+#include <consensus/validation.h>
+#include <pubkey.h>
+#include <key.h>
+#include <script/script.h>
+#include <script/standard.h>
+#include <uint256.h>
+#include <test/test_salemcash.h>
+
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+// Helpers:
+static std::vector<unsigned char>
+Serialize(const CScript& s)
+{
+    std::vector<unsigned char> sSerialized(s.begin(), s.end());
+    return sSerialized;
+}
+
+BOOST_FIXTURE_TEST_SUITE(sigopcount_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(GetSigOpCount)
+{
+    // Test CScript::GetSigOpCount()
+    CScript s1;
+    BOOST_CHECK_EQUAL(s1.GetSigOpCount(false), 0U);
+    BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 0U);
+
+    uint160 dummy;
+    s1 << OP_1 << ToByteVector(dummy) << ToByteVector(dummy) << OP_2 << OP_CHECKMULTISIG;
+    BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 2U);
+    s1 << OP_IF << OP_CHECKSIG << OP_ENDIF;
+    BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 3U);
+    BOOST_CHECK_EQUAL(s1.GetSigOpCount(false), 21U);
+
+    CScript p2sh = GetScriptForDestination(CScriptID(s1));
+    CScript scriptSig;
+    scriptSig << OP_0 << Serialize(s1);
+    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(scriptSig), 3U);
+
+    std::vector<CPubKey> keys;
+    for (int i = 0; i < 3; i++)
+    {
+        CKey k;
+        k.MakeNewKey(true);
+        keys.push_back(k.GetPubKey());
+    }
+    CScript s2 = GetScriptForMultisig(1, keys);
+    BOOST_CHECK_EQUAL(s2.GetSigOpCount(true), 3U);
+    BOOST_CHECK_EQUAL(s2.GetSigOpCount(false), 20U);
+
+    p2sh = GetScriptForDestination(CScriptID(s2));
+    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(true), 0U);
+    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(false), 0U);
+    CScript scriptSig2;
+    scriptSig2 << OP_1 << ToByteVector(dummy) << ToByteVector(dummy) << Serialize(s2);
+    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(scriptSig2), 3U);
+}
+
+/**
+ * Verifies script execution of the zeroth scriptPubKey of tx output and
+ * zeroth scriptSig and witness of tx input.
+ */
+ScriptError VerifyWithFlag(const CTransaction& output, const CMutableTransaction& input, int flags)
+{
+    ScriptError error;
+    CTransaction inputi(input);
+    bool ret = VerifyScript(inputi.vin[0].scriptSig, output.vout[0].scriptPubKey, &inputi.vin[0].scriptWitness, flags, TransactionSignatureChecker(&inputi, 0, output.vout[0].nValue), &error);
+    BOOST_CHECK((ret == true) == (error == SCRIPT_ERR_OK));
+
+    return error;
+}
+
+/**
+ * Builds a creationTx from scriptPubKey and a spendingTx from scriptSig
+ * and witness such that spendingTx spends output zero of creationTx.
+ * Also inserts creationTx's output into the coins view.
+ */
+void BuildTxs(CMutableTransaction& spendingTx, CCoinsViewCache& coins, CMutableTransaction& creationTx, const CScript& scriptPubKey, const CScript& scriptSig, const CScriptWitness& witness)
+{
+    creationTx.nVersion = 1;
+    creationTx.vin.resize(1);
+    creationTx.vin[0].prevout.SetNull();
+    creationTx.vin[0].scriptSig = CScript();
+    creationTx.vout.resize(1);
+    creationTx.vout[0].nValue = 1;
+    creationTx.vout[0].scriptPubKey = scriptPubKey;
+
+    spendingTx.nVersion = 1;
+    spendingTx.vin.resize(1);
+    spendingTx.vin[0].prevout.hash = creationTx.GetHash();
+    spendingTx.vin[0].prevout.n = 0;
+    spendingTx.vin[0].scriptSig = scriptSig;
+    spendingTx.vin[0].scriptWitness = witness;
+    spendingTx.vout.resize(1);
+    spendingTx.vout[0].nValue = 1;
+    spendingTx.vout[0].scriptPubKey = CScript();
+
+    AddCash(cash, creationTx, 0);
+}
+
+BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
+{
+    // Transaction creates outputs
+    CMutableTransaction creationTx;
+    // Transaction that spends outputs and whose
+    // sig op cost is going to be tested
+    CMutableTransaction spendingTx;
+
+    // Create utxo set
+    CCashView coinsDummy;
+    CCashViewCache cash(&cashDummy);
+    // Create key
+    CKey key;
+    key.MakeNewKey(true);
+    CPubKey pubkey = key.GetPubKey();
+    // Default flags
+    int flags = SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH;
+
+    // Multisig script (legacy counting)
+    {
+        CScript scriptPubKey = CScript() << 1 << ToByteVector(pubkey) << ToByteVector(pubkey) << 2 << OP_CHECKMULTISIGVERIFY;
+        // Do not use a valid signature to avoid using wallet operations.
+        CScript scriptSig = CScript() << OP_0 << OP_0;
+
+        BuildTxs(spendingTx, cash, creationTx, scriptPubKey, scriptSig, CScriptWitness());
+        // Legacy counting only includes signature operations in scriptSigs and scriptPubKeys
+        // of a transaction and does not take the actual executed sig operations into account.
+        // spendingTx in itself does not contain a signature operation.
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), cash, flags) == 0);
+        // creationTx contains two signature operations in its scriptPubKey, but legacy counting
+        // is not accurate.
+        assert(GetTransactionSigOpCost(CTransaction(creationTx), cash, flags) == MAX_PUBKEYS_PER_MULTISIG * WITNESS_SCALE_FACTOR);
+        // Sanity check: script verification fails because of an invalid signature.
+        assert(VerifyWithFlag(creationTx, spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
+    }
+
+    // Multisig nested in P2SH
+    {
+        CScript redeemScript = CScript() << 1 << ToByteVector(pubkey) << ToByteVector(pubkey) << 2 << OP_CHECKMULTISIGVERIFY;
+        CScript scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
+        CScript scriptSig = CScript() << OP_0 << OP_0 << ToByteVector(redeemScript);
+
+        BuildTxs(spendingTx, cash, creationTx, scriptPubKey, scriptSig, CScriptWitness());
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), cash, flags) == 2 * WITNESS_SCALE_FACTOR);
+        assert(VerifyWithFlag(creationTx, spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
+    }
+
+    // P2WPKH witness program
+    {
+        CScript p2pk = CScript() << ToByteVector(pubkey) << OP_CHECKSIG;
+        CScript scriptPubKey = GetScriptForWitness(p2pk);
+        CScript scriptSig = CScript();
+        CScriptWitness scriptWitness;
+        scriptWitness.stack.push_back(std::vector<unsigned char>(0));
+        scriptWitness.stack.push_back(std::vector<unsigned char>(0));
+
+
+        BuildTxs(spendingTx, cash, creationTx, scriptPubKey, scriptSig, scriptWitness);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), cash, flags) == 1);
+        // No signature operations if we don't verify the witness.
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), cash, flags & ~SCRIPT_VERIFY_WITNESS) == 0);
+        assert(VerifyWithFlag(creationTx, spendingTx, flags) == SCRIPT_ERR_EQUALVERIFY);
+
+        // The sig op cost for witness version != 0 is zero.
+        assert(scriptPubKey[0] == 0x00);
+        scriptPubKey[0] = 0x51;
+        BuildTxs(spendingTx, cash, creationTx, scriptPubKey, scriptSig, scriptWitness);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), cash, flags) == 0);
+        scriptPubKey[0] = 0x00;
+        BuildTxs(spendingTx, cash, creationTx, scriptPubKey, scriptSig, scriptWitness);
+
+        // The witness of a cashbase transaction is not taken into account.
+        spendingTx.vin[0].prevout.SetNull();
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), cash, flags) == 0);
+    }
+
+    // P2WPKH nested in P2SH
+    {
+        CScript p2pk = CScript() << ToByteVector(pubkey) << OP_CHECKSIG;
+        CScript scriptSig = GetScriptForWitness(p2pk);
+        CScript scriptPubKey = GetScriptForDestination(CScriptID(scriptSig));
+        scriptSig = CScript() << ToByteVector(scriptSig);
+        CScriptWitness scriptWitness;
+        scriptWitness.stack.push_back(std::vector<unsigned char>(0));
+        scriptWitness.stack.push_back(std::vector<unsigned char>(0));
+
+        BuildTxs(spendingTx, cash, creationTx, scriptPubKey, scriptSig, scriptWitness);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), cash, flags) == 1);
+        assert(VerifyWithFlag(creationTx, spendingTx, flags) == SCRIPT_ERR_EQUALVERIFY);
+    }
+
+    // P2WSH witness program
+    {
+        CScript witnessScript = CScript() << 1 << ToByteVector(pubkey) << ToByteVector(pubkey) << 2 << OP_CHECKMULTISIGVERIFY;
+        CScript scriptPubKey = GetScriptForWitness(witnessScript);
+        CScript scriptSig = CScript();
+        CScriptWitness scriptWitness;
+        scriptWitness.stack.push_back(std::vector<unsigned char>(0));
+        scriptWitness.stack.push_back(std::vector<unsigned char>(0));
+        scriptWitness.stack.push_back(std::vector<unsigned char>(witnessScript.begin(), witnessScript.end()));
+
+        BuildTxs(spendingTx, cash, creationTx, scriptPubKey, scriptSig, scriptWitness);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), cash, flags) == 2);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), cash, flags & ~SCRIPT_VERIFY_WITNESS) == 0);
+        assert(VerifyWithFlag(creationTx, spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
+    }
+
+    // P2WSH nested in P2SH
+    {
+        CScript witnessScript = CScript() << 1 << ToByteVector(pubkey) << ToByteVector(pubkey) << 2 << OP_CHECKMULTISIGVERIFY;
+        CScript redeemScript = GetScriptForWitness(witnessScript);
+        CScript scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
+        CScript scriptSig = CScript() << ToByteVector(redeemScript);
+        CScriptWitness scriptWitness;
+        scriptWitness.stack.push_back(std::vector<unsigned char>(0));
+        scriptWitness.stack.push_back(std::vector<unsigned char>(0));
+        scriptWitness.stack.push_back(std::vector<unsigned char>(witnessScript.begin(), witnessScript.end()));
+
+        BuildTxs(spendingTx, cash, creationTx, scriptPubKey, scriptSig, scriptWitness);
+        assert(GetTransactionSigOpCost(CTransaction(spendingTx), cash, flags) == 2);
+        assert(VerifyWithFlag(creationTx, spendingTx, flags) == SCRIPT_ERR_CHECKMULTISIGVERIFY);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/skiplist_tests.cpp b/skiplist_tests.cpp
new file mode 100644
index 0000000..d4a31a3
--- /dev/null
+++ b/skiplist_tests.cpp
@@ -0,0 +1,180 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <chain.h>
+#include <util.h>
+#include <test/test_salemcash.h>
+
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+#define SKIPLIST_LENGTH 300000
+
+BOOST_FIXTURE_TEST_SUITE(skiplist_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(skiplist_test)
+{
+    std::vector<CBlockIndex> vIndex(SKIPLIST_LENGTH);
+
+    for (int i=0; i<SKIPLIST_LENGTH; i++) {
+        vIndex[i].nHeight = i;
+        vIndex[i].pprev = (i == 0) ? nullptr : &vIndex[i - 1];
+        vIndex[i].BuildSkip();
+    }
+
+    for (int i=0; i<SKIPLIST_LENGTH; i++) {
+        if (i > 0) {
+            BOOST_CHECK(vIndex[i].pskip == &vIndex[vIndex[i].pskip->nHeight]);
+            BOOST_CHECK(vIndex[i].pskip->nHeight < i);
+        } else {
+            BOOST_CHECK(vIndex[i].pskip == nullptr);
+        }
+    }
+
+    for (int i=0; i < 1000; i++) {
+        int from = InsecureRandRange(SKIPLIST_LENGTH - 1);
+        int to = InsecureRandRange(from + 1);
+
+        BOOST_CHECK(vIndex[SKIPLIST_LENGTH - 1].GetAncestor(from) == &vIndex[from]);
+        BOOST_CHECK(vIndex[from].GetAncestor(to) == &vIndex[to]);
+        BOOST_CHECK(vIndex[from].GetAncestor(0) == vIndex.data());
+    }
+}
+
+BOOST_AUTO_TEST_CASE(getlocator_test)
+{
+    // Build a main chain 100000 blocks long.
+    std::vector<uint256> vHashMain(100000);
+    std::vector<CBlockIndex> vBlocksMain(100000);
+    for (unsigned int i=0; i<vBlocksMain.size(); i++) {
+        vHashMain[i] = ArithToUint256(i); // Set the hash equal to the height, so we can quickly check the distances.
+        vBlocksMain[i].nHeight = i;
+        vBlocksMain[i].pprev = i ? &vBlocksMain[i - 1] : nullptr;
+        vBlocksMain[i].phashBlock = &vHashMain[i];
+        vBlocksMain[i].BuildSkip();
+        BOOST_CHECK_EQUAL((int)UintToArith256(vBlocksMain[i].GetBlockHash()).GetLow64(), vBlocksMain[i].nHeight);
+        BOOST_CHECK(vBlocksMain[i].pprev == nullptr || vBlocksMain[i].nHeight == vBlocksMain[i].pprev->nHeight + 1);
+    }
+
+    // Build a branch that splits off at block 49999, 50000 blocks long.
+    std::vector<uint256> vHashSide(50000);
+    std::vector<CBlockIndex> vBlocksSide(50000);
+    for (unsigned int i=0; i<vBlocksSide.size(); i++) {
+        vHashSide[i] = ArithToUint256(i + 50000 + (arith_uint256(1) << 128)); // Add 1<<128 to the hashes, so GetLow64() still returns the height.
+        vBlocksSide[i].nHeight = i + 50000;
+        vBlocksSide[i].pprev = i ? &vBlocksSide[i - 1] : (vBlocksMain.data()+49999);
+        vBlocksSide[i].phashBlock = &vHashSide[i];
+        vBlocksSide[i].BuildSkip();
+        BOOST_CHECK_EQUAL((int)UintToArith256(vBlocksSide[i].GetBlockHash()).GetLow64(), vBlocksSide[i].nHeight);
+        BOOST_CHECK(vBlocksSide[i].pprev == nullptr || vBlocksSide[i].nHeight == vBlocksSide[i].pprev->nHeight + 1);
+    }
+
+    // Build a CChain for the main branch.
+    CChain chain;
+    chain.SetTip(&vBlocksMain.back());
+
+    // Test 100 random starting points for locators.
+    for (int n=0; n<100; n++) {
+        int r = InsecureRandRange(150000);
+        CBlockIndex* tip = (r < 100000) ? &vBlocksMain[r] : &vBlocksSide[r - 100000];
+        CBlockLocator locator = chain.GetLocator(tip);
+
+        // The first result must be the block itself, the last one must be genesis.
+        BOOST_CHECK(locator.vHave.front() == tip->GetBlockHash());
+        BOOST_CHECK(locator.vHave.back() == vBlocksMain[0].GetBlockHash());
+
+        // Entries 1 through 11 (inclusive) go back one step each.
+        for (unsigned int i = 1; i < 12 && i < locator.vHave.size() - 1; i++) {
+            BOOST_CHECK_EQUAL(UintToArith256(locator.vHave[i]).GetLow64(), tip->nHeight - i);
+        }
+
+        // The further ones (excluding the last one) go back with exponential steps.
+        unsigned int dist = 2;
+        for (unsigned int i = 12; i < locator.vHave.size() - 1; i++) {
+            BOOST_CHECK_EQUAL(UintToArith256(locator.vHave[i - 1]).GetLow64() - UintToArith256(locator.vHave[i]).GetLow64(), dist);
+            dist *= 2;
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(findearliestatleast_test)
+{
+    std::vector<uint256> vHashMain(100000);
+    std::vector<CBlockIndex> vBlocksMain(100000);
+    for (unsigned int i=0; i<vBlocksMain.size(); i++) {
+        vHashMain[i] = ArithToUint256(i); // Set the hash equal to the height
+        vBlocksMain[i].nHeight = i;
+        vBlocksMain[i].pprev = i ? &vBlocksMain[i - 1] : nullptr;
+        vBlocksMain[i].phashBlock = &vHashMain[i];
+        vBlocksMain[i].BuildSkip();
+        if (i < 10) {
+            vBlocksMain[i].nTime = i;
+            vBlocksMain[i].nTimeMax = i;
+        } else {
+            // randomly choose something in the range [MTP, MTP*2]
+            int64_t medianTimePast = vBlocksMain[i].GetMedianTimePast();
+            int r = InsecureRandRange(medianTimePast);
+            vBlocksMain[i].nTime = r + medianTimePast;
+            vBlocksMain[i].nTimeMax = std::max(vBlocksMain[i].nTime, vBlocksMain[i-1].nTimeMax);
+        }
+    }
+    // Check that we set nTimeMax up correctly.
+    unsigned int curTimeMax = 0;
+    for (unsigned int i=0; i<vBlocksMain.size(); ++i) {
+        curTimeMax = std::max(curTimeMax, vBlocksMain[i].nTime);
+        BOOST_CHECK(curTimeMax == vBlocksMain[i].nTimeMax);
+    }
+
+    // Build a CChain for the main branch.
+    CChain chain;
+    chain.SetTip(&vBlocksMain.back());
+
+    // Verify that FindEarliestAtLeast is correct.
+    for (unsigned int i=0; i<10000; ++i) {
+        // Pick a random element in vBlocksMain.
+        int r = InsecureRandRange(vBlocksMain.size());
+        int64_t test_time = vBlocksMain[r].nTime;
+        CBlockIndex *ret = chain.FindEarliestAtLeast(test_time);
+        BOOST_CHECK(ret->nTimeMax >= test_time);
+        BOOST_CHECK((ret->pprev==nullptr) || ret->pprev->nTimeMax < test_time);
+        BOOST_CHECK(vBlocksMain[r].GetAncestor(ret->nHeight) == ret);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(findearliestatleast_edge_test)
+{
+    std::list<CBlockIndex> blocks;
+    for (unsigned int timeMax : {100, 100, 100, 200, 200, 200, 300, 300, 300}) {
+        CBlockIndex* prev = blocks.empty() ? nullptr : &blocks.back();
+        blocks.emplace_back();
+        blocks.back().nHeight = prev ? prev->nHeight + 1 : 0;
+        blocks.back().pprev = prev;
+        blocks.back().BuildSkip();
+        blocks.back().nTimeMax = timeMax;
+    }
+
+    CChain chain;
+    chain.SetTip(&blocks.back());
+
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(50)->nHeight, 0);
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(100)->nHeight, 0);
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(150)->nHeight, 3);
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(200)->nHeight, 3);
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(250)->nHeight, 6);
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(300)->nHeight, 6);
+    BOOST_CHECK(!chain.FindEarliestAtLeast(350));
+
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(0)->nHeight, 0);
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(-1)->nHeight, 0);
+
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(std::numeric_limits<int64_t>::min())->nHeight, 0);
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(std::numeric_limits<unsigned int>::min())->nHeight, 0);
+    BOOST_CHECK_EQUAL(chain.FindEarliestAtLeast(-int64_t(std::numeric_limits<unsigned int>::max()) - 1)->nHeight, 0);
+    BOOST_CHECK(!chain.FindEarliestAtLeast(std::numeric_limits<int64_t>::max()));
+    BOOST_CHECK(!chain.FindEarliestAtLeast(std::numeric_limits<unsigned int>::max()));
+    BOOST_CHECK(!chain.FindEarliestAtLeast(int64_t(std::numeric_limits<unsigned int>::max()) + 1));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/streams_tests.cpp b/streams_tests.cpp
new file mode 100644
index 0000000..bc19bed
--- /dev/null
+++ b/streams_tests.cpp
@@ -0,0 +1,123 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <streams.h>
+#include <support/allocators/zeroafterfree.h>
+#include <test/test_salemcash.h>
+
+#include <boost/assign/std/vector.hpp> // for 'operator+=()'
+#include <boost/test/unit_test.hpp>
+
+using namespace boost::assign; // bring 'operator+=()' into scope
+
+BOOST_FIXTURE_TEST_SUITE(streams_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(streams_vector_writer)
+{
+    unsigned char a(1);
+    unsigned char b(2);
+    unsigned char bytes[] = { 3, 4, 5, 6 };
+    std::vector<unsigned char> vch;
+
+    // Each test runs twice. Serializing a second time at the same starting
+    // point should yield the same results, even if the first test grew the
+    // vector.
+
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, a, b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{1, 2}}));
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, a, b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{1, 2}}));
+    vch.clear();
+
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2}}));
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2}}));
+    vch.clear();
+
+    vch.resize(5, 0);
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2, 0}}));
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 1, 2, 0}}));
+    vch.clear();
+
+    vch.resize(4, 0);
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 3, a, b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 1, 2}}));
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 3, a, b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 1, 2}}));
+    vch.clear();
+
+    vch.resize(4, 0);
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 4, a, b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 0, 1, 2}}));
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 4, a, b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{0, 0, 0, 0, 1, 2}}));
+    vch.clear();
+
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, FLATDATA(bytes));
+    BOOST_CHECK((vch == std::vector<unsigned char>{{3, 4, 5, 6}}));
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, FLATDATA(bytes));
+    BOOST_CHECK((vch == std::vector<unsigned char>{{3, 4, 5, 6}}));
+    vch.clear();
+
+    vch.resize(4, 8);
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, FLATDATA(bytes), b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{8, 8, 1, 3, 4, 5, 6, 2}}));
+    CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, FLATDATA(bytes), b);
+    BOOST_CHECK((vch == std::vector<unsigned char>{{8, 8, 1, 3, 4, 5, 6, 2}}));
+    vch.clear();
+}
+
+BOOST_AUTO_TEST_CASE(streams_serializedata_xor)
+{
+    std::vector<char> in;
+    std::vector<char> expected_xor;
+    std::vector<unsigned char> key;
+    CDataStream ds(in, 0, 0);
+
+    // Degenerate case
+    
+    key += '\x00','\x00';
+    ds.Xor(key);
+    BOOST_CHECK_EQUAL(
+            std::string(expected_xor.begin(), expected_xor.end()), 
+            std::string(ds.begin(), ds.end()));
+
+    in += '\x0f','\xf0';
+    expected_xor += '\xf0','\x0f';
+    
+    // Single character key
+
+    ds.clear();
+    ds.insert(ds.begin(), in.begin(), in.end());
+    key.clear();
+
+    key += '\xff';
+    ds.Xor(key);
+    BOOST_CHECK_EQUAL(
+            std::string(expected_xor.begin(), expected_xor.end()), 
+            std::string(ds.begin(), ds.end())); 
+    
+    // Multi character key
+
+    in.clear();
+    expected_xor.clear();
+    in += '\xf0','\x0f';
+    expected_xor += '\x0f','\x00';
+                        
+    ds.clear();
+    ds.insert(ds.begin(), in.begin(), in.end());
+
+    key.clear();
+    key += '\xff','\x0f';
+
+    ds.Xor(key);
+    BOOST_CHECK_EQUAL(
+            std::string(expected_xor.begin(), expected_xor.end()), 
+            std::string(ds.begin(), ds.end()));  
+}         
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test_salemcash.cpp b/test_salemcash.cpp
new file mode 100644
index 0000000..fcbbdb7
--- /dev/null
+++ b/test_salemcash.cpp
@@ -0,0 +1,188 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/test_salemcash.h>
+
+#include <chainparams.h>
+#include <consensus/consensus.h>
+#include <consensus/validation.h>
+#include <crypto/sha256.h>
+#include <validation.h>
+#include <miner.h>
+#include <net_processing.h>
+#include <ui_interface.h>
+#include <streams.h>
+#include <rpc/server.h>
+#include <rpc/register.h>
+#include <script/sigcache.h>
+
+#include <memory>
+
+void CConnmanTest::AddNode(CNode& node)
+{
+    LOCK(g_connman->cs_vNodes);
+    g_connman->vNodes.push_back(&node);
+}
+
+void CConnmanTest::ClearNodes()
+{
+    LOCK(g_connman->cs_vNodes);
+    for (CNode* node : g_connman->vNodes) {
+        delete node;
+    }
+    g_connman->vNodes.clear();
+}
+
+uint256 insecure_rand_seed = GetRandHash();
+FastRandomContext insecure_rand_ctx(insecure_rand_seed);
+
+extern bool fPrintToConsole;
+extern void noui_connect();
+
+BasicTestingSetup::BasicTestingSetup(const std::string& chainName)
+{
+        SHA256AutoDetect();
+        RandomInit();
+        ECC_Start();
+        SetupEnvironment();
+        SetupNetworking();
+        InitSignatureCache();
+        InitScriptExecutionCache();
+        fPrintToDebugLog = false; // don't want to write to debug.log file
+        fCheckBlockIndex = true;
+        SelectParams(chainName);
+        noui_connect();
+}
+
+BasicTestingSetup::~BasicTestingSetup()
+{
+        ECC_Stop();
+}
+
+TestingSetup::TestingSetup(const std::string& chainName) : BasicTestingSetup(chainName)
+{
+    const CChainParams& chainparams = Params();
+        // Ideally we'd move all the RPC tests to the functional testing framework
+        // instead of unit tests, but for now we need these here.
+
+        RegisterAllCoreRPCCommands(tableRPC);
+        ClearDatadirCache();
+        pathTemp = fs::temp_directory_path() / strprintf("test_salemcash_%lu_%i", (unsigned long)GetTime(), (int)(InsecureRandRange(100000)));
+        fs::create_directories(pathTemp);
+        gArgs.ForceSetArg("-datadir", pathTemp.string());
+
+        // We have to run a scheduler thread to prevent ActivateBestChain
+        // from blocking due to queue overrun.
+        threadGroup.create_thread(boost::bind(&CScheduler::serviceQueue, &scheduler));
+        GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
+
+        mempool.setSanityCheck(1.0);
+        pblocktree.reset(new CBlockTreeDB(1 << 20, true));
+        pcashdbview.reset(new CCashViewDB(1 << 23, true));
+        pcashTip.reset(new CCashViewCache(pcashdbview.get()));
+        if (!LoadGenesisBlock(chainparams)) {
+            throw std::runtime_error("LoadGenesisBlock failed.");
+        }
+        {
+            CValidationState state;
+            if (!ActivateBestChain(state, chainparams)) {
+                throw std::runtime_error("ActivateBestChain failed.");
+            }
+        }
+        nScriptCheckThreads = 3;
+        for (int i=0; i < nScriptCheckThreads-1; i++)
+            threadGroup.create_thread(&ThreadScriptCheck);
+        g_connman = std::unique_ptr<CConnman>(new CConnman(0x1337, 0x1337)); // Deterministic randomness for tests.
+        connman = g_connman.get();
+        peerLogic.reset(new PeerLogicValidation(connman, scheduler));
+}
+
+TestingSetup::~TestingSetup()
+{
+        threadGroup.interrupt_all();
+        threadGroup.join_all();
+        GetMainSignals().FlushBackgroundCallbacks();
+        GetMainSignals().UnregisterBackgroundSignalScheduler();
+        g_connman.reset();
+        peerLogic.reset();
+        UnloadBlockIndex();
+        pcoinsTip.reset();
+        pcoinsdbview.reset();
+        pblocktree.reset();
+        fs::remove_all(pathTemp);
+}
+
+TestChain100Setup::TestChain100Setup() : TestingSetup(CBaseChainParams::REGTEST)
+{
+    // CreateAndProcessBlock() does not support building SegWit blocks, so don't activate in these tests.
+    // TODO: fix the code to support SegWit blocks.
+    UpdateVersionBitsParameters(Consensus::DEPLOYMENT_SEGWIT, 0, Consensus::BIP9Deployment::NO_TIMEOUT);
+    // Generate a 100-block chain:
+    coinbaseKey.MakeNewKey(true);
+    CScript scriptPubKey = CScript() <<  ToByteVector(cashbaseKey.GetPubKey()) << OP_CHECKSIG;
+    for (int i = 0; i < COINBASE_MATURITY; i++)
+    {
+        std::vector<CMutableTransaction> noTxns;
+        CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
+        cashbaseTxns.push_back(*b.vtx[0]);
+    }
+}
+
+//
+// Create a new block with just given transactions, cashbase paying to
+// scriptPubKey, and try to add it to the current chain.
+//
+CBlock
+TestChain100Setup::CreateAndProcessBlock(const std::vector<CMutableTransaction>& txns, const CScript& scriptPubKey)
+{
+    const CChainParams& chainparams = Params();
+    std::unique_ptr<CBlockTemplate> pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey);
+    CBlock& block = pblocktemplate->block;
+
+    // Replace mempool-selected txns with just cashbase plus passed-in txns:
+    block.vtx.resize(1);
+    for (const CMutableTransaction& tx : txns)
+        block.vtx.push_back(MakeTransactionRef(tx));
+    // IncrementExtraNonce creates a valid coinbase and merkleRoot
+    unsigned int extraNonce = 0;
+    {
+        LOCK(cs_main);
+        IncrementExtraNonce(&block, chainActive.Tip(), extraNonce);
+    }
+
+    while (!CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce;
+
+    std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
+    ProcessNewBlock(chainparams, shared_pblock, true, nullptr);
+
+    CBlock result = block;
+    return result;
+}
+
+TestChain100Setup::~TestChain100Setup()
+{
+}
+
+
+CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CMutableTransaction &tx) {
+    CTransaction txn(tx);
+    return FromTx(txn);
+}
+
+CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CTransaction &txn) {
+    return CTxMemPoolEntry(MakeTransactionRef(txn), nFee, nTime, nHeight,
+                           spendsCoinbase, sigOpCost, lp);
+}
+
+/**
+ * @returns a real block (0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af)
+ *      with 9 txs.
+ */
+CBlock getBlock13b8a()
+{
+    CBlock block;
+    CDataStream stream(ParseHex("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"), SER_NETWORK, PROTOCOL_VERSION);
+    stream >> block;
+    return block;
+}
diff --git a/test_salemcash.h b/test_salemcash.h
new file mode 100644
index 0000000..d4f3e63
--- /dev/null
+++ b/test_salemcash.h
@@ -0,0 +1,121 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef SALEMCASH_TEST_TEST_BITCOIN_H
+#define SALEMCASH_TEST_TEST_BITCOIN_H
+
+#include <chainparamsbase.h>
+#include <fs.h>
+#include <key.h>
+#include <pubkey.h>
+#include <random.h>
+#include <scheduler.h>
+#include <txdb.h>
+#include <txmempool.h>
+
+#include <boost/thread.hpp>
+
+extern uint256 insecure_rand_seed;
+extern FastRandomContext insecure_rand_ctx;
+
+static inline void SeedInsecureRand(bool fDeterministic = false)
+{
+    if (fDeterministic) {
+        insecure_rand_seed = uint256();
+    } else {
+        insecure_rand_seed = GetRandHash();
+    }
+    insecure_rand_ctx = FastRandomContext(insecure_rand_seed);
+}
+
+static inline uint32_t InsecureRand32() { return insecure_rand_ctx.rand32(); }
+static inline uint256 InsecureRand256() { return insecure_rand_ctx.rand256(); }
+static inline uint64_t InsecureRandBits(int bits) { return insecure_rand_ctx.randbits(bits); }
+static inline uint64_t InsecureRandRange(uint64_t range) { return insecure_rand_ctx.randrange(range); }
+static inline bool InsecureRandBool() { return insecure_rand_ctx.randbool(); }
+
+/** Basic testing setup.
+ * This just configures logging and chain parameters.
+ */
+struct BasicTestingSetup {
+    ECCVerifyHandle globalVerifyHandle;
+
+    explicit BasicTestingSetup(const std::string& chainName = CBaseChainParams::MAIN);
+    ~BasicTestingSetup();
+};
+
+/** Testing setup that configures a complete environment.
+ * Included are data directory, coins database, script check threads setup.
+ */
+class CConnman;
+class CNode;
+struct CConnmanTest {
+    static void AddNode(CNode& node);
+    static void ClearNodes();
+};
+
+class PeerLogicValidation;
+struct TestingSetup: public BasicTestingSetup {
+    fs::path pathTemp;
+    boost::thread_group threadGroup;
+    CConnman* connman;
+    CScheduler scheduler;
+    std::unique_ptr<PeerLogicValidation> peerLogic;
+
+    explicit TestingSetup(const std::string& chainName = CBaseChainParams::MAIN);
+    ~TestingSetup();
+};
+
+class CBlock;
+struct CMutableTransaction;
+class CScript;
+
+//
+// Testing fixture that pre-creates a
+// 100-block REGTEST-mode block chain
+//
+struct TestChain100Setup : public TestingSetup {
+    TestChain100Setup();
+
+    // Create a new block with just given transactions, cashbase paying to
+    // scriptPubKey, and try to add it to the current chain.
+    CBlock CreateAndProcessBlock(const std::vector<CMutableTransaction>& txns,
+                                 const CScript& scriptPubKey);
+
+    ~TestChain100Setup();
+
+    std::vector<CTransaction> cashbaseTxns; // For convenience, cashbase transactions
+    CKey cashbaseKey; // private/public key needed to spend cashbase transactions
+};
+
+class CTxMemPoolEntry;
+
+struct TestMemPoolEntryHelper
+{
+    // Default values
+    CAmount nFee;
+    int64_t nTime;
+    unsigned int nHeight;
+    bool spendsCashbase;
+    unsigned int sigOpCost;
+    LockPoints lp;
+
+    TestMemPoolEntryHelper() :
+        nFee(0), nTime(0), nHeight(1),
+        spendsCoinbase(false), sigOpCost(4) { }
+
+    CTxMemPoolEntry FromTx(const CMutableTransaction &tx);
+    CTxMemPoolEntry FromTx(const CTransaction &tx);
+
+    // Change the default value
+    TestMemPoolEntryHelper &Fee(CAmount _fee) { nFee = _fee; return *this; }
+    TestMemPoolEntryHelper &Time(int64_t _time) { nTime = _time; return *this; }
+    TestMemPoolEntryHelper &Height(unsigned int _height) { nHeight = _height; return *this; }
+    TestMemPoolEntryHelper &SpendsCoinbase(bool _flag) { spendsCoinbase = _flag; return *this; }
+    TestMemPoolEntryHelper &SigOpsCost(unsigned int _sigopsCost) { sigOpCost = _sigopsCost; return *this; }
+};
+
+CBlock getBlock13b8a();
+
+#endif
diff --git a/test_salemcash_fuzzy.cpp b/test_salemcash_fuzzy.cpp
new file mode 100644
index 0000000..bac192b
--- /dev/null
+++ b/test_salemcash_fuzzy.cpp
@@ -0,0 +1,328 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#if defined(HAVE_CONFIG_H)
+#include <config/salemcash-config.h>
+#endif
+
+#include <consensus/merkle.h>
+#include <primitives/block.h>
+#include <script/script.h>
+#include <addrman.h>
+#include <chain.h>
+#include <cash.h>
+#include <compressor.h>
+#include <net.h>
+#include <protocol.h>
+#include <streams.h>
+#include <undo.h>
+#include <version.h>
+#include <pubkey.h>
+#include <blockencodings.h>
+
+#include <stdint.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <vector>
+
+enum TEST_ID {
+    CBLOCK_DESERIALIZE=0,
+    CTRANSACTION_DESERIALIZE,
+    CBLOCKLOCATOR_DESERIALIZE,
+    CBLOCKMERKLEROOT,
+    CADDRMAN_DESERIALIZE,
+    CBLOCKHEADER_DESERIALIZE,
+    CBANENTRY_DESERIALIZE,
+    CTXUNDO_DESERIALIZE,
+    CBLOCKUNDO_DESERIALIZE,
+    CCASH_DESERIALIZE,
+    CNETADDR_DESERIALIZE,
+    CSERVICE_DESERIALIZE,
+    CMESSAGEHEADER_DESERIALIZE,
+    CADDRESS_DESERIALIZE,
+    CINV_DESERIALIZE,
+    CBLOOMFILTER_DESERIALIZE,
+    CDISKBLOCKINDEX_DESERIALIZE,
+    CTXOUTCOMPRESSOR_DESERIALIZE,
+    BLOCKTRANSACTIONS_DESERIALIZE,
+    BLOCKTRANSACTIONSREQUEST_DESERIALIZE,
+    TEST_ID_END
+};
+
+bool read_stdin(std::vector<uint8_t> &data) {
+    uint8_t buffer[1024];
+    ssize_t length=0;
+    while((length = read(STDIN_FILENO, buffer, 1024)) > 0) {
+        data.insert(data.end(), buffer, buffer+length);
+
+        if (data.size() > (1<<20)) return false;
+    }
+    return length==0;
+}
+
+int test_one_input(std::vector<uint8_t> buffer) {
+    if (buffer.size() < sizeof(uint32_t)) return 0;
+
+    uint32_t test_id = 0xffffffff;
+    memcpy(&test_id, buffer.data(), sizeof(uint32_t));
+    buffer.erase(buffer.begin(), buffer.begin() + sizeof(uint32_t));
+
+    if (test_id >= TEST_ID_END) return 0;
+
+    CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
+    try {
+        int nVersion;
+        ds >> nVersion;
+        ds.SetVersion(nVersion);
+    } catch (const std::ios_base::failure& e) {
+        return 0;
+    }
+
+    switch(test_id) {
+        case CBLOCK_DESERIALIZE:
+        {
+            try
+            {
+                CBlock block;
+                ds >> block;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CTRANSACTION_DESERIALIZE:
+        {
+            try
+            {
+                CTransaction tx(deserialize, ds);
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CBLOCKLOCATOR_DESERIALIZE:
+        {
+            try
+            {
+                CBlockLocator bl;
+                ds >> bl;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CBLOCKMERKLEROOT:
+        {
+            try
+            {
+                CBlock block;
+                ds >> block;
+                bool mutated;
+                BlockMerkleRoot(block, &mutated);
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CADDRMAN_DESERIALIZE:
+        {
+            try
+            {
+                CAddrMan am;
+                ds >> am;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CBLOCKHEADER_DESERIALIZE:
+        {
+            try
+            {
+                CBlockHeader bh;
+                ds >> bh;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CBANENTRY_DESERIALIZE:
+        {
+            try
+            {
+                CBanEntry be;
+                ds >> be;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CTXUNDO_DESERIALIZE:
+        {
+            try
+            {
+                CTxUndo tu;
+                ds >> tu;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CBLOCKUNDO_DESERIALIZE:
+        {
+            try
+            {
+                CBlockUndo bu;
+                ds >> bu;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CCOINS_DESERIALIZE:
+        {
+            try
+            {
+                Cash cash;
+                ds >> cash;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CNETADDR_DESERIALIZE:
+        {
+            try
+            {
+                CNetAddr na;
+                ds >> na;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CSERVICE_DESERIALIZE:
+        {
+            try
+            {
+                CService s;
+                ds >> s;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CMESSAGEHEADER_DESERIALIZE:
+        {
+            CMessageHeader::MessageStartChars pchMessageStart = {0x00, 0x00, 0x00, 0x00};
+            try
+            {
+                CMessageHeader mh(pchMessageStart);
+                ds >> mh;
+                if (!mh.IsValid(pchMessageStart)) {return 0;}
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CADDRESS_DESERIALIZE:
+        {
+            try
+            {
+                CAddress a;
+                ds >> a;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CINV_DESERIALIZE:
+        {
+            try
+            {
+                CInv i;
+                ds >> i;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CBLOOMFILTER_DESERIALIZE:
+        {
+            try
+            {
+                CBloomFilter bf;
+                ds >> bf;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CDISKBLOCKINDEX_DESERIALIZE:
+        {
+            try
+            {
+                CDiskBlockIndex dbi;
+                ds >> dbi;
+            } catch (const std::ios_base::failure& e) {return 0;}
+            break;
+        }
+        case CTXOUTCOMPRESSOR_DESERIALIZE:
+        {
+            CTxOut to;
+            CTxOutCompressor toc(to);
+            try
+            {
+                ds >> toc;
+            } catch (const std::ios_base::failure& e) {return 0;}
+
+            break;
+        }
+        case BLOCKTRANSACTIONS_DESERIALIZE:
+        {
+            try
+            {
+                BlockTransactions bt;
+                ds >> bt;
+            } catch (const std::ios_base::failure& e) {return 0;}
+
+            break;
+        }
+        case BLOCKTRANSACTIONSREQUEST_DESERIALIZE:
+        {
+            try
+            {
+                BlockTransactionsRequest btr;
+                ds >> btr;
+            } catch (const std::ios_base::failure& e) {return 0;}
+
+            break;
+        }
+        default:
+            return 0;
+    }
+    return 0;
+}
+
+static std::unique_ptr<ECCVerifyHandle> globalVerifyHandle;
+void initialize() {
+    globalVerifyHandle = std::unique_ptr<ECCVerifyHandle>(new ECCVerifyHandle());
+}
+
+// This function is used by libFuzzer
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+    test_one_input(std::vector<uint8_t>(data, data + size));
+    return 0;
+}
+
+// This function is used by libFuzzer
+extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) {
+    initialize();
+    return 0;
+}
+
+// Disabled under WIN32 due to clash with Cygwin's WinMain.
+#ifndef WIN32
+// Declare main(...) "weak" to allow for libFuzzer linking. libFuzzer provides
+// the main(...) function.
+__attribute__((weak))
+#endif
+int main(int argc, char **argv)
+{
+    initialize();
+#ifdef __AFL_INIT
+    // Enable AFL deferred forkserver mode. Requires compilation using
+    // afl-clang-fast++. See fuzzing.md for details.
+    __AFL_INIT();
+#endif
+
+#ifdef __AFL_LOOP
+    // Enable AFL persistent mode. Requires compilation using afl-clang-fast++.
+    // See fuzzing.md for details.
+    int ret = 0;
+    while (__AFL_LOOP(1000)) {
+        std::vector<uint8_t> buffer;
+        if (!read_stdin(buffer)) {
+            continue;
+        }
+        ret = test_one_input(buffer);
+    }
+    return ret;
+#else
+    std::vector<uint8_t> buffer;
+    if (!read_stdin(buffer)) {
+        return 0;
+    }
+    return test_one_input(buffer);
+#endif
+}
diff --git a/test_salemcash_main.cpp b/test_salemcash_main.cpp
new file mode 100644
index 0000000..382fade
--- /dev/null
+++ b/test_salemcash_main.cpp
@@ -0,0 +1,26 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#define BOOST_TEST_MODULE SalemCash Test Suite
+
+#include <net.h>
+
+#include <boost/test/unit_test.hpp>
+
+std::unique_ptr<CConnman> g_connman;
+
+[[noreturn]] void Shutdown(void* parg)
+{
+  std::exit(EXIT_SUCCESS);
+}
+
+[[noreturn]] void StartShutdown()
+{
+  std::exit(EXIT_SUCCESS);
+}
+
+bool ShutdownRequested()
+{
+  return false;
+}
diff --git a/timedata_tests.cpp b/timedata_tests.cpp
new file mode 100644
index 0000000..a646716
--- /dev/null
+++ b/timedata_tests.cpp
@@ -0,0 +1,37 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+//
+#include <timedata.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(timedata_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(util_MedianFilter)
+{
+    CMedianFilter<int> filter(5, 15);
+
+    BOOST_CHECK_EQUAL(filter.median(), 15);
+
+    filter.input(20); // [15 20]
+    BOOST_CHECK_EQUAL(filter.median(), 17);
+
+    filter.input(30); // [15 20 30]
+    BOOST_CHECK_EQUAL(filter.median(), 20);
+
+    filter.input(3); // [3 15 20 30]
+    BOOST_CHECK_EQUAL(filter.median(), 17);
+
+    filter.input(7); // [3 7 15 20 30]
+    BOOST_CHECK_EQUAL(filter.median(), 15);
+
+    filter.input(18); // [3 7 18 20 30]
+    BOOST_CHECK_EQUAL(filter.median(), 18);
+
+    filter.input(0); // [0 3 7 18 30]
+    BOOST_CHECK_EQUAL(filter.median(), 7);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/torcontrol_tests.cpp b/torcontrol_tests.cpp
new file mode 100644
index 0000000..eb98291
--- /dev/null
+++ b/torcontrol_tests.cpp
@@ -0,0 +1,200 @@
+// Copyright (c) 2018 The Salem Cash developers
+// Copyright (c) 2017 The Zcash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+//
+#include <test/test_salemcash.h>
+#include <torcontrol.cpp>
+
+#include <boost/test/unit_test.hpp>
+
+
+BOOST_FIXTURE_TEST_SUITE(torcontrol_tests, BasicTestingSetup)
+
+void CheckSplitTorReplyLine(std::string input, std::string command, std::string args)
+{
+    BOOST_TEST_MESSAGE(std::string("CheckSplitTorReplyLine(") + input + ")");
+    auto ret = SplitTorReplyLine(input);
+    BOOST_CHECK_EQUAL(ret.first, command);
+    BOOST_CHECK_EQUAL(ret.second, args);
+}
+
+BOOST_AUTO_TEST_CASE(util_SplitTorReplyLine)
+{
+    // Data we should receive during normal usage
+    CheckSplitTorReplyLine(
+        "PROTOCOLINFO PIVERSION",
+        "PROTOCOLINFO", "PIVERSION");
+    CheckSplitTorReplyLine(
+        "AUTH METHODS=COOKIE,SAFECOOKIE COOKIEFILE=\"/home/x/.tor/control_auth_cookie\"",
+        "AUTH", "METHODS=COOKIE,SAFECOOKIE COOKIEFILE=\"/home/x/.tor/control_auth_cookie\"");
+    CheckSplitTorReplyLine(
+        "AUTH METHODS=NULL",
+        "AUTH", "METHODS=NULL");
+    CheckSplitTorReplyLine(
+        "AUTH METHODS=HASHEDPASSWORD",
+        "AUTH", "METHODS=HASHEDPASSWORD");
+    CheckSplitTorReplyLine(
+        "VERSION Tor=\"0.2.9.8 (git-a0df013ea241b026)\"",
+        "VERSION", "Tor=\"0.2.9.8 (git-a0df013ea241b026)\"");
+    CheckSplitTorReplyLine(
+        "AUTHCHALLENGE SERVERHASH=aaaa SERVERNONCE=bbbb",
+        "AUTHCHALLENGE", "SERVERHASH=aaaa SERVERNONCE=bbbb");
+
+    // Other valid inputs
+    CheckSplitTorReplyLine("COMMAND", "COMMAND", "");
+    CheckSplitTorReplyLine("COMMAND SOME  ARGS", "COMMAND", "SOME  ARGS");
+
+    // These inputs are valid because PROTOCOLINFO accepts an OtherLine that is
+    // just an OptArguments, which enables multiple spaces to be present
+    // between the command and arguments.
+    CheckSplitTorReplyLine("COMMAND  ARGS", "COMMAND", " ARGS");
+    CheckSplitTorReplyLine("COMMAND   EVEN+more  ARGS", "COMMAND", "  EVEN+more  ARGS");
+}
+
+void CheckParseTorReplyMapping(std::string input, std::map<std::string,std::string> expected)
+{
+    BOOST_TEST_MESSAGE(std::string("CheckParseTorReplyMapping(") + input + ")");
+    auto ret = ParseTorReplyMapping(input);
+    BOOST_CHECK_EQUAL(ret.size(), expected.size());
+    auto r_it = ret.begin();
+    auto e_it = expected.begin();
+    while (r_it != ret.end() && e_it != expected.end()) {
+        BOOST_CHECK_EQUAL(r_it->first, e_it->first);
+        BOOST_CHECK_EQUAL(r_it->second, e_it->second);
+        r_it++;
+        e_it++;
+    }
+}
+
+BOOST_AUTO_TEST_CASE(util_ParseTorReplyMapping)
+{
+    // Data we should receive during normal usage
+    CheckParseTorReplyMapping(
+        "METHODS=COOKIE,SAFECOOKIE COOKIEFILE=\"/home/x/.tor/control_auth_cookie\"", {
+            {"METHODS", "COOKIE,SAFECOOKIE"},
+            {"COOKIEFILE", "/home/x/.tor/control_auth_cookie"},
+        });
+    CheckParseTorReplyMapping(
+        "METHODS=NULL", {
+            {"METHODS", "NULL"},
+        });
+    CheckParseTorReplyMapping(
+        "METHODS=HASHEDPASSWORD", {
+            {"METHODS", "HASHEDPASSWORD"},
+        });
+    CheckParseTorReplyMapping(
+        "Tor=\"0.2.9.8 (git-a0df013ea241b026)\"", {
+            {"Tor", "0.2.9.8 (git-a0df013ea241b026)"},
+        });
+    CheckParseTorReplyMapping(
+        "SERVERHASH=aaaa SERVERNONCE=bbbb", {
+            {"SERVERHASH", "aaaa"},
+            {"SERVERNONCE", "bbbb"},
+        });
+    CheckParseTorReplyMapping(
+        "ServiceID=exampleonion1234", {
+            {"ServiceID", "exampleonion1234"},
+        });
+    CheckParseTorReplyMapping(
+        "PrivateKey=RSA1024:BLOB", {
+            {"PrivateKey", "RSA1024:BLOB"},
+        });
+    CheckParseTorReplyMapping(
+        "ClientAuth=bob:BLOB", {
+            {"ClientAuth", "bob:BLOB"},
+        });
+
+    // Other valid inputs
+    CheckParseTorReplyMapping(
+        "Foo=Bar=Baz Spam=Eggs", {
+            {"Foo", "Bar=Baz"},
+            {"Spam", "Eggs"},
+        });
+    CheckParseTorReplyMapping(
+        "Foo=\"Bar=Baz\"", {
+            {"Foo", "Bar=Baz"},
+        });
+    CheckParseTorReplyMapping(
+        "Foo=\"Bar Baz\"", {
+            {"Foo", "Bar Baz"},
+        });
+
+    // Escapes
+    CheckParseTorReplyMapping(
+        "Foo=\"Bar\\ Baz\"", {
+            {"Foo", "Bar Baz"},
+        });
+    CheckParseTorReplyMapping(
+        "Foo=\"Bar\\Baz\"", {
+            {"Foo", "BarBaz"},
+        });
+    CheckParseTorReplyMapping(
+        "Foo=\"Bar\\@Baz\"", {
+            {"Foo", "Bar@Baz"},
+        });
+    CheckParseTorReplyMapping(
+        "Foo=\"Bar\\\"Baz\" Spam=\"\\\"Eggs\\\"\"", {
+            {"Foo", "Bar\"Baz"},
+            {"Spam", "\"Eggs\""},
+        });
+    CheckParseTorReplyMapping(
+        "Foo=\"Bar\\\\Baz\"", {
+            {"Foo", "Bar\\Baz"},
+        });
+
+    // C escapes
+    CheckParseTorReplyMapping(
+        "Foo=\"Bar\\nBaz\\t\" Spam=\"\\rEggs\" Octals=\"\\1a\\11\\17\\18\\81\\377\\378\\400\\2222\" Final=Check", {
+            {"Foo", "Bar\nBaz\t"},
+            {"Spam", "\rEggs"},
+            {"Octals", "\1a\11\17\1" "881\377\37" "8\40" "0\222" "2"},
+            {"Final", "Check"},
+        });
+    CheckParseTorReplyMapping(
+        "Valid=Mapping Escaped=\"Escape\\\\\"", {
+            {"Valid", "Mapping"},
+            {"Escaped", "Escape\\"},
+        });
+    CheckParseTorReplyMapping(
+        "Valid=Mapping Bare=\"Escape\\\"", {});
+    CheckParseTorReplyMapping(
+        "OneOctal=\"OneEnd\\1\" TwoOctal=\"TwoEnd\\11\"", {
+            {"OneOctal", "OneEnd\1"},
+            {"TwoOctal", "TwoEnd\11"},
+        });
+
+    // Special handling for null case
+    // (needed because string comparison reads the null as end-of-string)
+    BOOST_TEST_MESSAGE(std::string("CheckParseTorReplyMapping(Null=\"\\0\")"));
+    auto ret = ParseTorReplyMapping("Null=\"\\0\"");
+    BOOST_CHECK_EQUAL(ret.size(), 1);
+    auto r_it = ret.begin();
+    BOOST_CHECK_EQUAL(r_it->first, "Null");
+    BOOST_CHECK_EQUAL(r_it->second.size(), 1);
+    BOOST_CHECK_EQUAL(r_it->second[0], '\0');
+
+    // A more complex valid grammar. PROTOCOLINFO accepts a VersionLine that
+    // takes a key=value pair followed by an OptArguments, making this valid.
+    // Because an OptArguments contains no semantic data, there is no point in
+    // parsing it.
+    CheckParseTorReplyMapping(
+        "SOME=args,here MORE optional=arguments  here", {
+            {"SOME", "args,here"},
+        });
+
+    // Inputs that are effectively invalid under the target grammar.
+    // PROTOCOLINFO accepts an OtherLine that is just an OptArguments, which
+    // would make these inputs valid. However,
+    // - This parser is never used in that situation, because the
+    //   SplitTorReplyLine parser enables OtherLine to be skipped.
+    // - Even if these were valid, an OptArguments contains no semantic data,
+    //   so there is no point in parsing it.
+    CheckParseTorReplyMapping("ARGS", {});
+    CheckParseTorReplyMapping("MORE ARGS", {});
+    CheckParseTorReplyMapping("MORE  ARGS", {});
+    CheckParseTorReplyMapping("EVEN more=ARGS", {});
+    CheckParseTorReplyMapping("EVEN+more ARGS", {});
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/transaction_tests.cpp b/transaction_tests.cpp
new file mode 100644
index 0000000..6fd82c9
--- /dev/null
+++ b/transaction_tests.cpp
@@ -0,0 +1,762 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/data/tx_invalid.json.h>
+#include <test/data/tx_valid.json.h>
+#include <test/test_salemcash.h>
+
+#include <clientversion.h>
+#include <checkqueue.h>
+#include <consensus/tx_verify.h>
+#include <consensus/validation.h>
+#include <core_io.h>
+#include <key.h>
+#include <keystore.h>
+#include <validation.h>
+#include <policy/policy.h>
+#include <script/script.h>
+#include <script/sign.h>
+#include <script/script_error.h>
+#include <script/standard.h>
+#include <utilstrencodings.h>
+
+#include <map>
+#include <string>
+
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <univalue.h>
+
+typedef std::vector<unsigned char> valtype;
+
+// In script_tests.cpp
+extern UniValue read_json(const std::string& jsondata);
+
+static std::map<std::string, unsigned int> mapFlagNames = {
+    {std::string("NONE"), (unsigned int)SCRIPT_VERIFY_NONE},
+    {std::string("P2SH"), (unsigned int)SCRIPT_VERIFY_P2SH},
+    {std::string("STRICTENC"), (unsigned int)SCRIPT_VERIFY_STRICTENC},
+    {std::string("DERSIG"), (unsigned int)SCRIPT_VERIFY_DERSIG},
+    {std::string("LOW_S"), (unsigned int)SCRIPT_VERIFY_LOW_S},
+    {std::string("SIGPUSHONLY"), (unsigned int)SCRIPT_VERIFY_SIGPUSHONLY},
+    {std::string("MINIMALDATA"), (unsigned int)SCRIPT_VERIFY_MINIMALDATA},
+    {std::string("NULLDUMMY"), (unsigned int)SCRIPT_VERIFY_NULLDUMMY},
+    {std::string("DISCOURAGE_UPGRADABLE_NOPS"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS},
+    {std::string("CLEANSTACK"), (unsigned int)SCRIPT_VERIFY_CLEANSTACK},
+    {std::string("MINIMALIF"), (unsigned int)SCRIPT_VERIFY_MINIMALIF},
+    {std::string("NULLFAIL"), (unsigned int)SCRIPT_VERIFY_NULLFAIL},
+    {std::string("CHECKLOCKTIMEVERIFY"), (unsigned int)SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY},
+    {std::string("CHECKSEQUENCEVERIFY"), (unsigned int)SCRIPT_VERIFY_CHECKSEQUENCEVERIFY},
+    {std::string("WITNESS"), (unsigned int)SCRIPT_VERIFY_WITNESS},
+    {std::string("DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM},
+    {std::string("WITNESS_PUBKEYTYPE"), (unsigned int)SCRIPT_VERIFY_WITNESS_PUBKEYTYPE},
+};
+
+unsigned int ParseScriptFlags(std::string strFlags)
+{
+    if (strFlags.empty()) {
+        return 0;
+    }
+    unsigned int flags = 0;
+    std::vector<std::string> words;
+    boost::algorithm::split(words, strFlags, boost::algorithm::is_any_of(","));
+
+    for (std::string word : words)
+    {
+        if (!mapFlagNames.count(word))
+            BOOST_ERROR("Bad test: unknown verification flag '" << word << "'");
+        flags |= mapFlagNames[word];
+    }
+
+    return flags;
+}
+
+std::string FormatScriptFlags(unsigned int flags)
+{
+    if (flags == 0) {
+        return "";
+    }
+    std::string ret;
+    std::map<std::string, unsigned int>::const_iterator it = mapFlagNames.begin();
+    while (it != mapFlagNames.end()) {
+        if (flags & it->second) {
+            ret += it->first + ",";
+        }
+        it++;
+    }
+    return ret.substr(0, ret.size() - 1);
+}
+
+BOOST_FIXTURE_TEST_SUITE(transaction_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(tx_valid)
+{
+    // Read tests from test/data/tx_valid.json
+    // Format is an array of arrays
+    // Inner arrays are either [ "comment" ]
+    // or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"], serializedTransaction, verifyFlags
+    // ... where all scripts are stringified scripts.
+    //
+    // verifyFlags is a comma separated list of script verification flags to apply, or "NONE"
+    UniValue tests = read_json(std::string(json_tests::tx_valid, json_tests::tx_valid + sizeof(json_tests::tx_valid)));
+
+    ScriptError err;
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        UniValue test = tests[idx];
+        std::string strTest = test.write();
+        if (test[0].isArray())
+        {
+            if (test.size() != 3 || !test[1].isStr() || !test[2].isStr())
+            {
+                BOOST_ERROR("Bad test: " << strTest);
+                continue;
+            }
+
+            std::map<COutPoint, CScript> mapprevOutScriptPubKeys;
+            std::map<COutPoint, int64_t> mapprevOutValues;
+            UniValue inputs = test[0].get_array();
+            bool fValid = true;
+	    for (unsigned int inpIdx = 0; inpIdx < inputs.size(); inpIdx++) {
+	        const UniValue& input = inputs[inpIdx];
+                if (!input.isArray())
+                {
+                    fValid = false;
+                    break;
+                }
+                UniValue vinput = input.get_array();
+                if (vinput.size() < 3 || vinput.size() > 4)
+                {
+                    fValid = false;
+                    break;
+                }
+                COutPoint outpoint(uint256S(vinput[0].get_str()), vinput[1].get_int());
+                mapprevOutScriptPubKeys[outpoint] = ParseScript(vinput[2].get_str());
+                if (vinput.size() >= 4)
+                {
+                    mapprevOutValues[outpoint] = vinput[3].get_int64();
+                }
+            }
+            if (!fValid)
+            {
+                BOOST_ERROR("Bad test: " << strTest);
+                continue;
+            }
+
+            std::string transaction = test[1].get_str();
+            CDataStream stream(ParseHex(transaction), SER_NETWORK, PROTOCOL_VERSION);
+            CTransaction tx(deserialize, stream);
+
+            CValidationState state;
+            BOOST_CHECK_MESSAGE(CheckTransaction(tx, state), strTest);
+            BOOST_CHECK(state.IsValid());
+
+            PrecomputedTransactionData txdata(tx);
+            for (unsigned int i = 0; i < tx.vin.size(); i++)
+            {
+                if (!mapprevOutScriptPubKeys.count(tx.vin[i].prevout))
+                {
+                    BOOST_ERROR("Bad test: " << strTest);
+                    break;
+                }
+
+                CAmount amount = 0;
+                if (mapprevOutValues.count(tx.vin[i].prevout)) {
+                    amount = mapprevOutValues[tx.vin[i].prevout];
+                }
+                unsigned int verify_flags = ParseScriptFlags(test[2].get_str());
+                const CScriptWitness *witness = &tx.vin[i].scriptWitness;
+                BOOST_CHECK_MESSAGE(VerifyScript(tx.vin[i].scriptSig, mapprevOutScriptPubKeys[tx.vin[i].prevout],
+                                                 witness, verify_flags, TransactionSignatureChecker(&tx, i, amount, txdata), &err),
+                                    strTest);
+                BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+            }
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(tx_invalid)
+{
+    // Read tests from test/data/tx_invalid.json
+    // Format is an array of arrays
+    // Inner arrays are either [ "comment" ]
+    // or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"], serializedTransaction, verifyFlags
+    // ... where all scripts are stringified scripts.
+    //
+    // verifyFlags is a comma separated list of script verification flags to apply, or "NONE"
+    UniValue tests = read_json(std::string(json_tests::tx_invalid, json_tests::tx_invalid + sizeof(json_tests::tx_invalid)));
+
+    // Initialize to SCRIPT_ERR_OK. The tests expect err to be changed to a
+    // value other than SCRIPT_ERR_OK.
+    ScriptError err = SCRIPT_ERR_OK;
+    for (unsigned int idx = 0; idx < tests.size(); idx++) {
+        UniValue test = tests[idx];
+        std::string strTest = test.write();
+        if (test[0].isArray())
+        {
+            if (test.size() != 3 || !test[1].isStr() || !test[2].isStr())
+            {
+                BOOST_ERROR("Bad test: " << strTest);
+                continue;
+            }
+
+            std::map<COutPoint, CScript> mapprevOutScriptPubKeys;
+            std::map<COutPoint, int64_t> mapprevOutValues;
+            UniValue inputs = test[0].get_array();
+            bool fValid = true;
+	    for (unsigned int inpIdx = 0; inpIdx < inputs.size(); inpIdx++) {
+	        const UniValue& input = inputs[inpIdx];
+                if (!input.isArray())
+                {
+                    fValid = false;
+                    break;
+                }
+                UniValue vinput = input.get_array();
+                if (vinput.size() < 3 || vinput.size() > 4)
+                {
+                    fValid = false;
+                    break;
+                }
+                COutPoint outpoint(uint256S(vinput[0].get_str()), vinput[1].get_int());
+                mapprevOutScriptPubKeys[outpoint] = ParseScript(vinput[2].get_str());
+                if (vinput.size() >= 4)
+                {
+                    mapprevOutValues[outpoint] = vinput[3].get_int64();
+                }
+            }
+            if (!fValid)
+            {
+                BOOST_ERROR("Bad test: " << strTest);
+                continue;
+            }
+
+            std::string transaction = test[1].get_str();
+            CDataStream stream(ParseHex(transaction), SER_NETWORK, PROTOCOL_VERSION );
+            CTransaction tx(deserialize, stream);
+
+            CValidationState state;
+            fValid = CheckTransaction(tx, state) && state.IsValid();
+
+            PrecomputedTransactionData txdata(tx);
+            for (unsigned int i = 0; i < tx.vin.size() && fValid; i++)
+            {
+                if (!mapprevOutScriptPubKeys.count(tx.vin[i].prevout))
+                {
+                    BOOST_ERROR("Bad test: " << strTest);
+                    break;
+                }
+
+                unsigned int verify_flags = ParseScriptFlags(test[2].get_str());
+                CAmount amount = 0;
+                if (mapprevOutValues.count(tx.vin[i].prevout)) {
+                    amount = mapprevOutValues[tx.vin[i].prevout];
+                }
+                const CScriptWitness *witness = &tx.vin[i].scriptWitness;
+                fValid = VerifyScript(tx.vin[i].scriptSig, mapprevOutScriptPubKeys[tx.vin[i].prevout],
+                                      witness, verify_flags, TransactionSignatureChecker(&tx, i, amount, txdata), &err);
+            }
+            BOOST_CHECK_MESSAGE(!fValid, strTest);
+            BOOST_CHECK_MESSAGE(err != SCRIPT_ERR_OK, ScriptErrorString(err));
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(basic_transaction_tests)
+{
+    // Random real transaction (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
+    unsigned char ch[] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f, 0xcd, 0x4f, 0x85, 0x65, 0xef, 0x40, 0x6d, 0xd5, 0xd6, 0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8, 0x20, 0x27, 0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f, 0x74, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77, 0x37, 0x57, 0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f, 0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c, 0x02, 0x21, 0x00, 0xd2, 0x5b, 0x5c, 0x87, 0x04, 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e, 0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27, 0xc4, 0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2, 0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a, 0x6c, 0xf9, 0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34, 0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff, 0x9a, 0x2e, 0xe1, 0x97, 0x8d, 0xd7, 0xfd, 0x01, 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b, 0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb, 0x0f, 0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b, 0xa7, 0x94, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef, 0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0, 0x39, 0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93, 0xed, 0x51, 0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43, 0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00};
+    std::vector<unsigned char> vch(ch, ch + sizeof(ch) -1);
+    CDataStream stream(vch, SER_DISK, CLIENT_VERSION);
+    CMutableTransaction tx;
+    stream >> tx;
+    CValidationState state;
+    BOOST_CHECK_MESSAGE(CheckTransaction(tx, state) && state.IsValid(), "Simple deserialized transaction should be valid.");
+
+    // Check that duplicate txins fail
+    tx.vin.push_back(tx.vin[0]);
+    BOOST_CHECK_MESSAGE(!CheckTransaction(tx, state) || !state.IsValid(), "Transaction with duplicate txins should be invalid.");
+}
+
+//
+// Helper: create two dummy transactions, each with
+// two outputs.  The first has 11 and 50 CENT outputs
+// paid to a TX_PUBKEY, the second 21 and 22 CENT outputs
+// paid to a TX_PUBKEYHASH.
+//
+static std::vector<CMutableTransaction>
+SetupDummyInputs(CBasicKeyStore& keystoreRet, CCashViewCache& cashRet)
+{
+    std::vector<CMutableTransaction> dummyTransactions;
+    dummyTransactions.resize(2);
+
+    // Add some keys to the keystore:
+    CKey key[4];
+    for (int i = 0; i < 4; i++)
+    {
+        key[i].MakeNewKey(i % 2);
+        keystoreRet.AddKey(key[i]);
+    }
+
+    // Create some dummy input transactions
+    dummyTransactions[0].vout.resize(2);
+    dummyTransactions[0].vout[0].nValue = 11*CENT;
+    dummyTransactions[0].vout[0].scriptPubKey << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
+    dummyTransactions[0].vout[1].nValue = 50*CENT;
+    dummyTransactions[0].vout[1].scriptPubKey << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
+    AddCoins(coinsRet, dummyTransactions[0], 0);
+
+    dummyTransactions[1].vout.resize(2);
+    dummyTransactions[1].vout[0].nValue = 21*CENT;
+    dummyTransactions[1].vout[0].scriptPubKey = GetScriptForDestination(key[2].GetPubKey().GetID());
+    dummyTransactions[1].vout[1].nValue = 22*CENT;
+    dummyTransactions[1].vout[1].scriptPubKey = GetScriptForDestination(key[3].GetPubKey().GetID());
+    AddCoins(coinsRet, dummyTransactions[1], 0);
+
+    return dummyTransactions;
+}
+
+BOOST_AUTO_TEST_CASE(test_Get)
+{
+    CBasicKeyStore keystore;
+    CCashView cashDummy;
+    CCashViewCache cash(&cashDummy);
+    std::vector<CMutableTransaction> dummyTransactions = SetupDummyInputs(keystore, cash);
+
+    CMutableTransaction t1;
+    t1.vin.resize(3);
+    t1.vin[0].prevout.hash = dummyTransactions[0].GetHash();
+    t1.vin[0].prevout.n = 1;
+    t1.vin[0].scriptSig << std::vector<unsigned char>(65, 0);
+    t1.vin[1].prevout.hash = dummyTransactions[1].GetHash();
+    t1.vin[1].prevout.n = 0;
+    t1.vin[1].scriptSig << std::vector<unsigned char>(65, 0) << std::vector<unsigned char>(33, 4);
+    t1.vin[2].prevout.hash = dummyTransactions[1].GetHash();
+    t1.vin[2].prevout.n = 1;
+    t1.vin[2].scriptSig << std::vector<unsigned char>(65, 0) << std::vector<unsigned char>(33, 4);
+    t1.vout.resize(2);
+    t1.vout[0].nValue = 90*CENT;
+    t1.vout[0].scriptPubKey << OP_1;
+
+    BOOST_CHECK(AreInputsStandard(t1, coins));
+    BOOST_CHECK_EQUAL(coins.GetValueIn(t1), (50+21+22)*CENT);
+}
+
+void CreateCreditAndSpend(const CKeyStore& keystore, const CScript& outscript, CTransactionRef& output, CMutableTransaction& input, bool success = true)
+{
+    CMutableTransaction outputm;
+    outputm.nVersion = 1;
+    outputm.vin.resize(1);
+    outputm.vin[0].prevout.SetNull();
+    outputm.vin[0].scriptSig = CScript();
+    outputm.vout.resize(1);
+    outputm.vout[0].nValue = 1;
+    outputm.vout[0].scriptPubKey = outscript;
+    CDataStream ssout(SER_NETWORK, PROTOCOL_VERSION);
+    ssout << outputm;
+    ssout >> output;
+    assert(output->vin.size() == 1);
+    assert(output->vin[0] == outputm.vin[0]);
+    assert(output->vout.size() == 1);
+    assert(output->vout[0] == outputm.vout[0]);
+
+    CMutableTransaction inputm;
+    inputm.nVersion = 1;
+    inputm.vin.resize(1);
+    inputm.vin[0].prevout.hash = output->GetHash();
+    inputm.vin[0].prevout.n = 0;
+    inputm.vout.resize(1);
+    inputm.vout[0].nValue = 1;
+    inputm.vout[0].scriptPubKey = CScript();
+    bool ret = SignSignature(keystore, *output, inputm, 0, SIGHASH_ALL);
+    assert(ret == success);
+    CDataStream ssin(SER_NETWORK, PROTOCOL_VERSION);
+    ssin << inputm;
+    ssin >> input;
+    assert(input.vin.size() == 1);
+    assert(input.vin[0] == inputm.vin[0]);
+    assert(input.vout.size() == 1);
+    assert(input.vout[0] == inputm.vout[0]);
+    assert(input.vin[0].scriptWitness.stack == inputm.vin[0].scriptWitness.stack);
+}
+
+void CheckWithFlag(const CTransactionRef& output, const CMutableTransaction& input, int flags, bool success)
+{
+    ScriptError error;
+    CTransaction inputi(input);
+    bool ret = VerifyScript(inputi.vin[0].scriptSig, output->vout[0].scriptPubKey, &inputi.vin[0].scriptWitness, flags, TransactionSignatureChecker(&inputi, 0, output->vout[0].nValue), &error);
+    assert(ret == success);
+}
+
+static CScript PushAll(const std::vector<valtype>& values)
+{
+    CScript result;
+    for (const valtype& v : values) {
+        if (v.size() == 0) {
+            result << OP_0;
+        } else if (v.size() == 1 && v[0] >= 1 && v[0] <= 16) {
+            result << CScript::EncodeOP_N(v[0]);
+        } else {
+            result << v;
+        }
+    }
+    return result;
+}
+
+void ReplaceRedeemScript(CScript& script, const CScript& redeemScript)
+{
+    std::vector<valtype> stack;
+    EvalScript(stack, script, SCRIPT_VERIFY_STRICTENC, BaseSignatureChecker(), SIGVERSION_BASE);
+    assert(stack.size() > 0);
+    stack.back() = std::vector<unsigned char>(redeemScript.begin(), redeemScript.end());
+    script = PushAll(stack);
+}
+
+BOOST_AUTO_TEST_CASE(test_big_witness_transaction) {
+    CMutableTransaction mtx;
+    mtx.nVersion = 1;
+
+    CKey key;
+    key.MakeNewKey(true); // Need to use compressed keys in segwit or the signing will fail
+    CBasicKeyStore keystore;
+    keystore.AddKeyPubKey(key, key.GetPubKey());
+    CKeyID hash = key.GetPubKey().GetID();
+    CScript scriptPubKey = CScript() << OP_0 << std::vector<unsigned char>(hash.begin(), hash.end());
+
+    std::vector<int> sigHashes;
+    sigHashes.push_back(SIGHASH_NONE | SIGHASH_ANYONECANPAY);
+    sigHashes.push_back(SIGHASH_SINGLE | SIGHASH_ANYONECANPAY);
+    sigHashes.push_back(SIGHASH_ALL | SIGHASH_ANYONECANPAY);
+    sigHashes.push_back(SIGHASH_NONE);
+    sigHashes.push_back(SIGHASH_SINGLE);
+    sigHashes.push_back(SIGHASH_ALL);
+
+    // create a big transaction of 4500 inputs signed by the same key
+    for(uint32_t ij = 0; ij < 4500; ij++) {
+        uint32_t i = mtx.vin.size();
+        uint256 prevId;
+        prevId.SetHex("0000000000000000000000000000000000000000000000000000000000000100");
+        COutPoint outpoint(prevId, i);
+
+        mtx.vin.resize(mtx.vin.size() + 1);
+        mtx.vin[i].prevout = outpoint;
+        mtx.vin[i].scriptSig = CScript();
+
+        mtx.vout.resize(mtx.vout.size() + 1);
+        mtx.vout[i].nValue = 1000;
+        mtx.vout[i].scriptPubKey = CScript() << OP_1;
+    }
+
+    // sign all inputs
+    for(uint32_t i = 0; i < mtx.vin.size(); i++) {
+        bool hashSigned = SignSignature(keystore, scriptPubKey, mtx, i, 1000, sigHashes.at(i % sigHashes.size()));
+        assert(hashSigned);
+    }
+
+    CDataStream ssout(SER_NETWORK, PROTOCOL_VERSION);
+    auto vstream = WithOrVersion(&ssout, 0);
+    vstream << mtx;
+    CTransaction tx(deserialize, vstream);
+
+    // check all inputs concurrently, with the cache
+    PrecomputedTransactionData txdata(tx);
+    boost::thread_group threadGroup;
+    CCheckQueue<CScriptCheck> scriptcheckqueue(128);
+    CCheckQueueControl<CScriptCheck> control(&scriptcheckqueue);
+
+    for (int i=0; i<20; i++)
+        threadGroup.create_thread(boost::bind(&CCheckQueue<CScriptCheck>::Thread, boost::ref(scriptcheckqueue)));
+
+    std::vector<Cash> cash;
+    for(uint32_t i = 0; i < mtx.vin.size(); i++) {
+        Cash cash;
+        cash.nHeight = 1;
+        cash.fCashBase = false;
+        cash.out.nValue = 1000;
+        cash.out.scriptPubKey = scriptPubKey;
+        cash.emplace_back(std::move(cash));
+    }
+
+    for(uint32_t i = 0; i < mtx.vin.size(); i++) {
+        std::vector<CScriptCheck> vChecks;
+        CScriptCheck check(cash[tx.vin[i].prevout.n].out, tx, i, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, false, &txdata);
+        vChecks.push_back(CScriptCheck());
+        check.swap(vChecks.back());
+        control.Add(vChecks);
+    }
+
+    bool controlCheck = control.Wait();
+    assert(controlCheck);
+
+    threadGroup.interrupt_all();
+    threadGroup.join_all();
+}
+
+BOOST_AUTO_TEST_CASE(test_witness)
+{
+    CBasicKeyStore keystore, keystore2;
+    CKey key1, key2, key3, key1L, key2L;
+    CPubKey pubkey1, pubkey2, pubkey3, pubkey1L, pubkey2L;
+    key1.MakeNewKey(true);
+    key2.MakeNewKey(true);
+    key3.MakeNewKey(true);
+    key1L.MakeNewKey(false);
+    key2L.MakeNewKey(false);
+    pubkey1 = key1.GetPubKey();
+    pubkey2 = key2.GetPubKey();
+    pubkey3 = key3.GetPubKey();
+    pubkey1L = key1L.GetPubKey();
+    pubkey2L = key2L.GetPubKey();
+    keystore.AddKeyPubKey(key1, pubkey1);
+    keystore.AddKeyPubKey(key2, pubkey2);
+    keystore.AddKeyPubKey(key1L, pubkey1L);
+    keystore.AddKeyPubKey(key2L, pubkey2L);
+    CScript scriptPubkey1, scriptPubkey2, scriptPubkey1L, scriptPubkey2L, scriptMulti;
+    scriptPubkey1 << ToByteVector(pubkey1) << OP_CHECKSIG;
+    scriptPubkey2 << ToByteVector(pubkey2) << OP_CHECKSIG;
+    scriptPubkey1L << ToByteVector(pubkey1L) << OP_CHECKSIG;
+    scriptPubkey2L << ToByteVector(pubkey2L) << OP_CHECKSIG;
+    std::vector<CPubKey> oneandthree;
+    oneandthree.push_back(pubkey1);
+    oneandthree.push_back(pubkey3);
+    scriptMulti = GetScriptForMultisig(2, oneandthree);
+    keystore.AddCScript(scriptPubkey1);
+    keystore.AddCScript(scriptPubkey2);
+    keystore.AddCScript(scriptPubkey1L);
+    keystore.AddCScript(scriptPubkey2L);
+    keystore.AddCScript(scriptMulti);
+    keystore.AddCScript(GetScriptForWitness(scriptPubkey1));
+    keystore.AddCScript(GetScriptForWitness(scriptPubkey2));
+    keystore.AddCScript(GetScriptForWitness(scriptPubkey1L));
+    keystore.AddCScript(GetScriptForWitness(scriptPubkey2L));
+    keystore.AddCScript(GetScriptForWitness(scriptMulti));
+    keystore2.AddCScript(scriptMulti);
+    keystore2.AddCScript(GetScriptForWitness(scriptMulti));
+    keystore2.AddKeyPubKey(key3, pubkey3);
+
+    CTransactionRef output1, output2;
+    CMutableTransaction input1, input2;
+    SignatureData sigdata;
+
+    // Normal pay-to-compressed-pubkey.
+    CreateCreditAndSpend(keystore, scriptPubkey1, output1, input1);
+    CreateCreditAndSpend(keystore, scriptPubkey2, output2, input2);
+    CheckWithFlag(output1, input1, 0, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
+    CheckWithFlag(output1, input2, 0, false);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_P2SH, false);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false);
+    CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
+
+    // P2SH pay-to-compressed-pubkey.
+    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(scriptPubkey1)), output1, input1);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(scriptPubkey2)), output2, input2);
+    ReplaceRedeemScript(input2.vin[0].scriptSig, scriptPubkey1);
+    CheckWithFlag(output1, input1, 0, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
+    CheckWithFlag(output1, input2, 0, true);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_P2SH, false);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false);
+    CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
+
+    // Witness pay-to-compressed-pubkey (v0).
+    CreateCreditAndSpend(keystore, GetScriptForWitness(scriptPubkey1), output1, input1);
+    CreateCreditAndSpend(keystore, GetScriptForWitness(scriptPubkey2), output2, input2);
+    CheckWithFlag(output1, input1, 0, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
+    CheckWithFlag(output1, input2, 0, true);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false);
+    CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
+
+    // P2SH witness pay-to-compressed-pubkey (v0).
+    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptPubkey1))), output1, input1);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptPubkey2))), output2, input2);
+    ReplaceRedeemScript(input2.vin[0].scriptSig, GetScriptForWitness(scriptPubkey1));
+    CheckWithFlag(output1, input1, 0, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
+    CheckWithFlag(output1, input2, 0, true);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false);
+    CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
+
+    // Normal pay-to-uncompressed-pubkey.
+    CreateCreditAndSpend(keystore, scriptPubkey1L, output1, input1);
+    CreateCreditAndSpend(keystore, scriptPubkey2L, output2, input2);
+    CheckWithFlag(output1, input1, 0, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
+    CheckWithFlag(output1, input2, 0, false);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_P2SH, false);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false);
+    CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
+
+    // P2SH pay-to-uncompressed-pubkey.
+    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(scriptPubkey1L)), output1, input1);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(scriptPubkey2L)), output2, input2);
+    ReplaceRedeemScript(input2.vin[0].scriptSig, scriptPubkey1L);
+    CheckWithFlag(output1, input1, 0, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
+    CheckWithFlag(output1, input2, 0, true);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_P2SH, false);
+    CheckWithFlag(output1, input2, SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false);
+    CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
+
+    // Signing disabled for witness pay-to-uncompressed-pubkey (v1).
+    CreateCreditAndSpend(keystore, GetScriptForWitness(scriptPubkey1L), output1, input1, false);
+    CreateCreditAndSpend(keystore, GetScriptForWitness(scriptPubkey2L), output2, input2, false);
+
+    // Signing disabled for P2SH witness pay-to-uncompressed-pubkey (v1).
+    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptPubkey1L))), output1, input1, false);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptPubkey2L))), output2, input2, false);
+
+    // Normal 2-of-2 multisig
+    CreateCreditAndSpend(keystore, scriptMulti, output1, input1, false);
+    CheckWithFlag(output1, input1, 0, false);
+    CreateCreditAndSpend(keystore2, scriptMulti, output2, input2, false);
+    CheckWithFlag(output2, input2, 0, false);
+    BOOST_CHECK(*output1 == *output2);
+    UpdateTransaction(input1, 0, CombineSignatures(output1->vout[0].scriptPubKey, MutableTransactionSignatureChecker(&input1, 0, output1->vout[0].nValue), DataFromTransaction(input1, 0), DataFromTransaction(input2, 0)));
+    CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
+
+    // P2SH 2-of-2 multisig
+    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(scriptMulti)), output1, input1, false);
+    CheckWithFlag(output1, input1, 0, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, false);
+    CreateCreditAndSpend(keystore2, GetScriptForDestination(CScriptID(scriptMulti)), output2, input2, false);
+    CheckWithFlag(output2, input2, 0, true);
+    CheckWithFlag(output2, input2, SCRIPT_VERIFY_P2SH, false);
+    BOOST_CHECK(*output1 == *output2);
+    UpdateTransaction(input1, 0, CombineSignatures(output1->vout[0].scriptPubKey, MutableTransactionSignatureChecker(&input1, 0, output1->vout[0].nValue), DataFromTransaction(input1, 0), DataFromTransaction(input2, 0)));
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
+
+    // Witness 2-of-2 multisig
+    CreateCreditAndSpend(keystore, GetScriptForWitness(scriptMulti), output1, input1, false);
+    CheckWithFlag(output1, input1, 0, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, false);
+    CreateCreditAndSpend(keystore2, GetScriptForWitness(scriptMulti), output2, input2, false);
+    CheckWithFlag(output2, input2, 0, true);
+    CheckWithFlag(output2, input2, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, false);
+    BOOST_CHECK(*output1 == *output2);
+    UpdateTransaction(input1, 0, CombineSignatures(output1->vout[0].scriptPubKey, MutableTransactionSignatureChecker(&input1, 0, output1->vout[0].nValue), DataFromTransaction(input1, 0), DataFromTransaction(input2, 0)));
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true);
+    CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
+
+    // P2SH witness 2-of-2 multisig
+    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptMulti))), output1, input1, false);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, false);
+    CreateCreditAndSpend(keystore2, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptMulti))), output2, input2, false);
+    CheckWithFlag(output2, input2, SCRIPT_VERIFY_P2SH, true);
+    CheckWithFlag(output2, input2, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, false);
+    BOOST_CHECK(*output1 == *output2);
+    UpdateTransaction(input1, 0, CombineSignatures(output1->vout[0].scriptPubKey, MutableTransactionSignatureChecker(&input1, 0, output1->vout[0].nValue), DataFromTransaction(input1, 0), DataFromTransaction(input2, 0)));
+    CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true);
+    CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
+}
+
+BOOST_AUTO_TEST_CASE(test_IsStandard)
+{
+    LOCK(cs_main);
+    CBasicKeyStore keystore;
+    CCashView cashDummy;
+    CCashViewCache cash(&cashDummy);
+    std::vector<CMutableTransaction> dummyTransactions = SetupDummyInputs(keystore, coins);
+
+    CMutableTransaction t;
+    t.vin.resize(1);
+    t.vin[0].prevout.hash = dummyTransactions[0].GetHash();
+    t.vin[0].prevout.n = 1;
+    t.vin[0].scriptSig << std::vector<unsigned char>(65, 0);
+    t.vout.resize(1);
+    t.vout[0].nValue = 90*CENT;
+    CKey key;
+    key.MakeNewKey(true);
+    t.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
+
+    std::string reason;
+    BOOST_CHECK(IsStandardTx(t, reason));
+
+    // Check dust with default relay fee:
+    CAmount nDustThreshold = 182 * dustRelayFee.GetFeePerK()/1000;
+    BOOST_CHECK_EQUAL(nDustThreshold, 546);
+    // dust:
+    t.vout[0].nValue = nDustThreshold - 1;
+    BOOST_CHECK(!IsStandardTx(t, reason));
+    // not dust:
+    t.vout[0].nValue = nDustThreshold;
+    BOOST_CHECK(IsStandardTx(t, reason));
+
+    // Check dust with odd relay fee to verify rounding:
+    // nDustThreshold = 182 * 3702 / 1000
+    dustRelayFee = CFeeRate(3702);
+    // dust:
+    t.vout[0].nValue = 673 - 1;
+    BOOST_CHECK(!IsStandardTx(t, reason));
+    // not dust:
+    t.vout[0].nValue = 673;
+    BOOST_CHECK(IsStandardTx(t, reason));
+    dustRelayFee = CFeeRate(DUST_RELAY_TX_FEE);
+
+    t.vout[0].scriptPubKey = CScript() << OP_1;
+    BOOST_CHECK(!IsStandardTx(t, reason));
+
+    // MAX_OP_RETURN_RELAY-byte TX_NULL_DATA (standard)
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
+    BOOST_CHECK_EQUAL(MAX_OP_RETURN_RELAY, t.vout[0].scriptPubKey.size());
+    BOOST_CHECK(IsStandardTx(t, reason));
+
+    // MAX_OP_RETURN_RELAY+1-byte TX_NULL_DATA (non-standard)
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3804678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3800");
+    BOOST_CHECK_EQUAL(MAX_OP_RETURN_RELAY + 1, t.vout[0].scriptPubKey.size());
+    BOOST_CHECK(!IsStandardTx(t, reason));
+
+    // Data payload can be encoded in any way...
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("");
+    BOOST_CHECK(IsStandardTx(t, reason));
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("00") << ParseHex("01");
+    BOOST_CHECK(IsStandardTx(t, reason));
+    // OP_RESERVED *is* considered to be a PUSHDATA type opcode by IsPushOnly()!
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN << OP_RESERVED << -1 << 0 << ParseHex("01") << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15 << 16;
+    BOOST_CHECK(IsStandardTx(t, reason));
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN << 0 << ParseHex("01") << 2 << ParseHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+    BOOST_CHECK(IsStandardTx(t, reason));
+
+    // ...so long as it only contains PUSHDATA's
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN << OP_RETURN;
+    BOOST_CHECK(!IsStandardTx(t, reason));
+
+    // TX_NULL_DATA w/o PUSHDATA
+    t.vout.resize(1);
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN;
+    BOOST_CHECK(IsStandardTx(t, reason));
+
+    // Only one TX_NULL_DATA permitted in all cases
+    t.vout.resize(2);
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
+    t.vout[1].scriptPubKey = CScript() << OP_RETURN << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
+    BOOST_CHECK(!IsStandardTx(t, reason));
+
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38");
+    t.vout[1].scriptPubKey = CScript() << OP_RETURN;
+    BOOST_CHECK(!IsStandardTx(t, reason));
+
+    t.vout[0].scriptPubKey = CScript() << OP_RETURN;
+    t.vout[1].scriptPubKey = CScript() << OP_RETURN;
+    BOOST_CHECK(!IsStandardTx(t, reason));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/txvalidation_tests.cpp b/txvalidation_tests.cpp
new file mode 100644
index 0000000..20b28ef
--- /dev/null
+++ b/txvalidation_tests.cpp
@@ -0,0 +1,61 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <validation.h>
+#include <txmempool.h>
+#include <amount.h>
+#include <consensus/validation.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+
+
+BOOST_AUTO_TEST_SUITE(txvalidation_tests)
+
+/**
+ * Ensure that the mempool won't accept coinbase transactions.
+ */
+BOOST_FIXTURE_TEST_CASE(tx_mempool_reject_coinbase, TestChain100Setup)
+{
+    CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
+    CMutableTransaction coinbaseTx;
+
+    coinbaseTx.nVersion = 1;
+    coinbaseTx.vin.resize(1);
+    coinbaseTx.vout.resize(1);
+    coinbaseTx.vin[0].scriptSig = CScript() << OP_11 << OP_EQUAL;
+    coinbaseTx.vout[0].nValue = 1 * CENT;
+    coinbaseTx.vout[0].scriptPubKey = scriptPubKey;
+
+    assert(CTransaction(coinbaseTx).IsCoinBase());
+
+    CValidationState state;
+
+    LOCK(cs_main);
+
+    unsigned int initialPoolSize = mempool.size();
+
+    BOOST_CHECK_EQUAL(
+            false,
+            AcceptToMemoryPool(mempool, state, MakeTransactionRef(coinbaseTx),
+                nullptr /* pfMissingInputs */,
+                nullptr /* plTxnReplaced */,
+                true /* bypass_limits */,
+                0 /* nAbsurdFee */));
+
+    // Check that the transaction hasn't been added to mempool.
+    BOOST_CHECK_EQUAL(mempool.size(), initialPoolSize);
+
+    // Check that the validation state reflects the unsuccessful attempt.
+    BOOST_CHECK(state.IsInvalid());
+    BOOST_CHECK_EQUAL(state.GetRejectReason(), "coinbase");
+
+    int nDoS;
+    BOOST_CHECK_EQUAL(state.IsInvalid(nDoS), true);
+    BOOST_CHECK_EQUAL(nDoS, 100);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/txvalidationcache_tests.cpp b/txvalidationcache_tests.cpp
new file mode 100644
index 0000000..34898ae
--- /dev/null
+++ b/txvalidationcache_tests.cpp
@@ -0,0 +1,371 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <consensus/validation.h>
+#include <key.h>
+#include <validation.h>
+#include <miner.h>
+#include <pubkey.h>
+#include <txmempool.h>
+#include <random.h>
+#include <script/standard.h>
+#include <script/sign.h>
+#include <test/test_salemcash.h>
+#include <utiltime.h>
+#include <core_io.h>
+#include <keystore.h>
+#include <policy/policy.h>
+
+#include <boost/test/unit_test.hpp>
+
+bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCashViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks);
+
+BOOST_AUTO_TEST_SUITE(tx_validationcache_tests)
+
+static bool
+ToMemPool(CMutableTransaction& tx)
+{
+    LOCK(cs_main);
+
+    CValidationState state;
+    return AcceptToMemoryPool(mempool, state, MakeTransactionRef(tx), nullptr /* pfMissingInputs */,
+                              nullptr /* plTxnReplaced */, true /* bypass_limits */, 0 /* nAbsurdFee */);
+}
+
+BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, TestChain100Setup)
+{
+    // Make sure skipping validation of transactions that were
+    // validated going into the memory pool does not allow
+    // double-spends in blocks to pass validation when they should not.
+
+    CScript scriptPubKey = CScript() <<  ToByteVector(cashbaseKey.GetPubKey()) << OP_CHECKSIG;
+
+    // Create a double-spend of mature coinbase txn:
+    std::vector<CMutableTransaction> spends;
+    spends.resize(2);
+    for (int i = 0; i < 2; i++)
+    {
+        spends[i].nVersion = 1;
+        spends[i].vin.resize(1);
+        spends[i].vin[0].prevout.hash = coinbaseTxns[0].GetHash();
+        spends[i].vin[0].prevout.n = 0;
+        spends[i].vout.resize(1);
+        spends[i].vout[0].nValue = 11*CENT;
+        spends[i].vout[0].scriptPubKey = scriptPubKey;
+
+        // Sign:
+        std::vector<unsigned char> vchSig;
+        uint256 hash = SignatureHash(scriptPubKey, spends[i], 0, SIGHASH_ALL, 0, SIGVERSION_BASE);
+        BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
+        vchSig.push_back((unsigned char)SIGHASH_ALL);
+        spends[i].vin[0].scriptSig << vchSig;
+    }
+
+    CBlock block;
+
+    // Test 1: block with both of those transactions should be rejected.
+    block = CreateAndProcessBlock(spends, scriptPubKey);
+    BOOST_CHECK(chainActive.Tip()->GetBlockHash() != block.GetHash());
+
+    // Test 2: ... and should be rejected if spend1 is in the memory pool
+    BOOST_CHECK(ToMemPool(spends[0]));
+    block = CreateAndProcessBlock(spends, scriptPubKey);
+    BOOST_CHECK(chainActive.Tip()->GetBlockHash() != block.GetHash());
+    mempool.clear();
+
+    // Test 3: ... and should be rejected if spend2 is in the memory pool
+    BOOST_CHECK(ToMemPool(spends[1]));
+    block = CreateAndProcessBlock(spends, scriptPubKey);
+    BOOST_CHECK(chainActive.Tip()->GetBlockHash() != block.GetHash());
+    mempool.clear();
+
+    // Final sanity test: first spend in mempool, second in block, that's OK:
+    std::vector<CMutableTransaction> oneSpend;
+    oneSpend.push_back(spends[0]);
+    BOOST_CHECK(ToMemPool(spends[1]));
+    block = CreateAndProcessBlock(oneSpend, scriptPubKey);
+    BOOST_CHECK(chainActive.Tip()->GetBlockHash() == block.GetHash());
+    // spends[1] should have been removed from the mempool when the
+    // block with spends[0] is accepted:
+    BOOST_CHECK_EQUAL(mempool.size(), 0);
+}
+
+// Run CheckInputs (using pcashTip) on the given transaction, for all script
+// flags.  Test that CheckInputs passes for all flags that don't overlap with
+// the failing_flags argument, but otherwise fails.
+// CHECKLOCKTIMEVERIFY and CHECKSEQUENCEVERIFY (and future NOP codes that may
+// get reassigned) have an interaction with DISCOURAGE_UPGRADABLE_NOPS: if
+// the script flags used contain DISCOURAGE_UPGRADABLE_NOPS but don't contain
+// CHECKLOCKTIMEVERIFY (or CHECKSEQUENCEVERIFY), but the script does contain
+// OP_CHECKLOCKTIMEVERIFY (or OP_CHECKSEQUENCEVERIFY), then script execution
+// should fail.
+// Capture this interaction with the upgraded_nop argument: set it when evaluating
+// any script flag that is implemented as an upgraded NOP code.
+void ValidateCheckInputsForAllFlags(CMutableTransaction &tx, uint32_t failing_flags, bool add_to_cache)
+{
+    PrecomputedTransactionData txdata(tx);
+    // If we add many more flags, this loop can get too expensive, but we can
+    // rewrite in the future to randomly pick a set of flags to evaluate.
+    for (uint32_t test_flags=0; test_flags < (1U << 16); test_flags += 1) {
+        CValidationState state;
+        // Filter out incompatible flag choices
+        if ((test_flags & SCRIPT_VERIFY_CLEANSTACK)) {
+            // CLEANSTACK requires P2SH and WITNESS, see VerifyScript() in
+            // script/interpreter.cpp
+            test_flags |= SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS;
+        }
+        if ((test_flags & SCRIPT_VERIFY_WITNESS)) {
+            // WITNESS requires P2SH
+            test_flags |= SCRIPT_VERIFY_P2SH;
+        }
+        bool ret = CheckInputs(tx, state, pcoinsTip.get(), true, test_flags, true, add_to_cache, txdata, nullptr);
+        // CheckInputs should succeed iff test_flags doesn't intersect with
+        // failing_flags
+        bool expected_return_value = !(test_flags & failing_flags);
+        BOOST_CHECK_EQUAL(ret, expected_return_value);
+
+        // Test the caching
+        if (ret && add_to_cache) {
+            // Check that we get a cache hit if the tx was valid
+            std::vector<CScriptCheck> scriptchecks;
+            BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true, test_flags, true, add_to_cache, txdata, &scriptchecks));
+            BOOST_CHECK(scriptchecks.empty());
+        } else {
+            // Check that we get script executions to check, if the transaction
+            // was invalid, or we didn't add to cache.
+            std::vector<CScriptCheck> scriptchecks;
+            BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true, test_flags, true, add_to_cache, txdata, &scriptchecks));
+            BOOST_CHECK_EQUAL(scriptchecks.size(), tx.vin.size());
+        }
+    }
+}
+
+BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)
+{
+    // Test that passing CheckInputs with one set of script flags doesn't imply
+    // that we would pass again with a different set of flags.
+    {
+        LOCK(cs_main);
+        InitScriptExecutionCache();
+    }
+
+    CScript p2pk_scriptPubKey = CScript() << ToByteVector(cashbaseKey.GetPubKey()) << OP_CHECKSIG;
+    CScript p2sh_scriptPubKey = GetScriptForDestination(CScriptID(p2pk_scriptPubKey));
+    CScript p2pkh_scriptPubKey = GetScriptForDestination(cashbaseKey.GetPubKey().GetID());
+    CScript p2wpkh_scriptPubKey = GetScriptForWitness(p2pkh_scriptPubKey);
+
+    CBasicKeyStore keystore;
+    keystore.AddKey(coinbaseKey);
+    keystore.AddCScript(p2pk_scriptPubKey);
+
+    // flags to test: SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, SCRIPT_VERIFY_CHECKSEQUENCE_VERIFY, SCRIPT_VERIFY_NULLDUMMY, uncompressed pubkey thing
+
+    // Create 2 outputs that match the three scripts above, spending the first
+    // coinbase tx.
+    CMutableTransaction spend_tx;
+
+    spend_tx.nVersion = 1;
+    spend_tx.vin.resize(1);
+    spend_tx.vin[0].prevout.hash = coinbaseTxns[0].GetHash();
+    spend_tx.vin[0].prevout.n = 0;
+    spend_tx.vout.resize(4);
+    spend_tx.vout[0].nValue = 11*CENT;
+    spend_tx.vout[0].scriptPubKey = p2sh_scriptPubKey;
+    spend_tx.vout[1].nValue = 11*CENT;
+    spend_tx.vout[1].scriptPubKey = p2wpkh_scriptPubKey;
+    spend_tx.vout[2].nValue = 11*CENT;
+    spend_tx.vout[2].scriptPubKey = CScript() << OP_CHECKLOCKTIMEVERIFY << OP_DROP << ToByteVector(cashbaseKey.GetPubKey()) << OP_CHECKSIG;
+    spend_tx.vout[3].nValue = 11*CENT;
+    spend_tx.vout[3].scriptPubKey = CScript() << OP_CHECKSEQUENCEVERIFY << OP_DROP << ToByteVector(cashbaseKey.GetPubKey()) << OP_CHECKSIG;
+
+    // Sign, with a non-DER signature
+    {
+        std::vector<unsigned char> vchSig;
+        uint256 hash = SignatureHash(p2pk_scriptPubKey, spend_tx, 0, SIGHASH_ALL, 0, SIGVERSION_BASE);
+        BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
+        vchSig.push_back((unsigned char) 0); // padding byte makes this non-DER
+        vchSig.push_back((unsigned char)SIGHASH_ALL);
+        spend_tx.vin[0].scriptSig << vchSig;
+    }
+
+    // Test that invalidity under a set of flags doesn't preclude validity
+    // under other (eg consensus) flags.
+    // spend_tx is invalid according to DERSIG
+    {
+        LOCK(cs_main);
+
+        CValidationState state;
+        PrecomputedTransactionData ptd_spend_tx(spend_tx);
+
+        BOOST_CHECK(!CheckInputs(spend_tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, nullptr));
+
+        // If we call again asking for scriptchecks (as happens in
+        // ConnectBlock), we should add a script check object for this -- we're
+        // not caching invalidity (if that changes, delete this test case).
+        std::vector<CScriptCheck> scriptchecks;
+        BOOST_CHECK(CheckInputs(spend_tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, &scriptchecks));
+        BOOST_CHECK_EQUAL(scriptchecks.size(), 1);
+
+        // Test that CheckInputs returns true iff DERSIG-enforcing flags are
+        // not present.  Don't add these checks to the cache, so that we can
+        // test later that block validation works fine in the absence of cached
+        // successes.
+        ValidateCheckInputsForAllFlags(spend_tx, SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC, false);
+    }
+
+    // And if we produce a block with this tx, it should be valid (DERSIG not
+    // enabled yet), even though there's no cache entry.
+    CBlock block;
+
+    block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);
+    BOOST_CHECK(chainActive.Tip()->GetBlockHash() == block.GetHash());
+    BOOST_CHECK(pcashTip->GetBestBlock() == block.GetHash());
+
+    LOCK(cs_main);
+
+    // Test P2SH: construct a transaction that is valid without P2SH, and
+    // then test validity with P2SH.
+    {
+        CMutableTransaction invalid_under_p2sh_tx;
+        invalid_under_p2sh_tx.nVersion = 1;
+        invalid_under_p2sh_tx.vin.resize(1);
+        invalid_under_p2sh_tx.vin[0].prevout.hash = spend_tx.GetHash();
+        invalid_under_p2sh_tx.vin[0].prevout.n = 0;
+        invalid_under_p2sh_tx.vout.resize(1);
+        invalid_under_p2sh_tx.vout[0].nValue = 11*CENT;
+        invalid_under_p2sh_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
+        std::vector<unsigned char> vchSig2(p2pk_scriptPubKey.begin(), p2pk_scriptPubKey.end());
+        invalid_under_p2sh_tx.vin[0].scriptSig << vchSig2;
+
+        ValidateCheckInputsForAllFlags(invalid_under_p2sh_tx, SCRIPT_VERIFY_P2SH, true);
+    }
+
+    // Test CHECKLOCKTIMEVERIFY
+    {
+        CMutableTransaction invalid_with_cltv_tx;
+        invalid_with_cltv_tx.nVersion = 1;
+        invalid_with_cltv_tx.nLockTime = 100;
+        invalid_with_cltv_tx.vin.resize(1);
+        invalid_with_cltv_tx.vin[0].prevout.hash = spend_tx.GetHash();
+        invalid_with_cltv_tx.vin[0].prevout.n = 2;
+        invalid_with_cltv_tx.vin[0].nSequence = 0;
+        invalid_with_cltv_tx.vout.resize(1);
+        invalid_with_cltv_tx.vout[0].nValue = 11*CENT;
+        invalid_with_cltv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
+
+        // Sign
+        std::vector<unsigned char> vchSig;
+        uint256 hash = SignatureHash(spend_tx.vout[2].scriptPubKey, invalid_with_cltv_tx, 0, SIGHASH_ALL, 0, SIGVERSION_BASE);
+        BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
+        vchSig.push_back((unsigned char)SIGHASH_ALL);
+        invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
+
+        ValidateCheckInputsForAllFlags(invalid_with_cltv_tx, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true);
+
+        // Make it valid, and check again
+        invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
+        CValidationState state;
+        PrecomputedTransactionData txdata(invalid_with_cltv_tx);
+        BOOST_CHECK(CheckInputs(invalid_with_cltv_tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, true, txdata, nullptr));
+    }
+
+    // TEST CHECKSEQUENCEVERIFY
+    {
+        CMutableTransaction invalid_with_csv_tx;
+        invalid_with_csv_tx.nVersion = 2;
+        invalid_with_csv_tx.vin.resize(1);
+        invalid_with_csv_tx.vin[0].prevout.hash = spend_tx.GetHash();
+        invalid_with_csv_tx.vin[0].prevout.n = 3;
+        invalid_with_csv_tx.vin[0].nSequence = 100;
+        invalid_with_csv_tx.vout.resize(1);
+        invalid_with_csv_tx.vout[0].nValue = 11*CENT;
+        invalid_with_csv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
+
+        // Sign
+        std::vector<unsigned char> vchSig;
+        uint256 hash = SignatureHash(spend_tx.vout[3].scriptPubKey, invalid_with_csv_tx, 0, SIGHASH_ALL, 0, SIGVERSION_BASE);
+        BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
+        vchSig.push_back((unsigned char)SIGHASH_ALL);
+        invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
+
+        ValidateCheckInputsForAllFlags(invalid_with_csv_tx, SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true);
+
+        // Make it valid, and check again
+        invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
+        CValidationState state;
+        PrecomputedTransactionData txdata(invalid_with_csv_tx);
+        BOOST_CHECK(CheckInputs(invalid_with_csv_tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, true, txdata, nullptr));
+    }
+
+    // TODO: add tests for remaining script flags
+
+    // Test that passing CheckInputs with a valid witness doesn't imply success
+    // for the same tx with a different witness.
+    {
+        CMutableTransaction valid_with_witness_tx;
+        valid_with_witness_tx.nVersion = 1;
+        valid_with_witness_tx.vin.resize(1);
+        valid_with_witness_tx.vin[0].prevout.hash = spend_tx.GetHash();
+        valid_with_witness_tx.vin[0].prevout.n = 1;
+        valid_with_witness_tx.vout.resize(1);
+        valid_with_witness_tx.vout[0].nValue = 11*CENT;
+        valid_with_witness_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
+
+        // Sign
+        SignatureData sigdata;
+        ProduceSignature(MutableTransactionSignatureCreator(&keystore, &valid_with_witness_tx, 0, 11*CENT, SIGHASH_ALL), spend_tx.vout[1].scriptPubKey, sigdata);
+        UpdateTransaction(valid_with_witness_tx, 0, sigdata);
+
+        // This should be valid under all script flags.
+        ValidateCheckInputsForAllFlags(valid_with_witness_tx, 0, true);
+
+        // Remove the witness, and check that it is now invalid.
+        valid_with_witness_tx.vin[0].scriptWitness.SetNull();
+        ValidateCheckInputsForAllFlags(valid_with_witness_tx, SCRIPT_VERIFY_WITNESS, true);
+    }
+
+    {
+        // Test a transaction with multiple inputs.
+        CMutableTransaction tx;
+
+        tx.nVersion = 1;
+        tx.vin.resize(2);
+        tx.vin[0].prevout.hash = spend_tx.GetHash();
+        tx.vin[0].prevout.n = 0;
+        tx.vin[1].prevout.hash = spend_tx.GetHash();
+        tx.vin[1].prevout.n = 1;
+        tx.vout.resize(1);
+        tx.vout[0].nValue = 22*CENT;
+        tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
+
+        // Sign
+        for (int i=0; i<2; ++i) {
+            SignatureData sigdata;
+            ProduceSignature(MutableTransactionSignatureCreator(&keystore, &tx, i, 11*CENT, SIGHASH_ALL), spend_tx.vout[i].scriptPubKey, sigdata);
+            UpdateTransaction(tx, i, sigdata);
+        }
+
+        // This should be valid under all script flags
+        ValidateCheckInputsForAllFlags(tx, 0, true);
+
+        // Check that if the second input is invalid, but the first input is
+        // valid, the transaction is not cached.
+        // Invalidate vin[1]
+        tx.vin[1].scriptWitness.SetNull();
+
+        CValidationState state;
+        PrecomputedTransactionData txdata(tx);
+        // This transaction is now invalid under segwit, because of the second input.
+        BOOST_CHECK(!CheckInputs(tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, nullptr));
+
+        std::vector<CScriptCheck> scriptchecks;
+        // Make sure this transaction was not cached (ie because the first
+        // input was valid)
+        BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, &scriptchecks));
+        // Should get 2 script checks back -- caching is on a whole-transaction basis.
+        BOOST_CHECK_EQUAL(scriptchecks.size(), 2);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/uint256_tests.cpp b/uint256_tests.cpp
new file mode 100644
index 0000000..a51d0e5
--- /dev/null
+++ b/uint256_tests.cpp
@@ -0,0 +1,269 @@
+// Copyright (c) 2018 The SalemCash developers
+// 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 <uint256.h>
+#include <version.h>
+#include <test/test_salemcash.h>
+
+#include <boost/test/unit_test.hpp>
+#include <stdint.h>
+#include <sstream>
+#include <iomanip>
+#include <limits>
+#include <cmath>
+#include <string>
+#include <stdio.h>
+
+BOOST_FIXTURE_TEST_SUITE(uint256_tests, BasicTestingSetup)
+
+const unsigned char R1Array[] =
+    "\x9c\x52\x4a\xdb\xcf\x56\x11\x12\x2b\x29\x12\x5e\x5d\x35\xd2\xd2"
+    "\x22\x81\xaa\xb5\x33\xf0\x08\x32\xd5\x56\xb1\xf9\xea\xe5\x1d\x7d";
+const char R1ArrayHex[] = "7D1DE5EAF9B156D53208F033B5AA8122D2d2355d5e12292b121156cfdb4a529c";
+const uint256 R1L = uint256(std::vector<unsigned char>(R1Array,R1Array+32));
+const uint160 R1S = uint160(std::vector<unsigned char>(R1Array,R1Array+20));
+
+const unsigned char R2Array[] =
+    "\x70\x32\x1d\x7c\x47\xa5\x6b\x40\x26\x7e\x0a\xc3\xa6\x9c\xb6\xbf"
+    "\x13\x30\x47\xa3\x19\x2d\xda\x71\x49\x13\x72\xf0\xb4\xca\x81\xd7";
+const uint256 R2L = uint256(std::vector<unsigned char>(R2Array,R2Array+32));
+const uint160 R2S = uint160(std::vector<unsigned char>(R2Array,R2Array+20));
+
+const unsigned char ZeroArray[] =
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
+const uint256 ZeroL = uint256(std::vector<unsigned char>(ZeroArray,ZeroArray+32));
+const uint160 ZeroS = uint160(std::vector<unsigned char>(ZeroArray,ZeroArray+20));
+
+const unsigned char OneArray[] =
+    "\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
+const uint256 OneL = uint256(std::vector<unsigned char>(OneArray,OneArray+32));
+const uint160 OneS = uint160(std::vector<unsigned char>(OneArray,OneArray+20));
+
+const unsigned char MaxArray[] =
+    "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+    "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
+const uint256 MaxL = uint256(std::vector<unsigned char>(MaxArray,MaxArray+32));
+const uint160 MaxS = uint160(std::vector<unsigned char>(MaxArray,MaxArray+20));
+
+std::string ArrayToString(const unsigned char A[], unsigned int width)
+{
+    std::stringstream Stream;
+    Stream << std::hex;
+    for (unsigned int i = 0; i < width; ++i)
+    {
+        Stream<<std::setw(2)<<std::setfill('0')<<(unsigned int)A[width-i-1];
+    }
+    return Stream.str();
+}
+
+inline uint160 uint160S(const char *str)
+{
+    uint160 rv;
+    rv.SetHex(str);
+    return rv;
+}
+inline uint160 uint160S(const std::string& str)
+{
+    uint160 rv;
+    rv.SetHex(str);
+    return rv;
+}
+
+BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
+{
+    BOOST_CHECK(1 == 0+1);
+    // constructor uint256(vector<char>):
+    BOOST_CHECK(R1L.ToString() == ArrayToString(R1Array,32));
+    BOOST_CHECK(R1S.ToString() == ArrayToString(R1Array,20));
+    BOOST_CHECK(R2L.ToString() == ArrayToString(R2Array,32));
+    BOOST_CHECK(R2S.ToString() == ArrayToString(R2Array,20));
+    BOOST_CHECK(ZeroL.ToString() == ArrayToString(ZeroArray,32));
+    BOOST_CHECK(ZeroS.ToString() == ArrayToString(ZeroArray,20));
+    BOOST_CHECK(OneL.ToString() == ArrayToString(OneArray,32));
+    BOOST_CHECK(OneS.ToString() == ArrayToString(OneArray,20));
+    BOOST_CHECK(MaxL.ToString() == ArrayToString(MaxArray,32));
+    BOOST_CHECK(MaxS.ToString() == ArrayToString(MaxArray,20));
+    BOOST_CHECK(OneL.ToString() != ArrayToString(ZeroArray,32));
+    BOOST_CHECK(OneS.ToString() != ArrayToString(ZeroArray,20));
+
+    // == and !=
+    BOOST_CHECK(R1L != R2L && R1S != R2S);
+    BOOST_CHECK(ZeroL != OneL && ZeroS != OneS);
+    BOOST_CHECK(OneL != ZeroL && OneS != ZeroS);
+    BOOST_CHECK(MaxL != ZeroL && MaxS != ZeroS);
+
+    // String Constructor and Copy Constructor
+    BOOST_CHECK(uint256S("0x"+R1L.ToString()) == R1L);
+    BOOST_CHECK(uint256S("0x"+R2L.ToString()) == R2L);
+    BOOST_CHECK(uint256S("0x"+ZeroL.ToString()) == ZeroL);
+    BOOST_CHECK(uint256S("0x"+OneL.ToString()) == OneL);
+    BOOST_CHECK(uint256S("0x"+MaxL.ToString()) == MaxL);
+    BOOST_CHECK(uint256S(R1L.ToString()) == R1L);
+    BOOST_CHECK(uint256S("   0x"+R1L.ToString()+"   ") == R1L);
+    BOOST_CHECK(uint256S("") == ZeroL);
+    BOOST_CHECK(R1L == uint256S(R1ArrayHex));
+    BOOST_CHECK(uint256(R1L) == R1L);
+    BOOST_CHECK(uint256(ZeroL) == ZeroL);
+    BOOST_CHECK(uint256(OneL) == OneL);
+
+    BOOST_CHECK(uint160S("0x"+R1S.ToString()) == R1S);
+    BOOST_CHECK(uint160S("0x"+R2S.ToString()) == R2S);
+    BOOST_CHECK(uint160S("0x"+ZeroS.ToString()) == ZeroS);
+    BOOST_CHECK(uint160S("0x"+OneS.ToString()) == OneS);
+    BOOST_CHECK(uint160S("0x"+MaxS.ToString()) == MaxS);
+    BOOST_CHECK(uint160S(R1S.ToString()) == R1S);
+    BOOST_CHECK(uint160S("   0x"+R1S.ToString()+"   ") == R1S);
+    BOOST_CHECK(uint160S("") == ZeroS);
+    BOOST_CHECK(R1S == uint160S(R1ArrayHex));
+
+    BOOST_CHECK(uint160(R1S) == R1S);
+    BOOST_CHECK(uint160(ZeroS) == ZeroS);
+    BOOST_CHECK(uint160(OneS) == OneS);
+}
+
+BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
+{
+    uint256 LastL;
+    for (int i = 255; i >= 0; --i) {
+        uint256 TmpL;
+        *(TmpL.begin() + (i>>3)) |= 1<<(7-(i&7));
+        BOOST_CHECK( LastL < TmpL );
+        LastL = TmpL;
+    }
+
+    BOOST_CHECK( ZeroL < R1L );
+    BOOST_CHECK( R2L < R1L );
+    BOOST_CHECK( ZeroL < OneL );
+    BOOST_CHECK( OneL < MaxL );
+    BOOST_CHECK( R1L < MaxL );
+    BOOST_CHECK( R2L < MaxL );
+
+    uint160 LastS;
+    for (int i = 159; i >= 0; --i) {
+        uint160 TmpS;
+        *(TmpS.begin() + (i>>3)) |= 1<<(7-(i&7));
+        BOOST_CHECK( LastS < TmpS );
+        LastS = TmpS;
+    }
+    BOOST_CHECK( ZeroS < R1S );
+    BOOST_CHECK( R2S < R1S );
+    BOOST_CHECK( ZeroS < OneS );
+    BOOST_CHECK( OneS < MaxS );
+    BOOST_CHECK( R1S < MaxS );
+    BOOST_CHECK( R2S < MaxS );
+}
+
+BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 GetSerializeSize, Serialize, Unserialize
+{
+    BOOST_CHECK(R1L.GetHex() == R1L.ToString());
+    BOOST_CHECK(R2L.GetHex() == R2L.ToString());
+    BOOST_CHECK(OneL.GetHex() == OneL.ToString());
+    BOOST_CHECK(MaxL.GetHex() == MaxL.ToString());
+    uint256 TmpL(R1L);
+    BOOST_CHECK(TmpL == R1L);
+    TmpL.SetHex(R2L.ToString());   BOOST_CHECK(TmpL == R2L);
+    TmpL.SetHex(ZeroL.ToString()); BOOST_CHECK(TmpL == uint256());
+
+    TmpL.SetHex(R1L.ToString());
+    BOOST_CHECK(memcmp(R1L.begin(), R1Array, 32)==0);
+    BOOST_CHECK(memcmp(TmpL.begin(), R1Array, 32)==0);
+    BOOST_CHECK(memcmp(R2L.begin(), R2Array, 32)==0);
+    BOOST_CHECK(memcmp(ZeroL.begin(), ZeroArray, 32)==0);
+    BOOST_CHECK(memcmp(OneL.begin(), OneArray, 32)==0);
+    BOOST_CHECK(R1L.size() == sizeof(R1L));
+    BOOST_CHECK(sizeof(R1L) == 32);
+    BOOST_CHECK(R1L.size() == 32);
+    BOOST_CHECK(R2L.size() == 32);
+    BOOST_CHECK(ZeroL.size() == 32);
+    BOOST_CHECK(MaxL.size() == 32);
+    BOOST_CHECK(R1L.begin() + 32 == R1L.end());
+    BOOST_CHECK(R2L.begin() + 32 == R2L.end());
+    BOOST_CHECK(OneL.begin() + 32 == OneL.end());
+    BOOST_CHECK(MaxL.begin() + 32 == MaxL.end());
+    BOOST_CHECK(TmpL.begin() + 32 == TmpL.end());
+    BOOST_CHECK(GetSerializeSize(R1L, 0, PROTOCOL_VERSION) == 32);
+    BOOST_CHECK(GetSerializeSize(ZeroL, 0, PROTOCOL_VERSION) == 32);
+
+    CDataStream ss(0, PROTOCOL_VERSION);
+    ss << R1L;
+    BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+32));
+    ss >> TmpL;
+    BOOST_CHECK(R1L == TmpL);
+    ss.clear();
+    ss << ZeroL;
+    BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+32));
+    ss >> TmpL;
+    BOOST_CHECK(ZeroL == TmpL);
+    ss.clear();
+    ss << MaxL;
+    BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+32));
+    ss >> TmpL;
+    BOOST_CHECK(MaxL == TmpL);
+    ss.clear();
+
+    BOOST_CHECK(R1S.GetHex() == R1S.ToString());
+    BOOST_CHECK(R2S.GetHex() == R2S.ToString());
+    BOOST_CHECK(OneS.GetHex() == OneS.ToString());
+    BOOST_CHECK(MaxS.GetHex() == MaxS.ToString());
+    uint160 TmpS(R1S);
+    BOOST_CHECK(TmpS == R1S);
+    TmpS.SetHex(R2S.ToString());   BOOST_CHECK(TmpS == R2S);
+    TmpS.SetHex(ZeroS.ToString()); BOOST_CHECK(TmpS == uint160());
+
+    TmpS.SetHex(R1S.ToString());
+    BOOST_CHECK(memcmp(R1S.begin(), R1Array, 20)==0);
+    BOOST_CHECK(memcmp(TmpS.begin(), R1Array, 20)==0);
+    BOOST_CHECK(memcmp(R2S.begin(), R2Array, 20)==0);
+    BOOST_CHECK(memcmp(ZeroS.begin(), ZeroArray, 20)==0);
+    BOOST_CHECK(memcmp(OneS.begin(), OneArray, 20)==0);
+    BOOST_CHECK(R1S.size() == sizeof(R1S));
+    BOOST_CHECK(sizeof(R1S) == 20);
+    BOOST_CHECK(R1S.size() == 20);
+    BOOST_CHECK(R2S.size() == 20);
+    BOOST_CHECK(ZeroS.size() == 20);
+    BOOST_CHECK(MaxS.size() == 20);
+    BOOST_CHECK(R1S.begin() + 20 == R1S.end());
+    BOOST_CHECK(R2S.begin() + 20 == R2S.end());
+    BOOST_CHECK(OneS.begin() + 20 == OneS.end());
+    BOOST_CHECK(MaxS.begin() + 20 == MaxS.end());
+    BOOST_CHECK(TmpS.begin() + 20 == TmpS.end());
+    BOOST_CHECK(GetSerializeSize(R1S, 0, PROTOCOL_VERSION) == 20);
+    BOOST_CHECK(GetSerializeSize(ZeroS, 0, PROTOCOL_VERSION) == 20);
+
+    ss << R1S;
+    BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+20));
+    ss >> TmpS;
+    BOOST_CHECK(R1S == TmpS);
+    ss.clear();
+    ss << ZeroS;
+    BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+20));
+    ss >> TmpS;
+    BOOST_CHECK(ZeroS == TmpS);
+    ss.clear();
+    ss << MaxS;
+    BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+20));
+    ss >> TmpS;
+    BOOST_CHECK(MaxS == TmpS);
+    ss.clear();
+}
+
+BOOST_AUTO_TEST_CASE( conversion )
+{
+    BOOST_CHECK(ArithToUint256(UintToArith256(ZeroL)) == ZeroL);
+    BOOST_CHECK(ArithToUint256(UintToArith256(OneL)) == OneL);
+    BOOST_CHECK(ArithToUint256(UintToArith256(R1L)) == R1L);
+    BOOST_CHECK(ArithToUint256(UintToArith256(R2L)) == R2L);
+    BOOST_CHECK(UintToArith256(ZeroL) == 0);
+    BOOST_CHECK(UintToArith256(OneL) == 1);
+    BOOST_CHECK(ArithToUint256(0) == ZeroL);
+    BOOST_CHECK(ArithToUint256(1) == OneL);
+    BOOST_CHECK(arith_uint256(R1L.GetHex()) == UintToArith256(R1L));
+    BOOST_CHECK(arith_uint256(R2L.GetHex()) == UintToArith256(R2L));
+    BOOST_CHECK(R1L.GetHex() == UintToArith256(R1L).GetHex());
+    BOOST_CHECK(R2L.GetHex() == UintToArith256(R2L).GetHex());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/util_tests.cpp b/util_tests.cpp
new file mode 100644
index 0000000..1cd10d0
--- /dev/null
+++ b/util_tests.cpp
@@ -0,0 +1,836 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <util.h>
+
+#include <clientversion.h>
+#include <primitives/transaction.h>
+#include <sync.h>
+#include <utilstrencodings.h>
+#include <utilmoneystr.h>
+#include <test/test_salemcash.h>
+
+#include <stdint.h>
+#include <vector>
+#ifndef WIN32
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#endif
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(util_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(util_criticalsection)
+{
+    CCriticalSection cs;
+
+    do {
+        LOCK(cs);
+        break;
+
+        BOOST_ERROR("break was swallowed!");
+    } while(0);
+
+    do {
+        TRY_LOCK(cs, lockTest);
+        if (lockTest)
+            break;
+
+        BOOST_ERROR("break was swallowed!");
+    } while(0);
+}
+
+static const unsigned char ParseHex_expected[65] = {
+    0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, 0xb7,
+    0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde,
+    0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, 0x12,
+    0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d,
+    0x5f
+};
+BOOST_AUTO_TEST_CASE(util_ParseHex)
+{
+    std::vector<unsigned char> result;
+    std::vector<unsigned char> expected(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
+    // Basic test vector
+    result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
+    BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
+
+    // Spaces between bytes must be supported
+    result = ParseHex("12 34 56 78");
+    BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);
+
+    // Leading space must be supported (used in CDBEnv::Salvage)
+    result = ParseHex(" 89 34 56 78");
+    BOOST_CHECK(result.size() == 4 && result[0] == 0x89 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);
+
+    // Stop parsing at invalid value
+    result = ParseHex("1234 invalid 1234");
+    BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
+}
+
+BOOST_AUTO_TEST_CASE(util_HexStr)
+{
+    BOOST_CHECK_EQUAL(
+        HexStr(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected)),
+        "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
+
+    BOOST_CHECK_EQUAL(
+        HexStr(ParseHex_expected, ParseHex_expected + 5, true),
+        "04 67 8a fd b0");
+
+    BOOST_CHECK_EQUAL(
+        HexStr(ParseHex_expected + sizeof(ParseHex_expected),
+               ParseHex_expected + sizeof(ParseHex_expected)),
+        "");
+
+    BOOST_CHECK_EQUAL(
+        HexStr(ParseHex_expected + sizeof(ParseHex_expected),
+               ParseHex_expected + sizeof(ParseHex_expected), true),
+        "");
+
+    BOOST_CHECK_EQUAL(
+        HexStr(ParseHex_expected, ParseHex_expected),
+        "");
+
+    BOOST_CHECK_EQUAL(
+        HexStr(ParseHex_expected, ParseHex_expected, true),
+        "");
+
+    std::vector<unsigned char> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);
+
+    BOOST_CHECK_EQUAL(
+        HexStr(ParseHex_vec, true),
+        "04 67 8a fd b0");
+
+    BOOST_CHECK_EQUAL(
+        HexStr(ParseHex_vec.rbegin(), ParseHex_vec.rend()),
+        "b0fd8a6704"
+    );
+
+    BOOST_CHECK_EQUAL(
+        HexStr(ParseHex_vec.rbegin(), ParseHex_vec.rend(), true),
+        "b0 fd 8a 67 04"
+    );
+
+    BOOST_CHECK_EQUAL(
+        HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected),
+               std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
+        ""
+    );
+
+    BOOST_CHECK_EQUAL(
+        HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected),
+               std::reverse_iterator<const uint8_t *>(ParseHex_expected), true),
+        ""
+    );
+
+    BOOST_CHECK_EQUAL(
+        HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 1),
+               std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
+        "04"
+    );
+
+    BOOST_CHECK_EQUAL(
+        HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 1),
+               std::reverse_iterator<const uint8_t *>(ParseHex_expected), true),
+        "04"
+    );
+
+    BOOST_CHECK_EQUAL(
+        HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 5),
+               std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
+        "b0fd8a6704"
+    );
+
+    BOOST_CHECK_EQUAL(
+        HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 5),
+               std::reverse_iterator<const uint8_t *>(ParseHex_expected), true),
+        "b0 fd 8a 67 04"
+    );
+
+    BOOST_CHECK_EQUAL(
+        HexStr(std::reverse_iterator<const uint8_t *>(ParseHex_expected + 65),
+               std::reverse_iterator<const uint8_t *>(ParseHex_expected)),
+        "5f1df16b2b704c8a578d0bbaf74d385cde12c11ee50455f3c438ef4c3fbcf649b6de611feae06279a60939e028a8d65c10b73071a6f16719274855feb0fd8a6704"
+    );
+}
+
+
+BOOST_AUTO_TEST_CASE(util_DateTimeStrFormat)
+{
+    BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0), "1970-01-01 00:00:00");
+    BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0x7FFFFFFF), "2038-01-19 03:14:07");
+    BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 1317425777), "2011-09-30 23:36:17");
+    BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%dT%H:%M:%SZ", 1317425777), "2011-09-30T23:36:17Z");
+    BOOST_CHECK_EQUAL(DateTimeStrFormat("%H:%M:%SZ", 1317425777), "23:36:17Z");
+    BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M", 1317425777), "2011-09-30 23:36");
+    BOOST_CHECK_EQUAL(DateTimeStrFormat("%a, %d %b %Y %H:%M:%S +0000", 1317425777), "Fri, 30 Sep 2011 23:36:17 +0000");
+}
+
+BOOST_AUTO_TEST_CASE(util_FormatISO8601DateTime)
+{
+    BOOST_CHECK_EQUAL(FormatISO8601DateTime(1317425777), "2011-09-30T23:36:17Z");
+}
+
+BOOST_AUTO_TEST_CASE(util_FormatISO8601Date)
+{
+    BOOST_CHECK_EQUAL(FormatISO8601Date(1317425777), "2011-09-30");
+}
+
+BOOST_AUTO_TEST_CASE(util_FormatISO8601Time)
+{
+    BOOST_CHECK_EQUAL(FormatISO8601Time(1317425777), "23:36:17Z");
+}
+
+class TestArgsManager : public ArgsManager
+{
+public:
+    std::map<std::string, std::string>& GetMapArgs()
+    {
+        return mapArgs;
+    };
+    const std::map<std::string, std::vector<std::string> >& GetMapMultiArgs()
+    {
+        return mapMultiArgs;
+    };
+};
+
+BOOST_AUTO_TEST_CASE(util_ParseParameters)
+{
+    TestArgsManager testArgs;
+    const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"};
+
+    testArgs.ParseParameters(0, (char**)argv_test);
+    BOOST_CHECK(testArgs.GetMapArgs().empty() && testArgs.GetMapMultiArgs().empty());
+
+    testArgs.ParseParameters(1, (char**)argv_test);
+    BOOST_CHECK(testArgs.GetMapArgs().empty() && testArgs.GetMapMultiArgs().empty());
+
+    testArgs.ParseParameters(7, (char**)argv_test);
+    // expectation: -ignored is ignored (program name argument),
+    // -a, -b and -ccc end up in map, -d ignored because it is after
+    // a non-option argument (non-GNU option parsing)
+    BOOST_CHECK(testArgs.GetMapArgs().size() == 3 && testArgs.GetMapMultiArgs().size() == 3);
+    BOOST_CHECK(testArgs.IsArgSet("-a") && testArgs.IsArgSet("-b") && testArgs.IsArgSet("-ccc")
+                && !testArgs.IsArgSet("f") && !testArgs.IsArgSet("-d"));
+    BOOST_CHECK(testArgs.GetMapMultiArgs().count("-a") && testArgs.GetMapMultiArgs().count("-b") && testArgs.GetMapMultiArgs().count("-ccc")
+                && !testArgs.GetMapMultiArgs().count("f") && !testArgs.GetMapMultiArgs().count("-d"));
+
+    BOOST_CHECK(testArgs.GetMapArgs()["-a"] == "" && testArgs.GetMapArgs()["-ccc"] == "multiple");
+    BOOST_CHECK(testArgs.GetArgs("-ccc").size() == 2);
+}
+
+BOOST_AUTO_TEST_CASE(util_GetArg)
+{
+    TestArgsManager testArgs;
+    testArgs.GetMapArgs().clear();
+    testArgs.GetMapArgs()["strtest1"] = "string...";
+    // strtest2 undefined on purpose
+    testArgs.GetMapArgs()["inttest1"] = "12345";
+    testArgs.GetMapArgs()["inttest2"] = "81985529216486895";
+    // inttest3 undefined on purpose
+    testArgs.GetMapArgs()["booltest1"] = "";
+    // booltest2 undefined on purpose
+    testArgs.GetMapArgs()["booltest3"] = "0";
+    testArgs.GetMapArgs()["booltest4"] = "1";
+
+    BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
+    BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
+    BOOST_CHECK_EQUAL(testArgs.GetArg("inttest1", -1), 12345);
+    BOOST_CHECK_EQUAL(testArgs.GetArg("inttest2", -1), 81985529216486895LL);
+    BOOST_CHECK_EQUAL(testArgs.GetArg("inttest3", -1), -1);
+    BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
+    BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest2", false), false);
+    BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest3", false), false);
+    BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest4", false), true);
+}
+
+BOOST_AUTO_TEST_CASE(util_FormatMoney)
+{
+    BOOST_CHECK_EQUAL(FormatMoney(0), "0.00");
+    BOOST_CHECK_EQUAL(FormatMoney((CASH/10000)*123456789), "12345.6789");
+    BOOST_CHECK_EQUAL(FormatMoney(-CASH), "-1.00");
+
+    BOOST_CHECK_EQUAL(FormatMoney(CASH*100000000), "100000000.00");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH*10000000), "10000000.00");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH*1000000), "1000000.00");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH*100000), "100000.00");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH*10000), "10000.00");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH*1000), "1000.00");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH*100), "100.00");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH*10), "10.00");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH), "1.00");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH/10), "0.10");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH/100), "0.01");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH/1000), "0.001");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH/10000), "0.0001");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH/100000), "0.00001");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH/1000000), "0.000001");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH/10000000), "0.0000001");
+    BOOST_CHECK_EQUAL(FormatMoney(CASH/100000000), "0.00000001");
+}
+
+BOOST_AUTO_TEST_CASE(util_ParseMoney)
+{
+    CAmount ret = 0;
+    BOOST_CHECK(ParseMoney("0.0", ret));
+    BOOST_CHECK_EQUAL(ret, 0);
+
+    BOOST_CHECK(ParseMoney("12345.6789", ret));
+    BOOST_CHECK_EQUAL(ret, (CASH/10000)*123456789);
+
+    BOOST_CHECK(ParseMoney("100000000.00", ret));
+    BOOST_CHECK_EQUAL(ret, CASH*100000000);
+    BOOST_CHECK(ParseMoney("10000000.00", ret));
+    BOOST_CHECK_EQUAL(ret, CASH*10000000);
+    BOOST_CHECK(ParseMoney("1000000.00", ret));
+    BOOST_CHECK_EQUAL(ret, CASH*1000000);
+    BOOST_CHECK(ParseMoney("100000.00", ret));
+    BOOST_CHECK_EQUAL(ret, CASH*100000);
+    BOOST_CHECK(ParseMoney("10000.00", ret));
+    BOOST_CHECK_EQUAL(ret, CASH*10000);
+    BOOST_CHECK(ParseMoney("1000.00", ret));
+    BOOST_CHECK_EQUAL(ret, CASH*1000);
+    BOOST_CHECK(ParseMoney("100.00", ret));
+    BOOST_CHECK_EQUAL(ret, CASH*100);
+    BOOST_CHECK(ParseMoney("10.00", ret));
+    BOOST_CHECK_EQUAL(ret, CASH*10);
+    BOOST_CHECK(ParseMoney("1.00", ret));
+    BOOST_CHECK_EQUAL(ret, CASH);
+    BOOST_CHECK(ParseMoney("1", ret));
+    BOOST_CHECK_EQUAL(ret, CASH);
+    BOOST_CHECK(ParseMoney("0.1", ret));
+    BOOST_CHECK_EQUAL(ret, CASH/10);
+    BOOST_CHECK(ParseMoney("0.01", ret));
+    BOOST_CHECK_EQUAL(ret, CASH/100);
+    BOOST_CHECK(ParseMoney("0.001", ret));
+    BOOST_CHECK_EQUAL(ret, CASH/1000);
+    BOOST_CHECK(ParseMoney("0.0001", ret));
+    BOOST_CHECK_EQUAL(ret, CASH/10000);
+    BOOST_CHECK(ParseMoney("0.00001", ret));
+    BOOST_CHECK_EQUAL(ret, CASH/100000);
+    BOOST_CHECK(ParseMoney("0.000001", ret));
+    BOOST_CHECK_EQUAL(ret, CASH/1000000);
+    BOOST_CHECK(ParseMoney("0.0000001", ret));
+    BOOST_CHECK_EQUAL(ret, CASH/10000000);
+    BOOST_CHECK(ParseMoney("0.00000001", ret));
+    BOOST_CHECK_EQUAL(ret, CASH/100000000);
+
+    // Attempted 63 bit overflow should fail
+    BOOST_CHECK(!ParseMoney("92233720368.54775808", ret));
+
+    // Parsing negative amounts must fail
+    BOOST_CHECK(!ParseMoney("-1", ret));
+}
+
+BOOST_AUTO_TEST_CASE(util_IsHex)
+{
+    BOOST_CHECK(IsHex("00"));
+    BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
+    BOOST_CHECK(IsHex("ff"));
+    BOOST_CHECK(IsHex("FF"));
+
+    BOOST_CHECK(!IsHex(""));
+    BOOST_CHECK(!IsHex("0"));
+    BOOST_CHECK(!IsHex("a"));
+    BOOST_CHECK(!IsHex("eleven"));
+    BOOST_CHECK(!IsHex("00xx00"));
+    BOOST_CHECK(!IsHex("0x0000"));
+}
+
+BOOST_AUTO_TEST_CASE(util_IsHexNumber)
+{
+    BOOST_CHECK(IsHexNumber("0x0"));
+    BOOST_CHECK(IsHexNumber("0"));
+    BOOST_CHECK(IsHexNumber("0x10"));
+    BOOST_CHECK(IsHexNumber("10"));
+    BOOST_CHECK(IsHexNumber("0xff"));
+    BOOST_CHECK(IsHexNumber("ff"));
+    BOOST_CHECK(IsHexNumber("0xFfa"));
+    BOOST_CHECK(IsHexNumber("Ffa"));
+    BOOST_CHECK(IsHexNumber("0x00112233445566778899aabbccddeeffAABBCCDDEEFF"));
+    BOOST_CHECK(IsHexNumber("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
+
+    BOOST_CHECK(!IsHexNumber(""));   // empty string not allowed
+    BOOST_CHECK(!IsHexNumber("0x")); // empty string after prefix not allowed
+    BOOST_CHECK(!IsHexNumber("0x0 ")); // no spaces at end,
+    BOOST_CHECK(!IsHexNumber(" 0x0")); // or beginning,
+    BOOST_CHECK(!IsHexNumber("0x 0")); // or middle,
+    BOOST_CHECK(!IsHexNumber(" "));    // etc.
+    BOOST_CHECK(!IsHexNumber("0x0ga")); // invalid character
+    BOOST_CHECK(!IsHexNumber("x0"));    // broken prefix
+    BOOST_CHECK(!IsHexNumber("0x0x00")); // two prefixes not allowed
+
+}
+
+BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
+{
+    SeedInsecureRand(true);
+    for (int mod=2;mod<11;mod++)
+    {
+        int mask = 1;
+        // Really rough binomial confidence approximation.
+        int err = 30*10000./mod*sqrt((1./mod*(1-1./mod))/10000.);
+        //mask is 2^ceil(log2(mod))-1
+        while(mask<mod-1)mask=(mask<<1)+1;
+
+        int count = 0;
+        //How often does it get a zero from the uniform range [0,mod)?
+        for (int i = 0; i < 10000; i++) {
+            uint32_t rval;
+            do{
+                rval=InsecureRand32()&mask;
+            }while(rval>=(uint32_t)mod);
+            count += rval==0;
+        }
+        BOOST_CHECK(count<=10000/mod+err);
+        BOOST_CHECK(count>=10000/mod-err);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(util_TimingResistantEqual)
+{
+    BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
+    BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
+    BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
+    BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
+    BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
+    BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
+    BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
+}
+
+/* Test strprintf formatting directives.
+ * Put a string before and after to ensure sanity of element sizes on stack. */
+#define B "check_prefix"
+#define E "check_postfix"
+BOOST_AUTO_TEST_CASE(strprintf_numbers)
+{
+    int64_t s64t = -9223372036854775807LL; /* signed 64 bit test value */
+    uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
+    BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B" -9223372036854775807 " E);
+    BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B" 18446744073709551615 " E);
+    BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B" ffffffffffffffff " E);
+
+    size_t st = 12345678; /* unsigned size_t test value */
+    ssize_t sst = -12345678; /* signed size_t test value */
+    BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B" -12345678 " E);
+    BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B" 12345678 " E);
+    BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B" bc614e " E);
+
+    ptrdiff_t pt = 87654321; /* positive ptrdiff_t test value */
+    ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
+    BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B" -87654321 " E);
+    BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B" 87654321 " E);
+    BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B" 5397fb1 " E);
+}
+#undef B
+#undef E
+
+/* Check for mingw/wine issue #3494
+ * Remove this test before time.ctime(0xffffffff) == 'Sun Feb  7 07:28:15 2106'
+ */
+BOOST_AUTO_TEST_CASE(gettime)
+{
+    BOOST_CHECK((GetTime() & ~0xFFFFFFFFLL) == 0);
+}
+
+BOOST_AUTO_TEST_CASE(test_ParseInt32)
+{
+    int32_t n;
+    // Valid values
+    BOOST_CHECK(ParseInt32("1234", nullptr));
+    BOOST_CHECK(ParseInt32("0", &n) && n == 0);
+    BOOST_CHECK(ParseInt32("1234", &n) && n == 1234);
+    BOOST_CHECK(ParseInt32("01234", &n) && n == 1234); // no octal
+    BOOST_CHECK(ParseInt32("2147483647", &n) && n == 2147483647);
+    BOOST_CHECK(ParseInt32("-2147483648", &n) && n == (-2147483647 - 1)); // (-2147483647 - 1) equals INT_MIN
+    BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
+    // Invalid values
+    BOOST_CHECK(!ParseInt32("", &n));
+    BOOST_CHECK(!ParseInt32(" 1", &n)); // no padding inside
+    BOOST_CHECK(!ParseInt32("1 ", &n));
+    BOOST_CHECK(!ParseInt32("1a", &n));
+    BOOST_CHECK(!ParseInt32("aap", &n));
+    BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
+    BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
+    const char test_bytes[] = {'1', 0, '1'};
+    std::string teststr(test_bytes, sizeof(test_bytes));
+    BOOST_CHECK(!ParseInt32(teststr, &n)); // no embedded NULs
+    // Overflow and underflow
+    BOOST_CHECK(!ParseInt32("-2147483649", nullptr));
+    BOOST_CHECK(!ParseInt32("2147483648", nullptr));
+    BOOST_CHECK(!ParseInt32("-32482348723847471234", nullptr));
+    BOOST_CHECK(!ParseInt32("32482348723847471234", nullptr));
+}
+
+BOOST_AUTO_TEST_CASE(test_ParseInt64)
+{
+    int64_t n;
+    // Valid values
+    BOOST_CHECK(ParseInt64("1234", nullptr));
+    BOOST_CHECK(ParseInt64("0", &n) && n == 0LL);
+    BOOST_CHECK(ParseInt64("1234", &n) && n == 1234LL);
+    BOOST_CHECK(ParseInt64("01234", &n) && n == 1234LL); // no octal
+    BOOST_CHECK(ParseInt64("2147483647", &n) && n == 2147483647LL);
+    BOOST_CHECK(ParseInt64("-2147483648", &n) && n == -2147483648LL);
+    BOOST_CHECK(ParseInt64("9223372036854775807", &n) && n == (int64_t)9223372036854775807);
+    BOOST_CHECK(ParseInt64("-9223372036854775808", &n) && n == (int64_t)-9223372036854775807-1);
+    BOOST_CHECK(ParseInt64("-1234", &n) && n == -1234LL);
+    // Invalid values
+    BOOST_CHECK(!ParseInt64("", &n));
+    BOOST_CHECK(!ParseInt64(" 1", &n)); // no padding inside
+    BOOST_CHECK(!ParseInt64("1 ", &n));
+    BOOST_CHECK(!ParseInt64("1a", &n));
+    BOOST_CHECK(!ParseInt64("aap", &n));
+    BOOST_CHECK(!ParseInt64("0x1", &n)); // no hex
+    const char test_bytes[] = {'1', 0, '1'};
+    std::string teststr(test_bytes, sizeof(test_bytes));
+    BOOST_CHECK(!ParseInt64(teststr, &n)); // no embedded NULs
+    // Overflow and underflow
+    BOOST_CHECK(!ParseInt64("-9223372036854775809", nullptr));
+    BOOST_CHECK(!ParseInt64("9223372036854775808", nullptr));
+    BOOST_CHECK(!ParseInt64("-32482348723847471234", nullptr));
+    BOOST_CHECK(!ParseInt64("32482348723847471234", nullptr));
+}
+
+BOOST_AUTO_TEST_CASE(test_ParseUInt32)
+{
+    uint32_t n;
+    // Valid values
+    BOOST_CHECK(ParseUInt32("1234", nullptr));
+    BOOST_CHECK(ParseUInt32("0", &n) && n == 0);
+    BOOST_CHECK(ParseUInt32("1234", &n) && n == 1234);
+    BOOST_CHECK(ParseUInt32("01234", &n) && n == 1234); // no octal
+    BOOST_CHECK(ParseUInt32("2147483647", &n) && n == 2147483647);
+    BOOST_CHECK(ParseUInt32("2147483648", &n) && n == (uint32_t)2147483648);
+    BOOST_CHECK(ParseUInt32("4294967295", &n) && n == (uint32_t)4294967295);
+    // Invalid values
+    BOOST_CHECK(!ParseUInt32("", &n));
+    BOOST_CHECK(!ParseUInt32(" 1", &n)); // no padding inside
+    BOOST_CHECK(!ParseUInt32(" -1", &n));
+    BOOST_CHECK(!ParseUInt32("1 ", &n));
+    BOOST_CHECK(!ParseUInt32("1a", &n));
+    BOOST_CHECK(!ParseUInt32("aap", &n));
+    BOOST_CHECK(!ParseUInt32("0x1", &n)); // no hex
+    BOOST_CHECK(!ParseUInt32("0x1", &n)); // no hex
+    const char test_bytes[] = {'1', 0, '1'};
+    std::string teststr(test_bytes, sizeof(test_bytes));
+    BOOST_CHECK(!ParseUInt32(teststr, &n)); // no embedded NULs
+    // Overflow and underflow
+    BOOST_CHECK(!ParseUInt32("-2147483648", &n));
+    BOOST_CHECK(!ParseUInt32("4294967296", &n));
+    BOOST_CHECK(!ParseUInt32("-1234", &n));
+    BOOST_CHECK(!ParseUInt32("-32482348723847471234", nullptr));
+    BOOST_CHECK(!ParseUInt32("32482348723847471234", nullptr));
+}
+
+BOOST_AUTO_TEST_CASE(test_ParseUInt64)
+{
+    uint64_t n;
+    // Valid values
+    BOOST_CHECK(ParseUInt64("1234", nullptr));
+    BOOST_CHECK(ParseUInt64("0", &n) && n == 0LL);
+    BOOST_CHECK(ParseUInt64("1234", &n) && n == 1234LL);
+    BOOST_CHECK(ParseUInt64("01234", &n) && n == 1234LL); // no octal
+    BOOST_CHECK(ParseUInt64("2147483647", &n) && n == 2147483647LL);
+    BOOST_CHECK(ParseUInt64("9223372036854775807", &n) && n == 9223372036854775807ULL);
+    BOOST_CHECK(ParseUInt64("9223372036854775808", &n) && n == 9223372036854775808ULL);
+    BOOST_CHECK(ParseUInt64("18446744073709551615", &n) && n == 18446744073709551615ULL);
+    // Invalid values
+    BOOST_CHECK(!ParseUInt64("", &n));
+    BOOST_CHECK(!ParseUInt64(" 1", &n)); // no padding inside
+    BOOST_CHECK(!ParseUInt64(" -1", &n));
+    BOOST_CHECK(!ParseUInt64("1 ", &n));
+    BOOST_CHECK(!ParseUInt64("1a", &n));
+    BOOST_CHECK(!ParseUInt64("aap", &n));
+    BOOST_CHECK(!ParseUInt64("0x1", &n)); // no hex
+    const char test_bytes[] = {'1', 0, '1'};
+    std::string teststr(test_bytes, sizeof(test_bytes));
+    BOOST_CHECK(!ParseUInt64(teststr, &n)); // no embedded NULs
+    // Overflow and underflow
+    BOOST_CHECK(!ParseUInt64("-9223372036854775809", nullptr));
+    BOOST_CHECK(!ParseUInt64("18446744073709551616", nullptr));
+    BOOST_CHECK(!ParseUInt64("-32482348723847471234", nullptr));
+    BOOST_CHECK(!ParseUInt64("-2147483648", &n));
+    BOOST_CHECK(!ParseUInt64("-9223372036854775808", &n));
+    BOOST_CHECK(!ParseUInt64("-1234", &n));
+}
+
+BOOST_AUTO_TEST_CASE(test_ParseDouble)
+{
+    double n;
+    // Valid values
+    BOOST_CHECK(ParseDouble("1234", nullptr));
+    BOOST_CHECK(ParseDouble("0", &n) && n == 0.0);
+    BOOST_CHECK(ParseDouble("1234", &n) && n == 1234.0);
+    BOOST_CHECK(ParseDouble("01234", &n) && n == 1234.0); // no octal
+    BOOST_CHECK(ParseDouble("2147483647", &n) && n == 2147483647.0);
+    BOOST_CHECK(ParseDouble("-2147483648", &n) && n == -2147483648.0);
+    BOOST_CHECK(ParseDouble("-1234", &n) && n == -1234.0);
+    BOOST_CHECK(ParseDouble("1e6", &n) && n == 1e6);
+    BOOST_CHECK(ParseDouble("-1e6", &n) && n == -1e6);
+    // Invalid values
+    BOOST_CHECK(!ParseDouble("", &n));
+    BOOST_CHECK(!ParseDouble(" 1", &n)); // no padding inside
+    BOOST_CHECK(!ParseDouble("1 ", &n));
+    BOOST_CHECK(!ParseDouble("1a", &n));
+    BOOST_CHECK(!ParseDouble("aap", &n));
+    BOOST_CHECK(!ParseDouble("0x1", &n)); // no hex
+    const char test_bytes[] = {'1', 0, '1'};
+    std::string teststr(test_bytes, sizeof(test_bytes));
+    BOOST_CHECK(!ParseDouble(teststr, &n)); // no embedded NULs
+    // Overflow and underflow
+    BOOST_CHECK(!ParseDouble("-1e10000", nullptr));
+    BOOST_CHECK(!ParseDouble("1e10000", nullptr));
+}
+
+BOOST_AUTO_TEST_CASE(test_FormatParagraph)
+{
+    BOOST_CHECK_EQUAL(FormatParagraph("", 79, 0), "");
+    BOOST_CHECK_EQUAL(FormatParagraph("test", 79, 0), "test");
+    BOOST_CHECK_EQUAL(FormatParagraph(" test", 79, 0), " test");
+    BOOST_CHECK_EQUAL(FormatParagraph("test test", 79, 0), "test test");
+    BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 0), "test\ntest");
+    BOOST_CHECK_EQUAL(FormatParagraph("testerde test", 4, 0), "testerde\ntest");
+    BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 4), "test\n    test");
+
+    // Make sure we don't indent a fully-new line following a too-long line ending
+    BOOST_CHECK_EQUAL(FormatParagraph("test test\nabc", 4, 4), "test\n    test\nabc");
+
+    BOOST_CHECK_EQUAL(FormatParagraph("This_is_a_very_long_test_string_without_any_spaces_so_it_should_just_get_returned_as_is_despite_the_length until it gets here", 79), "This_is_a_very_long_test_string_without_any_spaces_so_it_should_just_get_returned_as_is_despite_the_length\nuntil it gets here");
+
+    // Test wrap length is exact
+    BOOST_CHECK_EQUAL(FormatParagraph("a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p", 79), "a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de\nf g h i j k l m n o p");
+    BOOST_CHECK_EQUAL(FormatParagraph("x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p", 79), "x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de\nf g h i j k l m n o p");
+    // Indent should be included in length of lines
+    BOOST_CHECK_EQUAL(FormatParagraph("x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 a b c d e fg h i j k", 79, 4), "x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 a b c de\n    f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 a b c d e fg\n    h i j k");
+
+    BOOST_CHECK_EQUAL(FormatParagraph("This is a very long test string. This is a second sentence in the very long test string.", 79), "This is a very long test string. This is a second sentence in the very long\ntest string.");
+    BOOST_CHECK_EQUAL(FormatParagraph("This is a very long test string.\nThis is a second sentence in the very long test string. This is a third sentence in the very long test string.", 79), "This is a very long test string.\nThis is a second sentence in the very long test string. This is a third\nsentence in the very long test string.");
+    BOOST_CHECK_EQUAL(FormatParagraph("This is a very long test string.\n\nThis is a second sentence in the very long test string. This is a third sentence in the very long test string.", 79), "This is a very long test string.\n\nThis is a second sentence in the very long test string. This is a third\nsentence in the very long test string.");
+    BOOST_CHECK_EQUAL(FormatParagraph("Testing that normal newlines do not get indented.\nLike here.", 79), "Testing that normal newlines do not get indented.\nLike here.");
+}
+
+BOOST_AUTO_TEST_CASE(test_FormatSubVersion)
+{
+    std::vector<std::string> comments;
+    comments.push_back(std::string("comment1"));
+    std::vector<std::string> comments2;
+    comments2.push_back(std::string("comment1"));
+    comments2.push_back(SanitizeString(std::string("Comment2; .,_?@-; !\"#$%&'()*+/<=>[]\\^`{|}~"), SAFE_CHARS_UA_COMMENT)); // Semicolon is discouraged but not forbidden by BIP-0014
+    BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, std::vector<std::string>()),std::string("/Test:0.9.99/"));
+    BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments),std::string("/Test:0.9.99(comment1)/"));
+    BOOST_CHECK_EQUAL(FormatSubVersion("Test", 99900, comments2),std::string("/Test:0.9.99(comment1; Comment2; .,_?@-; )/"));
+}
+
+BOOST_AUTO_TEST_CASE(test_ParseFixedPoint)
+{
+    int64_t amount = 0;
+    BOOST_CHECK(ParseFixedPoint("0", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 0LL);
+    BOOST_CHECK(ParseFixedPoint("1", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 100000000LL);
+    BOOST_CHECK(ParseFixedPoint("0.0", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 0LL);
+    BOOST_CHECK(ParseFixedPoint("-0.1", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, -10000000LL);
+    BOOST_CHECK(ParseFixedPoint("1.1", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 110000000LL);
+    BOOST_CHECK(ParseFixedPoint("1.10000000000000000", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 110000000LL);
+    BOOST_CHECK(ParseFixedPoint("1.1e1", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 1100000000LL);
+    BOOST_CHECK(ParseFixedPoint("1.1e-1", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 11000000LL);
+    BOOST_CHECK(ParseFixedPoint("1000", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 100000000000LL);
+    BOOST_CHECK(ParseFixedPoint("-1000", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, -100000000000LL);
+    BOOST_CHECK(ParseFixedPoint("0.00000001", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 1LL);
+    BOOST_CHECK(ParseFixedPoint("0.0000000100000000", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 1LL);
+    BOOST_CHECK(ParseFixedPoint("-0.00000001", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, -1LL);
+    BOOST_CHECK(ParseFixedPoint("1000000000.00000001", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 100000000000000001LL);
+    BOOST_CHECK(ParseFixedPoint("9999999999.99999999", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, 999999999999999999LL);
+    BOOST_CHECK(ParseFixedPoint("-9999999999.99999999", 8, &amount));
+    BOOST_CHECK_EQUAL(amount, -999999999999999999LL);
+
+    BOOST_CHECK(!ParseFixedPoint("", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("a-1000", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-a1000", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-1000a", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-01000", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("00.1", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint(".1", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("--0.1", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("0.000000001", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-0.000000001", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("0.00000001000000001", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-10000000000.00000000", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("10000000000.00000000", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-10000000000.00000001", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("10000000000.00000001", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-10000000000.00000009", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("10000000000.00000009", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-99999999999.99999999", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("99999909999.09999999", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("92233720368.54775807", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("92233720368.54775808", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-92233720368.54775808", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("-92233720368.54775809", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("1.1e", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("1.1e-", 8, &amount));
+    BOOST_CHECK(!ParseFixedPoint("1.", 8, &amount));
+}
+
+static void TestOtherThread(fs::path dirname, std::string lockname, bool *result)
+{
+    *result = LockDirectory(dirname, lockname);
+}
+
+#ifndef WIN32 // Cannot do this test on WIN32 due to lack of fork()
+static constexpr char LockCommand = 'L';
+static constexpr char UnlockCommand = 'U';
+static constexpr char ExitCommand = 'X';
+
+static void TestOtherProcess(fs::path dirname, std::string lockname, int fd)
+{
+    char ch;
+    int rv;
+    while (true) {
+        rv = read(fd, &ch, 1); // Wait for command
+        assert(rv == 1);
+        switch(ch) {
+        case LockCommand:
+            ch = LockDirectory(dirname, lockname);
+            rv = write(fd, &ch, 1);
+            assert(rv == 1);
+            break;
+        case UnlockCommand:
+            ReleaseDirectoryLocks();
+            ch = true; // Always succeeds
+            rv = write(fd, &ch, 1);
+            break;
+        case ExitCommand:
+            close(fd);
+            exit(0);
+        default:
+            assert(0);
+        }
+    }
+}
+#endif
+
+BOOST_AUTO_TEST_CASE(test_LockDirectory)
+{
+    fs::path dirname = fs::temp_directory_path() / fs::unique_path();
+    const std::string lockname = ".lock";
+#ifndef WIN32
+    // Revert SIGCHLD to default, otherwise boost.test will catch and fail on
+    // it: there is BOOST_TEST_IGNORE_SIGCHLD but that only works when defined
+    // at build-time of the boost library
+    void (*old_handler)(int) = signal(SIGCHLD, SIG_DFL);
+
+    // Fork another process for testing before creating the lock, so that we
+    // won't fork while holding the lock (which might be undefined, and is not
+    // relevant as test case as that is avoided with -daemonize).
+    int fd[2];
+    BOOST_CHECK_EQUAL(socketpair(AF_UNIX, SOCK_STREAM, 0, fd), 0);
+    pid_t pid = fork();
+    if (!pid) {
+        BOOST_CHECK_EQUAL(close(fd[1]), 0); // Child: close parent end
+        TestOtherProcess(dirname, lockname, fd[0]);
+    }
+    BOOST_CHECK_EQUAL(close(fd[0]), 0); // Parent: close child end
+#endif
+    // Lock on non-existent directory should fail
+    BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), false);
+
+    fs::create_directories(dirname);
+
+    // Probing lock on new directory should succeed
+    BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
+
+    // Persistent lock on new directory should succeed
+    BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), true);
+
+    // Another lock on the directory from the same thread should succeed
+    BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), true);
+
+    // Another lock on the directory from a different thread within the same process should succeed
+    bool threadresult;
+    std::thread thr(TestOtherThread, dirname, lockname, &threadresult);
+    thr.join();
+    BOOST_CHECK_EQUAL(threadresult, true);
+#ifndef WIN32
+    // Try to acquire lock in child process while we're holding it, this should fail.
+    char ch;
+    BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
+    BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
+    BOOST_CHECK_EQUAL((bool)ch, false);
+
+    // Give up our lock
+    ReleaseDirectoryLocks();
+    // Probing lock from our side now should succeed, but not hold on to the lock.
+    BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
+
+    // Try to acquire the lock in the child process, this should be successful.
+    BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
+    BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
+    BOOST_CHECK_EQUAL((bool)ch, true);
+
+    // When we try to probe the lock now, it should fail.
+    BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), false);
+
+    // Unlock the lock in the child process
+    BOOST_CHECK_EQUAL(write(fd[1], &UnlockCommand, 1), 1);
+    BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
+    BOOST_CHECK_EQUAL((bool)ch, true);
+
+    // When we try to probe the lock now, it should succeed.
+    BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
+
+    // Re-lock the lock in the child process, then wait for it to exit, check
+    // successful return. After that, we check that exiting the process
+    // has released the lock as we would expect by probing it.
+    int processstatus;
+    BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
+    BOOST_CHECK_EQUAL(write(fd[1], &ExitCommand, 1), 1);
+    BOOST_CHECK_EQUAL(waitpid(pid, &processstatus, 0), pid);
+    BOOST_CHECK_EQUAL(processstatus, 0);
+    BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
+
+    // Restore SIGCHLD
+    signal(SIGCHLD, old_handler);
+    BOOST_CHECK_EQUAL(close(fd[1]), 0); // Close our side of the socketpair
+#endif
+    // Clean up
+    ReleaseDirectoryLocks();
+    fs::remove_all(dirname);
+}
+
+BOOST_AUTO_TEST_CASE(test_DirIsWritable)
+{
+    // Should be able to write to the system tmp dir.
+    fs::path tmpdirname = fs::temp_directory_path();
+    BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), true);
+
+    // Should not be able to write to a non-existent dir.
+    tmpdirname = fs::temp_directory_path() / fs::unique_path();
+    BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), false);
+
+    fs::create_directory(tmpdirname);
+    // Should be able to write to it now.
+    BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), true);
+    fs::remove(tmpdirname);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/versionbits_tests.cpp b/versionbits_tests.cpp
new file mode 100644
index 0000000..20f4e8e
--- /dev/null
+++ b/versionbits_tests.cpp
@@ -0,0 +1,354 @@
+// Copyright (c) 2018 The SalemCash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <chain.h>
+#include <versionbits.h>
+#include <test/test_bitcoin.h>
+#include <chainparams.h>
+#include <validation.h>
+#include <consensus/params.h>
+
+#include <boost/test/unit_test.hpp>
+
+/* Define a virtual block time, one block per 10 minutes after Nov 14 2014, 0:55:36am */
+int32_t TestTime(int nHeight) { return 1415926536 + 600 * nHeight; }
+
+static const Consensus::Params paramsDummy = Consensus::Params();
+
+class TestConditionChecker : public AbstractThresholdConditionChecker
+{
+private:
+    mutable ThresholdConditionCache cache;
+
+public:
+    int64_t BeginTime(const Consensus::Params& params) const override { return TestTime(10000); }
+    int64_t EndTime(const Consensus::Params& params) const override { return TestTime(20000); }
+    int Period(const Consensus::Params& params) const override { return 1000; }
+    int Threshold(const Consensus::Params& params) const override { return 900; }
+    bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override { return (pindex->nVersion & 0x100); }
+
+    ThresholdState GetStateFor(const CBlockIndex* pindexPrev) const { return AbstractThresholdConditionChecker::GetStateFor(pindexPrev, paramsDummy, cache); }
+    int GetStateSinceHeightFor(const CBlockIndex* pindexPrev) const { return AbstractThresholdConditionChecker::GetStateSinceHeightFor(pindexPrev, paramsDummy, cache); }
+};
+
+class TestAlwaysActiveConditionChecker : public TestConditionChecker
+{
+public:
+    int64_t BeginTime(const Consensus::Params& params) const override { return Consensus::BIP9Deployment::ALWAYS_ACTIVE; }
+};
+
+#define CHECKERS 6
+
+class VersionBitsTester
+{
+    // A fake blockchain
+    std::vector<CBlockIndex*> vpblock;
+
+    // 6 independent checkers for the same bit.
+    // The first one performs all checks, the second only 50%, the third only 25%, etc...
+    // This is to test whether lack of cached information leads to the same results.
+    TestConditionChecker checker[CHECKERS];
+    // Another 6 that assume always active activation
+    TestAlwaysActiveConditionChecker checker_always[CHECKERS];
+
+    // Test counter (to identify failures)
+    int num;
+
+public:
+    VersionBitsTester() : num(0) {}
+
+    VersionBitsTester& Reset() {
+        for (unsigned int i = 0; i < vpblock.size(); i++) {
+            delete vpblock[i];
+        }
+        for (unsigned int  i = 0; i < CHECKERS; i++) {
+            checker[i] = TestConditionChecker();
+            checker_always[i] = TestAlwaysActiveConditionChecker();
+        }
+        vpblock.clear();
+        return *this;
+    }
+
+    ~VersionBitsTester() {
+         Reset();
+    }
+
+    VersionBitsTester& Mine(unsigned int height, int32_t nTime, int32_t nVersion) {
+        while (vpblock.size() < height) {
+            CBlockIndex* pindex = new CBlockIndex();
+            pindex->nHeight = vpblock.size();
+            pindex->pprev = vpblock.size() > 0 ? vpblock.back() : nullptr;
+            pindex->nTime = nTime;
+            pindex->nVersion = nVersion;
+            pindex->BuildSkip();
+            vpblock.push_back(pindex);
+        }
+        return *this;
+    }
+
+    VersionBitsTester& TestStateSinceHeight(int height) {
+        for (int i = 0; i < CHECKERS; i++) {
+            if (InsecureRandBits(i) == 0) {
+                BOOST_CHECK_MESSAGE(checker[i].GetStateSinceHeightFor(vpblock.empty() ? nullptr : vpblock.back()) == height, strprintf("Test %i for StateSinceHeight", num));
+                BOOST_CHECK_MESSAGE(checker_always[i].GetStateSinceHeightFor(vpblock.empty() ? nullptr : vpblock.back()) == 0, strprintf("Test %i for StateSinceHeight (always active)", num));
+            }
+        }
+        num++;
+        return *this;
+    }
+
+    VersionBitsTester& TestDefined() {
+        for (int i = 0; i < CHECKERS; i++) {
+            if (InsecureRandBits(i) == 0) {
+                BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == THRESHOLD_DEFINED, strprintf("Test %i for DEFINED", num));
+                BOOST_CHECK_MESSAGE(checker_always[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == THRESHOLD_ACTIVE, strprintf("Test %i for ACTIVE (always active)", num));
+            }
+        }
+        num++;
+        return *this;
+    }
+
+    VersionBitsTester& TestStarted() {
+        for (int i = 0; i < CHECKERS; i++) {
+            if (InsecureRandBits(i) == 0) {
+                BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == THRESHOLD_STARTED, strprintf("Test %i for STARTED", num));
+                BOOST_CHECK_MESSAGE(checker_always[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == THRESHOLD_ACTIVE, strprintf("Test %i for ACTIVE (always active)", num));
+            }
+        }
+        num++;
+        return *this;
+    }
+
+    VersionBitsTester& TestLockedIn() {
+        for (int i = 0; i < CHECKERS; i++) {
+            if (InsecureRandBits(i) == 0) {
+                BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == THRESHOLD_LOCKED_IN, strprintf("Test %i for LOCKED_IN", num));
+                BOOST_CHECK_MESSAGE(checker_always[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == THRESHOLD_ACTIVE, strprintf("Test %i for ACTIVE (always active)", num));
+            }
+        }
+        num++;
+        return *this;
+    }
+
+    VersionBitsTester& TestActive() {
+        for (int i = 0; i < CHECKERS; i++) {
+            if (InsecureRandBits(i) == 0) {
+                BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == THRESHOLD_ACTIVE, strprintf("Test %i for ACTIVE", num));
+                BOOST_CHECK_MESSAGE(checker_always[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == THRESHOLD_ACTIVE, strprintf("Test %i for ACTIVE (always active)", num));
+            }
+        }
+        num++;
+        return *this;
+    }
+
+    VersionBitsTester& TestFailed() {
+        for (int i = 0; i < CHECKERS; i++) {
+            if (InsecureRandBits(i) == 0) {
+                BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == THRESHOLD_FAILED, strprintf("Test %i for FAILED", num));
+                BOOST_CHECK_MESSAGE(checker_always[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == THRESHOLD_ACTIVE, strprintf("Test %i for ACTIVE (always active)", num));
+            }
+        }
+        num++;
+        return *this;
+    }
+
+    CBlockIndex * Tip() { return vpblock.size() ? vpblock.back() : nullptr; }
+};
+
+BOOST_FIXTURE_TEST_SUITE(versionbits_tests, TestingSetup)
+
+BOOST_AUTO_TEST_CASE(versionbits_test)
+{
+    for (int i = 0; i < 64; i++) {
+        // DEFINED -> FAILED
+        VersionBitsTester().TestDefined().TestStateSinceHeight(0)
+                           .Mine(1, TestTime(1), 0x100).TestDefined().TestStateSinceHeight(0)
+                           .Mine(11, TestTime(11), 0x100).TestDefined().TestStateSinceHeight(0)
+                           .Mine(989, TestTime(989), 0x100).TestDefined().TestStateSinceHeight(0)
+                           .Mine(999, TestTime(20000), 0x100).TestDefined().TestStateSinceHeight(0)
+                           .Mine(1000, TestTime(20000), 0x100).TestFailed().TestStateSinceHeight(1000)
+                           .Mine(1999, TestTime(30001), 0x100).TestFailed().TestStateSinceHeight(1000)
+                           .Mine(2000, TestTime(30002), 0x100).TestFailed().TestStateSinceHeight(1000)
+                           .Mine(2001, TestTime(30003), 0x100).TestFailed().TestStateSinceHeight(1000)
+                           .Mine(2999, TestTime(30004), 0x100).TestFailed().TestStateSinceHeight(1000)
+                           .Mine(3000, TestTime(30005), 0x100).TestFailed().TestStateSinceHeight(1000)
+
+        // DEFINED -> STARTED -> FAILED
+                           .Reset().TestDefined().TestStateSinceHeight(0)
+                           .Mine(1, TestTime(1), 0).TestDefined().TestStateSinceHeight(0)
+                           .Mine(1000, TestTime(10000) - 1, 0x100).TestDefined().TestStateSinceHeight(0) // One second more and it would be defined
+                           .Mine(2000, TestTime(10000), 0x100).TestStarted().TestStateSinceHeight(2000) // So that's what happens the next period
+                           .Mine(2051, TestTime(10010), 0).TestStarted().TestStateSinceHeight(2000) // 51 old blocks
+                           .Mine(2950, TestTime(10020), 0x100).TestStarted().TestStateSinceHeight(2000) // 899 new blocks
+                           .Mine(3000, TestTime(20000), 0).TestFailed().TestStateSinceHeight(3000) // 50 old blocks (so 899 out of the past 1000)
+                           .Mine(4000, TestTime(20010), 0x100).TestFailed().TestStateSinceHeight(3000)
+
+        // DEFINED -> STARTED -> FAILED while threshold reached
+                           .Reset().TestDefined().TestStateSinceHeight(0)
+                           .Mine(1, TestTime(1), 0).TestDefined().TestStateSinceHeight(0)
+                           .Mine(1000, TestTime(10000) - 1, 0x101).TestDefined().TestStateSinceHeight(0) // One second more and it would be defined
+                           .Mine(2000, TestTime(10000), 0x101).TestStarted().TestStateSinceHeight(2000) // So that's what happens the next period
+                           .Mine(2999, TestTime(30000), 0x100).TestStarted().TestStateSinceHeight(2000) // 999 new blocks
+                           .Mine(3000, TestTime(30000), 0x100).TestFailed().TestStateSinceHeight(3000) // 1 new block (so 1000 out of the past 1000 are new)
+                           .Mine(3999, TestTime(30001), 0).TestFailed().TestStateSinceHeight(3000)
+                           .Mine(4000, TestTime(30002), 0).TestFailed().TestStateSinceHeight(3000)
+                           .Mine(14333, TestTime(30003), 0).TestFailed().TestStateSinceHeight(3000)
+                           .Mine(24000, TestTime(40000), 0).TestFailed().TestStateSinceHeight(3000)
+
+        // DEFINED -> STARTED -> LOCKEDIN at the last minute -> ACTIVE
+                           .Reset().TestDefined()
+                           .Mine(1, TestTime(1), 0).TestDefined().TestStateSinceHeight(0)
+                           .Mine(1000, TestTime(10000) - 1, 0x101).TestDefined().TestStateSinceHeight(0) // One second more and it would be defined
+                           .Mine(2000, TestTime(10000), 0x101).TestStarted().TestStateSinceHeight(2000) // So that's what happens the next period
+                           .Mine(2050, TestTime(10010), 0x200).TestStarted().TestStateSinceHeight(2000) // 50 old blocks
+                           .Mine(2950, TestTime(10020), 0x100).TestStarted().TestStateSinceHeight(2000) // 900 new blocks
+                           .Mine(2999, TestTime(19999), 0x200).TestStarted().TestStateSinceHeight(2000) // 49 old blocks
+                           .Mine(3000, TestTime(29999), 0x200).TestLockedIn().TestStateSinceHeight(3000) // 1 old block (so 900 out of the past 1000)
+                           .Mine(3999, TestTime(30001), 0).TestLockedIn().TestStateSinceHeight(3000)
+                           .Mine(4000, TestTime(30002), 0).TestActive().TestStateSinceHeight(4000)
+                           .Mine(14333, TestTime(30003), 0).TestActive().TestStateSinceHeight(4000)
+                           .Mine(24000, TestTime(40000), 0).TestActive().TestStateSinceHeight(4000)
+
+        // DEFINED multiple periods -> STARTED multiple periods -> FAILED
+                           .Reset().TestDefined().TestStateSinceHeight(0)
+                           .Mine(999, TestTime(999), 0).TestDefined().TestStateSinceHeight(0)
+                           .Mine(1000, TestTime(1000), 0).TestDefined().TestStateSinceHeight(0)
+                           .Mine(2000, TestTime(2000), 0).TestDefined().TestStateSinceHeight(0)
+                           .Mine(3000, TestTime(10000), 0).TestStarted().TestStateSinceHeight(3000)
+                           .Mine(4000, TestTime(10000), 0).TestStarted().TestStateSinceHeight(3000)
+                           .Mine(5000, TestTime(10000), 0).TestStarted().TestStateSinceHeight(3000)
+                           .Mine(6000, TestTime(20000), 0).TestFailed().TestStateSinceHeight(6000)
+                           .Mine(7000, TestTime(20000), 0x100).TestFailed().TestStateSinceHeight(6000);
+    }
+
+    // Sanity checks of version bit deployments
+    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const Consensus::Params &mainnetParams = chainParams->GetConsensus();
+    for (int i=0; i<(int) Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
+        uint32_t bitmask = VersionBitsMask(mainnetParams, static_cast<Consensus::DeploymentPos>(i));
+        // Make sure that no deployment tries to set an invalid bit.
+        BOOST_CHECK_EQUAL(bitmask & ~(uint32_t)VERSIONBITS_TOP_MASK, bitmask);
+
+        // Verify that the deployment windows of different deployment using the
+        // same bit are disjoint.
+        // This test may need modification at such time as a new deployment
+        // is proposed that reuses the bit of an activated soft fork, before the
+        // end time of that soft fork.  (Alternatively, the end time of that
+        // activated soft fork could be later changed to be earlier to avoid
+        // overlap.)
+        for (int j=i+1; j<(int) Consensus::MAX_VERSION_BITS_DEPLOYMENTS; j++) {
+            if (VersionBitsMask(mainnetParams, static_cast<Consensus::DeploymentPos>(j)) == bitmask) {
+                BOOST_CHECK(mainnetParams.vDeployments[j].nStartTime > mainnetParams.vDeployments[i].nTimeout ||
+                        mainnetParams.vDeployments[i].nStartTime > mainnetParams.vDeployments[j].nTimeout);
+            }
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(versionbits_computeblockversion)
+{
+    // Check that ComputeBlockVersion will set the appropriate bit correctly
+    // on mainnet.
+    const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
+    const Consensus::Params &mainnetParams = chainParams->GetConsensus();
+
+    // Use the TESTDUMMY deployment for testing purposes.
+    int64_t bit = mainnetParams.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit;
+    int64_t nStartTime = mainnetParams.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime;
+    int64_t nTimeout = mainnetParams.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout;
+
+    assert(nStartTime < nTimeout);
+
+    // In the first chain, test that the bit is set by CBV until it has failed.
+    // In the second chain, test the bit is set by CBV while STARTED and
+    // LOCKED-IN, and then no longer set while ACTIVE.
+    VersionBitsTester firstChain, secondChain;
+
+    // Start generating blocks before nStartTime
+    int64_t nTime = nStartTime - 1;
+
+    // Before MedianTimePast of the chain has crossed nStartTime, the bit
+    // should not be set.
+    CBlockIndex *lastBlock = nullptr;
+    lastBlock = firstChain.Mine(2016, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
+    BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit), 0);
+
+    // Mine 2011 more blocks at the old time, and check that CBV isn't setting the bit yet.
+    for (int i=1; i<2012; i++) {
+        lastBlock = firstChain.Mine(2016+i, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
+        // This works because VERSIONBITS_LAST_OLD_BLOCK_VERSION happens
+        // to be 4, and the bit we're testing happens to be bit 28.
+        BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit), 0);
+    }
+    // Now mine 5 more blocks at the start time -- MTP should not have passed yet, so
+    // CBV should still not yet set the bit.
+    nTime = nStartTime;
+    for (int i=2012; i<=2016; i++) {
+        lastBlock = firstChain.Mine(2016+i, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
+        BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit), 0);
+    }
+
+    // Advance to the next period and transition to STARTED,
+    lastBlock = firstChain.Mine(6048, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
+    // so ComputeBlockVersion should now set the bit,
+    BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
+    // and should also be using the VERSIONBITS_TOP_BITS.
+    BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & VERSIONBITS_TOP_MASK, VERSIONBITS_TOP_BITS);
+
+    // Check that ComputeBlockVersion will set the bit until nTimeout
+    nTime += 600;
+    int blocksToMine = 4032; // test blocks for up to 2 time periods
+    int nHeight = 6048;
+    // These blocks are all before nTimeout is reached.
+    while (nTime < nTimeout && blocksToMine > 0) {
+        lastBlock = firstChain.Mine(nHeight+1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
+        BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
+        BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & VERSIONBITS_TOP_MASK, VERSIONBITS_TOP_BITS);
+        blocksToMine--;
+        nTime += 600;
+        nHeight += 1;
+    }
+
+    nTime = nTimeout;
+    // FAILED is only triggered at the end of a period, so CBV should be setting
+    // the bit until the period transition.
+    for (int i=0; i<2015; i++) {
+        lastBlock = firstChain.Mine(nHeight+1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
+        BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
+        nHeight += 1;
+    }
+    // The next block should trigger no longer setting the bit.
+    lastBlock = firstChain.Mine(nHeight+1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
+    BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit), 0);
+
+    // On a new chain:
+    // verify that the bit will be set after lock-in, and then stop being set
+    // after activation.
+    nTime = nStartTime;
+
+    // Mine one period worth of blocks, and check that the bit will be on for the
+    // next period.
+    lastBlock = secondChain.Mine(2016, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
+    BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
+
+    // Mine another period worth of blocks, signaling the new bit.
+    lastBlock = secondChain.Mine(4032, nTime, VERSIONBITS_TOP_BITS | (1<<bit)).Tip();
+    // After one period of setting the bit on each block, it should have locked in.
+    // We keep setting the bit for one more period though, until activation.
+    BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
+
+    // Now check that we keep mining the block until the end of this period, and
+    // then stop at the beginning of the next period.
+    lastBlock = secondChain.Mine(6047, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
+    BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
+    lastBlock = secondChain.Mine(6048, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
+    BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit), 0);
+
+    // Finally, verify that after a soft fork has activated, CBV no longer uses
+    // VERSIONBITS_LAST_OLD_BLOCK_VERSION.
+    //BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & VERSIONBITS_TOP_MASK, VERSIONBITS_TOP_BITS);
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()