diff --git a/src/policy/fees.cpp b/src/policy/fees.cpp
index 85135747ff..6c529557b9 100644
--- a/src/policy/fees.cpp
+++ b/src/policy/fees.cpp
@@ -1,29 +1,29 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2018 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "policy/fees.h"
-#include "amount.h"
-#include "feerate.h"
+#include <amount.h>
+#include <feerate.h>
+#include <policy/fees.h>
 
 FeeFilterRounder::FeeFilterRounder(const CFeeRate &minIncrementalFee) {
     Amount minFeeLimit = std::max(SATOSHI, minIncrementalFee.GetFeePerK() / 2);
     feeset.insert(Amount::zero());
     for (double bucketBoundary = minFeeLimit / SATOSHI;
          bucketBoundary <= double(MAX_FEERATE / SATOSHI);
          bucketBoundary *= FEE_SPACING) {
         feeset.insert(int64_t(bucketBoundary) * SATOSHI);
     }
 }
 
 Amount FeeFilterRounder::round(const Amount currentMinFee) {
     auto it = feeset.lower_bound(currentMinFee);
     if ((it != feeset.begin() && insecure_rand.rand32() % 3 != 0) ||
         it == feeset.end()) {
         it--;
     }
 
     return *it;
 }
diff --git a/src/policy/fees.h b/src/policy/fees.h
index 6b65ab4b6f..b49c6dbfc3 100644
--- a/src/policy/fees.h
+++ b/src/policy/fees.h
@@ -1,40 +1,40 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #ifndef BITCOIN_POLICYESTIMATOR_H
 #define BITCOIN_POLICYESTIMATOR_H
 
-#include "amount.h"
-#include "random.h"
-#include "uint256.h"
+#include <amount.h>
+#include <random.h>
+#include <uint256.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 class CFeeRate;
 
 // Minimum and Maximum values for tracking feerates
 static constexpr Amount MIN_FEERATE(10 * SATOSHI);
 static const Amount MAX_FEERATE(int64_t(1e7) * SATOSHI);
 
 // We have to lump transactions into buckets based on feerate, but we want to be
 // able to give accurate estimates over a large range of potential feerates.
 // Therefore it makes sense to exponentially space the buckets
 /** Spacing of FeeRate buckets */
 static const double FEE_SPACING = 1.1;
 
 class FeeFilterRounder {
 public:
     /** Create new FeeFilterRounder */
     explicit FeeFilterRounder(const CFeeRate &minIncrementalFee);
 
     /** Quantize a minimum fee for privacy purpose before broadcast **/
     Amount round(const Amount currentMinFee);
 
 private:
     std::set<Amount> feeset;
     FastRandomContext insecure_rand;
 };
 #endif /*BITCOIN_POLICYESTIMATOR_H */
diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
index 0118e64844..a6bccbbcb6 100644
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -1,155 +1,155 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 // NOTE: This file is intended to be customised by the end user, and includes
 // only local node policy logic
 
-#include "policy/policy.h"
+#include <policy/policy.h>
 
