diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -20,6 +20,31 @@
 
 #include <atomic>
 
+namespace DBKeys {
+const std::string ACENTRY{"acentry"};
+const std::string BESTBLOCK_NOMERKLE{"bestblock_nomerkle"};
+const std::string BESTBLOCK{"bestblock"};
+const std::string CRYPTED_KEY{"ckey"};
+const std::string CSCRIPT{"cscript"};
+const std::string DEFAULTKEY{"defaultkey"};
+const std::string DESTDATA{"destdata"};
+const std::string FLAGS{"flags"};
+const std::string HDCHAIN{"hdchain"};
+const std::string KEYMETA{"keymeta"};
+const std::string KEY{"key"};
+const std::string MASTER_KEY{"mkey"};
+const std::string MINVERSION{"minversion"};
+const std::string NAME{"name"};
+const std::string OLD_KEY{"wkey"};
+const std::string ORDERPOSNEXT{"orderposnext"};
+const std::string POOL{"pool"};
+const std::string PURPOSE{"purpose"};
+const std::string TX{"tx"};
+const std::string VERSION{"version"};
+const std::string WATCHMETA{"watchmeta"};
+const std::string WATCHS{"watchs"};
+} // namespace DBKeys
+
 //
 // WalletBatch
 //
@@ -29,9 +54,9 @@
     if (!IsValidDestination(address)) {
         return false;
     }
-    return WriteIC(std::make_pair(std::string("name"),
-                                  EncodeLegacyAddr(address, Params())),
-                   strName);
+    return WriteIC(
+        std::make_pair(DBKeys::NAME, EncodeLegacyAddr(address, Params())),
+        strName);
 }
 
 bool WalletBatch::EraseName(const CTxDestination &address) {
@@ -41,8 +66,8 @@
     if (!IsValidDestination(address)) {
         return false;
     }
-    return EraseIC(std::make_pair(std::string("name"),
-                                  EncodeLegacyAddr(address, Params())));
+    return EraseIC(
+        std::make_pair(DBKeys::NAME, EncodeLegacyAddr(address, Params())));
 }
 
 bool WalletBatch::WritePurpose(const CTxDestination &address,
@@ -50,32 +75,31 @@
     if (!IsValidDestination(address)) {
         return false;
     }
-    return WriteIC(std::make_pair(std::string("purpose"),
-                                  EncodeLegacyAddr(address, Params())),
-                   strPurpose);
+    return WriteIC(
+        std::make_pair(DBKeys::PURPOSE, EncodeLegacyAddr(address, Params())),
+        strPurpose);
 }
 
 bool WalletBatch::ErasePurpose(const CTxDestination &address) {
     if (!IsValidDestination(address)) {
         return false;
     }
-    return EraseIC(std::make_pair(std::string("purpose"),
-                                  EncodeLegacyAddr(address, Params())));
+    return EraseIC(
+        std::make_pair(DBKeys::PURPOSE, EncodeLegacyAddr(address, Params())));
 }
 
 bool WalletBatch::WriteTx(const CWalletTx &wtx) {
-    return WriteIC(std::make_pair(std::string("tx"), wtx.GetId()), wtx);
+    return WriteIC(std::make_pair(DBKeys::TX, wtx.GetId()), wtx);
 }
 
 bool WalletBatch::EraseTx(uint256 hash) {
-    return EraseIC(std::make_pair(std::string("tx"), hash));
+    return EraseIC(std::make_pair(DBKeys::TX, hash));
 }
 
 bool WalletBatch::WriteKeyMetadata(const CKeyMetadata &meta,
                                    const CPubKey &pubkey,
                                    const bool overwrite) {
-    return WriteIC(std::make_pair(std::string("keymeta"), pubkey), meta,
-                   overwrite);
+    return WriteIC(std::make_pair(DBKeys::KEYMETA, pubkey), meta, overwrite);
 }
 
 bool WalletBatch::WriteKey(const CPubKey &vchPubKey, const CPrivKey &vchPrivKey,
@@ -91,7 +115,7 @@
     vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());
 
     return WriteIC(
-        std::make_pair(std::string("key"), vchPubKey),
+        std::make_pair(DBKeys::KEY, vchPubKey),
         std::make_pair(vchPrivKey, Hash(vchKey.begin(), vchKey.end())), false);
 }
 
