diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -532,7 +532,9 @@
 	noui.cpp
 	policy/fees.cpp
 	policy/settings.cpp
-	pow.cpp
+	pow/daa.cpp
+	pow/eda.cpp
+	pow/pow.cpp
 	rest.cpp
 	rpc/abc.cpp
 	rpc/avalanche.cpp
@@ -588,6 +590,7 @@
 # Test suites.
 add_subdirectory(test)
 add_subdirectory(avalanche/test)
+add_subdirectory(pow/test)
 
 # Benchmark suite.
 add_subdirectory(bench)
diff --git a/src/Makefile.am b/src/Makefile.am
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -198,7 +198,9 @@
   policy/mempool.h \
   policy/policy.h \
   policy/settings.h \
-  pow.h \
+  pow/daa.h \
+  pow/eda.h \
+  pow/pow.h \
   protocol.h \
   psbt.h \
   radix.h \
@@ -333,7 +335,9 @@
   noui.cpp \
   policy/fees.cpp \
   policy/settings.cpp \
-  pow.cpp \
+  pow/daa.cpp \
+  pow/eda.cpp \
+  pow/pow.cpp \
   rest.cpp \
   rpc/abc.cpp \
   rpc/avalanche.cpp \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -90,6 +90,8 @@
   avalanche/test/peermanager_tests.cpp \
   avalanche/test/processor_tests.cpp \
   avalanche/test/proof_tests.cpp \
+  pow/test/daa_tests.cpp \
+  pow/test/eda_tests.cpp \
   test/scriptnum10.h \
   test/activation_tests.cpp \
   test/addrman_tests.cpp \
@@ -150,7 +152,6 @@
   test/op_reversebytes_tests.cpp \
   test/pmt_tests.cpp \
   test/policyestimator_tests.cpp \
-  test/pow_tests.cpp \
   test/prevector_tests.cpp \
   test/radix_tests.cpp \
   test/raii_event_tests.cpp \
diff --git a/src/bench/duplicate_inputs.cpp b/src/bench/duplicate_inputs.cpp
--- a/src/bench/duplicate_inputs.cpp
+++ b/src/bench/duplicate_inputs.cpp
@@ -8,7 +8,7 @@
 #include <config.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <random.h>
 #include <script/scriptcache.h>
 #include <txmempool.h>
diff --git a/src/miner.cpp b/src/miner.cpp
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -19,7 +19,7 @@
 #include <net.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <primitives/transaction.h>
 #include <timedata.h>
 #include <util/moneystr.h>
