diff --git a/src/bloom.h b/src/bloom.h
index 3e1141f761..99f147fdb8 100644
--- a/src/bloom.h
+++ b/src/bloom.h
@@ -1,149 +1,149 @@
 // Copyright (c) 2012-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_BLOOM_H
 #define BITCOIN_BLOOM_H
 
-#include "serialize.h"
+#include <serialize.h>
 
 #include <cstdint>
 #include <vector>
 
 class COutPoint;
 class CTransaction;
 class uint256;
 
 //! 20,000 items with fp rate < 0.1% or 10,000 items and <0.0001%
 static const uint32_t MAX_BLOOM_FILTER_SIZE = 36000; // bytes
 static const uint32_t MAX_HASH_FUNCS = 50;
 
 /**
  * First two bits of nFlags control how much IsRelevantAndUpdate actually
  * updates. The remaining bits are reserved.
  */
 enum bloomflags {
     BLOOM_UPDATE_NONE = 0,
     BLOOM_UPDATE_ALL = 1,
     // Only adds outpoints to the filter if the output is a
     // pay-to-pubkey/pay-to-multisig script
     BLOOM_UPDATE_P2PUBKEY_ONLY = 2,
     BLOOM_UPDATE_MASK = 3,
 };
 
 /**
  * BloomFilter is a probabilistic filter which SPV clients provide so that we
  * can filter the transactions we send them.
  *
  * This allows for significantly more efficient transaction and block downloads.
  *
  * Because bloom filters are probabilistic, a SPV node can increase the
  * false-positive rate, making us send it transactions which aren't actually
  * its, allowing clients to trade more bandwidth for more privacy by obfuscating
  * which keys are controlled by them.
  */
 class CBloomFilter {
 private:
     std::vector<uint8_t> vData;
     bool isFull;
     bool isEmpty;
     uint32_t nHashFuncs;
     uint32_t nTweak;
     uint8_t nFlags;
 
     uint32_t Hash(uint32_t nHashNum,
                   const std::vector<uint8_t> &vDataToHash) const;
 
     // Private constructor for CRollingBloomFilter, no restrictions on size
     CBloomFilter(uint32_t nElements, double nFPRate, uint32_t nTweak);
     friend class CRollingBloomFilter;
 
 public:
     /**
      * Creates a new bloom filter which will provide the given fp rate when
      * filled with the given number of elements. Note that if the given
      * parameters will result in a filter outside the bounds of the protocol
      * limits, the filter created will be as close to the given parameters as
      * possible within the protocol limits. This will apply if nFPRate is very
      * low or nElements is unreasonably high. nTweak is a constant which is
      * added to the seed value passed to the hash function. It should generally
      * always be a random value (and is largely only exposed for unit testing)
      * nFlags should be one of the BLOOM_UPDATE_* enums (not _MASK)
      */
     CBloomFilter(uint32_t nElements, double nFPRate, uint32_t nTweak,
                  uint8_t nFlagsIn);
     CBloomFilter()
         : isFull(true), isEmpty(false), nHashFuncs(0), nTweak(0), nFlags(0) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(vData);
         READWRITE(nHashFuncs);
         READWRITE(nTweak);
         READWRITE(nFlags);
     }
 
     void insert(const std::vector<uint8_t> &vKey);
     void insert(const COutPoint &outpoint);
     void insert(const uint256 &hash);
 
     bool contains(const std::vector<uint8_t> &vKey) const;
     bool contains(const COutPoint &outpoint) const;
     bool contains(const uint256 &hash) const;
 
     void clear();
     void reset(uint32_t nNewTweak);
 
     //! True if the size is <= MAX_BLOOM_FILTER_SIZE and the number of hash
     //! functions is <= MAX_HASH_FUNCS (catch a filter which was just
     //! deserialized which was too big)
     bool IsWithinSizeConstraints() const;
 
     //! Also adds any outputs which match the filter to the filter (to match
     //! their spending txes)
     bool IsRelevantAndUpdate(const CTransaction &tx);
 
     //! Checks for empty and full filters to avoid wasting cpu
     void UpdateEmptyFull();
 };
 
 /**
  * RollingBloomFilter is a probabilistic "keep track of most recently inserted"
  * set. Construct it with the number of items to keep track of, and a
  * false-positive rate. Unlike CBloomFilter, by default nTweak is set to a
  * cryptographically secure random value for you. Similarly rather than clear()
  * the method reset() is provided, which also changes nTweak to decrease the
  * impact of false-positives.
  *
  * contains(item) will always return true if item was one of the last N to 1.5*N
  * insert()'ed ... but may also return true for items that were not inserted.
  *
  * It needs around 1.8 bytes per element per factor 0.1 of false positive rate.
  * (More accurately: 3/(log(256)*log(2)) * log(1/fpRate) * nElements bytes)
  */
 class CRollingBloomFilter {
 public:
     // A random bloom filter calls GetRand() at creation time. Don't create
     // global CRollingBloomFilter objects, as they may be constructed before the
     // randomizer is properly initialized.
     CRollingBloomFilter(uint32_t nElements, double nFPRate);
 
     void insert(const std::vector<uint8_t> &vKey);
     void insert(const uint256 &hash);
     bool contains(const std::vector<uint8_t> &vKey) const;
     bool contains(const uint256 &hash) const;
 
     void reset();
 
 private:
     int nEntriesPerGeneration;
     int nEntriesThisGeneration;
     int nGeneration;
     std::vector<uint64_t> data;
     uint32_t nTweak;
     int nHashFuncs;
 };
 
 #endif // BITCOIN_BLOOM_H
diff --git a/src/cashaddr.cpp b/src/cashaddr.cpp
index 6e09693e27..3dcb71f891 100644
--- a/src/cashaddr.cpp
+++ b/src/cashaddr.cpp
@@ -1,299 +1,299 @@
 // Copyright (c) 2017 Pieter Wuille
 // Copyright (c) 2017 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "cashaddr.h"
+#include <cashaddr.h>
 
 namespace {
 
 typedef std::vector<uint8_t> data;
 
 /**
  * The cashaddr character set for encoding.
  */
 const char *CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
 
 /**
  * The cashaddr character set for decoding.
  */
 const int8_t CHARSET_REV[128] = {
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 15, -1, 10, 17, 21, 20, 26, 30, 7,
     5,  -1, -1, -1, -1, -1, -1, -1, 29, -1, 24, 13, 25, 9,  8,  23, -1, 18, 22,
     31, 27, 19, -1, 1,  0,  3,  16, 11, 28, 12, 14, 6,  4,  2,  -1, -1, -1, -1,
     -1, -1, 29, -1, 24, 13, 25, 9,  8,  23, -1, 18, 22, 31, 27, 19, -1, 1,  0,
     3,  16, 11, 28, 12, 14, 6,  4,  2,  -1, -1, -1, -1, -1};
 
 /**
  * Concatenate two byte arrays.
  */
 data Cat(data x, const data &y) {
     x.insert(x.end(), y.begin(), y.end());
     return x;
 }
 
 /**
  * This function will compute what 8 5-bit values to XOR into the last 8 input
  * values, in order to make the checksum 0. These 8 values are packed together
  * in a single 40-bit integer. The higher bits correspond to earlier values.
  */
 uint64_t PolyMod(const data &v) {
     /**
      * The input is interpreted as a list of coefficients of a polynomial over F
      * = GF(32), with an implicit 1 in front. If the input is [v0,v1,v2,v3,v4],
      * that polynomial is v(x) = 1*x^5 + v0*x^4 + v1*x^3 + v2*x^2 + v3*x + v4.
      * The implicit 1 guarantees that [v0,v1,v2,...] has a distinct checksum
      * from [0,v0,v1,v2,...].
      *
      * The output is a 40-bit integer whose 5-bit groups are the coefficients of
      * the remainder of v(x) mod g(x), where g(x) is the cashaddr generator, x^8
      * + {19}*x^7 + {3}*x^6 + {25}*x^5 + {11}*x^4 + {25}*x^3 + {3}*x^2 + {19}*x
      * + {1}. g(x) is chosen in such a way that the resulting code is a BCH
      * code, guaranteeing detection of up to 4 errors within a window of 1025
      * characters. Among the various possible BCH codes, one was selected to in
      * fact guarantee detection of up to 5 errors within a window of 160
      * characters and 6 erros within a window of 126 characters. In addition,
      * the code guarantee the detection of a burst of up to 8 errors.
      *
      * Note that the coefficients are elements of GF(32), here represented as
      * decimal numbers between {}. In this finite field, addition is just XOR of
      * the corresponding numbers. For example, {27} + {13} = {27 ^ 13} = {22}.
      * Multiplication is more complicated, and requires treating the bits of
      * values themselves as coefficients of a polynomial over a smaller field,
      * GF(2), and multiplying those polynomials mod a^5 + a^3 + 1. For example,
      * {5} * {26} = (a^2 + 1) * (a^4 + a^3 + a) = (a^4 + a^3 + a) * a^2 + (a^4 +
      * a^3 + a) = a^6 + a^5 + a^4 + a = a^3 + 1 (mod a^5 + a^3 + 1) = {9}.
      *
      * During the course of the loop below, `c` contains the bitpacked
      * coefficients of the polynomial constructed from just the values of v that
      * were processed so far, mod g(x). In the above example, `c` initially
      * corresponds to 1 mod (x), and after processing 2 inputs of v, it
      * corresponds to x^2 + v0*x + v1 mod g(x). As 1 mod g(x) = 1, that is the
      * starting value for `c`.
      */
     uint64_t c = 1;
     for (uint8_t d : v) {
         /**
          * We want to update `c` to correspond to a polynomial with one extra
          * term. If the initial value of `c` consists of the coefficients of
          * c(x) = f(x) mod g(x), we modify it to correspond to
          * c'(x) = (f(x) * x + d) mod g(x), where d is the next input to
          * process.
          *
          * Simplifying:
          * c'(x) = (f(x) * x + d) mod g(x)
          *         ((f(x) mod g(x)) * x + d) mod g(x)
          *         (c(x) * x + d) mod g(x)
          * If c(x) = c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5, we want to
          * compute
          * c'(x) = (c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5) * x + d
          *                                                             mod g(x)
          *       = c0*x^6 + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + d
          *                                                             mod g(x)
          *       = c0*(x^6 mod g(x)) + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 +
          *                                                             c5*x + d
          * If we call (x^6 mod g(x)) = k(x), this can be written as
          * c'(x) = (c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + d) + c0*k(x)
          */
 
         // First, determine the value of c0:
         uint8_t c0 = c >> 35;
 
         // Then compute c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + d:
         c = ((c & 0x07ffffffff) << 5) ^ d;
 
         // Finally, for each set bit n in c0, conditionally add {2^n}k(x):
         if (c0 & 0x01) {
             // k(x) = {19}*x^7 + {3}*x^6 + {25}*x^5 + {11}*x^4 + {25}*x^3 +
             //        {3}*x^2 + {19}*x + {1}
             c ^= 0x98f2bc8e61;
         }
 
         if (c0 & 0x02) {
             // {2}k(x) = {15}*x^7 + {6}*x^6 + {27}*x^5 + {22}*x^4 + {27}*x^3 +
             //           {6}*x^2 + {15}*x + {2}
             c ^= 0x79b76d99e2;
         }
 
         if (c0 & 0x04) {
             // {4}k(x) = {30}*x^7 + {12}*x^6 + {31}*x^5 + {5}*x^4 + {31}*x^3 +
             //           {12}*x^2 + {30}*x + {4}
             c ^= 0xf33e5fb3c4;
         }
 
         if (c0 & 0x08) {
             // {8}k(x) = {21}*x^7 + {24}*x^6 + {23}*x^5 + {10}*x^4 + {23}*x^3 +
             //           {24}*x^2 + {21}*x + {8}
             c ^= 0xae2eabe2a8;
         }
 
         if (c0 & 0x10) {
             // {16}k(x) = {3}*x^7 + {25}*x^6 + {7}*x^5 + {20}*x^4 + {7}*x^3 +
             //            {25}*x^2 + {3}*x + {16}
             c ^= 0x1e4f43e470;
         }
     }
 
     /**
      * PolyMod computes what value to xor into the final values to make the
      * checksum 0. However, if we required that the checksum was 0, it would be
      * the case that appending a 0 to a valid list of values would result in a
      * new valid list. For that reason, cashaddr requires the resulting checksum
      * to be 1 instead.
      */
     return c ^ 1;
 }
 
 /**
  * Convert to lower case.
  *
  * Assume the input is a character.
  */
 inline uint8_t LowerCase(uint8_t c) {
     // ASCII black magic.
     return c | 0x20;
 }
 
 /**
  * Expand the address prefix for the checksum computation.
  */
 data ExpandPrefix(const std::string &prefix) {
     data ret;
     ret.resize(prefix.size() + 1);
     for (size_t i = 0; i < prefix.size(); ++i) {
         ret[i] = prefix[i] & 0x1f;
     }
 
     ret[prefix.size()] = 0;
     return ret;
 }
 
 /**
  * Verify a checksum.
  */
 bool VerifyChecksum(const std::string &prefix, const data &payload) {
     return PolyMod(Cat(ExpandPrefix(prefix), payload)) == 0;
 }
 
 /**
  * Create a checksum.
  */
 data CreateChecksum(const std::string &prefix, const data &payload) {
     data enc = Cat(ExpandPrefix(prefix), payload);
     // Append 8 zeroes.
     enc.resize(enc.size() + 8);
     // Determine what to XOR into those 8 zeroes.
     uint64_t mod = PolyMod(enc);
     data ret(8);
     for (size_t i = 0; i < 8; ++i) {
         // Convert the 5-bit groups in mod to checksum values.
         ret[i] = (mod >> (5 * (7 - i))) & 0x1f;
     }
 
     return ret;
 }
 
 } // namespace
 
 namespace cashaddr {
 
 /**
  * Encode a cashaddr string.
  */
 std::string Encode(const std::string &prefix, const data &payload) {
     data checksum = CreateChecksum(prefix, payload);
     data combined = Cat(payload, checksum);
     std::string ret = prefix + ':';
 
     ret.reserve(ret.size() + combined.size());
     for (uint8_t c : combined) {
         ret += CHARSET[c];
     }
 
     return ret;
 }
 
 /**
  * Decode a cashaddr string.
  */
 std::pair<std::string, data> Decode(const std::string &str,
                                     const std::string &default_prefix) {
     // Go over the string and do some sanity checks.
     bool lower = false, upper = false, hasNumber = false;
     size_t prefixSize = 0;
     for (size_t i = 0; i < str.size(); ++i) {
         uint8_t c = str[i];
         if (c >= 'a' && c <= 'z') {
             lower = true;
             continue;
         }
 
         if (c >= 'A' && c <= 'Z') {
             upper = true;
             continue;
         }
 
         if (c >= '0' && c <= '9') {
             // We cannot have numbers in the prefix.
             hasNumber = true;
             continue;
         }
 
         if (c == ':') {
             // The separator cannot be the first character, cannot have number
             // and there must not be 2 separators.
             if (hasNumber || i == 0 || prefixSize != 0) {
                 return {};
             }
 
             prefixSize = i;
             continue;
         }
 
         // We have an unexpected character.
         return {};
     }
 
     // We can't have both upper case and lowercase.
     if (upper && lower) {
         return {};
     }
 
     // Get the prefix.
     std::string prefix;
     if (prefixSize == 0) {
         prefix = default_prefix;
     } else {
         prefix.reserve(prefixSize);
         for (size_t i = 0; i < prefixSize; ++i) {
             prefix += LowerCase(str[i]);
         }
 
         // Now add the ':' in the size.
         prefixSize++;
     }
 
     // Decode values.
     const size_t valuesSize = str.size() - prefixSize;
     data values(valuesSize);
     for (size_t i = 0; i < valuesSize; ++i) {
         uint8_t c = str[i + prefixSize];
         // We have an invalid char in there.
         if (c > 127 || CHARSET_REV[c] == -1) {
             return {};
         }
 
         values[i] = CHARSET_REV[c];
     }
 
     // Verify the checksum.
     if (!VerifyChecksum(prefix, values)) {
         return {};
     }
 
     return {std::move(prefix), data(values.begin(), values.end() - 8)};
 }
 
 } // namespace cashaddr
