diff --git a/src/serialize.h b/src/serialize.h
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -244,15 +244,18 @@
  * size <= UINT_MAX   -- 5 bytes  (254 + 4 bytes)
  * size >  UINT_MAX   -- 9 bytes  (255 + 8 bytes)
  */
-inline unsigned int GetSizeOfCompactSize(uint64_t nSize) {
-    if (nSize < 253)
+inline uint32_t GetSizeOfCompactSize(uint64_t nSize) {
+    if (nSize < 253) {
         return sizeof(uint8_t);
-    else if (nSize <= std::numeric_limits<unsigned short>::max())
-        return sizeof(uint8_t) + sizeof(unsigned short);
-    else if (nSize <= std::numeric_limits<unsigned int>::max())
-        return sizeof(uint8_t) + sizeof(unsigned int);
-    else
-        return sizeof(uint8_t) + sizeof(uint64_t);
+    }
+    if (nSize <= std::numeric_limits<uint16_t>::max()) {
+        return sizeof(uint8_t) + sizeof(uint16_t);
+    }
+    if (nSize <= std::numeric_limits<uint32_t>::max()) {
+        return sizeof(uint8_t) + sizeof(uint32_t);
+    }
+
+    return sizeof(uint8_t) + sizeof(uint64_t);
 }
 
 inline void WriteCompactSize(CSizeComputer &os, uint64_t nSize);
@@ -260,10 +263,10 @@
 template <typename Stream> void WriteCompactSize(Stream &os, uint64_t nSize) {
     if (nSize < 253) {
         ser_writedata8(os, nSize);
-    } else if (nSize <= std::numeric_limits<unsigned short>::max()) {
+    } else if (nSize <= std::numeric_limits<uint16_t>::max()) {
         ser_writedata8(os, 253);
         ser_writedata16(os, nSize);
-    } else if (nSize <= std::numeric_limits<unsigned int>::max()) {
+    } else if (nSize <= std::numeric_limits<uint32_t>::max()) {
         ser_writedata8(os, 254);
         ser_writedata32(os, nSize);
     } else {
@@ -280,16 +283,19 @@
         nSizeRet = chSize;
     } else if (chSize == 253) {
         nSizeRet = ser_readdata16(is);
-        if (nSizeRet < 253)
+        if (nSizeRet < 253) {
             throw std::ios_base::failure("non-canonical ReadCompactSize()");
+        }
     } else if (chSize == 254) {
         nSizeRet = ser_readdata32(is);
-        if (nSizeRet < 0x10000u)
+        if (nSizeRet < 0x10000u) {
             throw std::ios_base::failure("non-canonical ReadCompactSize()");
+        }
     } else {
         nSizeRet = ser_readdata64(is);
-        if (nSizeRet < 0x100000000ULL)
+        if (nSizeRet < 0x100000000ULL) {
             throw std::ios_base::failure("non-canonical ReadCompactSize()");
+        }
     }
     if (nSizeRet > MAX_SIZE) {
         throw std::ios_base::failure("ReadCompactSize(): size too large");
@@ -324,10 +330,11 @@
     int nRet = 0;
     while (true) {
         nRet++;
-        if (n <= 0x7F) break;
+        if (n <= 0x7F) {
+            return nRet;
+        }
         n = (n >> 7) - 1;
     }
-    return nRet;
 }
 
 template <typename I> inline void WriteVarInt(CSizeComputer &os, I n);
@@ -337,7 +344,9 @@
     int len = 0;
     while (true) {
         tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
-        if (n <= 0x7F) break;
+        if (n <= 0x7F) {
+            break;
+        }
         n = (n >> 7) - 1;
         len++;
     }
@@ -351,10 +360,10 @@
     while (true) {
         uint8_t chData = ser_readdata8(is);
         n = (n << 7) | (chData & 0x7F);
-        if (chData & 0x80)
-            n++;
-        else
+        if ((chData & 0x80) == 0) {
             return n;
+        }
+        n++;
     }
 }
 
@@ -443,12 +452,16 @@
             throw std::ios_base::failure("String length limit exceeded");
         }
         string.resize(size);