diff --git a/src/pow.cpp b/src/pow.cpp
deleted file mode 100644
--- a/src/pow.cpp
+++ /dev/null
@@ -1,284 +0,0 @@
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2016 The Bitcoin Core developers
-// Copyright (c) 2017-2020 The Bitcoin developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <pow.h>
-
-#include <arith_uint256.h>
-#include <chain.h>
-#include <consensus/activation.h>
-#include <consensus/params.h>
-#include <primitives/block.h>
-#include <primitives/blockhash.h>
-#include <uint256.h>
-#include <util/system.h>
-
-/**
- * Compute the next required proof of work using the legacy Bitcoin difficulty
- * adjustment + Emergency Difficulty Adjustment (EDA).
- */
-static uint32_t GetNextEDAWorkRequired(const CBlockIndex *pindexPrev,
-                                       const CBlockHeader *pblock,
-                                       const Consensus::Params &params) {
-    // Only change once per difficulty adjustment interval
-    uint32_t nHeight = pindexPrev->nHeight + 1;
-    if (nHeight % params.DifficultyAdjustmentInterval() == 0) {
-        // Go back by what we want to be 14 days worth of blocks
-        assert(nHeight >= params.DifficultyAdjustmentInterval());
-        uint32_t nHeightFirst = nHeight - params.DifficultyAdjustmentInterval();
-        const CBlockIndex *pindexFirst = pindexPrev->GetAncestor(nHeightFirst);
-        assert(pindexFirst);
-
-        return CalculateNextWorkRequired(pindexPrev,
-                                         pindexFirst->GetBlockTime(), params);
-    }
-
-    const uint32_t nProofOfWorkLimit =
-        UintToArith256(params.powLimit).GetCompact();
-
-    if (params.fPowAllowMinDifficultyBlocks) {
-        // 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.
-        if (pblock->GetBlockTime() >
-            pindexPrev->GetBlockTime() + 2 * params.nPowTargetSpacing) {
-            return nProofOfWorkLimit;
-        }
-
-        // Return the last non-special-min-difficulty-rules-block
-        const CBlockIndex *pindex = pindexPrev;
-        while (pindex->pprev &&
-               pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 &&
-               pindex->nBits == nProofOfWorkLimit) {
-            pindex = pindex->pprev;
-        }
-
-        return pindex->nBits;
-    }
-
-    // We can't go below the minimum, so bail early.
-    uint32_t nBits = pindexPrev->nBits;
-    if (nBits == nProofOfWorkLimit) {
-        return nProofOfWorkLimit;
-    }
-
-    // If producing the last 6 blocks took less than 12h, we keep the same
-    // difficulty.
-    const CBlockIndex *pindex6 = pindexPrev->GetAncestor(nHeight - 7);
-    assert(pindex6);
-    int64_t mtp6blocks =
-        pindexPrev->GetMedianTimePast() - pindex6->GetMedianTimePast();
-    if (mtp6blocks < 12 * 3600) {
-        return nBits;
-    }
-
-    // If producing the last 6 blocks took more than 12h, increase the
-    // difficulty target by 1/4 (which reduces the difficulty by 20%).
-    // This ensures that the chain does not get stuck in case we lose
-    // hashrate abruptly.
-    arith_uint256 nPow;
-    nPow.SetCompact(nBits);
-    nPow += (nPow >> 2);
-
-    // Make sure we do not go below allowed values.
-    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
-    if (nPow > bnPowLimit) {
-        nPow = bnPowLimit;
-    }
-
-    return nPow.GetCompact();
-}
-
-uint32_t GetNextWorkRequired(const CBlockIndex *pindexPrev,
-                             const CBlockHeader *pblock,
-                             const Consensus::Params &params) {
-    // GetNextWorkRequired should never be called on the genesis block
-    assert(pindexPrev != nullptr);
-
-    // Special rule for regtest: we never retarget.
-    if (params.fPowNoRetargeting) {
-        return pindexPrev->nBits;
-    }
-
-    if (IsDAAEnabled(params, pindexPrev)) {
-        return GetNextCashWorkRequired(pindexPrev, pblock, params);
-    }
-
-    return GetNextEDAWorkRequired(pindexPrev, pblock, params);
-}
-
-uint32_t CalculateNextWorkRequired(const CBlockIndex *pindexPrev,
-                                   int64_t nFirstBlockTime,
-                                   const Consensus::Params &params) {
-    if (params.fPowNoRetargeting) {
-        return pindexPrev->nBits;
-    }
-
-    // Limit adjustment step
-    int64_t nActualTimespan = pindexPrev->GetBlockTime() - nFirstBlockTime;
-    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);
-    arith_uint256 bnNew;
-    bnNew.SetCompact(pindexPrev->nBits);
-    bnNew *= nActualTimespan;
-    bnNew /= params.nPowTargetTimespan;
-
-    if (bnNew > bnPowLimit) {
-        bnNew = bnPowLimit;
-    }
-
-    return bnNew.GetCompact();
-}
-
-bool CheckProofOfWork(const BlockHash &hash, uint32_t nBits,
-                      const Consensus::Params &params) {
-    bool fNegative;
-    bool fOverflow;
-    arith_uint256 bnTarget;
-
-    bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
-
-    // Check range
-    if (fNegative || bnTarget == 0 || fOverflow ||
-        bnTarget > UintToArith256(params.powLimit)) {
-        return false;
-    }
-
-    // Check proof of work matches claimed amount
-    if (UintToArith256(hash) > bnTarget) {
-        return false;
-    }
-
-    return true;
-}
-
-/**
- * Compute a target based on the work done between 2 blocks and the time
- * required to produce that work.
- */
-static arith_uint256 ComputeTarget(const CBlockIndex *pindexFirst,
-                                   const CBlockIndex *pindexLast,
-                                   const Consensus::Params &params) {
-    assert(pindexLast->nHeight > pindexFirst->nHeight);
-
-    /**
-     * From the total work done and the time it took to produce that much work,
-     * we can deduce how much work we expect to be produced in the targeted time
-     * between blocks.
-     */
-    arith_uint256 work = pindexLast->nChainWork - pindexFirst->nChainWork;
-    work *= params.nPowTargetSpacing;
-
-    // In order to avoid difficulty cliffs, we bound the amplitude of the
-    // adjustment we are going to do to a factor in [0.5, 2].
-    int64_t nActualTimespan =
-        int64_t(pindexLast->nTime) - int64_t(pindexFirst->nTime);
-    if (nActualTimespan > 288 * params.nPowTargetSpacing) {
-        nActualTimespan = 288 * params.nPowTargetSpacing;
-    } else if (nActualTimespan < 72 * params.nPowTargetSpacing) {
-        nActualTimespan = 72 * params.nPowTargetSpacing;
-    }
-
-    work /= nActualTimespan;
-
-    /**
-     * We need to compute T = (2^256 / W) - 1 but 2^256 doesn't fit in 256 bits.
-     * By expressing 1 as W / W, we get (2^256 - W) / W, and we can compute
-     * 2^256 - W as the complement of W.
-     */
-    return (-work) / work;
-}
-
-/**
- * To reduce the impact of timestamp manipulation, we select the block we are
- * basing our computation on via a median of 3.
- */
-static const CBlockIndex *GetSuitableBlock(const CBlockIndex *pindex) {
-    assert(pindex->nHeight >= 3);
-
-    /**
-     * In order to avoid a block with a very skewed timestamp having too much
-     * influence, we select the median of the 3 top most blocks as a starting
-     * point.
-     */
-    const CBlockIndex *blocks[3];
-    blocks[2] = pindex;
-    blocks[1] = pindex->pprev;
-    blocks[0] = blocks[1]->pprev;
-
-    // Sorting network.
-    if (blocks[0]->nTime > blocks[2]->nTime) {
-        std::swap(blocks[0], blocks[2]);
-    }
-
-    if (blocks[0]->nTime > blocks[1]->nTime) {
-        std::swap(blocks[0], blocks[1]);
-    }
-
-    if (blocks[1]->nTime > blocks[2]->nTime) {
-        std::swap(blocks[1], blocks[2]);
-    }
-
-    // We should have our candidate in the middle now.
-    return blocks[1];
-}
-
-/**
- * Compute the next required proof of work using a weighted average of the
- * estimated hashrate per block.
- *
- * Using a weighted average ensure that the timestamp parameter cancels out in
- * most of the calculation - except for the timestamp of the first and last
- * block. Because timestamps are the least trustworthy information we have as
- * input, this ensures the algorithm is more resistant to malicious inputs.
- */
-uint32_t GetNextCashWorkRequired(const CBlockIndex *pindexPrev,
-                                 const CBlockHeader *pblock,
-                                 const Consensus::Params &params) {
-    // This cannot handle the genesis block and early blocks in general.
-    assert(pindexPrev);
-
-    // 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.
-    if (params.fPowAllowMinDifficultyBlocks &&
-        (pblock->GetBlockTime() >
-         pindexPrev->GetBlockTime() + 2 * params.nPowTargetSpacing)) {
-        return UintToArith256(params.powLimit).GetCompact();
-    }
-
-    // Compute the difficulty based on the full adjustment interval.
-    const uint32_t nHeight = pindexPrev->nHeight;
-    assert(nHeight >= params.DifficultyAdjustmentInterval());
-
-    // Get the last suitable block of the difficulty interval.
-    const CBlockIndex *pindexLast = GetSuitableBlock(pindexPrev);
-    assert(pindexLast);
-
-    // Get the first suitable block of the difficulty interval.
-    uint32_t nHeightFirst = nHeight - 144;
-    const CBlockIndex *pindexFirst =
-        GetSuitableBlock(pindexPrev->GetAncestor(nHeightFirst));
-    assert(pindexFirst);
-
-    // Compute the target based on time and work done during the interval.
-    const arith_uint256 nextTarget =
-        ComputeTarget(pindexFirst, pindexLast, params);
-
-    const arith_uint256 powLimit = UintToArith256(params.powLimit);
-    if (nextTarget > powLimit) {
-        return powLimit.GetCompact();
-    }
-
-    return nextTarget.GetCompact();
-}
diff --git a/src/pow/daa.h b/src/pow/daa.h
new file mode 100644
--- /dev/null
+++ b/src/pow/daa.h
@@ -0,0 +1,21 @@
+// Copyright (c) 2017-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_POW_DAA_H
+#define BITCOIN_POW_DAA_H
+
+#include <cstdint>
+
+class CBlockHeader;
+class CBlockIndex;
+
+namespace Consensus {
+struct Params;
+}
+
+uint32_t GetNextDAAWorkRequired(const CBlockIndex *pindexPrev,
+                                const CBlockHeader *pblock,
+                                const Consensus::Params &params);
+
+#endif // BITCOIN_POW_DAA_H
diff --git a/src/pow/daa.cpp b/src/pow/daa.cpp
new file mode 100644
--- /dev/null
+++ b/src/pow/daa.cpp
@@ -0,0 +1,130 @@
+// Copyright (c) 2017-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <pow/daa.h>
+
+#include <arith_uint256.h>
+#include <chain.h>
+#include <consensus/params.h>
+
+/**
+ * Compute a target based on the work done between 2 blocks and the time
+ * required to produce that work.
+ */
+static arith_uint256 ComputeTarget(const CBlockIndex *pindexFirst,
+                                   const CBlockIndex *pindexLast,
+                                   const Consensus::Params &params) {
+    assert(pindexLast->nHeight > pindexFirst->nHeight);
+
+    /**
+     * From the total work done and the time it took to produce that much work,
+     * we can deduce how much work we expect to be produced in the targeted time
+     * between blocks.
+     */
+    arith_uint256 work = pindexLast->nChainWork - pindexFirst->nChainWork;
+    work *= params.nPowTargetSpacing;
+
+    // In order to avoid difficulty cliffs, we bound the amplitude of the
+    // adjustment we are going to do to a factor in [0.5, 2].
+    int64_t nActualTimespan =
+        int64_t(pindexLast->nTime) - int64_t(pindexFirst->nTime);
+    if (nActualTimespan > 288 * params.nPowTargetSpacing) {
+        nActualTimespan = 288 * params.nPowTargetSpacing;
+    } else if (nActualTimespan < 72 * params.nPowTargetSpacing) {
+        nActualTimespan = 72 * params.nPowTargetSpacing;
+    }
+
+    work /= nActualTimespan;
+
+    /**
+     * We need to compute T = (2^256 / W) - 1 but 2^256 doesn't fit in 256 bits.
+     * By expressing 1 as W / W, we get (2^256 - W) / W, and we can compute
+     * 2^256 - W as the complement of W.
+     */
+    return (-work) / work;
+}
+
+/**
+ * To reduce the impact of timestamp manipulation, we select the block we are
+ * basing our computation on via a median of 3.
+ */
+static const CBlockIndex *GetSuitableBlock(const CBlockIndex *pindex) {
+    assert(pindex->nHeight >= 3);
+
+    /**
+     * In order to avoid a block with a very skewed timestamp having too much
+     * influence, we select the median of the 3 top most blocks as a starting
+     * point.
+     */
+    const CBlockIndex *blocks[3];
+    blocks[2] = pindex;
+    blocks[1] = pindex->pprev;
+    blocks[0] = blocks[1]->pprev;
+
+    // Sorting network.
+    if (blocks[0]->nTime > blocks[2]->nTime) {
+        std::swap(blocks[0], blocks[2]);
+    }
+
+    if (blocks[0]->nTime > blocks[1]->nTime) {
+        std::swap(blocks[0], blocks[1]);
+    }
+
+    if (blocks[1]->nTime > blocks[2]->nTime) {
+        std::swap(blocks[1], blocks[2]);
+    }
+
+    // We should have our candidate in the middle now.
+    return blocks[1];
+}
+
+/**
+ * Compute the next required proof of work using a weighted average of the
+ * estimated hashrate per block.
+ *
+ * Using a weighted average ensure that the timestamp parameter cancels out in
+ * most of the calculation - except for the timestamp of the first and last
+ * block. Because timestamps are the least trustworthy information we have as
+ * input, this ensures the algorithm is more resistant to malicious inputs.
+ */
+uint32_t GetNextDAAWorkRequired(const CBlockIndex *pindexPrev,
+                                const CBlockHeader *pblock,
+                                const Consensus::Params &params) {
+    // This cannot handle the genesis block and early blocks in general.
+    assert(pindexPrev);
+
+    // 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.
+    if (params.fPowAllowMinDifficultyBlocks &&
+        (pblock->GetBlockTime() >
+         pindexPrev->GetBlockTime() + 2 * params.nPowTargetSpacing)) {
+        return UintToArith256(params.powLimit).GetCompact();
+    }
+
+    // Compute the difficulty based on the full adjustment interval.
+    const uint32_t nHeight = pindexPrev->nHeight;
+    assert(nHeight >= params.DifficultyAdjustmentInterval());
+
+    // Get the last suitable block of the difficulty interval.
+    const CBlockIndex *pindexLast = GetSuitableBlock(pindexPrev);
+    assert(pindexLast);
+
+    // Get the first suitable block of the difficulty interval.
+    uint32_t nHeightFirst = nHeight - 144;
+    const CBlockIndex *pindexFirst =
+        GetSuitableBlock(pindexPrev->GetAncestor(nHeightFirst));
+    assert(pindexFirst);
+
+    // Compute the target based on time and work done during the interval.
+    const arith_uint256 nextTarget =
+        ComputeTarget(pindexFirst, pindexLast, params);
+
+    const arith_uint256 powLimit = UintToArith256(params.powLimit);
+    if (nextTarget > powLimit) {
+        return powLimit.GetCompact();
+    }
+
+    return nextTarget.GetCompact();
+}
diff --git a/src/pow/eda.h b/src/pow/eda.h
new file mode 100644
--- /dev/null
+++ b/src/pow/eda.h
@@ -0,0 +1,25 @@
+// Copyright (c) 2017-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_POW_EDA_H
+#define BITCOIN_POW_EDA_H
+
+#include <cstdint>
+
+class CBlockHeader;
+class CBlockIndex;
+
+namespace Consensus {
+struct Params;
+}
+
+uint32_t CalculateNextWorkRequired(const CBlockIndex *pindexPrev,
+                                   int64_t nFirstBlockTime,
+                                   const Consensus::Params &params);
+
+uint32_t GetNextEDAWorkRequired(const CBlockIndex *pindexPrev,
+                                const CBlockHeader *pblock,
+                                const Consensus::Params &params);
+
+#endif // BITCOIN_POW_EDA_H
diff --git a/src/pow/eda.cpp b/src/pow/eda.cpp
new file mode 100644
--- /dev/null
+++ b/src/pow/eda.cpp
@@ -0,0 +1,119 @@
+// Copyright (c) 2017-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <pow/eda.h>
+
+#include <arith_uint256.h>
+#include <chain.h>
+#include <consensus/params.h>
+
+/**
+ * Do difficulty adjustement Satoshi's way.
+ */
+uint32_t CalculateNextWorkRequired(const CBlockIndex *pindexPrev,
+                                   int64_t nFirstBlockTime,
+                                   const Consensus::Params &params) {
+    if (params.fPowNoRetargeting) {
+        return pindexPrev->nBits;
+    }
+
+    // Limit adjustment step
+    int64_t nActualTimespan = pindexPrev->GetBlockTime() - nFirstBlockTime;
+    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);
+    arith_uint256 bnNew;
+    bnNew.SetCompact(pindexPrev->nBits);
+    bnNew *= nActualTimespan;
+    bnNew /= params.nPowTargetTimespan;
+
+    if (bnNew > bnPowLimit) {
+        bnNew = bnPowLimit;
+    }
+
+    return bnNew.GetCompact();
+}
+
+/**
+ * Compute the next required proof of work using the legacy Bitcoin difficulty
+ * adjustment + Emergency Difficulty Adjustment (EDA).
+ */
+uint32_t GetNextEDAWorkRequired(const CBlockIndex *pindexPrev,
+                                const CBlockHeader *pblock,
+                                const Consensus::Params &params) {
+    // Only change once per difficulty adjustment interval
+    uint32_t nHeight = pindexPrev->nHeight + 1;
+    if (nHeight % params.DifficultyAdjustmentInterval() == 0) {
+        // Go back by what we want to be 14 days worth of blocks
+        assert(nHeight >= params.DifficultyAdjustmentInterval());
+        uint32_t nHeightFirst = nHeight - params.DifficultyAdjustmentInterval();
+        const CBlockIndex *pindexFirst = pindexPrev->GetAncestor(nHeightFirst);
+        assert(pindexFirst);
+
+        return CalculateNextWorkRequired(pindexPrev,
+                                         pindexFirst->GetBlockTime(), params);
+    }
+
+    const uint32_t nProofOfWorkLimit =
+        UintToArith256(params.powLimit).GetCompact();
+
+    if (params.fPowAllowMinDifficultyBlocks) {
+        // 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.
+        if (pblock->GetBlockTime() >
+            pindexPrev->GetBlockTime() + 2 * params.nPowTargetSpacing) {
+            return nProofOfWorkLimit;
+        }
+
+        // Return the last non-special-min-difficulty-rules-block
+        const CBlockIndex *pindex = pindexPrev;
+        while (pindex->pprev &&
+               pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 &&
+               pindex->nBits == nProofOfWorkLimit) {
+            pindex = pindex->pprev;
+        }
+
+        return pindex->nBits;
+    }
+
+    // We can't go below the minimum, so bail early.
+    uint32_t nBits = pindexPrev->nBits;
+    if (nBits == nProofOfWorkLimit) {
+        return nProofOfWorkLimit;
+    }
+
+    // If producing the last 6 blocks took less than 12h, we keep the same
+    // difficulty.
+    const CBlockIndex *pindex6 = pindexPrev->GetAncestor(nHeight - 7);
+    assert(pindex6);
+    int64_t mtp6blocks =
+        pindexPrev->GetMedianTimePast() - pindex6->GetMedianTimePast();
+    if (mtp6blocks < 12 * 3600) {
+        return nBits;
+    }
+
+    // If producing the last 6 blocks took more than 12h, increase the
+    // difficulty target by 1/4 (which reduces the difficulty by 20%).
+    // This ensures that the chain does not get stuck in case we lose
+    // hashrate abruptly.
+    arith_uint256 nPow;
+    nPow.SetCompact(nBits);
+    nPow += (nPow >> 2);
+
+    // Make sure we do not go below allowed values.
+    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
+    if (nPow > bnPowLimit) {
+        nPow = bnPowLimit;
+    }
+
+    return nPow.GetCompact();
+}
diff --git a/src/pow.h b/src/pow/pow.h
rename from src/pow.h
rename to src/pow/pow.h
--- a/src/pow.h
+++ b/src/pow/pow.h
@@ -3,15 +3,14 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_POW_H
-#define BITCOIN_POW_H
+#ifndef BITCOIN_POW_POW_H
+#define BITCOIN_POW_POW_H
 
 #include <cstdint>
 
 struct BlockHash;
 class CBlockHeader;
 class CBlockIndex;