diff --git a/src/cashaddrenc.cpp b/src/cashaddrenc.cpp
index 081a264842..ce1d9a4d64 100644
--- a/src/cashaddrenc.cpp
+++ b/src/cashaddrenc.cpp
@@ -1,189 +1,190 @@
 // Copyright (c) 2017 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
-#include "cashaddrenc.h"
-#include "cashaddr.h"
-#include "chainparams.h"
-#include "pubkey.h"
-#include "script/script.h"
-#include "utilstrencodings.h"
+#include <cashaddrenc.h>
+
+#include <cashaddr.h>
+#include <chainparams.h>
+#include <pubkey.h>
+#include <script/script.h>
+#include <utilstrencodings.h>
 
 #include <boost/variant/static_visitor.hpp>
 
 #include <algorithm>
 
 namespace {
 
 // Convert the data part to a 5 bit representation.
 template <class T>
 std::vector<uint8_t> PackAddrData(const T &id, uint8_t type) {
     uint8_t version_byte(type << 3);
     size_t size = id.size();
     uint8_t encoded_size = 0;
     switch (size * 8) {
         case 160:
             encoded_size = 0;
             break;
         case 192:
             encoded_size = 1;
             break;
         case 224:
             encoded_size = 2;
             break;
         case 256:
             encoded_size = 3;
             break;
         case 320:
             encoded_size = 4;
             break;
         case 384:
             encoded_size = 5;
             break;
         case 448:
             encoded_size = 6;
             break;
         case 512:
             encoded_size = 7;
             break;
         default:
             throw std::runtime_error(
                 "Error packing cashaddr: invalid address length");
     }
     version_byte |= encoded_size;
     std::vector<uint8_t> data = {version_byte};
     data.insert(data.end(), std::begin(id), std::end(id));
 
     std::vector<uint8_t> converted;
     // Reserve the number of bytes required for a 5-bit packed version of a
     // hash, with version byte.  Add half a byte(4) so integer math provides
     // the next multiple-of-5 that would fit all the data.
     converted.reserve(((size + 1) * 8 + 4) / 5);
     ConvertBits<8, 5, true>(converted, std::begin(data), std::end(data));
 
     return converted;
 }
 
 // Implements encoding of CTxDestination using cashaddr.
 class CashAddrEncoder : public boost::static_visitor<std::string> {
 public:
     CashAddrEncoder(const CChainParams &p) : params(p) {}
 
     std::string operator()(const CKeyID &id) const {
         std::vector<uint8_t> data = PackAddrData(id, PUBKEY_TYPE);
         return cashaddr::Encode(params.CashAddrPrefix(), data);
     }
 
     std::string operator()(const CScriptID &id) const {
         std::vector<uint8_t> data = PackAddrData(id, SCRIPT_TYPE);
         return cashaddr::Encode(params.CashAddrPrefix(), data);
     }
 
     std::string operator()(const CNoDestination &) const { return ""; }
 
 private:
     const CChainParams &params;
 };
 
 } // namespace
 
 std::string EncodeCashAddr(const CTxDestination &dst,
                            const CChainParams &params) {
     return boost::apply_visitor(CashAddrEncoder(params), dst);
 }
 
 std::string EncodeCashAddr(const std::string &prefix,
                            const CashAddrContent &content) {
     std::vector<uint8_t> data = PackAddrData(content.hash, content.type);
     return cashaddr::Encode(prefix, data);
 }
 
 CTxDestination DecodeCashAddr(const std::string &addr,
                               const CChainParams &params) {
     CashAddrContent content =
         DecodeCashAddrContent(addr, params.CashAddrPrefix());
     if (content.hash.size() == 0) {
         return CNoDestination{};
     }
 
     return DecodeCashAddrDestination(content);
 }
 
 CashAddrContent DecodeCashAddrContent(const std::string &addr,
                                       const std::string &expectedPrefix) {
     std::string prefix;
     std::vector<uint8_t> payload;
     std::tie(prefix, payload) = cashaddr::Decode(addr, expectedPrefix);
 
     if (prefix != expectedPrefix) {
         return {};
     }
 
     if (payload.empty()) {
         return {};
     }
 
     // Check that the padding is zero.
     size_t extrabits = payload.size() * 5 % 8;
     if (extrabits >= 5) {
         // We have more padding than allowed.
         return {};
     }
 
     uint8_t last = payload.back();
     uint8_t mask = (1 << extrabits) - 1;
     if (last & mask) {
         // We have non zero bits as padding.
         return {};
     }
 
     std::vector<uint8_t> data;
     data.reserve(payload.size() * 5 / 8);
     ConvertBits<5, 8, false>(data, begin(payload), end(payload));
 
     // Decode type and size from the version.
     uint8_t version = data[0];
     if (version & 0x80) {
         // First bit is reserved.
         return {};
     }
 
     auto type = CashAddrType((version >> 3) & 0x1f);
     uint32_t hash_size = 20 + 4 * (version & 0x03);
     if (version & 0x04) {
         hash_size *= 2;
     }
 
     // Check that we decoded the exact number of bytes we expected.
     if (data.size() != hash_size + 1) {
         return {};
     }
 
     // Pop the version.
     data.erase(data.begin());
     return {type, std::move(data)};
 }
 
 CTxDestination DecodeCashAddrDestination(const CashAddrContent &content) {
     if (content.hash.size() != 20) {
         // Only 20 bytes hash are supported now.
         return CNoDestination{};
     }
 
     uint160 hash;
     std::copy(begin(content.hash), end(content.hash), hash.begin());
 
     switch (content.type) {
         case PUBKEY_TYPE:
             return CKeyID(hash);
         case SCRIPT_TYPE:
             return CScriptID(hash);
         default:
             return CNoDestination{};
     }
 }
 
 // PackCashAddrContent allows for testing PackAddrData in unittests due to
 // template definitions.
 std::vector<uint8_t> PackCashAddrContent(const CashAddrContent &content) {
     return PackAddrData(content.hash, content.type);
 }
diff --git a/src/cashaddrenc.h b/src/cashaddrenc.h
index a54def06e0..7b0d715fe6 100644
--- a/src/cashaddrenc.h
+++ b/src/cashaddrenc.h
@@ -1,32 +1,32 @@
 // Copyright (c) 2017 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_CASHADDRENC_H
 #define BITCOIN_CASHADDRENC_H
 
-#include "script/standard.h"
+#include <script/standard.h>
 
 #include <string>
 #include <vector>
 
 class CChainParams;
 
 enum CashAddrType : uint8_t { PUBKEY_TYPE = 0, SCRIPT_TYPE = 1 };
 
 struct CashAddrContent {
     CashAddrType type;
     std::vector<uint8_t> hash;
 };
 
 std::string EncodeCashAddr(const CTxDestination &, const CChainParams &);
 std::string EncodeCashAddr(const std::string &prefix,
                            const CashAddrContent &content);
 
 CTxDestination DecodeCashAddr(const std::string &addr,
                               const CChainParams &params);
 CashAddrContent DecodeCashAddrContent(const std::string &addr,
                                       const std::string &prefix);
 CTxDestination DecodeCashAddrDestination(const CashAddrContent &content);
 
 std::vector<uint8_t> PackCashAddrContent(const CashAddrContent &content);
 #endif
diff --git a/src/chain.cpp b/src/chain.cpp
index 761921fd48..6eba2cd035 100644
--- a/src/chain.cpp
+++ b/src/chain.cpp
@@ -1,193 +1,193 @@
 // 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.
 
-#include "chain.h"
+#include <chain.h>
 
 /**
  * CChain implementation
  */
 void CChain::SetTip(CBlockIndex *pindex) {
     if (pindex == nullptr) {
         vChain.clear();
         return;
     }
 
     vChain.resize(pindex->nHeight + 1);
     while (pindex && vChain[pindex->nHeight] != pindex) {
         vChain[pindex->nHeight] = pindex;
         pindex = pindex->pprev;
     }
 }
 
 CBlockLocator CChain::GetLocator(const CBlockIndex *pindex) const {
     int nStep = 1;
     std::vector<uint256> vHave;
     vHave.reserve(32);
 
     if (!pindex) {
         pindex = Tip();
     }
     while (pindex) {
         vHave.push_back(pindex->GetBlockHash());
         // Stop when we have added the genesis block.
         if (pindex->nHeight == 0) {
             break;
         }
         // Exponentially larger steps back, plus the genesis block.
         int nHeight = std::max(pindex->nHeight - nStep, 0);
         if (Contains(pindex)) {
             // Use O(1) CChain index if possible.
             pindex = (*this)[nHeight];
         } else {
             // Otherwise, use O(log n) skiplist.
             pindex = pindex->GetAncestor(nHeight);
         }
         if (vHave.size() > 10) {
             nStep *= 2;
         }
     }
 
     return CBlockLocator(vHave);
 }
 
 const CBlockIndex *CChain::FindFork(const CBlockIndex *pindex) const {
     if (pindex == nullptr) {
         return nullptr;
     }
     if (pindex->nHeight > Height()) {
         pindex = pindex->GetAncestor(Height());
     }
     while (pindex && !Contains(pindex)) {
         pindex = pindex->pprev;
     }
     return pindex;
 }
 
 CBlockIndex *CChain::FindEarliestAtLeast(int64_t nTime) const {
     std::vector<CBlockIndex *>::const_iterator lower =
         std::lower_bound(vChain.begin(), vChain.end(), nTime,
                          [](CBlockIndex *pBlock, const int64_t &time) -> bool {
                              return pBlock->GetBlockTimeMax() < time;
                          });
     return (lower == vChain.end() ? nullptr : *lower);
 }
 
 /** Turn the lowest '1' bit in the binary representation of a number into a '0'.
  */
 static inline int InvertLowestOne(int n) {
     return n & (n - 1);
 }
 
 /** Compute what height to jump back to with the CBlockIndex::pskip pointer. */
 static inline int GetSkipHeight(int height) {
     if (height < 2) {
         return 0;
     }
 
     // Determine which height to jump back to. Any number strictly lower than
     // height is acceptable, but the following expression seems to perform well
     // in simulations (max 110 steps to go back up to 2**18 blocks).
     return (height & 1) ? InvertLowestOne(InvertLowestOne(height - 1)) + 1
                         : InvertLowestOne(height);
 }
 
 CBlockIndex *CBlockIndex::GetAncestor(int height) {
     if (height > nHeight || height < 0) {
         return nullptr;
     }
 
     CBlockIndex *pindexWalk = this;
     int heightWalk = nHeight;
     while (heightWalk > height) {
         int heightSkip = GetSkipHeight(heightWalk);
         int heightSkipPrev = GetSkipHeight(heightWalk - 1);
         if (pindexWalk->pskip != nullptr &&
             (heightSkip == height ||
              (heightSkip > height && !(heightSkipPrev < heightSkip - 2 &&
                                        heightSkipPrev >= height)))) {
             // Only follow pskip if pprev->pskip isn't better than pskip->pprev.
             pindexWalk = pindexWalk->pskip;
             heightWalk = heightSkip;
         } else {
             assert(pindexWalk->pprev);
             pindexWalk = pindexWalk->pprev;
             heightWalk--;
         }
     }
     return pindexWalk;
 }
 
 const CBlockIndex *CBlockIndex::GetAncestor(int height) const {
     return const_cast<CBlockIndex *>(this)->GetAncestor(height);
 }
 
 void CBlockIndex::BuildSkip() {
     if (pprev) {
         pskip = pprev->GetAncestor(GetSkipHeight(nHeight));
     }
 }
 
 arith_uint256 GetBlockProof(const CBlockIndex &block) {
     arith_uint256 bnTarget;
     bool fNegative;
     bool fOverflow;
     bnTarget.SetCompact(block.nBits, &fNegative, &fOverflow);
     if (fNegative || fOverflow || bnTarget == 0) {
         return 0;
     }
     // We need to compute 2**256 / (bnTarget+1), but we can't represent 2**256
     // as it's too large for a arith_uint256. However, as 2**256 is at least as
     // large as bnTarget+1, it is equal to ((2**256 - bnTarget - 1) /
     // (bnTarget+1)) + 1, or ~bnTarget / (nTarget+1) + 1.
     return (~bnTarget / (bnTarget + 1)) + 1;
 }
 
 int64_t GetBlockProofEquivalentTime(const CBlockIndex &to,
                                     const CBlockIndex &from,
                                     const CBlockIndex &tip,
                                     const Consensus::Params &params) {
     arith_uint256 r;
     int sign = 1;
     if (to.nChainWork > from.nChainWork) {
         r = to.nChainWork - from.nChainWork;
     } else {
         r = from.nChainWork - to.nChainWork;
         sign = -1;
     }
     r = r * arith_uint256(params.nPowTargetSpacing) / GetBlockProof(tip);
     if (r.bits() > 63) {
         return sign * std::numeric_limits<int64_t>::max();
     }
     return sign * r.GetLow64();
 }
 
 /**
  * Find the last common ancestor two blocks have.
  * Both pa and pb must be non null.
  */
 const CBlockIndex *LastCommonAncestor(const CBlockIndex *pa,
                                       const CBlockIndex *pb) {
     if (pa->nHeight > pb->nHeight) {
         pa = pa->GetAncestor(pb->nHeight);
     } else if (pb->nHeight > pa->nHeight) {
         pb = pb->GetAncestor(pa->nHeight);
     }
 
     while (pa != pb && pa && pb) {
         pa = pa->pprev;
         pb = pb->pprev;
     }
 
     // Eventually all chain branches meet at the genesis block.
     assert(pa == pb);
     return pa;
 }
 
 bool AreOnTheSameFork(const CBlockIndex *pa, const CBlockIndex *pb) {
     // The common ancestor needs to be either pa (pb is a child of pa) or pb (pa
     // is a child of pb).
     const CBlockIndex *pindexCommon = LastCommonAncestor(pa, pb);
     return pindexCommon == pa || pindexCommon == pb;
 }
diff --git a/src/chain.h b/src/chain.h
index c34c3279ad..c6f08c3679 100644
--- a/src/chain.h
+++ b/src/chain.h
@@ -1,419 +1,419 @@
 // 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_CHAIN_H
 #define BITCOIN_CHAIN_H
 