@@ -102,74 +126,72 @@
         return false;
     }
 
-    if (!WriteIC(std::make_pair(std::string("ckey"), vchPubKey),
+    if (!WriteIC(std::make_pair(DBKeys::CRYPTED_KEY, vchPubKey),
                  vchCryptedSecret, false)) {
         return false;
     }
-    EraseIC(std::make_pair(std::string("key"), vchPubKey));
-    EraseIC(std::make_pair(std::string("wkey"), vchPubKey));
+    EraseIC(std::make_pair(DBKeys::KEY, vchPubKey));
+    EraseIC(std::make_pair(DBKeys::OLD_KEY, vchPubKey));
     return true;
 }
 
 bool WalletBatch::WriteMasterKey(unsigned int nID,
                                  const CMasterKey &kMasterKey) {
-    return WriteIC(std::make_pair(std::string("mkey"), nID), kMasterKey, true);
+    return WriteIC(std::make_pair(DBKeys::MASTER_KEY, nID), kMasterKey, true);
 }
 
 bool WalletBatch::WriteCScript(const uint160 &hash,
                                const CScript &redeemScript) {
-    return WriteIC(std::make_pair(std::string("cscript"), hash), redeemScript,
-                   false);
+    return WriteIC(std::make_pair(DBKeys::CSCRIPT, hash), redeemScript, false);
 }
 
 bool WalletBatch::WriteWatchOnly(const CScript &dest,
                                  const CKeyMetadata &keyMeta) {
-    if (!WriteIC(std::make_pair(std::string("watchmeta"), dest), keyMeta)) {
+    if (!WriteIC(std::make_pair(DBKeys::WATCHMETA, dest), keyMeta)) {
         return false;
     }
-    return WriteIC(std::make_pair(std::string("watchs"), dest), '1');
+    return WriteIC(std::make_pair(DBKeys::WATCHS, dest), '1');
 }
 
 bool WalletBatch::EraseWatchOnly(const CScript &dest) {
-    if (!EraseIC(std::make_pair(std::string("watchmeta"), dest))) {
+    if (!EraseIC(std::make_pair(DBKeys::WATCHMETA, dest))) {
         return false;
     }
-    return EraseIC(std::make_pair(std::string("watchs"), dest));
+    return EraseIC(std::make_pair(DBKeys::WATCHS, dest));
 }
 
 bool WalletBatch::WriteBestBlock(const CBlockLocator &locator) {
     // Write empty block locator so versions that require a merkle branch
     // automatically rescan
-    WriteIC(std::string("bestblock"), CBlockLocator());
-    return WriteIC(std::string("bestblock_nomerkle"), locator);
+    WriteIC(DBKeys::BESTBLOCK, CBlockLocator());
+    return WriteIC(DBKeys::BESTBLOCK_NOMERKLE, locator);
 }
 
 bool WalletBatch::ReadBestBlock(CBlockLocator &locator) {
-    if (m_batch.Read(std::string("bestblock"), locator) &&
-        !locator.vHave.empty()) {
+    if (m_batch.Read(DBKeys::BESTBLOCK, locator) && !locator.vHave.empty()) {
         return true;
     }
-    return m_batch.Read(std::string("bestblock_nomerkle"), locator);
+    return m_batch.Read(DBKeys::BESTBLOCK_NOMERKLE, locator);
 }
 
 bool WalletBatch::WriteOrderPosNext(int64_t nOrderPosNext) {
-    return WriteIC(std::string("orderposnext"), nOrderPosNext);
+    return WriteIC(DBKeys::ORDERPOSNEXT, nOrderPosNext);
 }
 
 bool WalletBatch::ReadPool(int64_t nPool, CKeyPool &keypool) {
-    return m_batch.Read(std::make_pair(std::string("pool"), nPool), keypool);
+    return m_batch.Read(std::make_pair(DBKeys::POOL, nPool), keypool);
 }
 
 bool WalletBatch::WritePool(int64_t nPool, const CKeyPool &keypool) {
-    return WriteIC(std::make_pair(std::string("pool"), nPool), keypool);
+    return WriteIC(std::make_pair(DBKeys::POOL, nPool), keypool);
 }
 
 bool WalletBatch::ErasePool(int64_t nPool) {
-    return EraseIC(std::make_pair(std::string("pool"), nPool));
+    return EraseIC(std::make_pair(DBKeys::POOL, nPool));
 }
 
 bool WalletBatch::WriteMinVersion(int nVersion) {
-    return WriteIC(std::string("minversion"), nVersion);
+    return WriteIC(DBKeys::MINVERSION, nVersion);
 }
 
 class CWalletScanState {
@@ -195,21 +217,21 @@
         // Taking advantage of the fact that pair serialization is just the two
         // items serialized one after the other.
         ssKey >> strType;
-        if (strType == "name") {
+        if (strType == DBKeys::NAME) {
             std::string strAddress;
             ssKey >> strAddress;
             ssValue >> pwallet
                            ->mapAddressBook[DecodeDestination(
                                strAddress, pwallet->chainParams)]
                            .name;
-        } else if (strType == "purpose") {
+        } else if (strType == DBKeys::PURPOSE) {
             std::string strAddress;
             ssKey >> strAddress;
             ssValue >> pwallet
                            ->mapAddressBook[DecodeDestination(
                                strAddress, pwallet->chainParams)]
                            .purpose;
-        } else if (strType == "tx") {
+        } else if (strType == DBKeys::TX) {
             TxId txid;
             ssKey >> txid;
             CWalletTx wtx(nullptr /* pwallet */, MakeTransactionRef());
@@ -248,7 +270,7 @@
             }
 
             pwallet->LoadToWallet(wtx);
-        } else if (strType == "watchs") {
+        } else if (strType == DBKeys::WATCHS) {
             wss.nWatchKeys++;
             CScript script;
             ssKey >> script;
@@ -257,7 +279,7 @@
             if (fYes == '1') {
                 pwallet->LoadWatchOnly(script);
             }
-        } else if (strType == "key" || strType == "wkey") {
+        } else if (strType == DBKeys::KEY || strType == DBKeys::OLD_KEY) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             if (!vchPubKey.IsValid()) {
@@ -268,7 +290,7 @@
             CPrivKey pkey;
             uint256 hash;
 
-            if (strType == "key") {
+            if (strType == DBKeys::KEY) {
                 wss.nKeys++;
                 ssValue >> pkey;
             } else {
@@ -277,10 +299,10 @@
                 pkey = wkey.vchPrivKey;
             }
 
-            // Old wallets store keys as "key" [pubkey] => [privkey]
-            // ... which was slow for wallets with lots of keys, because the
-            // public key is re-derived from the private key using EC operations
-            // as a checksum. Newer wallets store keys as "key"[pubkey] =>
+            // Old wallets store keys as DBKeys::KEY [pubkey] => [privkey] ...
+            // which was slow for wallets with lots of keys, because the public
+            // key is re-derived from the private key using EC operations as a
+            // checksum. Newer wallets store keys as DBKeys::KEY [pubkey] =>
             // [privkey][hash(pubkey,privkey)], which is much faster while
             // remaining backwards-compatible.
             try {
@@ -314,7 +336,7 @@
                 strErr = "Error reading wallet database: LoadKey failed";
                 return false;
             }
-        } else if (strType == "mkey") {
+        } else if (strType == DBKeys::MASTER_KEY) {
             unsigned int nID;
             ssKey >> nID;
             CMasterKey kMasterKey;
@@ -329,7 +351,7 @@
             if (pwallet->nMasterKeyMaxID < nID) {
                 pwallet->nMasterKeyMaxID = nID;
             }
-        } else if (strType == "ckey") {
+        } else if (strType == DBKeys::CRYPTED_KEY) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             if (!vchPubKey.IsValid()) {
@@ -345,7 +367,7 @@
                 return false;
             }
             wss.fIsEncrypted = true;
-        } else if (strType == "keymeta") {
+        } else if (strType == DBKeys::KEYMETA) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             CKeyMetadata keyMeta;
@@ -353,14 +375,14 @@
             wss.nKeyMeta++;
 
             pwallet->LoadKeyMetadata(vchPubKey.GetID(), keyMeta);
-        } else if (strType == "watchmeta") {
+        } else if (strType == DBKeys::WATCHMETA) {
             CScript script;
             ssKey >> script;
             CKeyMetadata keyMeta;
             ssValue >> keyMeta;
             wss.nKeyMeta++;
             pwallet->LoadScriptMetadata(CScriptID(script), keyMeta);
-        } else if (strType == "defaultkey") {
+        } else if (strType == DBKeys::DEFAULTKEY) {
             // We don't want or need the default key, but if there is one set,
             // we want to make sure that it is valid so that we can detect
             // corruption
@@ -370,14 +392,14 @@
                 strErr = "Error reading wallet database: Default Key corrupt";
                 return false;
             }
-        } else if (strType == "pool") {
+        } else if (strType == DBKeys::POOL) {
             int64_t nIndex;
             ssKey >> nIndex;
             CKeyPool keypool;
             ssValue >> keypool;
 
             pwallet->LoadKeyPool(nIndex, keypool);
-        } else if (strType == "cscript") {
+        } else if (strType == DBKeys::CSCRIPT) {
             uint160 hash;
             ssKey >> hash;
             CScript script;
@@ -386,9 +408,9 @@
                 strErr = "Error reading wallet database: LoadCScript failed";
                 return false;
             }
-        } else if (strType == "orderposnext") {
+        } else if (strType == DBKeys::ORDERPOSNEXT) {
             ssValue >> pwallet->nOrderPosNext;
-        } else if (strType == "destdata") {
+        } else if (strType == DBKeys::DESTDATA) {
             std::string strAddress, strKey, strValue;
             ssKey >> strAddress;
             ssKey >> strKey;
@@ -396,11 +418,11 @@
             pwallet->LoadDestData(
                 DecodeDestination(strAddress, pwallet->chainParams), strKey,
                 strValue);
-        } else if (strType == "hdchain") {
+        } else if (strType == DBKeys::HDCHAIN) {
             CHDChain chain;
             ssValue >> chain;
             pwallet->SetHDChain(chain, true);
-        } else if (strType == "flags") {
+        } else if (strType == DBKeys::FLAGS) {
             uint64_t flags;
             ssValue >> flags;
             if (!pwallet->SetWalletFlags(flags, true)) {
@@ -408,9 +430,10 @@
                          "wallet flags found";
                 return false;
             }
-        } else if (strType != "bestblock" && strType != "bestblock_nomerkle" &&
-                   strType != "minversion" && strType != "acentry" &&
-                   strType != "version") {
+        } else if (strType != DBKeys::BESTBLOCK &&
+                   strType != DBKeys::BESTBLOCK_NOMERKLE &&
+                   strType != DBKeys::MINVERSION &&
+                   strType != DBKeys::ACENTRY && strType != DBKeys::VERSION) {
             wss.m_unknown_records++;
         }
     } catch (...) {
@@ -420,8 +443,8 @@
 }
 
 bool WalletBatch::IsKeyType(const std::string &strType) {
-    return (strType == "key" || strType == "wkey" || strType == "mkey" ||
-            strType == "ckey");
+    return (strType == DBKeys::KEY || strType == DBKeys::OLD_KEY ||
+            strType == DBKeys::MASTER_KEY || strType == DBKeys::CRYPTED_KEY);
 }
 
 DBErrors WalletBatch::LoadWallet(CWallet *pwallet) {
@@ -432,7 +455,7 @@
     LOCK(pwallet->cs_wallet);
     try {
         int nMinVersion = 0;
-        if (m_batch.Read((std::string) "minversion", nMinVersion)) {
+        if (m_batch.Read(DBKeys::MINVERSION, nMinVersion)) {
             if (nMinVersion > FEATURE_LATEST) {
                 return DBErrors::TOO_NEW;
             }
@@ -466,9 +489,9 @@
             if (!ReadKeyValue(pwallet, ssKey, ssValue, wss, strType, strErr)) {
                 // losing keys is considered a catastrophic error, anything else
                 // we assume the user can live with:
-                if (IsKeyType(strType) || strType == "defaultkey") {
+                if (IsKeyType(strType) || strType == DBKeys::DEFAULTKEY) {
                     result = DBErrors::CORRUPT;
-                } else if (strType == "flags") {
+                } else if (strType == DBKeys::FLAGS) {
                     // Reading the wallet flags can only fail if unknown flags
                     // are present.
                     result = DBErrors::TOO_NEW;
@@ -477,7 +500,7 @@
                     // make things worse. But do warn the user there is
                     // something wrong.
                     fNoncriticalErrors = true;
-                    if (strType == "tx") {
+                    if (strType == DBKeys::TX) {
                         // Rescan if there is a bad transaction record:
                         gArgs.SoftSetBoolArg("-rescan", true);
                     }
@@ -507,7 +530,7 @@
     // Last client version to open this wallet, was previously the file version
     // number
     int last_client = CLIENT_VERSION;
-    m_batch.Read(std::string("version"), last_client);
+    m_batch.Read(DBKeys::VERSION, last_client);
 
     int wallet_version = pwallet->GetVersion();
     pwallet->WalletLogPrintf("Wallet File Version = %d\n",
@@ -534,7 +557,7 @@
 
     if (last_client < CLIENT_VERSION) {
         // Update
-        m_batch.Write(std::string("version"), CLIENT_VERSION);
+        m_batch.Write(DBKeys::VERSION, CLIENT_VERSION);
     }
 
     if (wss.fAnyUnordered) {
@@ -559,7 +582,7 @@
 
     try {
         int nMinVersion = 0;
-        if (m_batch.Read((std::string) "minversion", nMinVersion)) {
+        if (m_batch.Read(DBKeys::MINVERSION, nMinVersion)) {
             if (nMinVersion > FEATURE_LATEST) {
                 return DBErrors::TOO_NEW;
             }
@@ -588,7 +611,7 @@
 
             std::string strType;
             ssKey >> strType;
-            if (strType == "tx") {
+            if (strType == DBKeys::TX) {
                 TxId txid;
                 ssKey >> txid;
 
@@ -731,7 +754,7 @@
         fReadOK = ReadKeyValue(dummyWallet, ssKey, ssValue, dummyWss, strType,
                                strErr);
     }
-    if (!IsKeyType(strType) && strType != "hdchain") {
+    if (!IsKeyType(strType) && strType != DBKeys::HDCHAIN) {
         return false;
     }
     if (!fReadOK) {
@@ -763,7 +786,7 @@
     }
     return WriteIC(
         std::make_pair(
-            std::string("destdata"),
+            DBKeys::DESTDATA,
             std::make_pair(EncodeLegacyAddr(address, Params()), key)),
         value);
 }
@@ -774,16 +797,16 @@
         return false;
     }
     return EraseIC(std::make_pair(
-        std::string("destdata"),
+        DBKeys::DESTDATA,
         std::make_pair(EncodeLegacyAddr(address, Params()), key)));
 }
 
 bool WalletBatch::WriteHDChain(const CHDChain &chain) {
-    return WriteIC(std::string("hdchain"), chain);
+    return WriteIC(DBKeys::HDCHAIN, chain);
 }
 
 bool WalletBatch::WriteWalletFlags(const uint64_t flags) {
-    return WriteIC(std::string("flags"), flags);
+    return WriteIC(DBKeys::FLAGS, flags);
 }
 
 bool WalletBatch::TxnBegin() {