-class uint256;
 
 namespace Consensus {
 struct Params;
@@ -20,9 +19,6 @@
 uint32_t GetNextWorkRequired(const CBlockIndex *pindexPrev,
                              const CBlockHeader *pblock,
                              const Consensus::Params &params);
-uint32_t CalculateNextWorkRequired(const CBlockIndex *pindexPrev,
-                                   int64_t nFirstBlockTime,
-                                   const Consensus::Params &params);
 
 /**
  * Check whether a block hash satisfies the proof-of-work requirement specified
@@ -31,11 +27,4 @@
 bool CheckProofOfWork(const BlockHash &hash, uint32_t nBits,
                       const Consensus::Params &params);
 
-/**
- * Bitcoin cash's difficulty adjustment mechanism.
- */
-uint32_t GetNextCashWorkRequired(const CBlockIndex *pindexPrev,
-                                 const CBlockHeader *pblock,
-                                 const Consensus::Params &params);
-
-#endif // BITCOIN_POW_H
+#endif // BITCOIN_POW_POW_H
diff --git a/src/pow/pow.cpp b/src/pow/pow.cpp
new file mode 100644
--- /dev/null
+++ b/src/pow/pow.cpp
@@ -0,0 +1,56 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2016 The Bitcoin Core developers
+// Copyright (c) 2017-2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <pow/pow.h>
+
+#include <arith_uint256.h>
+#include <chain.h>
+#include <consensus/activation.h>
+#include <consensus/params.h>
+#include <pow/daa.h>
+#include <pow/eda.h>
+#include <primitives/blockhash.h>
+#include <util/system.h>
+
+uint32_t GetNextWorkRequired(const CBlockIndex *pindexPrev,
+                             const CBlockHeader *pblock,
+                             const Consensus::Params &params) {
+    // GetNextWorkRequired should never be called on the genesis block
+    assert(pindexPrev != nullptr);
+
+    // Special rule for regtest: we never retarget.
+    if (params.fPowNoRetargeting) {
+        return pindexPrev->nBits;
+    }
+
+    if (IsDAAEnabled(params, pindexPrev)) {
+        return GetNextDAAWorkRequired(pindexPrev, pblock, params);
+    }
+
+    return GetNextEDAWorkRequired(pindexPrev, pblock, params);
+}
+
+bool CheckProofOfWork(const BlockHash &hash, uint32_t nBits,
+                      const Consensus::Params &params) {
+    bool fNegative;
+    bool fOverflow;
+    arith_uint256 bnTarget;
+
+    bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
+
+    // Check range
+    if (fNegative || bnTarget == 0 || fOverflow ||
+        bnTarget > UintToArith256(params.powLimit)) {
+        return false;
+    }
+
+    // Check proof of work matches claimed amount
+    if (UintToArith256(hash) > bnTarget) {
+        return false;
+    }
+
+    return true;
+}
diff --git a/src/pow/test/CMakeLists.txt b/src/pow/test/CMakeLists.txt
new file mode 100644
--- /dev/null
+++ b/src/pow/test/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Copyright (c) 2020 The Bitcoin developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+project(pow-test)
+
+include(TestSuite)
+create_test_suite(pow)
+add_dependencies(check check-pow)
+
+add_boost_unit_tests_to_suite(pow test-pow
+	fixture.cpp
+
+	TESTS
+		daa_tests.cpp
+		eda_tests.cpp
+)
+
+target_link_libraries(test-pow server testutil)
diff --git a/src/pow/test/daa_tests.cpp b/src/pow/test/daa_tests.cpp
new file mode 100644
--- /dev/null
+++ b/src/pow/test/daa_tests.cpp
@@ -0,0 +1,204 @@
+// Copyright (c) 2015-2019 The Bitcoin Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <pow/daa.h>
+
+#include <chain.h>
+#include <chainparams.h>
+#include <config.h>
+
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(daa_tests, BasicTestingSetup)
+
+static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval,
+                                 uint32_t nBits) {
+    CBlockIndex block;
+    block.pprev = pindexPrev;
+    block.nHeight = pindexPrev->nHeight + 1;
+    block.nTime = pindexPrev->nTime + nTimeInterval;
+    block.nBits = nBits;
+
+    block.nChainWork = pindexPrev->nChainWork + GetBlockProof(block);
+    return block;
+}
+
+BOOST_AUTO_TEST_CASE(daa_test) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    std::vector<CBlockIndex> blocks(3000);
+
+    const Consensus::Params &params = config.GetChainParams().GetConsensus();
+    const arith_uint256 powLimit = UintToArith256(params.powLimit);
+    uint32_t powLimitBits = powLimit.GetCompact();
+    arith_uint256 currentPow = powLimit >> 4;
+    uint32_t initialBits = currentPow.GetCompact();
+
+    // Genesis block.
+    blocks[0] = CBlockIndex();
+    blocks[0].nHeight = 0;
+    blocks[0].nTime = 1269211443;
+    blocks[0].nBits = initialBits;
+
+    blocks[0].nChainWork = GetBlockProof(blocks[0]);
+
+    // Block counter.
+    size_t i;
+
+    // Pile up some blocks every 10 mins to establish some history.
+    for (i = 1; i < 2050; i++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, initialBits);
+    }
+
+    CBlockHeader blkHeaderDummy;
+    uint32_t nBits =
+        GetNextDAAWorkRequired(&blocks[2049], &blkHeaderDummy, params);
+
+    // Difficulty stays the same as long as we produce a block every 10 mins.
+    for (size_t j = 0; j < 10; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, nBits);
+        BOOST_CHECK_EQUAL(
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params), nBits);
+    }
+
+    // Make sure we skip over blocks that are out of wack. To do so, we produce
+    // a block that is far in the future, and then produce a block with the
+    // expected timestamp.
+    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+    BOOST_CHECK_EQUAL(
+        GetNextDAAWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
+    blocks[i] = GetBlockIndex(&blocks[i - 1], 2 * 600 - 6000, nBits);
+    BOOST_CHECK_EQUAL(
+        GetNextDAAWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
+
+    // The system should continue unaffected by the block with a bogous
+    // timestamps.
+    for (size_t j = 0; j < 20; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, nBits);
+        BOOST_CHECK_EQUAL(
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params), nBits);
+    }
+
+    // We start emitting blocks slightly faster. The first block has no impact.
+    blocks[i] = GetBlockIndex(&blocks[i - 1], 550, nBits);
+    BOOST_CHECK_EQUAL(
+        GetNextDAAWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
+
+    // Now we should see difficulty increase slowly.
+    for (size_t j = 0; j < 10; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 550, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        arith_uint256 currentTarget;
+        currentTarget.SetCompact(nBits);
+        arith_uint256 nextTarget;
+        nextTarget.SetCompact(nextBits);
+
+        // Make sure that difficulty increases very slowly.
+        BOOST_CHECK(nextTarget < currentTarget);
+        BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 10));
+
+        nBits = nextBits;
+    }
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1c0fe7b1);
+
+    // If we dramatically shorten block production, difficulty increases faster.
+    for (size_t j = 0; j < 20; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 10, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        arith_uint256 currentTarget;
+        currentTarget.SetCompact(nBits);
+        arith_uint256 nextTarget;
+        nextTarget.SetCompact(nextBits);
+
+        // Make sure that difficulty increases faster.
+        BOOST_CHECK(nextTarget < currentTarget);
+        BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 4));
+
+        nBits = nextBits;
+    }
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1c0db19f);
+
+    // We start to emit blocks significantly slower. The first block has no
+    // impact.
+    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+    nBits = GetNextDAAWorkRequired(&blocks[i++], &blkHeaderDummy, params);
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1c0d9222);
+
+    // If we dramatically slow down block production, difficulty decreases.
+    for (size_t j = 0; j < 93; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        arith_uint256 currentTarget;
+        currentTarget.SetCompact(nBits);
+        arith_uint256 nextTarget;
+        nextTarget.SetCompact(nextBits);
+
+        // Check the difficulty decreases.
+        BOOST_CHECK(nextTarget <= powLimit);
+        BOOST_CHECK(nextTarget > currentTarget);
+        BOOST_CHECK((nextTarget - currentTarget) < (currentTarget >> 3));
+
+        nBits = nextBits;
+    }
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1c2f13b9);
+
+    // Due to the window of time being bounded, next block's difficulty actually
+    // gets harder.
+    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+    nBits = GetNextDAAWorkRequired(&blocks[i++], &blkHeaderDummy, params);
+    BOOST_CHECK_EQUAL(nBits, 0x1c2ee9bf);
+
+    // And goes down again. It takes a while due to the window being bounded and
+    // the skewed block causes 2 blocks to get out of the window.
+    for (size_t j = 0; j < 192; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        arith_uint256 currentTarget;
+        currentTarget.SetCompact(nBits);
+        arith_uint256 nextTarget;
+        nextTarget.SetCompact(nextBits);
+
+        // Check the difficulty decreases.
+        BOOST_CHECK(nextTarget <= powLimit);
+        BOOST_CHECK(nextTarget > currentTarget);
+        BOOST_CHECK((nextTarget - currentTarget) < (currentTarget >> 3));
+
+        nBits = nextBits;
+    }
+
+    // Check the actual value.
+    BOOST_CHECK_EQUAL(nBits, 0x1d00ffff);
+
+    // Once the difficulty reached the minimum allowed level, it doesn't get any
+    // easier.
+    for (size_t j = 0; j < 5; i++, j++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
+        const uint32_t nextBits =
+            GetNextDAAWorkRequired(&blocks[i], &blkHeaderDummy, params);
+
+        // Check the difficulty stays constant.
+        BOOST_CHECK_EQUAL(nextBits, powLimitBits);
+        nBits = nextBits;
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/pow/test/eda_tests.cpp b/src/pow/test/eda_tests.cpp
new file mode 100644
--- /dev/null
+++ b/src/pow/test/eda_tests.cpp
@@ -0,0 +1,196 @@
+// Copyright (c) 2015-2019 The Bitcoin Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <pow/eda.h>
+
+#include <chain.h>
+#include <chainparams.h>
+#include <config.h>
+
+#include <test/util/setup_common.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(eda_tests, BasicTestingSetup)
+
+/* Test calculation of next difficulty target with no constraints applying */
+BOOST_AUTO_TEST_CASE(get_next_work) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    int64_t nLastRetargetTime = 1261130161; // Block #30240
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 32255;
+    pindexLast.nTime = 1262152739; // Block #32255
+    pindexLast.nBits = 0x1d00ffff;
+    BOOST_CHECK_EQUAL(
+        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
+                                  config.GetChainParams().GetConsensus()),
+        0x1d00d86aU);
+}
+
+/* Test the constraint on the upper bound for next work */
+BOOST_AUTO_TEST_CASE(get_next_work_pow_limit) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    int64_t nLastRetargetTime = 1231006505; // Block #0
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 2015;
+    pindexLast.nTime = 1233061996; // Block #2015
+    pindexLast.nBits = 0x1d00ffff;
+    BOOST_CHECK_EQUAL(
+        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
+                                  config.GetChainParams().GetConsensus()),
+        0x1d00ffffU);
+}
+
+/* Test the constraint on the lower bound for actual time taken */
+BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    int64_t nLastRetargetTime = 1279008237; // Block #66528
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 68543;
+    pindexLast.nTime = 1279297671; // Block #68543
+    pindexLast.nBits = 0x1c05a3f4;
+    BOOST_CHECK_EQUAL(
+        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
+                                  config.GetChainParams().GetConsensus()),
+        0x1c0168fdU);
+}
+
+/* Test the constraint on the upper bound for actual time taken */
+BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    int64_t nLastRetargetTime = 1263163443; // NOTE: Not an actual block time
+    CBlockIndex pindexLast;
+    pindexLast.nHeight = 46367;
+    pindexLast.nTime = 1269211443; // Block #46367
+    pindexLast.nBits = 0x1c387f6f;
+    BOOST_CHECK_EQUAL(
+        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
+                                  config.GetChainParams().GetConsensus()),
+        0x1d00e1fdU);
+}
+
+BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    std::vector<CBlockIndex> blocks(10000);
+    for (int i = 0; i < 10000; i++) {
+        blocks[i].pprev = i ? &blocks[i - 1] : nullptr;
+        blocks[i].nHeight = i;
+        blocks[i].nTime =
+            1269211443 +
+            i * config.GetChainParams().GetConsensus().nPowTargetSpacing;
+        blocks[i].nBits = 0x207fffff; /* target 0x7fffff000... */
+        blocks[i].nChainWork =
+            i ? blocks[i - 1].nChainWork + GetBlockProof(blocks[i])
+              : arith_uint256(0);
+    }
+
+    for (int j = 0; j < 1000; j++) {
+        CBlockIndex *p1 = &blocks[InsecureRandRange(10000)];
+        CBlockIndex *p2 = &blocks[InsecureRandRange(10000)];
+        CBlockIndex *p3 = &blocks[InsecureRandRange(10000)];
+
+        int64_t tdiff = GetBlockProofEquivalentTime(
+            *p1, *p2, *p3, config.GetChainParams().GetConsensus());
+        BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime());
+    }
+}
+
+static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval,
+                                 uint32_t nBits) {
+    CBlockIndex block;
+    block.pprev = pindexPrev;
+    block.nHeight = pindexPrev->nHeight + 1;
+    block.nTime = pindexPrev->nTime + nTimeInterval;
+    block.nBits = nBits;
+
+    block.nChainWork = pindexPrev->nChainWork + GetBlockProof(block);
+    return block;
+}
+
+BOOST_AUTO_TEST_CASE(retargeting_test) {
+    DummyConfig config(CBaseChainParams::MAIN);
+
+    std::vector<CBlockIndex> blocks(115);
+
+    const Consensus::Params &params = config.GetChainParams().GetConsensus();
+    const arith_uint256 powLimit = UintToArith256(params.powLimit);
+    arith_uint256 currentPow = powLimit >> 1;
+    uint32_t initialBits = currentPow.GetCompact();
+
+    // Genesis block.
+    blocks[0] = CBlockIndex();
+    blocks[0].nHeight = 0;
+    blocks[0].nTime = 1269211443;
+    blocks[0].nBits = initialBits;
+
+    blocks[0].nChainWork = GetBlockProof(blocks[0]);
+
+    // Pile up some blocks.
+    for (size_t i = 1; i < 100; i++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], params.nPowTargetSpacing,
+                                  initialBits);
+    }
+
+    CBlockHeader blkHeaderDummy;
+
+    // We start getting 2h blocks time. For the first 5 blocks, it doesn't
+    // matter as the MTP is not affected. For the next 5 block, MTP difference
+    // increases but stays below 12h.
+    for (size_t i = 100; i < 110; i++) {
+        blocks[i] = GetBlockIndex(&blocks[i - 1], 2 * 3600, initialBits);
+        BOOST_CHECK_EQUAL(
+            GetNextEDAWorkRequired(&blocks[i], &blkHeaderDummy, params),
+            initialBits);
+    }
+
+    // Now we expect the difficulty to decrease.
+    blocks[110] = GetBlockIndex(&blocks[109], 2 * 3600, initialBits);
+    currentPow.SetCompact(currentPow.GetCompact());
+    currentPow += (currentPow >> 2);
+    BOOST_CHECK_EQUAL(
+        GetNextEDAWorkRequired(&blocks[110], &blkHeaderDummy, params),
+        currentPow.GetCompact());
+
+    // As we continue with 2h blocks, difficulty continue to decrease.
+    blocks[111] =
+        GetBlockIndex(&blocks[110], 2 * 3600, currentPow.GetCompact());
+    currentPow.SetCompact(currentPow.GetCompact());
+    currentPow += (currentPow >> 2);
+    BOOST_CHECK_EQUAL(
+        GetNextEDAWorkRequired(&blocks[111], &blkHeaderDummy, params),
+        currentPow.GetCompact());
+
+    // We decrease again.
+    blocks[112] =
+        GetBlockIndex(&blocks[111], 2 * 3600, currentPow.GetCompact());
+    currentPow.SetCompact(currentPow.GetCompact());
+    currentPow += (currentPow >> 2);
+    BOOST_CHECK_EQUAL(
+        GetNextEDAWorkRequired(&blocks[112], &blkHeaderDummy, params),
+        currentPow.GetCompact());
+
+    // We check that we do not go below the minimal difficulty.
+    blocks[113] =
+        GetBlockIndex(&blocks[112], 2 * 3600, currentPow.GetCompact());
+    currentPow.SetCompact(currentPow.GetCompact());
+    currentPow += (currentPow >> 2);
+    BOOST_CHECK(powLimit.GetCompact() != currentPow.GetCompact());
+    BOOST_CHECK_EQUAL(
+        GetNextEDAWorkRequired(&blocks[113], &blkHeaderDummy, params),
+        powLimit.GetCompact());
+
+    // Once we reached the minimal difficulty, we stick with it.
+    blocks[114] = GetBlockIndex(&blocks[113], 2 * 3600, powLimit.GetCompact());
+    BOOST_CHECK(powLimit.GetCompact() != currentPow.GetCompact());
+    BOOST_CHECK_EQUAL(
+        GetNextEDAWorkRequired(&blocks[114], &blkHeaderDummy, params),
+        powLimit.GetCompact());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/pow/test/fixture.cpp b/src/pow/test/fixture.cpp
new file mode 100644
--- /dev/null
+++ b/src/pow/test/fixture.cpp
@@ -0,0 +1,6 @@
+// Copyright (c) 2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#define BOOST_TEST_MODULE Difficulty Adjustement Test Suite
+#include <boost/test/unit_test.hpp>
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -17,7 +17,7 @@
 #include <net.h>
 #include <node/context.h>
 #include <policy/policy.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -156,7 +156,6 @@
 		op_reversebytes_tests.cpp
 		pmt_tests.cpp
 		policyestimator_tests.cpp