-#include "arith_uint256.h"
-#include "blockstatus.h"
-#include "blockvalidity.h"
-#include "consensus/params.h"
-#include "diskblockpos.h"
-#include "pow.h"
-#include "primitives/block.h"
-#include "sync.h"
-#include "tinyformat.h"
-#include "uint256.h"
+#include <arith_uint256.h>
+#include <blockstatus.h>
+#include <blockvalidity.h>
+#include <consensus/params.h>
+#include <diskblockpos.h>
+#include <pow.h>
+#include <primitives/block.h>
+#include <sync.h>
+#include <tinyformat.h>
+#include <uint256.h>
 
 #include <unordered_map>
 #include <vector>
 
 /**
  * Maximum amount of time that a block timestamp is allowed to exceed the
  * current network-adjusted time before the block will be accepted.
  */
 static const int64_t MAX_FUTURE_BLOCK_TIME = 2 * 60 * 60;
 
 /**
  * Timestamp window used as a grace period by code that compares external
  * timestamps (such as timestamps passed to RPCs, or wallet key creation times)
  * to block timestamps. This should be set at least as high as
  * MAX_FUTURE_BLOCK_TIME.
  */
 static const int64_t TIMESTAMP_WINDOW = MAX_FUTURE_BLOCK_TIME;
 
 /**
  * The block chain is a tree shaped structure starting with the genesis block at
  * the root, with each block potentially having multiple candidates to be the
  * next block. A blockindex may have multiple pprev pointing to it, but at most
  * one of them can be part of the currently active branch.
  */
 class CBlockIndex {
 public:
     //! pointer to the hash of the block, if any. Memory is owned by this
     //! CBlockIndex
     const uint256 *phashBlock;
 
     //! pointer to the index of the predecessor of this block
     CBlockIndex *pprev;
 
     //! pointer to the index of some further predecessor of this block
     CBlockIndex *pskip;
 
     //! height of the entry in the chain. The genesis block has height 0
     int nHeight;
 
     //! Which # file this block is stored in (blk?????.dat)
     int nFile;
 
     //! Byte offset within blk?????.dat where this block's data is stored
     unsigned int nDataPos;
 
     //! Byte offset within rev?????.dat where this block's undo data is stored
     unsigned int nUndoPos;
 
     //! (memory only) Total amount of work (expected number of hashes) in the
     //! chain up to and including this block
     arith_uint256 nChainWork;
 
     //! Number of transactions in this block.
     //! Note: in a potential headers-first mode, this number cannot be relied
     //! upon
     unsigned int nTx;
 
     //! (memory only) Number of transactions in the chain up to and including
     //! this block.
     //! This value will be non-zero only if and only if transactions for this
     //! block and all its parents are available. Change to 64-bit type when
     //! necessary; won't happen before 2030
     unsigned int nChainTx;
 
     //! Verification status of this block. See enum BlockStatus
     BlockStatus nStatus;
 
     //! block header
     int32_t nVersion;
     uint256 hashMerkleRoot;
     uint32_t nTime;
     uint32_t nBits;
     uint32_t nNonce;
 
     //! (memory only) Sequential id assigned to distinguish order in which
     //! blocks are received.
     int32_t nSequenceId;
 
     //! (memory only) block header metadata
     uint64_t nTimeReceived;
 
     //! (memory only) Maximum nTime in the chain upto and including this block.
     unsigned int nTimeMax;
 
     void SetNull() {
         phashBlock = nullptr;
         pprev = nullptr;
         pskip = nullptr;
         nHeight = 0;
         nFile = 0;
         nDataPos = 0;
         nUndoPos = 0;
         nChainWork = arith_uint256();
         nTx = 0;
         nChainTx = 0;
         nStatus = BlockStatus();
         nSequenceId = 0;
         nTimeMax = 0;
 
         nVersion = 0;
         hashMerkleRoot = uint256();
         nTime = 0;
         nTimeReceived = 0;
         nBits = 0;
         nNonce = 0;
     }
 
     CBlockIndex() { SetNull(); }
 
     explicit CBlockIndex(const CBlockHeader &block) {
         SetNull();
 
         nVersion = block.nVersion;
         hashMerkleRoot = block.hashMerkleRoot;
         nTime = block.nTime;
         nTimeReceived = 0;
         nBits = block.nBits;
         nNonce = block.nNonce;
     }
 
     CDiskBlockPos GetBlockPos() const {
         CDiskBlockPos ret;
         if (nStatus.hasData()) {
             ret.nFile = nFile;
             ret.nPos = nDataPos;
         }
         return ret;
     }
 
     CDiskBlockPos GetUndoPos() const {
         CDiskBlockPos ret;
         if (nStatus.hasUndo()) {
             ret.nFile = nFile;
             ret.nPos = nUndoPos;
         }
         return ret;
     }
 
     CBlockHeader GetBlockHeader() const {
         CBlockHeader block;
         block.nVersion = nVersion;
         if (pprev) {
             block.hashPrevBlock = pprev->GetBlockHash();
         }
         block.hashMerkleRoot = hashMerkleRoot;
         block.nTime = nTime;
         block.nBits = nBits;
         block.nNonce = nNonce;
         return block;
     }
 
     uint256 GetBlockHash() const { return *phashBlock; }
 
     int64_t GetBlockTime() const { return int64_t(nTime); }
 
     int64_t GetBlockTimeMax() const { return int64_t(nTimeMax); }
 
     int64_t GetHeaderReceivedTime() const { return nTimeReceived; }
 
     int64_t GetReceivedTimeDiff() const {
         return GetHeaderReceivedTime() - GetBlockTime();
     }
 
     static constexpr int nMedianTimeSpan = 11;
 
     int64_t GetMedianTimePast() const {
         int64_t pmedian[nMedianTimeSpan];
         int64_t *pbegin = &pmedian[nMedianTimeSpan];
         int64_t *pend = &pmedian[nMedianTimeSpan];
 
         const CBlockIndex *pindex = this;
         for (int i = 0; i < nMedianTimeSpan && pindex;
              i++, pindex = pindex->pprev) {
             *(--pbegin) = pindex->GetBlockTime();
         }
 
         std::sort(pbegin, pend);
         return pbegin[(pend - pbegin) / 2];
     }
 
     std::string ToString() const {
         return strprintf(
             "CBlockIndex(pprev=%p, nHeight=%d, merkle=%s, hashBlock=%s)", pprev,
             nHeight, hashMerkleRoot.ToString(), GetBlockHash().ToString());
     }
 
     //! Check whether this block index entry is valid up to the passed validity
     //! level.
     bool IsValid(enum BlockValidity nUpTo = BlockValidity::TRANSACTIONS) const {
         return nStatus.isValid(nUpTo);
     }
 
     //! Raise the validity level of this block index entry.
     //! Returns true if the validity was changed.
     bool RaiseValidity(enum BlockValidity nUpTo) {
         // Only validity flags allowed.
         if (nStatus.isInvalid()) {
             return false;
         }
 
         if (nStatus.getValidity() >= nUpTo) {
             return false;
         }
 
         nStatus = nStatus.withValidity(nUpTo);
         return true;
     }
 
     //! Build the skiplist pointer for this entry.
     void BuildSkip();
 
     //! Efficiently find an ancestor of this block.
     CBlockIndex *GetAncestor(int height);
     const CBlockIndex *GetAncestor(int height) const;
 };
 
 /**
  * Maintain a map of CBlockIndex for all known headers.
  */
 struct BlockHasher {
     size_t operator()(const uint256 &hash) const { return hash.GetCheapHash(); }
 };
 
 typedef std::unordered_map<uint256, CBlockIndex *, BlockHasher> BlockMap;
 extern BlockMap &mapBlockIndex;
 extern CCriticalSection cs_main;
 
 inline CBlockIndex *LookupBlockIndex(const uint256 &hash) {
     AssertLockHeld(cs_main);
     BlockMap::const_iterator it = mapBlockIndex.find(hash);
     return it == mapBlockIndex.end() ? nullptr : it->second;
 }
 
 arith_uint256 GetBlockProof(const CBlockIndex &block);
 
 /**
  * Return the time it would take to redo the work difference between from and
  * to, assuming the current hashrate corresponds to the difficulty at tip, in
  * seconds.
  */
 int64_t GetBlockProofEquivalentTime(const CBlockIndex &to,
                                     const CBlockIndex &from,
                                     const CBlockIndex &tip,
                                     const Consensus::Params &);
 /**
  * Find the forking point between two chain tips.
  */
 const CBlockIndex *LastCommonAncestor(const CBlockIndex *pa,
                                       const CBlockIndex *pb);
 
 /**
  * Check if two block index are on the same fork.
  */
 bool AreOnTheSameFork(const CBlockIndex *pa, const CBlockIndex *pb);
 
 /** Used to marshal pointers into hashes for db storage. */
 class CDiskBlockIndex : public CBlockIndex {
 public:
     uint256 hashPrev;
 
     CDiskBlockIndex() { hashPrev = uint256(); }
 
     explicit CDiskBlockIndex(const CBlockIndex *pindex) : CBlockIndex(*pindex) {
         hashPrev = (pprev ? pprev->GetBlockHash() : uint256());
     }
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         int _nVersion = s.GetVersion();
         if (!(s.GetType() & SER_GETHASH)) {
             READWRITE(VARINT(_nVersion));
         }
 
         READWRITE(VARINT(nHeight));
         READWRITE(nStatus);
         READWRITE(VARINT(nTx));
         if (nStatus.hasData() || nStatus.hasUndo()) {
             READWRITE(VARINT(nFile));
         }
         if (nStatus.hasData()) {
             READWRITE(VARINT(nDataPos));
         }
         if (nStatus.hasUndo()) {
             READWRITE(VARINT(nUndoPos));
         }
 
         // block header
         READWRITE(this->nVersion);
         READWRITE(hashPrev);
         READWRITE(hashMerkleRoot);
         READWRITE(nTime);
         READWRITE(nBits);
         READWRITE(nNonce);
     }
 
     uint256 GetBlockHash() const {
         CBlockHeader block;
         block.nVersion = nVersion;
         block.hashPrevBlock = hashPrev;
         block.hashMerkleRoot = hashMerkleRoot;
         block.nTime = nTime;
         block.nBits = nBits;
         block.nNonce = nNonce;
         return block.GetHash();
     }
 
     std::string ToString() const {
         std::string str = "CDiskBlockIndex(";
         str += CBlockIndex::ToString();
         str += strprintf("\n                hashBlock=%s, hashPrev=%s)",
                          GetBlockHash().ToString(), hashPrev.ToString());
         return str;
     }
 };
 
 /**
  * An in-memory indexed chain of blocks.
  */
 class CChain {
 private:
     std::vector<CBlockIndex *> vChain;
 
 public:
     /**
      * Returns the index entry for the genesis block of this chain, or nullptr
      * if none.
      */
     CBlockIndex *Genesis() const {
         return vChain.size() > 0 ? vChain[0] : nullptr;
     }
 
     /**
      * Returns the index entry for the tip of this chain, or nullptr if none.
      */
     CBlockIndex *Tip() const {
         return vChain.size() > 0 ? vChain[vChain.size() - 1] : nullptr;
     }
 
     /**
      * Returns the index entry at a particular height in this chain, or nullptr
      * if no such height exists.
      */
     CBlockIndex *operator[](int nHeight) const {
         if (nHeight < 0 || nHeight >= (int)vChain.size()) {
             return nullptr;
         }
         return vChain[nHeight];
     }
 
     /** Compare two chains efficiently. */
     friend bool operator==(const CChain &a, const CChain &b) {
         return a.vChain.size() == b.vChain.size() &&
                a.vChain[a.vChain.size() - 1] == b.vChain[b.vChain.size() - 1];
     }
 
     /** Efficiently check whether a block is present in this chain. */
     bool Contains(const CBlockIndex *pindex) const {
         return (*this)[pindex->nHeight] == pindex;
     }
 
     /**
      * Find the successor of a block in this chain, or nullptr if the given
      * index is not found or is the tip.
      */
     CBlockIndex *Next(const CBlockIndex *pindex) const {
         if (!Contains(pindex)) {
             return nullptr;
         }
 
         return (*this)[pindex->nHeight + 1];
     }
 
     /**
      * Return the maximal height in the chain. Is equal to chain.Tip() ?
      * chain.Tip()->nHeight : -1.
      */
     int Height() const { return vChain.size() - 1; }
 
     /** Set/initialize a chain with a given tip. */
     void SetTip(CBlockIndex *pindex);
 
     /**
      * Return a CBlockLocator that refers to a block in this chain (by default
      * the tip).
      */
     CBlockLocator GetLocator(const CBlockIndex *pindex = nullptr) const;
 
     /**
      * Find the last common block between this chain and a block index entry.
      */
     const CBlockIndex *FindFork(const CBlockIndex *pindex) const;
 
     /**
      * Find the earliest block with timestamp equal or greater than the given.
      */
     CBlockIndex *FindEarliestAtLeast(int64_t nTime) const;
 };
 
 #endif // BITCOIN_CHAIN_H
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 9ec8d29797..e98ca4d496 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -1,509 +1,508 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-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 "chainparams.h"
-#include "consensus/merkle.h"
+#include <chainparams.h>
 
-#include "tinyformat.h"
-#include "util.h"
-#include "utilstrencodings.h"
+#include <chainparamsseeds.h>
+#include <consensus/merkle.h>
+#include <tinyformat.h>
+#include <util.h>
+#include <utilstrencodings.h>
 
 #include <cassert>
 
