diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
index 4696a57de..101c566e9 100644
--- a/src/wallet/walletdb.h
+++ b/src/wallet/walletdb.h
@@ -1,323 +1,317 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2020 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_WALLET_WALLETDB_H
 #define BITCOIN_WALLET_WALLETDB_H
 
 #include <amount.h>
 #include <key.h>
 #include <script/sign.h>
 #include <script/standard.h> // for CTxDestination
 #include <wallet/bdb.h>
 #include <wallet/walletutil.h>
 
 #include <cstdint>
 #include <string>
 #include <vector>
 
 /**
  * Overview of wallet database classes:
  *
  * - WalletBatch is an abstract modifier object for the wallet database, and
  * encapsulates a database batch update as well as methods to act on the
  * database. It should be agnostic to the database implementation.
  *
  * The following classes are implementation specific:
  * - BerkeleyEnvironment is an environment in which the database exists.
  * - BerkeleyDatabase represents a wallet database.
  * - BerkeleyBatch is a low-level database batch update.
  */
 
 static const bool DEFAULT_FLUSHWALLET = true;
 
 struct CBlockLocator;
 class CKeyPool;
 class CMasterKey;
 class CScript;
 class CWallet;
 class CWalletTx;
 class uint160;
 class uint256;
 
 /** Backend-agnostic database type. */
 using WalletDatabase = BerkeleyDatabase;
 
 /** Error statuses for the wallet database */
 enum class DBErrors {
     LOAD_OK,
     CORRUPT,
     NONCRITICAL_ERROR,
     TOO_NEW,
     LOAD_FAIL,
     NEED_REWRITE
 };
 
 namespace DBKeys {
 extern const std::string ACENTRY;
 extern const std::string ACTIVEEXTERNALSPK;
 extern const std::string ACTIVEINTERNALSPK;
 extern const std::string BESTBLOCK;
 extern const std::string BESTBLOCK_NOMERKLE;
 extern const std::string CRYPTED_KEY;
 extern const std::string CSCRIPT;
 extern const std::string DEFAULTKEY;
 extern const std::string DESTDATA;
 extern const std::string FLAGS;
 extern const std::string HDCHAIN;
 extern const std::string KEY;
 extern const std::string KEYMETA;
 extern const std::string MASTER_KEY;
 extern const std::string MINVERSION;
 extern const std::string NAME;
 extern const std::string OLD_KEY;
 extern const std::string ORDERPOSNEXT;
 extern const std::string POOL;
 extern const std::string PURPOSE;
 extern const std::string SETTINGS;
 extern const std::string TX;
 extern const std::string VERSION;
 extern const std::string WALLETDESCRIPTOR;
 extern const std::string WALLETDESCRIPTORCACHE;
 extern const std::string WALLETDESCRIPTORCKEY;
 extern const std::string WALLETDESCRIPTORKEY;
 extern const std::string WATCHMETA;
 extern const std::string WATCHS;
 } // namespace DBKeys
 
 /* simple HD chain data model */
 class CHDChain {
 public:
     uint32_t nExternalChainCounter;
     uint32_t nInternalChainCounter;
     //! seed hash160
     CKeyID seed_id;
 
     static const int VERSION_HD_BASE = 1;
     static const int VERSION_HD_CHAIN_SPLIT = 2;
     static const int CURRENT_VERSION = VERSION_HD_CHAIN_SPLIT;
     int nVersion;
 
     CHDChain() { SetNull(); }
 
     SERIALIZE_METHODS(CHDChain, obj) {
         READWRITE(obj.nVersion, obj.nExternalChainCounter, obj.seed_id);
         if (obj.nVersion >= VERSION_HD_CHAIN_SPLIT) {
             READWRITE(obj.nInternalChainCounter);
         }
     }
 
     void SetNull() {
         nVersion = CHDChain::CURRENT_VERSION;
         nExternalChainCounter = 0;
         nInternalChainCounter = 0;
         seed_id.SetNull();
     }
 
     bool operator==(const CHDChain &chain) const {
         return seed_id == chain.seed_id;
     }
 };
 
 class CKeyMetadata {
 public:
     static const int VERSION_BASIC = 1;
     static const int VERSION_WITH_HDDATA = 10;
     static const int VERSION_WITH_KEY_ORIGIN = 12;
     static const int CURRENT_VERSION = VERSION_WITH_KEY_ORIGIN;
     int nVersion;
     // 0 means unknown.
     int64_t nCreateTime;
     // optional HD/bip32 keypath. Still used to determine whether a key is a
     // seed. Also kept for backwards compatibility
     std::string hdKeypath;
     // Id of the HD seed used to derive this key.
     CKeyID hd_seed_id;
     // Key origin info with path and fingerprint
     KeyOriginInfo key_origin;
     //! Whether the key_origin is useful
     bool has_key_origin = false;
 
     CKeyMetadata() { SetNull(); }
     explicit CKeyMetadata(int64_t nCreateTime_) {
         SetNull();
         nCreateTime = nCreateTime_;
     }
 
     SERIALIZE_METHODS(CKeyMetadata, obj) {
         READWRITE(obj.nVersion, obj.nCreateTime);
         if (obj.nVersion >= VERSION_WITH_HDDATA) {
             READWRITE(obj.hdKeypath, obj.hd_seed_id);
         }
         if (obj.nVersion >= VERSION_WITH_KEY_ORIGIN) {
             READWRITE(obj.key_origin);
             READWRITE(obj.has_key_origin);
         }
     }
 
     void SetNull() {
         nVersion = CKeyMetadata::CURRENT_VERSION;
         nCreateTime = 0;
         hdKeypath.clear();
         hd_seed_id.SetNull();
         key_origin.clear();
         has_key_origin = false;
     }
 };
 
 /**
  * Access to the wallet database.
  * Opens the database and provides read and write access to it. Each read and
  * write is its own transaction. Multiple operation transactions can be started
  * using TxnBegin() and committed using TxnCommit() Otherwise the transaction
  * will be committed when the object goes out of scope. Optionally (on by
  * default) it will flush to disk on close. Every 1000 writes will automatically
  * trigger a flush to disk.
  */
 class WalletBatch {
 private:
     template <typename K, typename T>
     bool WriteIC(const K &key, const T &value, bool fOverwrite = true) {
         if (!m_batch.Write(key, value, fOverwrite)) {
             return false;
         }
         m_database.IncrementUpdateCounter();
         if (m_database.nUpdateCounter % 1000 == 0) {
             m_batch.Flush();
         }
         return true;
     }
 
     template <typename K> bool EraseIC(const K &key) {
         if (!m_batch.Erase(key)) {
             return false;
         }
         m_database.IncrementUpdateCounter();
         if (m_database.nUpdateCounter % 1000 == 0) {
             m_batch.Flush();
         }
         return true;
     }
 
 public:
     explicit WalletBatch(WalletDatabase &database, const char *pszMode = "r+",
                          bool _fFlushOnClose = true)
         : m_batch(database, pszMode, _fFlushOnClose), m_database(database) {}
     WalletBatch(const WalletBatch &) = delete;
     WalletBatch &operator=(const WalletBatch &) = delete;
 
     bool WriteName(const CTxDestination &address, const std::string &strName);
     bool EraseName(const CTxDestination &address);
 
     bool WritePurpose(const CTxDestination &address,
                       const std::string &purpose);
     bool ErasePurpose(const CTxDestination &address);
 
     bool WriteTx(const CWalletTx &wtx);
     bool EraseTx(uint256 hash);
 
     bool WriteKeyMetadata(const CKeyMetadata &meta, const CPubKey &pubkey,
                           const bool overwrite);
     bool WriteKey(const CPubKey &vchPubKey, const CPrivKey &vchPrivKey,
                   const CKeyMetadata &keyMeta);
     bool WriteCryptedKey(const CPubKey &vchPubKey,
                          const std::vector<uint8_t> &vchCryptedSecret,
                          const CKeyMetadata &keyMeta);
     bool WriteMasterKey(unsigned int nID, const CMasterKey &kMasterKey);
 
     bool WriteCScript(const uint160 &hash, const CScript &redeemScript);
 
     bool WriteWatchOnly(const CScript &script, const CKeyMetadata &keymeta);
     bool EraseWatchOnly(const CScript &script);
 
     bool WriteBestBlock(const CBlockLocator &locator);
     bool ReadBestBlock(CBlockLocator &locator);
 
     bool WriteOrderPosNext(int64_t nOrderPosNext);
 
     bool ReadPool(int64_t nPool, CKeyPool &keypool);
     bool WritePool(int64_t nPool, const CKeyPool &keypool);
     bool ErasePool(int64_t nPool);
 
     bool WriteMinVersion(int nVersion);
 
     bool WriteDescriptorKey(const uint256 &desc_id, const CPubKey &pubkey,
                             const CPrivKey &privkey);
     bool WriteCryptedDescriptorKey(const uint256 &desc_id,
                                    const CPubKey &pubkey,
                                    const std::vector<uint8_t> &secret);
     bool WriteDescriptor(const uint256 &desc_id,
                          const WalletDescriptor &descriptor);
     bool WriteDescriptorDerivedCache(const CExtPubKey &xpub,
                                      const uint256 &desc_id,
                                      uint32_t key_exp_index,
                                      uint32_t der_index);
     bool WriteDescriptorParentCache(const CExtPubKey &xpub,
                                     const uint256 &desc_id,
                                     uint32_t key_exp_index);
 
     /// Write destination data key,value tuple to database.
     bool WriteDestData(const CTxDestination &address, const std::string &key,
                        const std::string &value);
     /// Erase destination data tuple from wallet database.
     bool EraseDestData(const CTxDestination &address, const std::string &key);
 
     bool WriteActiveScriptPubKeyMan(uint8_t type, const uint256 &id,
                                     bool internal);
 
     DBErrors LoadWallet(CWallet *pwallet);
     DBErrors FindWalletTx(std::vector<TxId> &txIds, std::list<CWalletTx> &vWtx);
     DBErrors ZapWalletTx(std::list<CWalletTx> &vWtx);
     DBErrors ZapSelectTx(std::vector<TxId> &txIdsIn,
                          std::vector<TxId> &txIdsOut);
     /* Function to determine if a certain KV/key-type is a key (cryptographical
      * key) type */
     static bool IsKeyType(const std::string &strType);
-    /* verifies the database environment */
-    static bool VerifyEnvironment(const fs::path &wallet_path,
-                                  bilingual_str &errorStr);
-    /* verifies the database file */
-    static bool VerifyDatabaseFile(const fs::path &wallet_path,
-                                   bilingual_str &errorStr);
 
     //! write the hdchain model (external chain child index counter)
     bool WriteHDChain(const CHDChain &chain);
 
     bool WriteWalletFlags(const uint64_t flags);
     //! Begin a new transaction
     bool TxnBegin();
     //! Commit current transaction
     bool TxnCommit();
     //! Abort current transaction
     bool TxnAbort();
 
 private:
     BerkeleyBatch m_batch;
     WalletDatabase &m_database;
 };
 
 //! Compacts BDB state so that wallet.dat is self-contained (if there are
 //! changes)
 void MaybeCompactWalletDB();
 
 //! Unserialize a given Key-Value pair and load it into the wallet
 bool ReadKeyValue(CWallet *pwallet, CDataStream &ssKey, CDataStream &ssValue,
                   std::string &strType, std::string &strErr);
 
 /** Return whether a wallet database is currently loaded. */
 bool IsWalletLoaded(const fs::path &wallet_path);
 
 /** Return object for accessing database at specified path. */
 std::unique_ptr<BerkeleyDatabase> CreateWalletDatabase(const fs::path &path);
 
 /**
  * Return object for accessing dummy database with no read/write capabilities.
  */
 std::unique_ptr<BerkeleyDatabase> CreateDummyWalletDatabase();
 
 /** Return object for accessing temporary in-memory database. */
 std::unique_ptr<BerkeleyDatabase> CreateMockWalletDatabase();
 
 #endif // BITCOIN_WALLET_WALLETDB_H