-		pow_tests.cpp
 		prevector_tests.cpp
 		radix_tests.cpp
 		raii_event_tests.cpp
diff --git a/src/test/blockencodings_tests.cpp b/src/test/blockencodings_tests.cpp
--- a/src/test/blockencodings_tests.cpp
+++ b/src/test/blockencodings_tests.cpp
@@ -7,7 +7,7 @@
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/merkle.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <streams.h>
 #include <txmempool.h>
 
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -8,7 +8,7 @@
 #include <consensus/validation.h>
 #include <index/blockfilterindex.h>
 #include <miner.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <script/standard.h>
 #include <test/util/blockfilter.h>
 #include <test/util/setup_common.h>
diff --git a/src/test/pow_tests.cpp b/src/test/pow_tests.cpp
deleted file mode 100644
--- a/src/test/pow_tests.cpp
+++ /dev/null
@@ -1,373 +0,0 @@
-// Copyright (c) 2015-2019 The Bitcoin Core developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <pow.h>
-
-#include <chain.h>
-#include <chainparams.h>
-#include <config.h>
-
-#include <test/util/setup_common.h>
-
-#include <boost/test/unit_test.hpp>
-
-BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
-
-/* Test calculation of next difficulty target with no constraints applying */
-BOOST_AUTO_TEST_CASE(get_next_work) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    int64_t nLastRetargetTime = 1261130161; // Block #30240
-    CBlockIndex pindexLast;
-    pindexLast.nHeight = 32255;
-    pindexLast.nTime = 1262152739; // Block #32255
-    pindexLast.nBits = 0x1d00ffff;
-    BOOST_CHECK_EQUAL(
-        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
-                                  config.GetChainParams().GetConsensus()),
-        0x1d00d86aU);
-}
-
-/* Test the constraint on the upper bound for next work */
-BOOST_AUTO_TEST_CASE(get_next_work_pow_limit) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    int64_t nLastRetargetTime = 1231006505; // Block #0
-    CBlockIndex pindexLast;
-    pindexLast.nHeight = 2015;
-    pindexLast.nTime = 1233061996; // Block #2015
-    pindexLast.nBits = 0x1d00ffff;
-    BOOST_CHECK_EQUAL(
-        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
-                                  config.GetChainParams().GetConsensus()),
-        0x1d00ffffU);
-}
-
-/* Test the constraint on the lower bound for actual time taken */
-BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    int64_t nLastRetargetTime = 1279008237; // Block #66528
-    CBlockIndex pindexLast;
-    pindexLast.nHeight = 68543;
-    pindexLast.nTime = 1279297671; // Block #68543
-    pindexLast.nBits = 0x1c05a3f4;
-    BOOST_CHECK_EQUAL(
-        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
-                                  config.GetChainParams().GetConsensus()),
-        0x1c0168fdU);
-}
-
-/* Test the constraint on the upper bound for actual time taken */
-BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    int64_t nLastRetargetTime = 1263163443; // NOTE: Not an actual block time
-    CBlockIndex pindexLast;
-    pindexLast.nHeight = 46367;
-    pindexLast.nTime = 1269211443; // Block #46367
-    pindexLast.nBits = 0x1c387f6f;
-    BOOST_CHECK_EQUAL(
-        CalculateNextWorkRequired(&pindexLast, nLastRetargetTime,
-                                  config.GetChainParams().GetConsensus()),
-        0x1d00e1fdU);
-}
-
-BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    std::vector<CBlockIndex> blocks(10000);
-    for (int i = 0; i < 10000; i++) {
-        blocks[i].pprev = i ? &blocks[i - 1] : nullptr;
-        blocks[i].nHeight = i;
-        blocks[i].nTime =
-            1269211443 +
-            i * config.GetChainParams().GetConsensus().nPowTargetSpacing;
-        blocks[i].nBits = 0x207fffff; /* target 0x7fffff000... */
-        blocks[i].nChainWork =
-            i ? blocks[i - 1].nChainWork + GetBlockProof(blocks[i])
-              : arith_uint256(0);
-    }
-
-    for (int j = 0; j < 1000; j++) {
-        CBlockIndex *p1 = &blocks[InsecureRandRange(10000)];
-        CBlockIndex *p2 = &blocks[InsecureRandRange(10000)];
-        CBlockIndex *p3 = &blocks[InsecureRandRange(10000)];
-
-        int64_t tdiff = GetBlockProofEquivalentTime(
-            *p1, *p2, *p3, config.GetChainParams().GetConsensus());
-        BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime());
-    }
-}
-
-static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval,
-                                 uint32_t nBits) {
-    CBlockIndex block;
-    block.pprev = pindexPrev;
-    block.nHeight = pindexPrev->nHeight + 1;
-    block.nTime = pindexPrev->nTime + nTimeInterval;
-    block.nBits = nBits;
-
-    block.nChainWork = pindexPrev->nChainWork + GetBlockProof(block);
-    return block;
-}
-
-BOOST_AUTO_TEST_CASE(retargeting_test) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    std::vector<CBlockIndex> blocks(115);
-
-    const Consensus::Params &params = config.GetChainParams().GetConsensus();
-    const arith_uint256 powLimit = UintToArith256(params.powLimit);
-    arith_uint256 currentPow = powLimit >> 1;
-    uint32_t initialBits = currentPow.GetCompact();
-
-    // Genesis block.
-    blocks[0] = CBlockIndex();
-    blocks[0].nHeight = 0;
-    blocks[0].nTime = 1269211443;
-    blocks[0].nBits = initialBits;
-
-    blocks[0].nChainWork = GetBlockProof(blocks[0]);
-
-    // Pile up some blocks.
-    for (size_t i = 1; i < 100; i++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], params.nPowTargetSpacing,
-                                  initialBits);
-    }
-
-    CBlockHeader blkHeaderDummy;
-
-    // We start getting 2h blocks time. For the first 5 blocks, it doesn't
-    // matter as the MTP is not affected. For the next 5 block, MTP difference
-    // increases but stays below 12h.
-    for (size_t i = 100; i < 110; i++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 2 * 3600, initialBits);
-        BOOST_CHECK_EQUAL(
-            GetNextWorkRequired(&blocks[i], &blkHeaderDummy, params),
-            initialBits);
-    }
-
-    // Now we expect the difficulty to decrease.
-    blocks[110] = GetBlockIndex(&blocks[109], 2 * 3600, initialBits);
-    currentPow.SetCompact(currentPow.GetCompact());
-    currentPow += (currentPow >> 2);
-    BOOST_CHECK_EQUAL(
-        GetNextWorkRequired(&blocks[110], &blkHeaderDummy, params),
-        currentPow.GetCompact());
-
-    // As we continue with 2h blocks, difficulty continue to decrease.
-    blocks[111] =
-        GetBlockIndex(&blocks[110], 2 * 3600, currentPow.GetCompact());
-    currentPow.SetCompact(currentPow.GetCompact());
-    currentPow += (currentPow >> 2);
-    BOOST_CHECK_EQUAL(
-        GetNextWorkRequired(&blocks[111], &blkHeaderDummy, params),
-        currentPow.GetCompact());
-
-    // We decrease again.
-    blocks[112] =
-        GetBlockIndex(&blocks[111], 2 * 3600, currentPow.GetCompact());
-    currentPow.SetCompact(currentPow.GetCompact());
-    currentPow += (currentPow >> 2);
-    BOOST_CHECK_EQUAL(
-        GetNextWorkRequired(&blocks[112], &blkHeaderDummy, params),
-        currentPow.GetCompact());
-
-    // We check that we do not go below the minimal difficulty.
-    blocks[113] =
-        GetBlockIndex(&blocks[112], 2 * 3600, currentPow.GetCompact());
-    currentPow.SetCompact(currentPow.GetCompact());
-    currentPow += (currentPow >> 2);
-    BOOST_CHECK(powLimit.GetCompact() != currentPow.GetCompact());
-    BOOST_CHECK_EQUAL(
-        GetNextWorkRequired(&blocks[113], &blkHeaderDummy, params),
-        powLimit.GetCompact());
-
-    // Once we reached the minimal difficulty, we stick with it.
-    blocks[114] = GetBlockIndex(&blocks[113], 2 * 3600, powLimit.GetCompact());
-    BOOST_CHECK(powLimit.GetCompact() != currentPow.GetCompact());
-    BOOST_CHECK_EQUAL(
-        GetNextWorkRequired(&blocks[114], &blkHeaderDummy, params),
-        powLimit.GetCompact());
-}
-
-BOOST_AUTO_TEST_CASE(cash_difficulty_test) {
-    DummyConfig config(CBaseChainParams::MAIN);
-
-    std::vector<CBlockIndex> blocks(3000);
-
-    const Consensus::Params &params = config.GetChainParams().GetConsensus();
-    const arith_uint256 powLimit = UintToArith256(params.powLimit);
-    uint32_t powLimitBits = powLimit.GetCompact();
-    arith_uint256 currentPow = powLimit >> 4;
-    uint32_t initialBits = currentPow.GetCompact();
-
-    // Genesis block.
-    blocks[0] = CBlockIndex();
-    blocks[0].nHeight = 0;
-    blocks[0].nTime = 1269211443;
-    blocks[0].nBits = initialBits;
-
-    blocks[0].nChainWork = GetBlockProof(blocks[0]);
-
-    // Block counter.
-    size_t i;
-
-    // Pile up some blocks every 10 mins to establish some history.
-    for (i = 1; i < 2050; i++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, initialBits);
-    }
-
-    CBlockHeader blkHeaderDummy;
-    uint32_t nBits =
-        GetNextCashWorkRequired(&blocks[2049], &blkHeaderDummy, params);
-
-    // Difficulty stays the same as long as we produce a block every 10 mins.
-    for (size_t j = 0; j < 10; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, nBits);
-        BOOST_CHECK_EQUAL(
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params),
-            nBits);
-    }
-
-    // Make sure we skip over blocks that are out of wack. To do so, we produce
-    // a block that is far in the future, and then produce a block with the
-    // expected timestamp.
-    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-    BOOST_CHECK_EQUAL(
-        GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
-    blocks[i] = GetBlockIndex(&blocks[i - 1], 2 * 600 - 6000, nBits);
-    BOOST_CHECK_EQUAL(
-        GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
-
-    // The system should continue unaffected by the block with a bogous
-    // timestamps.
-    for (size_t j = 0; j < 20; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 600, nBits);
-        BOOST_CHECK_EQUAL(
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params),
-            nBits);
-    }
-
-    // We start emitting blocks slightly faster. The first block has no impact.
-    blocks[i] = GetBlockIndex(&blocks[i - 1], 550, nBits);
-    BOOST_CHECK_EQUAL(
-        GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params), nBits);
-
-    // Now we should see difficulty increase slowly.
-    for (size_t j = 0; j < 10; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 550, nBits);
-        const uint32_t nextBits =
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
-
-        arith_uint256 currentTarget;
-        currentTarget.SetCompact(nBits);
-        arith_uint256 nextTarget;
-        nextTarget.SetCompact(nextBits);
-
-        // Make sure that difficulty increases very slowly.
-        BOOST_CHECK(nextTarget < currentTarget);
-        BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 10));
-
-        nBits = nextBits;
-    }
-
-    // Check the actual value.
-    BOOST_CHECK_EQUAL(nBits, 0x1c0fe7b1);
-
-    // If we dramatically shorten block production, difficulty increases faster.
-    for (size_t j = 0; j < 20; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 10, nBits);
-        const uint32_t nextBits =
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
-
-        arith_uint256 currentTarget;
-        currentTarget.SetCompact(nBits);
-        arith_uint256 nextTarget;
-        nextTarget.SetCompact(nextBits);
-
-        // Make sure that difficulty increases faster.
-        BOOST_CHECK(nextTarget < currentTarget);
-        BOOST_CHECK((currentTarget - nextTarget) < (currentTarget >> 4));
-
-        nBits = nextBits;
-    }
-
-    // Check the actual value.
-    BOOST_CHECK_EQUAL(nBits, 0x1c0db19f);
-
-    // We start to emit blocks significantly slower. The first block has no
-    // impact.
-    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-    nBits = GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params);
-
-    // Check the actual value.
-    BOOST_CHECK_EQUAL(nBits, 0x1c0d9222);
-
-    // If we dramatically slow down block production, difficulty decreases.
-    for (size_t j = 0; j < 93; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-        const uint32_t nextBits =
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
-
-        arith_uint256 currentTarget;
-        currentTarget.SetCompact(nBits);
-        arith_uint256 nextTarget;
-        nextTarget.SetCompact(nextBits);
-
-        // Check the difficulty decreases.
-        BOOST_CHECK(nextTarget <= powLimit);
-        BOOST_CHECK(nextTarget > currentTarget);
-        BOOST_CHECK((nextTarget - currentTarget) < (currentTarget >> 3));
-
-        nBits = nextBits;
-    }
-
-    // Check the actual value.
-    BOOST_CHECK_EQUAL(nBits, 0x1c2f13b9);
-
-    // Due to the window of time being bounded, next block's difficulty actually
-    // gets harder.
-    blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-    nBits = GetNextCashWorkRequired(&blocks[i++], &blkHeaderDummy, params);
-    BOOST_CHECK_EQUAL(nBits, 0x1c2ee9bf);
-
-    // And goes down again. It takes a while due to the window being bounded and
-    // the skewed block causes 2 blocks to get out of the window.
-    for (size_t j = 0; j < 192; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-        const uint32_t nextBits =
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
-
-        arith_uint256 currentTarget;
-        currentTarget.SetCompact(nBits);
-        arith_uint256 nextTarget;
-        nextTarget.SetCompact(nextBits);
-
-        // Check the difficulty decreases.
-        BOOST_CHECK(nextTarget <= powLimit);
-        BOOST_CHECK(nextTarget > currentTarget);
-        BOOST_CHECK((nextTarget - currentTarget) < (currentTarget >> 3));
-
-        nBits = nextBits;
-    }
-
-    // Check the actual value.
-    BOOST_CHECK_EQUAL(nBits, 0x1d00ffff);
-
-    // Once the difficulty reached the minimum allowed level, it doesn't get any
-    // easier.
-    for (size_t j = 0; j < 5; i++, j++) {
-        blocks[i] = GetBlockIndex(&blocks[i - 1], 6000, nBits);
-        const uint32_t nextBits =
-            GetNextCashWorkRequired(&blocks[i], &blkHeaderDummy, params);
-
-        // Check the difficulty stays constant.
-        BOOST_CHECK_EQUAL(nextBits, powLimitBits);
-        nBits = nextBits;
-    }
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util.cpp b/src/test/util.cpp
--- a/src/test/util.cpp
+++ b/src/test/util.cpp
@@ -9,7 +9,7 @@
 #include <consensus/merkle.h>
 #include <key_io.h>
 #include <miner.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <validation.h>
 
 #ifdef ENABLE_WALLET
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -15,7 +15,7 @@
 #include <miner.h>
 #include <net.h>
 #include <noui.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <rpc/blockchain.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -10,7 +10,7 @@
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <miner.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <random.h>
 #include <test/util/setup_common.h>
 #include <util/time.h>
diff --git a/src/txdb.cpp b/src/txdb.cpp
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -6,7 +6,7 @@
 #include <txdb.h>
 
 #include <chain.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <random.h>
 #include <shutdown.h>
 #include <ui_interface.h>
diff --git a/src/validation.cpp b/src/validation.cpp
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -25,7 +25,7 @@
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
-#include <pow.h>
+#include <pow/pow.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <random.h>