-#include "chainparamsseeds.h"
-
 static CBlock CreateGenesisBlock(const char *pszTimestamp,
                                  const CScript &genesisOutputScript,
                                  uint32_t nTime, uint32_t nNonce,
                                  uint32_t nBits, int32_t nVersion,
                                  const Amount genesisReward) {
     CMutableTransaction txNew;
     txNew.nVersion = 1;
     txNew.vin.resize(1);
     txNew.vout.resize(1);
     txNew.vin[0].scriptSig =
         CScript() << 486604799 << CScriptNum(4)
                   << std::vector<uint8_t>((const uint8_t *)pszTimestamp,
                                           (const uint8_t *)pszTimestamp +
                                               strlen(pszTimestamp));
     txNew.vout[0].nValue = genesisReward;
     txNew.vout[0].scriptPubKey = genesisOutputScript;
 
     CBlock genesis;
     genesis.nTime = nTime;
     genesis.nBits = nBits;
     genesis.nNonce = nNonce;
     genesis.nVersion = nVersion;
     genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
     genesis.hashPrevBlock.SetNull();
     genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
     return genesis;
 }
 
 /**
  * Build the genesis block. Note that the output of its generation transaction
  * cannot be spent since it did not originally exist in the database.
  *
  * CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000,
  * hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893,
  * vtx=1)
  *   CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
  *     CTxIn(COutPoint(000000, -1), coinbase
  * 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
  *     CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
  *   vMerkleTree: 4a5e1e
  */
 static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce,
                                  uint32_t nBits, int32_t nVersion,
                                  const Amount genesisReward) {
     const char *pszTimestamp =
         "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
     const CScript genesisOutputScript =
         CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
                               "de5c384df7ba0b8d578a4c702b6bf11d5f")
                   << OP_CHECKSIG;
     return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce,
                               nBits, nVersion, genesisReward);
 }
 
 /**
  * Main network
  */
 /**
  * What makes a good checkpoint block?
  * + Is surrounded by blocks with reasonable timestamps
  *   (no blocks before with a timestamp after, none after with
  *    timestamp before)
  * + Contains no strange transactions
  */
 class CMainParams : public CChainParams {
 public:
     CMainParams() {
         strNetworkID = "main";
         consensus.nSubsidyHalvingInterval = 210000;
         consensus.BIP34Height = 227931;
         consensus.BIP34Hash = uint256S(
             "000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
         // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
         consensus.BIP65Height = 388381;
         // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
         consensus.BIP66Height = 363725;
         // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
         consensus.CSVHeight = 419328;
         consensus.powLimit = uint256S(
             "00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         // two weeks
         consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
         consensus.nPowTargetSpacing = 10 * 60;
         consensus.fPowAllowMinDifficultyBlocks = false;
         consensus.fPowNoRetargeting = false;
         // 95% of 2016
         consensus.nRuleChangeActivationThreshold = 1916;
         // nPowTargetTimespan / nPowTargetSpacing
         consensus.nMinerConfirmationWindow = 2016;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
         // January 1, 2008
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime =
             1199145601;
         // December 31, 2008
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout =
             1230767999;
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork = uint256S(
             "000000000000000000000000000000000000000000e69facb8ace3926ead407c");
 
         // By default assume that the signatures in ancestors of this block are
         // valid.
         consensus.defaultAssumeValid = uint256S(
             "000000000000000001cfa7b6cb48a93d07d8e7f474edcf4fe9b32b7525afe971");
 
         // August 1, 2017 hard fork
         consensus.uahfHeight = 478558;
 
         // November 13, 2017 hard fork
         consensus.daaHeight = 504031;
 
         // November 15, 2018 hard fork
         consensus.magneticAnomalyHeight = 556766;
 
         // Wed, 15 May 2019 12:00:00 UTC hard fork
         consensus.greatWallActivationTime = 1557921600;
 
         // Nov 15, 2019 12:00:00 UTC protocol upgrade
         consensus.gravitonActivationTime = 1573819200;
 
         /**
          * The message start string is designed to be unlikely to occur in
          * normal data. The characters are rarely used upper ASCII, not valid as
          * UTF-8, and produce a large 32-bit integer with any alignment.
          */
         diskMagic[0] = 0xf9;
         diskMagic[1] = 0xbe;
         diskMagic[2] = 0xb4;
         diskMagic[3] = 0xd9;
         netMagic[0] = 0xe3;
         netMagic[1] = 0xe1;
         netMagic[2] = 0xf3;
         netMagic[3] = 0xe8;
         nDefaultPort = 8333;
         nPruneAfterHeight = 100000;
 
         genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1,
                                      50 * COIN);
         consensus.hashGenesisBlock = genesis.GetHash();
         assert(consensus.hashGenesisBlock ==
                uint256S("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1"
                         "b60a8ce26f"));
         assert(genesis.hashMerkleRoot ==
                uint256S("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b"
                         "7afdeda33b"));
 
         // Note that of those which support the service bits prefix, most only
         // support a subset of possible options. This is fine at runtime as
         // we'll fall back to using them as a oneshot if they dont support the
         // service bits we want, but we should get them updated to support all
         // service bits wanted by any release ASAP to avoid it where possible.
         // Bitcoin ABC seeder
         vSeeds.emplace_back("seed.bitcoinabc.org");
         // bitcoinforks seeders
         vSeeds.emplace_back("seed-abc.bitcoinforks.org");
         // BU backed seeder
         vSeeds.emplace_back("btccash-seeder.bitcoinunlimited.info");
         // Bitprim
         vSeeds.emplace_back("seed.bitprim.org");
         // Amaury SÉCHET
         vSeeds.emplace_back("seed.deadalnix.me");
         // criptolayer.net
         vSeeds.emplace_back("seeder.criptolayer.net");
 
         base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 0);
         base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 5);
         base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 128);
         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
         cashaddrPrefix = "bitcoincash";
 
         vFixedSeeds = std::vector<SeedSpec6>(
             pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));
 
         fDefaultConsistencyChecks = false;
         fRequireStandard = true;
         fMineBlocksOnDemand = false;
 
         checkpointData = {
             .mapCheckpoints = {
                 {11111, uint256S("0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee"
                                  "92559f542fdb26e7c1d")},
                 {33333, uint256S("000000002dd5588a74784eaa7ab0507a18ad16a236e7b"
                                  "1ce69f00d7ddfb5d0a6")},
                 {74000, uint256S("0000000000573993a3c9e41ce34471c079dcf5f52a0e8"
                                  "24a81e7f953b8661a20")},
                 {105000, uint256S("00000000000291ce28027faea320c8d2b054b2e0fe44"
                                   "a773f3eefb151d6bdc97")},
                 {134444, uint256S("00000000000005b12ffd4cd315cd34ffd4a594f430ac"
                                   "814c91184a0d42d2b0fe")},
                 {168000, uint256S("000000000000099e61ea72015e79632f216fe6cb33d7"
                                   "899acb35b75c8303b763")},
                 {193000, uint256S("000000000000059f452a5f7340de6682a977387c1701"
                                   "0ff6e6c3bd83ca8b1317")},
                 {210000, uint256S("000000000000048b95347e83192f69cf0366076336c6"
                                   "39f9b7228e9ba171342e")},
                 {216116, uint256S("00000000000001b4f4b433e81ee46494af945cf96014"
                                   "816a4e2370f11b23df4e")},
                 {225430, uint256S("00000000000001c108384350f74090433e7fcf79a606"
                                   "b8e797f065b130575932")},
                 {250000, uint256S("000000000000003887df1f29024b06fc2200b55f8af8"
                                   "f35453d7be294df2d214")},
                 {279000, uint256S("0000000000000001ae8c72a0b0c301f67e3afca10e81"
                                   "9efa9041e458e9bd7e40")},
                 {295000, uint256S("00000000000000004d9b4ef50f0f9d686fd69db2e03a"
                                   "f35a100370c64632a983")},
                 // UAHF fork block.
                 {478558, uint256S("0000000000000000011865af4122fe3b144e2cbeea86"
                                   "142e8ff2fb4107352d43")},
                 // Nov, 13 DAA activation block.
                 {504031, uint256S("0000000000000000011ebf65b60d0a3de80b8175be70"
                                   "9d653b4c1a1beeb6ab9c")},
                 // Monolith activation.
                 {530359, uint256S("0000000000000000011ada8bd08f46074f44a8f15539"
                                   "6f43e38acf9501c49103")},
                 // Magnetic anomaly activation.
                 {556767, uint256S("0000000000000000004626ff6e3b936941d341c5932e"
                                   "ce4357eeccac44e6d56c")},
             }};
 
         // Data as of block
         // 000000000000000001d2ce557406b017a928be25ee98906397d339c3f68eec5d
         // (height 523992).
         chainTxData = ChainTxData{
             // UNIX timestamp of last known number of transactions.
             1522608016,
             // Total number of transactions between genesis and that timestamp
             // (the tx=... number in the SetBestChain debug.log lines)
             248589038,
             // Estimated number of transactions per second after that timestamp.
             3.2};
     }
 };
 
 /**
  * Testnet (v3)
  */
 class CTestNetParams : public CChainParams {
 public:
     CTestNetParams() {
         strNetworkID = "test";
         consensus.nSubsidyHalvingInterval = 210000;
         consensus.BIP34Height = 21111;
         consensus.BIP34Hash = uint256S(
             "0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");
         // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
         consensus.BIP65Height = 581885;
         // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
         consensus.BIP66Height = 330776;
         // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
         consensus.CSVHeight = 770112;
         consensus.powLimit = uint256S(
             "00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         // two weeks
         consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
         consensus.nPowTargetSpacing = 10 * 60;
         consensus.fPowAllowMinDifficultyBlocks = true;
         consensus.fPowNoRetargeting = false;
         // 75% for testchains
         consensus.nRuleChangeActivationThreshold = 1512;
         // nPowTargetTimespan / nPowTargetSpacing
         consensus.nMinerConfirmationWindow = 2016;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
         // January 1, 2008
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime =
             1199145601;
         // December 31, 2008
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout =
             1230767999;
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork = uint256S(
             "000000000000000000000000000000000000000000000043cb761ba833f844c5");
 
         // By default assume that the signatures in ancestors of this block are
         // valid.
         consensus.defaultAssumeValid = uint256S(
             "00000000000002cb911c0a756a24c2fe6c1a29acaede3569ce430b95d8ff012d");
 
         // August 1, 2017 hard fork
         consensus.uahfHeight = 1155875;
 
         // November 13, 2017 hard fork
         consensus.daaHeight = 1188697;
 
         // November 15, 2018 hard fork
         consensus.magneticAnomalyHeight = 1267996;
 
         // Wed, 15 May 2019 12:00:00 UTC hard fork
         consensus.greatWallActivationTime = 1557921600;
 
         // Nov 15, 2019 12:00:00 UTC protocol upgrade
         consensus.gravitonActivationTime = 1573819200;
 
         diskMagic[0] = 0x0b;
         diskMagic[1] = 0x11;
         diskMagic[2] = 0x09;
         diskMagic[3] = 0x07;
         netMagic[0] = 0xf4;
         netMagic[1] = 0xe5;
         netMagic[2] = 0xf3;
         netMagic[3] = 0xf4;
         nDefaultPort = 18333;
         nPruneAfterHeight = 1000;
 
         genesis =
             CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
         consensus.hashGenesisBlock = genesis.GetHash();
         assert(consensus.hashGenesisBlock ==
                uint256S("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526"
                         "f8d77f4943"));
         assert(genesis.hashMerkleRoot ==
                uint256S("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b"
                         "7afdeda33b"));
 
         vFixedSeeds.clear();
         vSeeds.clear();
         // nodes with support for servicebits filtering should be at the top
         // Bitcoin ABC seeder
         vSeeds.emplace_back("testnet-seed.bitcoinabc.org");
         // bitcoinforks seeders
         vSeeds.emplace_back("testnet-seed-abc.bitcoinforks.org");
         // Bitprim
         vSeeds.emplace_back("testnet-seed.bitprim.org");
         // Amaury SÉCHET
         vSeeds.emplace_back("testnet-seed.deadalnix.me");
         // criptolayer.net
         vSeeds.emplace_back("testnet-seeder.criptolayer.net");
 
         base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 111);
         base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 196);
         base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 239);
         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
         cashaddrPrefix = "bchtest";
         vFixedSeeds = std::vector<SeedSpec6>(
             pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));
 
         fDefaultConsistencyChecks = false;
         fRequireStandard = false;
         fMineBlocksOnDemand = false;
 
         checkpointData = {
             .mapCheckpoints = {
                 {546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345"
                                "d31b1bcebf76acb70")},
                 // UAHF fork block.
                 {1155875, uint256S("00000000f17c850672894b9a75b63a1e72830bbd5f4"
                                    "c8889b5c1a80e7faef138")},
                 // Nov, 13. DAA activation block.
                 {1188697, uint256S("0000000000170ed0918077bde7b4d36cc4c91be69fa"
                                    "09211f748240dabe047fb")},
             }};
 
         // Data as of block
         // 000000000005b07ecf85563034d13efd81c1a29e47e22b20f4fc6919d5b09cd6
         // (height 1223263)
         chainTxData = ChainTxData{1522608381, 15052068, 0.15};
     }
 };
 
 /**
  * Regression test
  */
 class CRegTestParams : public CChainParams {
 public:
     CRegTestParams() {
         strNetworkID = "regtest";
         consensus.nSubsidyHalvingInterval = 150;
         // BIP34 has not activated on regtest (far in the future so block v1 are
         // not rejected in tests)
         consensus.BIP34Height = 100000000;
         consensus.BIP34Hash = uint256();
         // BIP65 activated on regtest (Used in rpc activation tests)
         consensus.BIP65Height = 1351;
         // BIP66 activated on regtest (Used in rpc activation tests)
         consensus.BIP66Height = 1251;
         // CSV activated on regtest (Used in rpc activation tests)
         consensus.CSVHeight = 576;
         consensus.powLimit = uint256S(
             "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         // two weeks
         consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
         consensus.nPowTargetSpacing = 10 * 60;
         consensus.fPowAllowMinDifficultyBlocks = true;
         consensus.fPowNoRetargeting = true;
         // 75% for testchains
         consensus.nRuleChangeActivationThreshold = 108;
         // Faster than normal for regtest (144 instead of 2016)
         consensus.nMinerConfirmationWindow = 144;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout =
             999999999999ULL;
 
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork = uint256S("0x00");
 
         // By default assume that the signatures in ancestors of this block are
         // valid.
         consensus.defaultAssumeValid = uint256S("0x00");
 
         // UAHF is always enabled on regtest.
         consensus.uahfHeight = 0;
 
         // November 13, 2017 hard fork is always on on regtest.
         consensus.daaHeight = 0;
 
         // November 15, 2018 hard fork is always on on regtest.
         consensus.magneticAnomalyHeight = 0;
 
         // Wed, 15 May 2019 12:00:00 UTC hard fork
         consensus.greatWallActivationTime = 1557921600;
 
         // Nov 15, 2019 12:00:00 UTC protocol upgrade
         consensus.gravitonActivationTime = 1573819200;
 
         diskMagic[0] = 0xfa;
         diskMagic[1] = 0xbf;
         diskMagic[2] = 0xb5;
         diskMagic[3] = 0xda;
         netMagic[0] = 0xda;
         netMagic[1] = 0xb5;
         netMagic[2] = 0xbf;
         netMagic[3] = 0xfa;
         nDefaultPort = 18444;
         nPruneAfterHeight = 1000;
 
         genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
         consensus.hashGenesisBlock = genesis.GetHash();
         assert(consensus.hashGenesisBlock ==
                uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b"
                         "1a11466e2206"));
         assert(genesis.hashMerkleRoot ==
                uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab212"
                         "7b7afdeda33b"));
 
         //!< Regtest mode doesn't have any fixed seeds.
         vFixedSeeds.clear();
         //!< Regtest mode doesn't have any DNS seeds.
         vSeeds.clear();
 
         fDefaultConsistencyChecks = true;
         fRequireStandard = false;
         fMineBlocksOnDemand = true;
 
         checkpointData = {.mapCheckpoints = {
                               {0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5"
                                            "beb436012afca590b1a11466e2206")},
                           }};
 
         chainTxData = ChainTxData{0, 0, 0};
 
         base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 111);
         base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 196);
         base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 239);
         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
         cashaddrPrefix = "bchreg";
     }
 };
 
 static std::unique_ptr<CChainParams> globalChainParams;
 
 const CChainParams &Params() {
     assert(globalChainParams);
     return *globalChainParams;
 }
 
 std::unique_ptr<CChainParams> CreateChainParams(const std::string &chain) {
     if (chain == CBaseChainParams::MAIN) {
         return std::unique_ptr<CChainParams>(new CMainParams());
     }
 
     if (chain == CBaseChainParams::TESTNET) {
         return std::unique_ptr<CChainParams>(new CTestNetParams());
     }
 
     if (chain == CBaseChainParams::REGTEST) {
         return std::unique_ptr<CChainParams>(new CRegTestParams());
     }
 
     throw std::runtime_error(
         strprintf("%s: Unknown chain %s.", __func__, chain));
 }
 
 void SelectParams(const std::string &network) {
     SelectBaseParams(network);
     globalChainParams = CreateChainParams(network);
 }
diff --git a/src/chainparams.h b/src/chainparams.h
index a63c82153f..f3f3d8d0fa 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -1,121 +1,121 @@
 // 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_CHAINPARAMS_H
 #define BITCOIN_CHAINPARAMS_H
 
