diff --git a/TODO b/TODO
new file mode 100644
index 00000000..b5793983
--- /dev/null
+++ b/TODO
@@ -0,0 +1,14 @@
+* upgrade to new version at fixed height:
+  - P2SH as enforced soft fork (BIP16)
+  - strict BIP30 as enforced soft fork
+  - allow larger blocks (DB locks)
+  - no need to disallow auxpow parent blocks with auxpow-flag in the version
+    any more; instead, the auxpow is simply never loaded for them
+  - disallow legacy blocks also on testnet
+  - restrict auxpow size / coinbase tx size?
+
+* reenable some of the disabled tests, new alert keys?
+
+* make dust spam unspendable?
+
+* simplify regtests with reduced number of nodes?
diff --git a/contrib/auxpow-sizes/auxpow-sizes.py b/contrib/auxpow-sizes/auxpow-sizes.py
new file mode 100755
index 00000000..1b54e8fd
--- /dev/null
+++ b/contrib/auxpow-sizes/auxpow-sizes.py
@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+
+#   Auxpow Sizes - find sizes of auxpow's in the blockchain
+#   Copyright (C) 2015  Daniel Kraft <d@domob.eu>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU Affero General Public License for more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import jsonrpc
+import sys
+import urllib
+
+username = urllib.quote_plus ("devcoin")
+password = urllib.quote_plus ("password")
+port = 8336
+url = "http://%s:%s@localhost:%d/" % (username, password, port)
+
+class AuxpowStats:
+  """
+  Keep track of the interesting statistics of the auxpows
+  found in the blockchain.
+  """
+
+  def __init__ (self):
+    self.merkleLength = dict ()
+    self.txSize = dict ()
+    self.maxMerkle = 0
+    self.maxTxSize = 0
+
+  def add (self, obj):
+    """
+    Add the auxpow described by the block JSON obj (if any)
+    to the statistics.
+    """
+
+    if 'auxpow' not in obj:
+      return
+
+    txSize = len (obj['auxpow']['tx']['hex']) / 2
+    merkleLen = len (obj['auxpow']['merklebranch'])
+
+    if txSize not in self.txSize:
+      self.txSize[txSize] = 1
+    else:
+      self.txSize[txSize] += 1
+
+    if merkleLen not in self.merkleLength:
+      self.merkleLength[merkleLen] = 1
+    else:
+      self.merkleLength[merkleLen] += 1
+
+    if txSize > self.maxTxSize:
+      self.maxTxSize = txSize
+      self.maxTxSizeHash = obj['hash']
+    if merkleLen > self.maxMerkle:
+      self.maxMerkle = merkleLen
+      self.maxMerkleHash = obj['hash']
+
+  def output (self):
+    """
+    Output statistics in the end.
+    """
+
+    print "Merkle lengths:"
+    for (key, val) in self.merkleLength.items ():
+      print "%4d: %6d" % (key, val)
+    print "Maximum: %d, block %s\n" % (self.maxMerkle, self.maxMerkleHash)
+
+    print "\nCoinbase tx sizes:"
+    buckets = [0, 1000, 2000, 5000, 10000, 20000, 50000]
+    bucketCnts = (len (buckets) + 1) * [0]
+    for (key, val) in self.txSize.items ():
+      for i in range (len (buckets) - 1, -1, -1):
+        if (key >= buckets[i]):
+          bucketCnts[i] += val
+    for i in range (len (buckets) - 1):
+      label = "%d - %d" % (buckets[i], buckets[i + 1] - 1)
+      print "  %15s: %6d" % (label, bucketCnts[i])
+    label = ">= %d" % buckets[-1]
+    print "  %15s: %6d" % (label, bucketCnts[-1])
+    print "Maximum: %d, block %s\n" % (self.maxTxSize, self.maxTxSizeHash)
+
+rpc = jsonrpc.proxy.ServiceProxy (url)
+tips = rpc.getchaintips ()
+tip = None
+for t in tips:
+  if t['status'] == 'active':
+    tip = t
+    break
+assert tip is not None
+
+stats = AuxpowStats ()
+curHash = tip['hash']
+while True:
+  obj = rpc.getblock (curHash)
+  stats.add (obj)
+  if obj['height'] % 1000 == 0:
+    sys.stderr.write ("At height %d...\n" % obj['height'])
+  if 'previousblockhash' not in obj:
+    break
+  curHash = obj['previousblockhash']
+stats.output ()
diff --git a/contrib/auxpow/getwork-wrapper.py b/contrib/auxpow/getwork-wrapper.py
new file mode 100755
index 00000000..50a01503
--- /dev/null
+++ b/contrib/auxpow/getwork-wrapper.py
@@ -0,0 +1,124 @@
+#!/usr/bin/env python
+# Copyright (c) 2018 Daniel Kraft
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# This is a simple wrapper around the merge-mining interface of the core
+# daemon (createauxblock and submitauxblock).  It handles the creation of
+# a "fake" auxpow, providing an external miner with a getwork-like interface.
+#
+# Since using this loses the ability to *actually* merge mine with a parent
+# chain, this is likely not very useful in production.  But it can be used
+# for testing and debugging.
+#
+# This needs jsonrpclib, which can be found in the 'python-jsonrpclib' Debian
+# package or at https://github.com/joshmarshall/jsonrpclib.  It also imports
+# auxpow from test/functional/test_framework.
+
+import codecs
+import optparse
+import struct
+from xmlrpclib import ProtocolError
+
+import jsonrpclib
+from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer
+
+import auxpow
+
+
+class GetworkWrapper:
+  """
+  The main server class.  It sets up a JSON-RPC server and handles requests
+  coming in.
+  """
+
+  def __init__ (self, backend, host, port):
+    self.backend = backend
+    self.server = SimpleJSONRPCServer ((host, port))
+
+    def getwork (data=None):
+      if data is None:
+        return self.createWork ()
+      return self.submitWork (data)
+    self.server.register_function (getwork)
+
+    # We use our own extra nonce to not return the same work twice if
+    # asked again for new work.
+    self.extraNonce = 0
+
+    # Dictionary that holds all created works so they can be retrieved when
+    # necessary for matching.  The key is the (byte-order swapped) block merkle
+    # hash, which is not changed by the miner when processing the work.
+    # This is cleared only once a submitted block was accepted.  We do not try
+    # to detect if the chain tip changes externally.
+    self.works = {}
+
+  def keyForWork (self, data):
+    """
+    Returns the key used in self.works for the given, hex-encoded and
+    byte-swapped, getwork 'data'.
+    """
+
+    return data[2*36 : 2*68]
+
+  def createWork (self):
+    auxblock = self.backend.getauxblock ()
+    (tx, hdr) = auxpow.constructAuxpow (auxblock['hash'])
+
+    en = self.extraNonce
+    self.extraNonce = (self.extraNonce + 1) % (1 << 32)
+
+    hdrBytes = bytearray (codecs.decode (hdr, 'hex_codec'))
+    hdrBytes[0:4] = struct.pack ('<I', en)
+    formatted = auxpow.getworkByteswap (hdrBytes)
+    formatted += bytearray ([0] * (128 - len (formatted)))
+    formatted[83] = 0x80
+    formatted[-4] = 0x80
+    formatted[-3] = 0x02
+    work = codecs.encode (formatted, 'hex_codec')
+
+    self.works[self.keyForWork (work)] = {"auxblock": auxblock, "tx": tx}
+
+    return {"data": work, "target": auxblock['_target']}
+
+  def submitWork (self, data):
+    key = self.keyForWork (data)
+    if not key in self.works:
+      print ('Error: stale / unknown work submitted')
+      return False
+    w = self.works[key]
+
+    dataBytes = codecs.decode (data, 'hex_codec')
+    fixedBytes = auxpow.getworkByteswap (dataBytes[:80])
+    hdrHex = codecs.encode (fixedBytes, 'hex_codec')
+
+    auxpowHex = auxpow.finishAuxpow (w['tx'], hdrHex)
+    try:
+      res = self.backend.submitauxblock (w['auxblock']['hash'], auxpowHex)
+    except ProtocolError as exc:
+      print ('Error submitting work: %s' % exc)
+      return False
+
+    # Clear cache of created works when a new block was accepted.
+    if res:
+      self.works = {}
+
+    return res
+
+  def serve (self):
+    self.server.serve_forever ()
+
+
+if __name__ == '__main__':
+  parser = optparse.OptionParser (usage="%prog [options]")
+  parser.add_option ("--backend-url", dest="backend",
+                     help="URL for the backend daemon connection")
+  parser.add_option ("--port", dest="port", type="int",
+                     help="Port on which to serve")
+  (options, _) = parser.parse_args ()
+  if options.backend is None or options.port is None:
+    parser.error ("--backend-url and --port must be specified")
+
+  backend = jsonrpclib.Server (options.backend)
+  server = GetworkWrapper (backend, 'localhost', options.port)
+  server.serve ()
diff --git a/contrib/auxpow/getwork-wrapper.sh b/contrib/auxpow/getwork-wrapper.sh
new file mode 100755
index 00000000..cc131287
--- /dev/null
+++ b/contrib/auxpow/getwork-wrapper.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# Copyright (c) 2018 Daniel Kraft
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Starts up the getwork-wrapper.py script, setting PYTHONPATH accordingly.
+# This script must be run from the root source directory to work correctly.
+#
+# Example:
+#   contrib/auxpow/getwork-wrapper.sh http://user:pass@localhost:port/ 1234
+
+PYTHONPATH="test/functional/test_framework"
+contrib/auxpow/getwork-wrapper.py --backend-url="$1" --port="$2"
diff --git a/src/Makefile.am b/src/Makefile.am
index 547cd555..29516ced 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -213,6 +213,7 @@ DEVCOIN_CORE_H = \
   rpc/mining.h \
   rpc/net.h \
   rpc/protocol.h \
+  rpc/rawtransaction.h \
   rpc/rawtransaction_util.h \
   rpc/register.h \
   rpc/request.h \