-        if (size != 0) s.read((char *)&string[0], size);
+        if (size != 0) {
+            s.read((char *)&string[0], size);
+        }
     }
 
     template <typename Stream> void Serialize(Stream &s) const {
         WriteCompactSize(s, string.size());
-        if (!string.empty()) s.write((char *)&string[0], string.size());
+        if (!string.empty()) {
+            s.write((char *)&string[0], string.size());
+        }
     }
 };
 
@@ -564,14 +577,18 @@
 template <typename Stream, typename C>
 void Serialize(Stream &os, const std::basic_string<C> &str) {
     WriteCompactSize(os, str.size());
-    if (!str.empty()) os.write((char *)&str[0], str.size() * sizeof(str[0]));
+    if (!str.empty()) {
+        os.write((char *)&str[0], str.size() * sizeof(str[0]));
+    }
 }
 
 template <typename Stream, typename C>
 void Unserialize(Stream &is, std::basic_string<C> &str) {
-    unsigned int nSize = ReadCompactSize(is);
+    size_t nSize = ReadCompactSize(is);
     str.resize(nSize);
-    if (nSize != 0) is.read((char *)&str[0], nSize * sizeof(str[0]));
+    if (nSize != 0) {
+        is.read((char *)&str[0], nSize * sizeof(str[0]));
+    }
 }
 
 /**
@@ -580,15 +597,17 @@
 template <typename Stream, unsigned int N, typename T>
 void Serialize_impl(Stream &os, const prevector<N, T> &v, const uint8_t &) {
     WriteCompactSize(os, v.size());
-    if (!v.empty()) os.write((char *)&v[0], v.size() * sizeof(T));
+    if (!v.empty()) {
+        os.write((char *)&v[0], v.size() * sizeof(T));
+    }
 }
 
 template <typename Stream, unsigned int N, typename T, typename V>
 void Serialize_impl(Stream &os, const prevector<N, T> &v, const V &) {
     WriteCompactSize(os, v.size());
-    for (typename prevector<N, T>::const_iterator vi = v.begin(); vi != v.end();
-         ++vi)
-        ::Serialize(os, (*vi));
+    for (const T &i : v) {
+        ::Serialize(os, i);
+    }
 }
 
 template <typename Stream, unsigned int N, typename T>
@@ -600,11 +619,10 @@
 void Unserialize_impl(Stream &is, prevector<N, T> &v, const uint8_t &) {
     // Limit size per read so bogus size value won't cause out of memory
     v.clear();
-    unsigned int nSize = ReadCompactSize(is);
-    unsigned int i = 0;
+    size_t nSize = ReadCompactSize(is);
+    size_t i = 0;
     while (i < nSize) {
-        unsigned int blk =
-            std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
+        size_t blk = std::min(nSize - i, size_t(1 + 4999999 / sizeof(T)));
         v.resize(i + blk);
         is.read((char *)&v[i], blk * sizeof(T));
         i += blk;
@@ -614,15 +632,18 @@
 template <typename Stream, unsigned int N, typename T, typename V>
 void Unserialize_impl(Stream &is, prevector<N, T> &v, const V &) {
     v.clear();
-    unsigned int nSize = ReadCompactSize(is);
-    unsigned int i = 0;
-    unsigned int nMid = 0;
+    size_t nSize = ReadCompactSize(is);
+    size_t i = 0;
+    size_t nMid = 0;
     while (nMid < nSize) {
         nMid += 5000000 / sizeof(T);
-        if (nMid > nSize) nMid = nSize;
+        if (nMid > nSize) {
+            nMid = nSize;
+        }
         v.resize(nMid);
-        for (; i < nMid; i++)
+        for (; i < nMid; i++) {
             Unserialize(is, v[i]);
+        }
     }
 }
 
@@ -637,15 +658,17 @@
 template <typename Stream, typename T, typename A>
 void Serialize_impl(Stream &os, const std::vector<T, A> &v, const uint8_t &) {
     WriteCompactSize(os, v.size());
-    if (!v.empty()) os.write((char *)&v[0], v.size() * sizeof(T));
+    if (!v.empty()) {
+        os.write((char *)&v[0], v.size() * sizeof(T));
+    }
 }
 
 template <typename Stream, typename T, typename A, typename V>
 void Serialize_impl(Stream &os, const std::vector<T, A> &v, const V &) {
     WriteCompactSize(os, v.size());
-    for (typename std::vector<T, A>::const_iterator vi = v.begin();
-         vi != v.end(); ++vi)
-        ::Serialize(os, (*vi));
+    for (const T &i : v) {
+        ::Serialize(os, i);
+    }
 }
 
 template <typename Stream, typename T, typename A>
@@ -657,11 +680,10 @@
 void Unserialize_impl(Stream &is, std::vector<T, A> &v, const uint8_t &) {
     // Limit size per read so bogus size value won't cause out of memory
     v.clear();
-    unsigned int nSize = ReadCompactSize(is);
-    unsigned int i = 0;
+    size_t nSize = ReadCompactSize(is);
+    size_t i = 0;
     while (i < nSize) {
-        unsigned int blk =
-            std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
+        size_t blk = std::min(nSize - i, size_t(1 + 4999999 / sizeof(T)));
         v.resize(i + blk);
         is.read((char *)&v[i], blk * sizeof(T));
         i += blk;
@@ -671,15 +693,18 @@
 template <typename Stream, typename T, typename A, typename V>
 void Unserialize_impl(Stream &is, std::vector<T, A> &v, const V &) {
     v.clear();
-    unsigned int nSize = ReadCompactSize(is);
-    unsigned int i = 0;
-    unsigned int nMid = 0;
+    size_t nSize = ReadCompactSize(is);
+    size_t i = 0;
+    size_t nMid = 0;
     while (nMid < nSize) {
         nMid += 5000000 / sizeof(T);
-        if (nMid > nSize) nMid = nSize;
+        if (nMid > nSize) {
+            nMid = nSize;
+        }
         v.resize(nMid);
-        for (; i < nMid; i++)
+        for (; i < nMid; i++) {
             Unserialize(is, v[i]);
+        }
     }
 }
 
@@ -709,17 +734,17 @@
 template <typename Stream, typename K, typename T, typename Pred, typename A>
 void Serialize(Stream &os, const std::map<K, T, Pred, A> &m) {
     WriteCompactSize(os, m.size());
-    for (typename std::map<K, T, Pred, A>::const_iterator mi = m.begin();
-         mi != m.end(); ++mi)
-        Serialize(os, (*mi));
+    for (const std::pair<K, T> &p : m) {
+        Serialize(os, p);
+    }
 }
 
 template <typename Stream, typename K, typename T, typename Pred, typename A>
 void Unserialize(Stream &is, std::map<K, T, Pred, A> &m) {
     m.clear();
-    unsigned int nSize = ReadCompactSize(is);
+    size_t nSize = ReadCompactSize(is);
     typename std::map<K, T, Pred, A>::iterator mi = m.begin();
-    for (unsigned int i = 0; i < nSize; i++) {
+    for (size_t i = 0; i < nSize; i++) {
         std::pair<K, T> item;
         Unserialize(is, item);
         mi = m.insert(mi, item);
@@ -732,17 +757,17 @@
 template <typename Stream, typename K, typename Pred, typename A>
 void Serialize(Stream &os, const std::set<K, Pred, A> &m) {
     WriteCompactSize(os, m.size());
-    for (typename std::set<K, Pred, A>::const_iterator it = m.begin();
-         it != m.end(); ++it)
-        Serialize(os, (*it));
+    for (const K &i : m) {
+        Serialize(os, i);
+    }
 }
 
 template <typename Stream, typename K, typename Pred, typename A>
 void Unserialize(Stream &is, std::set<K, Pred, A> &m) {
     m.clear();
-    unsigned int nSize = ReadCompactSize(is);
+    size_t nSize = ReadCompactSize(is);
     typename std::set<K, Pred, A>::iterator it = m.begin();
-    for (unsigned int i = 0; i < nSize; i++) {
+    for (size_t i = 0; i < nSize; i++) {
         K key;
         Unserialize(is, key);
         it = m.insert(it, key);