-#include "chainparamsbase.h"
-#include "consensus/params.h"
-#include "primitives/block.h"
-#include "protocol.h"
+#include <chainparamsbase.h>
+#include <consensus/params.h>
+#include <primitives/block.h>
+#include <protocol.h>
 
 #include <memory>
 #include <vector>
 
 struct SeedSpec6 {
     uint8_t addr[16];
     uint16_t port;
 };
 
 typedef std::map<int, uint256> MapCheckpoints;
 
 struct CCheckpointData {
     MapCheckpoints mapCheckpoints;
 };
 
 struct ChainTxData {
     int64_t nTime;
     int64_t nTxCount;
     double dTxRate;
 };
 
 /**
  * CChainParams defines various tweakable parameters of a given instance of the
  * Bitcoin system. There are three: the main network on which people trade goods
  * and services, the public test network which gets reset from time to time and
  * a regression test mode which is intended for private networks only. It has
  * minimal difficulty to ensure that blocks can be found instantly.
  */
 class CChainParams {
 public:
     enum Base58Type {
         PUBKEY_ADDRESS,
         SCRIPT_ADDRESS,
         SECRET_KEY,
         EXT_PUBLIC_KEY,
         EXT_SECRET_KEY,
 
         MAX_BASE58_TYPES
     };
 
     const Consensus::Params &GetConsensus() const { return consensus; }
     const CMessageHeader::MessageMagic &DiskMagic() const { return diskMagic; }
     const CMessageHeader::MessageMagic &NetMagic() const { return netMagic; }
     int GetDefaultPort() const { return nDefaultPort; }
 
     const CBlock &GenesisBlock() const { return genesis; }
     /** Default value for -checkmempool and -checkblockindex argument */
     bool DefaultConsistencyChecks() const { return fDefaultConsistencyChecks; }
     /** Policy: Filter transactions that do not match well-defined patterns */
     bool RequireStandard() const { return fRequireStandard; }
     uint64_t PruneAfterHeight() const { return nPruneAfterHeight; }
     /**
      * Make miner stop after a block is found. In RPC, don't return until
      * nGenProcLimit blocks are generated.
      */
     bool MineBlocksOnDemand() const { return fMineBlocksOnDemand; }
     /** Return the BIP70 network string (main, test or regtest) */
     std::string NetworkIDString() const { return strNetworkID; }
     /** Return the list of hostnames to look up for DNS seeds */
     const std::vector<std::string> &DNSSeeds() const { return vSeeds; }
     const std::vector<uint8_t> &Base58Prefix(Base58Type type) const {
         return base58Prefixes[type];
     }
     const std::string &CashAddrPrefix() const { return cashaddrPrefix; }
     const std::vector<SeedSpec6> &FixedSeeds() const { return vFixedSeeds; }
     const CCheckpointData &Checkpoints() const { return checkpointData; }
     const ChainTxData &TxData() const { return chainTxData; }
 
 protected:
     CChainParams() {}
 
     Consensus::Params consensus;
     CMessageHeader::MessageMagic diskMagic;
     CMessageHeader::MessageMagic netMagic;
     int nDefaultPort;
     uint64_t nPruneAfterHeight;
     std::vector<std::string> vSeeds;
     std::vector<uint8_t> base58Prefixes[MAX_BASE58_TYPES];
     std::string cashaddrPrefix;
     std::string strNetworkID;
     CBlock genesis;
     std::vector<SeedSpec6> vFixedSeeds;
     bool fDefaultConsistencyChecks;
     bool fRequireStandard;
     bool fMineBlocksOnDemand;
     CCheckpointData checkpointData;
     ChainTxData chainTxData;
 };
 
 /**
  * Creates and returns a std::unique_ptr<CChainParams> of the chosen chain.
  * @returns a CChainParams* of the chosen chain.
  * @throws a std::runtime_error if the chain is not supported.
  */
 std::unique_ptr<CChainParams> CreateChainParams(const std::string &chain);
 
 /**
  * Return the currently selected parameters. This won't change after app
  * startup, except for unit tests.
  */
 const CChainParams &Params();
 
 /**
  * Sets the params returned by Params() to those for the given BIP70 chain name.
  * @throws std::runtime_error when the chain is not supported.
  */
 void SelectParams(const std::string &chain);
 
 #endif // BITCOIN_CHAINPARAMS_H
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index 8d24a34960..985869ab85 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -1,82 +1,82 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "chainparamsbase.h"
+#include <chainparamsbase.h>
 
-#include "tinyformat.h"
-#include "util.h"
+#include <tinyformat.h>
+#include <util.h>
 
 #include <cassert>
 
 const std::string CBaseChainParams::MAIN = "main";
 const std::string CBaseChainParams::TESTNET = "test";
 const std::string CBaseChainParams::REGTEST = "regtest";
 
 void AppendParamsHelpMessages(std::string &strUsage, bool debugHelp) {
     strUsage += HelpMessageGroup(_("Chain selection options:"));
     strUsage += HelpMessageOpt("-testnet", _("Use the test chain"));
     if (debugHelp) {
         strUsage += HelpMessageOpt(
             "-regtest", "Enter regression test mode, which uses a special "
                         "chain in which blocks can be solved instantly. "
                         "This is intended for regression testing tools and app "
                         "development.");
     }
 }
 
 /**
  * Main network
  */
 class CBaseMainParams : public CBaseChainParams {
 public:
     CBaseMainParams() { nRPCPort = 8332; }
 };
 
 /**
  * Testnet (v3)
  */
 class CBaseTestNetParams : public CBaseChainParams {
 public:
     CBaseTestNetParams() {
         nRPCPort = 18332;
         strDataDir = "testnet3";
     }
 };
 
 /*
  * Regression test
  */
 class CBaseRegTestParams : public CBaseChainParams {
 public:
     CBaseRegTestParams() {
         nRPCPort = 18332;
         strDataDir = "regtest";
     }
 };
 
 static std::unique_ptr<CBaseChainParams> globalChainBaseParams;
 
 const CBaseChainParams &BaseParams() {
     assert(globalChainBaseParams);
     return *globalChainBaseParams;
 }
 
 std::unique_ptr<CBaseChainParams>
 CreateBaseChainParams(const std::string &chain) {
     if (chain == CBaseChainParams::MAIN)
         return std::unique_ptr<CBaseChainParams>(new CBaseMainParams());
     else if (chain == CBaseChainParams::TESTNET)
         return std::unique_ptr<CBaseChainParams>(new CBaseTestNetParams());
     else if (chain == CBaseChainParams::REGTEST)
         return std::unique_ptr<CBaseChainParams>(new CBaseRegTestParams());
     else
         throw std::runtime_error(
             strprintf("%s: Unknown chain %s.", __func__, chain));
 }
 
 void SelectBaseParams(const std::string &chain) {
     globalChainBaseParams = CreateBaseChainParams(chain);
     gArgs.SelectConfigNetwork(chain);
 }
diff --git a/src/checkpoints.cpp b/src/checkpoints.cpp
index c3fd9e53f5..4c1c019ab4 100644
--- a/src/checkpoints.cpp
+++ b/src/checkpoints.cpp
@@ -1,39 +1,39 @@
 // 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.
 
-#include "checkpoints.h"
+#include <checkpoints.h>
 
-#include "chain.h"
-#include "chainparams.h"
-#include "reverse_iterator.h"
+#include <chain.h>
+#include <chainparams.h>
+#include <reverse_iterator.h>
 
 #include <cstdint>
 
 namespace Checkpoints {
 
 bool CheckBlock(const CCheckpointData &data, int nHeight, const uint256 &hash) {
     const MapCheckpoints &checkpoints = data.mapCheckpoints;
 
     MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
     if (i == checkpoints.end()) {
         return true;
     }
     return hash == i->second;
 }
 
 CBlockIndex *GetLastCheckpoint(const CCheckpointData &data) {
     const MapCheckpoints &checkpoints = data.mapCheckpoints;
 
     for (const MapCheckpoints::value_type &i : reverse_iterate(checkpoints)) {
         const uint256 &hash = i.second;
         CBlockIndex *pindex = LookupBlockIndex(hash);
         if (pindex) {
             return pindex;
         }
     }
 
     return nullptr;
 }
 
 } // namespace Checkpoints
diff --git a/src/checkpoints.h b/src/checkpoints.h
index ecdae98404..47be0bfdc5 100644
--- a/src/checkpoints.h
+++ b/src/checkpoints.h
@@ -1,29 +1,29 @@
 // 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_CHECKPOINTS_H
 #define BITCOIN_CHECKPOINTS_H
 
-#include "uint256.h"
+#include <uint256.h>
 
 #include <map>
 
 class CBlockIndex;
 struct CCheckpointData;
 
 /**
  * Block-chain checkpoints are compiled-in sanity checks.
  * They are updated every release or three.
  */
 namespace Checkpoints {
 
 //! Returns true if block passes checkpoint checks
 bool CheckBlock(const CCheckpointData &data, int nHeight, const uint256 &hash);
 
 //! Returns last CBlockIndex* that is a checkpoint
 CBlockIndex *GetLastCheckpoint(const CCheckpointData &data);
 
 } // namespace Checkpoints
 
 #endif // BITCOIN_CHECKPOINTS_H
diff --git a/src/clientversion.cpp b/src/clientversion.cpp
index 01621f4a65..3bc1985342 100644
--- a/src/clientversion.cpp
+++ b/src/clientversion.cpp
@@ -1,116 +1,116 @@
 // Copyright (c) 2012-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.
 
-#include "clientversion.h"
+#include <clientversion.h>
 
-#include "tinyformat.h"
+#include <tinyformat.h>
 
 #include <string>
 
 /**
  * Name of client reported in the 'version' message. Report the same name
  * for both bitcoind and bitcoin-abc, to make it harder for attackers to
  * target servers or GUI users specifically.
  */
 const std::string CLIENT_NAME("Bitcoin ABC");
 
 /**
  * Client version number
  */
 #define CLIENT_VERSION_SUFFIX ""
 
 /**
  * The following part of the code determines the CLIENT_BUILD variable.
  * Several mechanisms are used for this:
  * * first, if HAVE_BUILD_INFO is defined, include build.h, a file that is
  *   generated by the build environment, possibly containing the output
  *   of git-describe in a macro called BUILD_DESC
  * * secondly, if this is an exported version of the code, GIT_ARCHIVE will
  *   be defined (automatically using the export-subst git attribute), and
  *   GIT_COMMIT will contain the commit id.
  * * then, three options exist for determining CLIENT_BUILD:
  *   * if BUILD_DESC is defined, use that literally (output of git-describe)
  *   * if not, but GIT_COMMIT is defined, use
  *     v[maj].[min].[rev].[build]-g[commit]
  *   * otherwise, use v[maj].[min].[rev].[build]-unk
  * finally CLIENT_VERSION_SUFFIX is added
  */
 
 //! First, include build.h if requested
 #ifdef HAVE_BUILD_INFO
-#include "build.h"
+#include <build.h>
 #endif
 
 //! git will put "#define GIT_ARCHIVE 1" on the next line inside archives.
 //! $Format:%n#define GIT_ARCHIVE 1$
 #ifdef GIT_ARCHIVE
 #define GIT_COMMIT_ID "$Format:%h$"
 #define GIT_COMMIT_DATE "$Format:%cD$"
 #endif
 
 #define BUILD_DESC_WITH_SUFFIX(maj, min, rev, build, suffix)                   \
     "v" DO_STRINGIZE(maj) "." DO_STRINGIZE(min) "." DO_STRINGIZE(              \
         rev) "." DO_STRINGIZE(build) "-" DO_STRINGIZE(suffix)
 
 #define BUILD_DESC_FROM_COMMIT(maj, min, rev, build, commit)                   \
     "v" DO_STRINGIZE(maj) "." DO_STRINGIZE(min) "." DO_STRINGIZE(              \
         rev) "." DO_STRINGIZE(build) "-g" commit
 
 #define BUILD_DESC_FROM_UNKNOWN(maj, min, rev, build)                          \
     "v" DO_STRINGIZE(maj) "." DO_STRINGIZE(min) "." DO_STRINGIZE(              \
         rev) "." DO_STRINGIZE(build) "-unk"
 
 #ifndef BUILD_DESC
 #ifdef BUILD_SUFFIX
 #define BUILD_DESC                                                             \
     BUILD_DESC_WITH_SUFFIX(CLIENT_VERSION_MAJOR, CLIENT_VERSION_MINOR,         \
                            CLIENT_VERSION_REVISION, CLIENT_VERSION_BUILD,      \
                            BUILD_SUFFIX)
 #elif defined(GIT_COMMIT_ID)
 #define BUILD_DESC                                                             \
     BUILD_DESC_FROM_COMMIT(CLIENT_VERSION_MAJOR, CLIENT_VERSION_MINOR,         \
                            CLIENT_VERSION_REVISION, CLIENT_VERSION_BUILD,      \
                            GIT_COMMIT_ID)
 #else
 #define BUILD_DESC                                                             \
     BUILD_DESC_FROM_UNKNOWN(CLIENT_VERSION_MAJOR, CLIENT_VERSION_MINOR,        \
                             CLIENT_VERSION_REVISION, CLIENT_VERSION_BUILD)
 #endif
 #endif
 
 const std::string CLIENT_BUILD(BUILD_DESC CLIENT_VERSION_SUFFIX);
 
 static std::string FormatVersion(int nVersion) {
     if (nVersion % 100 == 0)
         return strprintf("%d.%d.%d", nVersion / 1000000,
                          (nVersion / 10000) % 100, (nVersion / 100) % 100);
     else
         return strprintf("%d.%d.%d.%d", nVersion / 1000000,
                          (nVersion / 10000) % 100, (nVersion / 100) % 100,
                          nVersion % 100);
 }
 
 std::string FormatFullVersion() {
     return CLIENT_BUILD;
 }
 
 /**
  * Format the subversion field according to BIP 14 spec
  * (https://github.com/bitcoin/bips/blob/master/bip-0014.mediawiki)
  */
 std::string FormatSubVersion(const std::string &name, int nClientVersion,
                              const std::vector<std::string> &comments) {
     std::ostringstream ss;
     ss << "/";
     ss << name << ":" << FormatVersion(nClientVersion);
     if (!comments.empty()) {
         std::vector<std::string>::const_iterator it(comments.begin());
         ss << "(" << *it;
         for (++it; it != comments.end(); ++it)
             ss << "; " << *it;
         ss << ")";
     }
     ss << "/";
     return ss.str();
 }
diff --git a/src/clientversion.h b/src/clientversion.h
index b84bee4b22..aab0d46215 100644
--- a/src/clientversion.h
+++ b/src/clientversion.h
@@ -1,47 +1,47 @@
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2018 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_CLIENTVERSION_H
 #define BITCOIN_CLIENTVERSION_H
 