-#include "script/interpreter.h"
-#include "tinyformat.h"
-#include "util.h"
-#include "utilstrencodings.h"
-#include "validation.h"
+#include <script/interpreter.h>
+#include <tinyformat.h>
+#include <util.h>
+#include <utilstrencodings.h>
+#include <validation.h>
 
 /**
  * Check transaction inputs to mitigate two potential denial-of-service attacks:
  *
  * 1. scriptSigs with extra data stuffed into them, not consumed by scriptPubKey
  * (or P2SH script)
  * 2. P2SH scripts with a crazy number of expensive CHECKSIG/CHECKMULTISIG
  * operations
  *
  * Why bother? To avoid denial-of-service attacks; an attacker can submit a
  * standard HASH... OP_EQUAL transaction, which will get accepted into blocks.
  * The redemption script can be anything; an attacker could use a very
  * expensive-to-check-upon-redemption script like:
  *   DUP CHECKSIG DROP ... repeated 100 times... OP_1
  */
 bool IsStandard(const CScript &scriptPubKey, txnouttype &whichType) {
     std::vector<std::vector<uint8_t>> vSolutions;
     if (!Solver(scriptPubKey, whichType, vSolutions)) {
         return false;
     }
 
     if (whichType == TX_MULTISIG) {
         uint8_t m = vSolutions.front()[0];
         uint8_t n = vSolutions.back()[0];
         // Support up to x-of-3 multisig txns as standard
         if (n < 1 || n > 3) return false;
         if (m < 1 || m > n) return false;
     } else if (whichType == TX_NULL_DATA) {
         if (!fAcceptDatacarrier) {
             return false;
         }
 
         unsigned nMaxDatacarrierBytes =
             gArgs.GetArg("-datacarriersize", MAX_OP_RETURN_RELAY);
         if (scriptPubKey.size() > nMaxDatacarrierBytes) {
             return false;
         }
     }
 
     return whichType != TX_NONSTANDARD;
 }
 
 bool IsStandardTx(const CTransaction &tx, std::string &reason) {
     if (tx.nVersion > CTransaction::MAX_STANDARD_VERSION || tx.nVersion < 1) {
         reason = "version";
         return false;
     }
 
     // Extremely large transactions with lots of inputs can cost the network
     // almost as much to process as they cost the sender in fees, because
     // computing signature hashes is O(ninputs*txsize). Limiting transactions
     // to MAX_STANDARD_TX_SIZE mitigates CPU exhaustion attacks.
     uint32_t sz = tx.GetTotalSize();
     if (sz >= MAX_STANDARD_TX_SIZE) {
         reason = "tx-size";
         return false;
     }
 
     for (const CTxIn &txin : tx.vin) {
         if (txin.scriptSig.size() > MAX_TX_IN_SCRIPT_SIG_SIZE) {
             reason = "scriptsig-size";
             return false;
         }
         if (!txin.scriptSig.IsPushOnly()) {
             reason = "scriptsig-not-pushonly";
             return false;
         }
     }
 
     unsigned int nDataOut = 0;
     txnouttype whichType;
     for (const CTxOut &txout : tx.vout) {
         if (!::IsStandard(txout.scriptPubKey, whichType)) {
             reason = "scriptpubkey";
             return false;
         }
 
         if (whichType == TX_NULL_DATA) {
             nDataOut++;
         } else if ((whichType == TX_MULTISIG) && (!fIsBareMultisigStd)) {
             reason = "bare-multisig";
             return false;
         } else if (txout.IsDust(dustRelayFee)) {
             reason = "dust";
             return false;
         }
     }
 
     // only one OP_RETURN txout is permitted
     if (nDataOut > 1) {
         reason = "multi-op-return";
         return false;
     }
 
     return true;
 }
 
 bool AreInputsStandard(const CTransaction &tx,
                        const CCoinsViewCache &mapInputs) {
     if (tx.IsCoinBase()) {
         // Coinbases don't use vin normally.
         return true;
     }
 
     for (const CTxIn &in : tx.vin) {
         const CTxOut &prev = mapInputs.GetOutputFor(in);
 
         std::vector<std::vector<uint8_t>> vSolutions;
         txnouttype whichType;
         // get the scriptPubKey corresponding to this input:
         const CScript &prevScript = prev.scriptPubKey;
         if (!Solver(prevScript, whichType, vSolutions)) {
             return false;
         }
 
         if (whichType == TX_SCRIPTHASH) {
             std::vector<std::vector<uint8_t>> stack;
             // convert the scriptSig into a stack, so we can inspect the
             // redeemScript
             if (!EvalScript(stack, in.scriptSig, SCRIPT_VERIFY_NONE,
                             BaseSignatureChecker())) {
                 return false;
             }
             if (stack.empty()) {
                 return false;
             }
 
             CScript subscript(stack.back().begin(), stack.back().end());
             if (subscript.GetSigOpCount(STANDARD_CHECKDATASIG_VERIFY_FLAGS,
                                         true) > MAX_P2SH_SIGOPS) {
                 return false;
             }
         }
     }
 
     return true;
 }
 
 CFeeRate dustRelayFee = CFeeRate(DUST_RELAY_TX_FEE);
 uint32_t nBytesPerSigOp = DEFAULT_BYTES_PER_SIGOP;
diff --git a/src/policy/policy.h b/src/policy/policy.h
index 910a89cb4b..10ecae1cee 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -1,133 +1,133 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_POLICY_POLICY_H
 #define BITCOIN_POLICY_POLICY_H
 