diff --git a/src/auxpow.cpp b/src/auxpow.cpp
index fa0e886a..764a56c8 100644
--- a/src/auxpow.cpp
+++ b/src/auxpow.cpp
@@ -1,7 +1,7 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2011 Vince Durham
 // Copyright (c) 2009-2014 The Bitcoin developers
-// Copyright (c) 2014-2019 Daniel Kraft
+// Copyright (c) 2014-2021 Daniel Kraft
 // Distributed under the MIT/X11 software license, see the accompanying
 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
 
@@ -42,22 +42,17 @@ CAuxPow::check (const uint256& hashAuxBlock, int nChainId,
                 const Consensus::Params& params) const
 {
     if (params.fStrictChainId) {
-        const int32_t &nChainIDParent = parentBlock.GetChainId();
-        if(nChainIDParent > 0) {
-            if(nChainIDParent == params.nAuxpowChainId)
-                return error("Aux POW parent has our chain ID");
-        } else {
-            const int32_t &nOldChainIDParent = parentBlock.GetOldChainId();
-            if(nOldChainIDParent == params.nAuxpowOldChainId)
-                return error("Aux POW parent has our old chain ID");
-        }
+        if (parentBlock.GetChainId () == nChainId)
+            return error("Aux POW parent has our chain ID");
+        else if(parentBlock.GetOldChainId() == params.nAuxpowOldChainId)
+            return error("Aux POW parent has our old 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
+    const uint256 nRootHash
       = CheckMerkleBranch (hashAuxBlock, vChainMerkleBranch, nChainIndex);
     valtype vchRootHash(nRootHash.begin (), nRootHash.end ());
     std::reverse (vchRootHash.begin (), vchRootHash.end ()); // correct endian
@@ -71,7 +66,7 @@ CAuxPow::check (const uint256& hashAuxBlock, int nChainId,
     if (coinbaseTx->vin.empty())
         return error("Aux POW coinbase has no inputs");
 
-    const CScript &script = coinbaseTx->vin[0].scriptSig;
+    const CScript script = coinbaseTx->vin[0].scriptSig;
 
     // Check that the same work is not submitted twice to our chain.
     //
@@ -114,12 +109,12 @@ CAuxPow::check (const uint256& hashAuxBlock, int nChainId,
     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 ();
+    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]);
+    const uint32_t nNonce = DecodeLE32 (&pc[4]);
     if (nChainIndex != getExpectedIndex (nNonce, nChainId, merkleHeight))
         return error("Aux POW wrong index");
 
@@ -127,8 +122,8 @@ CAuxPow::check (const uint256& hashAuxBlock, int nChainId,
 }
 
 int
-CAuxPow::getExpectedIndex (const uint32_t &nNonce, const int &nChainId,
-                           const unsigned &h)
+CAuxPow::getExpectedIndex (const uint32_t nNonce, const int nChainId,
+                           const unsigned h)
 {
   // Choose a pseudo-random slot in the chain merkle tree
   // but have it be fixed for a size/nonce/chain combination.
diff --git a/src/auxpow.h b/src/auxpow.h
index 7090219e..df842886 100644
--- a/src/auxpow.h
+++ b/src/auxpow.h
@@ -20,8 +20,10 @@
 class CBlock;
 class CBlockHeader;
 class CBlockIndex;
+class CChainState;
+class CValidationState;
 class UniValue;
-class ChainstateManager;
+
 namespace auxpow_tests
 {
 class CAuxPowForTest;
@@ -30,8 +32,6 @@ class CAuxPowForTest;
 /** Header for merge-mining data in the coinbase.  */
 static const unsigned char pchMergedMiningHeader[] = { 0xfa, 0xbe, 'm', 'm' };
 
-typedef std::vector<unsigned char> valtype;
-
 /**
  * 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 Devcoin block
@@ -65,7 +65,8 @@ class CAuxPow
                                     const std::vector<uint256>& vMerkleBranch,
                                     int nIndex);
 
-  friend UniValue AuxpowToJSON(const CAuxPow& auxpow, ChainstateManager& chainstate);
+  friend UniValue AuxpowToJSON(const CAuxPow& auxpow, bool verbose,
+                               CChainState& active_chainstate);
   friend class auxpow_tests::CAuxPowForTest;
 
 public:
@@ -83,8 +84,7 @@ class CAuxPow
   CAuxPow (const CAuxPow&) = delete;
   void operator= (const CAuxPow&) = delete;
 
-
-  SERIALIZE_METHODS(CAuxPow, obj)
+  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
@@ -96,8 +96,11 @@ class CAuxPow
     /* The index of the parent coinbase tx is always zero.  */
     int nIndex = 0;
 
-    /* Data from the coinbase transaction READWRITE(obj.key);READWRITE(obj.key);as Merkle tx.  */
-    READWRITE (obj.coinbaseTx, hashBlock, obj.vMerkleBranch, nIndex, obj.vChainMerkleBranch, obj.nChainIndex, obj.parentBlock);
+    /* 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);
   }
 
   /**
@@ -121,6 +124,18 @@ class CAuxPow
     return parentBlock.GetHash ();
   }
 
+  /**
+   * 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.
@@ -129,7 +144,7 @@ class CAuxPow
    * @param h The merkle block height.
    * @return The expected index for the aux hash.
    */
-  static int getExpectedIndex (const uint32_t &nNonce, const int &nChainId, const unsigned &h);
+  static int getExpectedIndex (uint32_t nNonce, int nChainId, unsigned h);
 
   /**
    * Constructs a minimal CAuxPow object for the given block header and
diff --git a/src/chain.cpp b/src/chain.cpp
index a420af72..c3f80dc2 100644
--- a/src/chain.cpp
+++ b/src/chain.cpp
@@ -4,7 +4,9 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chain.h>
+
 #include <node/blockstorage.h>
+
 /* Moved here from the header, because we need auxpow and the logic
    becomes more involved.  */
 CBlockHeader CBlockIndex::GetBlockHeader(const Consensus::Params& consensusParams) const
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index f8aa9acc..e6292efd 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -65,7 +65,7 @@ class CMainParams : public CChainParams {
         consensus.signet_blocks = false;
         consensus.signet_challenge.clear();
         consensus.nSubsidyHalvingInterval = 210000;
-        consensus.BIP16Exception = uint256{};
+        consensus.BIP16Height = 1;
         consensus.BIP34Height = 23523;
         consensus.BIP34Hash = uint256S("0x0000000002fde67fbf51d8b3c1fe80b162b0ba5ac58b0afe87c4c94cbe958c58");
         consensus.BIP65Height = 23523; // 0000000002fde67fbf51d8b3c1fe80b162b0ba5ac58b0afe87c4c94cbe958c58
@@ -94,10 +94,11 @@ class CMainParams : public CChainParams {
         consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000025018c6a1a353ba518e9753");
         consensus.defaultAssumeValid = uint256S("0xe5f6dbecef5f5b8c49b8a6b7cefc80183dace19c474264b87f07edf55d347860"); // 496000
 
-        // AuxPow
-        consensus.fStrictChainId = true;
         consensus.nAuxpowChainId = 4;
         consensus.nAuxpowOldChainId = 4096;
+        consensus.nAuxpowStartHeight = 0;
+        consensus.fStrictChainId = true;
+        consensus.nLegacyBlocksBefore = 19200;
 
         /**
          * The message start string is designed to be unlikely to occur in normal data.
@@ -178,7 +179,7 @@ class CTestNetParams : public CChainParams {
         consensus.signet_blocks = false;
         consensus.signet_challenge.clear();
         consensus.nSubsidyHalvingInterval = 210000;
-        consensus.BIP16Exception = uint256{};
+        consensus.BIP16Height = 1;
         consensus.BIP34Height = 1;
         consensus.BIP34Hash = uint256{};
         consensus.BIP65Height = 1;
@@ -189,6 +190,7 @@ class CTestNetParams : public CChainParams {
         consensus.nPowTargetTimespan = 24 * 60 * 60; // one day
         consensus.nPowTargetSpacing = 10 * 60;
         consensus.fPowAllowMinDifficultyBlocks = true;
+        consensus.nMinDifficultySince = 0;
         consensus.fPowNoRetargeting = false;
         consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
         consensus.nMinerConfirmationWindow = 144; // nPowTargetTimespan / nPowTargetSpacing
@@ -207,10 +209,11 @@ class CTestNetParams : public CChainParams {
         consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000000000000000141f25d13472"); // 838467
         consensus.defaultAssumeValid = uint256S("0x0000003243223caf052c7e5e6710fae794dbdc10949a594550f073dbf5755bd4"); // 838467
 
-        // AuxPow
-        consensus.fStrictChainId = false;
+        consensus.nAuxpowStartHeight = 0;
         consensus.nAuxpowChainId = 16;
         consensus.nAuxpowOldChainId = 4096;
+        consensus.fStrictChainId = false;
+        consensus.nLegacyBlocksBefore = -1;
 
         pchMessageStart[0] = 0x64; // d
         pchMessageStart[1] = 0x65; // e
@@ -316,15 +319,9 @@ class SigNetParams : public CChainParams {
 
         strNetworkID = CBaseChainParams::SIGNET;
         consensus.signet_blocks = true;
-
-        // AuxPow
-        consensus.fStrictChainId = false;
-        consensus.nAuxpowChainId = 8;
-        consensus.nAuxpowOldChainId = 4096;
-
         consensus.signet_challenge.assign(bin.begin(), bin.end());
         consensus.nSubsidyHalvingInterval = 210000;
-        consensus.BIP16Exception = uint256{};
+        consensus.BIP16Height = 1;
         consensus.BIP34Height = 1;
         consensus.BIP34Hash = uint256{};
         consensus.BIP65Height = 1;
@@ -350,6 +347,12 @@ class SigNetParams : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
 
+        consensus.nAuxpowStartHeight = 0;
+        consensus.nAuxpowChainId = 8;
+        consensus.nAuxpowOldChainId = 4096;
+        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;
@@ -392,21 +395,21 @@ class CRegTestParams : public CChainParams {
         consensus.signet_blocks = false;
         consensus.signet_challenge.clear();
         consensus.nSubsidyHalvingInterval = 150;
-        consensus.BIP16Exception = uint256();
+        consensus.BIP16Height = 1;
         consensus.BIP34Height = 500; // BIP34 activated on regtest (Used in functional tests)
-        consensus.BIP34Hash = uint256();
         consensus.BIP65Height = 1351; // BIP65 activated on regtest (Used in functional tests)
         consensus.BIP66Height = 1251; // BIP66 activated on regtest (Used in functional tests)
         consensus.CSVHeight = 432; // CSV activated on regtest (Used in rpc activation tests)
         consensus.SegwitHeight = 0; // SEGWIT is always activated on regtest unless overridden
+        consensus.MinBIP9WarningHeight = 0;
         consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.nPowTargetTimespan = 24 * 60 * 60; // one day
         consensus.nPowTargetSpacing = 10 * 60;
         consensus.fPowAllowMinDifficultyBlocks = true;
+        consensus.nMinDifficultySince = 0;
         consensus.fPowNoRetargeting = true;
         consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
         consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
-        consensus.MinBIP9WarningHeight = 0;
 
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
@@ -421,10 +424,11 @@ class CRegTestParams : public CChainParams {
         consensus.nMinimumChainWork = uint256{};
         consensus.defaultAssumeValid = uint256{};
 
-        // AuxPow
-        consensus.fStrictChainId = false;
+        consensus.nAuxpowStartHeight = 0;
         consensus.nAuxpowChainId = 8;
         consensus.nAuxpowOldChainId = 4096;
+        consensus.fStrictChainId = true;
+        consensus.nLegacyBlocksBefore = 0;
 
         pchMessageStart[0] = 0x64; // d
         pchMessageStart[1] = 0x65; // e
@@ -496,6 +500,16 @@ class CRegTestParams : public CChainParams {
 
 void CRegTestParams::UpdateActivationParametersFromArgs(const ArgsManager& args)
 {
+    if (args.IsArgSet("-bip16height")) {
+        int64_t height = args.GetArg("-bip16height", consensus.BIP16Height);
+        if (height < -1 || height >= std::numeric_limits<int>::max()) {
+            throw std::runtime_error(strprintf("Activation height %ld for BIP16 is out of valid range. Use -1 to disable BIP16.", height));
+        } else if (height == -1) {
+            LogPrintf("BIP16 disabled for testing\n");
+            height = std::numeric_limits<int>::max();
+        }
+        consensus.BIP16Height = static_cast<int>(height);
+    }
     if (args.IsArgSet("-segwitheight")) {
         int64_t height = args.GetArg("-segwitheight", consensus.SegwitHeight);
         if (height < -1 || height >= std::numeric_limits<int>::max()) {
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 786c742a..31ca109d 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -9,6 +9,8 @@
 #include <uint256.h>
 #include <limits>
 
+#include <memory>
+
 namespace Consensus {
 
 /**
@@ -18,6 +20,7 @@ namespace Consensus {
 enum BuriedDeployment : int16_t {
     // buried deployments get negative values to avoid overlap with DeploymentPos
     DEPLOYMENT_HEIGHTINCB = std::numeric_limits<int16_t>::min(),
+    DEPLOYMENT_P2SH,
     DEPLOYMENT_CLTV,
     DEPLOYMENT_DERSIG,
     DEPLOYMENT_CSV,
@@ -70,8 +73,8 @@ struct BIP9Deployment {
 struct Params {
     uint256 hashGenesisBlock;
     int nSubsidyHalvingInterval;
-    /* Block hash that is excepted from BIP16 enforcement */
-    uint256 BIP16Exception;
+    /** Block height at with BIP16 becomes active */
+    int BIP16Height;
     /** Block height and hash at which BIP34 becomes active */
     int BIP34Height;
     uint256 BIP34Hash;
@@ -99,6 +102,7 @@ struct Params {
     /** Proof of work parameters */
     uint256 powLimit;
     bool fPowAllowMinDifficultyBlocks;
+    int64_t nMinDifficultySince;
     bool fPowNoRetargeting;
     int64_t nPowTargetSpacing;
     int64_t nPowTargetTimespan;
@@ -107,12 +111,6 @@ struct Params {
     uint256 nMinimumChainWork;
     /** By default assume that the signatures in ancestors of this block are valid */
     uint256 defaultAssumeValid;
-    /** Auxpow parameters */
-    int32_t nAuxpowChainId;
-    int32_t nAuxpowOldChainId;
-    int nAuxpowStartHeight;
-    bool fStrictChainId;
-    int nLegacyBlocksBefore; // -1 for "always allow"
 
     /**
      * If true, witness commitments contain a payload equal to a Devcoin Script solution
@@ -124,6 +122,8 @@ struct Params {
     int DeploymentHeight(BuriedDeployment dep) const
     {
         switch (dep) {
+        case DEPLOYMENT_P2SH:
+            return BIP16Height;
         case DEPLOYMENT_HEIGHTINCB:
             return BIP34Height;
         case DEPLOYMENT_CLTV:
@@ -137,6 +137,39 @@ struct Params {
         } // no default case, so the compiler can warn about missing cases
         return std::numeric_limits<int>::max();
     }
+
+    /** Auxpow parameters */
+    int32_t nAuxpowChainId;
+    int32_t nAuxpowOldChainId;
+    int nAuxpowStartHeight;
+    bool fStrictChainId;
+    int nLegacyBlocksBefore; // -1 for "always allow"
+
+    /**
+     * Check whether or not minimum difficulty blocks are allowed
+     * with the given time stamp.
+     * @param nBlockTime Time of the block with minimum difficulty.
+     * @return True if it is allowed to have minimum difficulty.
+     */
+    bool AllowMinDifficultyBlocks(int64_t nBlockTime) const
+    {
+        if (!fPowAllowMinDifficultyBlocks)
+            return false;
+        return nBlockTime > nMinDifficultySince;
+    }
+
+    /**
+     * 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/deploymentinfo.cpp b/src/deploymentinfo.cpp
index 1d6e1220..abff5a58 100644
--- a/src/deploymentinfo.cpp
+++ b/src/deploymentinfo.cpp
@@ -21,6 +21,8 @@ std::string DeploymentName(Consensus::BuriedDeployment dep)
 {
     assert(ValidDeployment(dep));
     switch (dep) {
+    case Consensus::DEPLOYMENT_P2SH:
+        return "bip16";
     case Consensus::DEPLOYMENT_HEIGHTINCB:
         return "bip34";
     case Consensus::DEPLOYMENT_CLTV:
diff --git a/src/miner.cpp b/src/miner.cpp
index 544c72dc..499a511e 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -36,7 +36,7 @@ int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParam
         pblock->nTime = nNewTime;
 
     // Updating time can change work required on testnet:
-    if (consensusParams.fPowAllowMinDifficultyBlocks)
+    if (consensusParams.AllowMinDifficultyBlocks(pblock->GetBlockTime()))
         pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
 
     return nNewTime - nOldTime;
@@ -131,7 +131,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     // -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/net.h b/src/net.h
index b1fd22fb..fa2becc6 100644
--- a/src/net.h
+++ b/src/net.h
@@ -54,8 +54,14 @@ static const int TIMEOUT_INTERVAL = 20 * 60;
 static constexpr auto FEELER_INTERVAL = 2min;
 /** Run the extra block-relay-only connection loop once every 5 minutes. **/
 static constexpr auto EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL = 5min;
-/** Maximum length of incoming protocol messages (no message over 12 MB is currently acceptable). */
-static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 12 * 1000 * 1000;
+/**
+ * Maximum length of incoming protocol messages (no message over 32 MiB is
+ * currently acceptable).  Bitcoin has 4 MiB here, but we need more space
+ * to allow for 2,000 block headers with auxpow.
+ */
+/* FIXME: Once the headers size limit is deployed sufficiently in the network,
+   we may want to lower this again if it seems useful.  */
+static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 32 * 1024 * 1024;
 /** Maximum length of the user agent string in `version` message */
 static const unsigned int MAX_SUBVERSION_LENGTH = 256;
 /** Maximum number of automatic outgoing nodes over which we'll relay everything (blocks, tx, addrs, etc) */
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 856659a5..a9eba6b3 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -98,8 +98,25 @@ static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16;
 /** Time during which a peer must stall block download progress before being disconnected. */
 static constexpr auto BLOCK_STALLING_TIMEOUT = 2s;
 /** Number of headers sent in one getheaders result. We rely on the assumption that if a peer sends
- *  less than this number, we reached its tip. Changing this value is a protocol upgrade. */
+ *  less than this number, we reached its tip. Changing this value is a protocol upgrade.
+ *
+ *  With a protocol upgrade, we now enforce an additional restriction on the
+ *  total size of a "headers" message (see below).  The absolute limit
+ *  on the number of headers still applies as well, so that we do not get
+ *  overloaded both with small and large headers.
+ */
 static const unsigned int MAX_HEADERS_RESULTS = 2000;
+// DEVCOIN
+/** Maximum size of a "headers" message.  This is enforced starting with
+ *  SIZE_HEADERS_LIMIT_VERSION peers and prevents overloading if we have
+ *  very large headers (due to auxpow).
+ */
+static const unsigned int MAX_HEADERS_SIZE = (6 << 20); // 6 MiB
+/** Size of a headers message that is the threshold for assuming that the
+ *  peer has more headers (even if we have less than MAX_HEADERS_RESULTS).
+ *  This is used starting with SIZE_HEADERS_LIMIT_VERSION peers.
+ */
+static const unsigned int THRESHOLD_HEADERS_SIZE = (4 << 20); // 4 MiB
 /** Maximum depth of blocks we're willing to serve as compact blocks to peers
  *  when requested. For older blocks, a regular BLOCK response will be sent. */
 static const int MAX_CMPCTBLOCK_DEPTH = 5;
@@ -162,13 +179,7 @@ static constexpr double MAX_ADDR_RATE_PER_SECOND{0.1};
  *  based increments won't go above this, but the MAX_ADDR_TO_SEND increment following GETADDR
  *  is exempt from this limit. */
 static constexpr size_t MAX_ADDR_PROCESSING_TOKEN_BUCKET{MAX_ADDR_TO_SEND};
-// DEVCOIN
-static const unsigned int MAX_HEADERS_SIZE = (6 << 20); // 6 MiB
-/** Size of a headers message that is the threshold for assuming that the
- *  peer has more headers (even if we have less than MAX_HEADERS_RESULTS).
- *  This is used starting with SIZE_HEADERS_LIMIT_VERSION peers.
- */
-static const unsigned int THRESHOLD_HEADERS_SIZE = (4 << 20); // 4 MiB
+
 // Internal stuff
 namespace {
 /** Blocks that are in flight, and that are in the queue to be downloaded. */
@@ -2013,6 +2024,17 @@ void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
         return;
     }
 
+    size_t nSize = 0;
+    for (const auto& header : headers) {
+        nSize += GetSerializeSize(header, PROTOCOL_VERSION);
+        if (pfrom.nVersion >= SIZE_HEADERS_LIMIT_VERSION
+              && nSize > MAX_HEADERS_SIZE) {
+            LOCK(cs_main);
+            Misbehaving(pfrom.GetId(), 20, strprintf("headers message size = %u", nSize));
+            return;
+        }
+    }
+
     bool received_new_header = false;
     const CBlockIndex *pindexLast = nullptr;
     {
@@ -2089,7 +2111,14 @@ void PeerManagerImpl::ProcessHeadersMessage(CNode& pfrom, const Peer& peer,
             nodestate->m_last_block_announcement = GetTime();
         }
 
-        if (nCount == MAX_HEADERS_RESULTS) {
+        bool maxSize = (nCount == MAX_HEADERS_RESULTS);
+        if (pfrom.nVersion >= SIZE_HEADERS_LIMIT_VERSION
+              && nSize >= THRESHOLD_HEADERS_SIZE)
+            maxSize = true;
+        // FIXME: This change (with hasNewHeaders) is rolled back in Bitcoin,
+        // but I think it should stay here for merge-mined coins.  Try to get
+        // it fixed again upstream and then update the fix.
+        if (maxSize && received_new_header) {
             // Headers message had its maximum size; the peer may have more headers.
             // TODO: optimize: if pindexLast is an ancestor of m_chainman.ActiveChain().Tip or pindexBestHeader, continue
             // from there instead.
@@ -3143,12 +3172,13 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
             nSize += GetSerializeSize(header, PROTOCOL_VERSION);
             vHeaders.push_back(header);
             if (nCount >= MAX_HEADERS_RESULTS
-                    || pindex->GetBlockHash() == hashStop)
+                  || pindex->GetBlockHash() == hashStop)
                 break;
             if (pfrom.nVersion >= SIZE_HEADERS_LIMIT_VERSION
-                    && nSize >= THRESHOLD_HEADERS_SIZE)
+                  && nSize >= THRESHOLD_HEADERS_SIZE)
                 break;
         }
+
         /* Check maximum headers size before pushing the message
            if the peer enforces it.  This should not fail since we
            break above in the loop at the threshold and the threshold
@@ -3160,8 +3190,8 @@ void PeerManagerImpl::ProcessMessage(CNode& pfrom, const std::string& msg_type,
         else
         {
             LogPrint(BCLog::NET, "pushing %u headers, %u bytes\n", nCount, nSize);
-            // pindex can be nullptr either if we sent m_chainman.ActiveChain().Tip() OR
-            // if our peer has m_chainman.ActiveChain().Tip() (and thus we are sending an empty
+            // pindex can be nullptr either if we sent ::ChainActive().Tip() OR
+            // if our peer has ::ChainActive().Tip() (and thus we are sending an empty
             // headers message). In both cases it's safe to update
             // pindexBestHeaderSent to be our tip.
             //
diff --git a/src/pow.cpp b/src/pow.cpp
index f3f84ad5..b69800f2 100644
--- a/src/pow.cpp
+++ b/src/pow.cpp
@@ -10,7 +10,7 @@
 #include <primitives/block.h>
 #include <uint256.h>
 
-unsigned int GetNextWorkRequired_Original(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
+unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
 {
     assert(pindexLast != nullptr);
     unsigned int nProofOfWorkLimit = UintToArith256(params.powLimit).GetCompact();
@@ -18,8 +18,16 @@ unsigned int GetNextWorkRequired_Original(const CBlockIndex* pindexLast, const C
     // Only change once per difficulty adjustment interval
     if ((pindexLast->nHeight+1) % params.DifficultyAdjustmentInterval() != 0)
     {
-        if (params.fPowAllowMinDifficultyBlocks)
+        if (params.AllowMinDifficultyBlocks(pblock->GetBlockTime()))
         {
+            /* khal's port of this code from Bitcoin to the old namecoind
+               has a bug:  Comparison of block times is done by an unsigned
+               difference.  Consequently, the minimum difficulty is also
+               applied if the block's timestamp is earlier than the preceding
+               block's.  Reproduce this.  */
+            if (pblock->GetBlockTime() < pindexLast->GetBlockTime())
+                return nProofOfWorkLimit;
+
             // Special difficulty rule for testnet:
             // If the new block's timestamp is more than 2* 10 minutes
             // then allow mining of a min-difficulty block.
@@ -37,8 +45,15 @@ unsigned int GetNextWorkRequired_Original(const CBlockIndex* pindexLast, const C
         return pindexLast->nBits;
     }
 
+    /* Adapt the retargeting interval after merge-mining start
+       according to the changed Devcoin rules.  */
+    int nBlocksBack = params.DifficultyAdjustmentInterval() - 1;
+    if (pindexLast->nHeight >= params.nAuxpowStartHeight
+        && (pindexLast->nHeight + 1 > params.DifficultyAdjustmentInterval()))
+        nBlocksBack = params.DifficultyAdjustmentInterval();
+
     // Go back by what we want to be 14 days worth of blocks
-    int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval()-1);
+    int nHeightFirst = pindexLast->nHeight - nBlocksBack;
     assert(nHeightFirst >= 0);
     const CBlockIndex* pindexFirst = pindexLast->GetAncestor(nHeightFirst);
     assert(pindexFirst);
@@ -48,17 +63,15 @@ unsigned int GetNextWorkRequired_Original(const CBlockIndex* pindexLast, const C
 
 unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
 {
-    int64_t nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
-
     if (params.fPowNoRetargeting)
         return pindexLast->nBits;
 
     // Limit adjustment step
     int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
-    if (nActualTimespan < nPowTargetTimespan/4)
-        nActualTimespan = nPowTargetTimespan/4;
-    if (nActualTimespan > nPowTargetTimespan*4)
-        nActualTimespan = nPowTargetTimespan*4;
+    if (nActualTimespan < params.nPowTargetTimespan/4)
+        nActualTimespan = params.nPowTargetTimespan/4;
+    if (nActualTimespan > params.nPowTargetTimespan*4)
+        nActualTimespan = params.nPowTargetTimespan*4;
 
     // Retarget
     const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
@@ -183,7 +196,7 @@ unsigned int GetNextWorkRequired_Old(const CBlockIndex* pindexLast, const CBlock
     return bnNew.GetCompact();
 }
 
-unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
+unsigned int GetNextWorkRequired_New(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
 {
     return GetNextWorkRequired_Old(pindexLast, pblock, params);
 }
diff --git a/src/primitives/block.h b/src/primitives/block.h
index bd6a892d..799600e2 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -23,6 +23,7 @@
 class CBlockHeader : public CPureBlockHeader
 {
 public:
+
     // auxpow (if this is a merge-minded block)
     std::shared_ptr<CAuxPow> auxpow;
 
@@ -31,27 +32,18 @@ class CBlockHeader : public CPureBlockHeader
         SetNull();
     }
 
-    template<typename Stream>
-    void Serialize(Stream& s) const
+    SERIALIZE_METHODS(CBlockHeader, obj)
     {
-        s << *(CPureBlockHeader*)this;
-        if (this->IsAuxpow())
+        READWRITEAS(CPureBlockHeader, obj);
+
+        if (obj.IsAuxpow())
         {
-            assert(auxpow != nullptr);
-            s << *auxpow;
-        }
-    }
-    template<typename Stream>
-    void Unserialize(Stream& s)
-    {
-        s >> *(CPureBlockHeader*)this;
-        if (this->IsAuxpow())
+            SER_READ(obj, obj.auxpow = std::make_shared<CAuxPow>());
+            assert(obj.auxpow != nullptr);
+            READWRITE(*obj.auxpow);
+        } else
         {
-            auxpow = std::make_shared<CAuxPow>();
-            assert(auxpow != nullptr);
-            s >> *auxpow;
-        } else {
-            auxpow.reset();
+            SER_READ(obj, obj.auxpow.reset());
         }
     }
 
diff --git a/src/primitives/pureheader.cpp b/src/primitives/pureheader.cpp
index ef0e37e4..563720a3 100644
--- a/src/primitives/pureheader.cpp
+++ b/src/primitives/pureheader.cpp
@@ -1,52 +1,26 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2014 The Syscoin and Devcoin Core developers
+// Copyright (c) 2009-2014 The Bitcoin Core and Devcoin Core 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 <hash.h>
+#include <util/strencodings.h>
+
 uint256 CPureBlockHeader::GetHash() const
 {
     return SerializeHash(*this);
 }
 
-void CPureBlockHeader::SetBaseVersion(int32_t nBaseVersion, const int32_t &nChainId)
+void CPureBlockHeader::SetBaseVersion(int32_t nBaseVersion, int32_t nChainId)
 {
-    const int32_t withoutTopMask = nBaseVersion & ~VERSIONAUXPOW_TOP_MASK;
-    assert(withoutTopMask >= 0 && withoutTopMask < VERSION_CHAIN_START);
+    assert(nBaseVersion >= 1 && nBaseVersion < VERSION_AUXPOW);
     assert(!IsAuxpow());
-    nVersion = nBaseVersion | (nChainId << VERSION_START_BIT);
-}
-
-void CPureBlockHeader::SetOldBaseVersion(int32_t nBaseVersion, const int32_t &nChainId)
-{
-    assert(nBaseVersion >= 1 && nBaseVersion < VERSION_CHAIN_START);
-    assert(!IsAuxpow());
-    nVersion = nBaseVersion | (nChainId << VERSION_START_BIT);
-}
-
-int32_t CPureBlockHeader::GetBaseVersion(const int32_t &ver) 
-{
-    // remove AuxPow flag and Chain ID
-    return (ver & ~VERSION_AUXPOW) & ~VERSION_AUXPOW_CHAINID_SHIFTED;
-}
-
-int32_t CPureBlockHeader::GetOldBaseVersion(const int32_t &ver)
-{
-    
-    return (ver & ~VERSION_AUXPOW) & ~VERSION_OLD_AUXPOW_CHAINID_SHIFTED;
-}
-
-int32_t CPureBlockHeader::GetChainId(const int32_t &ver)
-{
-    // if auxpow is set then mask with Chain ID and shift back VERSION_START_BIT to get the real value
-    if((ver & VERSION_AUXPOW) > 0)
-        return (ver & MASK_AUXPOW_CHAINID_SHIFTED) >> VERSION_START_BIT;
-    else
-        return 0;
+    nVersion = nBaseVersion | (nChainId * VERSION_CHAIN_START);
 }
 
-int32_t CPureBlockHeader::GetOldChainId(const int32_t &ver) 
+int32_t CPureBlockHeader::GetOldChainId(const int32_t &ver)
 {
     if((ver & VERSION_AUXPOW) > 0)
         return (ver & MASK_OLD_AUXPOW_CHAINID_SHIFTED) >> VERSION_START_BIT;
diff --git a/src/primitives/pureheader.h b/src/primitives/pureheader.h
index 3ed76152..4a221d65 100644
--- a/src/primitives/pureheader.h
+++ b/src/primitives/pureheader.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2013 The Syscoin and Devcoin Core developers
+// Copyright (c) 2009-2013 The Bitcoin Core and Devcoin Core developers
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -8,6 +8,7 @@
 
 #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
@@ -17,25 +18,16 @@
  */
 class CPureBlockHeader
 {
-public:
-    static const uint32_t CHAINID = 4; // should match params.nAuxpowChainId
-    static const uint32_t OLD_CHAINID = 4096; // should match params.nAuxpowOldChainId
 private:
-    /* Mask for dummy bit and versionbits top mask.  */
-    static const int32_t VERSIONAUXPOW_TOP_MASK = (1 << 28) + (1 << 29) + (1 << 30);
+
     /* Modifiers to the version.  */
     static const int32_t VERSION_AUXPOW = (1 << 8);
     static const uint8_t VERSION_START_BIT = 16;
+
     /** Bits above are reserved for the auxpow chain ID.  */
-    static const int32_t VERSION_CHAIN_START = (1 << VERSION_START_BIT);
-    // mask to get Chain ID from version field, chainid is 16 in SYS so 0x001f mask should be OK
-    static const int32_t MASK_AUXPOW_CHAINID_SHIFTED = (0x001f << VERSION_START_BIT);
     // mask to get old Chain ID from version field, legacy one is 4096 (2^12) in SYS so 0x1fff mask is needed
     static const int32_t MASK_OLD_AUXPOW_CHAINID_SHIFTED = (0x1fff << VERSION_START_BIT);
-    // shifted Chain ID in version field
-    static const int32_t VERSION_AUXPOW_CHAINID_SHIFTED = (CHAINID << VERSION_START_BIT);
-    // shifted legaacy Chain ID, 4096 shifted by VERSION_START_BIT
-    static const int32_t VERSION_OLD_AUXPOW_CHAINID_SHIFTED = (OLD_CHAINID << VERSION_START_BIT); 
+    static const int32_t VERSION_CHAIN_START = (1 << 16);
 
 public:
     // header
@@ -89,16 +81,11 @@ class CPureBlockHeader
     {
         return GetBaseVersion(nVersion);
     }
-    inline int32_t GetOldBaseVersion() const
+    static inline int32_t GetBaseVersion(int32_t ver)
     {
-        return GetOldBaseVersion(nVersion);
+        return ver % VERSION_AUXPOW;
     }
-    static int32_t GetBaseVersion(const int32_t &ver);
-    static int32_t GetOldBaseVersion(const int32_t &ver);
 
-    static inline bool IsValidBaseVersion(const int32_t &nBaseVersion) {
-        return (nBaseVersion & ~VERSIONAUXPOW_TOP_MASK) < VERSION_CHAIN_START;
-    }
     /**
      * 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
@@ -106,24 +93,17 @@ class CPureBlockHeader
      * @param nBaseVersion The base version.
      * @param nChainId The auxpow chain ID.
      */
-    void SetBaseVersion(int32_t nBaseVersion, const int32_t &nChainId);
-    /**
-     * Set the legacy 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 SetOldBaseVersion(int32_t nBaseVersion, const int32_t &nChainId);
+    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 GetChainId(nVersion);
+        return nVersion / VERSION_CHAIN_START;
     }
-    static int32_t GetChainId(const int32_t &ver);
+
     /**
      * Extract the legacy chain ID.
      * @return The chain ID encoded in the version before versionbits were fixed to work with auxpow
@@ -133,11 +113,11 @@ class CPureBlockHeader
         return GetOldChainId(nVersion);
     }
     static int32_t GetOldChainId(const int& ver);
+
     /**
      * Set the chain ID.  This is used for the test suite.
-     * @param chainId The chain ID to set.
      */
-    inline void SetChainId(const int32_t &chainId)
+    inline void SetChainId(int32_t chainId)
     {
         nVersion %= VERSION_CHAIN_START;
         nVersion |= chainId * VERSION_CHAIN_START;
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index f036b3aa..096302e4 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -27,6 +27,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>
@@ -41,6 +42,7 @@
 #include <validation.h>
 #include <validationinterface.h>
 #include <versionbits.h>
+#include <wallet/context.h>
 #include <warnings.h>
 
 #include <stdint.h>
@@ -63,6 +65,12 @@ static CUpdatedBlock latestblock GUARDED_BY(cs_blockchange);
 
 NodeContext& EnsureAnyNodeContext(const std::any& context)
 {
+    auto wallet_context = util::AnyPtr<WalletContext>(context);
+    if (wallet_context) {
+        if (wallet_context->nodeContext != nullptr)
+            return *wallet_context->nodeContext;
+    }
+
     auto node_context = util::AnyPtr<NodeContext>(context);
     if (!node_context) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Node context not found");
@@ -111,13 +119,14 @@ CBlockPolicyEstimator& EnsureAnyFeeEstimator(const std::any& context)
 
 /* Calculate the difficulty for a given block index.
  */
-double GetDifficulty(const CBlockIndex* blockindex)
+double GetDifficultyForBits(const uint32_t nBits)
 {
-    CHECK_NONFATAL(blockindex);
+    const uint32_t mantissa = nBits & 0x00ffffff;
+    if (mantissa == 0)
+        return 0.0;
 
-    int nShift = (blockindex->nBits >> 24) & 0xff;
-    double dDiff =
-        (double)0x0000ffff / (double)(blockindex->nBits & 0x00ffffff);
+    int nShift = (nBits >> 24) & 0xff;
+    double dDiff = (double)0x0000ffff / (double)mantissa;
 
     while (nShift < 29)
     {
@@ -170,25 +179,38 @@ CBlockIndex* ParseHashOrHeight(const UniValue& param, ChainstateManager& chainma
     }
 }
 
+/** Converts the base data, excluding any contextual information,
+ * in a block header to JSON.  */
+static UniValue blockheaderToJSON(const CPureBlockHeader& header)
+{
+    UniValue result(UniValue::VOBJ);
+    result.pushKV("hash", header.GetHash().GetHex());
+    result.pushKV("version", header.nVersion);
+    result.pushKV("versionHex", strprintf("%08x", header.nVersion));
+    result.pushKV("merkleroot", header.hashMerkleRoot.GetHex());
+    result.pushKV("time", (int64_t)header.nTime);
+    result.pushKV("nonce", (uint64_t)header.nNonce);
+    result.pushKV("bits", strprintf("%08x", header.nBits));
+    result.pushKV("difficulty", GetDifficultyForBits(header.nBits));
+
+    if (!header.hashPrevBlock.IsNull())
+        result.pushKV("previousblockhash", header.hashPrevBlock.GetHex());
+
+    return result;
+}
+
 UniValue blockheaderToJSON(const CBlockIndex* tip, const CBlockIndex* blockindex)
 {
     // Serialize passed information without accessing chain state of the active chain!
     AssertLockNotHeld(cs_main); // For performance reasons
 
-    UniValue result(UniValue::VOBJ);
-    result.pushKV("hash", blockindex->GetBlockHash().GetHex());
+    auto result = blockheaderToJSON(blockindex->GetBlockHeader(Params().GetConsensus()));
+
     const CBlockIndex* pnext;
     int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);
     result.pushKV("confirmations", confirmations);
     result.pushKV("height", blockindex->nHeight);
-    result.pushKV("version", blockindex->nVersion);
-    result.pushKV("versionHex", strprintf("%08x", blockindex->nVersion));
-    result.pushKV("merkleroot", blockindex->hashMerkleRoot.GetHex());
-    result.pushKV("time", (int64_t)blockindex->nTime);
     result.pushKV("mediantime", (int64_t)blockindex->GetMedianTimePast());
-    result.pushKV("nonce", (uint64_t)blockindex->nNonce);
-    result.pushKV("bits", strprintf("%08x", blockindex->nBits));
-    result.pushKV("difficulty", GetDifficulty(blockindex));
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
     result.pushKV("nTx", (uint64_t)blockindex->nTx);
 
@@ -228,6 +250,46 @@ UniValue blockToJSON(const CBlock& block, const CBlockIndex* tip, const CBlockIn
     return result;
 }
 
+UniValue AuxpowToJSON(const CAuxPow& auxpow, const bool verbose, CChainState& active_chainstate)
+{
+    UniValue result(UniValue::VOBJ);
+
+    {
+        UniValue tx(UniValue::VOBJ);
+        tx.pushKV("hex", EncodeHexTx(*auxpow.coinbaseTx));
+        TxToJSON(*auxpow.coinbaseTx, auxpow.parentBlock.GetHash(), tx, active_chainstate);
+        result.pushKV("tx", tx);
+    }
+
+    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);
+    }
+
+    if (verbose)
+        result.pushKV("parentblock", blockheaderToJSON(auxpow.parentBlock));
+    else
+    {
+        CDataStream ssParent(SER_NETWORK, PROTOCOL_VERSION);
+        ssParent << auxpow.parentBlock;
+        const std::string strHex = HexStr(ssParent);
+        result.pushKV("parentblock", strHex);
+    }
+
+    return result;
+}
+
 static RPCHelpMan getblockcount()
 {
     return RPCHelpMan{"getblockcount",
@@ -446,7 +508,7 @@ static RPCHelpMan getdifficulty()
 {
     ChainstateManager& chainman = EnsureAnyChainman(request.context);
     LOCK(cs_main);
-    return GetDifficulty(chainman.ActiveChain().Tip());
+    return GetDifficultyForBits(chainman.ActiveChain().Tip()->nBits);
 },
     };
 }
@@ -868,10 +930,11 @@ static RPCHelpMan getblockheader()
     if (!request.params[1].isNull())
         fVerbose = request.params[1].get_bool();
 
+    ChainstateManager& chainman = EnsureAnyChainman(request.context);
+
     const CBlockIndex* pblockindex;
     const CBlockIndex* tip;
     {
-        ChainstateManager& chainman = EnsureAnyChainman(request.context);
         LOCK(cs_main);
         pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
         tip = chainman.ActiveChain().Tip();
@@ -881,14 +944,20 @@ static RPCHelpMan getblockheader()
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
     }
 
+    const auto header = pblockindex->GetBlockHeader(Params().GetConsensus());
+
     if (!fVerbose)
     {
         CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
-        ssBlock << pblockindex->GetBlockHeader(Params().GetConsensus());
+        ssBlock << header;
         std::string strHex = HexStr(ssBlock);
         return strHex;
     }
 
+    auto result = blockheaderToJSON(tip, pblockindex);
+    if (header.auxpow)
+        result.pushKV("auxpow", AuxpowToJSON(*header.auxpow, fVerbose, chainman.ActiveChainstate()));
+
     return blockheaderToJSON(tip, pblockindex);
 },
     };
@@ -961,6 +1030,18 @@ static RPCHelpMan getblock()
                     {RPCResult::Type::NUM, "nTx", "The number of transactions in the block"},
                     {RPCResult::Type::STR_HEX, "previousblockhash", /* optional */ true, "The hash of the previous block (if available)"},
                     {RPCResult::Type::STR_HEX, "nextblockhash", /* optional */ true, "The hash of the next block (if available)"},
+                    {RPCResult::Type::OBJ, "auxpow", "The auxpow object attached to this block",
+                        {
+                            {RPCResult::Type::OBJ, "tx", "The parent chain coinbase tx of this auxpow",
+                                {{RPCResult::Type::ELISION, "", "Same format as for decoded raw transactions"}}},
+                            {RPCResult::Type::NUM, "index", "Merkle index of the parent coinbase"},
+                            {RPCResult::Type::ARR, "merklebranch", "Merkle branch of the parent coinbase",
+                                {{RPCResult::Type::STR_HEX, "", "The Merkle branch hash"}}},
+                            {RPCResult::Type::NUM, "chainindex", "Index in the auxpow Merkle tree"},
+                            {RPCResult::Type::ARR, "chainmerklebranch", "Branch in the auxpow Merkle tree",
+                                {{RPCResult::Type::STR_HEX, "", "The Merkle branch hash"}}},
+                            {RPCResult::Type::STR_HEX, "parentblock", "The parent block serialised as hex string"},
+                        }},
                 }},
                     RPCResult{"for verbosity = 2",
                 RPCResult::Type::OBJ, "", "",
@@ -993,11 +1074,12 @@ static RPCHelpMan getblock()
         }
     }
 
+    ChainstateManager& chainman = EnsureAnyChainman(request.context);
+
     CBlock block;
     const CBlockIndex* pblockindex;
     const CBlockIndex* tip;
     {
-        ChainstateManager& chainman = EnsureAnyChainman(request.context);
         LOCK(cs_main);
         pblockindex = chainman.m_blockman.LookupBlockIndex(hash);
         tip = chainman.ActiveChain().Tip();
@@ -1017,7 +1099,12 @@ static RPCHelpMan getblock()
         return strHex;
     }
 
-    return blockToJSON(block, tip, pblockindex, verbosity >= 2);
+    auto result = blockToJSON(block, tip, pblockindex, verbosity >= 2);
+
+    if (block.auxpow)
+        result.pushKV("auxpow", AuxpowToJSON(*block.auxpow, verbosity >= 1, chainman.ActiveChainstate()));
+
+    return result;
 },
     };
 }
@@ -1364,6 +1451,9 @@ static void SoftForkDescPushBack(const CBlockIndex* active_chain_tip, UniValue&
 
 static void SoftForkDescPushBack(const CBlockIndex* active_chain_tip, UniValue& softforks, const Consensus::Params& consensusParams, Consensus::DeploymentPos id)
 {
+    // FIXME: For now, BIP9 is not used until we can do always-auxpow.
+    return;
+
     // For BIP9 deployments.
 
     if (!DeploymentEnabled(consensusParams, id)) return;
@@ -1477,7 +1567,7 @@ RPCHelpMan getblockchaininfo()
     obj.pushKV("blocks",                height);
     obj.pushKV("headers",               pindexBestHeader ? pindexBestHeader->nHeight : -1);
     obj.pushKV("bestblockhash",         tip->GetBlockHash().GetHex());
-    obj.pushKV("difficulty",            (double)GetDifficulty(tip));
+    obj.pushKV("difficulty",            (double)GetDifficultyForBits(tip->nBits));
     obj.pushKV("mediantime",            (int64_t)tip->GetMedianTimePast());
     obj.pushKV("verificationprogress",  GuessVerificationProgress(Params().TxData(), tip));
     obj.pushKV("initialblockdownload",  active_chainstate.IsInitialBlockDownload());
@@ -1504,6 +1594,7 @@ RPCHelpMan getblockchaininfo()
     const Consensus::Params& consensusParams = Params().GetConsensus();
     UniValue softforks(UniValue::VOBJ);
     SoftForkDescPushBack(tip, softforks, consensusParams, Consensus::DEPLOYMENT_HEIGHTINCB);
+    SoftForkDescPushBack(tip, softforks, consensusParams, Consensus::DEPLOYMENT_P2SH);
     SoftForkDescPushBack(tip, softforks, consensusParams, Consensus::DEPLOYMENT_DERSIG);
     SoftForkDescPushBack(tip, softforks, consensusParams, Consensus::DEPLOYMENT_CLTV);
     SoftForkDescPushBack(tip, softforks, consensusParams, Consensus::DEPLOYMENT_CSV);
diff --git a/src/rpc/blockchain.h b/src/rpc/blockchain.h
index 59066981..f7350bc2 100644
--- a/src/rpc/blockchain.h
+++ b/src/rpc/blockchain.h
@@ -28,12 +28,12 @@ struct NodeContext;
 static constexpr int NUM_GETBLOCKSTATS_PERCENTILES = 5;
 
 /**
- * Get the difficulty of the net wrt to the given block index.
+ * Get the difficulty of the net wrt to the given bits.
  *
  * @return A floating point number that is a multiple of the main net minimum
  * difficulty (4295032833 hashes).
  */
-double GetDifficulty(const CBlockIndex* blockindex);
+double GetDifficultyForBits(uint32_t nBits);
 
 /** Callback for when block tip changed. */
 void RPCNotifyBlockChange(const CBlockIndex*);
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index fd21540e..c43dc77b 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -119,21 +119,20 @@ static bool GenerateBlock(ChainstateManager& chainman, CBlock& block, uint64_t&
         IncrementExtraNonce(&block, chainman.ActiveChain().Tip(), extra_nonce);
     }
 
-    CChainParams chainparams(Params());
-
-    while (max_tries > 0 && block.nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(block.GetHash(), 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.GetHash(), 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");
     }
 
@@ -359,7 +358,6 @@ static RPCHelpMan generateblock()
         }
     }
 
-    CChainParams chainparams(Params());
     CBlock block;
 
     ChainstateManager& chainman = EnsureChainman(node);
@@ -367,7 +365,7 @@ static RPCHelpMan generateblock()
         LOCK(cs_main);
 
         CTxMemPool empty_mempool;
-        std::unique_ptr<CBlockTemplate> blocktemplate(BlockAssembler(chainman.ActiveChainstate(), empty_mempool, chainparams).CreateNewBlock(coinbase_script));
+        std::unique_ptr<CBlockTemplate> blocktemplate(BlockAssembler(chainman.ActiveChainstate(), empty_mempool, Params()).CreateNewBlock(coinbase_script));
         if (!blocktemplate) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
         }
@@ -384,7 +382,7 @@ static RPCHelpMan generateblock()
         LOCK(cs_main);
 
         BlockValidationState state;
-        if (!TestBlockValidity(state, chainparams, chainman.ActiveChainstate(), block, chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock), false, false)) {
+        if (!TestBlockValidity(state, Params(), chainman.ActiveChainstate(), block, chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock), false, false)) {
             throw JSONRPCError(RPC_VERIFY_ERROR, strprintf("TestBlockValidity failed: %s", state.ToString()));
         }
     }
@@ -437,7 +435,7 @@ static RPCHelpMan getmininginfo()
     obj.pushKV("blocks",           active_chain.Height());
     if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight);
     if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
-    obj.pushKV("difficulty",       (double)GetDifficulty(active_chain.Tip()));
+    obj.pushKV("difficulty",       (double)GetDifficultyForBits(active_chain.Tip()->nBits));
     obj.pushKV("networkhashps",    getnetworkhashps().HandleRequest(request));
     obj.pushKV("pooledtx",         (uint64_t)mempool.size());
     obj.pushKV("chain",            Params().NetworkIDString());
@@ -1246,6 +1244,7 @@ static RPCHelpMan estimaterawfee()
 },
     };
 }