-#include "config/bitcoin-config.h"
+#include <config/bitcoin-config.h>
 
 /**
  * Converts the parameter X to a string after macro replacement on X has been
  * performed.
  * Don't merge these into one macro!
  */
 #define STRINGIZE(X) DO_STRINGIZE(X)
 #define DO_STRINGIZE(X) #X
 
 //! Copyright string used in Windows .rc files
 #define COPYRIGHT_STR                                                          \
     "2009-" STRINGIZE(COPYRIGHT_YEAR) " " COPYRIGHT_HOLDERS_FINAL
 
 /**
  * bitcoind-res.rc includes this file, but it cannot cope with real c++ code.
  * WINDRES_PREPROC is defined to indicate that its pre-processor is running.
  * Anything other than a define should be guarded below.
  */
 
 #if !defined(WINDRES_PREPROC)
 
 #include <string>
 #include <vector>
 
 static const int CLIENT_VERSION =
     1000000 * CLIENT_VERSION_MAJOR + 10000 * CLIENT_VERSION_MINOR +
     100 * CLIENT_VERSION_REVISION + 1 * CLIENT_VERSION_BUILD;
 
 extern const std::string CLIENT_NAME;
 extern const std::string CLIENT_BUILD;
 
 std::string FormatFullVersion();
 std::string FormatSubVersion(const std::string &name, int nClientVersion,
                              const std::vector<std::string> &comments);
 
 #endif // WINDRES_PREPROC
 
 #endif // BITCOIN_CLIENTVERSION_H
diff --git a/src/coins.cpp b/src/coins.cpp
index d6b13b2e85..85d94b805b 100644
--- a/src/coins.cpp
+++ b/src/coins.cpp
@@ -1,344 +1,344 @@
 // Copyright (c) 2012-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.
 
-#include "coins.h"
+#include <coins.h>
 
-#include "consensus/consensus.h"
-#include "memusage.h"
-#include "random.h"
+#include <consensus/consensus.h>
+#include <memusage.h>
+#include <random.h>
 
 #include <cassert>
 
 bool CCoinsView::GetCoin(const COutPoint &outpoint, Coin &coin) const {
     return false;
 }
 bool CCoinsView::HaveCoin(const COutPoint &outpoint) const {
     return false;
 }
 uint256 CCoinsView::GetBestBlock() const {
     return uint256();
 }
 std::vector<uint256> CCoinsView::GetHeadBlocks() const {
     return std::vector<uint256>();
 }
 bool CCoinsView::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) {
     return false;
 }
 CCoinsViewCursor *CCoinsView::Cursor() const {
     return nullptr;
 }
 
 CCoinsViewBacked::CCoinsViewBacked(CCoinsView *viewIn) : base(viewIn) {}
 bool CCoinsViewBacked::GetCoin(const COutPoint &outpoint, Coin &coin) const {
     return base->GetCoin(outpoint, coin);
 }
 bool CCoinsViewBacked::HaveCoin(const COutPoint &outpoint) const {
     return base->HaveCoin(outpoint);
 }
 uint256 CCoinsViewBacked::GetBestBlock() const {
     return base->GetBestBlock();
 }
 std::vector<uint256> CCoinsViewBacked::GetHeadBlocks() const {
     return base->GetHeadBlocks();
 }
 void CCoinsViewBacked::SetBackend(CCoinsView &viewIn) {
     base = &viewIn;
 }
 bool CCoinsViewBacked::BatchWrite(CCoinsMap &mapCoins,
                                   const uint256 &hashBlock) {
     return base->BatchWrite(mapCoins, hashBlock);
 }
 CCoinsViewCursor *CCoinsViewBacked::Cursor() const {
     return base->Cursor();
 }
 size_t CCoinsViewBacked::EstimateSize() const {
     return base->EstimateSize();
 }
 
 SaltedOutpointHasher::SaltedOutpointHasher()
     : k0(GetRand(std::numeric_limits<uint64_t>::max())),
       k1(GetRand(std::numeric_limits<uint64_t>::max())) {}
 
 CCoinsViewCache::CCoinsViewCache(CCoinsView *baseIn)
     : CCoinsViewBacked(baseIn), cachedCoinsUsage(0) {}
 
 size_t CCoinsViewCache::DynamicMemoryUsage() const {
     return memusage::DynamicUsage(cacheCoins) + cachedCoinsUsage;
 }
 
 CCoinsMap::iterator
 CCoinsViewCache::FetchCoin(const COutPoint &outpoint) const {
     CCoinsMap::iterator it = cacheCoins.find(outpoint);
     if (it != cacheCoins.end()) {
         return it;
     }
     Coin tmp;
     if (!base->GetCoin(outpoint, tmp)) {
         return cacheCoins.end();
     }
     CCoinsMap::iterator ret =
         cacheCoins
             .emplace(std::piecewise_construct, std::forward_as_tuple(outpoint),
                      std::forward_as_tuple(std::move(tmp)))
             .first;
     if (ret->second.coin.IsSpent()) {
         // The parent only has an empty entry for this outpoint; we can consider
         // our version as fresh.
         ret->second.flags = CCoinsCacheEntry::FRESH;
     }
     cachedCoinsUsage += ret->second.coin.DynamicMemoryUsage();
     return ret;
 }
 
 bool CCoinsViewCache::GetCoin(const COutPoint &outpoint, Coin &coin) const {
     CCoinsMap::const_iterator it = FetchCoin(outpoint);
     if (it == cacheCoins.end()) {
         return false;
     }
     coin = it->second.coin;
     return true;
 }
 
 void CCoinsViewCache::AddCoin(const COutPoint &outpoint, Coin coin,
                               bool possible_overwrite) {
     assert(!coin.IsSpent());
     if (coin.GetTxOut().scriptPubKey.IsUnspendable()) {
         return;
     }
     CCoinsMap::iterator it;
     bool inserted;
     std::tie(it, inserted) =
         cacheCoins.emplace(std::piecewise_construct,
                            std::forward_as_tuple(outpoint), std::tuple<>());
     bool fresh = false;
     if (!inserted) {
         cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
     }
     if (!possible_overwrite) {
         if (!it->second.coin.IsSpent()) {
             throw std::logic_error(
                 "Adding new coin that replaces non-pruned entry");
         }
         fresh = !(it->second.flags & CCoinsCacheEntry::DIRTY);
     }
     it->second.coin = std::move(coin);
     it->second.flags |=
         CCoinsCacheEntry::DIRTY | (fresh ? CCoinsCacheEntry::FRESH : 0);
     cachedCoinsUsage += it->second.coin.DynamicMemoryUsage();
 }
 
 void AddCoins(CCoinsViewCache &cache, const CTransaction &tx, int nHeight,
               bool check) {
     bool fCoinbase = tx.IsCoinBase();
     const TxId txid = tx.GetId();
     for (size_t i = 0; i < tx.vout.size(); ++i) {
         const COutPoint outpoint(txid, i);
         bool overwrite = check ? cache.HaveCoin(outpoint) : fCoinbase;
         // Always set the possible_overwrite flag to AddCoin for coinbase txn,
         // in order to correctly deal with the pre-BIP30 occurrences of
         // duplicate coinbase transactions.
         cache.AddCoin(outpoint, Coin(tx.vout[i], nHeight, fCoinbase),
                       overwrite);
     }
 }
 
 bool CCoinsViewCache::SpendCoin(const COutPoint &outpoint, Coin *moveout) {
     CCoinsMap::iterator it = FetchCoin(outpoint);
     if (it == cacheCoins.end()) {
         return false;
     }
     cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
     if (moveout) {
         *moveout = std::move(it->second.coin);
     }
     if (it->second.flags & CCoinsCacheEntry::FRESH) {
         cacheCoins.erase(it);
     } else {
         it->second.flags |= CCoinsCacheEntry::DIRTY;
         it->second.coin.Clear();
     }
     return true;
 }
 
 static const Coin coinEmpty;
 
 const Coin &CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
     CCoinsMap::const_iterator it = FetchCoin(outpoint);
     if (it == cacheCoins.end()) {
         return coinEmpty;
     }
     return it->second.coin;
 }
 
 bool CCoinsViewCache::HaveCoin(const COutPoint &outpoint) const {
     CCoinsMap::const_iterator it = FetchCoin(outpoint);
     return it != cacheCoins.end() && !it->second.coin.IsSpent();
 }
 
 bool CCoinsViewCache::HaveCoinInCache(const COutPoint &outpoint) const {
     CCoinsMap::const_iterator it = cacheCoins.find(outpoint);
     return it != cacheCoins.end();
 }
 
 uint256 CCoinsViewCache::GetBestBlock() const {
     if (hashBlock.IsNull()) {
         hashBlock = base->GetBestBlock();
     }
     return hashBlock;
 }
 
 void CCoinsViewCache::SetBestBlock(const uint256 &hashBlockIn) {
     hashBlock = hashBlockIn;
 }
 
 bool CCoinsViewCache::BatchWrite(CCoinsMap &mapCoins,
                                  const uint256 &hashBlockIn) {
     for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
         // Ignore non-dirty entries (optimization).
         if (it->second.flags & CCoinsCacheEntry::DIRTY) {
             CCoinsMap::iterator itUs = cacheCoins.find(it->first);
             if (itUs == cacheCoins.end()) {
                 // The parent cache does not have an entry, while the child does
                 // We can ignore it if it's both FRESH and pruned in the child
                 if (!(it->second.flags & CCoinsCacheEntry::FRESH &&
                       it->second.coin.IsSpent())) {
                     // Otherwise we will need to create it in the parent and
                     // move the data up and mark it as dirty
                     CCoinsCacheEntry &entry = cacheCoins[it->first];
                     entry.coin = std::move(it->second.coin);
                     cachedCoinsUsage += entry.coin.DynamicMemoryUsage();
                     entry.flags = CCoinsCacheEntry::DIRTY;
                     // We can mark it FRESH in the parent if it was FRESH in the
                     // child. Otherwise it might have just been flushed from the
                     // parent's cache and already exist in the grandparent
                     if (it->second.flags & CCoinsCacheEntry::FRESH)
                         entry.flags |= CCoinsCacheEntry::FRESH;
                 }
             } else {
                 // Assert that the child cache entry was not marked FRESH if the
                 // parent cache entry has unspent outputs. If this ever happens,
                 // it means the FRESH flag was misapplied and there is a logic
                 // error in the calling code.
                 if ((it->second.flags & CCoinsCacheEntry::FRESH) &&
                     !itUs->second.coin.IsSpent())
                     throw std::logic_error("FRESH flag misapplied to cache "
                                            "entry for base transaction with "
                                            "spendable outputs");
 
                 // Found the entry in the parent cache
                 if ((itUs->second.flags & CCoinsCacheEntry::FRESH) &&
                     it->second.coin.IsSpent()) {
                     // The grandparent does not have an entry, and the child is
                     // modified and being pruned. This means we can just delete
                     // it from the parent.
                     cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
                     cacheCoins.erase(itUs);
                 } else {
                     // A normal modification.
                     cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
                     itUs->second.coin = std::move(it->second.coin);
                     cachedCoinsUsage += itUs->second.coin.DynamicMemoryUsage();
                     itUs->second.flags |= CCoinsCacheEntry::DIRTY;
                     // NOTE: It is possible the child has a FRESH flag here in
                     // the event the entry we found in the parent is pruned. But
                     // we must not copy that FRESH flag to the parent as that
                     // pruned state likely still needs to be communicated to the
                     // grandparent.
                 }
             }
         }
         CCoinsMap::iterator itOld = it++;
         mapCoins.erase(itOld);
     }
     hashBlock = hashBlockIn;
     return true;
 }
 
 bool CCoinsViewCache::Flush() {
     bool fOk = base->BatchWrite(cacheCoins, hashBlock);
     cacheCoins.clear();
     cachedCoinsUsage = 0;
     return fOk;
 }
 
 void CCoinsViewCache::Uncache(const COutPoint &outpoint) {
     CCoinsMap::iterator it = cacheCoins.find(outpoint);
     if (it != cacheCoins.end() && it->second.flags == 0) {
         cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
         cacheCoins.erase(it);
     }
 }
 
 unsigned int CCoinsViewCache::GetCacheSize() const {
     return cacheCoins.size();
 }
 
 const CTxOut &CCoinsViewCache::GetOutputFor(const CTxIn &input) const {
     const Coin &coin = AccessCoin(input.prevout);
     assert(!coin.IsSpent());
     return coin.GetTxOut();
 }
 
 Amount CCoinsViewCache::GetValueIn(const CTransaction &tx) const {
     if (tx.IsCoinBase()) {
         return Amount::zero();
     }
 
     Amount nResult = Amount::zero();
     for (size_t i = 0; i < tx.vin.size(); i++) {
         nResult += GetOutputFor(tx.vin[i]).nValue;
     }
 
     return nResult;
 }
 
 bool CCoinsViewCache::HaveInputs(const CTransaction &tx) const {
     if (tx.IsCoinBase()) {
         return true;
     }
 
     for (size_t i = 0; i < tx.vin.size(); i++) {
         if (!HaveCoin(tx.vin[i].prevout)) {
             return false;
         }
     }
 
     return true;
 }
 
 double CCoinsViewCache::GetPriority(const CTransaction &tx, int nHeight,
                                     Amount &inChainInputValue) const {
     inChainInputValue = Amount::zero();
     if (tx.IsCoinBase()) {
         return 0.0;
     }
     double dResult = 0.0;
     for (const CTxIn &txin : tx.vin) {
         const Coin &coin = AccessCoin(txin.prevout);
         if (coin.IsSpent()) {
             continue;
         }
         if (int64_t(coin.GetHeight()) <= nHeight) {
             dResult += double(coin.GetTxOut().nValue / SATOSHI) *
                        (nHeight - coin.GetHeight());
             inChainInputValue += coin.GetTxOut().nValue;
         }
     }
     return tx.ComputePriority(dResult);
 }
 
 // TODO: merge with similar definition in undo.h.
 static const size_t MAX_OUTPUTS_PER_TX =
     MAX_TX_SIZE / ::GetSerializeSize(CTxOut(), SER_NETWORK, PROTOCOL_VERSION);
 
 const Coin &AccessByTxid(const CCoinsViewCache &view, const TxId &txid) {
     for (uint32_t n = 0; n < MAX_OUTPUTS_PER_TX; n++) {
         const Coin &alternate = view.AccessCoin(COutPoint(txid, n));
         if (!alternate.IsSpent()) {
             return alternate;
         }
     }
 
     return coinEmpty;
 }
diff --git a/src/coins.h b/src/coins.h
index 97abeb9e00..f5959f1493 100644
--- a/src/coins.h
+++ b/src/coins.h
@@ -1,316 +1,316 @@
 // 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_COINS_H
 #define BITCOIN_COINS_H
 