-#include "consensus/consensus.h"
-#include "feerate.h"
-#include "script/standard.h"
+#include <consensus/consensus.h>
+#include <feerate.h>
+#include <script/standard.h>
 
 #include <string>
 
 class CCoinsViewCache;
 class CTransaction;
 
 /**
  * Default for -blockmaxsize, which controls the maximum size of block the
  * mining code will create.
  */
 static const uint64_t DEFAULT_MAX_GENERATED_BLOCK_SIZE = 2 * ONE_MEGABYTE;
 /**
  * Default for -blockprioritypercentage, define the amount of block space
  * reserved to high priority transactions.
  */
 static const uint64_t DEFAULT_BLOCK_PRIORITY_PERCENTAGE = 5;
 /**
  * Default for -blockmintxfee, which sets the minimum feerate for a transaction
  * in blocks created by mining code.
  */
 static const Amount DEFAULT_BLOCK_MIN_TX_FEE_PER_KB(1000 * SATOSHI);
 /**
  * The maximum size for transactions we're willing to relay/mine.
  */
 static const unsigned int MAX_STANDARD_TX_SIZE = 100000;
 
 /**
  * Biggest 'standard' txin is a 15-of-15 P2SH multisig with compressed
  * keys (remember the 520 byte limit on redeemScript size). That works
  * out to a (15*(33+1))+3=513 byte redeemScript, 513+1+15*(73+1)+3=1627
  * bytes of scriptSig, which we round off to 1650 bytes for some minor
  * future-proofing. That's also enough to spend a 20-of-20 CHECKMULTISIG
  * scriptPubKey, though such a scriptPubKey is not considered standard.
  */
 static const unsigned int MAX_TX_IN_SCRIPT_SIG_SIZE = 1650;
 
 /**
  * Maximum number of signature check operations in an IsStandard() P2SH script.
  */
 static const unsigned int MAX_P2SH_SIGOPS = 15;
 /**
  * The maximum number of sigops we're willing to relay/mine in a single tx.
  */
 static const unsigned int MAX_STANDARD_TX_SIGOPS = MAX_TX_SIGOPS_COUNT / 5;
 /**
  * Default for -maxmempool, maximum megabytes of mempool memory usage.
  */
 static const unsigned int DEFAULT_MAX_MEMPOOL_SIZE = 300;
 /**
  * Default for -incrementalrelayfee, which sets the minimum feerate increase for
  * mempool limiting or BIP 125 replacement.
  */
 static const CFeeRate MEMPOOL_FULL_FEE_INCREMENT(1000 * SATOSHI);
 /**
  * Default for -bytespersigop .
  */
 static const unsigned int DEFAULT_BYTES_PER_SIGOP = 20;
 /**
  * Min feerate for defining dust. Historically this has been the same as the
  * minRelayTxFee, however changing the dust limit changes which transactions are
  * standard and should be done with care and ideally rarely. It makes sense to
  * only increase the dust limit after prior releases were already not creating
  * outputs below the new threshold.
  */
 static const Amount DUST_RELAY_TX_FEE(1000 * SATOSHI);
 
 /**
  * Standard script verification flags that standard transactions will comply
  * with. However scripts violating these flags may still be present in valid
  * blocks and we must accept those blocks.
  */
 static const uint32_t STANDARD_SCRIPT_VERIFY_FLAGS =
     MANDATORY_SCRIPT_VERIFY_FLAGS | SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S |
     SCRIPT_VERIFY_NULLDUMMY | SCRIPT_VERIFY_SIGPUSHONLY |
     SCRIPT_VERIFY_MINIMALDATA | SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS |
     SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY |
     SCRIPT_VERIFY_CHECKSEQUENCEVERIFY | SCRIPT_VERIFY_NULLFAIL;
 
 /**
  * For convenience, standard but not mandatory verify flags.
  */
 static const uint32_t STANDARD_NOT_MANDATORY_VERIFY_FLAGS =
     STANDARD_SCRIPT_VERIFY_FLAGS & ~MANDATORY_SCRIPT_VERIFY_FLAGS;
 
 /**
  * Used as the flags parameter to sequence and nLocktime checks in non-consensus
  * code.
  */
 static const uint32_t STANDARD_LOCKTIME_VERIFY_FLAGS =
     LOCKTIME_VERIFY_SEQUENCE | LOCKTIME_MEDIAN_TIME_PAST;
 
 /**
  * Used as the flags parameters to check for sigops as if OP_CHECKDATASIG is
  * enabled. Can be removed after OP_CHECKDATASIG is activated as the flag is
  * made standard.
  */
 static const uint32_t STANDARD_CHECKDATASIG_VERIFY_FLAGS =
     STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_CHECKDATASIG;
 
 bool IsStandard(const CScript &scriptPubKey, txnouttype &whichType);
 
 /**
  * Check for standard transaction types
  * @return True if all outputs (scriptPubKeys) use only standard transaction
  * forms
  */
 bool IsStandardTx(const CTransaction &tx, std::string &reason);
 
 /**
  * Check for standard transaction types
  * @param[in] mapInputs    Map of previous transactions that have outputs we're
  * spending
  * @return True if all inputs (scriptSigs) use only standard transaction forms
  */
 bool AreInputsStandard(const CTransaction &tx,
                        const CCoinsViewCache &mapInputs);
 
 extern CFeeRate incrementalRelayFee;
 extern CFeeRate dustRelayFee;
 extern uint32_t nBytesPerSigOp;
 
 #endif // BITCOIN_POLICY_POLICY_H