From 5c8ebea00cc5aa6c6dd200222acc90619ad75aab Mon Sep 17 00:00:00 2001
From: Ross Nicoll <jrn@jrn.me.uk>
Date: Fri, 10 Sep 2021 08:25:57 +0100
Subject: [PATCH] consensus: AuxPoW header

Add the AuxPoW header to block storage, without yet adding code to mine or validate mined AuxPoW blocks.
---
 src/Makefile.test.include |   1 +
 src/rpc/auxpow_miner.cpp  | 154 ++++++++++
 src/rpc/auxpow_miner.h    | 107 +++++++
 src/test/auxpow_tests.cpp | 605 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 867 insertions(+)
 create mode 100644 src/rpc/auxpow_miner.cpp
 create mode 100644 src/rpc/auxpow_miner.h
 create mode 100644 src/test/auxpow_tests.cpp

diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 9902f53081f..fc2a0fe1a1c 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -214,6 +214,7 @@ BITCOIN_TESTS =\
   test/addrman_tests.cpp \
   test/amount_tests.cpp \
   test/allocator_tests.cpp \
+  test/auxpow_tests.cpp \
   test/base32_tests.cpp \
   test/base58_tests.cpp \
   test/base64_tests.cpp \
diff --git a/src/rpc/auxpow_miner.cpp b/src/rpc/auxpow_miner.cpp
new file mode 100644
index 00000000000..518736af6aa
--- /dev/null
+++ b/src/rpc/auxpow_miner.cpp
@@ -0,0 +1,154 @@
+// Copyright(c) 2018-2020 Daniel Kraft
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <rpc/auxpow_miner.h>
+
+#include <arith_uint256.h>
+#include <auxpow.h>
+#include <chainparams.h>
+#include <net.h>
+#include <node/context.h>
+#include <rpc/blockchain.h>
+#include <rpc/protocol.h>
+#include <rpc/request.h>
+#include <util/check.h>
+#include <util/strencodings.h>
+#include <util/time.h>
+#include <validation.h>
+
+const CBlock*
+AuxpowMiner::getCurrentBlock(const CTxMemPool& mempool,
+                              const CScript& scriptPubKey, uint256& target) EXCLUSIVE_LOCKS_REQUIRED(cs)
+{
+  AssertLockHeld(cs);
+  const CBlock* pblockCur = nullptr;
+
+  {
+    LOCK(cs_main);
+    CScriptID scriptID(scriptPubKey);
+    auto iter = curBlocks.find(scriptID);
+    if (iter != curBlocks.end())
+      pblockCur = iter->second;
+
+    if (pblockCur == nullptr
+        || pindexPrev != ::ChainActive().Tip()
+        ||(mempool.GetTransactionsUpdated() != txUpdatedLast
+            && GetTime() - startTime > MAX_BLOCK_TEMPLATE_AGE_SECONDS))
+      {
+        if (pindexPrev != ::ChainActive().Tip())
+          {
+            /* Clear old blocks since they're obsolete now.  */
+            blocks.clear();
+            templates.clear();
+            curBlocks.clear();
+          }
+
+        /* Create new block with nonce = 0 and extraNonce = 1.  */
+        std::unique_ptr<CBlockTemplate> newBlock
+            = BlockAssembler(mempool, Params()).CreateNewBlock(scriptPubKey);
+        if (newBlock == nullptr)
+          throw JSONRPCError(RPC_OUT_OF_MEMORY, "out of memory");
+
+        /* Update state only when CreateNewBlock succeeded.  */
+        txUpdatedLast = mempool.GetTransactionsUpdated();
+        pindexPrev = ::ChainActive().Tip();
+        startTime = GetTime();
+
+        /* Finalise it by setting the version and building the merkle root.  */
+        IncrementExtraNonce(&newBlock->block, pindexPrev, extraNonce);
+        newBlock->block.SetAuxpowFlag(true);
+
+        /* Save in our map of constructed blocks.  */
+        pblockCur = &newBlock->block;
+        curBlocks.emplace(scriptID, pblockCur);
+        blocks[pblockCur->GetHash()] = pblockCur;
+        templates.push_back(std::move(newBlock));
+      }
+  }
+
+  /* At this point, pblockCur is always initialised:  If we make it here
+     without creating a new block above, it means that, in particular,
+     pindexPrev == ::ChainActive().Tip().  But for that to happen, we must
+     already have created a pblockCur in a previous call, as pindexPrev is
+     initialised only when pblockCur is.  */
+  CHECK_NONFATAL(pblockCur);
+
+  arith_uint256 arithTarget;
+  bool fNegative, fOverflow;
+  arithTarget.SetCompact(pblockCur->nBits, &fNegative, &fOverflow);
+  if (fNegative || fOverflow || arithTarget == 0)
+    throw std::runtime_error("invalid difficulty bits in block");
+  target = ArithToUint256(arithTarget);
+
+  return pblockCur;
+}
+
+const CBlock*
+AuxpowMiner::lookupSavedBlock(const uint256 hash) const EXCLUSIVE_LOCKS_REQUIRED(cs)
+{
+  AssertLockHeld(cs);
+
+  const auto iter = blocks.find(hash);
+  if (iter == blocks.end())
+    throw JSONRPCError(RPC_INVALID_PARAMETER, "block hash unknown");
+
+  return iter->second;
+}
+
+UniValue
+AuxpowMiner::createAuxBlock(const CTxMemPool& mempool,
+                            const CScript& scriptPubKey)
+{
+  LOCK(cs);
+
+  uint256 target;
+  const CBlock* pblock = getCurrentBlock(mempool, scriptPubKey, target);
+
+  UniValue result(UniValue::VOBJ);
+  result.pushKV("hash", pblock->GetHash().GetHex());
+  result.pushKV("chainid", pblock->GetChainId());
+  result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
+  result.pushKV("coinbasevalue",
+                 static_cast<int64_t>(pblock->vtx[0]->vout[0].nValue));
+  result.pushKV("bits", strprintf("%08x", pblock->nBits));
+  result.pushKV("height", static_cast<int64_t>(pindexPrev->nHeight + 1));
+  result.pushKV("_target", HexStr(target));
+
+  return result;
+}
+
+bool
+AuxpowMiner::submitAuxBlock(ChainstateManager& chainman,
+                            const uint256 hash,
+                            const std::string& auxpowHex) const
+{
+  std::shared_ptr<CBlock> shared_block;
+  {
+    LOCK(cs);
+    const CBlock* pblock = lookupSavedBlock(hash);
+    shared_block = std::make_shared<CBlock>(*pblock);
+  }
+
+  const std::vector<unsigned char> vchAuxPow = ParseHex(auxpowHex);
+  CDataStream ss(vchAuxPow, SER_GETHASH, PROTOCOL_VERSION);
+  std::unique_ptr<CAuxPow> pow(new CAuxPow());
+  ss >> *pow;
+  shared_block->SetAuxpow(std::move(pow));
+  CHECK_NONFATAL(shared_block->GetHash() == hash);
+
+  return chainman.ProcessNewBlock(Params(), shared_block, true, nullptr);
+}
+
+AuxpowMiner&
+AuxpowMiner::get()
+{
+  static AuxpowMiner* instance = nullptr;
+  static RecursiveMutex lock;
+
+  LOCK(lock);
+  if (instance == nullptr)
+    instance = new AuxpowMiner();
+
+  return *instance;
+}
diff --git a/src/rpc/auxpow_miner.h b/src/rpc/auxpow_miner.h
new file mode 100644
index 00000000000..553f89cf856
--- /dev/null
+++ b/src/rpc/auxpow_miner.h
@@ -0,0 +1,107 @@
+// Copyright (c) 2018-2020 Daniel Kraft
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_RPC_AUXPOW_MINER_H
+#define BITCOIN_RPC_AUXPOW_MINER_H
+
+#include <miner.h>
+#include <rpc/request.h>
+#include <script/script.h>
+#include <script/standard.h>
+#include <sync.h>
+#include <txmempool.h>
+#include <uint256.h>
+#include <univalue.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+/** The maximum time to retain a built block template for, before forcing replacement. */
+// Dogecoin: This is a guesstimate, and may need refinement. Namecoin used 60 seconds (1/10th block interval).
+static const unsigned int MAX_BLOCK_TEMPLATE_AGE_SECONDS = 10;
+
+namespace auxpow_tests
+{
+class AuxpowMinerForTest;
+}
+
+/**
+ * This class holds "global" state used to construct blocks for the auxpow
+ * mining RPCs and the map of already constructed blocks to look them up
+ * in the submitauxblock RPC.
+ *
+ * It is used as a singleton that is initialised during startup, taking the
+ * place of the previously real global and static variables.
+ */
+class AuxpowMiner
+{
+
+private:
+
+  /** The lock used for state in this object.  */
+  mutable RecursiveMutex cs;
+  /** All currently "active" block templates.  */
+  std::vector<std::unique_ptr<CBlockTemplate>> templates;
+  /** Maps block hashes to pointers in vTemplates.  Does not own the memory.  */
+  std::map<uint256, const CBlock*> blocks;
+  /** Maps coinbase script hashes to pointers in vTemplates.  Does not own the memory.  */
+  std::map<CScriptID, const CBlock*> curBlocks;
+
+  /** The current extra nonce for block creation.  */
+  unsigned extraNonce = 0;
+
+  /* Some data about when the current block (pblock) was constructed.  */
+  unsigned txUpdatedLast;
+  const CBlockIndex* pindexPrev = nullptr;
+  uint64_t startTime;
+
+  /**
+   * Constructs a new current block if necessary (checking the current state to
+   * see if "enough changed" for this), and returns a pointer to the block
+   * that should be returned to a miner for working on at the moment.  Also
+   * fills in the difficulty target value.
+   */
+  const CBlock* getCurrentBlock(const CTxMemPool& mempool,
+                                const CScript& scriptPubKey, uint256& target);
+
+  /**
+   * Looks up a previously constructed block by its (hex-encoded) hash.  If the
+   * block is found, it is returned.  Otherwise, a JSONRPCError is thrown.
+   */
+  const CBlock* lookupSavedBlock(const uint256 hash) const;
+
+  friend class auxpow_tests::AuxpowMinerForTest;
+
+public:
+
+  AuxpowMiner () = default;
+
+  /**
+   * Performs the main work for the "createauxblock" RPC:  Construct a new block
+   * to work on with the given address for the block reward and return the
+   * necessary information for the miner to construct an auxpow for it.
+   */
+  UniValue createAuxBlock(const CTxMemPool& mempool,
+                          const CScript& scriptPubKey);
+
+  /**
+   * Performs the main work for the "submitauxblock" RPC:  Look up the block
+   * previously created for the given hash, attach the given auxpow to it
+   * and try to submit it.  Returns true if all was successful and the block
+   * was accepted.
+   */
+  bool submitAuxBlock(ChainstateManager& chainman,
+                      const uint256 hash,
+                      const std::string& auxpowHex) const;
+
+  /**
+   * Returns the singleton instance of AuxpowMiner that is used for RPCs.
+   */
+  static AuxpowMiner& get ();
+
+};
+
+#endif // BITCOIN_RPC_AUXPOW_MINER_H
diff --git a/src/test/auxpow_tests.cpp b/src/test/auxpow_tests.cpp
new file mode 100644
index 00000000000..53cc5b86b76
--- /dev/null
+++ b/src/test/auxpow_tests.cpp
@@ -0,0 +1,605 @@
+// Copyright (c) 2014-2020 Daniel Kraft
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <arith_uint256.h>
+#include <auxpow.h>
+#include <chainparams.h>
+#include <coins.h>
+#include <consensus/merkle.h>
+#include <validation.h>
+#include <pow.h>
+#include <primitives/block.h>
+#include <rpc/auxpow_miner.h>
+#include <script/script.h>
+#include <util/strencodings.h>
+#include <util/time.h>
+#include <uint256.h>
+#include <univalue.h>
+
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <vector>
+
+/* No space between BOOST_AUTO_TEST_SUITE and '(', so that extraction of
+   the test-suite name works with grep as done in the Makefile.  */
+BOOST_AUTO_TEST_SUITE(auxpow_tests)
+
+/* ************************************************************************** */
+
+/**
+ * Tamper with a uint256 (modify it).
+ * @param num The number to modify.
+ */
+static void
+tamperWith(uint256& num)
+{
+    arith_uint256 modifiable = UintToArith256(num);
+    modifiable += 1;
+    num = ArithToUint256(modifiable);
+}
+
+/**
+ * Helper class that is friend to CAuxPow and makes the internals accessible
+ * to the test code.
+ */
+class CAuxPowForTest : public CAuxPow
+{
+
+public:
+
+  explicit inline CAuxPowForTest (CTransactionRef txIn)
+    : CAuxPow (std::move (txIn))
+  {}
+
+  using CAuxPow::coinbaseTx;
+  using CAuxPow::vMerkleBranch;
+  using CAuxPow::vChainMerkleBranch;
+  using CAuxPow::nChainIndex;
+  using CAuxPow::parentBlock;
+
+  using CAuxPow::CheckMerkleBranch;
+
+};
+
+/**
+ * Utility class to construct auxpow's and manipulate them.  This is used
+ * to simulate various scenarios.
+ */
+class CAuxpowBuilder
+{
+public:
+
+    /** The parent block (with coinbase, not just header).  */
+    CBlock parentBlock;
+
+    /** The auxpow's merkle branch (connecting it to the coinbase).  */
+    std::vector<uint256> auxpowChainMerkleBranch;
+    /** The auxpow's merkle tree index.  */
+    int auxpowChainIndex;
+
+    /**
+    * Initialise everything.
+    * @param baseVersion The parent block's base version to use.
+    * @param chainId The parent block's chain ID to use.
+    */
+    CAuxpowBuilder(int baseVersion, int chainId);
+
+    /**
+    * Set the coinbase's script.
+    * @param scr Set it to this script.
+    */
+    void setCoinbase(const CScript& scr);
+
+    /**
+    * Build the auxpow merkle branch.  The member variables will be
+    * set accordingly.  This has to be done before constructing the coinbase
+    * itself (which must contain the root merkle hash).  When we have the
+    * coinbase afterwards, the member variables can be used to initialise
+    * the CAuxPow object from it.
+    * @param hashAux The merge-mined chain's block hash.
+    * @param h Height of the merkle tree to build.
+    * @param index Index to use in the merkle tree.
+    * @return The root hash, with reversed endian.
+    */
+    std::vector<unsigned char> buildAuxpowChain(const uint256& hashAux, unsigned h, int index);
+
+    /**
+    * Build the finished CAuxPow object.  We assume that the auxpowChain
+    * member variables are already set.  We use the passed in transaction
+    * as the base.  It should (probably) be the parent block's coinbase.
+    * @param tx The base tx to use.
+    * @return The constructed CAuxPow object.
+    */
+    CAuxPow get(const CTransactionRef tx) const;
+
+    /**
+    * Build the finished CAuxPow object from the parent block's coinbase.
+    * @return The constructed CAuxPow object.
+    */
+    inline CAuxPow
+    get() const
+    {
+        assert (!parentBlock.vtx.empty());
+        return get(parentBlock.vtx[0]);
+    }
+
+    /**
+    * Returns the finished CAuxPow object and returns it as std::unique_ptr.
+    */
+    inline std::unique_ptr<CAuxPow>
+    getUnique() const
+    {
+        return std::unique_ptr<CAuxPow>(new CAuxPow(get()));
+    }
+
+    /**
+    * Build a data vector to be included in the coinbase.  It consists
+    * of the aux hash, the merkle tree size and the nonce.  Optionally,
+    * the header can be added as well.
+    * @param header Add the header?
+    * @param hashAux The aux merkle root hash.
+    * @param h Height of the merkle tree.
+    * @param nonce The nonce value to use.
+    * @return The constructed data.
+    */
+    static std::vector<unsigned char> buildCoinbaseData(bool header, const std::vector<unsigned char>& auxRoot,
+                                        unsigned h, int nonce);
+
+};
+
+CAuxpowBuilder::CAuxpowBuilder(int baseVersion, int chainId)
+  : auxpowChainIndex(-1)
+{
+  parentBlock.SetBaseVersion(baseVersion, chainId);
+}
+
+void
+CAuxpowBuilder::setCoinbase(const CScript& scr)
+{
+    CMutableTransaction mtx;
+    mtx.vin.resize(1);
+    mtx.vin[0].prevout.SetNull ();
+    mtx.vin[0].scriptSig = scr;
+
+    parentBlock.vtx.clear();
+    parentBlock.vtx.push_back(MakeTransactionRef(std::move (mtx)));
+    parentBlock.hashMerkleRoot = BlockMerkleRoot(parentBlock);
+}
+
+std::vector<unsigned char>
+CAuxpowBuilder::buildAuxpowChain(const uint256& hashAux, unsigned h, int index)
+{
+    auxpowChainIndex = index;
+
+    /* Just use "something" for the branch.  Doesn't really matter.  */
+    auxpowChainMerkleBranch.clear();
+    for (unsigned i = 0; i < h; ++i)
+        auxpowChainMerkleBranch.push_back(ArithToUint256(arith_uint256(i)));
+
+    const uint256 hash
+        = CAuxPowForTest::CheckMerkleBranch(hashAux, auxpowChainMerkleBranch,
+                                          index);
+
+    std::vector<unsigned char> res = ToByteVector(hash);
+    std::reverse(res.begin(), res.end());
+
+    return res;
+}
+
+CAuxPow
+CAuxpowBuilder::get(const CTransactionRef tx) const
+{
+    LOCK(cs_main);
+
+    CAuxPowForTest res(tx);
+    res.vMerkleBranch = merkle_tests::BlockMerkleBranch(parentBlock, 0);
+
+    res.vChainMerkleBranch = auxpowChainMerkleBranch;
+    res.nChainIndex = auxpowChainIndex;
+    res.parentBlock = parentBlock;
+
+    return res;
+}
+
+std::vector<unsigned char>
+CAuxpowBuilder::buildCoinbaseData(bool header, const std::vector<unsigned char>& auxRoot,
+                                  unsigned h, int nonce)
+{
+    std::vector<unsigned char> res;
+
+    if (header)
+        res.insert(res.end(),
+                   pchMergedMiningHeader,
+                   pchMergedMiningHeader + sizeof (pchMergedMiningHeader));
+    res.insert(res.end(), auxRoot.begin(), auxRoot.end());
+
+    int size = (1 << h);
+    for (int i = 0; i < 4; ++i)
+    {
+        res.insert(res.end(), size & 0xFF);
+        size >>= 8;
+    }
+    for (int i = 0; i < 4; ++i)
+    {
+        res.insert(res.end(), nonce & 0xFF);
+        nonce >>= 8;
+    }
+
+    return res;
+}
+
+/* ************************************************************************** */
+
+BOOST_FIXTURE_TEST_CASE(check_auxpow, BasicTestingSetup)
+{
+    const Consensus::Params& params = Params().GetConsensus();
+    CAuxpowBuilder builder(5, 42);
+    CAuxPow auxpow;
+
+    const uint256 hashAux = ArithToUint256(arith_uint256(12345));
+    const int32_t ourChainId = params.nAuxpowChainId;
+    const unsigned height = 30;
+    const int nonce = 7;
+    int index;
+
+    std::vector<unsigned char> auxRoot, data;
+    CScript scr;
+
+    /* Build a correct auxpow.  The height is the maximally allowed one.  */
+    index = CAuxPow::getExpectedIndex(nonce, ourChainId, height);
+    auxRoot = builder.buildAuxpowChain(hashAux, height, index);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    scr = (CScript() << 2809 << 2013);
+    scr = (scr << OP_2 << data);
+    builder.setCoinbase(scr);
+    BOOST_CHECK(builder.get().check(hashAux, ourChainId, params));
+
+    /* An auxpow without any inputs in the parent coinbase tx should be
+      handled gracefully (and be considered invalid).  */
+    CMutableTransaction mtx(*builder.parentBlock.vtx[0]);
+    mtx.vin.clear();
+    builder.parentBlock.vtx.clear();
+    builder.parentBlock.vtx.push_back(MakeTransactionRef(std::move (mtx)));
+    builder.parentBlock.hashMerkleRoot = BlockMerkleRoot(builder.parentBlock);
+    BOOST_CHECK(!builder.get().check(hashAux, ourChainId, params));
+
+    /* Check that the auxpow is invalid if we change either the aux block's
+      hash or the chain ID.  */
+    uint256 modifiedAux(hashAux);
+    tamperWith(modifiedAux);
+    BOOST_CHECK(!builder.get().check(modifiedAux, ourChainId, params));
+    BOOST_CHECK(!builder.get().check(hashAux, ourChainId + 1, params));
+
+    /* Non-coinbase parent tx should fail.  Note that we can't just copy
+      the coinbase literally, as we have to get a tx with different hash.  */
+    const CTransactionRef oldCoinbase = builder.parentBlock.vtx[0];
+    builder.setCoinbase(scr << 5);
+    builder.parentBlock.vtx.push_back(oldCoinbase);
+    builder.parentBlock.hashMerkleRoot = BlockMerkleRoot(builder.parentBlock);
+    auxpow = builder.get(builder.parentBlock.vtx[0]);
+    BOOST_CHECK(auxpow.check(hashAux, ourChainId, params));
+    auxpow = builder.get(builder.parentBlock.vtx[1]);
+    BOOST_CHECK(!auxpow.check(hashAux, ourChainId, params));
+
+    /* The parent chain can't have the same chain ID.  */
+    CAuxpowBuilder builder2(builder);
+    builder2.parentBlock.SetChainId (100);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+    builder2.parentBlock.SetChainId (ourChainId);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    /* Disallow too long merkle branches.  */
+    builder2 = builder;
+    index = CAuxPow::getExpectedIndex(nonce, ourChainId, height + 1);
+    auxRoot = builder2.buildAuxpowChain(hashAux, height + 1, index);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height + 1, nonce);
+    scr = (CScript() << 2809 << 2013);
+    scr = (scr << OP_2 << data);
+    builder2.setCoinbase(scr);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    /* Verify that we compare correctly to the parent block's merkle root.  */
+    builder2 = builder;
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+    tamperWith(builder2.parentBlock.hashMerkleRoot);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    /* Build a non-header legacy version and check that it is also accepted.  */
+    builder2 = builder;
+    index = CAuxPow::getExpectedIndex(nonce, ourChainId, height);
+    auxRoot = builder2.buildAuxpowChain(hashAux, height, index);
+    data = CAuxpowBuilder::buildCoinbaseData(false, auxRoot, height, nonce);
+    scr = (CScript() << 2809 << 2013);
+    scr = (scr << OP_2 << data);
+    builder2.setCoinbase(scr);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+
+    /* However, various attempts at smuggling two roots in should be detected.  */
+
+    const std::vector<unsigned char> wrongAuxRoot
+      = builder2.buildAuxpowChain(modifiedAux, height, index);
+    std::vector<unsigned char> data2
+      = CAuxpowBuilder::buildCoinbaseData(false, wrongAuxRoot, height, nonce);
+    builder2.setCoinbase(CScript() << data << data2);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+    builder2.setCoinbase(CScript() << data2 << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    data2 = CAuxpowBuilder::buildCoinbaseData(true, wrongAuxRoot, height, nonce);
+    builder2.setCoinbase(CScript() << data << data2);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+    builder2.setCoinbase(CScript() << data2 << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder2.setCoinbase(CScript() << data << data2);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+    builder2.setCoinbase(CScript() << data2 << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    data2 = CAuxpowBuilder::buildCoinbaseData(false, wrongAuxRoot,
+                                              height, nonce);
+    builder2.setCoinbase(CScript() << data << data2);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+    builder2.setCoinbase(CScript() << data2 << data);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+
+    /* Verify that the appended nonce/size values are checked correctly.  */
+
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder2.setCoinbase(CScript() << data);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+
+    data.pop_back();
+    builder2.setCoinbase(CScript() << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height - 1, nonce);
+    builder2.setCoinbase(CScript() << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce + 3);
+    builder2.setCoinbase(CScript() << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    /* Put the aux hash in an invalid merkle tree position.  */
+
+    auxRoot = builder.buildAuxpowChain(hashAux, height, index + 1);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder2.setCoinbase(CScript() << data);
+    BOOST_CHECK(!builder2.get().check(hashAux, ourChainId, params));
+
+    auxRoot = builder.buildAuxpowChain(hashAux, height, index);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder2.setCoinbase(CScript() << data);
+    BOOST_CHECK(builder2.get().check(hashAux, ourChainId, params));
+}
+
+/* ************************************************************************** */
+
+/**
+ * Mine a block (assuming minimal difficulty) that either matches
+ * or doesn't match the difficulty target specified in the block header.
+ * @param block The block to mine (by updating nonce).
+ * @param ok Whether the block should be ok for PoW.
+ * @param nBits Use this as difficulty if specified.
+ */
+static void
+mineBlock (CBlockHeader& block, bool ok, int nBits = -1)
+{
+  if (nBits == -1)
+    nBits = block.nBits;
+
+  arith_uint256 target;
+  target.SetCompact(nBits);
+
+  block.nNonce = 0;
+  while (true)
+    {
+      const bool nowOk = (UintToArith256(block.GetPoWHash()) <= target);
+      if ((ok && nowOk) || (!ok && !nowOk))
+        break;
+
+      ++block.nNonce;
+    }
+
+  if (ok)
+    BOOST_CHECK(CheckProofOfWork(block.GetPoWHash(), nBits, Params().GetConsensus()));
+  else
+    BOOST_CHECK(!CheckProofOfWork(block.GetPoWHash(), nBits, Params().GetConsensus()));
+}
+
+BOOST_FIXTURE_TEST_CASE(auxpow_pow, BasicTestingSetup)
+{
+    /* Use regtest parameters to allow mining with easy difficulty.  */
+    SelectParams (CBaseChainParams::REGTEST);
+    const Consensus::Params& params = Params().GetConsensus();
+
+    const arith_uint256 target = (~arith_uint256(0) >> 1);
+    CBlockHeader block;
+    block.nBits = target.GetCompact ();
+
+    /* Verify the block version checks.  */
+
+    block.nVersion = 1;
+    mineBlock (block, true);
+    BOOST_CHECK(CheckProofOfWork(block, params));
+
+    block.nVersion = 2;
+    mineBlock (block, true);
+    BOOST_CHECK(!CheckProofOfWork(block, params));
+
+    block.SetBaseVersion (2, params.nAuxpowChainId);
+    mineBlock (block, true);
+    BOOST_CHECK(CheckProofOfWork(block, params));
+
+    block.SetChainId (params.nAuxpowChainId + 1);
+    mineBlock (block, true);
+    BOOST_CHECK(!CheckProofOfWork(block, params));
+
+    /* Check the case when the block does not have auxpow (this is true
+      right now).  */
+
+    block.SetChainId (params.nAuxpowChainId);
+    block.SetAuxpowFlag(true);
+    mineBlock (block, true);
+    BOOST_CHECK(!CheckProofOfWork(block, params));
+
+    block.SetAuxpowFlag(false);
+    mineBlock (block, true);
+    BOOST_CHECK(CheckProofOfWork(block, params));
+    mineBlock (block, false);
+    BOOST_CHECK(!CheckProofOfWork(block, params));
+
+    /* ****************************************** */
+    /* Check the case that the block has auxpow.  */
+
+    CAuxpowBuilder builder(5, 42);
+    CAuxPow auxpow;
+    const int32_t ourChainId = params.nAuxpowChainId;
+    const unsigned height = 3;
+    const int nonce = 7;
+    const int index = CAuxPow::getExpectedIndex(nonce, ourChainId, height);
+    std::vector<unsigned char> auxRoot, data;
+
+    /* Valid auxpow, PoW check of parent block.  */
+    block.SetAuxpowFlag(true);
+    auxRoot = builder.buildAuxpowChain(block.GetHash(), height, index);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder.setCoinbase(CScript() << data);
+    mineBlock (builder.parentBlock, false, block.nBits);
+    block.SetAuxpow (builder.getUnique());
+    BOOST_CHECK(!CheckProofOfWork(block, params));
+    mineBlock (builder.parentBlock, true, block.nBits);
+    block.SetAuxpow (builder.getUnique());
+    BOOST_CHECK(CheckProofOfWork(block, params));
+
+    /* Mismatch between auxpow being present and block.nVersion.  Note that
+      block.SetAuxpow sets also the version and that we want to ensure
+      that the block hash itself doesn't change due to version changes.
+      This requires some work arounds.  */
+    block.SetAuxpowFlag(false);
+    const uint256 hashAux = block.GetHash();
+    auxRoot = builder.buildAuxpowChain(hashAux, height, index);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder.setCoinbase(CScript() << data);
+    mineBlock (builder.parentBlock, true, block.nBits);
+    block.SetAuxpow (builder.getUnique());
+    BOOST_CHECK(hashAux != block.GetHash());
+    block.SetAuxpowFlag(false);
+    BOOST_CHECK(hashAux == block.GetHash());
+    BOOST_CHECK(!CheckProofOfWork(block, params));
+
+    /* Modifying the block invalidates the PoW.  */
+    block.SetAuxpowFlag(true);
+    auxRoot = builder.buildAuxpowChain(block.GetHash(), height, index);
+    data = CAuxpowBuilder::buildCoinbaseData(true, auxRoot, height, nonce);
+    builder.setCoinbase(CScript() << data);
+    mineBlock (builder.parentBlock, true, block.nBits);
+    block.SetAuxpow (builder.getUnique());
+    BOOST_CHECK(CheckProofOfWork(block, params));
+    tamperWith(block.hashMerkleRoot);
+    BOOST_CHECK(!CheckProofOfWork(block, params));
+}
+
+/* ************************************************************************** */
+
+/**
+ * Helper class that is friend to AuxpowMiner and makes the tested methods
+ * accessible to the test code.
+ */
+class AuxpowMinerForTest : public AuxpowMiner
+{
+
+public:
+
+  using AuxpowMiner::cs;
+
+  using AuxpowMiner::getCurrentBlock;
+  using AuxpowMiner::lookupSavedBlock;
+
+};
+
+BOOST_FIXTURE_TEST_CASE(auxpow_miner_blockRegeneration, TestChain240Setup)
+{
+    CTxMemPool mempool;
+    AuxpowMinerForTest miner;
+    LOCK (miner.cs);
+
+    /* We use mocktime so that we can control GetTime() as it is used in the
+      logic that determines whether or not to reconstruct a block.  The "base"
+      time is set such that the blocks we have from the fixture are fresh.  */
+    const int64_t baseTime = ::ChainActive().Tip ()->GetMedianTimePast() + 1;
+    SetMockTime(baseTime);
+
+    /* Construct a first block.  */
+    CScript scriptPubKey;
+    uint256 target;
+    const CBlock* pblock1 = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock1 != nullptr);
+    const uint256 hash1 = pblock1->GetHash();
+
+    /* Verify target computation.  */
+    arith_uint256 expected;
+    expected.SetCompact(pblock1->nBits);
+    BOOST_CHECK(target == ArithToUint256(expected));
+
+    /* Calling the method again should return the same, cached block a second
+      time (even if we advance the clock, since there are no new
+      transactions).  */
+    SetMockTime(baseTime + 10);
+    const CBlock* pblock = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock == pblock1 && pblock->GetHash() == hash1);
+
+    /* Mine a block, then we should get a new auxpow block constructed.  Note that
+      it can be the same *pointer* if the memory was reused after clearing it,
+      so we can only verify that the hash is different.  */
+    CreateAndProcessBlock ({}, scriptPubKey);
+    const CBlock* pblock2 = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock2 != nullptr);
+    const uint256 hash2 = pblock2->GetHash();
+    BOOST_CHECK(hash2 != hash1);
+
+    /* Add a new transaction to the mempool.  */
+    TestMemPoolEntryHelper entry;
+    CMutableTransaction mtx;
+    mtx.vout.emplace_back(1234, scriptPubKey);
+    {
+        LOCK(mempool.cs);
+        mempool.addUnchecked (entry.FromTx (mtx));
+    }
+
+    /* We should still get back the cached block, for now.  */
+    SetMockTime(baseTime + 20);
+    pblock = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock == pblock2 && pblock->GetHash() == hash2);
+
+    /* With time advanced too far, we get a new block.  This time, we should also
+      definitely get a different pointer, as there is no clearing.  The old
+      blocks are freed only after a new tip is found.  */
+    SetMockTime(baseTime + 21);
+    const CBlock* pblock3 = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock3 != pblock2 && pblock3->GetHash() != hash2);
+}
+
+BOOST_FIXTURE_TEST_CASE(auxpow_miner_createAndLookupBlock, TestChain240Setup)
+{
+    CTxMemPool mempool;
+    AuxpowMinerForTest miner;
+    LOCK (miner.cs);
+
+    CScript scriptPubKey;
+    uint256 target;
+    const CBlock* pblock = miner.getCurrentBlock(mempool, scriptPubKey, target);
+    BOOST_CHECK(pblock != nullptr);
+
+    BOOST_CHECK(miner.lookupSavedBlock(pblock->GetHash()) == pblock);
+}
+
+/* ************************************************************************** */
+
+BOOST_AUTO_TEST_SUITE_END ()