diff --git a/src/uint256.h b/src/uint256.h
--- a/src/uint256.h
+++ b/src/uint256.h
@@ -16,28 +16,28 @@
 template <unsigned int BITS> class base_blob {
 protected:
     static constexpr int WIDTH = BITS / 8;
-    uint8_t data[WIDTH];
+    uint8_t m_data[WIDTH];
 
 public:
-    base_blob() { memset(data, 0, sizeof(data)); }
+    base_blob() { memset(m_data, 0, sizeof(m_data)); }
 
     explicit base_blob(const std::vector<uint8_t> &vch);
 
     bool IsNull() const {
         for (int i = 0; i < WIDTH; i++) {
-            if (data[i] != 0) {
+            if (m_data[i] != 0) {
                 return false;
             }
         }
         return true;
     }
 
-    void SetNull() { memset(data, 0, sizeof(data)); }
+    void SetNull() { memset(m_data, 0, sizeof(m_data)); }
 
     inline int Compare(const base_blob &other) const {
-        for (size_t i = 0; i < sizeof(data); i++) {
-            uint8_t a = data[sizeof(data) - 1 - i];
-            uint8_t b = other.data[sizeof(data) - 1 - i];
+        for (size_t i = 0; i < sizeof(m_data); i++) {
+            uint8_t a = m_data[sizeof(m_data) - 1 - i];
+            uint8_t b = other.m_data[sizeof(m_data) - 1 - i];
             if (a > b) {
                 return 1;
             }
@@ -73,18 +73,18 @@
     void SetHex(const std::string &str);
     std::string ToString() const { return GetHex(); }
 
-    uint8_t *begin() { return &data[0]; }
+    uint8_t *begin() { return &m_data[0]; }
 
-    uint8_t *end() { return &data[WIDTH]; }
+    uint8_t *end() { return &m_data[WIDTH]; }
 
-    const uint8_t *begin() const { return &data[0]; }
+    const uint8_t *begin() const { return &m_data[0]; }
 
-    const uint8_t *end() const { return &data[WIDTH]; }
+    const uint8_t *end() const { return &m_data[WIDTH]; }
 
-    unsigned int size() const { return sizeof(data); }
+    unsigned int size() const { return sizeof(m_data); }
 
     uint64_t GetUint64(int pos) const {
-        const uint8_t *ptr = data + pos * 8;
+        const uint8_t *ptr = m_data + pos * 8;
         return uint64_t(ptr[0]) | (uint64_t(ptr[1]) << 8) |
                (uint64_t(ptr[2]) << 16) | (uint64_t(ptr[3]) << 24) |
                (uint64_t(ptr[4]) << 32) | (uint64_t(ptr[5]) << 40) |
@@ -92,11 +92,11 @@
     }
 
     template <typename Stream> void Serialize(Stream &s) const {
-        s.write((char *)data, sizeof(data));
+        s.write((char *)m_data, sizeof(m_data));
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
-        s.read((char *)data, sizeof(data));
+        s.read((char *)m_data, sizeof(m_data));
     }
 };
 
diff --git a/src/uint256.cpp b/src/uint256.cpp
--- a/src/uint256.cpp
+++ b/src/uint256.cpp
@@ -9,17 +9,18 @@
 
 template <unsigned int BITS>
 base_blob<BITS>::base_blob(const std::vector<uint8_t> &vch) {
-    assert(vch.size() == sizeof(data));
-    memcpy(data, vch.data(), sizeof(data));
+    assert(vch.size() == sizeof(m_data));
+    memcpy(m_data, vch.data(), sizeof(m_data));
 }
 
 template <unsigned int BITS> std::string base_blob<BITS>::GetHex() const {
-    return HexStr(std::reverse_iterator<const uint8_t *>(data + sizeof(data)),
-                  std::reverse_iterator<const uint8_t *>(data));
+    return HexStr(
+        std::reverse_iterator<const uint8_t *>(m_data + sizeof(m_data)),
+        std::reverse_iterator<const uint8_t *>(m_data));
 }
 
 template <unsigned int BITS> void base_blob<BITS>::SetHex(const char *psz) {
-    memset(data, 0, sizeof(data));
+    memset(m_data, 0, sizeof(m_data));
 
     // skip leading spaces
     while (IsSpace(*psz)) {
@@ -37,7 +38,7 @@
         digits++;
     }
 
-    uint8_t *p1 = (uint8_t *)data;
+    uint8_t *p1 = (uint8_t *)m_data;
     uint8_t *pend = p1 + WIDTH;
     while (digits > 0 && p1 < pend) {
         *p1 = ::HexDigit(psz[--digits]);