diff --git a/src/wallet/bdb.h b/src/wallet/bdb.h
--- a/src/wallet/bdb.h
+++ b/src/wallet/bdb.h
@@ -227,6 +227,12 @@
         operator Dbt *();
     };
 
+private:
+    bool ReadKey(CDataStream &key, CDataStream &value);
+    bool WriteKey(CDataStream &key, CDataStream &value, bool overwrite = true);
+    bool EraseKey(CDataStream &key);
+    bool HasKey(CDataStream &key);
+
 protected:
     Db *pdb;
     std::string strFile;
@@ -248,96 +254,60 @@
     void Close();
 
     template <typename K, typename T> bool Read(const K &key, T &value) {
-        if (!pdb) {
-            return false;
-        }
-
         // Key
         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
         ssKey.reserve(1000);
         ssKey << key;
-        SafeDbt datKey(ssKey.data(), ssKey.size());
 
-        // Read
-        SafeDbt datValue;
-        int ret = pdb->get(activeTxn, datKey, datValue, 0);
+        CDataStream ssValue(SER_DISK, CLIENT_VERSION);
         bool success = false;
-        if (datValue.get_data() != nullptr) {
+        bool ret = ReadKey(ssKey, ssValue);
+        if (ret) {
             // Unserialize value
             try {
-                CDataStream ssValue((char *)datValue.get_data(),
-                                    (char *)datValue.get_data() +
-                                        datValue.get_size(),
-                                    SER_DISK, CLIENT_VERSION);
                 ssValue >> value;
                 success = true;
             } catch (const std::exception &) {
                 // In this case success remains 'false'
             }
         }
-        return ret == 0 && success;
+        return ret && success;
     }
 
     template <typename K, typename T>
     bool Write(const K &key, const T &value, bool fOverwrite = true) {
-        if (!pdb) {
-            return true;
-        }
-        if (fReadOnly) {
-            assert(!"Write called on database in read-only mode");
-        }
-
         // Key
         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
         ssKey.reserve(1000);
         ssKey << key;
-        SafeDbt datKey(ssKey.data(), ssKey.size());
 
         // Value
         CDataStream ssValue(SER_DISK, CLIENT_VERSION);
         ssValue.reserve(10000);
         ssValue << value;
-        SafeDbt datValue(ssValue.data(), ssValue.size());
 
         // Write
-        int ret = pdb->put(activeTxn, datKey, datValue,
-                           (fOverwrite ? 0 : DB_NOOVERWRITE));
-        return (ret == 0);
+        return WriteKey(ssKey, ssValue, fOverwrite);
     }
 
     template <typename K> bool Erase(const K &key) {
-        if (!pdb) {
-            return false;
-        }
-        if (fReadOnly) {
-            assert(!"Erase called on database in read-only mode");
-        }
-
         // Key
         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
         ssKey.reserve(1000);
         ssKey << key;
-        SafeDbt datKey(ssKey.data(), ssKey.size());
 
         // Erase
-        int ret = pdb->del(activeTxn, datKey, 0);
-        return (ret == 0 || ret == DB_NOTFOUND);
+        return EraseKey(ssKey);
     }
 
     template <typename K> bool Exists(const K &key) {
-        if (!pdb) {
-            return false;
-        }
-
         // Key
         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
         ssKey.reserve(1000);
         ssKey << key;
-        SafeDbt datKey(ssKey.data(), ssKey.size());
 
         // Exists
-        int ret = pdb->exists(activeTxn, datKey, 0);
-        return (ret == 0);
+        return HasKey(ssKey);
     }
 
     Dbc *GetCursor();
diff --git a/src/wallet/bdb.cpp b/src/wallet/bdb.cpp
--- a/src/wallet/bdb.cpp
+++ b/src/wallet/bdb.cpp
@@ -854,3 +854,72 @@
     activeTxn = nullptr;
     return (ret == 0);
 }
+
+bool BerkeleyBatch::ReadKey(CDataStream &key, CDataStream &value) {
+    if (!pdb) {
+        return false;
+    }
+
+    // Key
+    SafeDbt datKey(key.data(), key.size());
+
+    // Read
+    SafeDbt datValue;
+    int ret = pdb->get(activeTxn, datKey, datValue, 0);
+    if (ret == 0 && datValue.get_data() != nullptr) {
+        value.write((char *)datValue.get_data(), datValue.get_size());
+        return true;
+    }
+    return false;
+}
+
+bool BerkeleyBatch::WriteKey(CDataStream &key, CDataStream &value,
+                             bool overwrite) {
+    if (!pdb) {
+        return true;
+    }
+
+    if (fReadOnly) {
+        assert(!"Write called on database in read-only mode");
+    }
+
+    // Key
+    SafeDbt datKey(key.data(), key.size());
+
+    // Value
+    SafeDbt datValue(value.data(), value.size());
+
+    // Write
+    int ret =
+        pdb->put(activeTxn, datKey, datValue, (overwrite ? 0 : DB_NOOVERWRITE));
+    return (ret == 0);
+}
+
+bool BerkeleyBatch::EraseKey(CDataStream &key) {
+    if (!pdb) {
+        return false;
+    }
+    if (fReadOnly) {
+        assert(!"Erase called on database in read-only mode");
+    }
+
+    // Key
+    SafeDbt datKey(key.data(), key.size());
+
+    // Erase
+    int ret = pdb->del(activeTxn, datKey, 0);
+    return (ret == 0 || ret == DB_NOTFOUND);
+}
+
+bool BerkeleyBatch::HasKey(CDataStream &key) {
+    if (!pdb) {
+        return false;
+    }
+
+    // Key
+    SafeDbt datKey(key.data(), key.size());
+
+    // Exists
+    int ret = pdb->exists(activeTxn, datKey, 0);
+    return ret == 0;
+}