diff --git a/src/Makefile.am b/src/Makefile.am
index 16f7b56272d..fd6b02d8dc3 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -107,6 +107,7 @@ BITCOIN_CORE_H = \
   addrdb.h \
   addrman.h \
   attributes.h \
+  auxpow.h \
   banman.h \
   base58.h \
   bech32.h \
@@ -185,6 +186,7 @@ BITCOIN_CORE_H = \
   random.h \
   randomenv.h \
   reverse_iterator.h \
+  rpc/auxpow_miner.h \
   rpc/blockchain.h \
   rpc/client.h \
   rpc/mining.h \
@@ -317,6 +319,7 @@ libbitcoin_server_a_SOURCES = \
   policy/settings.cpp \
   pow.cpp \
   rest.cpp \
+  rpc/auxpow_miner.cpp \
   rpc/blockchain.cpp \
   rpc/mining.cpp \
   rpc/misc.cpp \
@@ -463,6 +466,8 @@ libbitcoin_consensus_a_SOURCES = \
   prevector.h \
   primitives/block.cpp \
   primitives/block.h \
+  primitives/pureheader.cpp \
+  primitives/pureheader.h \
   primitives/transaction.cpp \
   primitives/transaction.h \
   pubkey.cpp \
@@ -487,6 +492,7 @@ libbitcoin_consensus_a_SOURCES = \
 libbitcoin_common_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
 libbitcoin_common_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_common_a_SOURCES = \
+  auxpow.cpp \
   base58.cpp \
   bech32.cpp \
   bloom.cpp \
@@ -586,8 +592,10 @@ if TARGET_WINDOWS
 dogecoin_daemon_sources += bitcoind-res.rc
 endif
 
+# FIXME: Remove SERVER once we have cleaned up getauxblock.
 dogecoin_bin_ldadd = \
   $(LIBBITCOIN_WALLET) \
+  $(LIBBITCOIN_SERVER) \
   $(LIBBITCOIN_COMMON) \
   $(LIBBITCOIN_UTIL) \
   $(LIBUNIVALUE) \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 4614179879b..1f5af956181 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -213,6 +213,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/auxpow.cpp b/src/auxpow.cpp
new file mode 100644
index 00000000000..24b13ad5579
--- /dev/null
+++ b/src/auxpow.cpp
@@ -0,0 +1,215 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 Vince Durham
+// Copyright (c) 2009-2014 The Bitcoin developers
+// Copyright (c) 2014-2019 Daniel Kraft
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#include <auxpow.h>
+
+#include <consensus/consensus.h>
+#include <consensus/merkle.h>
+#include <hash.h>
+#include <primitives/block.h>
+#include <script/script.h>
+#include <util/strencodings.h>
+#include <util/system.h>
+
+#include <algorithm>
+
+namespace
+{
+
+/**
+ * Decodes a 32-bit little endian integer from raw bytes.
+ */
+uint32_t
+DecodeLE32 (const unsigned char* bytes)
+{
+  uint32_t res = 0;
+  for (int i = 0; i < 4; ++i)
+    {
+      res <<= 8;
+      res |= bytes[3 - i];
+    }
+  return res;
+}
+
+} // anonymous namespace
+
+bool
+CAuxPow::check (const uint256& hashAuxBlock, int nChainId,
+                const Consensus::Params& params) const
+{
+    if (params.fStrictChainId && parentBlock.GetChainId () == nChainId)
+        return error("Aux POW parent has our chain ID");
+
+    if (vChainMerkleBranch.size() > 30)
+        return error("Aux POW chain merkle branch too long");
+
+    // Check that the chain merkle root is in the coinbase
+    const uint256 nRootHash
+      = CheckMerkleBranch (hashAuxBlock, vChainMerkleBranch, nChainIndex);
+    std::vector<unsigned char> vchRootHash(nRootHash.begin(), nRootHash.end());
+    std::reverse (vchRootHash.begin(), vchRootHash.end()); // correct endian
+
+    // Check that we are in the parent block merkle tree
+    if (CheckMerkleBranch(coinbaseTx->GetHash(), vMerkleBranch, 0)
+          != parentBlock.hashMerkleRoot)
+        return error("Aux POW merkle root incorrect");
+
+    // Check that there is at least one input.
+    if (coinbaseTx->vin.empty())
+        return error("Aux POW coinbase has no inputs");
+
+    const CScript script = coinbaseTx->vin[0].scriptSig;
+
+    // Check that the same work is not submitted twice to our chain.
+    //
+
+    const unsigned char* const mmHeaderBegin = pchMergedMiningHeader;
+    const unsigned char* const mmHeaderEnd
+        = mmHeaderBegin + sizeof (pchMergedMiningHeader);
+    CScript::const_iterator pcHead =
+        std::search(script.begin(), script.end(), mmHeaderBegin, mmHeaderEnd);
+
+    CScript::const_iterator pc =
+        std::search(script.begin(), script.end(), vchRootHash.begin(), vchRootHash.end());
+
+    if (pc == script.end())
+        return error("Aux POW missing chain merkle root in parent coinbase");
+
+    if (pcHead != script.end())
+    {
+        // Enforce only one chain merkle root by checking that a single instance of the merged
+        // mining header exists just before.
+        if (script.end() != std::search(pcHead + 1, script.end(),
+                                        mmHeaderBegin, mmHeaderEnd))
+            return error("Multiple merged mining headers in coinbase");
+        if (pcHead + sizeof(pchMergedMiningHeader) != pc)
+            return error("Merged mining header is not just before chain merkle root");
+    }
+    else
+    {
+        // For backward compatibility.
+        // Enforce only one chain merkle root by checking that it starts early in the coinbase.
+        // 8-12 bytes are enough to encode extraNonce and nBits.
+        if (pc - script.begin() > 20)
+            return error("Aux POW chain merkle root must start in the first 20 bytes of the parent coinbase");
+    }
+
+
+    // Ensure we are at a deterministic point in the merkle leaves by hashing
+    // a nonce and our chain ID and comparing to the index.
+    pc += vchRootHash.size();
+    if (script.end() - pc < 8)
+        return error("Aux POW missing chain merkle tree size and nonce in parent coinbase");
+
+    const uint32_t nSize = DecodeLE32 (&pc[0]);
+    const unsigned merkleHeight = vChainMerkleBranch.size ();
+    if (nSize != (1u << merkleHeight))
+        return error("Aux POW merkle branch size does not match parent coinbase");
+
+    const uint32_t nNonce = DecodeLE32 (&pc[4]);
+    if (nChainIndex != getExpectedIndex (nNonce, nChainId, merkleHeight))
+        return error("Aux POW wrong index");
+
+    return true;
+}
+
+int
+CAuxPow::getExpectedIndex (uint32_t nNonce, int nChainId, unsigned h)
+{
+  // Choose a pseudo-random slot in the chain merkle tree
+  // but have it be fixed for a size/nonce/chain combination.
+  //
+  // This prevents the same work from being used twice for the
+  // same chain while reducing the chance that two chains clash
+  // for the same slot.
+
+  /* This computation can overflow the uint32 used.  This is not an issue,
+     though, since we take the mod against a power-of-two in the end anyway.
+     This also ensures that the computation is, actually, consistent
+     even if done in 64 bits as it was in the past on some systems.
+
+     Note that h is always <= 30 (enforced by the maximum allowed chain
+     merkle branch length), so that 32 bits are enough for the computation.  */
+
+  uint32_t rand = nNonce;
+  rand = rand * 1103515245 + 12345;
+  rand += nChainId;
+  rand = rand * 1103515245 + 12345;
+
+  return rand % (1u << h);
+}
+
+uint256
+CAuxPow::CheckMerkleBranch (uint256 hash,
+                            const std::vector<uint256>& vMerkleBranch,
+                            int nIndex)
+{
+  if (nIndex == -1)
+    return uint256 ();
+  for (std::vector<uint256>::const_iterator it(vMerkleBranch.begin());
+       it != vMerkleBranch.end(); ++it)
+  {
+    if (nIndex & 1)
+      hash = Hash(*it, hash);
+    else
+      hash = Hash(hash, *it);
+    nIndex >>= 1;
+  }
+  return hash;
+}
+
+std::unique_ptr<CAuxPow>
+CAuxPow::createAuxPow (const CPureBlockHeader& header)
+{
+  assert (header.IsAuxpow ());
+
+  /* Build a minimal coinbase script input for merge-mining.  */
+  const uint256 blockHash = header.GetHash();
+  std::vector<unsigned char> inputData(blockHash.begin(), blockHash.end());
+  std::reverse (inputData.begin(), inputData.end());
+  inputData.push_back (1);
+  inputData.insert (inputData.end(), 7, 0);
+
+  /* Fake a parent-block coinbase with just the required input
+     script and no outputs.  */
+  CMutableTransaction coinbase;
+  coinbase.vin.resize (1);
+  coinbase.vin[0].prevout.SetNull ();
+  coinbase.vin[0].scriptSig = (CScript () << inputData);
+  assert (coinbase.vout.empty ());
+  CTransactionRef coinbaseRef = MakeTransactionRef (coinbase);
+
+  /* Build a fake parent block with the coinbase.  */
+  CBlock parent;
+  parent.nVersion = 1;
+  parent.vtx.resize (1);
+  parent.vtx[0] = coinbaseRef;
+  parent.hashMerkleRoot = BlockMerkleRoot (parent);
+
+  /* Construct the auxpow object.  */
+  std::unique_ptr<CAuxPow> auxpow(new CAuxPow (std::move (coinbaseRef)));
+  assert (auxpow->vMerkleBranch.empty ());
+  assert (auxpow->vChainMerkleBranch.empty ());
+  auxpow->nChainIndex = 0;
+  auxpow->parentBlock = parent;
+
+  return auxpow;
+}
+
+CPureBlockHeader&
+CAuxPow::initAuxPow (CBlockHeader& header)
+{
+  /* Set auxpow flag right now, since we take the block hash below when creating
+     the minimal auxpow for header.  */
+  header.SetAuxpowFlag(true);
+
+  std::unique_ptr<CAuxPow> apow = createAuxPow (header);
+  CPureBlockHeader& result = apow->parentBlock;
+  header.SetAuxpow (std::move (apow));
+
+  return result;
+}
diff --git a/src/auxpow.h b/src/auxpow.h
new file mode 100644
index 00000000000..6e04e863002
--- /dev/null
+++ b/src/auxpow.h
@@ -0,0 +1,158 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2014 The Bitcoin developers
+// Copyright (c) 2014-2019 Daniel Kraft
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_AUXPOW_H
+#define BITCOIN_AUXPOW_H
+
+#include <consensus/params.h>
+#include <primitives/pureheader.h>
+#include <primitives/transaction.h>
+#include <serialize.h>
+#include <uint256.h>
+
+#include <cassert>
+#include <memory>
+#include <vector>
+
+class CBlock;
+class CBlockHeader;
+class CBlockIndex;
+class CValidationState;
+class UniValue;
+
+namespace auxpow_tests
+{
+class CAuxPowForTest;
+}
+
+/** Header for merge-mining data in the coinbase.  */
+static const unsigned char pchMergedMiningHeader[] = { 0xfa, 0xbe, 'm', 'm' };
+
+/**
+ * Data for the merge-mining auxpow.  This uses a merkle tx (the parent block's
+ * coinbase tx) and a second merkle branch to link the actual Namecoin block
+ * header to the parent block header, which is mined to satisfy the PoW.
+ */
+class CAuxPow
+{
+
+private:
+
+  /** The parent block's coinbase transaction.  */
+  CTransactionRef coinbaseTx;
+
+  /** The Merkle branch of the coinbase tx to the parent block's root.  */
+  std::vector<uint256> vMerkleBranch;
+
+  /** The merkle branch connecting the aux block to our coinbase.  */
+  std::vector<uint256> vChainMerkleBranch;
+
+  /** Merkle tree index of the aux block header in the coinbase.  */
+  int nChainIndex;
+
+  /** Parent block header (on which the real PoW is done).  */
+  CPureBlockHeader parentBlock;
+
+  /**
+   * Check a merkle branch.  This used to be in CBlock, but was removed
+   * upstream.  Thus include it here now.
+   */
+  static uint256 CheckMerkleBranch (uint256 hash,
+                                    const std::vector<uint256>& vMerkleBranch,
+                                    int nIndex);
+
+  friend UniValue AuxpowToJSON(const CAuxPow& auxpow);
+  friend class auxpow_tests::CAuxPowForTest;
+
+public:
+
+  /* Prevent accidental conversion.  */
+  inline explicit CAuxPow (CTransactionRef&& txIn)
+    : coinbaseTx (std::move (txIn))
+  {}
+
+  CAuxPow () = default;
+
+  SERIALIZE_METHODS (CAuxPow, obj)
+  {
+    /* The coinbase Merkle tx' hashBlock field is never actually verified
+       or used in the code for an auxpow (and never was).  The parent block
+       is known anyway directly, so this is also redundant.  By setting the
+       value to zero (for serialising), we make sure that the format is
+       backwards compatible but the data can be compressed.  */
+    uint256 hashBlock;
+
+    /* The index of the parent coinbase tx is always zero.  */
+    int nIndex = 0;
+
+    /* Data from the coinbase transaction as Merkle tx.  */
+    READWRITE (obj.coinbaseTx, hashBlock, obj.vMerkleBranch, nIndex);
+
+    /* Additional data for the auxpow itself.  */
+    READWRITE (obj.vChainMerkleBranch, obj.nChainIndex, obj.parentBlock);
+  }
+
+  /**
+   * Check the auxpow, given the merge-mined block's hash and our chain ID.
+   * Note that this does not verify the actual PoW on the parent block!  It
+   * just confirms that all the merkle branches are valid.
+   * @param hashAuxBlock Hash of the merge-mined block.
+   * @param nChainId The auxpow chain ID of the block to check.
+   * @param params Consensus parameters.
+   * @return True if the auxpow is valid.
+   */
+  bool check (const uint256& hashAuxBlock, int nChainId,
+              const Consensus::Params& params) const;
+
+  /**
+   * Returns the parent block hash.  This is used to validate the PoW.
+   */
+  inline uint256
+  getParentBlockPoWHash() const
+  {
+    return parentBlock.GetPoWHash();
+  }
+
+  /**
+   * Return parent block.  This is only used for the temporary parentblock
+   * auxpow version check.
+   * @return The parent block.
+   */
+  /* FIXME: Remove after the hardfork.  */
+  inline const CPureBlockHeader&
+  getParentBlock () const
+  {
+    return parentBlock;
+  }
+
+  /**
+   * Calculate the expected index in the merkle tree.  This is also used
+   * for the test-suite.
+   * @param nNonce The coinbase's nonce value.
+   * @param nChainId The chain ID.
+   * @param h The merkle block height.
+   * @return The expected index for the aux hash.
+   */
+  static int getExpectedIndex (uint32_t nNonce, int nChainId, unsigned h);
+
+  /**
+   * Constructs a minimal CAuxPow object for the given block header and
+   * returns it.  The caller should make sure to set the auxpow flag on the
+   * header already, since the block hash to which the auxpow commits depends
+   * on that!
+   */
+  static std::unique_ptr<CAuxPow> createAuxPow (const CPureBlockHeader& header);
+
+  /**
+   * Initialises the auxpow of the given block header.  This builds a minimal
+   * auxpow object like createAuxPow and sets it on the block header.  Returns
+   * a reference to the parent header so it can be mined as a follow-up.
+   */
+  static CPureBlockHeader& initAuxPow (CBlockHeader& header);
+
+};
+
+#endif // BITCOIN_AUXPOW_H
diff --git a/src/chain.cpp b/src/chain.cpp
index c09113a8668..733d58be567 100644
--- a/src/chain.cpp
+++ b/src/chain.cpp
@@ -5,6 +5,34 @@
 
 #include <chain.h>
 