-#include "compressor.h"
-#include "core_memusage.h"
-#include "hash.h"
-#include "memusage.h"
-#include "serialize.h"
-#include "uint256.h"
+#include <compressor.h>
+#include <core_memusage.h>
+#include <hash.h>
+#include <memusage.h>
+#include <serialize.h>
+#include <uint256.h>
 
 #include <cassert>
 #include <cstdint>
 #include <unordered_map>
 
 /**
  * A UTXO entry.
  *
  * Serialized format:
  * - VARINT((coinbase ? 1 : 0) | (height << 1))
  * - the non-spent CTxOut (via CTxOutCompressor)
  */
 class Coin {
     //! Unspent transaction output.
     CTxOut out;
 
     //! Whether containing transaction was a coinbase and height at which the
     //! transaction was included into a block.
     uint32_t nHeightAndIsCoinBase;
 
 public:
     //! Empty constructor
     Coin() : nHeightAndIsCoinBase(0) {}
 
     //! Constructor from a CTxOut and height/coinbase information.
     Coin(CTxOut outIn, uint32_t nHeightIn, bool IsCoinbase)
         : out(std::move(outIn)),
           nHeightAndIsCoinBase((nHeightIn << 1) | IsCoinbase) {}
 
     uint32_t GetHeight() const { return nHeightAndIsCoinBase >> 1; }
     bool IsCoinBase() const { return nHeightAndIsCoinBase & 0x01; }
     bool IsSpent() const { return out.IsNull(); }
 
     CTxOut &GetTxOut() { return out; }
     const CTxOut &GetTxOut() const { return out; }
 
     void Clear() {
         out.SetNull();
         nHeightAndIsCoinBase = 0;
     }
 
     template <typename Stream> void Serialize(Stream &s) const {
         assert(!IsSpent());
         ::Serialize(s, VARINT(nHeightAndIsCoinBase));
         ::Serialize(s, CTxOutCompressor(REF(out)));
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         ::Unserialize(s, VARINT(nHeightAndIsCoinBase));
         ::Unserialize(s, REF(CTxOutCompressor(out)));
     }
 
     size_t DynamicMemoryUsage() const {
         return memusage::DynamicUsage(out.scriptPubKey);
     }
 };
 
 class SaltedOutpointHasher {
 private:
     /** Salt */
     const uint64_t k0, k1;
 
 public:
     SaltedOutpointHasher();
 
     /**
      * This *must* return size_t. With Boost 1.46 on 32-bit systems the
      * unordered_map will behave unpredictably if the custom hasher returns a
      * uint64_t, resulting in failures when syncing the chain (#4634).
      * Note: This information above might be outdated as the unordered map
      * container type has meanwhile been switched to the C++ standard library
      * implementation.
      */
     size_t operator()(const COutPoint &outpoint) const {
         return SipHashUint256Extra(k0, k1, outpoint.GetTxId(), outpoint.GetN());
     }
 };
 
 struct CCoinsCacheEntry {
     // The actual cached data.
     Coin coin;
     uint8_t flags;
 
     enum Flags {
         // This cache entry is potentially different from the version in the
         // parent view.
         DIRTY = (1 << 0),
         // The parent view does not have this entry (or it is pruned).
         FRESH = (1 << 1),
         /* Note that FRESH is a performance optimization with which we can erase
            coins that are fully spent if we know we do not need to flush the
            changes to the parent cache. It is always safe to not mark FRESH if
            that condition is not guaranteed. */
     };
 
     CCoinsCacheEntry() : flags(0) {}
     explicit CCoinsCacheEntry(Coin coinIn)
         : coin(std::move(coinIn)), flags(0) {}
 };
 
 typedef std::unordered_map<COutPoint, CCoinsCacheEntry, SaltedOutpointHasher>
     CCoinsMap;
 
 /** Cursor for iterating over CoinsView state */
 class CCoinsViewCursor {
 public:
     CCoinsViewCursor(const uint256 &hashBlockIn) : hashBlock(hashBlockIn) {}
     virtual ~CCoinsViewCursor() {}
 
     virtual bool GetKey(COutPoint &key) const = 0;
     virtual bool GetValue(Coin &coin) const = 0;
     virtual unsigned int GetValueSize() const = 0;
 
     virtual bool Valid() const = 0;
     virtual void Next() = 0;
 
     //! Get best block at the time this cursor was created
     const uint256 &GetBestBlock() const { return hashBlock; }
 
 private:
     uint256 hashBlock;
 };
 
 /** Abstract view on the open txout dataset. */
 class CCoinsView {
 public:
     //! Retrieve the Coin (unspent transaction output) for a given outpoint.
     virtual bool GetCoin(const COutPoint &outpoint, Coin &coin) const;
 
     //! Just check whether we have data for a given outpoint.
     //! This may (but cannot always) return true for spent outputs.
     virtual bool HaveCoin(const COutPoint &outpoint) const;
 
     //! Retrieve the block hash whose state this CCoinsView currently represents
     virtual uint256 GetBestBlock() const;
 
     //! Retrieve the range of blocks that may have been only partially written.
     //! If the database is in a consistent state, the result is the empty
     //! vector.
     //! Otherwise, a two-element vector is returned consisting of the new and
     //! the old block hash, in that order.
     virtual std::vector<uint256> GetHeadBlocks() const;
 
     //! Do a bulk modification (multiple Coin changes + BestBlock change).
     //! The passed mapCoins can be modified.
     virtual bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock);
 
     //! Get a cursor to iterate over the whole state
     virtual CCoinsViewCursor *Cursor() const;
 
     //! As we use CCoinsViews polymorphically, have a virtual destructor
     virtual ~CCoinsView() {}
 
     //! Estimate database size (0 if not implemented)
     virtual size_t EstimateSize() const { return 0; }
 };
 
 /** CCoinsView backed by another CCoinsView */
 class CCoinsViewBacked : public CCoinsView {
 protected:
     CCoinsView *base;
 
 public:
     CCoinsViewBacked(CCoinsView *viewIn);
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
     bool HaveCoin(const COutPoint &outpoint) const override;
     uint256 GetBestBlock() const override;
     std::vector<uint256> GetHeadBlocks() const override;
     void SetBackend(CCoinsView &viewIn);
     bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) override;
     CCoinsViewCursor *Cursor() const override;
     size_t EstimateSize() const override;
 };
 
 /**
  * CCoinsView that adds a memory cache for transactions to another CCoinsView
  */
 class CCoinsViewCache : public CCoinsViewBacked {
 protected:
     /**
      * Make mutable so that we can "fill the cache" even from Get-methods
      * declared as "const".
      */
     mutable uint256 hashBlock;
     mutable CCoinsMap cacheCoins;
 
     /* Cached dynamic memory usage for the inner Coin objects. */
     mutable size_t cachedCoinsUsage;
 
 public:
     CCoinsViewCache(CCoinsView *baseIn);
 
     // Standard CCoinsView methods
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override;
     bool HaveCoin(const COutPoint &outpoint) const override;
     uint256 GetBestBlock() const override;
     void SetBestBlock(const uint256 &hashBlock);
     bool BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) override;
     CCoinsViewCursor *Cursor() const override {
         throw std::logic_error(
             "CCoinsViewCache cursor iteration not supported.");
     }
 
     /**
      * Check if we have the given utxo already loaded in this cache.
      * The semantics are the same as HaveCoin(), but no calls to the backing
      * CCoinsView are made.
      */
     bool HaveCoinInCache(const COutPoint &outpoint) const;
 
     /**
      * Return a reference to a Coin in the cache, or a pruned one if not found.
      * This is more efficient than GetCoin. Modifications to other cache entries
      * are allowed while accessing the returned pointer.
      */
     const Coin &AccessCoin(const COutPoint &output) const;
 
     /**
      * Add a coin. Set potential_overwrite to true if a non-pruned version may
      * already exist.
      */
     void AddCoin(const COutPoint &outpoint, Coin coin,
                  bool potential_overwrite);
 
     /**
      * Spend a coin. Pass moveto in order to get the deleted data.
      * If no unspent output exists for the passed outpoint, this call has no
      * effect.
      */
     bool SpendCoin(const COutPoint &outpoint, Coin *moveto = nullptr);
 
     /**
      * Push the modifications applied to this cache to its base.
      * Failure to call this method before destruction will cause the changes to
      * be forgotten. If false is returned, the state of this cache (and its
      * backing view) will be undefined.
      */
     bool Flush();
 
     /**
      * Removes the UTXO with the given outpoint from the cache, if it is not
      * modified.
      */
     void Uncache(const COutPoint &outpoint);
 
     //! Calculate the size of the cache (in number of transaction outputs)
     unsigned int GetCacheSize() const;
 
     //! Calculate the size of the cache (in bytes)
     size_t DynamicMemoryUsage() const;
 
     /**
      * Amount of bitcoins coming in to a transaction
      * Note that lightweight clients may not know anything besides the hash of
      * previous transactions, so may not be able to calculate this.
      *
      * @param[in] tx	transaction for which we are checking input total
      * @return	Sum of value of all inputs (scriptSigs)
      */
     Amount GetValueIn(const CTransaction &tx) const;
 
     //! Check whether all prevouts of the transaction are present in the UTXO
     //! set represented by this view
     bool HaveInputs(const CTransaction &tx) const;
 
     /**
      * Return priority of tx at height nHeight. Also calculate the sum of the
      * values of the inputs that are already in the chain. These are the inputs
      * that will age and increase priority as new blocks are added to the chain.
      */
     double GetPriority(const CTransaction &tx, int nHeight,
                        Amount &inChainInputValue) const;
 
     const CTxOut &GetOutputFor(const CTxIn &input) const;
 
 private:
     CCoinsMap::iterator FetchCoin(const COutPoint &outpoint) const;
 
     /**
      * By making the copy constructor private, we prevent accidentally using it
      * when one intends to create a cache on top of a base cache.
      */
     CCoinsViewCache(const CCoinsViewCache &);
 };
 
 //! Utility function to add all of a transaction's outputs to a cache.
 // When check is false, this assumes that overwrites are only possible for
 // coinbase transactions.
 // When check is true, the underlying view may be queried to determine whether
 // an addition is an overwrite.
 // TODO: pass in a boolean to limit these possible overwrites to known
 // (pre-BIP34) cases.
 void AddCoins(CCoinsViewCache &cache, const CTransaction &tx, int nHeight,
               bool check = false);
 
 //! Utility function to find any unspent output with a given txid.
 // This function can be quite expensive because in the event of a transaction
 // which is not found in the cache, it can cause up to MAX_OUTPUTS_PER_BLOCK
 // lookups to database, so it should be used with care.
 const Coin &AccessByTxid(const CCoinsViewCache &cache, const TxId &txid);
 
 #endif // BITCOIN_COINS_H
diff --git a/src/compat.h b/src/compat.h
index 7207c9ed08..88f3c8d813 100644
--- a/src/compat.h
+++ b/src/compat.h
@@ -1,103 +1,103 @@
 // 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_COMPAT_H
 #define BITCOIN_COMPAT_H
 
 #if defined(HAVE_CONFIG_H)
-#include "config/bitcoin-config.h"
+#include <config/bitcoin-config.h>
 #endif
 
 #include <type_traits>
 
 // GCC 4.8 is missing some C++11 type_traits,
 // https://www.gnu.org/software/gcc/gcc-5/changes.html
 #if defined(__GNUC__) && __GNUC__ < 5
 #define IS_TRIVIALLY_CONSTRUCTIBLE std::is_trivial
 #else
 #define IS_TRIVIALLY_CONSTRUCTIBLE std::is_trivially_constructible
 #endif
 
 #ifdef WIN32
 #ifdef _WIN32_WINNT
 #undef _WIN32_WINNT
 #endif
 #define _WIN32_WINNT 0x0501
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN 1
 #endif
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 #ifdef FD_SETSIZE
 #undef FD_SETSIZE // prevent redefinition compiler warning
 #endif
 #define FD_SETSIZE 1024 // max number of fds in fd_set
 
 #include <winsock2.h> // Must be included before mswsock.h and windows.h
 
 #include <mswsock.h>
 #include <windows.h>
 #include <ws2tcpip.h>
 #else
 #include <arpa/inet.h>
 #include <climits>
 #include <ifaddrs.h>
 #include <net/if.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <sys/fcntl.h>
 #include <sys/mman.h>
 #include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 
 #ifndef WIN32
 typedef unsigned int SOCKET;
-#include "errno.h"
+#include <errno.h>
 #define WSAGetLastError() errno
 #define WSAEINVAL EINVAL
 #define WSAEALREADY EALREADY
 #define WSAEWOULDBLOCK EWOULDBLOCK
 #define WSAEMSGSIZE EMSGSIZE
 #define WSAEINTR EINTR
 #define WSAEINPROGRESS EINPROGRESS
 #define WSAEADDRINUSE EADDRINUSE
 #define WSAENOTSOCK EBADF
 #define INVALID_SOCKET (SOCKET)(~0)
 #define SOCKET_ERROR -1
 #endif
 
 #ifdef WIN32
 #ifndef S_IRUSR
 #define S_IRUSR 0400
 #define S_IWUSR 0200
 #endif
 #else
 #define MAX_PATH 1024
 #endif
 
 #if HAVE_DECL_STRNLEN == 0
 size_t strnlen(const char *start, size_t max_len);
 #endif // HAVE_DECL_STRNLEN
 
 #ifndef WIN32
 typedef void *sockopt_arg_type;
 #else
 typedef char *sockopt_arg_type;
 #endif
 
 static bool inline IsSelectableSocket(const SOCKET &s) {
 #ifdef WIN32
     return true;
 #else
     return (s < FD_SETSIZE);
 #endif
 }
 
 #endif // BITCOIN_COMPAT_H
diff --git a/src/compressor.cpp b/src/compressor.cpp
index d2cc0eab1e..9334a7751e 100644
--- a/src/compressor.cpp
+++ b/src/compressor.cpp
@@ -1,185 +1,185 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2014 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "compressor.h"
+#include <compressor.h>
 