+
 /* ************************************************************************** */
 /* Merge mining.  */
 
@@ -1315,8 +1314,7 @@ static RPCHelpMan submitauxblock()
     };
 }
 
-
- /* ************************************************************************** */
+/* ************************************************************************** */
 
 void RegisterMiningRPCCommands(CRPCTable &t)
 {
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index a17894e7..97b3cbf9 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -42,7 +42,7 @@
 
 #include <univalue.h>
 
-static void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry, CChainState& active_chainstate)
+void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry, CChainState& active_chainstate)
 {
     // Call into TxToUniv() in devcoin-common to decode the transaction hex.
     //
diff --git a/src/rpc/rawtransaction.h b/src/rpc/rawtransaction.h
new file mode 100644
index 00000000..cafb8e16
--- /dev/null
+++ b/src/rpc/rawtransaction.h
@@ -0,0 +1,14 @@
+// Copyright (c) 2017-2022 The Bitcoin Core and Devcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef DEVCOIN_RPC_RAWTRANSACTION_H
+#define DEVCOIN_RPC_RAWTRANSACTION_H
+
+class CTransaction;
+class UniValue;
+class uint256;
+
+void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry, CChainState& active_chainstate);
+
+#endif // DEVCOIN_RPC_RAWTRANSACTION_H
diff --git a/src/script/script.h b/src/script/script.h
index 9d9424cb..84a7c5ea 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -55,6 +55,8 @@ static constexpr uint64_t VALIDATION_WEIGHT_PER_SIGOP_PASSED = 50;
 // How much weight budget is added to the witness size (Tapscript only, see BIP 342).
 static constexpr uint64_t VALIDATION_WEIGHT_OFFSET = 50;
 