+#include <validation.h>
+
+/* Moved here from the header, because we need auxpow and the logic
+   becomes more involved.  */
+CBlockHeader CBlockIndex::GetBlockHeader(const Consensus::Params& consensusParams) const
+{
+    CBlockHeader block;
+
+    block.nVersion       = nVersion;
+
+    /* The CBlockIndex object's block header is missing the auxpow.
+       So if this is an auxpow block, read it from disk instead.  We only
+       have to read the actual *header*, not the full block.  */
+    if (block.IsAuxpow())
+    {
+        ReadBlockHeaderFromDisk(block, this, consensusParams);
+        return block;
+    }
+
+    if (pprev)
+        block.hashPrevBlock = pprev->GetBlockHash();
+    block.hashMerkleRoot = hashMerkleRoot;
+    block.nTime          = nTime;
+    block.nBits          = nBits;
+    block.nNonce         = nNonce;
+    return block;
+}
+
 /**
  * CChain implementation
  */
diff --git a/src/chain.h b/src/chain.h
index 1f4eaae7ed9..17bc6d3d24a 100644
--- a/src/chain.h
+++ b/src/chain.h
@@ -10,6 +10,7 @@
 #include <consensus/params.h>
 #include <flatfile.h>
 #include <primitives/block.h>
+#include <primitives/pureheader.h>
 #include <tinyformat.h>
 #include <uint256.h>
 
@@ -190,7 +191,7 @@ class CBlockIndex
     {
     }
 
-    explicit CBlockIndex(const CBlockHeader& block)
+    explicit CBlockIndex(const CPureBlockHeader& block)
         : nVersion{block.nVersion},
           hashMerkleRoot{block.hashMerkleRoot},
           nTime{block.nTime},
@@ -217,18 +218,7 @@ class CBlockIndex
         return ret;
     }
 