-#include "hash.h"
-#include "pubkey.h"
-#include "script/standard.h"
+#include <hash.h>
+#include <pubkey.h>
+#include <script/standard.h>
 
 bool CScriptCompressor::IsToKeyID(CKeyID &hash) const {
     if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160 &&
         script[2] == 20 && script[23] == OP_EQUALVERIFY &&
         script[24] == OP_CHECKSIG) {
         memcpy(&hash, &script[3], 20);
         return true;
     }
     return false;
 }
 
 bool CScriptCompressor::IsToScriptID(CScriptID &hash) const {
     if (script.size() == 23 && script[0] == OP_HASH160 && script[1] == 20 &&
         script[22] == OP_EQUAL) {
         memcpy(&hash, &script[2], 20);
         return true;
     }
     return false;
 }
 
 bool CScriptCompressor::IsToPubKey(CPubKey &pubkey) const {
     if (script.size() == 35 && script[0] == 33 && script[34] == OP_CHECKSIG &&
         (script[1] == 0x02 || script[1] == 0x03)) {
         pubkey.Set(&script[1], &script[34]);
         return true;
     }
     if (script.size() == 67 && script[0] == 65 && script[66] == OP_CHECKSIG &&
         script[1] == 0x04) {
         pubkey.Set(&script[1], &script[66]);
         // if not fully valid, a case that would not be compressible
         return pubkey.IsFullyValid();
     }
     return false;
 }
 
 bool CScriptCompressor::Compress(std::vector<uint8_t> &out) const {
     CKeyID keyID;
     if (IsToKeyID(keyID)) {
         out.resize(21);
         out[0] = 0x00;
         memcpy(&out[1], &keyID, 20);
         return true;
     }
     CScriptID scriptID;
     if (IsToScriptID(scriptID)) {
         out.resize(21);
         out[0] = 0x01;
         memcpy(&out[1], &scriptID, 20);
         return true;
     }
     CPubKey pubkey;
     if (IsToPubKey(pubkey)) {
         out.resize(33);
         memcpy(&out[1], &pubkey[1], 32);
         if (pubkey[0] == 0x02 || pubkey[0] == 0x03) {
             out[0] = pubkey[0];
             return true;
         } else if (pubkey[0] == 0x04) {
             out[0] = 0x04 | (pubkey[64] & 0x01);
             return true;
         }
     }
     return false;
 }
 
 unsigned int CScriptCompressor::GetSpecialSize(unsigned int nSize) const {
     if (nSize == 0 || nSize == 1) {
         return 20;
     }
     if (nSize == 2 || nSize == 3 || nSize == 4 || nSize == 5) {
         return 32;
     }
     return 0;
 }
 
 bool CScriptCompressor::Decompress(unsigned int nSize,
                                    const std::vector<uint8_t> &in) {
     switch (nSize) {
         case 0x00:
             script.resize(25);
             script[0] = OP_DUP;
             script[1] = OP_HASH160;
             script[2] = 20;
             memcpy(&script[3], &in[0], 20);
             script[23] = OP_EQUALVERIFY;
             script[24] = OP_CHECKSIG;
             return true;
         case 0x01:
             script.resize(23);
             script[0] = OP_HASH160;
             script[1] = 20;
             memcpy(&script[2], &in[0], 20);
             script[22] = OP_EQUAL;
             return true;
         case 0x02:
         case 0x03:
             script.resize(35);
             script[0] = 33;
             script[1] = nSize;
             memcpy(&script[2], &in[0], 32);
             script[34] = OP_CHECKSIG;
             return true;
         case 0x04:
         case 0x05:
             uint8_t vch[33] = {};
             vch[0] = nSize - 2;
             memcpy(&vch[1], &in[0], 32);
             CPubKey pubkey(&vch[0], &vch[33]);
             if (!pubkey.Decompress()) return false;
             assert(pubkey.size() == 65);
             script.resize(67);
             script[0] = 65;
             memcpy(&script[1], pubkey.begin(), 65);
             script[66] = OP_CHECKSIG;
             return true;
     }
     return false;
 }
 
 // Amount compression:
 // * If the amount is 0, output 0
 // * first, divide the amount (in base units) by the largest power of 10
 // possible; call the exponent e (e is max 9)
 // * if e<9, the last digit of the resulting number cannot be 0; store it as d,
 // and drop it (divide by 10)
 //   * call the result n
 //   * output 1 + 10*(9*n + d - 1) + e
 // * if e==9, we only know the resulting number is not zero, so output 1 + 10*(n
 // - 1) + 9
 // (this is decodable, as d is in [1-9] and e is in [0-9])
 uint64_t CTxOutCompressor::CompressAmount(Amount amt) {
     uint64_t n = amt / SATOSHI;
     if (n == 0) {
         return 0;
     }
     int e = 0;
     while (((n % 10) == 0) && e < 9) {
         n /= 10;
         e++;
     }
     if (e < 9) {
         int d = (n % 10);
         assert(d >= 1 && d <= 9);
         n /= 10;
         return 1 + (n * 9 + d - 1) * 10 + e;
     } else {
         return 1 + (n - 1) * 10 + 9;
     }
 }
 
 Amount CTxOutCompressor::DecompressAmount(uint64_t x) {
     // x = 0  OR  x = 1+10*(9*n + d - 1) + e  OR  x = 1+10*(n - 1) + 9
     if (x == 0) {
         return Amount::zero();
     }
     x--;
     // x = 10*(9*n + d - 1) + e
     int e = x % 10;
     x /= 10;
     uint64_t n = 0;
     if (e < 9) {
         // x = 9*n + d - 1
         int d = (x % 9) + 1;
         x /= 9;
         // x = n
         n = x * 10 + d;
     } else {
         n = x + 1;
     }
     while (e) {
         n *= 10;
         e--;
     }
     return int64_t(n) * SATOSHI;
 }
diff --git a/src/compressor.h b/src/compressor.h
index 80378ff960..aa1d367e08 100644
--- a/src/compressor.h
+++ b/src/compressor.h
@@ -1,120 +1,120 @@
 // 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_COMPRESSOR_H
 #define BITCOIN_COMPRESSOR_H
 
-#include "primitives/transaction.h"
-#include "script/script.h"
-#include "serialize.h"
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <serialize.h>
 
 class CKeyID;
 class CPubKey;
 class CScriptID;
 
 /**
  * Compact serializer for scripts.
  *
  * It detects common cases and encodes them much more efficiently.
  * 3 special cases are defined:
  *  * Pay to pubkey hash (encoded as 21 bytes)
  *  * Pay to script hash (encoded as 21 bytes)
  *  * Pay to pubkey starting with 0x02, 0x03 or 0x04 (encoded as 33 bytes)
  *
  * Other scripts up to 121 bytes require 1 byte + script length. Above that,
  * scripts up to 16505 bytes require 2 bytes + script length.
  */
 class CScriptCompressor {
 private:
     /**
      * make this static for now (there are only 6 special scripts defined) this
      * can potentially be extended together with a new nVersion for
      * transactions, in which case this value becomes dependent on nVersion and
      * nHeight of the enclosing transaction.
      */
     static const unsigned int nSpecialScripts = 6;
 
     CScript &script;
 
 protected:
     /**
      * These check for scripts for which a special case with a shorter encoding
      * is defined. They are implemented separately from the CScript test, as
      * these test for exact byte sequence correspondences, and are more strict.
      * For example, IsToPubKey also verifies whether the public key is valid (as
      * invalid ones cannot be represented in compressed form).
      */
     bool IsToKeyID(CKeyID &hash) const;
     bool IsToScriptID(CScriptID &hash) const;
     bool IsToPubKey(CPubKey &pubkey) const;
 
     bool Compress(std::vector<uint8_t> &out) const;
     unsigned int GetSpecialSize(unsigned int nSize) const;
     bool Decompress(unsigned int nSize, const std::vector<uint8_t> &out);
 
 public:
     explicit CScriptCompressor(CScript &scriptIn) : script(scriptIn) {}
 
     template <typename Stream> void Serialize(Stream &s) const {
         std::vector<uint8_t> compr;
         if (Compress(compr)) {
             s << CFlatData(compr);
             return;
         }
         unsigned int nSize = script.size() + nSpecialScripts;
         s << VARINT(nSize);
         s << CFlatData(script);
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
         unsigned int nSize = 0;
         s >> VARINT(nSize);
         if (nSize < nSpecialScripts) {
             std::vector<uint8_t> vch(GetSpecialSize(nSize), 0x00);
             s >> REF(CFlatData(vch));
             Decompress(nSize, vch);
             return;
         }
         nSize -= nSpecialScripts;
         if (nSize > MAX_SCRIPT_SIZE) {
             // Overly long script, replace with a short invalid one
             script << OP_RETURN;
             s.ignore(nSize);
         } else {
             script.resize(nSize);
             s >> REF(CFlatData(script));
         }
     }
 };
 
 /** wrapper for CTxOut that provides a more compact serialization */
 class CTxOutCompressor {
 private:
     CTxOut &txout;
 
 public:
     static uint64_t CompressAmount(Amount nAmount);
     static Amount DecompressAmount(uint64_t nAmount);
 
     explicit CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) {}
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         if (!ser_action.ForRead()) {
             uint64_t nVal = CompressAmount(txout.nValue);
             READWRITE(VARINT(nVal));
         } else {
             uint64_t nVal = 0;
             READWRITE(VARINT(nVal));
             txout.nValue = DecompressAmount(nVal);
         }
         CScriptCompressor cscript(REF(txout.scriptPubKey));
         READWRITE(cscript);
     }
 };
 
 #endif // BITCOIN_COMPRESSOR_H
diff --git a/src/config.cpp b/src/config.cpp
index 246244939f..80069d446e 100644
--- a/src/config.cpp
+++ b/src/config.cpp
@@ -1,100 +1,101 @@
 // Copyright (c) 2017 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "config.h"
-#include "chainparams.h"
-#include "consensus/consensus.h" // DEFAULT_MAX_BLOCK_SIZE
-#include "globals.h"
-#include "policy/policy.h" // DEFAULT_BLOCK_PRIORITY_PERCENTAGE
+#include <config.h>
+
+#include <chainparams.h>
+#include <consensus/consensus.h> // DEFAULT_MAX_BLOCK_SIZE
+#include <globals.h>
+#include <policy/policy.h> // DEFAULT_BLOCK_PRIORITY_PERCENTAGE
 
 GlobalConfig::GlobalConfig()
     : useCashAddr(false), nMaxBlockSize(DEFAULT_MAX_BLOCK_SIZE),
       nBlockPriorityPercentage(DEFAULT_BLOCK_PRIORITY_PERCENTAGE) {}
 
 bool GlobalConfig::SetMaxBlockSize(uint64_t maxBlockSize) {
     // Do not allow maxBlockSize to be set below historic 1MB limit
     // It cannot be equal either because of the "must be big" UAHF rule.
     if (maxBlockSize <= LEGACY_MAX_BLOCK_SIZE) {
         return false;
     }
 
     nMaxBlockSize = maxBlockSize;
     return true;
 }
 
 uint64_t GlobalConfig::GetMaxBlockSize() const {
     return nMaxBlockSize;
 }
 
 bool GlobalConfig::SetBlockPriorityPercentage(int64_t blockPriorityPercentage) {
     // blockPriorityPercentage has to belong to [0..100]
     if ((blockPriorityPercentage < 0) || (blockPriorityPercentage > 100)) {
         return false;
     }
     nBlockPriorityPercentage = blockPriorityPercentage;
     return true;
 }
 
 uint8_t GlobalConfig::GetBlockPriorityPercentage() const {
     return nBlockPriorityPercentage;
 }
 
 const CChainParams &GlobalConfig::GetChainParams() const {
     return Params();
 }
 
 static GlobalConfig gConfig;
 
 const Config &GetConfig() {
     return gConfig;
 }
 
 void GlobalConfig::SetCashAddrEncoding(bool c) {
     useCashAddr = c;
 }
 bool GlobalConfig::UseCashAddrEncoding() const {
     return useCashAddr;
 }
 
 DummyConfig::DummyConfig()
     : chainParams(CreateChainParams(CBaseChainParams::REGTEST)) {}
 
 DummyConfig::DummyConfig(std::string net)
     : chainParams(CreateChainParams(net)) {}
 
 void DummyConfig::SetChainParams(std::string net) {
     chainParams = CreateChainParams(net);
 }
 
 void GlobalConfig::SetExcessUTXOCharge(Amount fee) {
     excessUTXOCharge = fee;
 }
 
 Amount GlobalConfig::GetExcessUTXOCharge() const {
     return excessUTXOCharge;
 }
 
 void GlobalConfig::SetMinFeePerKB(CFeeRate fee) {
     feePerKB = fee;
 }
 
 CFeeRate GlobalConfig::GetMinFeePerKB() const {
     return feePerKB;
 }
 
 void GlobalConfig::SetRPCUserAndPassword(std::string userAndPassword) {
     rpcUserAndPassword = userAndPassword;
 }
 
 std::string GlobalConfig::GetRPCUserAndPassword() const {
     return rpcUserAndPassword;
 }
 
 void GlobalConfig::SetRPCCORSDomain(std::string corsDomain) {
     rpcCORSDomain = corsDomain;
 }
 
 std::string GlobalConfig::GetRPCCORSDomain() const {
     return rpcCORSDomain;
 }
diff --git a/src/config.h b/src/config.h
index cfe9fc800e..9c415b225a 100644
--- a/src/config.h
+++ b/src/config.h
@@ -1,120 +1,120 @@
 // Copyright (c) 2017 Amaury SÉCHET
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_CONFIG_H
 #define BITCOIN_CONFIG_H
 
-#include "amount.h"
-#include "feerate.h"
+#include <amount.h>
+#include <feerate.h>
 
 #include <boost/noncopyable.hpp>
 
 #include <cstdint>
 #include <memory>
 #include <string>
 
 class CChainParams;
 
 class Config : public boost::noncopyable {
 public:
     virtual bool SetMaxBlockSize(uint64_t maxBlockSize) = 0;
     virtual uint64_t GetMaxBlockSize() const = 0;
     virtual bool
     SetBlockPriorityPercentage(int64_t blockPriorityPercentage) = 0;
     virtual uint8_t GetBlockPriorityPercentage() const = 0;
     virtual const CChainParams &GetChainParams() const = 0;
     virtual void SetCashAddrEncoding(bool) = 0;
     virtual bool UseCashAddrEncoding() const = 0;
 
     virtual void SetExcessUTXOCharge(Amount amt) = 0;
     virtual Amount GetExcessUTXOCharge() const = 0;
 
     virtual void SetMinFeePerKB(CFeeRate amt) = 0;
     virtual CFeeRate GetMinFeePerKB() const = 0;
 
     virtual void SetRPCUserAndPassword(std::string userAndPassword) = 0;
     virtual std::string GetRPCUserAndPassword() const = 0;
     virtual void SetRPCCORSDomain(std::string corsDomain) = 0;
     virtual std::string GetRPCCORSDomain() const = 0;
 };
 
 class GlobalConfig final : public Config {
 public:
     GlobalConfig();
     bool SetMaxBlockSize(uint64_t maxBlockSize) override;
     uint64_t GetMaxBlockSize() const override;
     bool SetBlockPriorityPercentage(int64_t blockPriorityPercentage) override;
     uint8_t GetBlockPriorityPercentage() const override;
     const CChainParams &GetChainParams() const override;
     void SetCashAddrEncoding(bool) override;
     bool UseCashAddrEncoding() const override;
 
     void SetExcessUTXOCharge(Amount) override;
     Amount GetExcessUTXOCharge() const override;
 
     void SetMinFeePerKB(CFeeRate amt) override;
     CFeeRate GetMinFeePerKB() const override;
 
     void SetRPCUserAndPassword(std::string userAndPassword) override;
     std::string GetRPCUserAndPassword() const override;
     void SetRPCCORSDomain(std::string corsDomain) override;
     std::string GetRPCCORSDomain() const override;
 
 private:
     bool useCashAddr;
     Amount excessUTXOCharge;
     CFeeRate feePerKB;
 
     /** RPC authentication configs */
 
     // Pre-base64-encoded authentication token, with user and password separated
     // by a colon.
     std::string rpcUserAndPassword;
     // CORS domain, the allowed Origin
     std::string rpcCORSDomain;
 
     /** The largest block size this node will accept. */
     uint64_t nMaxBlockSize;
     uint64_t nBlockPriorityPercentage;
 };
 
 // Dummy for subclassing in unittests
 class DummyConfig : public Config {
 public:
     DummyConfig();
     DummyConfig(std::string net);
     bool SetMaxBlockSize(uint64_t maxBlockSize) override { return false; }
     uint64_t GetMaxBlockSize() const override { return 0; }
     bool SetBlockPriorityPercentage(int64_t blockPriorityPercentage) override {
         return false;
     }
     uint8_t GetBlockPriorityPercentage() const override { return 0; }
 
     void SetChainParams(std::string net);
     const CChainParams &GetChainParams() const override { return *chainParams; }
 
     void SetCashAddrEncoding(bool) override {}
     bool UseCashAddrEncoding() const override { return false; }
 
     void SetExcessUTXOCharge(Amount amt) override {}
     Amount GetExcessUTXOCharge() const override { return Amount::zero(); }
 
     void SetMinFeePerKB(CFeeRate amt) override{};
     CFeeRate GetMinFeePerKB() const override {
         return CFeeRate(Amount::zero());
     }
 
     void SetRPCUserAndPassword(std::string userAndPassword) override{};
     std::string GetRPCUserAndPassword() const override { return ""; };
     void SetRPCCORSDomain(std::string corsDomain) override{};
     std::string GetRPCCORSDomain() const override { return ""; };
 
 private:
     std::unique_ptr<CChainParams> chainParams;
 };
 
 // Temporary woraround.
 const Config &GetConfig();
 
 #endif