+using valtype = std::vector<unsigned char>;
+
 template <typename T>
 std::vector<unsigned char> ToByteVector(const T& in)
 {
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 2a0b6da3..9a5e2cab 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -303,6 +303,7 @@ bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams,
                    the CDiskBlockIndex does not contain the auxpow.
                    This check isn't important, since the data on disk should
                    already be valid and can be trusted.  */
+
                 pcursor->Next();
             } else {
                 return error("%s: failed to read value", __func__);
diff --git a/src/validation.cpp b/src/validation.cpp
index d1d0d8ff..9bb569c1 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -657,8 +657,8 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         if (!m_view.HaveCoin(txin.prevout)) {
             // Are inputs missing because we already have the tx?
             for (size_t out = 0; out < tx.vout.size(); out++) {
-                // Optimistically just do efficient check of cache for outputs
-                if (coins_cache.HaveCoinInCache(COutPoint(hash, out))) {
+                // See if we have any output in the UTXO set.
+                if (coins_cache.HaveCoin(COutPoint(hash, out))) {
                     return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-known");
                 }
             }
@@ -779,7 +779,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         // being able to broadcast descendants of an unconfirmed transaction
         // to be secure by simply only having two immediately-spendable
         // outputs - one for each counterparty. For more info on the uses for
-        // this, see https://lists.linuxfoundation.org/pipermail/devcoin-dev/2018-November/016518.html
+        // this, see https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2018-November/016518.html
         if (nSize >  EXTRA_DESCENDANT_TX_SIZE_LIMIT ||
                 !m_pool.CalculateMemPoolAncestors(*entry, setAncestors, 2, m_limit_ancestor_size, m_limit_descendants + 1, m_limit_descendant_size + EXTRA_DESCENDANT_TX_SIZE_LIMIT, dummy_err_string)) {
             return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", errString);
@@ -1160,10 +1160,38 @@ PackageMempoolAcceptResult ProcessNewPackage(CChainState& active_chainstate, CTx
     return result;
 }
 
+CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock)
+{
+    LOCK(cs_main);
+
+    if (block_index) {
+        CBlock block;
+        if (ReadBlockFromDisk(block, block_index, consensusParams)) {
+            for (const auto& tx : block.vtx) {
+                if (tx->GetHash() == hash) {
+                    hashBlock = block_index->GetBlockHash();
+                    return tx;
+                }
+            }
+        }
+        return nullptr;
+    }
+    if (mempool) {
+        CTransactionRef ptx = mempool->get(hash);
+        if (ptx) return ptx;
+    }
+    if (g_txindex) {
+        CTransactionRef tx;
+        if (g_txindex->FindTx(hash, hashBlock, tx)) return tx;
+    }
+    return nullptr;
+}
+
 //////////////////////////////////////////////////////////////////////////////
 //
 // CBlock and CBlockIndex
 //
+
 bool CheckProofOfWork(const CBlockHeader& block, const Consensus::Params& params)
 {
     /* Except for legacy blocks with full version 1, ensure that
@@ -1202,9 +1230,16 @@ bool CheckProofOfWork(const CBlockHeader& block, const Consensus::Params& params
     }
 
     /* We have auxpow.  Check it.  */
+
     if (!block.IsAuxpow())
         return error("%s : auxpow on block with non-auxpow version", __func__);
 
+    /* Temporary check:  Disallow parent blocks with auxpow version.  This is
+       for compatibility with the old client.  */
+    /* FIXME: Remove this check with a hardfork later on.  */
+    if (block.auxpow->getParentBlock().IsAuxpow())
+        return error("%s : auxpow parent block has auxpow version", __func__);
+
     if (!CheckProofOfWork(block.auxpow->getParentBlockHash(), block.nBits, params))
         return error("%s : AUX proof of work failed", __func__);
     if (!block.auxpow->check(block.GetHash(), block.GetChainId(), params))
@@ -1213,33 +1248,6 @@ bool CheckProofOfWork(const CBlockHeader& block, const Consensus::Params& params
     return true;
 }
 
-CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock)
-{
-    LOCK(cs_main);
-
-    if (block_index) {
-        CBlock block;
-        if (ReadBlockFromDisk(block, block_index, consensusParams)) {
-            for (const auto& tx : block.vtx) {
-                if (tx->GetHash() == hash) {
-                    hashBlock = block_index->GetBlockHash();
-                    return tx;
-                }
-            }
-        }
-        return nullptr;
-    }
-    if (mempool) {
-        CTransactionRef ptx = mempool->get(hash);
-        if (ptx) return ptx;
-    }
-    if (g_txindex) {
-        CTransactionRef tx;
-        if (g_txindex->FindTx(hash, hashBlock, tx)) return tx;
-    }
-    return nullptr;
-}
-
 CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)
 {
     CAmount nSubsidy;
@@ -1694,9 +1702,7 @@ static unsigned int GetBlockScriptFlags(const CBlockIndex* pindex, const Consens
     // retroactively applied to their testnet)
     // However, no Devcoin historical block violated the P2SH rules (on both
     // mainnet and testnet), so for simplicity, always leave P2SH on
-    if (consensusparams.BIP16Exception.IsNull() || // no bip16 exception on this chain
-        pindex->phashBlock == nullptr) // this is a new candidate block, eg from TestBlockValidity()
-    {
+    if (DeploymentActiveAt(*pindex, consensusparams, Consensus::DEPLOYMENT_P2SH)) {
         flags |= SCRIPT_VERIFY_P2SH;
     }
 
@@ -1835,79 +1841,15 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
     // See BIP30, CVE-2012-1909, and http://r6.ca/blog/20120206T005236Z.html for more information.
     // This logic is not necessary for memory pool transactions, as AcceptToMemoryPool
     // already refuses previously-known transaction ids entirely.
-    // This rule was originally applied to all blocks with a timestamp after March 15, 2012, 0:00 UTC.
-    // Now that the whole chain is irreversibly beyond that time it is applied to all blocks except the
-    // two in the chain that violate it. This prevents exploiting the issue against nodes during their
-    // initial block download.
-
-    // DEVCOIN blockchain has no BIP30 exceptions.
-    bool fEnforceBIP30 = (!pindex->phashBlock);
-
-    // Once BIP34 activated it was not possible to create new duplicate coinbases and thus other than starting
-    // with the 2 existing duplicate coinbase pairs, not possible to create overwriting txs.  But by the
-    // time BIP34 activated, in each of the existing pairs the duplicate coinbase had overwritten the first
-    // before the first had been spent.  Since those coinbases are sufficiently buried it's no longer possible to create further
-    // duplicate transactions descending from the known pairs either.
-    // If we're on the known chain at height greater than where BIP34 activated, we can save the db accesses needed for the BIP30 check.
-
-    // BIP34 requires that a block at height X (block X) has its coinbase
-    // scriptSig start with a CScriptNum of X (indicated height X).  The above
-    // logic of no longer requiring BIP30 once BIP34 activates is flawed in the
-    // case that there is a block X before the BIP34 height of 227,931 which has
-    // an indicated height Y where Y is greater than X.  The coinbase for block
-    // X would also be a valid coinbase for block Y, which could be a BIP30
-    // violation.  An exhaustive search of all mainnet coinbases before the
-    // BIP34 height which have an indicated height greater than the block height
-    // reveals many occurrences. The 3 lowest indicated heights found are
-    // 209,921, 490,897, and 1,983,702 and thus coinbases for blocks at these 3
-    // heights would be the first opportunity for BIP30 to be violated.
-
-    // The search reveals a great many blocks which have an indicated height
-    // greater than 1,983,702, so we simply remove the optimization to skip
-    // BIP30 checking for blocks at height 1,983,702 or higher.  Before we reach
-    // that block in another 25 years or so, we should take advantage of a
-    // future consensus change to do a new and improved version of BIP34 that
-    // will actually prevent ever creating any duplicate coinbases in the
-    // future.
-    static constexpr int BIP34_IMPLIES_BIP30_LIMIT = 1983702;
-
-    // There is no potential to create a duplicate coinbase at block 209,921
-    // because this is still before the BIP34 height and so explicit BIP30
-    // checking is still active.
-
-    // The final case is block 176,684 which has an indicated height of
-    // 490,897. Unfortunately, this issue was not discovered until about 2 weeks
-    // before block 490,897 so there was not much opportunity to address this
-    // case other than to carefully analyze it and determine it would not be a
-    // problem. Block 490,897 was, in fact, mined with a different coinbase than
-    // block 176,684, but it is important to note that even if it hadn't been or
-    // is remined on an alternate fork with a duplicate coinbase, we would still
-    // not run into a BIP30 violation.  This is because the coinbase for 176,684
-    // is spent in block 185,956 in transaction
-    // d4f7fbbf92f4a3014a230b2dc70b8058d02eb36ac06b4a0736d9d60eaa9e8781.  This
-    // spending transaction can't be duplicated because it also spends coinbase
-    // 0328dd85c331237f18e781d692c92de57649529bd5edf1d01036daea32ffde29.  This
-    // coinbase has an indicated height of over 4.2 billion, and wouldn't be
-    // duplicatable until that height, and it's currently impossible to create a
-    // chain that long. Nevertheless we may wish to consider a future soft fork
-    // which retroactively prevents block 490,897 from creating a duplicate
-    // coinbase. The two historical BIP30 violations often provide a confusing
-    // edge case when manipulating the UTXO and it would be simpler not to have
-    // another edge case to deal with.
-
-    // testnet3 has no blocks before the BIP34 height with indicated heights
-    // post BIP34 before approximately height 486,000,000 and presumably will
-    // be reset before it reaches block 1,983,702 and starts doing unnecessary
-    // BIP30 checking again.
+    // FIXME: Enable strict check after appropriate fork.
+    bool fEnforceBIP30 = (!pindex->phashBlock) || // Enforce on CreateNewBlock invocations which don't have a hash.
+                          !(true);
     assert(pindex->pprev);
     CBlockIndex* pindexBIP34height = pindex->pprev->GetAncestor(m_params.GetConsensus().BIP34Height);
     //Only continue to enforce if we're below BIP34 activation height or the block hash at that height doesn't correspond.
     fEnforceBIP30 = fEnforceBIP30 && (!pindexBIP34height || !(pindexBIP34height->GetBlockHash() == m_params.GetConsensus().BIP34Hash));
 
-    // TODO: Remove BIP30 checking from block height 1,983,702 on, once we have a
-    // consensus change that ensures coinbases at those heights can not
-    // duplicate earlier coinbases.
-    if (fEnforceBIP30 || pindex->nHeight >= BIP34_IMPLIES_BIP30_LIMIT) {
+    if (fEnforceBIP30) {
         for (const auto& tx : block.vtx) {
             for (size_t o = 0; o < tx->vout.size(); o++) {
                 if (view.HaveCoin(COutPoint(tx->GetHash(), o))) {
@@ -3240,8 +3182,14 @@ static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidatio
     assert(pindexPrev != nullptr);
     const int nHeight = pindexPrev->nHeight + 1;
 
-    // Check proof of work
+    // Disallow legacy blocks after merge-mining start.
     const Consensus::Params& consensusParams = params.GetConsensus();
+    if (!consensusParams.AllowLegacyBlocks(nHeight) && block.IsLegacy())
+        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER,
+                             "late-legacy-block",
+                             "legacy block after auxpow start");
+
+    // Check proof of work
     if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
         return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "bad-diffbits", "incorrect proof of work");
 
@@ -3266,9 +3214,9 @@ static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidatio
         return state.Invalid(BlockValidationResult::BLOCK_TIME_FUTURE, "time-too-new", "block timestamp too far in the future");
 
     // Reject blocks with outdated version
-    if ((block.nVersion < 2 && DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_HEIGHTINCB)) ||
-        (block.nVersion < 3 && DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_DERSIG)) ||
-        (block.nVersion < 4 && DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_CLTV))) {
+    if ((block.GetBaseVersion() < 2 && DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_HEIGHTINCB)) ||
+        (block.GetBaseVersion() < 3 && DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_DERSIG)) ||
+        (block.GetBaseVersion() < 4 && DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_CLTV))) {
             return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, strprintf("bad-version(0x%08x)", block.nVersion),
                                  strprintf("rejected nVersion=0x%08x block", block.nVersion));
     }
@@ -3581,7 +3529,7 @@ bool ChainstateManager::ProcessNewBlock(const CChainParams& chainparams, const s
         // Skipping AcceptBlock() for CheckBlock() failures means that we will never mark a block as invalid if
         // CheckBlock() fails.  This is protective against consensus failure if there are any unknown forms of block
         // malleability that cause CheckBlock() to fail; see e.g. CVE-2012-2459 and
-        // https://lists.linuxfoundation.org/pipermail/devcoin-dev/2019-February/016697.html.  Because CheckBlock() is
+        // https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2019-February/016697.html.  Because CheckBlock() is
         // not very expensive, the anti-DoS benefits of caching failure (of a definitely-invalid block) are not substantial.
         bool ret = CheckBlock(*block, state, chainparams.GetConsensus());
         if (ret) {
diff --git a/src/validation.h b/src/validation.h
index 854466e0..7f631384 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -349,6 +349,7 @@ void UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* pindexPr
 
 /** Produce the necessary coinbase commitment for a block (modifies the hash, don't call for mined blocks). */
 std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, const CBlockIndex* pindexPrev, const Consensus::Params& consensusParams);
+
 /**
  * Check proof-of-work of a block header, taking auxpow into account.
  * @param block The block header.
diff --git a/src/wallet/context.h b/src/wallet/context.h
index c27c6a0d..0d962b6e 100644
--- a/src/wallet/context.h
+++ b/src/wallet/context.h
@@ -10,6 +10,8 @@ namespace interfaces {
 class Chain;
 } // namespace interfaces
 
+struct NodeContext;
+
 //! WalletContext struct containing references to state shared between CWallet
 //! instances, like the reference to the chain interface, and the list of opened
 //! wallets.
@@ -24,6 +26,10 @@ struct WalletContext {
     interfaces::Chain* chain{nullptr};
     ArgsManager* args{nullptr};
 
+    /* getauxwork is a wallet RPC but actually needs the NodeContext (unlike
+       any of the upstream Bitcoin wallet RPCs).  */
+    NodeContext* nodeContext{nullptr};
+
     //! Declare default constructor and destructor that are not inline, so code
     //! instantiating the WalletContext struct doesn't need to #include class
     //! definitions for smart pointer and container members.
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 1268f316..2e0d8f7b 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -7,6 +7,7 @@
 #include <amount.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
+#include <node/context.h>
 #include <policy/fees.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
@@ -511,8 +512,16 @@ class WalletClientImpl : public WalletClient
     {
         for (const CRPCCommand& command : GetWalletRPCCommands()) {
             m_rpc_commands.emplace_back(command.category, command.name, [this, &command](const JSONRPCRequest& request, UniValue& result, bool last_handler) {
+                /* Unlike upstream Bitcoin, we need the NodeContext for
+                   getauxblock.  Thus we construct a new context that
+                   contains both and use that.  */
+                WalletContext extendedCtx = m_context;
+                auto node_context = util::AnyPtr<NodeContext>(request.context);
+                if (node_context)
+                    extendedCtx.nodeContext = node_context;
+
                 JSONRPCRequest wallet_request = request;
-                wallet_request.context = &m_context;
+                wallet_request.context = &extendedCtx;
                 return command.actor(wallet_request, result, last_handler);
             }, command.argNames, command.unique_id);
             m_rpc_handlers.emplace_back(m_context.chain->handleRpc(m_rpc_commands.back()));
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index fe5a2755..199d05ea 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -13,6 +13,8 @@
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <policy/rbf.h>
+#include <rpc/auxpow_miner.h>
+#include <rpc/blockchain.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
@@ -4609,6 +4611,191 @@ static RPCHelpMan walletdisplayaddress()
 }
 #endif // ENABLE_EXTERNAL_SIGNER
 
+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;
+    std::string dest_err;
+    if (!rdest.GetReservedDestination (dest, false, dest_err))
+      throw JSONRPCError (RPC_WALLET_KEYPOOL_RAN_OUT,
+                          strprintf ("Failed to generate mining address: %s",
+                                     dest_err));
+    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 RPCHelpMan getauxblock()
+{
+    return RPCHelpMan{"getauxblock",
+                "\nCreates 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, deprecated"},
+                      },
+                  },
+                  {"with arguments",
+                      RPCResult::Type::BOOL, "", "whether the submitted block was correct"
+                  },
+                },
+                RPCExamples{
+                    HelpExampleCli("getauxblock", "")
+                    + HelpExampleCli("getauxblock", "\"hash\" \"serialised auxpow\"")
+                    + HelpExampleRpc("getauxblock", "")
+                },
+                [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    if (request.params.size() != 0 && request.params.size() != 2)
+        throw std::runtime_error(self.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();
@@ -4692,6 +4879,10 @@ static const CRPCCommand commands[] =
     { "wallet",             &walletpassphrase,               },
     { "wallet",             &walletpassphrasechange,         },
     { "wallet",             &walletprocesspsbt,              },
+
+    /** Auxpow wallet functions */
+    { "mining",             &getauxblock,                    },
+
 };
 // clang-format on
     return MakeSpan(commands);