-    CBlockHeader GetBlockHeader() const
-    {
-        CBlockHeader block;
-        block.nVersion       = nVersion;
-        if (pprev)
-            block.hashPrevBlock = pprev->GetBlockHash();
-        block.hashMerkleRoot = hashMerkleRoot;
-        block.nTime          = nTime;
-        block.nBits          = nBits;
-        block.nNonce         = nNonce;
-        return block;
-    }
+    CBlockHeader GetBlockHeader(const Consensus::Params& consensusParams) const;
 
     uint256 GetBlockHash() const
     {
@@ -243,11 +233,6 @@ class CBlockIndex
      * Does not imply the transactions are still stored on disk. (IsBlockPruned might return true)
      */
     bool HaveTxsDownloaded() const { return nChainTx != 0; }
-    
-    uint256 GetBlockPoWHash() const
-    {
-        return GetBlockHeader().GetPoWHash();
-    }
 
     int64_t GetBlockTime() const
     {
@@ -312,6 +297,13 @@ class CBlockIndex
     //! Efficiently find an ancestor of this block.
     CBlockIndex* GetAncestor(int height);
     const CBlockIndex* GetAncestor(int height) const;
+
+    /* Analyse the block version.  */
+    inline int GetBaseVersion() const
+    {
+        return CPureBlockHeader::GetBaseVersion(nVersion);
+    }
+
 };
 
 arith_uint256 GetBlockProof(const CBlockIndex& block);
@@ -358,7 +350,7 @@ class CDiskBlockIndex : public CBlockIndex
 
     uint256 GetBlockHash() const
     {
-        CBlockHeader block;
+        CPureBlockHeader block;
         block.nVersion        = nVersion;
         block.hashPrevBlock   = hashPrev;
         block.hashMerkleRoot  = hashMerkleRoot;
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index dd3e4a5a7e3..abd64421167 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -99,7 +99,12 @@ class CMainParams : public CChainParams {
         consensus.fSimplifiedRewards = false;
         consensus.fShortEarlyCoinbase = true;
 
-        /**
+        consensus.nAuxpowChainId = 0x0062; // 98 - Josh Wise!
+        consensus.nAuxpowStartHeight = 371337;
+        consensus.fStrictChainId = true;
+        consensus.nLegacyBlocksBefore = 371337;
+
+        /** 
          * The message start string is designed to be unlikely to occur in normal data.
          * The characters are rarely used upper ASCII, not valid as UTF-8, and produce
          * a large 32-bit integer with any alignment.
@@ -114,6 +119,7 @@ class CMainParams : public CChainParams {
         m_assumed_chain_state_size = 6;
 
         genesis = CreateGenesisBlock(1386325540, 99943, 0x1e0ffff0, 1, 88 * COIN);
+
         consensus.hashGenesisBlock = genesis.GetHash();
         assert(consensus.hashGenesisBlock == uint256S("0x1a91e3dace36e2be3bf030a65679fe821aa1d6ef92e7c9902eb318182c355691"));
         assert(genesis.hashMerkleRoot == uint256S("0x5b2a3f53f605d62c53e62932dac6925e3d74afa5a4b459745c36d42d0ed26a69"));
@@ -216,6 +222,11 @@ class CTestNetParams : public CChainParams {
         consensus.fSimplifiedRewards = false;
         consensus.fShortEarlyCoinbase = true;
 
+        consensus.nAuxpowChainId = 0x0062; // 98 - Josh Wise!
+        consensus.nAuxpowStartHeight = 158100;
+        consensus.fStrictChainId = false;
+        consensus.nLegacyBlocksBefore = 158100;
+
         pchMessageStart[0] = 0xfc;
         pchMessageStart[1] = 0xc1;
         pchMessageStart[2] = 0xb7;
@@ -345,6 +356,14 @@ class SigNetParams : public CChainParams {
         consensus.fSimplifiedRewards = true;
         consensus.fShortEarlyCoinbase = true;
 
+        consensus.fStrictChainId = true;
+        consensus.nLegacyBlocksBefore = 0;
+
+        consensus.nAuxpowChainId = 0x0062; // 98 - Josh Wise!
+        consensus.nAuxpowStartHeight = 0;
+        consensus.fStrictChainId = true;
+        consensus.nLegacyBlocksBefore = 0;
+
         // message start is defined as the first 4 bytes of the sha256d of the block script
         CHashWriter h(SER_DISK, 0);
         h << consensus.signet_challenge;
@@ -417,6 +436,13 @@ class CRegTestParams : public CChainParams {
         consensus.fSimplifiedRewards = true;
         consensus.fShortEarlyCoinbase = false;
 
+        consensus.nAuxpowChainId = 0x0062; // 98 - Josh Wise!
+        consensus.nAuxpowStartHeight = 0;
+        consensus.fStrictChainId = true;
+        consensus.nLegacyBlocksBefore = 0;
+
+        consensus.fStrictChainId = true;
+        consensus.nLegacyBlocksBefore = 0;
         pchMessageStart[0] = 0xfa;
         pchMessageStart[1] = 0xbf;
         pchMessageStart[2] = 0xb5;
diff --git a/src/chainparams.h b/src/chainparams.h
index d8b25c72204..7f28a6912ca 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -91,6 +91,9 @@ class CChainParams
     const std::vector<SeedSpec6>& FixedSeeds() const { return vFixedSeeds; }
     const CCheckpointData& Checkpoints() const { return checkpointData; }
     const ChainTxData& TxData() const { return chainTxData; }
+
+    void UpdateVersionBitsParameters(Consensus::DeploymentPos d, int64_t nStartTime, int64_t nTimeout);
+
 protected:
     CChainParams() {}
 
diff --git a/src/consensus/params.h b/src/consensus/params.h
index b7223b2fc07..a7b400d0e4f 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -95,6 +95,24 @@ struct Params {
 
     bool fSimplifiedRewards;
     bool fShortEarlyCoinbase;
+
+    /** Auxpow parameters */
+    int32_t nAuxpowChainId;
+    int nAuxpowStartHeight;
+    bool fStrictChainId;
+    int nLegacyBlocksBefore; // -1 for "always allow"
+
+    /**
+     * Check whether or not to allow legacy blocks at the given height.
+     * @param nHeight Height of the block to check.
+     * @return True if it is allowed to have a legacy version.
+     */
+    bool AllowLegacyBlocks(unsigned nHeight) const
+    {
+        if (nLegacyBlocksBefore < 0)
+            return true;
+        return static_cast<int> (nHeight) < nLegacyBlocksBefore;
+    }
 };
 } // namespace Consensus
 
diff --git a/src/dogecoin.cpp b/src/dogecoin.cpp
index 31cd69bfcf1..70f6c39f110 100644
--- a/src/dogecoin.cpp
+++ b/src/dogecoin.cpp
@@ -7,7 +7,8 @@
 
 #include <arith_uint256.h>
 #include <dogecoin.h>
-#include <logging.h>
+#include <pow.h>
+#include <util/system.h>
 
 int static generateMTRandom(unsigned int s, int range)
 {
@@ -119,3 +120,42 @@ unsigned int CalculateDogecoinNextWorkRequired(const CBlockIndex* pindexLast, in
 
     return bnNew.GetCompact();
 }
+
+bool CheckAuxPowProofOfWork(const CBlockHeader& block, const Consensus::Params& params)
+{
+    /* Except for legacy blocks with full version 1, ensure that
+       the chain ID is correct.  Legacy blocks are not allowed since
+       the merge-mining start, which is checked in AcceptBlockHeader
+       where the height is known.  */
+    if (!block.IsLegacy() && params.fStrictChainId
+        && block.GetChainId() != params.nAuxpowChainId)
+        return error("%s : block does not have our chain ID"
+                     " (got %d, expected %d, full nVersion %d)",
+                     __func__, block.GetChainId(),
+                     params.nAuxpowChainId, block.nVersion);
+
+    /* If there is no auxpow, just check the block hash.  */
+    if (!block.auxpow)
+    {
+        if (block.IsAuxpow())
+            return error("%s : no auxpow on block with auxpow version",
+                         __func__);
+
+        if (!CheckProofOfWork(block.GetPoWHash(), block.nBits, params))
+            return error("%s : non-AUX proof of work failed", __func__);
+
+        return true;
+    }
+
+    /* We have auxpow.  Check it.  */
+
+    if (!block.IsAuxpow())
+        return error("%s : auxpow on block with non-auxpow version", __func__);
+
+    if (!block.auxpow->check(block.GetHash(), block.GetChainId(), params))
+        return error("%s : AUX POW is not valid", __func__);
+    if (!CheckProofOfWork(block.auxpow->getParentBlockPoWHash(), block.nBits, params))
+        return error("%s : AUX proof of work failed", __func__);
+
+    return true;
+}
diff --git a/src/dogecoin.h b/src/dogecoin.h
index 4ff44998ead..ba468b883ef 100644
--- a/src/dogecoin.h
+++ b/src/dogecoin.h
@@ -14,4 +14,12 @@ bool AllowDigishieldMinDifficultyForBlock(const CBlockIndex* pindexLast, const C
 unsigned int CalculateDogecoinNextWorkRequired(const CBlockIndex* pindexLast, int64_t nLastRetargetTime, const Consensus::Params& params);
 CAmount GetDogecoinBlockSubsidy(int nHeight, const Consensus::Params& consensusParams, uint256 prevHash);
 
+/**
+ * Check proof-of-work of a block header, taking auxpow into account.
+ * @param block The block header.
+ * @param params Consensus parameters.
+ * @return True iff the PoW is correct.
+ */
+bool CheckAuxPowProofOfWork(const CBlockHeader& block, const Consensus::Params& params);
+
 #endif // BITCOIN_DOGECOIN_H
diff --git a/src/init.cpp b/src/init.cpp
index 36b82c243d1..761beaeafbe 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -38,6 +38,7 @@
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <protocol.h>
+#include <rpc/auxpow_miner.h>
 #include <rpc/blockchain.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
@@ -598,7 +599,7 @@ void SetupServerArgs(NodeContext& node)
 
 std::string LicenseInfo()
 {
-    const std::string URL_SOURCE_CODE = "<https://github.com/bitcoin/bitcoin>";
+    const std::string URL_SOURCE_CODE = "<https://github.com/dogecoin/dogecoin>";
 
     return CopyrightHolders(strprintf(_("Copyright (C) %i-%i").translated, 2009, COPYRIGHT_YEAR) + " ") + "\n" +
            "\n" +
diff --git a/src/miner.cpp b/src/miner.cpp
index b44cb947d1a..5a61e335d69 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -122,11 +122,13 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     assert(pindexPrev != nullptr);
     nHeight = pindexPrev->nHeight + 1;
 
-    pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
+    const int32_t nChainId = chainparams.GetConsensus().nAuxpowChainId;
+    const int32_t nVersion = 4;
+    pblock->SetBaseVersion(nVersion, nChainId);
     // -regtest only: allow overriding block.nVersion with
     // -blockversion=N to test forking scenarios
     if (chainparams.MineBlocksOnDemand())
-        pblock->nVersion = gArgs.GetArg("-blockversion", pblock->nVersion);
+        pblock->SetBaseVersion(gArgs.GetArg("-blockversion", pblock->GetBaseVersion()), nChainId);
 
     pblock->nTime = GetAdjustedTime();
     const int64_t nMedianTimePast = pindexPrev->GetMedianTimePast();
diff --git a/src/miner.h b/src/miner.h
index bb7a30b1840..ae123812fd2 100644
--- a/src/miner.h
+++ b/src/miner.h
@@ -132,10 +132,12 @@ class BlockAssembler
     // Configuration parameters for the block size
     bool fIncludeWitness;
     unsigned int nBlockMaxWeight;
+    bool fNeedSizeAccounting;
     CFeeRate blockMinFeeRate;
 
     // Information on the current status of the block
     uint64_t nBlockWeight;
+    uint64_t nBlockSize;
     uint64_t nBlockTx;
     uint64_t nBlockSigOpsCost;
     CAmount nFees;
@@ -200,6 +202,7 @@ class BlockAssembler
 /** Modify the extranonce in a block */
 void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
 int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev);
+bool ProcessBlockFound(const CBlock* pblock, const CChainParams& chainParams);
 
 /** Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed */
 void RegenerateCommitments(CBlock& block);
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index d2a0e6d910d..be01bad6722 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -2918,7 +2918,7 @@ void PeerManager::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDat
         LogPrint(BCLog::NET, "getheaders %d to %s from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), pfrom.GetId());
         for (; pindex; pindex = ::ChainActive().Next(pindex))
         {
-            vHeaders.push_back(pindex->GetBlockHeader());
+            vHeaders.push_back(pindex->GetBlockHeader(m_chainparams.GetConsensus()));
             if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop)
                 break;
         }
@@ -4213,14 +4213,14 @@ bool PeerManager::SendMessages(CNode* pto)
                     pBestIndex = pindex;
                     if (fFoundStartingHeader) {
                         // add this to the headers message
-                        vHeaders.push_back(pindex->GetBlockHeader());
+                        vHeaders.push_back(pindex->GetBlockHeader(consensusParams));
                     } else if (PeerHasHeader(&state, pindex)) {
                         continue; // keep looking for the first new block
                     } else if (pindex->pprev == nullptr || PeerHasHeader(&state, pindex->pprev)) {
                         // Peer doesn't have this header but they do have the prior one.
                         // Start sending headers.
                         fFoundStartingHeader = true;
-                        vHeaders.push_back(pindex->GetBlockHeader());
+                        vHeaders.push_back(pindex->GetBlockHeader(consensusParams));
                     } else {
                         // Peer doesn't have this header or the prior one -- nothing will
                         // connect, so bail out.
diff --git a/src/policy/policy.h b/src/policy/policy.h
index 8090dff4c62..c9562dee57e 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -16,8 +16,10 @@
 class CCoinsViewCache;
 class CTxOut;
 
+/** Default for -blockmaxsize, which controls the maximum size of block the mining code will create **/
+static const unsigned int DEFAULT_BLOCK_MAX_SIZE = 750000;
 /** Default for -blockmaxweight, which controls the range of block weights the mining code will create **/
-static const unsigned int DEFAULT_BLOCK_MAX_WEIGHT = MAX_BLOCK_WEIGHT - 4000;
+static const unsigned int DEFAULT_BLOCK_MAX_WEIGHT = 3000000;
 /** Default for -blockmintxfee, which sets the minimum feerate for a transaction in blocks created by mining code **/
 static const unsigned int DEFAULT_BLOCK_MIN_TX_FEE = 1000;
 /** The maximum weight for transactions we're willing to relay/mine */
diff --git a/src/pow.cpp b/src/pow.cpp
index de8ba9be2fd..28a070436df 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -5,6 +5,7 @@
 
 #include <pow.h>
 
+#include <auxpow.h>
 #include <arith_uint256.h>
 #include <chain.h>
 #include <dogecoin.h>
diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index 1aeabb3d5eb..b174ccb26c8 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -10,16 +10,17 @@
 #include <crypto/common.h>
 #include <crypto/scrypt.h>
 
-uint256 CBlockHeader::GetHash() const
+void CBlockHeader::SetAuxpow (std::unique_ptr<CAuxPow> apow)
 {
-    return SerializeHash(*this);
-}
-
-uint256 CBlockHeader::GetPoWHash() const
-{
-    uint256 thash;
-    scrypt_1024_1_1_256((char*)&nVersion, (char*)&thash);
-    return thash;
+    if (apow != nullptr)
+    {
+        auxpow.reset(apow.release());
+        SetAuxpowFlag(true);
+    } else
+    {
+        auxpow.reset();
+        SetAuxpowFlag(false);
+    }
 }
 
 std::string CBlock::ToString() const
diff --git a/src/primitives/block.h b/src/primitives/block.h
index 20642d744d7..dae194fc417 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -6,10 +6,14 @@
 #ifndef BITCOIN_PRIMITIVES_BLOCK_H
 #define BITCOIN_PRIMITIVES_BLOCK_H
 
+#include <auxpow.h>
 #include <primitives/transaction.h>
+#include <primitives/pureheader.h>
 #include <serialize.h>
 #include <uint256.h>
 
+#include <memory>
+
 /** Nodes collect new transactions into a block, hash them into a hash tree,
  * and scan through nonce values to make the block's hash satisfy proof-of-work
  * requirements.  When they solve the proof-of-work, they broadcast the block
@@ -17,47 +21,44 @@
  * in the block is a special one that creates a new coin owned by the creator
  * of the block.
  */
-class CBlockHeader
+class CBlockHeader : public CPureBlockHeader
 {
 public:
-    // header
-    int32_t nVersion;
-    uint256 hashPrevBlock;
-    uint256 hashMerkleRoot;
-    uint32_t nTime;
-    uint32_t nBits;
-    uint32_t nNonce;
+
+    // auxpow (if this is a merge-minded block)
+    std::shared_ptr<CAuxPow> auxpow;
 
     CBlockHeader()
     {
         SetNull();
     }
 
-    SERIALIZE_METHODS(CBlockHeader, obj) { READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce); }
-
-    void SetNull()
+    SERIALIZE_METHODS(CBlockHeader, obj)
     {
-        nVersion = 0;
-        hashPrevBlock.SetNull();
-        hashMerkleRoot.SetNull();
-        nTime = 0;
-        nBits = 0;
-        nNonce = 0;
+        READWRITEAS(CPureBlockHeader, obj);
+
+        if (obj.IsAuxpow())
+        {
+            SER_READ(obj, obj.auxpow = std::make_shared<CAuxPow>());
+            assert(obj.auxpow != nullptr);
+            READWRITE(*obj.auxpow);
+        } else
+        {
+            SER_READ(obj, obj.auxpow.reset());
+        }
     }
 
-    bool IsNull() const
+    void SetNull()
     {
-        return (nBits == 0);
+        CPureBlockHeader::SetNull();
+        auxpow.reset();
     }
 
-    uint256 GetHash() const;
-
-    uint256 GetPoWHash() const;
-
-    int64_t GetBlockTime() const
-    {
-        return (int64_t)nTime;
-    }
+    /**
+     * Set the block's auxpow (or unset it).  This takes care of updating
+     * the version accordingly.
+     */
+    void SetAuxpow (std::unique_ptr<CAuxPow> apow);
 };
 
 
@@ -103,6 +104,7 @@ class CBlock : public CBlockHeader
         block.nTime          = nTime;
         block.nBits          = nBits;
         block.nNonce         = nNonce;
+        block.auxpow         = auxpow;
         return block;
     }
 
diff --git a/src/primitives/pureheader.cpp b/src/primitives/pureheader.cpp
new file mode 100644
index 00000000000..311ff9fb1b1
--- /dev/null
+++ b/src/primitives/pureheader.cpp
@@ -0,0 +1,29 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2014 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "primitives/pureheader.h"
+
+#include "crypto/scrypt.h"
+#include "hash.h"
+#include "util/strencodings.h"
+
+void CPureBlockHeader::SetBaseVersion(int32_t nBaseVersion, int32_t nChainId)
+{
+    assert(nBaseVersion >= 1 && nBaseVersion < VERSION_AUXPOW);
+    assert(!IsAuxpow());
+    nVersion = nBaseVersion | (nChainId * VERSION_CHAIN_START);
+}
+
+uint256 CPureBlockHeader::GetHash() const
+{
+    return SerializeHash(*this);
+}
+
+uint256 CPureBlockHeader::GetPoWHash() const
+{
+    uint256 thash;
+    scrypt_1024_1_1_256((char*)&nVersion, (char*)&thash);
+    return thash;
+}
diff --git a/src/primitives/pureheader.h b/src/primitives/pureheader.h
new file mode 100644
index 00000000000..a01d93bd1e1
--- /dev/null
+++ b/src/primitives/pureheader.h
@@ -0,0 +1,146 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2013 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_PRIMITIVES_PUREHEADER_H
+#define BITCOIN_PRIMITIVES_PUREHEADER_H
+
+#include <serialize.h>
+#include <uint256.h>
+
+/**
+ * A block header without auxpow information.  This "intermediate step"
+ * in constructing the full header is useful, because it breaks the cyclic
+ * dependency between auxpow (referencing a parent block header) and
+ * the block header (referencing an auxpow).  The parent block header
+ * does not have auxpow itself, so it is a pure header.
+ */
+class CPureBlockHeader
+{
+private:
+
+    /* Modifiers to the version.  */
+    static const int32_t VERSION_AUXPOW = (1 << 8);
+
+    /** Bits above are reserved for the auxpow chain ID.  */
+    static const int32_t VERSION_CHAIN_START = (1 << 16);
+
+public:
+    // header
+    int32_t nVersion;
+    uint256 hashPrevBlock;
+    uint256 hashMerkleRoot;
+    uint32_t nTime;
+    uint32_t nBits;
+    uint32_t nNonce;
+
+    CPureBlockHeader()
+    {
+        SetNull();
+    }
+
+    SERIALIZE_METHODS(CPureBlockHeader, obj) { READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce); }
+
+    void SetNull()
+    {
+        nVersion = 0;
+        hashPrevBlock.SetNull();
+        hashMerkleRoot.SetNull();
+        nTime = 0;
+        nBits = 0;
+        nNonce = 0;
+    }
+
+    bool IsNull() const
+    {
+        return (nBits == 0);
+    }
+
+    uint256 GetHash() const;
+    uint256 GetPoWHash() const;
+
+    int64_t GetBlockTime() const
+    {
+        return (int64_t)nTime;
+    }
+
+    /* Below are methods to interpret the version with respect to
+       auxpow data and chain ID.  This used to be in the CBlockVersion
+       class, but was moved here when we switched back to nVersion being
+       a pure int member as preparation to undoing the "abuse" and
+       allowing BIP9 to work.  */
+
+    /**
+     * Extract the base version (without modifiers and chain ID).
+     * @return The base version./
+     */
+    inline int32_t GetBaseVersion() const
+    {
+        return GetBaseVersion(nVersion);
+    }
+    static inline int32_t GetBaseVersion(int32_t ver)
+    {
+        return ver % VERSION_AUXPOW;
+    }
+
+    /**
+     * Set the base version (apart from chain ID and auxpow flag) to
+     * the one given.  This should only be called when auxpow is not yet
+     * set, to initialise a block!
+     * @param nBaseVersion The base version.
+     * @param nChainId The auxpow chain ID.
+     */
+    void SetBaseVersion(int32_t nBaseVersion, int32_t nChainId);
+
+    /**
+     * Extract the chain ID.
+     * @return The chain ID encoded in the version.
+     */
+    inline int32_t GetChainId() const
+    {
+        return nVersion >> 16;
+    }
+
+    /**
+     * Set the chain ID.  This is used for the test suite.
+     * @param ch The chain ID to set.
+     */
+    inline void SetChainId(int32_t chainId)
+    {
+        nVersion %= VERSION_CHAIN_START;
+        nVersion |= chainId * VERSION_CHAIN_START;
+    }
+
+    /**
+     * Check if the auxpow flag is set in the version.
+     * @return True iff this block version is marked as auxpow.
+     */
+    inline bool IsAuxpow() const
+    {
+        return nVersion & VERSION_AUXPOW;
+    }
+
+    /**
+     * Set the auxpow flag.  This is used for testing.
+     * @param auxpow Whether to mark auxpow as true.
+     */
+    inline void SetAuxpowFlag(bool auxpow)
+    {
+        if (auxpow)
+            nVersion |= VERSION_AUXPOW;
+        else
+            nVersion &= ~VERSION_AUXPOW;
+    }
+
+    /**
+     * Check whether this is a "legacy" block without chain ID.
+     * @return True iff it is.
+     */
+    inline bool IsLegacy() const
+    {
+        return nVersion == 1;
+    }
+};
+
+#endif // BITCOIN_PRIMITIVES_PUREHEADER_H
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index 9fcfb081ce4..1963639ce51 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -133,7 +133,7 @@ void BumpFee(TransactionView& view, const uint256& txid, bool expectDisabled, st
 //     QT_QPA_PLATFORM=cocoa   src/qt/test/test_bitcoin-qt  # macOS
 void TestGUI(interfaces::Node& node)
 {
-    // Set up wallet and chain with 105 blocks (5 mature blocks for spending).
+    // Set up wallet and chain with 245 blocks (5 mature blocks for spending).
     TestChain240Setup test;
     for (int i = 0; i < 5; ++i) {
         test.CreateAndProcessBlock({}, GetScriptForRawPubKey(test.coinbaseKey.GetPubKey()));
diff --git a/src/rest.cpp b/src/rest.cpp
index 949cc9d84ad..cc65e6a7a1b 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -192,7 +192,7 @@ static bool rest_headers(const util::Ref& context,
     case RetFormat::BINARY: {
         CDataStream ssHeader(SER_NETWORK, PROTOCOL_VERSION);
         for (const CBlockIndex *pindex : headers) {
-            ssHeader << pindex->GetBlockHeader();
+            ssHeader << pindex->GetBlockHeader(Params().GetConsensus());
         }
 
         std::string binaryHeader = ssHeader.str();
@@ -204,7 +204,7 @@ static bool rest_headers(const util::Ref& context,
     case RetFormat::HEX: {
         CDataStream ssHeader(SER_NETWORK, PROTOCOL_VERSION);
         for (const CBlockIndex *pindex : headers) {
-            ssHeader << pindex->GetBlockHeader();
+            ssHeader << pindex->GetBlockHeader(Params().GetConsensus());
         }
 
         std::string strHex = HexStr(ssHeader) + "\n";
diff --git a/src/rpc/auxpow_miner.cpp b/src/rpc/auxpow_miner.cpp
new file mode 100644
index 00000000000..d255960895f
--- /dev/null
+++ b/src/rpc/auxpow_miner.cpp
@@ -0,0 +1,197 @@
+// 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/strencodings.h>
+#include <util/time.h>
+#include <validation.h>
+
+#include <cassert>
+
+namespace
+{
+
+void auxMiningCheck(const JSONRPCRequest& request)
+{
+  NodeContext& node = EnsureNodeContext(request.context);
+  if (!node.connman)
+    throw JSONRPCError(RPC_CLIENT_P2P_DISABLED,
+                        "Error: Peer-to-peer functionality missing or"
+                        " disabled");
+
+  if (node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0
+        && !Params().MineBlocksOnDemand())
+    throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED,
+                        "Dogecoin is not connected!");
+
+  if (::ChainstateActive().IsInitialBlockDownload()
+        && !Params().MineBlocksOnDemand())
+    throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD,
+                        "Dogecoin is downloading blocks...");
+
+  /* This should never fail, since the chain is already
+     past the point of merge-mining start.  Check nevertheless.  */
+  {
+    LOCK(cs_main);
+    const auto auxpowStart = Params().GetConsensus().nAuxpowStartHeight;
+    if (::ChainActive().Height() + 1 < auxpowStart)
+      throw std::runtime_error("mining auxblock method is not yet available");
+  }
+}
+
+}  // anonymous namespace
+
+const CBlock*
+AuxpowMiner::getCurrentBlock(const CTxMemPool& mempool,
+                              const CScript& scriptPubKey, uint256& target)
+{
+  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.  */
+  assert(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 std::string& hashHex) const
+{
+  AssertLockHeld(cs);
+
+  uint256 hash;
+  hash.SetHex(hashHex);
+
+  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 JSONRPCRequest& request,
+                             const CScript& scriptPubKey)
+{
+  auxMiningCheck(request);
+  LOCK(cs);
+
+  const auto& mempool = EnsureMemPool(request.context);
+
+  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(const JSONRPCRequest& request,
+                             const std::string& hashHex,
+                             const std::string& auxpowHex) const
+{
+  auxMiningCheck(request);
+  auto& chainman = EnsureChainman(request.context);
+
+  std::shared_ptr<CBlock> shared_block;
+  {
+    LOCK(cs);
+    const CBlock* pblock = lookupSavedBlock(hashHex);
+    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));
+  assert(shared_block->GetHash().GetHex() == hashHex);
+
+  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..20f9710416c
--- /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 std::string& hashHex) 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 JSONRPCRequest& request,
+                           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 (const JSONRPCRequest& request,
+                       const std::string& hashHex,
+                       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/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index b72181cc1a9..8b23125c6e6 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -22,6 +22,7 @@
 #include <policy/policy.h>
 #include <policy/rbf.h>
 #include <primitives/transaction.h>
+#include <rpc/rawtransaction.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
@@ -116,6 +117,43 @@ static int ComputeNextBlockAndDepth(const CBlockIndex* tip, const CBlockIndex* b
     return blockindex == tip ? 1 : -1;
 }
 
+
+UniValue AuxpowToJSON(const CAuxPow& auxpow)
+{
+    UniValue result(UniValue::VOBJ);
+
+    {
+        UniValue tx(UniValue::VOBJ);
+        tx.pushKV("hex", EncodeHexTx(*auxpow.coinbaseTx));
+        TxToJSON(*auxpow.coinbaseTx, auxpow.parentBlock.GetHash(), tx);
+        result.pushKV("tx", tx);
+    }
+
+    // FIXME: We have a compatibility issue where the "index" field is no longer available in 1.21
+    result.pushKV("chainindex", auxpow.nChainIndex);
+
+    {
+        UniValue branch(UniValue::VARR);
+        for (const auto& node : auxpow.vMerkleBranch)
+            branch.push_back(node.GetHex());
+        result.pushKV("merklebranch", branch);
+    }
+
+    {
+        UniValue branch(UniValue::VARR);
+        for (const auto& node : auxpow.vChainMerkleBranch)
+            branch.push_back(node.GetHex());
+        result.pushKV("chainmerklebranch", branch);
+    }
+
+    CDataStream ssParent(SER_NETWORK, PROTOCOL_VERSION);
+    ssParent << auxpow.parentBlock;
+    const std::string strHex = HexStr(ssParent);
+    result.pushKV("parentblock", strHex);
+
+    return result;
+}
+
 UniValue blockheaderToJSON(const CBlockIndex* tip, const CBlockIndex* blockindex)
 {
     // Serialize passed information without accessing chain state of the active chain!
@@ -183,6 +221,9 @@ UniValue blockToJSON(const CBlock& block, const CBlockIndex* tip, const CBlockIn
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
     result.pushKV("nTx", (uint64_t)blockindex->nTx);
 
+    if (block.auxpow)
+        result.pushKV("auxpow", AuxpowToJSON(*block.auxpow));
+
     if (blockindex->pprev)
         result.pushKV("previousblockhash", blockindex->pprev->GetBlockHash().GetHex());
     if (pnext)
@@ -840,7 +881,7 @@ static RPCHelpMan getblockheader()
     if (!fVerbose)
     {
         CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
-        ssBlock << pblockindex->GetBlockHeader();
+        ssBlock << pblockindex->GetBlockHeader(Params().GetConsensus());
         std::string strHex = HexStr(ssBlock);
         return strHex;
     }
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 74e1c469b1b..6cae12e7579 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -16,6 +16,7 @@
 #include <node/context.h>
 #include <policy/fees.h>
 #include <pow.h>
+#include <rpc/auxpow_miner.h>
 #include <rpc/blockchain.h>
 #include <rpc/mining.h>
 #include <rpc/server.h>
@@ -38,6 +39,8 @@
 
 #include <memory>
 #include <stdint.h>
+#include <string>
+#include <utility>
 
 /**
  * Return average network hashes per second based on the last 'lookup' blocks,
@@ -116,19 +119,20 @@ static bool GenerateBlock(ChainstateManager& chainman, CBlock& block, uint64_t&
 
     CChainParams chainparams(Params());
 
-    while (max_tries > 0 && block.nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(block.GetPoWHash(), block.nBits, chainparams.GetConsensus()) && !ShutdownRequested()) {
-        ++block.nNonce;
+    auto& miningHeader = CAuxPow::initAuxPow(block);
+    while (max_tries > 0 && miningHeader.nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(miningHeader.GetPoWHash(), block.nBits, Params().GetConsensus()) && !ShutdownRequested()) {
+        ++miningHeader.nNonce;
         --max_tries;
     }
     if (max_tries == 0 || ShutdownRequested()) {
         return false;
     }
-    if (block.nNonce == std::numeric_limits<uint32_t>::max()) {
+    if (miningHeader.nNonce == std::numeric_limits<uint32_t>::max()) {
         return true;
     }
 
     std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
-    if (!chainman.ProcessNewBlock(chainparams, shared_pblock, true, nullptr)) {
+    if (!chainman.ProcessNewBlock(Params(), shared_pblock, true, nullptr)) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
     }
 
@@ -1209,6 +1213,77 @@ static RPCHelpMan estimaterawfee()
     };
 }
 
+/* ************************************************************************** */
+/* Merge mining.  */
+
+static RPCHelpMan createauxblock()
+{
+    return RPCHelpMan{"createauxblock",
+        "\nCreates a new block and returns information required to"
+        " merge-mine it.\n",
+        {
+            {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "Payout address for the coinbase transaction"},
+        },
+        RPCResult{
+            RPCResult::Type::OBJ, "", "",
+            {
+                {RPCResult::Type::STR_HEX, "hash", "hash of the created block"},
+                {RPCResult::Type::NUM, "chainid", "chain ID for this block"},
+                {RPCResult::Type::STR_HEX, "previousblockhash", "hash of the previous block"},
+                {RPCResult::Type::NUM, "coinbasevalue", "value of the block's coinbase"},
+                {RPCResult::Type::STR_HEX, "bits", "compressed target of the block"},
+                {RPCResult::Type::NUM, "height", "height of the block"},
+                {RPCResult::Type::STR_HEX, "_target", "target in reversed byte order, deprecated"},
+            },
+        },
+        RPCExamples{
+          HelpExampleCli("createauxblock", "\"address\"")
+          + HelpExampleRpc("createauxblock", "\"address\"")
+        },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+
+    // Check coinbase payout address
+    const CTxDestination coinbaseScript
+      = DecodeDestination(request.params[0].get_str());
+    if (!IsValidDestination(coinbaseScript)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
+                           "Error: Invalid coinbase payout address");
+    }
+    const CScript scriptPubKey = GetScriptForDestination(coinbaseScript);
+
+    return AuxpowMiner::get ().createAuxBlock(request, scriptPubKey);
+},
+    };
+}
+
+static RPCHelpMan submitauxblock()
+{
+    return RPCHelpMan{"submitauxblock",
+        "\nSubmits a solved auxpow for a block that was previously"
+        " created by 'createauxblock'.\n",
+        {
+            {"hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Hash of the block to submit"},
+            {"auxpow", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Serialised auxpow found"},
+        },
+        RPCResult{
+            RPCResult::Type::BOOL, "", "whether the submitted block was correct"
+        },
+        RPCExamples{
+            HelpExampleCli("submitauxblock", "\"hash\" \"serialised auxpow\"")
+            + HelpExampleRpc("submitauxblock", "\"hash\" \"serialised auxpow\"")
+        },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    return AuxpowMiner::get ().submitAuxBlock(request,
+                                              request.params[0].get_str(),
+                                              request.params[1].get_str());
+},
+    };
+}
+
+/* ************************************************************************** */
+
 void RegisterMiningRPCCommands(CRPCTable &t)
 {
 // clang-format off
@@ -1222,6 +1297,8 @@ static const CRPCCommand commands[] =
     { "mining",             "submitblock",            &submitblock,            {"hexdata","dummy"} },
     { "mining",             "submitheader",           &submitheader,           {"hexdata"} },
 
+    { "mining",             "createauxblock",         &createauxblock,         {"address"} },
+    { "mining",             "submitauxblock",         &submitauxblock,         {"hash", "auxpow"} },
 
     { "generating",         "generatetoaddress",      &generatetoaddress,      {"nblocks","address","maxtries"} },
     { "generating",         "generatetodescriptor",   &generatetodescriptor,   {"num_blocks","descriptor","maxtries"} },
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 70f9279b233..46222c47f6d 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -20,6 +20,7 @@
 #include <psbt.h>
 #include <random.h>
 #include <rpc/blockchain.h>
+#include <rpc/rawtransaction.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
@@ -41,7 +42,7 @@
 
 #include <univalue.h>
 
-static void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry)
+void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry)
 {
     // Call into TxToUniv() in bitcoin-common to decode the transaction hex.
     //
diff --git a/src/rpc/rawtransaction.h b/src/rpc/rawtransaction.h
new file mode 100644
index 00000000000..941463e3172
--- /dev/null
+++ b/src/rpc/rawtransaction.h
@@ -0,0 +1,15 @@
+// Copyright (c) 2010 Satoshi Nakamoto
+// Copyright (c) 2009-2020 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_RPC_RAWTRANSACTION_H
+#define BITCOIN_RPC_RAWTRANSACTION_H
+
+class CTransaction;
+class UniValue;
+class uint256;
+
+void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry);
+
+#endif // BITCOIN_RPC_RAWTRANSACTION_H
diff --git a/src/test/auxpow_tests.cpp b/src/test/auxpow_tests.cpp
new file mode 100644
index 00000000000..bc5228c6053
--- /dev/null
+++ b/src/test/auxpow_tests.cpp
@@ -0,0 +1,609 @@
+// 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 <dogecoin.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(CheckAuxPowProofOfWork(block, params));
+
+  block.nVersion = 2;
+  mineBlock(block, true);
+  BOOST_CHECK(!CheckAuxPowProofOfWork(block, params));
+
+  block.SetBaseVersion (2, params.nAuxpowChainId);
+  mineBlock(block, true);
+  BOOST_CHECK(CheckAuxPowProofOfWork(block, params));
+
+  block.SetChainId (params.nAuxpowChainId + 1);
+  mineBlock(block, true);
+  BOOST_CHECK(!CheckAuxPowProofOfWork(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(!CheckAuxPowProofOfWork(block, params));
+
+  block.SetAuxpowFlag(false);
+  mineBlock(block, true);
+  BOOST_CHECK(CheckAuxPowProofOfWork(block, params));
+  mineBlock(block, false);
+  BOOST_CHECK(!CheckAuxPowProofOfWork(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(!CheckAuxPowProofOfWork(block, params));
+  mineBlock(builder.parentBlock, true, block.nBits);
+  block.SetAuxpow(builder.getUnique());
+  BOOST_CHECK(CheckAuxPowProofOfWork(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(!CheckAuxPowProofOfWork(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(CheckAuxPowProofOfWork(block, params));
+  tamperWith (block.hashMerkleRoot);
+  BOOST_CHECK(!CheckAuxPowProofOfWork(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);
+    BOOST_CHECK(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);
+    BOOST_CHECK(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().GetHex ()) == pblock);
+    BOOST_CHECK_THROW (miner.lookupSavedBlock("foobar"), UniValue);
+}
+
+/* ************************************************************************** */
+
+BOOST_AUTO_TEST_SUITE_END ()
diff --git a/src/test/merkle_tests.cpp b/src/test/merkle_tests.cpp
index 9bc7cc5dab5..b578da7fd41 100644
--- a/src/test/merkle_tests.cpp
+++ b/src/test/merkle_tests.cpp
@@ -116,7 +116,7 @@ static std::vector<uint256> ComputeMerkleBranch(const std::vector<uint256>& leav
     return ret;
 }
 
-static std::vector<uint256> BlockMerkleBranch(const CBlock& block, uint32_t position)
+std::vector<uint256> BlockMerkleBranch(const CBlock& block, uint32_t position)
 {
     std::vector<uint256> leaves;
     leaves.resize(block.vtx.size());
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 405a51c9211..db85cc68e38 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -254,3 +254,12 @@ CBlock getBlock13b8a()
     stream >> block;
     return block;
 }
+
+//! equality test
+bool operator==(const Coin &a, const Coin &b) {
+    // Empty Coin objects are always equal.
+    if (a.IsSpent() && b.IsSpent()) return true;
+    return a.fCoinBase == b.fCoinBase &&
+           a.nHeight == b.nHeight &&
+           a.out == b.out;
+}
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index 960a52b344d..6521cce1d1d 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -172,4 +172,9 @@ class HasReason
     const std::string m_reason;
 };
 
+/* This is defined in merkle_tests.cpp, but also used by auxpow_tests.cpp.  */
+namespace merkle_tests {
+std::vector<uint256> BlockMerkleBranch(const CBlock& block, uint32_t position);
+}
+
 #endif
diff --git a/src/validation.cpp b/src/validation.cpp
index 481eb03590e..7d9b5cc5e0f 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -6,6 +6,7 @@
 #include <validation.h>
 
 #include <arith_uint256.h>
+#include <auxpow.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <checkqueue.h>
@@ -1143,7 +1144,12 @@ static bool WriteBlockToDisk(const CBlock& block, FlatFilePos& pos, const CMessa
     return true;
 }
 
-bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::Params& consensusParams)
+
+/* Generic implementation of block reading that can handle
+   both a block and its header.  */
+
+template<typename T>
+static bool ReadBlockOrHeader(T& block, const FlatFilePos& pos, const Consensus::Params& consensusParams)
 {
     block.SetNull();
 
@@ -1161,7 +1167,7 @@ bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::P
     }
 
     // Check the header
-    if (!CheckProofOfWork(block.GetPoWHash(), block.nBits, consensusParams))
+    if (!CheckAuxPowProofOfWork(block, consensusParams))
         return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString());
 
     // Signet only: check block solution
@@ -1172,7 +1178,8 @@ bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::P
     return true;
 }
 
-bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams)
+template<typename T>
+static bool ReadBlockOrHeader(T& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams)
 {
     FlatFilePos blockPos;
     {
@@ -1180,7 +1187,7 @@ bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus
         blockPos = pindex->GetBlockPos();
     }
 
-    if (!ReadBlockFromDisk(block, blockPos, consensusParams))
+    if (!ReadBlockOrHeader(block, blockPos, consensusParams))
         return false;
     if (block.GetHash() != pindex->GetBlockHash())
         return error("ReadBlockFromDisk(CBlock&, CBlockIndex*): GetHash() doesn't match index for %s at %s",
@@ -1188,6 +1195,21 @@ bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus
     return true;
 }
 
+bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::Params& consensusParams)
+{
+    return ReadBlockOrHeader(block, pos, consensusParams);
+}
+
+bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams)
+{
+    return ReadBlockOrHeader(block, pindex, consensusParams);
+}
+
+bool ReadBlockHeaderFromDisk(CBlockHeader& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams)
+{
+    return ReadBlockOrHeader(block, pindex, consensusParams);
+}
+
 bool ReadRawBlockFromDisk(std::vector<uint8_t>& block, const FlatFilePos& pos, const CMessageHeader::MessageStartChars& message_start)
 {
     FlatFilePos hpos = pos;
@@ -3342,7 +3364,7 @@ static bool FindUndoPos(BlockValidationState &state, int nFile, FlatFilePos &pos
 static bool CheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true)
 {
     // Check proof of work matches claimed amount
-    if (fCheckPOW && !CheckProofOfWork(block.GetPoWHash(), block.nBits, consensusParams))
+    if (fCheckPOW && !CheckAuxPowProofOfWork(block, consensusParams))
         return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "high-hash", "proof of work failed");
 
     return true;
@@ -3499,6 +3521,22 @@ static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidatio
     assert(pindexPrev != nullptr);
     const int nHeight = pindexPrev->nHeight + 1;
 
+    // Disallow legacy blocks after merge-mining start.
+    if (!Params().GetConsensus().AllowLegacyBlocks(nHeight)
+        && block.IsLegacy())
+        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER,
+                             "late-legacy-block",
+                             "legacy block after auxpow start");
+
+    // Dogecoin: Disallow AuxPow blocks before it is activated.
+    // TODO: Remove this test, as checkpoints will enforce this for us now
+    // NOTE: Previously this had its own fAllowAuxPoW flag, but that's always the opposite of fAllowLegacyBlocks
+    if (Params().GetConsensus().AllowLegacyBlocks(nHeight)
+        && block.IsAuxpow())
+        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER,
+                             "early-auxpow-block",
+                             "auxpow block before auxpow start");
+
     // Check proof of work
     const Consensus::Params& consensusParams = params.GetConsensus();
     if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
diff --git a/src/validation.h b/src/validation.h
index ffb038ad75f..dc722cfe6ce 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -289,6 +289,7 @@ bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::P
 bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams);
 bool ReadRawBlockFromDisk(std::vector<uint8_t>& block, const FlatFilePos& pos, const CMessageHeader::MessageStartChars& message_start);
 bool ReadRawBlockFromDisk(std::vector<uint8_t>& block, const CBlockIndex* pindex, const CMessageHeader::MessageStartChars& message_start);
+bool ReadBlockHeaderFromDisk(CBlockHeader& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams);
 
 bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex* pindex);
 
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index e8c3ae888d0..2c41b4fc7d6 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -14,6 +14,7 @@
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <policy/rbf.h>
+#include <rpc/auxpow_miner.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
@@ -4521,6 +4522,190 @@ static RPCHelpMan upgradewallet()
     };
 }
 
+namespace
+{
+
+/**
+ * Helper class that keeps track of reserved keys that are used for mining
+ * coinbases.  We also keep track of the block hash(es) that have been
+ * constructed based on the key, so that we can mark it as keep and get a
+ * fresh one when one of those blocks is submitted.
+ */
+class ReservedKeysForMining
+{
+
+private:
+
+  /**
+   * The per-wallet data that we store.
+   */
+  struct PerWallet
+  {
+
+    /**
+     * The current coinbase script.  This has been taken out of the wallet
+     * already (and marked as "keep"), but is reused until a block actually
+     * using it is submitted successfully.
+     */
+    CScript coinbaseScript;
+
+    /** All block hashes (in hex) that are based on the current script.  */
+    std::set<std::string> blockHashes;
+
+    explicit PerWallet (const CScript& scr)
+      : coinbaseScript(scr)
+    {}
+
+    PerWallet (PerWallet&&) = default;
+
+  };
+
+  /**
+   * Data for each wallet that we have.  This is keyed by CWallet::GetName,
+   * which is not perfect; but it will likely work in most cases, and even
+   * when two different wallets are loaded with the same name (after each
+   * other), the worst that can happen is that we mine to an address from
+   * the other wallet.
+   */
+  std::map<std::string, PerWallet> data;
+
+  /** Lock for this instance.  */
+  mutable RecursiveMutex cs;
+
+public:
+
+  ReservedKeysForMining () = default;
+
+  /**
+   * Retrieves the key to use for mining at the moment.
+   */
+  CScript
+  GetCoinbaseScript (CWallet* pwallet)
+  {
+    LOCK2 (cs, pwallet->cs_wallet);
+
+    const auto mit = data.find (pwallet->GetName ());
+    if (mit != data.end ())
+      return mit->second.coinbaseScript;
+
+    ReserveDestination rdest(pwallet, pwallet->m_default_address_type);
+    CTxDestination dest;
+    if (!rdest.GetReservedDestination (dest, false))
+      throw JSONRPCError (RPC_WALLET_KEYPOOL_RAN_OUT,
+                          "Error: Keypool ran out,"
+                          " please call keypoolrefill first");
+    rdest.KeepDestination ();
+
+    const CScript res = GetScriptForDestination (dest);
+    data.emplace (pwallet->GetName (), PerWallet (res));
+    return res;
+  }
+
+  /**
+   * Adds the block hash (given as hex string) of a newly constructed block
+   * to the set of blocks for the current key.
+   */
+  void
+  AddBlockHash (const CWallet* pwallet, const std::string& hashHex)
+  {
+    LOCK (cs);
+
+    const auto mit = data.find (pwallet->GetName ());
+    assert (mit != data.end ());
+    mit->second.blockHashes.insert (hashHex);
+  }
+
+  /**
+   * Marks a block as submitted, releasing the key for it (if any).
+   */
+  void
+  MarkBlockSubmitted (const CWallet* pwallet, const std::string& hashHex)
+  {
+    LOCK (cs);
+
+    const auto mit = data.find (pwallet->GetName ());
+    if (mit == data.end ())
+      return;
+
+    if (mit->second.blockHashes.count (hashHex) > 0)
+      data.erase (mit);
+  }
+
+};
+
+ReservedKeysForMining g_mining_keys;
+
+} // anonymous namespace
+
+static UniValue getauxblock(const JSONRPCRequest& request)
+{
+    /* RPCHelpMan::Check is not applicable here since we have the
+       custom check for exactly zero or two arguments.  */
+    if (request.fHelp
+          || (request.params.size() != 0 && request.params.size() != 2))
+        throw std::runtime_error(
+            RPCHelpMan{"getauxblock",
+                "\nCreate or submits a merge-mined block.\n"
+                "\nWithout arguments, creates a new block and returns information\n"
+                "required to merge-mine it.  With arguments, submits a solved\n"
+                "auxpow for a previously returned block.\n",
+                {
+                    {"hash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED_NAMED_ARG, "Hash of the block to submit"},
+                    {"auxpow", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED_NAMED_ARG, "Serialised auxpow found"},
+                },
+                {
+                  RPCResult{"without arguments",
+                      RPCResult::Type::OBJ, "", "",
+                      {
+                          {RPCResult::Type::STR_HEX, "hash", "hash of the created block"},
+                          {RPCResult::Type::NUM, "chainid", "chain ID for this block"},
+                          {RPCResult::Type::STR_HEX, "previousblockhash", "hash of the previous block"},
+                          {RPCResult::Type::NUM, "coinbasevalue", "value of the block's coinbase"},
+                          {RPCResult::Type::STR_HEX, "bits", "compressed target of the block"},
+                          {RPCResult::Type::NUM, "height", "height of the block"},
+                          {RPCResult::Type::STR_HEX, "target", "target in reversed byte order"},
+                      },
+                  },
+                  {"with arguments",
+                      RPCResult::Type::BOOL, "", "whether the submitted block was correct"
+                  },
+                },
+                RPCExamples{
+                    HelpExampleCli("getauxblock", "")
+                    + HelpExampleCli("getauxblock", "\"hash\" \"serialised auxpow\"")
+                    + HelpExampleRpc("getauxblock", "")
+                },
+            }.ToString());
+
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    if (!wallet) return NullUniValue;
+    CWallet* const pwallet = wallet.get();
+
+    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
+        throw JSONRPCError(RPC_WALLET_ERROR, "Error: Private keys are disabled for this wallet");
+    }
+
+    /* Create a new block */
+    if (request.params.size() == 0)
+    {
+        const CScript coinbaseScript = g_mining_keys.GetCoinbaseScript(pwallet);
+        const UniValue res = AuxpowMiner::get().createAuxBlock(request, coinbaseScript);
+        g_mining_keys.AddBlockHash(pwallet, res["hash"].get_str ());
+        return res;
+    }
+
+    /* Submit a block instead.  */
+    assert(request.params.size() == 2);
+    const std::string& hash = request.params[0].get_str();
+
+    const bool fAccepted
+        = AuxpowMiner::get().submitAuxBlock(request, hash, request.params[1].get_str());
+    if (fAccepted)
+        g_mining_keys.MarkBlockSubmitted(pwallet, hash);
+
+    return fAccepted;
+}
+
 RPCHelpMan abortrescan();
 RPCHelpMan dumpprivkey();
 RPCHelpMan importprivkey();
@@ -4552,6 +4737,7 @@ static const CRPCCommand commands[] =
     { "wallet",             "encryptwallet",                    &encryptwallet,                 {"passphrase"} },
     { "wallet",             "getaddressesbylabel",              &getaddressesbylabel,           {"label"} },
     { "wallet",             "getaddressinfo",                   &getaddressinfo,                {"address"} },
+    { "mining",             "getauxblock",                      &getauxblock,                   {"hash", "auxpow"} },
     { "wallet",             "getbalance",                       &getbalance,                    {"dummy","minconf","include_watchonly","avoid_reuse"} },
     { "wallet",             "getnewaddress",                    &getnewaddress,                 {"label","address_type"} },
     { "wallet",             "getrawchangeaddress",              &getrawchangeaddress,           {"address_type"} },
diff --git a/test/functional/auxpow_mining.py b/test/functional/auxpow_mining.py
new file mode 100755
index 00000000000..bb4568772d1
--- /dev/null
+++ b/test/functional/auxpow_mining.py
@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2018 Daniel Kraft
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Test the merge-mining RPC interface:
+# getauxblock, createauxblock, submitauxblock
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import *
+
+from test_framework.auxpow import reverseHex
+from test_framework.auxpow_testing import (
+  computeAuxpow,
+  getCoinbaseAddr,
+  mineAuxpowBlockWithMethods,
+)
+
+class AuxpowMiningTest (BitcoinTestFramework):
+
+  def set_test_params (self):
+    self.num_nodes = 2
+
+  def add_options (self, parser):
+    parser.add_argument ("--segwit", dest="segwit", default=False,
+                         action="store_true",
+                         help="Test behaviour with SegWit active")
+
+  def run_test (self):
+    # Enable mock time to be out of IBD.
+    self.enable_mocktime ()
+
+    # Activate segwit if requested.
+    if self.options.segwit:
+      self.nodes[0].generate (500)
+      self.sync_all ()
+
+    # Test with getauxblock and createauxblock/submitauxblock.
+    self.test_getauxblock ()
+    self.test_create_submit_auxblock ()
+
+  def test_common (self, create, submit):
+    """
+    Common test code that is shared between the tests for getauxblock and the
+    createauxblock / submitauxblock method pair.
+    """
+
+    # Verify data that can be found in another way.
+    auxblock = create ()
+    assert_equal (auxblock['chainid'], 1)
+    assert_equal (auxblock['height'], self.nodes[0].getblockcount () + 1)
+    assert_equal (auxblock['previousblockhash'],
+                  self.nodes[0].getblockhash (auxblock['height'] - 1))
+
+    # Calling again should give the same block.
+    auxblock2 = create ()
+    assert_equal (auxblock2, auxblock)
+
+    # If we receive a new block, the old hash will be replaced.
+    self.sync_all ()
+    self.nodes[1].generate (1)
+    self.sync_all ()
+    auxblock2 = create ()
+    assert auxblock['hash'] != auxblock2['hash']
+    assert_raises_rpc_error (-8, 'block hash unknown', submit,
+                             auxblock['hash'], "x")
+
+    # Invalid format for auxpow.
+    assert_raises_rpc_error (-1, None, submit,
+                             auxblock2['hash'], "x")
+
+    # Invalidate the block again, send a transaction and query for the
+    # auxblock to solve that contains the transaction.
+    self.nodes[0].generate (1)
+    addr = self.nodes[1].getnewaddress ()
+    txid = self.nodes[0].sendtoaddress (addr, 1)
+    self.sync_all ()
+    assert_equal (self.nodes[1].getrawmempool (), [txid])
+    auxblock = create ()
+    target = reverseHex (auxblock['_target'])
+
+    # Compute invalid auxpow.
+    apow = computeAuxpow (auxblock['hash'], target, False)
+    res = submit (auxblock['hash'], apow)
+    assert not res
+
+    # Compute and submit valid auxpow.
+    apow = computeAuxpow (auxblock['hash'], target, True)
+    res = submit (auxblock['hash'], apow)
+    assert res
+
+    # Make sure that the block is indeed accepted.
+    self.sync_all ()
+    assert_equal (self.nodes[1].getrawmempool (), [])
+    height = self.nodes[1].getblockcount ()
+    assert_equal (height, auxblock['height'])
+    assert_equal (self.nodes[1].getblockhash (height), auxblock['hash'])
+
+    # Call getblock and verify the auxpow field.
+    data = self.nodes[1].getblock (auxblock['hash'])
+    assert 'auxpow' in data
+    auxJson = data['auxpow']
+    assert_equal (auxJson['index'], 0)
+    assert_equal (auxJson['chainindex'], 0)
+    assert_equal (auxJson['merklebranch'], [])
+    assert_equal (auxJson['chainmerklebranch'], [])
+    assert_equal (auxJson['parentblock'], apow[-160:])
+
+    # Also previous blocks should have 'auxpow', since all blocks (also
+    # those generated by "generate") are merge-mined.
+    oldHash = self.nodes[1].getblockhash (100)
+    data = self.nodes[1].getblock (oldHash)
+    assert 'auxpow' in data
+
+    # Check that it paid correctly to the first node.
+    t = self.nodes[0].listtransactions ("*", 1)
+    assert_equal (len (t), 1)
+    t = t[0]
+    assert_equal (t['category'], "immature")
+    assert_equal (t['blockhash'], auxblock['hash'])
+    assert t['generated']
+    assert_greater_than_or_equal (t['amount'], Decimal ("1"))
+    assert_equal (t['confirmations'], 1)
+
+    # Verify the coinbase script.  Ensure that it includes the block height
+    # to make the coinbase tx unique.  The expected block height is around
+    # 200, so that the serialisation of the CScriptNum ends in an extra 00.
+    # The vector has length 2, which makes up for 02XX00 as the serialised
+    # height.  Check this.  (With segwit, the height is different, so we skip
+    # this for simplicity.)
+    if not self.options.segwit:
+      blk = self.nodes[1].getblock (auxblock['hash'])
+      tx = self.nodes[1].getrawtransaction (blk['tx'][0], 1)
+      coinbase = tx['vin'][0]['coinbase']
+      assert_equal ("02%02x00" % auxblock['height'], coinbase[0 : 6])
+
+  def test_getauxblock (self):
+    """
+    Test the getauxblock method.
+    """
+
+    create = self.nodes[0].getauxblock
+    submit = self.nodes[0].getauxblock
+    self.test_common (create, submit)
+
+    # Ensure that the payout address is changed from one block to the next.
+    hash1 = mineAuxpowBlockWithMethods (create, submit)
+    hash2 = mineAuxpowBlockWithMethods (create, submit)
+    self.sync_all ()
+    addr1 = getCoinbaseAddr (self.nodes[1], hash1)
+    addr2 = getCoinbaseAddr (self.nodes[1], hash2)
+    assert addr1 != addr2
+    info = self.nodes[0].getaddressinfo (addr1)
+    assert info['ismine']
+    info = self.nodes[0].getaddressinfo (addr2)
+    assert info['ismine']
+
+  def test_create_submit_auxblock (self):
+    """
+    Test the createauxblock / submitauxblock method pair.
+    """
+
+    # Check for errors with wrong parameters.
+    assert_raises_rpc_error (-1, None, self.nodes[0].createauxblock)
+    assert_raises_rpc_error (-5, "Invalid coinbase payout address",
+                             self.nodes[0].createauxblock,
+                             "this_an_invalid_address")
+
+    # Fix a coinbase address and construct methods for it.
+    coinbaseAddr = self.nodes[0].getnewaddress ()
+    def create ():
+      return self.nodes[0].createauxblock (coinbaseAddr)
+    submit = self.nodes[0].submitauxblock
+
+    # Run common tests.
+    self.test_common (create, submit)
+
+    # Ensure that the payout address is the one which we specify
+    hash1 = mineAuxpowBlockWithMethods (create, submit)
+    hash2 = mineAuxpowBlockWithMethods (create, submit)
+    self.sync_all ()
+    addr1 = getCoinbaseAddr (self.nodes[1], hash1)
+    addr2 = getCoinbaseAddr (self.nodes[1], hash2)
+    assert_equal (addr1, coinbaseAddr)
+    assert_equal (addr2, coinbaseAddr)
+
+if __name__ == '__main__':
+  AuxpowMiningTest ().main ()
diff --git a/test/functional/interface_rest.py b/test/functional/interface_rest.py
index f4fe29871a3..86dc431c756 100755
--- a/test/functional/interface_rest.py
+++ b/test/functional/interface_rest.py
@@ -14,6 +14,7 @@
 import http.client
 import urllib.parse
 
+from test_framework import auxpow
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
@@ -185,7 +186,13 @@ def run_test(self):
         assert_equal(len(json_obj['utxos']), 0)
 
         self.nodes[0].generate(1)
+
+        json_request = json_request.rstrip("/")
+        response = http_post_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json', '', True)
+        assert_equal(response.status, 200) #must be a 200 because we are within the limits
+
         self.sync_all()
+        bb_hash = self.nodes[0].getbestblockhash()
 
         json_obj = self.test_rest_request("/getutxos/{}-{}".format(*spending))
         assert_equal(len(json_obj['utxos']), 1)
@@ -205,7 +212,7 @@ def run_test(self):
         long_uri = '/'.join(['{}-{}'.format(txid, n_) for n_ in range(15)])
         self.test_rest_request("/getutxos/checkmempool/{}".format(long_uri), http_method='POST', status=200)
 
-        self.nodes[0].generate(1)  # generate block to not affect upcoming tests
+        mineAuxpowBlock(self.nodes[0])  # generate block to not affect upcoming tests
         self.sync_all()
 
         self.log.info("Test the /block, /blockhashbyheight and /headers URIs")
@@ -228,9 +235,10 @@ def run_test(self):
 
         # Compare with block header
         response_header = self.test_rest_request("/headers/1/{}".format(bb_hash), req_type=ReqType.BIN, ret_type=RetType.OBJ)
-        assert_equal(int(response_header.getheader('content-length')), BLOCK_HEADER_SIZE)
+        headerLen = int(response_header.getheader('content-length'))
+        assert_greater_than(headerLen, BLOCK_HEADER_SIZE)
         response_header_bytes = response_header.read()
-        assert_equal(response_bytes[:BLOCK_HEADER_SIZE], response_header_bytes)
+        assert_equal(response_bytes[:headerLen], response_header_bytes)
 
         # Check block hex format
         response_hex = self.test_rest_request("/block/{}".format(bb_hash), req_type=ReqType.HEX, ret_type=RetType.OBJ)
@@ -241,8 +249,9 @@ def run_test(self):
         # Compare with hex block header
         response_header_hex = self.test_rest_request("/headers/1/{}".format(bb_hash), req_type=ReqType.HEX, ret_type=RetType.OBJ)
         assert_greater_than(int(response_header_hex.getheader('content-length')), BLOCK_HEADER_SIZE*2)
-        response_header_hex_bytes = response_header_hex.read(BLOCK_HEADER_SIZE*2)
-        assert_equal(binascii.hexlify(response_bytes[:BLOCK_HEADER_SIZE]), response_header_hex_bytes)
+        response_header_hex_bytes = response_header_hex.read().strip()
+        headerLen = len(response_header_hex_bytes)
+        assert_equal(binascii.hexlify(response_bytes[:headerLen]), response_header_hex_bytes)
 
         # Check json format
         block_json_obj = self.test_rest_request("/block/{}".format(bb_hash))
diff --git a/test/functional/test_framework/auxpow.py b/test/functional/test_framework/auxpow.py
new file mode 100644
index 00000000000..e145e7ce719
--- /dev/null
+++ b/test/functional/test_framework/auxpow.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2018 Daniel Kraft
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Basic code for working with auxpow.  This is used for the regtests (e.g. from
+# auxpow_testing.py), but also for contrib/auxpow/getwork-wrapper.py.
+
+import binascii
+import codecs
+import hashlib
+
+def constructAuxpow (block):
+  """
+  Starts to construct a minimal auxpow, ready to be mined.  Returns the fake
+  coinbase tx and the unmined parent block header as hex strings.
+  """
+
+  block = codecs.encode (block, 'ascii')
+
+  # Start by building the merge-mining coinbase.  The merkle tree
+  # consists only of the block hash as root.
+  coinbase = b"fabe" + binascii.hexlify (b"m" * 2)
+  coinbase += block
+  coinbase += b"01000000" + (b"00" * 4)
+
+  # Construct "vector" of transaction inputs.
+  vin = b"01"
+  vin += (b"00" * 32) + (b"ff" * 4)
+  vin += codecs.encode ("%02x" % (len (coinbase) // 2), "ascii") + coinbase
+  vin += (b"ff" * 4)
+
+  # Build up the full coinbase transaction.  It consists only
+  # of the input and has no outputs.
+  tx = b"01000000" + vin + b"00" + (b"00" * 4)
+  txHash = doubleHashHex (tx)
+
+  # Construct the parent block header.  It need not be valid, just good
+  # enough for auxpow purposes.
+  header = b"01000000"
+  header += b"00" * 32
+  header += reverseHex (txHash)
+  header += b"00" * 4
+  header += b"00" * 4
+  header += b"00" * 4
+
+  return (tx.decode ('ascii'), header.decode ('ascii'))
+
+def finishAuxpow (tx, header):
+  """
+  Constructs the finished auxpow hex string based on the mined header.
+  """
+
+  blockhash = doubleHashHex (header)
+
+  # Build the MerkleTx part of the auxpow.
+  auxpow = codecs.encode (tx, 'ascii')
+  auxpow += blockhash
+  auxpow += b"00"
+  auxpow += b"00" * 4
+
+  # Extend to full auxpow.
+  auxpow += b"00"
+  auxpow += b"00" * 4
+  auxpow += header
+
+  return auxpow.decode ("ascii")
+
+def doubleHashHex (data):
+  """
+  Perform Bitcoin's Double-SHA256 hash on the given hex string.
+  """
+
+  hasher = hashlib.sha256 ()
+  hasher.update (binascii.unhexlify (data))
+  data = hasher.digest ()
+
+  hasher = hashlib.sha256 ()
+  hasher.update (data)
+
+  return reverseHex (hasher.hexdigest ())
+
+def reverseHex (data):
+  """
+  Flip byte order in the given data (hex string).
+  """
+
+  b = bytearray (binascii.unhexlify (data))
+  b.reverse ()
+
+  return binascii.hexlify (b)
+
+def getworkByteswap (data):
+  """
+  Run the byte-order swapping step necessary for working with getwork.
+  """
+
+  data = bytearray (data)
+  assert len (data) % 4 == 0
+  for i in range (0, len (data), 4):
+    data[i], data[i + 3] = data[i + 3], data[i]
+    data[i + 1], data[i + 2] = data[i + 2], data[i + 1]
+
+  return data
diff --git a/test/functional/test_framework/auxpow_testing.py b/test/functional/test_framework/auxpow_testing.py
new file mode 100644
index 00000000000..f1ef056b8a5
--- /dev/null
+++ b/test/functional/test_framework/auxpow_testing.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2018 Daniel Kraft
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Utility routines for auxpow that are needed specifically by the regtests.
+# This is mostly about actually *solving* an auxpow block (with regtest
+# difficulty) or inspecting the information for verification.
+
+import binascii
+
+from test_framework import auxpow
+
+def computeAuxpow (block, target, ok):
+  """
+  Build an auxpow object (serialised as hex string) that solves
+  (ok = True) or doesn't solve (ok = False) the block.
+  """
+
+  (tx, header) = auxpow.constructAuxpow (block)
+  (header, _) = mineBlock (header, target, ok)
+  return auxpow.finishAuxpow (tx, header)
+
+def mineAuxpowBlock (node):
+  """
+  Mine an auxpow block on the given RPC connection.  This uses the
+  createauxblock and submitauxblock command pair.
+  """
+
+  def create ():
+    addr = node.getnewaddress ()
+    return node.createauxblock (addr)
+
+  return mineAuxpowBlockWithMethods (create, node.submitauxblock)
+
+def mineAuxpowBlockWithMethods (create, submit):
+  """
+  Mine an auxpow block, using the given methods for creation and submission.
+  """
+
+  auxblock = create ()
+  target = auxpow.reverseHex (auxblock['_target'])
+  apow = computeAuxpow (auxblock['hash'], target, True)
+  res = submit (auxblock['hash'], apow)
+  assert res
+
+  return auxblock['hash']
+
+def getCoinbaseAddr (node, blockHash):
+    """
+    Extract the coinbase tx' payout address for the given block.
+    """
+
+    blockData = node.getblock (blockHash)
+    txn = blockData['tx']
+    assert len (txn) >= 1
+
+    txData = node.getrawtransaction (txn[0], 1)
+    assert len (txData['vout']) >= 1 and len (txData['vin']) == 1
+    assert 'coinbase' in txData['vin'][0]
+
+    addr = txData['vout'][0]['scriptPubKey']['addresses']
+    assert len (addr) == 1
+    return addr[0]
+
+def mineBlock (header, target, ok):
+  """
+  Given a block header, update the nonce until it is ok (or not)
+  for the given target.
+  """
+
+  data = bytearray (binascii.unhexlify (header))
+  while True:
+    assert data[79] < 255
+    data[79] += 1
+    hexData = binascii.hexlify (data)
+
+    blockhash = auxpow.doubleHashHex (hexData)
+    if (ok and blockhash < target) or ((not ok) and blockhash > target):
+      break
+
+  return (hexData, blockhash)