diff --git a/src/addrdb.cpp b/src/addrdb.cpp
index 854d46f6e..3cda947a5 100644
--- a/src/addrdb.cpp
+++ b/src/addrdb.cpp
@@ -1,232 +1,233 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <addrdb.h>
 
 #include <addrman.h>
 #include <chainparams.h>
 #include <clientversion.h>
+#include <fs.h>
 #include <hash.h>
 #include <logging/timer.h>
 #include <random.h>
 #include <streams.h>
 #include <tinyformat.h>
 #include <util/system.h>
 #include <util/translation.h>
 
 #include <cstdint>
 
 namespace {
 
 class DbNotFoundError : public std::exception {
     using std::exception::exception;
 };
 
 template <typename Stream, typename Data>
 bool SerializeDB(const CChainParams &chainParams, Stream &stream,
                  const Data &data) {
     // Write and commit header, data
     try {
         CHashWriter hasher(SER_DISK, CLIENT_VERSION);
         stream << chainParams.DiskMagic() << data;
         hasher << chainParams.DiskMagic() << data;
         stream << hasher.GetHash();
     } catch (const std::exception &e) {
         return error("%s: Serialize or I/O error - %s", __func__, e.what());
     }
 
     return true;
 }
 
 template <typename Data>
 bool SerializeFileDB(const CChainParams &chainParams, const std::string &prefix,
                      const fs::path &path, const Data &data) {
     // Generate random temporary filename
     uint16_t randv = 0;
     GetRandBytes((uint8_t *)&randv, sizeof(randv));
     std::string tmpfn = strprintf("%s.%04x", prefix, randv);
 
     // open temp output file, and associate with CAutoFile
     fs::path pathTmp = gArgs.GetDataDirNet() / tmpfn;
     FILE *file = fsbridge::fopen(pathTmp, "wb");
     CAutoFile fileout(file, SER_DISK, CLIENT_VERSION);
     if (fileout.IsNull()) {
         fileout.fclose();
         remove(pathTmp);
         return error("%s: Failed to open file %s", __func__,
                      fs::PathToString(pathTmp));
     }
 
     // Serialize
     if (!SerializeDB(chainParams, fileout, data)) {
         fileout.fclose();
         remove(pathTmp);
         return false;
     }
     if (!FileCommit(fileout.Get())) {
         fileout.fclose();
         remove(pathTmp);
         return error("%s: Failed to flush file %s", __func__,
                      fs::PathToString(pathTmp));
     }
     fileout.fclose();
 
     // replace existing file, if any, with new file
     if (!RenameOver(pathTmp, path)) {
         remove(pathTmp);
         return error("%s: Rename-into-place failed", __func__);
     }
 
     return true;
 }
 
 template <typename Stream, typename Data>
 void DeserializeDB(const CChainParams &chainParams, Stream &stream, Data &data,
                    bool fCheckSum = true) {
     CHashVerifier<Stream> verifier(&stream);
     // de-serialize file header (network specific magic number) and ..
     uint8_t pchMsgTmp[4];
     verifier >> pchMsgTmp;
     // ... verify the network matches ours
     if (memcmp(pchMsgTmp, std::begin(chainParams.DiskMagic()),
                sizeof(pchMsgTmp))) {
         throw std::runtime_error{"Invalid network magic number"};
     }
 
     // de-serialize data
     verifier >> data;
 
     // verify checksum
     if (fCheckSum) {
         uint256 hashTmp;
         stream >> hashTmp;
         if (hashTmp != verifier.GetHash()) {
             throw std::runtime_error{"Checksum mismatch, data corrupted"};
         }
     }
 }
 
 template <typename Data>
 void DeserializeFileDB(const CChainParams &chainParams, const fs::path &path,
                        Data &data) {
     // open input file, and associate with CAutoFile
     FILE *file = fsbridge::fopen(path, "rb");
     CAutoFile filein(file, SER_DISK, CLIENT_VERSION);
     if (filein.IsNull()) {
         throw DbNotFoundError{};
     }
 
     DeserializeDB(chainParams, filein, data);
 }
 
 } // namespace
 
 CBanDB::CBanDB(fs::path ban_list_path, const CChainParams &_chainParams)
     : m_ban_list_path(std::move(ban_list_path)), chainParams(_chainParams) {}
 
 bool CBanDB::Write(const banmap_t &banSet) {
     return SerializeFileDB(chainParams, "banlist", m_ban_list_path, banSet);
 }
 
 bool CBanDB::Read(banmap_t &banSet) {
     // TODO: this needs to be reworked after banlist.dat is deprecated (in
     // favor of banlist.json). See:
     //  - https://github.com/bitcoin/bitcoin/pull/20966
     //  - https://github.com/bitcoin/bitcoin/pull/22570
     try {
         DeserializeFileDB(chainParams, m_ban_list_path, banSet);
     } catch (const std::exception &) {
         LogPrintf("Missing or invalid file %s\n",
                   fs::quoted(fs::PathToString(m_ban_list_path)));
         return false;
     }
 
     return true;
 }
 
 bool DumpPeerAddresses(const CChainParams &chainParams, const ArgsManager &args,
                        const AddrMan &addr) {
     const auto pathAddr = args.GetDataDirNet() / "peers.dat";
     return SerializeFileDB(chainParams, "peers", pathAddr, addr);
 }
 
 void ReadFromStream(const CChainParams &chainParams, AddrMan &addr,
                     CDataStream &ssPeers) {
     DeserializeDB(chainParams, ssPeers, addr, false);
 }
 
 std::optional<bilingual_str> LoadAddrman(const CChainParams &chainparams,
                                          const std::vector<bool> &asmap,
                                          const ArgsManager &args,
                                          std::unique_ptr<AddrMan> &addrman) {
     auto check_addrman = std::clamp<int32_t>(
         args.GetIntArg("-checkaddrman", DEFAULT_ADDRMAN_CONSISTENCY_CHECKS), 0,
         1000000);
     addrman = std::make_unique<AddrMan>(
         asmap, /* consistency_check_ratio= */ check_addrman);
 
     int64_t nStart = GetTimeMillis();
     const auto path_addr{args.GetDataDirNet() / "peers.dat"};
     try {
         DeserializeFileDB(chainparams, path_addr, *addrman);
         LogPrintf("Loaded %i addresses from peers.dat  %dms\n", addrman->size(),
                   GetTimeMillis() - nStart);
     } catch (const DbNotFoundError &) {
         // Addrman can be in an inconsistent state after failure, reset it
         addrman = std::make_unique<AddrMan>(
             asmap, /* consistency_check_ratio= */ check_addrman);
         LogPrintf("Creating peers.dat because the file was not found (%s)\n",
                   fs::quoted(fs::PathToString(path_addr)));
         DumpPeerAddresses(chainparams, args, *addrman);
     } catch (const InvalidAddrManVersionError &) {
         if (!RenameOver(path_addr, fs::path(path_addr) + ".bak")) {
             addrman = nullptr;
             return strprintf(_("Failed to rename invalid peers.dat file. "
                                "Please move or delete it and try again."));
         }
         // Addrman can be in an inconsistent state after failure, reset it
         addrman = std::make_unique<AddrMan>(
             asmap, /* consistency_check_ratio= */ check_addrman);
         LogPrintf("Creating new peers.dat because the file version was not "
                   "compatible (%s). Original backed up to peers.dat.bak\n",
                   fs::quoted(fs::PathToString(path_addr)));
         DumpPeerAddresses(chainparams, args, *addrman);
     } catch (const std::exception &e) {
         addrman = nullptr;
         return strprintf(
             _("Invalid or corrupt peers.dat (%s). If you believe this is a "
               "bug, please report it to %s. As a workaround, you can move the "
               "file (%s) out of the way (rename, move, or delete) to have a "
               "new one created on the next start."),
             e.what(), PACKAGE_BUGREPORT,
             fs::quoted(fs::PathToString(path_addr)));
     }
 
     return std::nullopt;
 }
 
 void DumpAnchors(const CChainParams &chainParams,
                  const fs::path &anchors_db_path,
                  const std::vector<CAddress> &anchors) {
     LOG_TIME_SECONDS(strprintf(
         "Flush %d outbound block-relay-only peer addresses to anchors.dat",
         anchors.size()));
     SerializeFileDB(chainParams, "anchors", anchors_db_path, anchors);
 }
 
 std::vector<CAddress> ReadAnchors(const CChainParams &chainParams,
                                   const fs::path &anchors_db_path) {
     std::vector<CAddress> anchors;
     try {
         DeserializeFileDB(chainParams, anchors_db_path, anchors);
         LogPrintf("Loaded %i addresses from %s\n", anchors.size(),
                   fs::quoted(fs::PathToString(anchors_db_path.filename())));
     } catch (const std::exception &) {
         anchors.clear();
     }
 
     fs::remove(anchors_db_path);
     return anchors;
 }
diff --git a/src/bench/bench.cpp b/src/bench/bench.cpp
index 50c1c6e47..ed1dfe15a 100644
--- a/src/bench/bench.cpp
+++ b/src/bench/bench.cpp
@@ -1,97 +1,97 @@
 // Copyright (c) 2015-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
 
 #include <fs.h>
 
 #include <test/util/setup_common.h>
 
 #include <chrono>
 #include <fstream>
 #include <iostream>
 #include <map>
 #include <regex>
 #include <string>
 #include <vector>
 
 using namespace std::chrono_literals;
 
 namespace {
 
 void GenerateTemplateResults(
     const std::vector<ankerl::nanobench::Result> &benchmarkResults,
     const std::string &filename, const char *tpl) {
     if (benchmarkResults.empty() || filename.empty()) {
         // nothing to write, bail out
         return;
     }
-    fsbridge::ofstream fout{fs::PathFromString(filename)};
+    std::ofstream fout{fs::PathFromString(filename)};
     if (fout.is_open()) {
         ankerl::nanobench::render(tpl, benchmarkResults, fout);
     } else {
         std::cout << "Could write to file '" << filename << "'" << std::endl;
     }
 
     std::cout << "Created '" << filename << "'" << std::endl;
 }
 
 } // namespace
 
 benchmark::BenchRunner::BenchmarkMap &benchmark::BenchRunner::benchmarks() {
     static std::map<std::string, BenchFunction> benchmarks_map;
     return benchmarks_map;
 }
 
 benchmark::BenchRunner::BenchRunner(std::string name,
                                     benchmark::BenchFunction func) {
     benchmarks().insert(std::make_pair(name, func));
 }
 
 void benchmark::BenchRunner::RunAll(const Args &args) {
     std::regex reFilter(args.regex_filter);
     std::smatch baseMatch;
 
     std::vector<ankerl::nanobench::Result> benchmarkResults;
 
     for (const auto &p : benchmarks()) {
         if (!std::regex_match(p.first, baseMatch, reFilter)) {
             continue;
         }
 
         if (args.is_list_only) {
             std::cout << p.first << std::endl;
             continue;
         }
 
         Bench bench;
         bench.name(p.first);
         if (args.min_time > 0ms) {
             // convert to nanos before dividing to reduce rounding errors
             std::chrono::nanoseconds min_time_ns = args.min_time;
             bench.minEpochTime(min_time_ns / bench.epochs());
         }
 
         if (args.asymptote.empty()) {
             p.second(bench);
         } else {
             for (auto n : args.asymptote) {
                 bench.complexityN(n);
                 p.second(bench);
             }
             std::cout << bench.complexityBigO() << std::endl;
         }
         benchmarkResults.push_back(bench.results().back());
     }
 
     GenerateTemplateResults(
         benchmarkResults, args.output_csv,
         "# Benchmark, evals, iterations, total, min, max, median\n"
         "{{#result}}{{name}}, {{epochs}}, {{average(iterations)}}, "
         "{{sumProduct(iterations, elapsed)}}, {{minimum(elapsed)}}, "
         "{{maximum(elapsed)}}, {{median(elapsed)}}\n"
         "{{/result}}");
     GenerateTemplateResults(benchmarkResults, args.output_json,
                             ankerl::nanobench::templates::json());
 }
diff --git a/src/fs.cpp b/src/fs.cpp
index e523d5d42..33168fc24 100644
--- a/src/fs.cpp
+++ b/src/fs.cpp
@@ -1,281 +1,171 @@
 // Copyright (c) 2017 The Bitcoin Core developers
 // Copyright (c) 2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <fs.h>
 
 #ifndef WIN32
 #include <cstring>
 #include <fcntl.h>
 #include <sys/file.h>
 #include <sys/utsname.h>
 #include <unistd.h>
 #else
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 #include <codecvt>
 #include <windows.h>
 #endif
 
 #include <cassert>
 #include <limits>
 #include <string>
 
 namespace fsbridge {
 
 FILE *fopen(const fs::path &p, const char *mode) {
 #ifndef WIN32
     return ::fopen(p.c_str(), mode);
 #else
     std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> utf8_cvt;
     return ::_wfopen(p.wstring().c_str(), utf8_cvt.from_bytes(mode).c_str());
 #endif
 }
 
 fs::path AbsPathJoin(const fs::path &base, const fs::path &path) {
     assert(base.is_absolute());
-    return fs::absolute(path, base);
+    return path.empty() ? base : fs::path(base / path);
 }
 
 #ifndef WIN32
 
 static std::string GetErrorReason() {
     return std::strerror(errno);
 }
 
 FileLock::FileLock(const fs::path &file) {
     fd = open(file.c_str(), O_RDWR);
     if (fd == -1) {
         reason = GetErrorReason();
     }
 }
 
 FileLock::~FileLock() {
     if (fd != -1) {
         close(fd);
     }
 }
 
 static bool IsWSL() {
     struct utsname uname_data;
     return uname(&uname_data) == 0 &&
            std::string(uname_data.version).find("Microsoft") !=
                std::string::npos;
 }
 
 bool FileLock::TryLock() {
     if (fd == -1) {
         return false;
     }
 
     // Exclusive file locking is broken on WSL using fcntl (issue #18622)
     // This workaround can be removed once the bug on WSL is fixed
     static const bool is_wsl = IsWSL();
     if (is_wsl) {
         if (flock(fd, LOCK_EX | LOCK_NB) == -1) {
             reason = GetErrorReason();
             return false;
         }
     } else {
         struct flock lock;
         lock.l_type = F_WRLCK;
         lock.l_whence = SEEK_SET;
         lock.l_start = 0;
         lock.l_len = 0;
         if (fcntl(fd, F_SETLK, &lock) == -1) {
             reason = GetErrorReason();
             return false;
         }
     }
 
     return true;
 }
 #else
 
 static std::string GetErrorReason() {
     wchar_t *err;
     FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
                        FORMAT_MESSAGE_IGNORE_INSERTS,
                    nullptr, GetLastError(),
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                    reinterpret_cast<WCHAR *>(&err), 0, nullptr);
     std::wstring err_str(err);
     LocalFree(err);
     return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>().to_bytes(
         err_str);
 }
 
 FileLock::FileLock(const fs::path &file) {
     hFile = CreateFileW(file.wstring().c_str(), GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                         nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
     if (hFile == INVALID_HANDLE_VALUE) {
         reason = GetErrorReason();
     }
 }
 
 FileLock::~FileLock() {
     if (hFile != INVALID_HANDLE_VALUE) {
         CloseHandle(hFile);
     }
 }
 
 bool FileLock::TryLock() {
     if (hFile == INVALID_HANDLE_VALUE) {
         return false;
     }
     _OVERLAPPED overlapped = {0};
     if (!LockFileEx(hFile, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY,
                     0, std::numeric_limits<DWORD>::max(),
                     std::numeric_limits<DWORD>::max(), &overlapped)) {
         reason = GetErrorReason();
         return false;
     }
     return true;
 }
 #endif
 
 std::string get_filesystem_error_message(const fs::filesystem_error &e) {
 #ifndef WIN32
     return e.what();
 #else
     // Convert from Multi Byte to utf-16
     std::string mb_string(e.what());
     int size = MultiByteToWideChar(CP_ACP, 0, mb_string.data(),
                                    mb_string.size(), nullptr, 0);
 
     std::wstring utf16_string(size, L'\0');
     MultiByteToWideChar(CP_ACP, 0, mb_string.data(), mb_string.size(),
                         &*utf16_string.begin(), size);
     // Convert from utf-16 to utf-8
     return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t>()
         .to_bytes(utf16_string);
 #endif
 }
 
-#ifdef WIN32
-#ifdef __GLIBCXX__
-
-// reference:
-// https://github.com/gcc-mirror/gcc/blob/gcc-7_3_0-release/libstdc%2B%2B-v3/include/std/fstream#L270
-
-static std::string openmodeToStr(std::ios_base::openmode mode) {
-    switch (mode & ~std::ios_base::ate) {
-        case std::ios_base::out:
-        case std::ios_base::out | std::ios_base::trunc:
-            return "w";
-        case std::ios_base::out | std::ios_base::app:
-        case std::ios_base::app:
-            return "a";
-        case std::ios_base::in:
-            return "r";
-        case std::ios_base::in | std::ios_base::out:
-            return "r+";
-        case std::ios_base::in | std::ios_base::out | std::ios_base::trunc:
-            return "w+";
-        case std::ios_base::in | std::ios_base::out | std::ios_base::app:
-        case std::ios_base::in | std::ios_base::app:
-            return "a+";
-        case std::ios_base::out | std::ios_base::binary:
-        case std::ios_base::out | std::ios_base::trunc | std::ios_base::binary:
-            return "wb";
-        case std::ios_base::out | std::ios_base::app | std::ios_base::binary:
-        case std::ios_base::app | std::ios_base::binary:
-            return "ab";
-        case std::ios_base::in | std::ios_base::binary:
-            return "rb";
-        case std::ios_base::in | std::ios_base::out | std::ios_base::binary:
-            return "r+b";
-        case std::ios_base::in | std::ios_base::out | std::ios_base::trunc |
-            std::ios_base::binary:
-            return "w+b";
-        case std::ios_base::in | std::ios_base::out | std::ios_base::app |
-            std::ios_base::binary:
-        case std::ios_base::in | std::ios_base::app | std::ios_base::binary:
-            return "a+b";
-        default:
-            return std::string();
-    }
-}
-
-void ifstream::open(const fs::path &p, std::ios_base::openmode mode) {
-    close();
-    mode |= std::ios_base::in;
-    m_file = fsbridge::fopen(p, openmodeToStr(mode).c_str());
-    if (m_file == nullptr) {
-        return;
-    }
-    m_filebuf = __gnu_cxx::stdio_filebuf<char>(m_file, mode);
-    rdbuf(&m_filebuf);
-    if (mode & std::ios_base::ate) {
-        seekg(0, std::ios_base::end);
-    }
-}
-
-void ifstream::close() {
-    if (m_file != nullptr) {
-        m_filebuf.close();
-        fclose(m_file);
-    }
-    m_file = nullptr;
-}
-
-void ofstream::open(const fs::path &p, std::ios_base::openmode mode) {
-    close();
-    mode |= std::ios_base::out;
-    m_file = fsbridge::fopen(p, openmodeToStr(mode).c_str());
-    if (m_file == nullptr) {
-        return;
-    }
-    m_filebuf = __gnu_cxx::stdio_filebuf<char>(m_file, mode);
-    rdbuf(&m_filebuf);
-    if (mode & std::ios_base::ate) {
-        seekp(0, std::ios_base::end);
-    }
-}
-
-void ofstream::close() {
-    if (m_file != nullptr) {
-        m_filebuf.close();
-        fclose(m_file);
-    }
-    m_file = nullptr;
-}
-#else // __GLIBCXX__
-
-#if BOOST_VERSION >= 107700
-static_assert(
-    sizeof(*BOOST_FILESYSTEM_C_STR(boost::filesystem::path())) ==
-        sizeof(wchar_t),
-#else
-static_assert(
-    sizeof(*boost::filesystem::path().BOOST_FILESYSTEM_C_STR) ==
-        sizeof(wchar_t),
-#endif // BOOST_VERSION >= 107700
-    "Warning: This build is using boost::filesystem ofstream and ifstream "
-    "implementations which will fail to open paths containing multibyte "
-    "characters. You should delete this static_assert to ignore this warning, "
-    "or switch to a different C++ standard library like the Microsoft C++ "
-    "Standard Library (where boost uses non-standard extensions to construct "
-    "stream objects with wide filenames), or the GNU libstdc++ library (where "
-    "a more complicated workaround has been implemented above).");
-
-#endif // __GLIBCXX__
-#endif // WIN32
-
 fs::path GetTempDirectoryPath() {
 #ifndef WIN32
     return fs::temp_directory_path();
 #else
     wchar_t dirPathWchars[MAX_PATH];
     GetTempPathW(MAX_PATH, dirPathWchars);
     std::wstring dirPathWstring(dirPathWchars);
     return fs::PathFromString(
         std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>().to_bytes(
             dirPathWstring));
 #endif
 }
 
 } // namespace fsbridge
diff --git a/src/fs.h b/src/fs.h
index c13d0acbc..8dd7401b2 100644
--- a/src/fs.h
+++ b/src/fs.h
@@ -1,264 +1,211 @@
 // Copyright (c) 2017 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_FS_H
 #define BITCOIN_FS_H
 
+#include <tinyformat.h>
+
 #include <cstdio>
+#include <filesystem>
+#include <iomanip>
+#include <ios>
+#include <ostream>
 #include <string>
-#if defined WIN32 && defined __GLIBCXX__
-#include <ext/stdio_filebuf.h>
-#endif
-
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
-#include <tinyformat.h>
+#include <utility>
 
 /** Filesystem operations and types */
 namespace fs {
 
-using namespace boost::filesystem;
+using namespace std::filesystem;
 
 /**
- * Path class wrapper to prepare application code for transition from
- * boost::filesystem library to std::filesystem implementation. The main
- * purpose of the class is to define fs::path::u8string() and fs::u8path()
- * functions not present in boost. It also blocks calls to the
- * fs::path(std::string) implicit constructor and the fs::path::string()
- * method, which worked well in the boost::filesystem implementation, but have
- * unsafe and unpredictable behavior on Windows in the std::filesystem
- * implementation (see implementation note in \ref PathToString for details).
+ * Path class wrapper to block calls to the fs::path(std::string) implicit
+ * constructor and the fs::path::string() method, which have unsafe and
+ * unpredictable behavior on Windows (see implementation note in
+ * \ref PathToString for details)
  */
-class path : public boost::filesystem::path {
+class path : public std::filesystem::path {
 public:
-    using boost::filesystem::path::path;
+    using std::filesystem::path::path;
     // Allow path objects arguments for compatibility.
-    path(boost::filesystem::path path)
-        : boost::filesystem::path::path(std::move(path)) {}
-    path &operator=(boost::filesystem::path path) {
-        boost::filesystem::path::operator=(std::move(path));
+    path(std::filesystem::path path)
+        : std::filesystem::path::path(std::move(path)) {}
+    path &operator=(std::filesystem::path path) {
+        std::filesystem::path::operator=(std::move(path));
         return *this;
     }
-    path &operator/=(boost::filesystem::path path) {
-        boost::filesystem::path::operator/=(std::move(path));
+    path &operator/=(std::filesystem::path path) {
+        std::filesystem::path::operator/=(std::move(path));
         return *this;
     }
 
     // Allow literal string arguments, which are safe as long as the literals
     // are ASCII.
-    path(const char *c) : boost::filesystem::path(c) {}
+    path(const char *c) : std::filesystem::path(c) {}
     path &operator=(const char *c) {
-        boost::filesystem::path::operator=(c);
+        std::filesystem::path::operator=(c);
         return *this;
     }
     path &operator/=(const char *c) {
-        boost::filesystem::path::operator/=(c);
+        std::filesystem::path::operator/=(c);
         return *this;
     }
     path &append(const char *c) {
-        boost::filesystem::path::append(c);
+        std::filesystem::path::append(c);
         return *this;
     }
 
     // Disallow std::string arguments to avoid locale-dependent decoding on
     // windows.
     path(std::string) = delete;
     path &operator=(std::string) = delete;
     path &operator/=(std::string) = delete;
     path &append(std::string) = delete;
 
     // Disallow std::string conversion method to avoid locale-dependent encoding
     // on windows.
     std::string string() const = delete;
 
-    // Define UTF-8 string conversion method not present in boost::filesystem
-    // but present in std::filesystem.
-    std::string u8string() const { return boost::filesystem::path::string(); }
+    // Required for path overloads in <fstream>.
+    // See
+    // https://gcc.gnu.org/git/?p=gcc.git;a=commit;h=96e0367ead5d8dcac3bec2865582e76e2fbab190
+    path &make_preferred() {
+        std::filesystem::path::make_preferred();
+        return *this;
+    }
+    path filename() const { return std::filesystem::path::filename(); }
 };
 
-// Define UTF-8 string conversion function not present in boost::filesystem but
-// present in std::filesystem.
-static inline path u8path(const std::string &string) {
-    return boost::filesystem::path(string);
-}
-
-// Disallow implicit std::string conversion for system_complete to avoid
+// Disallow implicit std::string conversion for absolute to avoid
 // locale-dependent encoding on windows.
-static inline path system_complete(const path &p) {
-    return boost::filesystem::system_complete(p);
+static inline path absolute(const path &p) {
+    return std::filesystem::absolute(p);
 }
 
 // Disallow implicit std::string conversion for exists to avoid
 // locale-dependent encoding on windows.
 static inline bool exists(const path &p) {
-    return boost::filesystem::exists(p);
+    return std::filesystem::exists(p);
 }
 
 // Allow explicit quoted stream I/O.
 static inline auto quoted(const std::string &s) {
-    return boost::io::quoted(s, '&');
+    return std::quoted(s, '"', '&');
 }
 
 // Allow safe path append operations.
 static inline path operator+(path p1, path p2) {
-    p1 += static_cast<boost::filesystem::path &&>(p2);
+    p1 += std::move(p2);
     return p1;
 }
 
+// Disallow implicit std::string conversion for copy_file
+// to avoid locale-dependent encoding on Windows.
+static inline bool copy_file(const path &from, const path &to,
+                             copy_options options) {
+    return std::filesystem::copy_file(from, to, options);
+}
+
 /**
- * Convert path object to byte string. On POSIX, paths natively are byte
+ * Convert path object to a byte string. On POSIX, paths natively are byte
  * strings so this is trivial. On Windows, paths natively are Unicode, so an
  * encoding step is necessary.
  *
  * The inverse of \ref PathToString is \ref PathFromString. The strings
  * returned and parsed by these functions can be used to call POSIX APIs, and
  * for roundtrip conversion, logging, and debugging. But they are not
  * guaranteed to be valid UTF-8, and are generally meant to be used internally,
  * not externally. When communicating with external programs and libraries that
  * require UTF-8, fs::path::u8string() and fs::u8path() methods can be used.
  * For other applications, if support for non UTF-8 paths is required, or if
  * higher-level JSON or XML or URI or C-style escapes are preferred, it may be
  * also be appropriate to use different path encoding functions.
  *
  * Implementation note: On Windows, the std::filesystem::path(string)
  * constructor and std::filesystem::path::string() method are not safe to use
  * here, because these methods encode the path using C++'s narrow multibyte
  * encoding, which on Windows corresponds to the current "code page", which is
  * unpredictable and typically not able to represent all valid paths. So
  * std::filesystem::path::u8string() and std::filesystem::u8path() functions
  * are used instead on Windows. On POSIX, u8string/u8path functions are not
  * safe to use because paths are not always valid UTF-8, so plain string
  * methods which do not transform the path there are used.
  */
 static inline std::string PathToString(const path &path) {
 #ifdef WIN32
     return path.u8string();
 #else
     static_assert(std::is_same<path::string_type, std::string>::value,
                   "PathToString not implemented on this platform");
-    return path.boost::filesystem::path::string();
+    return path.std::filesystem::path::string();
 #endif
 }
 
 /**
  * Convert byte string to path object. Inverse of \ref PathToString.
  */
 static inline path PathFromString(const std::string &string) {
 #ifdef WIN32
     return u8path(string);
 #else
-    return boost::filesystem::path(string);
+    return std::filesystem::path(string);
 #endif
 }
 } // namespace fs
 
 /** Bridge operations to C stdio */
 namespace fsbridge {
 FILE *fopen(const fs::path &p, const char *mode);
 FILE *freopen(const fs::path &p, const char *mode, FILE *stream);
 
 /**
  * Helper function for joining two paths
  *
  * @param[in] base  Base path
  * @param[in] path  Path to combine with base
  * @returns path unchanged if it is an absolute path, otherwise returns base
  * joined with path. Returns base unchanged if path is empty.
  * @pre  Base path must be absolute
  * @post Returned path will always be absolute
  */
 fs::path AbsPathJoin(const fs::path &base, const fs::path &path);
 
 class FileLock {
 public:
     FileLock() = delete;
     FileLock(const FileLock &) = delete;
     FileLock(FileLock &&) = delete;
     explicit FileLock(const fs::path &file);
     ~FileLock();
     bool TryLock();
     std::string GetReason() { return reason; }
 
 private:
     std::string reason;
 #ifndef WIN32
     int fd = -1;
 #else
     // INVALID_HANDLE_VALUE
     void *hFile = (void *)-1;
 #endif
 };
 
 std::string get_filesystem_error_message(const fs::filesystem_error &e);
 
-// GNU libstdc++ specific workaround for opening UTF-8 paths on Windows.
-//
-// On Windows, it is only possible to reliably access multibyte file paths
-// through `wchar_t` APIs, not `char` APIs. But because the C++ standard doesn't
-// require ifstream/ofstream `wchar_t` constructors, and the GNU library doesn't
-// provide them (in contrast to the Microsoft C++ library, see
-// https://stackoverflow.com/questions/821873/how-to-open-an-stdfstream-ofstream-or-ifstream-with-a-unicode-filename/822032#822032),
-// Boost is forced to fall back to `char` constructors which may not work
-// properly.
-//
-// Work around this issue by creating stream objects with `_wfopen` in
-// combination with `__gnu_cxx::stdio_filebuf`. This workaround can be removed
-// with an upgrade to C++17, where streams can be constructed directly from
-// `std::filesystem::path` objects.
-
-#if defined WIN32 && defined __GLIBCXX__
-class ifstream : public std::istream {
-public:
-    ifstream() = default;
-    explicit ifstream(const fs::path &p,
-                      std::ios_base::openmode mode = std::ios_base::in) {
-        open(p, mode);
-    }
-    ~ifstream() { close(); }
-    void open(const fs::path &p,
-              std::ios_base::openmode mode = std::ios_base::in);
-    bool is_open() { return m_filebuf.is_open(); }
-    void close();
-
-private:
-    __gnu_cxx::stdio_filebuf<char> m_filebuf;
-    FILE *m_file = nullptr;
-};
-class ofstream : public std::ostream {
-public:
-    ofstream() = default;
-    explicit ofstream(const fs::path &p,
-                      std::ios_base::openmode mode = std::ios_base::out) {
-        open(p, mode);
-    }
-    ~ofstream() { close(); }
-    void open(const fs::path &p,
-              std::ios_base::openmode mode = std::ios_base::out);
-    bool is_open() { return m_filebuf.is_open(); }
-    void close();
-
-private:
-    __gnu_cxx::stdio_filebuf<char> m_filebuf;
-    FILE *m_file = nullptr;
-};
-#else  // !(WIN32 && __GLIBCXX__)
-typedef fs::ifstream ifstream;
-typedef fs::ofstream ofstream;
-#endif // WIN32 && __GLIBCXX__
-
 fs::path GetTempDirectoryPath();
 }; // namespace fsbridge
 
 // Disallow path operator<< formatting in tinyformat to avoid locale-dependent
 // encoding on windows.
 namespace tinyformat {
 template <>
 inline void formatValue(std::ostream &, const char *, const char *, int,
-                        const boost::filesystem::path &) = delete;
+                        const std::filesystem::path &) = delete;
 template <>
 inline void formatValue(std::ostream &, const char *, const char *, int,
                         const fs::path &) = delete;
 } // namespace tinyformat
 
 #endif // BITCOIN_FS_H
diff --git a/src/init.cpp b/src/init.cpp
index 124858ce9..846c4a57b 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1,2987 +1,2990 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <init.h>
 
 #include <addrman.h>
 #include <avalanche/avalanche.h>
 #include <avalanche/processor.h>
 #include <avalanche/proof.h> // For AVALANCHE_LEGACY_PROOF_DEFAULT
 #include <avalanche/validation.h>
 #include <avalanche/voterecord.h> // For AVALANCHE_VOTE_STALE_*
 #include <banman.h>
 #include <blockfilter.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <compat/sanity.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <currencyunit.h>
 #include <flatfile.h>
 #include <fs.h>
 #include <hash.h>
 #include <httprpc.h>
 #include <httpserver.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
 #include <index/txindex.h>
 #include <init/common.h>
 #include <interfaces/chain.h>
 #include <interfaces/node.h>
 #include <mapport.h>
 #include <net.h>
 #include <net_permissions.h>
 #include <net_processing.h>
 #include <netbase.h>
 #include <node/blockstorage.h>
 #include <node/caches.h>
 #include <node/chainstate.h>
 #include <node/context.h>
 #include <node/miner.h>
 #include <node/ui_interface.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <rpc/blockchain.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <scheduler.h>
 #include <script/scriptcache.h>
 #include <script/sigcache.h>
 #include <script/standard.h>
 #include <shutdown.h>
 #include <sync.h>
 #include <timedata.h>
 #include <torcontrol.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <txorphanage.h>
 #include <util/asmap.h>
 #include <util/check.h>
 #include <util/moneystr.h>
 #include <util/string.h>
 #include <util/thread.h>
 #include <util/threadnames.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <walletinitinterface.h>
 
 #include <boost/signals2/signal.hpp>
 
 #if ENABLE_CHRONIK
 #include <chronik-cpp/chronik.h>
 #endif
 
 #if ENABLE_ZMQ
 #include <zmq/zmqabstractnotifier.h>
 #include <zmq/zmqnotificationinterface.h>
 #include <zmq/zmqrpc.h>
 #endif
 
 #ifndef WIN32
 #include <cerrno>
 #include <csignal>
 #include <sys/stat.h>
 #endif
 #include <algorithm>
+#include <condition_variable>
 #include <cstdint>
 #include <cstdio>
+#include <fstream>
 #include <functional>
 #include <set>
+#include <string>
 #include <thread>
 #include <vector>
 
 using node::CacheSizes;
 using node::CalculateCacheSizes;
 using node::ChainstateLoadingError;
 using node::ChainstateLoadVerifyError;
 using node::CleanupBlockRevFiles;
 using node::DEFAULT_STOPAFTERBLOCKIMPORT;
 using node::fPruneMode;
 using node::fReindex;
 using node::LoadChainstate;
 using node::NodeContext;
 using node::nPruneTarget;
 using node::ThreadImport;
 using node::VerifyLoadedChainstate;
 
 static const bool DEFAULT_PROXYRANDOMIZE = true;
 static const bool DEFAULT_REST_ENABLE = false;
 static constexpr bool DEFAULT_CHRONIK = false;
 
 #ifdef WIN32
 // Win32 LevelDB doesn't use filedescriptors, and the ones used for accessing
 // block files don't count towards the fd_set size limit anyway.
 #define MIN_CORE_FILEDESCRIPTORS 0
 #else
 #define MIN_CORE_FILEDESCRIPTORS 150
 #endif
 
 static const char *DEFAULT_ASMAP_FILENAME = "ip_asn.map";
 
 /**
  * The PID file facilities.
  */
 static const char *BITCOIN_PID_FILENAME = "bitcoind.pid";
 
 static fs::path GetPidFile(const ArgsManager &args) {
     return AbsPathForConfigVal(
         fs::PathFromString(args.GetArg("-pid", BITCOIN_PID_FILENAME)));
 }
 
 [[nodiscard]] static bool CreatePidFile(const ArgsManager &args) {
-    fsbridge::ofstream file{GetPidFile(args)};
+    std::ofstream file{GetPidFile(args)};
     if (file) {
 #ifdef WIN32
         tfm::format(file, "%d\n", GetCurrentProcessId());
 #else
         tfm::format(file, "%d\n", getpid());
 #endif
         return true;
     } else {
         return InitError(strprintf(_("Unable to create the PID file '%s': %s"),
                                    fs::PathToString(GetPidFile(args)),
                                    std::strerror(errno)));
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // Shutdown
 //
 
 //
 // Thread management and startup/shutdown:
 //
 // The network-processing threads are all part of a thread group created by
 // AppInit() or the Qt main() function.
 //
 // A clean exit happens when StartShutdown() or the SIGTERM signal handler sets
 // fRequestShutdown, which makes main thread's WaitForShutdown() interrupts the
 // thread group.
 // And then, WaitForShutdown() makes all other on-going threads in the thread
 // group join the main thread.
 // Shutdown() is then called to clean up database connections, and stop other
 // threads that should only be stopped after the main network-processing threads
 // have exited.
 //
 // Shutdown for Qt is very similar, only it uses a QTimer to detect
 // ShutdownRequested() getting set, and then does the normal Qt shutdown thing.
 //
 
 void Interrupt(NodeContext &node) {
     InterruptHTTPServer();
     InterruptHTTPRPC();
     InterruptRPC();
     InterruptREST();
     InterruptTorControl();
     InterruptMapPort();
     if (g_avalanche) {
         // Avalanche needs to be stopped before we interrupt the thread group as
         // the scheduler will stop working then.
         g_avalanche->stopEventLoop();
     }
     if (node.connman) {
         node.connman->Interrupt();
     }
     if (g_txindex) {
         g_txindex->Interrupt();
     }
     ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Interrupt(); });
     if (g_coin_stats_index) {
         g_coin_stats_index->Interrupt();
     }
 }
 
 void Shutdown(NodeContext &node) {
     static Mutex g_shutdown_mutex;
     TRY_LOCK(g_shutdown_mutex, lock_shutdown);
     if (!lock_shutdown) {
         return;
     }
     LogPrintf("%s: In progress...\n", __func__);
     Assert(node.args);
 
     /// Note: Shutdown() must be able to handle cases in which initialization
     /// failed part of the way, for example if the data directory was found to
     /// be locked. Be sure that anything that writes files or flushes caches
     /// only does this if the respective module was initialized.
     util::ThreadRename("shutoff");
     if (node.mempool) {
         node.mempool->AddTransactionsUpdated(1);
     }
 
     StopHTTPRPC();
     StopREST();
     StopRPC();
     StopHTTPServer();
     for (const auto &client : node.chain_clients) {
         client->flush();
     }
     StopMapPort();
 
     // Because avalanche and the network depend on each other, it is important
     // to shut them down in this order:
     // 1. Stop avalanche event loop.
     // 2. Shutdown network processing.
     // 3. Destroy avalanche::Processor.
     // 4. Destroy CConnman
     if (g_avalanche) {
         g_avalanche->stopEventLoop();
     }
 
     // Because these depend on each-other, we make sure that neither can be
     // using the other before destroying them.
     if (node.peerman) {
         UnregisterValidationInterface(node.peerman.get());
     }
     if (node.connman) {
         node.connman->Stop();
     }
 
 #if ENABLE_CHRONIK
     chronik::Stop();
 #endif
 
     StopTorControl();
 
     // After everything has been shut down, but before things get flushed, stop
     // the CScheduler/checkqueue, scheduler and load block thread.
     if (node.scheduler) {
         node.scheduler->stop();
     }
     if (node.chainman && node.chainman->m_load_block.joinable()) {
         node.chainman->m_load_block.join();
     }
     StopScriptCheckWorkerThreads();
 
     // After the threads that potentially access these pointers have been
     // stopped, destruct and reset all to nullptr.
     node.peerman.reset();
 
     // Destroy various global instances
     g_avalanche.reset();
     node.connman.reset();
     node.banman.reset();
     node.addrman.reset();
 
     if (node.mempool && node.mempool->IsLoaded() &&
         node.args->GetBoolArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
         DumpMempool(*node.mempool);
     }
 
     // FlushStateToDisk generates a ChainStateFlushed callback, which we should
     // avoid missing
     if (node.chainman) {
         LOCK(cs_main);
         for (Chainstate *chainstate : node.chainman->GetAll()) {
             if (chainstate->CanFlushToDisk()) {
                 chainstate->ForceFlushStateToDisk();
             }
         }
     }
 
     // After there are no more peers/RPC left to give us new data which may
     // generate CValidationInterface callbacks, flush them...
     GetMainSignals().FlushBackgroundCallbacks();
 
     // Stop and delete all indexes only after flushing background callbacks.
     if (g_txindex) {
         g_txindex->Stop();
         g_txindex.reset();
     }
     if (g_coin_stats_index) {
         g_coin_stats_index->Stop();
         g_coin_stats_index.reset();
     }
     ForEachBlockFilterIndex([](BlockFilterIndex &index) { index.Stop(); });
     DestroyAllBlockFilterIndexes();
 
     // Any future callbacks will be dropped. This should absolutely be safe - if
     // missing a callback results in an unrecoverable situation, unclean
     // shutdown would too. The only reason to do the above flushes is to let the
     // wallet catch up with our current chain to avoid any strange pruning edge
     // cases and make next startup faster by avoiding rescan.
 
     if (node.chainman) {
         LOCK(cs_main);
         for (Chainstate *chainstate : node.chainman->GetAll()) {
             if (chainstate->CanFlushToDisk()) {
                 chainstate->ForceFlushStateToDisk();
                 chainstate->ResetCoinsViews();
             }
         }
     }
     for (const auto &client : node.chain_clients) {
         client->stop();
     }
 
 #if ENABLE_ZMQ
     if (g_zmq_notification_interface) {
         UnregisterValidationInterface(g_zmq_notification_interface);
         delete g_zmq_notification_interface;
         g_zmq_notification_interface = nullptr;
     }
 #endif
 
     node.chain_clients.clear();
     UnregisterAllValidationInterfaces();
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     init::UnsetGlobals();
     node.mempool.reset();
     node.chainman.reset();
     node.scheduler.reset();
 
     try {
         if (!fs::remove(GetPidFile(*node.args))) {
             LogPrintf("%s: Unable to remove PID file: File does not exist\n",
                       __func__);
         }
     } catch (const fs::filesystem_error &e) {
         LogPrintf("%s: Unable to remove PID file: %s\n", __func__,
                   fsbridge::get_filesystem_error_message(e));
     }
 
     node.args = nullptr;
     LogPrintf("%s: done\n", __func__);
 }
 
 /**
  * Signal handlers are very limited in what they are allowed to do.
  * The execution context the handler is invoked in is not guaranteed,
  * so we restrict handler operations to just touching variables:
  */
 #ifndef WIN32
 static void HandleSIGTERM(int) {
     StartShutdown();
 }
 
 static void HandleSIGHUP(int) {
     LogInstance().m_reopen_file = true;
 }
 #else
 static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType) {
     StartShutdown();
     Sleep(INFINITE);
     return true;
 }
 #endif
 
 #ifndef WIN32
 static void registerSignalHandler(int signal, void (*handler)(int)) {
     struct sigaction sa;
     sa.sa_handler = handler;
     sigemptyset(&sa.sa_mask);
     sa.sa_flags = 0;
     sigaction(signal, &sa, NULL);
 }
 #endif
 
 static boost::signals2::connection rpc_notify_block_change_connection;
 static void OnRPCStarted() {
     rpc_notify_block_change_connection = uiInterface.NotifyBlockTip_connect(
         std::bind(RPCNotifyBlockChange, std::placeholders::_2));
 }
 
 static void OnRPCStopped() {
     rpc_notify_block_change_connection.disconnect();
     RPCNotifyBlockChange(nullptr);
     g_best_block_cv.notify_all();
     LogPrint(BCLog::RPC, "RPC stopped.\n");
 }
 
 void SetupServerArgs(NodeContext &node) {
     assert(!node.args);
     node.args = &gArgs;
     ArgsManager &argsman = *node.args;
 
     SetupHelpOptions(argsman);
     SetupCurrencyUnitOptions(argsman);
     // server-only for now
     argsman.AddArg("-help-debug",
                    "Print help message with debugging options and exit", false,
                    OptionsCategory::DEBUG_TEST);
 
     init::AddLoggingArgs(argsman);
 
     const auto defaultBaseParams =
         CreateBaseChainParams(CBaseChainParams::MAIN);
     const auto testnetBaseParams =
         CreateBaseChainParams(CBaseChainParams::TESTNET);
     const auto regtestBaseParams =
         CreateBaseChainParams(CBaseChainParams::REGTEST);
     const auto defaultChainParams = CreateChainParams(CBaseChainParams::MAIN);
     const auto testnetChainParams =
         CreateChainParams(CBaseChainParams::TESTNET);
     const auto regtestChainParams =
         CreateChainParams(CBaseChainParams::REGTEST);
 
     // Hidden Options
     std::vector<std::string> hidden_args = {
         "-dbcrashratio",
         "-forcecompactdb",
         "-maxaddrtosend",
         "-parkdeepreorg",
         "-automaticunparking",
         "-replayprotectionactivationtime",
         "-enableminerfund",
         // GUI args. These will be overwritten by SetupUIArgs for the GUI
         "-allowselfsignedrootcertificates",
         "-choosedatadir",
         "-lang=<lang>",
         "-min",
         "-resetguisettings",
         "-rootcertificates=<file>",
         "-splash",
         "-uiplatform",
         // TODO remove after the May 2023 upgrade
         "-wellingtonactivationtime",
     };
 
     // Set all of the args and their help
     // When adding new options to the categories, please keep and ensure
     // alphabetical ordering. Do not translate _(...) -help-debug options, Many
     // technical terms, and only a very small audience, so is unnecessary stress
     // to translators.
     argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY,
                    OptionsCategory::OPTIONS);
 #if defined(HAVE_SYSTEM)
     argsman.AddArg(
         "-alertnotify=<cmd>",
         "Execute command when a relevant alert is received or we see "
         "a really long fork (%s in cmd is replaced by message)",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #endif
     argsman.AddArg(
         "-assumevalid=<hex>",
         strprintf(
             "If this block is in the chain assume that it and its ancestors "
             "are valid and potentially skip their script verification (0 to "
             "verify all, default: %s, testnet: %s)",
             defaultChainParams->GetConsensus().defaultAssumeValid.GetHex(),
             testnetChainParams->GetConsensus().defaultAssumeValid.GetHex()),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-blocksdir=<dir>",
                    "Specify directory to hold blocks subdirectory for *.dat "
                    "files (default: <datadir>)",
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-fastprune",
                    "Use smaller block files and lower minimum prune height for "
                    "testing purposes",
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
 #if defined(HAVE_SYSTEM)
     argsman.AddArg("-blocknotify=<cmd>",
                    "Execute command when the best block changes (%s in cmd is "
                    "replaced by block hash)",
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #endif
     argsman.AddArg("-blockreconstructionextratxn=<n>",
                    strprintf("Extra transactions to keep in memory for compact "
                              "block reconstructions (default: %u)",
                              DEFAULT_BLOCK_RECONSTRUCTION_EXTRA_TXN),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-blocksonly",
         strprintf("Whether to reject transactions from network peers.  "
                   "Automatic broadcast and rebroadcast of any transactions "
                   "from inbound peers is disabled, unless the peer has the "
                   "'forcerelay' permission. RPC transactions are"
                   " not affected. (default: %u)",
                   DEFAULT_BLOCKSONLY),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-coinstatsindex",
                    strprintf("Maintain coinstats index used by the "
                              "gettxoutsetinfo RPC (default: %u)",
                              DEFAULT_COINSTATSINDEX),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-conf=<file>",
         strprintf("Specify path to read-only configuration file. Relative "
                   "paths will be prefixed by datadir location. (default: %s)",
                   BITCOIN_CONF_FILENAME),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-datadir=<dir>", "Specify data directory",
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-dbbatchsize",
         strprintf("Maximum database write batch size in bytes (default: %u)",
                   DEFAULT_DB_BATCH_SIZE),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-dbcache=<n>",
         strprintf("Set database cache size in MiB (%d to %d, default: %d)",
                   MIN_DB_CACHE_MB, MAX_DB_CACHE_MB, DEFAULT_DB_CACHE_MB),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-includeconf=<file>",
         "Specify additional configuration file, relative to the -datadir path "
         "(only useable from configuration file, not command line)",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-loadblock=<file>",
                    "Imports blocks from external file on startup",
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-maxmempool=<n>",
                    strprintf("Keep the transaction memory pool below <n> "
                              "megabytes (default: %u)",
                              DEFAULT_MAX_MEMPOOL_SIZE),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-maxorphantx=<n>",
                    strprintf("Keep at most <n> unconnectable transactions in "
                              "memory (default: %u)",
                              DEFAULT_MAX_ORPHAN_TRANSACTIONS),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-mempoolexpiry=<n>",
                    strprintf("Do not keep transactions in the mempool longer "
                              "than <n> hours (default: %u)",
                              DEFAULT_MEMPOOL_EXPIRY),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-minimumchainwork=<hex>",
         strprintf(
             "Minimum work assumed to exist on a valid chain in hex "
             "(default: %s, testnet: %s)",
             defaultChainParams->GetConsensus().nMinimumChainWork.GetHex(),
             testnetChainParams->GetConsensus().nMinimumChainWork.GetHex()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-par=<n>",
         strprintf("Set the number of script verification threads (%u to %d, 0 "
                   "= auto, <0 = leave that many cores free, default: %d)",
                   -GetNumCores(), MAX_SCRIPTCHECK_THREADS,
                   DEFAULT_SCRIPTCHECK_THREADS),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-persistmempool",
                    strprintf("Whether to save the mempool on shutdown and load "
                              "on restart (default: %u)",
                              DEFAULT_PERSIST_MEMPOOL),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-pid=<file>",
         strprintf("Specify pid file. Relative paths will be prefixed "
                   "by a net-specific datadir location. (default: %s)",
                   BITCOIN_PID_FILENAME),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-prune=<n>",
         strprintf("Reduce storage requirements by enabling pruning (deleting) "
                   "of old blocks. This allows the pruneblockchain RPC to be "
                   "called to delete specific blocks, and enables automatic "
                   "pruning of old blocks if a target size in MiB is provided. "
                   "This mode is incompatible with -txindex, -coinstatsindex "
                   "and -rescan. Warning: Reverting this setting requires "
                   "re-downloading the entire blockchain. (default: 0 = disable "
                   "pruning blocks, 1 = allow manual pruning via RPC, >=%u = "
                   "automatically prune block files to stay under the specified "
                   "target size in MiB)",
                   MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-reindex-chainstate",
         "Rebuild chain state from the currently indexed blocks. When "
         "in pruning mode or if blocks on disk might be corrupted, use "
         "full -reindex instead.",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-reindex",
         "Rebuild chain state and block index from the blk*.dat files on disk",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-settings=<file>",
         strprintf(
             "Specify path to dynamic settings data file. Can be disabled with "
             "-nosettings. File is written at runtime and not meant to be "
             "edited by users (use %s instead for custom settings). Relative "
             "paths will be prefixed by datadir location. (default: %s)",
             BITCOIN_CONF_FILENAME, BITCOIN_SETTINGS_FILENAME),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #if HAVE_SYSTEM
     argsman.AddArg("-startupnotify=<cmd>", "Execute command on startup.",
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #endif
 #ifndef WIN32
     argsman.AddArg(
         "-sysperms",
         "Create new files with system default permissions, instead of umask "
         "077 (only effective with disabled wallet functionality)",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #else
     hidden_args.emplace_back("-sysperms");
 #endif
     argsman.AddArg("-txindex",
                    strprintf("Maintain a full transaction index, used by the "
                              "getrawtransaction rpc call (default: %d)",
                              DEFAULT_TXINDEX),
                    ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #if ENABLE_CHRONIK
     argsman.AddArg(
         "-chronik",
         strprintf("Enable the Chronik indexer, which can be read via a "
                   "dedicated HTTP/Protobuf interface (default: %d)",
                   DEFAULT_CHRONIK),
         ArgsManager::ALLOW_BOOL, OptionsCategory::CHRONIK);
     argsman.AddArg(
         "-chronikbind=<addr>[:port]",
         strprintf(
             "Bind the Chronik indexer to the given address to listen for "
             "HTTP/Protobuf connections to access the index. Unlike the "
             "JSON-RPC, it's ok to have this publicly exposed on the internet. "
             "This option can be specified multiple times (default: %s; default "
             "port: %u, testnet: %u, regtest: %u)",
             Join(chronik::DEFAULT_BINDS, ", "),
             defaultBaseParams->ChronikPort(), testnetBaseParams->ChronikPort(),
             regtestBaseParams->ChronikPort()),
         ArgsManager::ALLOW_STRING | ArgsManager::NETWORK_ONLY,
         OptionsCategory::CHRONIK);
     argsman.AddArg("-chronikreindex",
                    "Reindex the Chronik indexer from genesis, but leave the "
                    "other indexes untouched",
                    ArgsManager::ALLOW_BOOL, OptionsCategory::CHRONIK);
 #endif
     argsman.AddArg(
         "-blockfilterindex=<type>",
         strprintf("Maintain an index of compact filters by block "
                   "(default: %s, values: %s).",
                   DEFAULT_BLOCKFILTERINDEX, ListBlockFilterTypes()) +
             " If <type> is not supplied or if <type> = 1, indexes for "
             "all known types are enabled.",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg(
         "-usecashaddr",
         "Use Cash Address for destination encoding instead of base58 "
         "(activate by default on Jan, 14)",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 
     argsman.AddArg(
         "-addnode=<ip>",
         "Add a node to connect to and attempt to keep the connection "
         "open (see the `addnode` RPC command help for more info)",
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
         OptionsCategory::CONNECTION);
     argsman.AddArg("-asmap=<file>",
                    strprintf("Specify asn mapping used for bucketing of the "
                              "peers (default: %s). Relative paths will be "
                              "prefixed by the net-specific datadir location.",
                              DEFAULT_ASMAP_FILENAME),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-bantime=<n>",
                    strprintf("Default duration (in seconds) of manually "
                              "configured bans (default: %u)",
                              DEFAULT_MISBEHAVING_BANTIME),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-bind=<addr>[:<port>][=onion]",
         strprintf("Bind to given address and always listen on it (default: "
                   "0.0.0.0). Use [host]:port notation for IPv6. Append =onion "
                   "to tag any incoming connections to that address and port as "
                   "incoming Tor connections (default: 127.0.0.1:%u=onion, "
                   "testnet: 127.0.0.1:%u=onion, regtest: 127.0.0.1:%u=onion)",
                   defaultBaseParams->OnionServiceTargetPort(),
                   testnetBaseParams->OnionServiceTargetPort(),
                   regtestBaseParams->OnionServiceTargetPort()),
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
         OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-connect=<ip>",
         "Connect only to the specified node(s); -connect=0 disables automatic "
         "connections (the rules for this peer are the same as for -addnode)",
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
         OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-discover",
         "Discover own IP addresses (default: 1 when listening and no "
         "-externalip or -proxy)",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-dns",
                    strprintf("Allow DNS lookups for -addnode, -seednode and "
                              "-connect (default: %d)",
                              DEFAULT_NAME_LOOKUP),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-dnsseed",
         strprintf(
             "Query for peer addresses via DNS lookup, if low on addresses "
             "(default: %u unless -connect used)",
             DEFAULT_DNSSEED),
         ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
     argsman.AddArg("-externalip=<ip>", "Specify your own public address",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-fixedseeds",
         strprintf(
             "Allow fixed seeds if DNS seeds don't provide peers (default: %u)",
             DEFAULT_FIXEDSEEDS),
         ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-forcednsseed",
         strprintf(
             "Always query for peer addresses via DNS lookup (default: %d)",
             DEFAULT_FORCEDNSSEED),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-overridednsseed",
                    "If set, only use the specified DNS seed when "
                    "querying for peer addresses via DNS lookup.",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-listen",
         "Accept connections from outside (default: 1 if no -proxy or -connect)",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-listenonion",
         strprintf("Automatically create Tor onion service (default: %d)",
                   DEFAULT_LISTEN_ONION),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-maxconnections=<n>",
         strprintf("Maintain at most <n> connections to peers. The effective "
                   "limit depends on system limitations and might be lower than "
                   "the specified value (default: %u)",
                   DEFAULT_MAX_PEER_CONNECTIONS),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-maxreceivebuffer=<n>",
                    strprintf("Maximum per-connection receive buffer, <n>*1000 "
                              "bytes (default: %u)",
                              DEFAULT_MAXRECEIVEBUFFER),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-maxsendbuffer=<n>",
         strprintf(
             "Maximum per-connection send buffer, <n>*1000 bytes (default: %u)",
             DEFAULT_MAXSENDBUFFER),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-maxtimeadjustment",
         strprintf("Maximum allowed median peer time offset adjustment. Local "
                   "perspective of time may be influenced by peers forward or "
                   "backward by this amount. (default: %u seconds)",
                   DEFAULT_MAX_TIME_ADJUSTMENT),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-onion=<ip:port>",
                    strprintf("Use separate SOCKS5 proxy to reach peers via Tor "
                              "onion services (default: %s)",
                              "-proxy"),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-i2psam=<ip:port>",
                    "I2P SAM proxy to reach I2P peers and accept I2P "
                    "connections (default: none)",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-i2pacceptincoming",
         "If set and -i2psam is also set then incoming I2P connections are "
         "accepted via the SAM proxy. If this is not set but -i2psam is set "
         "then only outgoing connections will be made to the I2P network. "
         "Ignored if -i2psam is not set. Listening for incoming I2P connections "
         "is done through the SAM proxy, not by binding to a local address and "
         "port (default: 1)",
         ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
 
     argsman.AddArg(
         "-onlynet=<net>",
         "Make outgoing connections only through network <net> (" +
             Join(GetNetworkNames(), ", ") +
             "). Incoming connections are not affected by this option. This "
             "option can be specified multiple times to allow multiple "
             "networks. Warning: if it is used with non-onion networks "
             "and the -onion or -proxy option is set, then outbound onion "
             "connections will still be made; use -noonion or -onion=0 to "
             "disable outbound onion connections in this case",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-peerbloomfilters",
                    strprintf("Support filtering of blocks and transaction with "
                              "bloom filters (default: %d)",
                              DEFAULT_PEERBLOOMFILTERS),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-peerblockfilters",
         strprintf(
             "Serve compact block filters to peers per BIP 157 (default: %u)",
             DEFAULT_PEERBLOCKFILTERS),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-permitbaremultisig",
                    strprintf("Relay non-P2SH multisig (default: %d)",
                              DEFAULT_PERMIT_BAREMULTISIG),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     // TODO: remove the sentence "Nodes not using ... incoming connections."
     // once the changes from https://github.com/bitcoin/bitcoin/pull/23542 have
     // become widespread.
     argsman.AddArg("-port=<port>",
                    strprintf("Listen for connections on <port>. Nodes not "
                              "using the default ports (default: %u, "
                              "testnet: %u, regtest: %u) are unlikely to get "
                              "incoming connections.  Not relevant for I2P (see "
                              "doc/i2p.md).",
                              defaultChainParams->GetDefaultPort(),
                              testnetChainParams->GetDefaultPort(),
                              regtestChainParams->GetDefaultPort()),
                    ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                    OptionsCategory::CONNECTION);
     argsman.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-proxyrandomize",
         strprintf("Randomize credentials for every proxy connection. "
                   "This enables Tor stream isolation (default: %d)",
                   DEFAULT_PROXYRANDOMIZE),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-seednode=<ip>",
         "Connect to a node to retrieve peer addresses, and disconnect",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-networkactive",
         "Enable all P2P network activity (default: 1). Can be changed "
         "by the setnetworkactive RPC command",
         ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
     argsman.AddArg("-timeout=<n>",
                    strprintf("Specify connection timeout in milliseconds "
                              "(minimum: 1, default: %d)",
                              DEFAULT_CONNECT_TIMEOUT),
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-peertimeout=<n>",
         strprintf("Specify p2p connection timeout in seconds. This option "
                   "determines the amount of time a peer may be inactive before "
                   "the connection to it is dropped. (minimum: 1, default: %d)",
                   DEFAULT_PEER_CONNECT_TIMEOUT),
         true, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-torcontrol=<ip>:<port>",
         strprintf(
             "Tor control port to use if onion listening enabled (default: %s)",
             DEFAULT_TOR_CONTROL),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-torpassword=<pass>",
                    "Tor control port password (default: empty)",
                    ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE,
                    OptionsCategory::CONNECTION);
 #ifdef USE_UPNP
 #if USE_UPNP
     argsman.AddArg("-upnp",
                    "Use UPnP to map the listening port (default: 1 when "
                    "listening and no -proxy)",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 #else
     argsman.AddArg(
         "-upnp",
         strprintf("Use UPnP to map the listening port (default: %u)", 0),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 #endif
 #else
     hidden_args.emplace_back("-upnp");
 #endif
 #ifdef USE_NATPMP
     argsman.AddArg(
         "-natpmp",
         strprintf("Use NAT-PMP to map the listening port (default: %s)",
                   DEFAULT_NATPMP ? "1 when listening and no -proxy" : "0"),
         ArgsManager::ALLOW_BOOL, OptionsCategory::CONNECTION);
 #else
     hidden_args.emplace_back("-natpmp");
 #endif // USE_NATPMP
     argsman.AddArg(
         "-whitebind=<[permissions@]addr>",
         "Bind to the given address and add permission flags to the peers "
         "connecting to it."
         "Use [host]:port notation for IPv6. Allowed permissions: " +
             Join(NET_PERMISSIONS_DOC, ", ") +
             ". "
             "Specify multiple permissions separated by commas (default: "
             "download,noban,mempool,relay). Can be specified multiple times.",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 
     argsman.AddArg("-whitelist=<[permissions@]IP address or network>",
                    "Add permission flags to the peers connecting from the "
                    "given IP address (e.g. 1.2.3.4) or CIDR-notated network "
                    "(e.g. 1.2.3.0/24). "
                    "Uses the same permissions as -whitebind. Can be specified "
                    "multiple times.",
                    ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg(
         "-maxuploadtarget=<n>",
         strprintf("Tries to keep outbound traffic under the given target (in "
                   "MiB per 24h). Limit does not apply to peers with 'download' "
                   "permission. 0 = no limit (default: %d)",
                   DEFAULT_MAX_UPLOAD_TARGET),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 
     g_wallet_init_interface.AddWalletOptions(argsman);
 
 #if ENABLE_ZMQ
     argsman.AddArg("-zmqpubhashblock=<address>",
                    "Enable publish hash block in <address>",
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg("-zmqpubhashtx=<address>",
                    "Enable publish hash transaction in <address>",
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg("-zmqpubrawblock=<address>",
                    "Enable publish raw block in <address>",
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg("-zmqpubrawtx=<address>",
                    "Enable publish raw transaction in <address>",
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg("-zmqpubsequence=<address>",
                    "Enable publish hash block and tx sequence in <address>",
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg(
         "-zmqpubhashblockhwm=<n>",
         strprintf("Set publish hash block outbound message high water "
                   "mark (default: %d)",
                   CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
         ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg(
         "-zmqpubhashtxhwm=<n>",
         strprintf("Set publish hash transaction outbound message high "
                   "water mark (default: %d)",
                   CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
         false, OptionsCategory::ZMQ);
     argsman.AddArg(
         "-zmqpubrawblockhwm=<n>",
         strprintf("Set publish raw block outbound message high water "
                   "mark (default: %d)",
                   CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
         ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg(
         "-zmqpubrawtxhwm=<n>",
         strprintf("Set publish raw transaction outbound message high "
                   "water mark (default: %d)",
                   CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
         ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     argsman.AddArg("-zmqpubsequencehwm=<n>",
                    strprintf("Set publish hash sequence message high water mark"
                              " (default: %d)",
                              CZMQAbstractNotifier::DEFAULT_ZMQ_SNDHWM),
                    ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
 #else
     hidden_args.emplace_back("-zmqpubhashblock=<address>");
     hidden_args.emplace_back("-zmqpubhashtx=<address>");
     hidden_args.emplace_back("-zmqpubrawblock=<address>");
     hidden_args.emplace_back("-zmqpubrawtx=<address>");
     hidden_args.emplace_back("-zmqpubsequence=<n>");
     hidden_args.emplace_back("-zmqpubhashblockhwm=<n>");
     hidden_args.emplace_back("-zmqpubhashtxhwm=<n>");
     hidden_args.emplace_back("-zmqpubrawblockhwm=<n>");
     hidden_args.emplace_back("-zmqpubrawtxhwm=<n>");
     hidden_args.emplace_back("-zmqpubsequencehwm=<n>");
 #endif
 
     argsman.AddArg(
         "-checkblocks=<n>",
         strprintf("How many blocks to check at startup (default: %u, 0 = all)",
                   DEFAULT_CHECKBLOCKS),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-checklevel=<n>",
                    strprintf("How thorough the block verification of "
                              "-checkblocks is: %s (0-4, default: %u)",
                              Join(CHECKLEVEL_DOC, ", "), DEFAULT_CHECKLEVEL),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-checkblockindex",
                    strprintf("Do a consistency check for the block tree, "
                              "chainstate, and other validation data structures "
                              "occasionally. (default: %u, regtest: %u)",
                              defaultChainParams->DefaultConsistencyChecks(),
                              regtestChainParams->DefaultConsistencyChecks()),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-checkaddrman=<n>",
                    strprintf("Run addrman consistency checks every <n> "
                              "operations. Use 0 to disable. (default: %u)",
                              DEFAULT_ADDRMAN_CONSISTENCY_CHECKS),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-checkmempool=<n>",
         strprintf("Run mempool consistency checks every <n> transactions. Use "
                   "0 to disable. (default: %u, regtest: %u)",
                   defaultChainParams->DefaultConsistencyChecks(),
                   regtestChainParams->DefaultConsistencyChecks()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-checkpoints",
                    strprintf("Only accept block chain matching built-in "
                              "checkpoints (default: %d)",
                              DEFAULT_CHECKPOINTS_ENABLED),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-deprecatedrpc=<method>",
                    "Allows deprecated RPC method(s) to be used",
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-stopafterblockimport",
         strprintf("Stop running after importing blocks from disk (default: %d)",
                   DEFAULT_STOPAFTERBLOCKIMPORT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-stopatheight",
                    strprintf("Stop running after reaching the given height in "
                              "the main chain (default: %u)",
                              DEFAULT_STOPATHEIGHT),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     // TODO Remove after wellington activation
     argsman.AddArg(
         "-limitancestorcount=<n>",
         strprintf("DEPRECATED: Do not accept transactions if number of "
                   "in-mempool ancestors is <n> or more (default: %u). This is "
                   "no longer evaluated after the May 15th 2023 eCash network "
                   "upgrade.",
                   DEFAULT_ANCESTOR_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-limitancestorsize=<n>",
         strprintf("DEPRECATED: Do not accept transactions whose size with all "
                   "in-mempool ancestors exceeds <n> kilobytes (default: %u). "
                   "This is no longer evaluated after the May 15th 2023 eCash "
                   "network upgrade.",
                   DEFAULT_ANCESTOR_SIZE_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-limitdescendantcount=<n>",
         strprintf("DEPRECATED: Do not accept transactions if any ancestor "
                   "would have <n> or more in-mempool descendants (default: %u)"
                   ". This is no longer evaluated after the May 15th 2023 eCash "
                   "network upgrade.",
                   DEFAULT_DESCENDANT_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-limitdescendantsize=<n>",
         strprintf("DEPRECATED: Do not accept transactions if any ancestor "
                   "would have more than <n> kilobytes of in-mempool "
                   "descendants (default: %u). This is no longer evaluated "
                   "after the May 15th 2023 eCash network upgrade.",
                   DEFAULT_DESCENDANT_SIZE_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-addrmantest", "Allows to test address relay on localhost",
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-capturemessages", "Capture all P2P messages to disk",
                    ArgsManager::ALLOW_BOOL | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-mocktime=<n>",
                    "Replace actual time with " + UNIX_EPOCH_TIME +
                        " (default: 0)",
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-maxsigcachesize=<n>",
         strprintf("Limit size of signature cache to <n> MiB (default: %u)",
                   DEFAULT_MAX_SIG_CACHE_SIZE),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg(
         "-maxscriptcachesize=<n>",
         strprintf("Limit size of script cache to <n> MiB (default: %u)",
                   DEFAULT_MAX_SCRIPT_CACHE_SIZE),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-maxtipage=<n>",
                    strprintf("Maximum tip age in seconds to consider node in "
                              "initial block download (default: %u)",
                              DEFAULT_MAX_TIP_AGE),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::DEBUG_TEST);
 
     argsman.AddArg("-uacomment=<cmt>",
                    "Append comment to the user agent string",
                    ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-uaclientname=<clientname>", "Set user agent client name",
                    ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-uaclientversion=<clientversion>",
                    "Set user agent client version", ArgsManager::ALLOW_ANY,
                    OptionsCategory::DEBUG_TEST);
 
     SetupChainParamsBaseOptions(argsman);
 
     argsman.AddArg(
         "-acceptnonstdtxn",
         strprintf(
             "Relay and mine \"non-standard\" transactions (%sdefault: %u)",
             "testnet/regtest only; ", defaultChainParams->RequireStandard()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::NODE_RELAY);
     argsman.AddArg("-excessiveblocksize=<n>",
                    strprintf("Do not accept blocks larger than this limit, in "
                              "bytes (default: %d)",
                              DEFAULT_MAX_BLOCK_SIZE),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::NODE_RELAY);
     const auto &ticker = Currency::get().ticker;
     argsman.AddArg(
         "-dustrelayfee=<amt>",
         strprintf("Fee rate (in %s/kB) used to define dust, the value of an "
                   "output such that it will cost about 1/3 of its value in "
                   "fees at this fee rate to spend it. (default: %s)",
                   ticker, FormatMoney(DUST_RELAY_TX_FEE)),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::NODE_RELAY);
 
     argsman.AddArg(
         "-bytespersigcheck",
         strprintf("Equivalent bytes per sigCheck in transactions for relay and "
                   "mining (default: %u).",
                   DEFAULT_BYTES_PER_SIGCHECK),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-bytespersigop",
         strprintf("DEPRECATED: Equivalent bytes per sigCheck in transactions "
                   "for relay and mining (default: %u). This has been "
                   "deprecated since v0.26.8 and will be removed in the future, "
                   "please use -bytespersigcheck instead.",
                   DEFAULT_BYTES_PER_SIGCHECK),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-datacarrier",
         strprintf("Relay and mine data carrier transactions (default: %d)",
                   DEFAULT_ACCEPT_DATACARRIER),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-datacarriersize",
         strprintf("Maximum size of data in data carrier transactions "
                   "we relay and mine (default: %u)",
                   MAX_OP_RETURN_RELAY),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-minrelaytxfee=<amt>",
         strprintf("Fees (in %s/kB) smaller than this are rejected for "
                   "relaying, mining and transaction creation (default: %s)",
                   ticker, FormatMoney(DEFAULT_MIN_RELAY_TX_FEE_PER_KB)),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-whitelistrelay",
         strprintf("Add 'relay' permission to whitelisted inbound peers "
                   "with default permissions. This will accept relayed "
                   "transactions even when not relaying transactions "
                   "(default: %d)",
                   DEFAULT_WHITELISTRELAY),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     argsman.AddArg(
         "-whitelistforcerelay",
         strprintf("Add 'forcerelay' permission to whitelisted inbound peers"
                   " with default permissions. This will relay transactions "
                   "even if the transactions were already in the mempool "
                   "(default: %d)",
                   DEFAULT_WHITELISTFORCERELAY),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
 
     // Not sure this really belongs here, but it will do for now.
     // FIXME: This doesn't work anyways.
     argsman.AddArg("-excessutxocharge=<amt>",
                    strprintf("Fees (in %s/kB) to charge per utxo created for "
                              "relaying, and mining (default: %s)",
                              ticker, FormatMoney(DEFAULT_UTXO_FEE)),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::NODE_RELAY);
 
     argsman.AddArg("-blockmaxsize=<n>",
                    strprintf("Set maximum block size in bytes (default: %d)",
                              DEFAULT_MAX_GENERATED_BLOCK_SIZE),
                    ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
     argsman.AddArg(
         "-blockmintxfee=<amt>",
         strprintf("Set lowest fee rate (in %s/kB) for transactions to "
                   "be included in block creation. (default: %s)",
                   ticker, FormatMoney(DEFAULT_BLOCK_MIN_TX_FEE_PER_KB)),
         ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
 
     argsman.AddArg("-blockversion=<n>",
                    "Override block version to test forking scenarios",
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::BLOCK_CREATION);
 
     argsman.AddArg("-server", "Accept command line and JSON-RPC commands",
                    ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg("-rest",
                    strprintf("Accept public REST requests (default: %d)",
                              DEFAULT_REST_ENABLE),
                    ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcbind=<addr>[:port]",
         "Bind to given address to listen for JSON-RPC connections. Do not "
         "expose the RPC server to untrusted networks such as the public "
         "internet! This option is ignored unless -rpcallowip is also passed. "
         "Port is optional and overrides -rpcport.  Use [host]:port notation "
         "for IPv6. This option can be specified multiple times (default: "
         "127.0.0.1 and ::1 i.e., localhost)",
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY |
             ArgsManager::SENSITIVE,
         OptionsCategory::RPC);
     argsman.AddArg(
         "-rpccookiefile=<loc>",
         "Location of the auth cookie. Relative paths will be prefixed "
         "by a net-specific datadir location. (default: data dir)",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections",
                    ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE,
                    OptionsCategory::RPC);
     argsman.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections",
                    ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE,
                    OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcwhitelist=<whitelist>",
         "Set a whitelist to filter incoming RPC calls for a specific user. The "
         "field <whitelist> comes in the format: <USERNAME>:<rpc 1>,<rpc "
         "2>,...,<rpc n>. If multiple whitelists are set for a given user, they "
         "are set-intersected. See -rpcwhitelistdefault documentation for "
         "information on default whitelist behavior.",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcwhitelistdefault",
         "Sets default behavior for rpc whitelisting. Unless "
         "rpcwhitelistdefault is set to 0, if any -rpcwhitelist is set, the rpc "
         "server acts as if all rpc users are subject to "
         "empty-unless-otherwise-specified whitelists. If rpcwhitelistdefault "
         "is set to 1 and no -rpcwhitelist is set, rpc server acts as if all "
         "rpc users are subject to empty whitelists.",
         ArgsManager::ALLOW_BOOL, OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcauth=<userpw>",
         "Username and HMAC-SHA-256 hashed password for JSON-RPC connections. "
         "The field <userpw> comes in the format: <USERNAME>:<SALT>$<HASH>. A "
         "canonical python script is included in share/rpcauth. The client then "
         "connects normally using the rpcuser=<USERNAME>/rpcpassword=<PASSWORD> "
         "pair of arguments. This option can be specified multiple times",
         ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE, OptionsCategory::RPC);
     argsman.AddArg("-rpcport=<port>",
                    strprintf("Listen for JSON-RPC connections on <port> "
                              "(default: %u, testnet: %u, regtest: %u)",
                              defaultBaseParams->RPCPort(),
                              testnetBaseParams->RPCPort(),
                              regtestBaseParams->RPCPort()),
                    ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                    OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcallowip=<ip>",
         "Allow JSON-RPC connections from specified source. Valid for "
         "<ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. "
         "1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). "
         "This option can be specified multiple times",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg(
         "-rpcthreads=<n>",
         strprintf(
             "Set the number of threads to service RPC calls (default: %d)",
             DEFAULT_HTTP_THREADS),
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     argsman.AddArg(
         "-rpccorsdomain=value",
         "Domain from which to accept cross origin requests (browser enforced)",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
 
     argsman.AddArg("-rpcworkqueue=<n>",
                    strprintf("Set the depth of the work queue to service RPC "
                              "calls (default: %d)",
                              DEFAULT_HTTP_WORKQUEUE),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::RPC);
     argsman.AddArg("-rpcservertimeout=<n>",
                    strprintf("Timeout during HTTP requests (default: %d)",
                              DEFAULT_HTTP_SERVER_TIMEOUT),
                    ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                    OptionsCategory::RPC);
 
 #if HAVE_DECL_FORK
     argsman.AddArg("-daemon",
                    strprintf("Run in the background as a daemon and accept "
                              "commands (default: %d)",
                              DEFAULT_DAEMON),
                    ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
     argsman.AddArg("-daemonwait",
                    strprintf("Wait for initialization to be finished before "
                              "exiting. This implies -daemon (default: %d)",
                              DEFAULT_DAEMONWAIT),
                    ArgsManager::ALLOW_BOOL, OptionsCategory::OPTIONS);
 #else
     hidden_args.emplace_back("-daemon");
     hidden_args.emplace_back("-daemonwait");
 #endif
 
     // Avalanche options.
     argsman.AddArg("-avalanche",
                    strprintf("Enable the avalanche feature (default: %u)",
                              AVALANCHE_DEFAULT_ENABLED),
                    ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg("-avalancheconflictingproofcooldown",
                    strprintf("Mandatory cooldown before a proof conflicting "
                              "with an already registered one can be considered "
                              "in seconds (default: %u)",
                              AVALANCHE_DEFAULT_CONFLICTING_PROOF_COOLDOWN),
                    ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg("-avalanchepeerreplacementcooldown",
                    strprintf("Mandatory cooldown before a peer can be replaced "
                              "in seconds (default: %u)",
                              AVALANCHE_DEFAULT_PEER_REPLACEMENT_COOLDOWN),
                    ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avaminquorumstake",
         strprintf(
             "Minimum amount of known stake for a usable quorum (default: %s)",
             FormatMoney(AVALANCHE_DEFAULT_MIN_QUORUM_STAKE)),
         ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avaminquorumconnectedstakeratio",
         strprintf("Minimum proportion of known stake we"
                   " need nodes for to have a usable quorum (default: %s)",
                   AVALANCHE_DEFAULT_MIN_QUORUM_CONNECTED_STAKE_RATIO),
         ArgsManager::ALLOW_STRING, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avaminavaproofsnodecount",
         strprintf("Minimum number of node that needs to send us an avaproofs"
                   " message before we consider we have a usable quorum"
                   " (default: %s)",
                   AVALANCHE_DEFAULT_MIN_AVAPROOFS_NODE_COUNT),
         ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avastalevotethreshold",
         strprintf("Number of avalanche votes before a voted item goes stale "
                   "when voting confidence is low (default: %u)",
                   AVALANCHE_VOTE_STALE_THRESHOLD),
         ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avastalevotefactor",
         strprintf(
             "Factor affecting the number of avalanche votes before a voted "
             "item goes stale when voting confidence is high (default: %u)",
             AVALANCHE_VOTE_STALE_FACTOR),
         ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
     argsman.AddArg("-avacooldown",
                    strprintf("Mandatory cooldown between two avapoll in "
                              "milliseconds (default: %u)",
                              AVALANCHE_DEFAULT_COOLDOWN),
                    ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avatimeout",
         strprintf("Avalanche query timeout in milliseconds (default: %u)",
                   AVALANCHE_DEFAULT_QUERY_TIMEOUT.count()),
         ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avadelegation",
         "Avalanche proof delegation to the master key used by this node "
         "(default: none). Should be used in conjunction with -avaproof and "
         "-avamasterkey",
         ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg("-avaproof",
                    "Avalanche proof to be used by this node (default: none)",
                    ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     argsman.AddArg(
         "-avaproofstakeutxoconfirmations",
         strprintf(
             "Minimum number of confirmations before a stake utxo is mature"
             " enough to be included into a proof. Utxos in the mempool are not "
             "accepted (i.e this value must be greater than 0) (default: %s)",
             AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS),
         ArgsManager::ALLOW_INT, OptionsCategory::HIDDEN);
     argsman.AddArg("-avaproofstakeutxodustthreshold",
                    strprintf("Minimum value each stake utxo must have to be "
                              "considered valid (default: %s)",
                              avalanche::PROOF_DUST_THRESHOLD),
                    ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
     argsman.AddArg("-avamasterkey",
                    "Master key associated with the proof. If a proof is "
                    "required, this is mandatory.",
                    ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE,
                    OptionsCategory::AVALANCHE);
     argsman.AddArg("-avasessionkey", "Avalanche session key (default: random)",
                    ArgsManager::ALLOW_ANY | ArgsManager::SENSITIVE,
                    OptionsCategory::HIDDEN);
     argsman.AddArg(
         "-maxavalancheoutbound",
         strprintf(
             "Set the maximum number of avalanche outbound peers to connect to. "
             "Note that the -maxconnections option takes precedence (default: "
             "%u).",
             DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS),
         ArgsManager::ALLOW_INT, OptionsCategory::AVALANCHE);
 
     hidden_args.emplace_back("-avalanchepreconsensus");
 
     // Add the hidden options
     argsman.AddHiddenArgs(hidden_args);
 }
 
 std::string LicenseInfo() {
     const std::string URL_SOURCE_CODE =
         "<https://github.com/Bitcoin-ABC/bitcoin-abc>";
     const std::string URL_WEBSITE = "<https://www.bitcoinabc.org>";
 
     return CopyrightHolders(strprintf(_("Copyright (C) %i-%i").translated, 2009,
                                       COPYRIGHT_YEAR) +
                             " ") +
            "\n" + "\n" +
            strprintf(_("Please contribute if you find %s useful. "
                        "Visit %s for further information about the software.")
                          .translated,
                      PACKAGE_NAME, URL_WEBSITE) +
            "\n" +
            strprintf(_("The source code is available from %s.").translated,
                      URL_SOURCE_CODE) +
            "\n" + "\n" + _("This is experimental software.").translated + "\n" +
            strprintf(_("Distributed under the MIT software license, see the "
                        "accompanying file %s or %s")
                          .translated,
                      "COPYING", "<https://opensource.org/licenses/MIT>") +
            "\n" + "\n" +
            strprintf(_("This product includes software developed by the "
                        "OpenSSL Project for use in the OpenSSL Toolkit %s and "
                        "cryptographic software written by Eric Young and UPnP "
                        "software written by Thomas Bernard.")
                          .translated,
                      "<https://www.openssl.org>") +
            "\n";
 }
 
 static bool fHaveGenesis = false;
 static Mutex g_genesis_wait_mutex;
 static std::condition_variable g_genesis_wait_cv;
 
 static void BlockNotifyGenesisWait(const CBlockIndex *pBlockIndex) {
     if (pBlockIndex != nullptr) {
         {
             LOCK(g_genesis_wait_mutex);
             fHaveGenesis = true;
         }
         g_genesis_wait_cv.notify_all();
     }
 }
 
 #if HAVE_SYSTEM
 static void StartupNotify(const ArgsManager &args) {
     std::string cmd = args.GetArg("-startupnotify", "");
     if (!cmd.empty()) {
         std::thread t(runCommand, cmd);
         // thread runs free
         t.detach();
     }
 }
 #endif
 
 static bool AppInitServers(Config &config,
                            HTTPRPCRequestProcessor &httpRPCRequestProcessor,
                            NodeContext &node) {
     const ArgsManager &args = *Assert(node.args);
     RPCServerSignals::OnStarted(&OnRPCStarted);
     RPCServerSignals::OnStopped(&OnRPCStopped);
     if (!InitHTTPServer(config)) {
         return false;
     }
 
     StartRPC();
     node.rpc_interruption_point = RpcInterruptionPoint;
 
     if (!StartHTTPRPC(httpRPCRequestProcessor)) {
         return false;
     }
     if (args.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) {
         StartREST(&node);
     }
 
     StartHTTPServer();
     return true;
 }
 
 // Parameter interaction based on rules
 void InitParameterInteraction(ArgsManager &args) {
     // when specifying an explicit binding address, you want to listen on it
     // even when -connect or -proxy is specified.
     if (args.IsArgSet("-bind")) {
         if (args.SoftSetBoolArg("-listen", true)) {
             LogPrintf(
                 "%s: parameter interaction: -bind set -> setting -listen=1\n",
                 __func__);
         }
     }
     if (args.IsArgSet("-whitebind")) {
         if (args.SoftSetBoolArg("-listen", true)) {
             LogPrintf("%s: parameter interaction: -whitebind set -> setting "
                       "-listen=1\n",
                       __func__);
         }
     }
 
     if (args.IsArgSet("-connect")) {
         // when only connecting to trusted nodes, do not seed via DNS, or listen
         // by default.
         if (args.SoftSetBoolArg("-dnsseed", false)) {
             LogPrintf("%s: parameter interaction: -connect set -> setting "
                       "-dnsseed=0\n",
                       __func__);
         }
         if (args.SoftSetBoolArg("-listen", false)) {
             LogPrintf("%s: parameter interaction: -connect set -> setting "
                       "-listen=0\n",
                       __func__);
         }
     }
 
     if (args.IsArgSet("-proxy")) {
         // to protect privacy, do not listen by default if a default proxy
         // server is specified.
         if (args.SoftSetBoolArg("-listen", false)) {
             LogPrintf(
                 "%s: parameter interaction: -proxy set -> setting -listen=0\n",
                 __func__);
         }
         // to protect privacy, do not map ports when a proxy is set. The user
         // may still specify -listen=1 to listen locally, so don't rely on this
         // happening through -listen below.
         if (args.SoftSetBoolArg("-upnp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -proxy set -> setting -upnp=0\n",
                 __func__);
         }
         if (args.SoftSetBoolArg("-natpmp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -proxy set -> setting -natpmp=0\n",
                 __func__);
         }
         // to protect privacy, do not discover addresses by default
         if (args.SoftSetBoolArg("-discover", false)) {
             LogPrintf("%s: parameter interaction: -proxy set -> setting "
                       "-discover=0\n",
                       __func__);
         }
     }
 
     if (!args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
         // do not map ports or try to retrieve public IP when not listening
         // (pointless)
         if (args.SoftSetBoolArg("-upnp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -listen=0 -> setting -upnp=0\n",
                 __func__);
         }
         if (args.SoftSetBoolArg("-natpmp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -listen=0 -> setting -natpmp=0\n",
                 __func__);
         }
         if (args.SoftSetBoolArg("-discover", false)) {
             LogPrintf(
                 "%s: parameter interaction: -listen=0 -> setting -discover=0\n",
                 __func__);
         }
         if (args.SoftSetBoolArg("-listenonion", false)) {
             LogPrintf("%s: parameter interaction: -listen=0 -> setting "
                       "-listenonion=0\n",
                       __func__);
         }
         if (args.SoftSetBoolArg("-i2pacceptincoming", false)) {
             LogPrintf("%s: parameter interaction: -listen=0 -> setting "
                       "-i2pacceptincoming=0\n",
                       __func__);
         }
     }
 
     if (args.IsArgSet("-externalip")) {
         // if an explicit public IP is specified, do not try to find others
         if (args.SoftSetBoolArg("-discover", false)) {
             LogPrintf("%s: parameter interaction: -externalip set -> setting "
                       "-discover=0\n",
                       __func__);
         }
     }
 
     // disable whitelistrelay in blocksonly mode
     if (args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
         if (args.SoftSetBoolArg("-whitelistrelay", false)) {
             LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting "
                       "-whitelistrelay=0\n",
                       __func__);
         }
     }
 
     // Forcing relay from whitelisted hosts implies we will accept relays from
     // them in the first place.
     if (args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
         if (args.SoftSetBoolArg("-whitelistrelay", true)) {
             LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> "
                       "setting -whitelistrelay=1\n",
                       __func__);
         }
     }
 
     // If avalanche is set, soft set all the feature flags accordingly.
     if (args.IsArgSet("-avalanche")) {
         const bool fAvalanche =
             args.GetBoolArg("-avalanche", AVALANCHE_DEFAULT_ENABLED);
         args.SoftSetBoolArg("-automaticunparking", !fAvalanche);
     }
 }
 
 /**
  * Initialize global loggers.
  *
  * Note that this is called very early in the process lifetime, so you should be
  * careful about what global state you rely on here.
  */
 void InitLogging(const ArgsManager &args) {
     init::SetLoggingOptions(args);
     init::LogPackageVersion();
 }
 
 namespace { // Variables internal to initialization process only
 
 int nMaxConnections;
 int nUserMaxConnections;
 int nFD;
 ServiceFlags nLocalServices = ServiceFlags(NODE_NETWORK | NODE_NETWORK_LIMITED);
 int64_t peer_connect_timeout;
 std::set<BlockFilterType> g_enabled_filter_types;
 
 } // namespace
 
 [[noreturn]] static void new_handler_terminate() {
     // Rather than throwing std::bad-alloc if allocation fails, terminate
     // immediately to (try to) avoid chain corruption. Since LogPrintf may
     // itself allocate memory, set the handler directly to terminate first.
     std::set_new_handler(std::terminate);
     LogPrintf("Error: Out of memory. Terminating.\n");
 
     // The log was successful, terminate now.
     std::terminate();
 };
 
 bool AppInitBasicSetup(const ArgsManager &args) {
 // Step 1: setup
 #ifdef _MSC_VER
     // Turn off Microsoft heap dump noise
     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
     _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, nullptr,
                                              OPEN_EXISTING, 0, 0));
     // Disable confusing "helpful" text message on abort, Ctrl-C
     _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
 #endif
 #ifdef WIN32
     // Enable Data Execution Prevention (DEP)
     SetProcessDEPPolicy(PROCESS_DEP_ENABLE);
 #endif
     if (!InitShutdownState()) {
         return InitError(
             Untranslated("Initializing wait-for-shutdown state failed."));
     }
 
     if (!SetupNetworking()) {
         return InitError(Untranslated("Initializing networking failed"));
     }
 
 #ifndef WIN32
     if (!args.GetBoolArg("-sysperms", false)) {
         umask(077);
     }
 
     // Clean shutdown on SIGTERM
     registerSignalHandler(SIGTERM, HandleSIGTERM);
     registerSignalHandler(SIGINT, HandleSIGTERM);
 
     // Reopen debug.log on SIGHUP
     registerSignalHandler(SIGHUP, HandleSIGHUP);
 
     // Ignore SIGPIPE, otherwise it will bring the daemon down if the client
     // closes unexpectedly
     signal(SIGPIPE, SIG_IGN);
 #else
     SetConsoleCtrlHandler(consoleCtrlHandler, true);
 #endif
 
     std::set_new_handler(new_handler_terminate);
 
     return true;
 }
 
 bool AppInitParameterInteraction(Config &config, const ArgsManager &args) {
     const CChainParams &chainparams = config.GetChainParams();
     // Step 2: parameter interactions
 
     // also see: InitParameterInteraction()
 
     // Error if network-specific options (-addnode, -connect, etc) are
     // specified in default section of config file, but not overridden
     // on the command line or in this network's section of the config file.
     std::string network = args.GetChainName();
     bilingual_str errors;
     for (const auto &arg : args.GetUnsuitableSectionOnlyArgs()) {
         errors += strprintf(_("Config setting for %s only applied on %s "
                               "network when in [%s] section.") +
                                 Untranslated("\n"),
                             arg, network, network);
     }
 
     if (!errors.empty()) {
         return InitError(errors);
     }
 
     // Warn if unrecognized section name are present in the config file.
     bilingual_str warnings;
     for (const auto &section : args.GetUnrecognizedSections()) {
         warnings += strprintf(Untranslated("%s:%i ") +
                                   _("Section [%s] is not recognized.") +
                                   Untranslated("\n"),
                               section.m_file, section.m_line, section.m_name);
     }
 
     if (!warnings.empty()) {
         InitWarning(warnings);
     }
 
     if (!fs::is_directory(args.GetBlocksDirPath())) {
         return InitError(
             strprintf(_("Specified blocks directory \"%s\" does not exist."),
                       args.GetArg("-blocksdir", "")));
     }
 
     // parse and validate enabled filter types
     std::string blockfilterindex_value =
         args.GetArg("-blockfilterindex", DEFAULT_BLOCKFILTERINDEX);
     if (blockfilterindex_value == "" || blockfilterindex_value == "1") {
         g_enabled_filter_types = AllBlockFilterTypes();
     } else if (blockfilterindex_value != "0") {
         const std::vector<std::string> names =
             args.GetArgs("-blockfilterindex");
         for (const auto &name : names) {
             BlockFilterType filter_type;
             if (!BlockFilterTypeByName(name, filter_type)) {
                 return InitError(
                     strprintf(_("Unknown -blockfilterindex value %s."), name));
             }
             g_enabled_filter_types.insert(filter_type);
         }
     }
 
     // Signal NODE_COMPACT_FILTERS if peerblockfilters and basic filters index
     // are both enabled.
     if (args.GetBoolArg("-peerblockfilters", DEFAULT_PEERBLOCKFILTERS)) {
         if (g_enabled_filter_types.count(BlockFilterType::BASIC) != 1) {
             return InitError(
                 _("Cannot set -peerblockfilters without -blockfilterindex."));
         }
 
         nLocalServices = ServiceFlags(nLocalServices | NODE_COMPACT_FILTERS);
     }
 
     // if using block pruning, then disallow txindex, coinstatsindex and chronik
     if (args.GetIntArg("-prune", 0)) {
         if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
             return InitError(_("Prune mode is incompatible with -txindex."));
         }
         if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
             return InitError(
                 _("Prune mode is incompatible with -coinstatsindex."));
         }
         if (args.GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
             return InitError(_("Prune mode is incompatible with -chronik."));
         }
     }
 
     // -bind and -whitebind can't be set when not listening
     size_t nUserBind =
         args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
     if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
         return InitError(Untranslated(
             "Cannot set -bind or -whitebind together with -listen=0"));
     }
 
     // Make sure enough file descriptors are available
     int nBind = std::max(nUserBind, size_t(1));
     nUserMaxConnections =
         args.GetIntArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
     nMaxConnections = std::max(nUserMaxConnections, 0);
 
     // Trim requested connection counts, to fit into system limitations
     // <int> in std::min<int>(...) to work around FreeBSD compilation issue
     // described in #2695
     nFD = RaiseFileDescriptorLimit(
         nMaxConnections + nBind + MIN_CORE_FILEDESCRIPTORS +
         MAX_ADDNODE_CONNECTIONS + NUM_FDS_MESSAGE_CAPTURE);
 #ifdef USE_POLL
     int fd_max = nFD;
 #else
     int fd_max = FD_SETSIZE;
 #endif
     nMaxConnections = std::max(
         std::min<int>(nMaxConnections,
                       fd_max - nBind - MIN_CORE_FILEDESCRIPTORS -
                           MAX_ADDNODE_CONNECTIONS - NUM_FDS_MESSAGE_CAPTURE),
         0);
     if (nFD < MIN_CORE_FILEDESCRIPTORS) {
         return InitError(_("Not enough file descriptors available."));
     }
     nMaxConnections =
         std::min(nFD - MIN_CORE_FILEDESCRIPTORS - MAX_ADDNODE_CONNECTIONS,
                  nMaxConnections);
 
     if (nMaxConnections < nUserMaxConnections) {
         // Not categorizing as "Warning" because this is the normal behavior for
         // platforms using the select() interface for which FD_SETSIZE is
         // usually 1024.
         LogPrintf("Reducing -maxconnections from %d to %d, because of system "
                   "limitations.\n",
                   nUserMaxConnections, nMaxConnections);
     }
 
     // Step 3: parameter-to-internal-flags
     init::SetLoggingCategories(args);
 
     fCheckBlockIndex = args.GetBoolArg("-checkblockindex",
                                        chainparams.DefaultConsistencyChecks());
     fCheckpointsEnabled =
         args.GetBoolArg("-checkpoints", DEFAULT_CHECKPOINTS_ENABLED);
     if (fCheckpointsEnabled) {
         LogPrintf("Checkpoints will be verified.\n");
     } else {
         LogPrintf("Skipping checkpoint verification.\n");
     }
 
     hashAssumeValid = BlockHash::fromHex(
         args.GetArg("-assumevalid",
                     chainparams.GetConsensus().defaultAssumeValid.GetHex()));
     if (!hashAssumeValid.IsNull()) {
         LogPrintf("Assuming ancestors of block %s have valid signatures.\n",
                   hashAssumeValid.GetHex());
     } else {
         LogPrintf("Validating signatures for all blocks.\n");
     }
 
     if (args.IsArgSet("-minimumchainwork")) {
         const std::string minChainWorkStr =
             args.GetArg("-minimumchainwork", "");
         if (!IsHexNumber(minChainWorkStr)) {
             return InitError(strprintf(
                 Untranslated(
                     "Invalid non-hex (%s) minimum chain work value specified"),
                 minChainWorkStr));
         }
         nMinimumChainWork = UintToArith256(uint256S(minChainWorkStr));
     } else {
         nMinimumChainWork =
             UintToArith256(chainparams.GetConsensus().nMinimumChainWork);
     }
     LogPrintf("Setting nMinimumChainWork=%s\n", nMinimumChainWork.GetHex());
     if (nMinimumChainWork <
         UintToArith256(chainparams.GetConsensus().nMinimumChainWork)) {
         LogPrintf("Warning: nMinimumChainWork set below default value of %s\n",
                   chainparams.GetConsensus().nMinimumChainWork.GetHex());
     }
 
     // mempool limits
     int64_t nMempoolSizeMax =
         args.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     int64_t nMempoolSizeMin =
         args.GetIntArg("-limitdescendantsize", DEFAULT_DESCENDANT_SIZE_LIMIT) *
         1000 * 40;
     if (nMempoolSizeMax < 0 || nMempoolSizeMax < nMempoolSizeMin) {
         return InitError(strprintf(_("-maxmempool must be at least %d MB"),
                                    std::ceil(nMempoolSizeMin / 1000000.0)));
     }
 
     // Configure excessive block size.
     const int64_t nProposedExcessiveBlockSize =
         args.GetIntArg("-excessiveblocksize", DEFAULT_MAX_BLOCK_SIZE);
     if (nProposedExcessiveBlockSize <= 0 ||
         !config.SetMaxBlockSize(nProposedExcessiveBlockSize)) {
         return InitError(
             _("Excessive block size must be > 1,000,000 bytes (1MB)"));
     }
 
     // Check blockmaxsize does not exceed maximum accepted block size.
     const int64_t nProposedMaxGeneratedBlockSize =
         args.GetIntArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE);
     if (nProposedMaxGeneratedBlockSize <= 0) {
         return InitError(_("Max generated block size must be greater than 0"));
     }
     if (uint64_t(nProposedMaxGeneratedBlockSize) > config.GetMaxBlockSize()) {
         return InitError(_("Max generated block size (blockmaxsize) cannot "
                            "exceed the excessive block size "
                            "(excessiveblocksize)"));
     }
 
     // block pruning; get the amount of disk space (in MiB) to allot for block &
     // undo files
     int64_t nPruneArg = args.GetIntArg("-prune", 0);
     if (nPruneArg < 0) {
         return InitError(
             _("Prune cannot be configured with a negative value."));
     }
     nPruneTarget = (uint64_t)nPruneArg * 1024 * 1024;
     if (nPruneArg == 1) {
         // manual pruning: -prune=1
         LogPrintf("Block pruning enabled.  Use RPC call "
                   "pruneblockchain(height) to manually prune block and undo "
                   "files.\n");
         nPruneTarget = std::numeric_limits<uint64_t>::max();
         fPruneMode = true;
     } else if (nPruneTarget) {
         if (nPruneTarget < MIN_DISK_SPACE_FOR_BLOCK_FILES) {
             return InitError(
                 strprintf(_("Prune configured below the minimum of %d MiB. "
                             "Please use a higher number."),
                           MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024));
         }
         LogPrintf("Prune configured to target %u MiB on disk for block and "
                   "undo files.\n",
                   nPruneTarget / 1024 / 1024);
         fPruneMode = true;
     }
 
     nConnectTimeout = args.GetIntArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
     if (nConnectTimeout <= 0) {
         nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;
     }
 
     peer_connect_timeout =
         args.GetIntArg("-peertimeout", DEFAULT_PEER_CONNECT_TIMEOUT);
     if (peer_connect_timeout <= 0) {
         return InitError(Untranslated(
             "peertimeout cannot be configured with a negative value."));
     }
 
     // Obtain the amount to charge excess UTXO
     if (args.IsArgSet("-excessutxocharge")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(args.GetArg("-excessutxocharge", ""), n);
         if (!parsed || Amount::zero() > n) {
             return InitError(AmountErrMsg(
                 "excessutxocharge", args.GetArg("-excessutxocharge", "")));
         }
         config.SetExcessUTXOCharge(n);
     } else {
         config.SetExcessUTXOCharge(DEFAULT_UTXO_FEE);
     }
 
     if (args.IsArgSet("-minrelaytxfee")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(args.GetArg("-minrelaytxfee", ""), n);
         if (!parsed || n == Amount::zero()) {
             return InitError(AmountErrMsg("minrelaytxfee",
                                           args.GetArg("-minrelaytxfee", "")));
         }
         // High fee check is done afterward in CWallet::Create()
         ::minRelayTxFee = CFeeRate(n);
     }
 
     // Sanity check argument for min fee for including tx in block
     // TODO: Harmonize which arguments need sanity checking and where that
     // happens.
     if (args.IsArgSet("-blockmintxfee")) {
         Amount n = Amount::zero();
         if (!ParseMoney(args.GetArg("-blockmintxfee", ""), n)) {
             return InitError(AmountErrMsg("blockmintxfee",
                                           args.GetArg("-blockmintxfee", "")));
         }
     }
 
     // Feerate used to define dust.  Shouldn't be changed lightly as old
     // implementations may inadvertently create non-standard transactions.
     if (args.IsArgSet("-dustrelayfee")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(args.GetArg("-dustrelayfee", ""), n);
         if (!parsed || Amount::zero() == n) {
             return InitError(
                 AmountErrMsg("dustrelayfee", args.GetArg("-dustrelayfee", "")));
         }
         dustRelayFee = CFeeRate(n);
     }
 
     fRequireStandard =
         !args.GetBoolArg("-acceptnonstdtxn", !chainparams.RequireStandard());
     if (!chainparams.IsTestChain() && !fRequireStandard) {
         return InitError(strprintf(
             Untranslated(
                 "acceptnonstdtxn is not currently supported for %s chain"),
             chainparams.NetworkIDString()));
     }
     nBytesPerSigCheck =
         args.IsArgSet("-bytespersigcheck")
             ? args.GetIntArg("-bytespersigcheck", nBytesPerSigCheck)
             : args.GetIntArg("-bytespersigop", nBytesPerSigCheck);
 
     if (!g_wallet_init_interface.ParameterInteraction()) {
         return false;
     }
 
     fIsBareMultisigStd =
         args.GetBoolArg("-permitbaremultisig", DEFAULT_PERMIT_BAREMULTISIG);
     fAcceptDatacarrier =
         args.GetBoolArg("-datacarrier", DEFAULT_ACCEPT_DATACARRIER);
 
     // Option to startup with mocktime set (used for regression testing):
     SetMockTime(args.GetIntArg("-mocktime", 0)); // SetMockTime(0) is a no-op
 
     if (args.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS)) {
         nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM);
     }
 
     nMaxTipAge = args.GetIntArg("-maxtipage", DEFAULT_MAX_TIP_AGE);
 
     if (args.IsArgSet("-proxy") && args.GetArg("-proxy", "").empty()) {
         return InitError(_(
             "No proxy server specified. Use -proxy=<ip> or -proxy=<ip:port>."));
     }
 
     // Avalanche parameters
     const int64_t stakeUtxoMinConfirmations =
         args.GetIntArg("-avaproofstakeutxoconfirmations",
                        AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS);
 
     if (!chainparams.IsTestChain() &&
         stakeUtxoMinConfirmations !=
             AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS) {
         return InitError(_("Avalanche stake UTXO minimum confirmations can "
                            "only be set on test chains."));
     }
 
     if (stakeUtxoMinConfirmations <= 0) {
         return InitError(_("Avalanche stake UTXO minimum confirmations must be "
                            "a positive integer."));
     }
 
     if (args.IsArgSet("-avaproofstakeutxodustthreshold")) {
         Amount amount = Amount::zero();
         auto parsed = ParseMoney(
             args.GetArg("-avaproofstakeutxodustthreshold", ""), amount);
         if (!parsed || Amount::zero() == amount) {
             return InitError(AmountErrMsg(
                 "avaproofstakeutxodustthreshold",
                 args.GetArg("-avaproofstakeutxodustthreshold", "")));
         }
 
         if (!chainparams.IsTestChain() &&
             amount != avalanche::PROOF_DUST_THRESHOLD) {
             return InitError(_("Avalanche stake UTXO dust threshold can "
                                "only be set on test chains."));
         }
     }
 
     return true;
 }
 
 static bool LockDataDirectory(bool probeOnly) {
     // Make sure only a single Bitcoin process is using the data directory.
     fs::path datadir = gArgs.GetDataDirNet();
     if (!DirIsWritable(datadir)) {
         return InitError(strprintf(
             _("Cannot write to data directory '%s'; check permissions."),
             fs::PathToString(datadir)));
     }
     if (!LockDirectory(datadir, ".lock", probeOnly)) {
         return InitError(strprintf(_("Cannot obtain a lock on data directory "
                                      "%s. %s is probably already running."),
                                    fs::PathToString(datadir), PACKAGE_NAME));
     }
     return true;
 }
 
 bool AppInitSanityChecks() {
     // Step 4: sanity checks
 
     init::SetGlobals();
 
     // Sanity check
     if (!init::SanityChecks()) {
         return InitError(strprintf(
             _("Initialization sanity check failed. %s is shutting down."),
             PACKAGE_NAME));
     }
 
     // Probe the data directory lock to give an early error message, if possible
     // We cannot hold the data directory lock here, as the forking for daemon()
     // hasn't yet happened, and a fork will cause weird behavior to it.
     return LockDataDirectory(true);
 }
 
 bool AppInitLockDataDirectory() {
     // After daemonization get the data directory lock again and hold on to it
     // until exit. This creates a slight window for a race condition to happen,
     // however this condition is harmless: it will at most make us exit without
     // printing a message to console.
     if (!LockDataDirectory(false)) {
         // Detailed error printed inside LockDataDirectory
         return false;
     }
     return true;
 }
 
 bool AppInitInterfaces(NodeContext &node) {
     node.chain = interfaces::MakeChain(node, Params());
     // Create client interfaces for wallets that are supposed to be loaded
     // according to -wallet and -disablewallet options. This only constructs
     // the interfaces, it doesn't load wallet data. Wallets actually get loaded
     // when load() and start() interface methods are called below.
     g_wallet_init_interface.Construct(node);
     return true;
 }
 
 bool AppInitMain(Config &config, RPCServer &rpcServer,
                  HTTPRPCRequestProcessor &httpRPCRequestProcessor,
                  NodeContext &node,
                  interfaces::BlockAndHeaderTipInfo *tip_info) {
     // Step 4a: application initialization
     const ArgsManager &args = *Assert(node.args);
     const CChainParams &chainparams = config.GetChainParams();
 
     if (!CreatePidFile(args)) {
         // Detailed error printed inside CreatePidFile().
         return false;
     }
     if (!init::StartLogging(args)) {
         // Detailed error printed inside StartLogging().
         return false;
     }
 
     LogPrintf("Using at most %i automatic connections (%i file descriptors "
               "available)\n",
               nMaxConnections, nFD);
 
     // Warn about relative -datadir path.
     if (args.IsArgSet("-datadir") &&
         !fs::PathFromString(args.GetArg("-datadir", "")).is_absolute()) {
         LogPrintf("Warning: relative datadir option '%s' specified, which will "
                   "be interpreted relative to the current working directory "
                   "'%s'. This is fragile, because if bitcoin is started in the "
                   "future from a different location, it will be unable to "
                   "locate the current data files. There could also be data "
                   "loss if bitcoin is started while in a temporary "
                   "directory.\n",
                   args.GetArg("-datadir", ""),
                   fs::PathToString(fs::current_path()));
     }
 
     InitSignatureCache();
     InitScriptExecutionCache();
 
     int script_threads = args.GetIntArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
     if (script_threads <= 0) {
         // -par=0 means autodetect (number of cores - 1 script threads)
         // -par=-n means "leave n cores free" (number of cores - n - 1 script
         // threads)
         script_threads += GetNumCores();
     }
 
     // Subtract 1 because the main thread counts towards the par threads
     script_threads = std::max(script_threads - 1, 0);
 
     // Number of script-checking threads <= MAX_SCRIPTCHECK_THREADS
     script_threads = std::min(script_threads, MAX_SCRIPTCHECK_THREADS);
 
     LogPrintf("Script verification uses %d additional threads\n",
               script_threads);
     if (script_threads >= 1) {
         StartScriptCheckWorkerThreads(script_threads);
     }
 
     assert(!node.scheduler);
     node.scheduler = std::make_unique<CScheduler>();
 
     // Start the lightweight task scheduler thread
     node.scheduler->m_service_thread =
         std::thread(&util::TraceThread, "scheduler",
                     [&] { node.scheduler->serviceQueue(); });
 
     // Gather some entropy once per minute.
     node.scheduler->scheduleEvery(
         [] {
             RandAddPeriodic();
             return true;
         },
         std::chrono::minutes{1});
 
     GetMainSignals().RegisterBackgroundSignalScheduler(*node.scheduler);
 
     /**
      * Register RPC commands regardless of -server setting so they will be
      * available in the GUI RPC console even if external calls are disabled.
      */
     RegisterAllRPCCommands(config, rpcServer, tableRPC);
     for (const auto &client : node.chain_clients) {
         client->registerRpcs();
     }
 #if ENABLE_ZMQ
     RegisterZMQRPCCommands(tableRPC);
 #endif
 
     /**
      * Start the RPC server.  It will be started in "warmup" mode and not
      * process calls yet (but it will verify that the server is there and will
      * be ready later).  Warmup mode will be completed when initialisation is
      * finished.
      */
     if (args.GetBoolArg("-server", false)) {
         uiInterface.InitMessage_connect(SetRPCWarmupStatus);
         if (!AppInitServers(config, httpRPCRequestProcessor, node)) {
             return InitError(
                 _("Unable to start HTTP server. See debug log for details."));
         }
     }
 
     // Step 5: verify wallet database integrity
     for (const auto &client : node.chain_clients) {
         if (!client->verify()) {
             return false;
         }
     }
 
     // Step 6: network initialization
 
     // Note that we absolutely cannot open any actual connections
     // until the very end ("start node") as the UTXO/block state
     // is not yet setup and may end up being set up twice if we
     // need to reindex later.
 
     fListen = args.GetBoolArg("-listen", DEFAULT_LISTEN);
     fDiscover = args.GetBoolArg("-discover", true);
 
     {
         // Initialize addrman
         assert(!node.addrman);
 
         // Read asmap file if configured
         std::vector<bool> asmap;
         if (args.IsArgSet("-asmap")) {
             fs::path asmap_path = fs::PathFromString(args.GetArg("-asmap", ""));
             if (asmap_path.empty()) {
                 asmap_path = fs::PathFromString(DEFAULT_ASMAP_FILENAME);
             }
             if (!asmap_path.is_absolute()) {
                 asmap_path = args.GetDataDirNet() / asmap_path;
             }
             if (!fs::exists(asmap_path)) {
                 InitError(strprintf(_("Could not find asmap file %s"),
                                     fs::quoted(fs::PathToString(asmap_path))));
                 return false;
             }
             asmap = DecodeAsmap(asmap_path);
             if (asmap.size() == 0) {
                 InitError(strprintf(_("Could not parse asmap file %s"),
                                     fs::quoted(fs::PathToString(asmap_path))));
                 return false;
             }
             const uint256 asmap_version = SerializeHash(asmap);
             LogPrintf("Using asmap version %s for IP bucketing\n",
                       asmap_version.ToString());
         } else {
             LogPrintf("Using /16 prefix for IP bucketing\n");
         }
 
         uiInterface.InitMessage(_("Loading P2P addresses...").translated);
         if (const auto error{
                 LoadAddrman(chainparams, asmap, args, node.addrman)}) {
             return InitError(*error);
         }
     }
 
     assert(!node.banman);
     node.banman = std::make_unique<BanMan>(
         args.GetDataDirNet() / "banlist.dat", config.GetChainParams(),
         &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
     assert(!node.connman);
     node.connman = std::make_unique<CConnman>(
         config, GetRand(std::numeric_limits<uint64_t>::max()),
         GetRand(std::numeric_limits<uint64_t>::max()), *node.addrman,
         args.GetBoolArg("-networkactive", true));
 
     // sanitize comments per BIP-0014, format user agent and check total size
     std::vector<std::string> uacomments;
     for (const std::string &cmt : args.GetArgs("-uacomment")) {
         if (cmt != SanitizeString(cmt, SAFE_CHARS_UA_COMMENT)) {
             return InitError(strprintf(
                 _("User Agent comment (%s) contains unsafe characters."), cmt));
         }
         uacomments.push_back(cmt);
     }
     const std::string client_name = args.GetArg("-uaclientname", CLIENT_NAME);
     const std::string client_version =
         args.GetArg("-uaclientversion", FormatVersion(CLIENT_VERSION));
     if (client_name != SanitizeString(client_name, SAFE_CHARS_UA_COMMENT)) {
         return InitError(strprintf(
             _("-uaclientname (%s) contains invalid characters."), client_name));
     }
     if (client_version !=
         SanitizeString(client_version, SAFE_CHARS_UA_COMMENT)) {
         return InitError(
             strprintf(_("-uaclientversion (%s) contains invalid characters."),
                       client_version));
     }
     const std::string strSubVersion =
         FormatUserAgent(client_name, client_version, uacomments);
     if (strSubVersion.size() > MAX_SUBVERSION_LENGTH) {
         return InitError(strprintf(
             _("Total length of network version string (%i) exceeds maximum "
               "length (%i). Reduce the number or size of uacomments."),
             strSubVersion.size(), MAX_SUBVERSION_LENGTH));
     }
 
     if (args.IsArgSet("-onlynet")) {
         std::set<enum Network> nets;
         for (const std::string &snet : args.GetArgs("-onlynet")) {
             enum Network net = ParseNetwork(snet);
             if (net == NET_UNROUTABLE) {
                 return InitError(strprintf(
                     _("Unknown network specified in -onlynet: '%s'"), snet));
             }
             nets.insert(net);
         }
         for (int n = 0; n < NET_MAX; n++) {
             enum Network net = (enum Network)n;
             if (!nets.count(net)) {
                 SetReachable(net, false);
             }
         }
     }
 
     // Check for host lookup allowed before parsing any network related
     // parameters
     fNameLookup = args.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP);
 
     bool proxyRandomize =
         args.GetBoolArg("-proxyrandomize", DEFAULT_PROXYRANDOMIZE);
     // -proxy sets a proxy for all outgoing network traffic
     // -noproxy (or -proxy=0) as well as the empty string can be used to not set
     // a proxy, this is the default
     std::string proxyArg = args.GetArg("-proxy", "");
     SetReachable(NET_ONION, false);
     if (proxyArg != "" && proxyArg != "0") {
         CService proxyAddr;
         if (!Lookup(proxyArg, proxyAddr, 9050, fNameLookup)) {
             return InitError(strprintf(
                 _("Invalid -proxy address or hostname: '%s'"), proxyArg));
         }
 
         proxyType addrProxy = proxyType(proxyAddr, proxyRandomize);
         if (!addrProxy.IsValid()) {
             return InitError(strprintf(
                 _("Invalid -proxy address or hostname: '%s'"), proxyArg));
         }
 
         SetProxy(NET_IPV4, addrProxy);
         SetProxy(NET_IPV6, addrProxy);
         SetProxy(NET_ONION, addrProxy);
         SetNameProxy(addrProxy);
         // by default, -proxy sets onion as reachable, unless -noonion later
         SetReachable(NET_ONION, true);
     }
 
     // -onion can be used to set only a proxy for .onion, or override normal
     // proxy for .onion addresses.
     // -noonion (or -onion=0) disables connecting to .onion entirely. An empty
     // string is used to not override the onion proxy (in which case it defaults
     // to -proxy set above, or none)
     std::string onionArg = args.GetArg("-onion", "");
     if (onionArg != "") {
         if (onionArg == "0") {
             // Handle -noonion/-onion=0
             SetReachable(NET_ONION, false);
         } else {
             CService onionProxy;
             if (!Lookup(onionArg, onionProxy, 9050, fNameLookup)) {
                 return InitError(strprintf(
                     _("Invalid -onion address or hostname: '%s'"), onionArg));
             }
             proxyType addrOnion = proxyType(onionProxy, proxyRandomize);
             if (!addrOnion.IsValid()) {
                 return InitError(strprintf(
                     _("Invalid -onion address or hostname: '%s'"), onionArg));
             }
             SetProxy(NET_ONION, addrOnion);
             SetReachable(NET_ONION, true);
         }
     }
 
     for (const std::string &strAddr : args.GetArgs("-externalip")) {
         CService addrLocal;
         if (Lookup(strAddr, addrLocal, GetListenPort(), fNameLookup) &&
             addrLocal.IsValid()) {
             AddLocal(addrLocal, LOCAL_MANUAL);
         } else {
             return InitError(ResolveErrMsg("externalip", strAddr));
         }
     }
 
 #if ENABLE_ZMQ
     g_zmq_notification_interface = CZMQNotificationInterface::Create();
 
     if (g_zmq_notification_interface) {
         RegisterValidationInterface(g_zmq_notification_interface);
     }
 #endif
 
     // Step 7: load block chain
 
     fReindex = args.GetBoolArg("-reindex", false);
     bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false);
 
     // cache size calculations
     CacheSizes cache_sizes =
         CalculateCacheSizes(args, g_enabled_filter_types.size());
 
     int64_t nMempoolSizeMax =
         args.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     LogPrintf("Cache configuration:\n");
     LogPrintf("* Using %.1f MiB for block index database\n",
               cache_sizes.block_tree_db * (1.0 / 1024 / 1024));
     if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         LogPrintf("* Using %.1f MiB for transaction index database\n",
                   cache_sizes.tx_index * (1.0 / 1024 / 1024));
     }
     for (BlockFilterType filter_type : g_enabled_filter_types) {
         LogPrintf("* Using %.1f MiB for %s block filter index database\n",
                   cache_sizes.filter_index * (1.0 / 1024 / 1024),
                   BlockFilterTypeName(filter_type));
     }
     LogPrintf("* Using %.1f MiB for chain state database\n",
               cache_sizes.coins_db * (1.0 / 1024 / 1024));
     LogPrintf("* Using %.1f MiB for in-memory UTXO set (plus up to %.1f MiB of "
               "unused mempool space)\n",
               cache_sizes.coins * (1.0 / 1024 / 1024),
               nMempoolSizeMax * (1.0 / 1024 / 1024));
 
     assert(!node.mempool);
     assert(!node.chainman);
     const int mempool_check_ratio = std::clamp<int>(
         args.GetIntArg("-checkmempool",
                        chainparams.DefaultConsistencyChecks() ? 1 : 0),
         0, 1000000);
 
     for (bool fLoaded = false; !fLoaded && !ShutdownRequested();) {
         node.mempool = std::make_unique<CTxMemPool>(mempool_check_ratio);
 
         node.chainman = std::make_unique<ChainstateManager>();
         ChainstateManager &chainman = *node.chainman;
 
         const bool fReset = fReindex;
         bilingual_str strLoadError;
 
         uiInterface.InitMessage(_("Loading block index...").translated);
 
         const int64_t load_block_index_start_time = GetTimeMillis();
         std::optional<ChainstateLoadingError> rv;
 
         try {
             rv = LoadChainstate(
                 fReset, chainman, Assert(node.mempool.get()), fPruneMode,
                 chainparams.GetConsensus(), fReindexChainState,
                 cache_sizes.block_tree_db, cache_sizes.coins_db,
                 cache_sizes.coins, false, false, ShutdownRequested, []() {
                     uiInterface.ThreadSafeMessageBox(
                         _("Error reading from database, shutting down."), "",
                         CClientUIInterface::MSG_ERROR);
                 });
         } catch (const std::exception &e) {
             LogPrintf("%s\n", e.what());
             rv = ChainstateLoadingError::ERROR_GENERIC_BLOCKDB_OPEN_FAILED;
         }
 
         if (rv.has_value()) {
             switch (rv.value()) {
                 case ChainstateLoadingError::ERROR_UPGRADING_BLOCK_DB:
                     strLoadError = _("Error upgrading block index database");
                     break;
                 case ChainstateLoadingError::ERROR_LOADING_BLOCK_DB:
                     strLoadError = _("Error loading block database");
                     break;
                 case ChainstateLoadingError::ERROR_BAD_GENESIS_BLOCK:
                     // If the loaded chain has a wrong genesis, bail out
                     // immediately (we're likely using a testnet datadir, or
                     // the other way around).
                     return InitError(_("Incorrect or no genesis block found. "
                                        "Wrong datadir for network?"));
                 case ChainstateLoadingError::ERROR_PRUNED_NEEDS_REINDEX:
                     strLoadError =
                         _("You need to rebuild the database using -reindex to "
                           "go back to unpruned mode.  This will redownload the "
                           "entire blockchain");
                     break;
                 case ChainstateLoadingError::ERROR_LOAD_GENESIS_BLOCK_FAILED:
                     strLoadError = _("Error initializing block database");
                     break;
                 case ChainstateLoadingError::ERROR_CHAINSTATE_UPGRADE_FAILED:
                     strLoadError = _("Error upgrading chainstate database");
                     break;
                 case ChainstateLoadingError::ERROR_REPLAYBLOCKS_FAILED:
                     strLoadError =
                         _("Unable to replay blocks. You will need to rebuild "
                           "the database using -reindex-chainstate.");
                     break;
                 case ChainstateLoadingError::ERROR_LOADCHAINTIP_FAILED:
                     strLoadError = _("Error initializing block database");
                     break;
                 case ChainstateLoadingError::ERROR_GENERIC_BLOCKDB_OPEN_FAILED:
                     strLoadError = _("Error opening block database");
                     break;
                 case ChainstateLoadingError::SHUTDOWN_PROBED:
                     break;
             }
         } else {
             std::optional<ChainstateLoadVerifyError> rv2;
             try {
                 uiInterface.InitMessage(_("Verifying blocks…").translated);
 
                 auto check_blocks =
                     args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
                 if (chainman.m_blockman.m_have_pruned &&
                     check_blocks > MIN_BLOCKS_TO_KEEP) {
                     LogPrintf("Prune: pruned datadir may not have more than %d "
                               "blocks; only checking available blocks\n",
                               MIN_BLOCKS_TO_KEEP);
                 }
 
                 rv2 = VerifyLoadedChainstate(
                     chainman, fReset, fReindexChainState, config, check_blocks,
                     args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL),
                     static_cast<int64_t (*)()>(GetTime));
             } catch (const std::exception &e) {
                 LogPrintf("%s\n", e.what());
                 rv2 = ChainstateLoadVerifyError::ERROR_GENERIC_FAILURE;
             }
 
             if (rv2.has_value()) {
                 switch (rv2.value()) {
                     case ChainstateLoadVerifyError::ERROR_BLOCK_FROM_FUTURE:
                         strLoadError = _(
                             "The block database contains a block which appears "
                             "to be from the future. "
                             "This may be due to your computer's date and time "
                             "being set incorrectly. "
                             "Only rebuild the block database if you are sure "
                             "that your computer's date and time are correct");
                         break;
                     case ChainstateLoadVerifyError::ERROR_CORRUPTED_BLOCK_DB:
                         strLoadError = _("Corrupted block database detected");
                         break;
                     case ChainstateLoadVerifyError::ERROR_GENERIC_FAILURE:
                         strLoadError = _("Error opening block database");
                         break;
                 }
             } else {
                 fLoaded = true;
                 LogPrintf(" block index %15dms\n",
                           GetTimeMillis() - load_block_index_start_time);
             }
         }
 
         if (!fLoaded && !ShutdownRequested()) {
             // first suggest a reindex
             if (!fReset) {
                 bool fRet = uiInterface.ThreadSafeQuestion(
                     strLoadError + Untranslated(".\n\n") +
                         _("Do you want to rebuild the block database now?"),
                     strLoadError.original +
                         ".\nPlease restart with -reindex or "
                         "-reindex-chainstate to recover.",
                     "",
                     CClientUIInterface::MSG_ERROR |
                         CClientUIInterface::BTN_ABORT);
                 if (fRet) {
                     fReindex = true;
                     AbortShutdown();
                 } else {
                     LogPrintf("Aborted block database rebuild. Exiting.\n");
                     return false;
                 }
             } else {
                 return InitError(strLoadError);
             }
         }
     }
 
     // As LoadBlockIndex can take several minutes, it's possible the user
     // requested to kill the GUI during the last operation. If so, exit.
     // As the program has not fully started yet, Shutdown() is possibly
     // overkill.
     if (ShutdownRequested()) {
         LogPrintf("Shutdown requested. Exiting.\n");
         return false;
     }
 
     ChainstateManager &chainman = *Assert(node.chainman);
 
     assert(!node.peerman);
     node.peerman = PeerManager::make(
         chainparams, *node.connman, *node.addrman, node.banman.get(), chainman,
         *node.mempool, args.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY));
     RegisterValidationInterface(node.peerman.get());
 
     // Encoded addresses using cashaddr instead of base58.
     // We do this by default to avoid confusion with BTC addresses.
     config.SetCashAddrEncoding(args.GetBoolArg("-usecashaddr", true));
 
     // Step 7.5 (I guess ?): Initialize Avalanche.
     bilingual_str avalancheError;
     g_avalanche = avalanche::Processor::MakeProcessor(
         args, *node.chain, node.connman.get(), chainman, node.mempool.get(),
         *node.scheduler, avalancheError);
     if (!g_avalanche) {
         InitError(avalancheError);
         return false;
     }
 
     if (isAvalancheEnabled(args) &&
         g_avalanche->isAvalancheServiceAvailable()) {
         nLocalServices = ServiceFlags(nLocalServices | NODE_AVALANCHE);
     }
 
     // Step 8: load indexers
     if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         if (const auto error{CheckLegacyTxindex(
                 *Assert(chainman.m_blockman.m_block_tree_db))}) {
             return InitError(*error);
         }
 
         g_txindex =
             std::make_unique<TxIndex>(cache_sizes.tx_index, false, fReindex);
         g_txindex->Start(chainman.ActiveChainstate());
     }
 
     for (const auto &filter_type : g_enabled_filter_types) {
         InitBlockFilterIndex(filter_type, cache_sizes.filter_index, false,
                              fReindex);
         GetBlockFilterIndex(filter_type)->Start(chainman.ActiveChainstate());
     }
 
     if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {
         g_coin_stats_index = std::make_unique<CoinStatsIndex>(
             /* cache size */ 0, false, fReindex);
         g_coin_stats_index->Start(chainman.ActiveChainstate());
     }
 
 #if ENABLE_CHRONIK
     if (args.GetBoolArg("-chronik", DEFAULT_CHRONIK)) {
         const bool fReindexChronik =
             fReindex || args.GetBoolArg("-chronikreindex", false);
         if (!chronik::Start(config, node, fReindexChronik)) {
             return false;
         }
     }
 #endif
 
     // Step 9: load wallet
     for (const auto &client : node.chain_clients) {
         if (!client->load()) {
             return false;
         }
     }
 
     // Step 10: data directory maintenance
 
     // if pruning, unset the service bit and perform the initial blockstore
     // prune after any wallet rescanning has taken place.
     if (fPruneMode) {
         LogPrintf("Unsetting NODE_NETWORK on prune mode\n");
         nLocalServices = ServiceFlags(nLocalServices & ~NODE_NETWORK);
         if (!fReindex) {
             LOCK(cs_main);
             for (Chainstate *chainstate : chainman.GetAll()) {
                 uiInterface.InitMessage(_("Pruning blockstore...").translated);
                 chainstate->PruneAndFlush();
             }
         }
     }
 
     // Step 11: import blocks
     if (!CheckDiskSpace(args.GetDataDirNet())) {
         InitError(
             strprintf(_("Error: Disk space is low for %s"),
                       fs::quoted(fs::PathToString(args.GetDataDirNet()))));
         return false;
     }
     if (!CheckDiskSpace(args.GetBlocksDirPath())) {
         InitError(
             strprintf(_("Error: Disk space is low for %s"),
                       fs::quoted(fs::PathToString(args.GetBlocksDirPath()))));
         return false;
     }
 
     // Either install a handler to notify us when genesis activates, or set
     // fHaveGenesis directly.
     // No locking, as this happens before any background thread is started.
     boost::signals2::connection block_notify_genesis_wait_connection;
     if (chainman.ActiveTip() == nullptr) {
         block_notify_genesis_wait_connection =
             uiInterface.NotifyBlockTip_connect(
                 std::bind(BlockNotifyGenesisWait, std::placeholders::_2));
     } else {
         fHaveGenesis = true;
     }
 
 #if defined(HAVE_SYSTEM)
     const std::string block_notify = args.GetArg("-blocknotify", "");
     if (!block_notify.empty()) {
         uiInterface.NotifyBlockTip_connect([block_notify](
                                                SynchronizationState sync_state,
                                                const CBlockIndex *pBlockIndex) {
             if (sync_state != SynchronizationState::POST_INIT || !pBlockIndex) {
                 return;
             }
             std::string command = block_notify;
             ReplaceAll(command, "%s", pBlockIndex->GetBlockHash().GetHex());
             std::thread t(runCommand, command);
             // thread runs free
             t.detach();
         });
     }
 #endif
 
     std::vector<fs::path> vImportFiles;
     for (const std::string &strFile : args.GetArgs("-loadblock")) {
         vImportFiles.push_back(fs::PathFromString(strFile));
     }
 
     chainman.m_load_block = std::thread(
         &util::TraceThread, "loadblk", [=, &config, &chainman, &args] {
             ThreadImport(config, chainman, vImportFiles, args);
         });
 
     // Wait for genesis block to be processed
     {
         WAIT_LOCK(g_genesis_wait_mutex, lock);
         // We previously could hang here if StartShutdown() is called prior to
         // ThreadImport getting started, so instead we just wait on a timer to
         // check ShutdownRequested() regularly.
         while (!fHaveGenesis && !ShutdownRequested()) {
             g_genesis_wait_cv.wait_for(lock, std::chrono::milliseconds(500));
         }
         block_notify_genesis_wait_connection.disconnect();
     }
 
     if (ShutdownRequested()) {
         return false;
     }
 
     // Step 12: start node
 
     int chain_active_height;
 
     //// debug print
     {
         LOCK(cs_main);
         LogPrintf("block tree size = %u\n", chainman.BlockIndex().size());
         chain_active_height = chainman.ActiveChain().Height();
         if (tip_info) {
             tip_info->block_height = chain_active_height;
             tip_info->block_time =
                 chainman.ActiveChain().Tip()
                     ? chainman.ActiveChain().Tip()->GetBlockTime()
                     : Params().GenesisBlock().GetBlockTime();
             tip_info->verification_progress = GuessVerificationProgress(
                 Params().TxData(), chainman.ActiveChain().Tip());
         }
         if (tip_info && chainman.m_best_header) {
             tip_info->header_height = chainman.m_best_header->nHeight;
             tip_info->header_time = chainman.m_best_header->GetBlockTime();
         }
     }
     LogPrintf("nBestHeight = %d\n", chain_active_height);
     if (node.peerman) {
         node.peerman->SetBestHeight(chain_active_height);
     }
 
     Discover();
 
     // Map ports with UPnP or NAT-PMP.
     StartMapPort(args.GetBoolArg("-upnp", DEFAULT_UPNP),
                  args.GetBoolArg("-natpmp", DEFAULT_NATPMP));
 
     CConnman::Options connOptions;
     connOptions.nLocalServices = nLocalServices;
     connOptions.nMaxConnections = nMaxConnections;
     connOptions.m_max_avalanche_outbound = std::min<int64_t>(
         g_avalanche && isAvalancheEnabled(args)
             ? args.GetIntArg("-maxavalancheoutbound",
                              DEFAULT_MAX_AVALANCHE_OUTBOUND_CONNECTIONS)
             : 0,
         connOptions.nMaxConnections);
     connOptions.m_max_outbound_full_relay = std::min(
         MAX_OUTBOUND_FULL_RELAY_CONNECTIONS,
         connOptions.nMaxConnections - connOptions.m_max_avalanche_outbound);
     connOptions.m_max_outbound_block_relay = std::min(
         MAX_BLOCK_RELAY_ONLY_CONNECTIONS,
         connOptions.nMaxConnections - connOptions.m_max_avalanche_outbound -
             connOptions.m_max_outbound_full_relay);
     connOptions.nMaxAddnode = MAX_ADDNODE_CONNECTIONS;
     connOptions.nMaxFeeler = MAX_FEELER_CONNECTIONS;
     connOptions.uiInterface = &uiInterface;
     connOptions.m_banman = node.banman.get();
     connOptions.m_msgproc.push_back(node.peerman.get());
     if (g_avalanche) {
         connOptions.m_msgproc.push_back(g_avalanche.get());
     }
     connOptions.nSendBufferMaxSize =
         1000 * args.GetIntArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
     connOptions.nReceiveFloodSize =
         1000 * args.GetIntArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
     connOptions.m_added_nodes = args.GetArgs("-addnode");
 
     connOptions.nMaxOutboundLimit =
         1024 * 1024 *
         args.GetIntArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET);
     connOptions.m_peer_connect_timeout = peer_connect_timeout;
 
     const auto BadPortWarning = [](const char *prefix, uint16_t port) {
         return strprintf(_("%s request to listen on port %u. This port is "
                            "considered \"bad\" and "
                            "thus it is unlikely that any Bitcoin ABC peers "
                            "connect to it. See "
                            "doc/p2p-bad-ports.md for details and a full list."),
                          prefix, port);
     };
 
     for (const std::string &bind_arg : args.GetArgs("-bind")) {
         CService bind_addr;
         const size_t index = bind_arg.rfind('=');
         if (index == std::string::npos) {
             if (Lookup(bind_arg, bind_addr, GetListenPort(), false)) {
                 connOptions.vBinds.push_back(bind_addr);
                 if (IsBadPort(bind_addr.GetPort())) {
                     InitWarning(BadPortWarning("-bind", bind_addr.GetPort()));
                 }
                 continue;
             }
         } else {
             const std::string network_type = bind_arg.substr(index + 1);
             if (network_type == "onion") {
                 const std::string truncated_bind_arg =
                     bind_arg.substr(0, index);
                 if (Lookup(truncated_bind_arg, bind_addr,
                            BaseParams().OnionServiceTargetPort(), false)) {
                     connOptions.onion_binds.push_back(bind_addr);
                     continue;
                 }
             }
         }
         return InitError(ResolveErrMsg("bind", bind_arg));
     }
 
     for (const std::string &strBind : args.GetArgs("-whitebind")) {
         NetWhitebindPermissions whitebind;
         bilingual_str error;
         if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) {
             return InitError(error);
         }
         connOptions.vWhiteBinds.push_back(whitebind);
     }
 
     // If the user did not specify -bind= or -whitebind= then we bind
     // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
     connOptions.bind_on_any =
         args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
 
     // Emit a warning if a bad port is given to -port= but only if -bind and
     // -whitebind are not given, because if they are, then -port= is ignored.
     if (connOptions.bind_on_any && args.IsArgSet("-port")) {
         const uint16_t port_arg = args.GetIntArg("-port", 0);
         if (IsBadPort(port_arg)) {
             InitWarning(BadPortWarning("-port", port_arg));
         }
     }
 
     CService onion_service_target;
     if (!connOptions.onion_binds.empty()) {
         onion_service_target = connOptions.onion_binds.front();
     } else {
         onion_service_target = DefaultOnionServiceTarget();
         connOptions.onion_binds.push_back(onion_service_target);
     }
 
     if (args.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
         if (connOptions.onion_binds.size() > 1) {
             InitWarning(strprintf(
                 _("More than one onion bind address is provided. Using %s "
                   "for the automatically created Tor onion service."),
                 onion_service_target.ToStringIPPort()));
         }
         StartTorControl(onion_service_target);
     }
 
     for (const auto &net : args.GetArgs("-whitelist")) {
         NetWhitelistPermissions subnet;
         bilingual_str error;
         if (!NetWhitelistPermissions::TryParse(net, subnet, error)) {
             return InitError(error);
         }
         connOptions.vWhitelistedRange.push_back(subnet);
     }
 
     connOptions.vSeedNodes = args.GetArgs("-seednode");
 
     // Initiate outbound connections unless connect=0
     connOptions.m_use_addrman_outgoing = !args.IsArgSet("-connect");
     if (!connOptions.m_use_addrman_outgoing) {
         const auto connect = args.GetArgs("-connect");
         if (connect.size() != 1 || connect[0] != "0") {
             connOptions.m_specified_outgoing = connect;
         }
     }
 
     const std::string &i2psam_arg = args.GetArg("-i2psam", "");
     if (!i2psam_arg.empty()) {
         CService addr;
         if (!Lookup(i2psam_arg, addr, 7656, fNameLookup) || !addr.IsValid()) {
             return InitError(strprintf(
                 _("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
         }
         SetReachable(NET_I2P, true);
         SetProxy(NET_I2P, proxyType{addr});
     } else {
         SetReachable(NET_I2P, false);
     }
 
     connOptions.m_i2p_accept_incoming =
         args.GetBoolArg("-i2pacceptincoming", true);
 
     if (!node.connman->Start(*node.scheduler, connOptions)) {
         return false;
     }
 
     // Step 13: finished
 
     // At this point, the RPC is "started", but still in warmup, which means it
     // cannot yet be called. Before we make it callable, we need to make sure
     // that the RPC's view of the best block is valid and consistent with
     // ChainstateManager's ActiveTip.
     //
     // If we do not do this, RPC's view of the best block will be height=0 and
     // hash=0x0. This will lead to erroroneous responses for things like
     // waitforblockheight.
     RPCNotifyBlockChange(chainman.ActiveTip());
     SetRPCWarmupFinished();
 
     uiInterface.InitMessage(_("Done loading").translated);
 
     for (const auto &client : node.chain_clients) {
         client->start(*node.scheduler);
     }
 
     BanMan *banman = node.banman.get();
     node.scheduler->scheduleEvery(
         [banman] {
             banman->DumpBanlist();
             return true;
         },
         DUMP_BANS_INTERVAL);
 
     if (node.peerman) {
         node.peerman->StartScheduledTasks(*node.scheduler);
     }
 
     // Start Avalanche's event loop.
     g_avalanche->startEventLoop(*node.scheduler);
 
 #if HAVE_SYSTEM
     StartupNotify(args);
 #endif
 
     return true;
 }
diff --git a/src/logging.cpp b/src/logging.cpp
index 156c4d3f2..e1daf443d 100644
--- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -1,362 +1,363 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <fs.h>
 #include <logging.h>
 
 #include <util/string.h>
 #include <util/threadnames.h>
 #include <util/time.h>
 
 #include <algorithm>
 #include <array>
 
 bool fLogIPs = DEFAULT_LOGIPS;
 const char *const DEFAULT_DEBUGLOGFILE = "debug.log";
 
 BCLog::Logger &LogInstance() {
     /**
      * NOTE: the logger instance is leaked on exit. This is ugly, but will be
      * cleaned up by the OS/libc. Defining a logger as a global object doesn't
      * work since the order of destruction of static/global objects is
      * undefined. Consider if the logger gets destroyed, and then some later
      * destructor calls LogPrintf, maybe indirectly, and you get a core dump at
      * shutdown trying to access the logger. When the shutdown sequence is fully
      * audited and tested, explicit destruction of these objects can be
      * implemented by changing this from a raw pointer to a std::unique_ptr.
      * Since the ~Logger() destructor is never called, the Logger class and all
      * its subclasses must have implicitly-defined destructors.
      *
      * This method of initialization was originally introduced in
      * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
      */
     static BCLog::Logger *g_logger{new BCLog::Logger()};
     return *g_logger;
 }
 
 static int FileWriteStr(const std::string &str, FILE *fp) {
     return fwrite(str.data(), 1, str.size(), fp);
 }
 
 bool BCLog::Logger::StartLogging() {
     StdLockGuard scoped_lock(m_cs);
 
     assert(m_buffering);
     assert(m_fileout == nullptr);
 
     if (m_print_to_file) {
         assert(!m_file_path.empty());
         m_fileout = fsbridge::fopen(m_file_path, "a");
         if (!m_fileout) {
             return false;
         }
 
         // Unbuffered.
         setbuf(m_fileout, nullptr);
 
         // Add newlines to the logfile to distinguish this execution from the
         // last one.
         FileWriteStr("\n\n\n\n\n", m_fileout);
     }
 
     // Dump buffered messages from before we opened the log.
     m_buffering = false;
     while (!m_msgs_before_open.empty()) {
         const std::string &s = m_msgs_before_open.front();
 
         if (m_print_to_file) {
             FileWriteStr(s, m_fileout);
         }
         if (m_print_to_console) {
             fwrite(s.data(), 1, s.size(), stdout);
         }
         for (const auto &cb : m_print_callbacks) {
             cb(s);
         }
 
         m_msgs_before_open.pop_front();
     }
     if (m_print_to_console) {
         fflush(stdout);
     }
 
     return true;
 }
 
 void BCLog::Logger::DisconnectTestLogger() {
     StdLockGuard scoped_lock(m_cs);
     m_buffering = true;
     if (m_fileout != nullptr) {
         fclose(m_fileout);
     }
     m_fileout = nullptr;
     m_print_callbacks.clear();
 }
 
 struct CLogCategoryDesc {
     BCLog::LogFlags flag;
     std::string category;
 };
 
 const CLogCategoryDesc LogCategories[] = {
     {BCLog::NONE, "0"},
     {BCLog::NONE, "none"},
     {BCLog::NET, "net"},
     {BCLog::TOR, "tor"},
     {BCLog::MEMPOOL, "mempool"},
     {BCLog::HTTP, "http"},
     {BCLog::BENCH, "bench"},
     {BCLog::ZMQ, "zmq"},
     {BCLog::WALLETDB, "walletdb"},
     {BCLog::RPC, "rpc"},
     {BCLog::ESTIMATEFEE, "estimatefee"},
     {BCLog::ADDRMAN, "addrman"},
     {BCLog::SELECTCOINS, "selectcoins"},
     {BCLog::REINDEX, "reindex"},
     {BCLog::CMPCTBLOCK, "cmpctblock"},
     {BCLog::RAND, "rand"},
     {BCLog::PRUNE, "prune"},
     {BCLog::PROXY, "proxy"},
     {BCLog::MEMPOOLREJ, "mempoolrej"},
     {BCLog::LIBEVENT, "libevent"},
     {BCLog::COINDB, "coindb"},
     {BCLog::QT, "qt"},
     {BCLog::LEVELDB, "leveldb"},
     {BCLog::VALIDATION, "validation"},
     {BCLog::AVALANCHE, "avalanche"},
     {BCLog::I2P, "i2p"},
     {BCLog::CHRONIK, "chronik"},
 #ifdef DEBUG_LOCKCONTENTION
     {BCLog::LOCK, "lock"},
 #endif
     {BCLog::BLOCKSTORE, "blockstorage"},
     {BCLog::ALL, "1"},
     {BCLog::ALL, "all"},
 };
 
 bool GetLogCategory(BCLog::LogFlags &flag, const std::string &str) {
     if (str == "") {
         flag = BCLog::ALL;
         return true;
     }
     for (const CLogCategoryDesc &category_desc : LogCategories) {
         if (category_desc.category == str) {
             flag = category_desc.flag;
             return true;
         }
     }
     return false;
 }
 
 std::vector<LogCategory> BCLog::Logger::LogCategoriesList() const {
     // Sort log categories by alphabetical order.
     std::array<CLogCategoryDesc, std::size(LogCategories)> categories;
     std::copy(std::begin(LogCategories), std::end(LogCategories),
               categories.begin());
     std::sort(categories.begin(), categories.end(),
               [](auto a, auto b) { return a.category < b.category; });
 
     std::vector<LogCategory> ret;
     for (const CLogCategoryDesc &category_desc : categories) {
         if (category_desc.flag == BCLog::NONE ||
             category_desc.flag == BCLog::ALL) {
             continue;
         }
         LogCategory catActive;
         catActive.category = category_desc.category;
         catActive.active = WillLogCategory(category_desc.flag);
         ret.push_back(catActive);
     }
     return ret;
 }
 
 BCLog::Logger::~Logger() {
     if (m_fileout) {
         fclose(m_fileout);
     }
 }
 
 std::string BCLog::Logger::LogTimestampStr(const std::string &str) {
     std::string strStamped;
 
     if (!m_log_timestamps) {
         return str;
     }
 
     if (m_started_new_line) {
         int64_t nTimeMicros = GetTimeMicros();
         strStamped = FormatISO8601DateTime(nTimeMicros / 1000000);
         if (m_log_time_micros) {
             strStamped.pop_back();
             strStamped += strprintf(".%06dZ", nTimeMicros % 1000000);
         }
         std::chrono::seconds mocktime = GetMockTime();
         if (mocktime > 0s) {
             strStamped += " (mocktime: " +
                           FormatISO8601DateTime(count_seconds(mocktime)) + ")";
         }
         strStamped += ' ' + str;
     } else {
         strStamped = str;
     }
 
     return strStamped;
 }
 
 namespace BCLog {
 /** Belts and suspenders: make sure outgoing log messages don't contain
  * potentially suspicious characters, such as terminal control codes.
  *
  * This escapes control characters except newline ('\n') in C syntax.
  * It escapes instead of removes them to still allow for troubleshooting
  * issues where they accidentally end up in strings.
  */
 std::string LogEscapeMessage(const std::string &str) {
     std::string ret;
     for (char ch_in : str) {
         uint8_t ch = (uint8_t)ch_in;
         if ((ch >= 32 || ch == '\n') && ch != '\x7f') {
             ret += ch_in;
         } else {
             ret += strprintf("\\x%02x", ch);
         }
     }
     return ret;
 }
 } // namespace BCLog
 
 void BCLog::Logger::LogPrintStr(const std::string &str,
                                 const std::string &logging_function,
                                 const std::string &source_file,
                                 const int source_line) {
     StdLockGuard scoped_lock(m_cs);
     std::string str_prefixed = LogEscapeMessage(str);
 
     if (m_log_sourcelocations && m_started_new_line) {
         str_prefixed.insert(0, "[" + RemovePrefix(source_file, "./") + ":" +
                                    ToString(source_line) + "] [" +
                                    logging_function + "] ");
     }
 
     if (m_log_threadnames && m_started_new_line) {
         str_prefixed.insert(0, "[" + util::ThreadGetInternalName() + "] ");
     }
 
     str_prefixed = LogTimestampStr(str_prefixed);
 
     m_started_new_line = !str.empty() && str[str.size() - 1] == '\n';
 
     if (m_buffering) {
         // buffer if we haven't started logging yet
         m_msgs_before_open.push_back(str_prefixed);
         return;
     }
 
     if (m_print_to_console) {
         // Print to console.
         fwrite(str_prefixed.data(), 1, str_prefixed.size(), stdout);
         fflush(stdout);
     }
     for (const auto &cb : m_print_callbacks) {
         cb(str_prefixed);
     }
     if (m_print_to_file) {
         assert(m_fileout != nullptr);
 
         // Reopen the log file, if requested.
         if (m_reopen_file) {
             m_reopen_file = false;
             FILE *new_fileout = fsbridge::fopen(m_file_path, "a");
             if (new_fileout) {
                 // unbuffered.
                 setbuf(m_fileout, nullptr);
                 fclose(m_fileout);
                 m_fileout = new_fileout;
             }
         }
         FileWriteStr(str_prefixed, m_fileout);
     }
 }
 
 void BCLog::Logger::ShrinkDebugFile() {
     // Amount of debug.log to save at end when shrinking (must fit in memory)
     constexpr size_t RECENT_DEBUG_HISTORY_SIZE = 10 * 1000000;
 
     assert(!m_file_path.empty());
 
     // Scroll debug.log if it's getting too big.
     FILE *file = fsbridge::fopen(m_file_path, "r");
 
     // Special files (e.g. device nodes) may not have a size.
     size_t log_size = 0;
     try {
         log_size = fs::file_size(m_file_path);
     } catch (const fs::filesystem_error &) {
     }
 
     // If debug.log file is more than 10% bigger the RECENT_DEBUG_HISTORY_SIZE
     // trim it down by saving only the last RECENT_DEBUG_HISTORY_SIZE bytes.
     if (file && log_size > 11 * (RECENT_DEBUG_HISTORY_SIZE / 10)) {
         // Restart the file with some of the end.
         std::vector<char> vch(RECENT_DEBUG_HISTORY_SIZE, 0);
         if (fseek(file, -((long)vch.size()), SEEK_END)) {
             LogPrintf("Failed to shrink debug log file: fseek(...) failed\n");
             fclose(file);
             return;
         }
         int nBytes = fread(vch.data(), 1, vch.size(), file);
         fclose(file);
 
         file = fsbridge::fopen(m_file_path, "w");
         if (file) {
             fwrite(vch.data(), 1, nBytes, file);
             fclose(file);
         }
     } else if (file != nullptr) {
         fclose(file);
     }
 }
 
 void BCLog::Logger::EnableCategory(LogFlags category) {
     m_categories |= category;
 }
 
 bool BCLog::Logger::EnableCategory(const std::string &str) {
     BCLog::LogFlags flag;
     if (!GetLogCategory(flag, str)) {
         return false;
     }
     EnableCategory(flag);
     return true;
 }
 
 void BCLog::Logger::DisableCategory(LogFlags category) {
     m_categories &= ~category;
 }
 
 bool BCLog::Logger::DisableCategory(const std::string &str) {
     BCLog::LogFlags flag;
     if (!GetLogCategory(flag, str)) {
         return false;
     }
     DisableCategory(flag);
     return true;
 }
 
 bool BCLog::Logger::WillLogCategory(LogFlags category) const {
     // ALL is not meant to be used as a logging category, but only as a mask
     // representing all categories.
     if (category == BCLog::NONE || category == BCLog::ALL) {
         LogPrintf("Error trying to log using a category mask instead of an "
                   "explicit category.\n");
         return true;
     }
 
     return (m_categories.load(std::memory_order_relaxed) & category) != 0;
 }
 
 bool BCLog::Logger::DefaultShrinkDebugFile() const {
     return m_categories != BCLog::NONE;
 }
diff --git a/src/logging.h b/src/logging.h
index 36e73fa3b..60ac154e7 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -1,223 +1,224 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2019 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_LOGGING_H
 #define BITCOIN_LOGGING_H
 
 #include <fs.h>
 #include <threadsafety.h>
 #include <tinyformat.h>
 #include <util/string.h>
 
 #include <atomic>
 #include <cstdint>
+#include <functional>
 #include <list>
 #include <mutex>
 #include <string>
 
 static const bool DEFAULT_LOGTIMEMICROS = false;
 static const bool DEFAULT_LOGIPS = false;
 static const bool DEFAULT_LOGTIMESTAMPS = true;
 static const bool DEFAULT_LOGTHREADNAMES = false;
 static const bool DEFAULT_LOGSOURCELOCATIONS = false;
 
 extern bool fLogIPs;
 extern const char *const DEFAULT_DEBUGLOGFILE;
 
 struct LogCategory {
     std::string category;
     bool active;
 };
 
 namespace BCLog {
 
 enum LogFlags : uint32_t {
     NONE = 0,
     NET = (1 << 0),
     TOR = (1 << 1),
     MEMPOOL = (1 << 2),
     HTTP = (1 << 3),
     BENCH = (1 << 4),
     ZMQ = (1 << 5),
     WALLETDB = (1 << 6),
     RPC = (1 << 7),
     ESTIMATEFEE = (1 << 8),
     ADDRMAN = (1 << 9),
     SELECTCOINS = (1 << 10),
     REINDEX = (1 << 11),
     CMPCTBLOCK = (1 << 12),
     RAND = (1 << 13),
     PRUNE = (1 << 14),
     PROXY = (1 << 15),
     MEMPOOLREJ = (1 << 16),
     LIBEVENT = (1 << 17),
     COINDB = (1 << 18),
     QT = (1 << 19),
     LEVELDB = (1 << 20),
     VALIDATION = (1 << 21),
     AVALANCHE = (1 << 22),
     I2P = (1 << 23),
     CHRONIK = (1 << 24),
 #ifdef DEBUG_LOCKCONTENTION
     LOCK = (1 << 25),
 #endif
     BLOCKSTORE = (1 << 26),
     ALL = ~uint32_t(0),
 };
 
 class Logger {
 private:
     // Can not use Mutex from sync.h because in debug mode it would cause a
     // deadlock when a potential deadlock was detected
     mutable StdMutex m_cs;
 
     FILE *m_fileout GUARDED_BY(m_cs) = nullptr;
     std::list<std::string> m_msgs_before_open GUARDED_BY(m_cs);
     //! Buffer messages before logging can be started.
     bool m_buffering GUARDED_BY(m_cs) = true;
 
     /**
      * m_started_new_line is a state variable that will suppress printing of the
      * timestamp when multiple calls are made that don't end in a newline.
      */
     std::atomic_bool m_started_new_line{true};
 
     /**
      * Log categories bitfield.
      */
     std::atomic<uint32_t> m_categories{0};
 
     std::string LogTimestampStr(const std::string &str);
 
     /** Slots that connect to the print signal */
     std::list<std::function<void(const std::string &)>>
         m_print_callbacks GUARDED_BY(m_cs){};
 
 public:
     bool m_print_to_console = false;
     bool m_print_to_file = false;
 
     bool m_log_timestamps = DEFAULT_LOGTIMESTAMPS;
     bool m_log_time_micros = DEFAULT_LOGTIMEMICROS;
     bool m_log_threadnames = DEFAULT_LOGTHREADNAMES;
     bool m_log_sourcelocations = DEFAULT_LOGSOURCELOCATIONS;
 
     fs::path m_file_path;
     std::atomic<bool> m_reopen_file{false};
 
     ~Logger();
 
     /** Send a string to the log output */
     void LogPrintStr(const std::string &str,
                      const std::string &logging_function,
                      const std::string &source_file, const int source_line);
 
     /** Returns whether logs will be written to any output */
     bool Enabled() const {
         StdLockGuard scoped_lock(m_cs);
         return m_buffering || m_print_to_console || m_print_to_file ||
                !m_print_callbacks.empty();
     }
 
     /** Connect a slot to the print signal and return the connection */
     std::list<std::function<void(const std::string &)>>::iterator
     PushBackCallback(std::function<void(const std::string &)> fun) {
         StdLockGuard scoped_lock(m_cs);
         m_print_callbacks.push_back(std::move(fun));
         return --m_print_callbacks.end();
     }
 
     /** Delete a connection */
     void DeleteCallback(
         std::list<std::function<void(const std::string &)>>::iterator it) {
         StdLockGuard scoped_lock(m_cs);
         m_print_callbacks.erase(it);
     }
 
     /** Start logging (and flush all buffered messages) */
     bool StartLogging();
     /** Only for testing */
     void DisconnectTestLogger();
 
     void ShrinkDebugFile();
 
     uint32_t GetCategoryMask() const { return m_categories.load(); }
 
     void EnableCategory(LogFlags category);
     bool EnableCategory(const std::string &str);
     void DisableCategory(LogFlags category);
     bool DisableCategory(const std::string &str);
 
     /** Return true if log accepts specified category */
     bool WillLogCategory(LogFlags category) const;
 
     /** Returns a vector of the log categories in alphabetical order. */
     std::vector<LogCategory> LogCategoriesList() const;
     /** Returns a string with the log categories in alphabetical order. */
     std::string LogCategoriesString() const {
         return Join(LogCategoriesList(), ", ",
                     [&](const LogCategory &i) { return i.category; });
     };
 
     /** Default for whether ShrinkDebugFile should be run */
     bool DefaultShrinkDebugFile() const;
 };
 
 } // namespace BCLog
 
 BCLog::Logger &LogInstance();
 
 /** Return true if log accepts specified category */
 static inline bool LogAcceptCategory(BCLog::LogFlags category) {
     return LogInstance().WillLogCategory(category);
 }
 
 /** Return true if str parses as a log category and set the flag */
 bool GetLogCategory(BCLog::LogFlags &flag, const std::string &str);
 
 // Be conservative when using LogPrintf/error or other things which
 // unconditionally log to debug.log! It should not be the case that an inbound
 // peer can fill up a user's disk with debug.log entries.
 template <typename... Args>
 static inline void
 LogPrintf_(const std::string &logging_function, const std::string &source_file,
            const int source_line, const char *fmt, const Args &...args) {
     if (LogInstance().Enabled()) {
         std::string log_msg;
         try {
             log_msg = tfm::format(fmt, args...);
         } catch (tinyformat::format_error &fmterr) {
             /**
              * Original format string will have newline so don't add one here
              */
             log_msg = "Error \"" + std::string(fmterr.what()) +
                       "\" while formatting log message: " + fmt;
         }
         LogInstance().LogPrintStr(log_msg, logging_function, source_file,
                                   source_line);
     }
 }
 
 #define LogPrintf(...) LogPrintf_(__func__, __FILE__, __LINE__, __VA_ARGS__)
 
 // Use a macro instead of a function for conditional logging to prevent
 // evaluating arguments when logging for the category is not enabled.
 #define LogPrint(category, ...)                                                \
     do {                                                                       \
         if (LogAcceptCategory((category))) {                                   \
             LogPrintf(__VA_ARGS__);                                            \
         }                                                                      \
     } while (0)
 
 /**
  * These are aliases used to explicitly state that the message should not end
  * with a newline character. It allows for detecting the missing newlines that
  * could make the logs hard to read.
  */
 #define LogPrintfToBeContinued LogPrintf
 #define LogPrintToBeContinued LogPrint
 
 #endif // BITCOIN_LOGGING_H
diff --git a/src/net.cpp b/src/net.cpp
index 17c3d7b1f..1b458b28a 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -1,3651 +1,3652 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <net.h>
 
 #include <addrdb.h>
 #include <addrman.h>
 #include <avalanche/avalanche.h>
 #include <banman.h>
 #include <clientversion.h>
 #include <compat.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <crypto/sha256.h>
 #include <dnsseeds.h>
+#include <fs.h>
 #include <i2p.h>
 #include <netaddress.h>
 #include <netbase.h>
 #include <node/ui_interface.h>
 #include <protocol.h>
 #include <random.h>
 #include <scheduler.h>
 #include <util/sock.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/thread.h>
 #include <util/trace.h>
 #include <util/translation.h>
 
 #ifdef WIN32
 #include <cstring>
 #else
 #include <fcntl.h>
 #endif
 
 #ifdef USE_POLL
 #include <poll.h>
 #endif
 
 #include <algorithm>
 #include <array>
 #include <cmath>
 #include <cstdint>
 #include <functional>
 #include <limits>
 #include <optional>
 #include <unordered_map>
 
 /** Maximum number of block-relay-only anchor connections */
 static constexpr size_t MAX_BLOCK_RELAY_ONLY_ANCHORS = 2;
 static_assert(MAX_BLOCK_RELAY_ONLY_ANCHORS <=
                   static_cast<size_t>(MAX_BLOCK_RELAY_ONLY_CONNECTIONS),
               "MAX_BLOCK_RELAY_ONLY_ANCHORS must not exceed "
               "MAX_BLOCK_RELAY_ONLY_CONNECTIONS.");
 /** Anchor IP address database file name */
 const char *const ANCHORS_DATABASE_FILENAME = "anchors.dat";
 
 // How often to dump addresses to peers.dat
 static constexpr std::chrono::minutes DUMP_PEERS_INTERVAL{15};
 
 /**
  * Number of DNS seeds to query when the number of connections is low.
  */
 static constexpr int DNSSEEDS_TO_QUERY_AT_ONCE = 3;
 
 /**
  * How long to delay before querying DNS seeds
  *
  * If we have more than THRESHOLD entries in addrman, then it's likely
  * that we got those addresses from having previously connected to the P2P
  * network, and that we'll be able to successfully reconnect to the P2P
  * network via contacting one of them. So if that's the case, spend a
  * little longer trying to connect to known peers before querying the
  * DNS seeds.
  */
 static constexpr std::chrono::seconds DNSSEEDS_DELAY_FEW_PEERS{11};
 static constexpr std::chrono::minutes DNSSEEDS_DELAY_MANY_PEERS{5};
 // "many" vs "few" peers
 static constexpr int DNSSEEDS_DELAY_PEER_THRESHOLD = 1000;
 
 /** The default timeframe for -maxuploadtarget. 1 day. */
 static constexpr std::chrono::seconds MAX_UPLOAD_TIMEFRAME{60 * 60 * 24};
 
 // We add a random period time (0 to 1 seconds) to feeler connections to prevent
 // synchronization.
 #define FEELER_SLEEP_WINDOW 1
 
 /** Used to pass flags to the Bind() function */
 enum BindFlags {
     BF_NONE = 0,
     BF_EXPLICIT = (1U << 0),
     BF_REPORT_ERROR = (1U << 1),
     /**
      * Do not call AddLocal() for our special addresses, e.g., for incoming
      * Tor connections, to prevent gossiping them over the network.
      */
     BF_DONT_ADVERTISE = (1U << 2),
 };
 
 // The set of sockets cannot be modified while waiting
 // The sleep time needs to be small to avoid new sockets stalling
 static const uint64_t SELECT_TIMEOUT_MILLISECONDS = 50;
 
 const std::string NET_MESSAGE_COMMAND_OTHER = "*other*";
 
 // SHA256("netgroup")[0:8]
 static const uint64_t RANDOMIZER_ID_NETGROUP = 0x6c0edd8036ef4036ULL;
 // SHA256("localhostnonce")[0:8]
 static const uint64_t RANDOMIZER_ID_LOCALHOSTNONCE = 0xd93e69e2bbfa5735ULL;
 // SHA256("localhostnonce")[8:16]
 static const uint64_t RANDOMIZER_ID_EXTRAENTROPY = 0x94b05d41679a4ff7ULL;
 // SHA256("addrcache")[0:8]
 static const uint64_t RANDOMIZER_ID_ADDRCACHE = 0x1cf2e4ddd306dda9ULL;
 //
 // Global state variables
 //
 bool fDiscover = true;
 bool fListen = true;
 Mutex g_maplocalhost_mutex;
 std::map<CNetAddr, LocalServiceInfo>
     mapLocalHost GUARDED_BY(g_maplocalhost_mutex);
 static bool vfLimited[NET_MAX] GUARDED_BY(g_maplocalhost_mutex) = {};
 
 void CConnman::AddAddrFetch(const std::string &strDest) {
     LOCK(m_addr_fetches_mutex);
     m_addr_fetches.push_back(strDest);
 }
 
 uint16_t GetListenPort() {
     return static_cast<uint16_t>(
         gArgs.GetIntArg("-port", Params().GetDefaultPort()));
 }
 
 // find 'best' local address for a particular peer
 bool GetLocal(CService &addr, const CNetAddr *paddrPeer) {
     if (!fListen) {
         return false;
     }
 
     int nBestScore = -1;
     int nBestReachability = -1;
     {
         LOCK(g_maplocalhost_mutex);
         for (const auto &entry : mapLocalHost) {
             int nScore = entry.second.nScore;
             int nReachability = entry.first.GetReachabilityFrom(paddrPeer);
             if (nReachability > nBestReachability ||
                 (nReachability == nBestReachability && nScore > nBestScore)) {
                 addr = CService(entry.first, entry.second.nPort);
                 nBestReachability = nReachability;
                 nBestScore = nScore;
             }
         }
     }
     return nBestScore >= 0;
 }
 
 //! Convert the pnSeed6 array into usable address objects.
 static std::vector<CAddress>
 convertSeed6(const std::vector<SeedSpec6> &vSeedsIn) {
     // It'll only connect to one or two seed nodes because once it connects,
     // it'll get a pile of addresses with newer timestamps. Seed nodes are given
     // a random 'last seen time' of between one and two weeks ago.
     const int64_t nOneWeek = 7 * 24 * 60 * 60;
     std::vector<CAddress> vSeedsOut;
     vSeedsOut.reserve(vSeedsIn.size());
     FastRandomContext rng;
     for (const auto &seed_in : vSeedsIn) {
         struct in6_addr ip;
         memcpy(&ip, seed_in.addr, sizeof(ip));
         CAddress addr(CService(ip, seed_in.port),
                       GetDesirableServiceFlags(NODE_NONE));
         addr.nTime = GetTime() - rng.randrange(nOneWeek) - nOneWeek;
         vSeedsOut.push_back(addr);
     }
     return vSeedsOut;
 }
 
 // Get best local address for a particular peer as a CAddress. Otherwise, return
 // the unroutable 0.0.0.0 but filled in with the normal parameters, since the IP
 // may be changed to a useful one by discovery.
 CAddress GetLocalAddress(const CNetAddr *paddrPeer,
                          ServiceFlags nLocalServices) {
     CAddress ret(CService(CNetAddr(), GetListenPort()), nLocalServices);
     CService addr;
     if (GetLocal(addr, paddrPeer)) {
         ret = CAddress(addr, nLocalServices);
     }
     ret.nTime = GetAdjustedTime();
     return ret;
 }
 
 static int GetnScore(const CService &addr) {
     LOCK(g_maplocalhost_mutex);
     const auto it = mapLocalHost.find(addr);
     return (it != mapLocalHost.end()) ? it->second.nScore : 0;
 }
 
 // Is our peer's addrLocal potentially useful as an external IP source?
 bool IsPeerAddrLocalGood(CNode *pnode) {
     CService addrLocal = pnode->GetAddrLocal();
     return fDiscover && pnode->addr.IsRoutable() && addrLocal.IsRoutable() &&
            IsReachable(addrLocal.GetNetwork());
 }
 
 std::optional<CAddress> GetLocalAddrForPeer(CNode *pnode) {
     CAddress addrLocal =
         GetLocalAddress(&pnode->addr, pnode->GetLocalServices());
     if (gArgs.GetBoolArg("-addrmantest", false)) {
         // use IPv4 loopback during addrmantest
         addrLocal =
             CAddress(CService(LookupNumeric("127.0.0.1", GetListenPort())),
                      pnode->GetLocalServices());
     }
     // If discovery is enabled, sometimes give our peer the address it
     // tells us that it sees us as in case it has a better idea of our
     // address than we do.
     FastRandomContext rng;
     if (IsPeerAddrLocalGood(pnode) &&
         (!addrLocal.IsRoutable() ||
          rng.randbits((GetnScore(addrLocal) > LOCAL_MANUAL) ? 3 : 1) == 0)) {
         addrLocal.SetIP(pnode->GetAddrLocal());
     }
     if (addrLocal.IsRoutable() || gArgs.GetBoolArg("-addrmantest", false)) {
         LogPrint(BCLog::NET, "Advertising address %s to peer=%d\n",
                  addrLocal.ToString(), pnode->GetId());
         return addrLocal;
     }
     // Address is unroutable. Don't advertise.
     return std::nullopt;
 }
 
 // Learn a new local address.
 bool AddLocal(const CService &addr, int nScore) {
     if (!addr.IsRoutable()) {
         return false;
     }
 
     if (!fDiscover && nScore < LOCAL_MANUAL) {
         return false;
     }
 
     if (!IsReachable(addr)) {
         return false;
     }
 
     LogPrintf("AddLocal(%s,%i)\n", addr.ToString(), nScore);
 
     {
         LOCK(g_maplocalhost_mutex);
         const auto [it, is_newly_added] =
             mapLocalHost.emplace(addr, LocalServiceInfo());
         LocalServiceInfo &info = it->second;
         if (is_newly_added || nScore >= info.nScore) {
             info.nScore = nScore + !is_newly_added;
             info.nPort = addr.GetPort();
         }
     }
 
     return true;
 }
 
 bool AddLocal(const CNetAddr &addr, int nScore) {
     return AddLocal(CService(addr, GetListenPort()), nScore);
 }
 
 void RemoveLocal(const CService &addr) {
     LOCK(g_maplocalhost_mutex);
     LogPrintf("RemoveLocal(%s)\n", addr.ToString());
     mapLocalHost.erase(addr);
 }
 
 void SetReachable(enum Network net, bool reachable) {
     if (net == NET_UNROUTABLE || net == NET_INTERNAL) {
         return;
     }
     LOCK(g_maplocalhost_mutex);
     vfLimited[net] = !reachable;
 }
 
 bool IsReachable(enum Network net) {
     LOCK(g_maplocalhost_mutex);
     return !vfLimited[net];
 }
 
 bool IsReachable(const CNetAddr &addr) {
     return IsReachable(addr.GetNetwork());
 }
 
 /** vote for a local address */
 bool SeenLocal(const CService &addr) {
     LOCK(g_maplocalhost_mutex);
     const auto it = mapLocalHost.find(addr);
     if (it == mapLocalHost.end()) {
         return false;
     }
     ++it->second.nScore;
     return true;
 }
 
 /** check whether a given address is potentially local */
 bool IsLocal(const CService &addr) {
     LOCK(g_maplocalhost_mutex);
     return mapLocalHost.count(addr) > 0;
 }
 
 CNode *CConnman::FindNode(const CNetAddr &ip) {
     LOCK(m_nodes_mutex);
     for (CNode *pnode : m_nodes) {
         if (static_cast<CNetAddr>(pnode->addr) == ip) {
             return pnode;
         }
     }
     return nullptr;
 }
 
 CNode *CConnman::FindNode(const CSubNet &subNet) {
     LOCK(m_nodes_mutex);
     for (CNode *pnode : m_nodes) {
         if (subNet.Match(static_cast<CNetAddr>(pnode->addr))) {
             return pnode;
         }
     }
     return nullptr;
 }
 
 CNode *CConnman::FindNode(const std::string &addrName) {
     LOCK(m_nodes_mutex);
     for (CNode *pnode : m_nodes) {
         if (pnode->m_addr_name == addrName) {
             return pnode;
         }
     }
     return nullptr;
 }
 
 CNode *CConnman::FindNode(const CService &addr) {
     LOCK(m_nodes_mutex);
     for (CNode *pnode : m_nodes) {
         if (static_cast<CService>(pnode->addr) == addr) {
             return pnode;
         }
     }
     return nullptr;
 }
 
 bool CConnman::AlreadyConnectedToAddress(const CAddress &addr) {
     return FindNode(static_cast<CNetAddr>(addr)) ||
            FindNode(addr.ToStringIPPort());
 }
 
 bool CConnman::CheckIncomingNonce(uint64_t nonce) {
     LOCK(m_nodes_mutex);
     for (const CNode *pnode : m_nodes) {
         if (!pnode->fSuccessfullyConnected && !pnode->IsInboundConn() &&
             pnode->GetLocalNonce() == nonce) {
             return false;
         }
     }
     return true;
 }
 
 /** Get the bind address for a socket as CAddress */
 static CAddress GetBindAddress(SOCKET sock) {
     CAddress addr_bind;
     struct sockaddr_storage sockaddr_bind;
     socklen_t sockaddr_bind_len = sizeof(sockaddr_bind);
     if (sock != INVALID_SOCKET) {
         if (!getsockname(sock, (struct sockaddr *)&sockaddr_bind,
                          &sockaddr_bind_len)) {
             addr_bind.SetSockAddr((const struct sockaddr *)&sockaddr_bind);
         } else {
             LogPrint(BCLog::NET, "Warning: getsockname failed\n");
         }
     }
     return addr_bind;
 }
 
 CNode *CConnman::ConnectNode(CAddress addrConnect, const char *pszDest,
                              bool fCountFailure, ConnectionType conn_type) {
     assert(conn_type != ConnectionType::INBOUND);
 
     if (pszDest == nullptr) {
         if (IsLocal(addrConnect)) {
             return nullptr;
         }
 
         // Look for an existing connection
         CNode *pnode = FindNode(static_cast<CService>(addrConnect));
         if (pnode) {
             LogPrintf("Failed to open new connection, already connected\n");
             return nullptr;
         }
     }
 
     /// debug print
     LogPrint(BCLog::NET, "trying connection %s lastseen=%.1fhrs\n",
              pszDest ? pszDest : addrConnect.ToString(),
              pszDest
                  ? 0.0
                  : (double)(GetAdjustedTime() - addrConnect.nTime) / 3600.0);
 
     // Resolve
     const uint16_t default_port{pszDest != nullptr
                                     ? Params().GetDefaultPort(pszDest)
                                     : Params().GetDefaultPort()};
     if (pszDest) {
         std::vector<CService> resolved;
         if (Lookup(pszDest, resolved, default_port,
                    fNameLookup && !HaveNameProxy(), 256) &&
             !resolved.empty()) {
             addrConnect =
                 CAddress(resolved[GetRand(resolved.size())], NODE_NONE);
             if (!addrConnect.IsValid()) {
                 LogPrint(BCLog::NET,
                          "Resolver returned invalid address %s for %s\n",
                          addrConnect.ToString(), pszDest);
                 return nullptr;
             }
             // It is possible that we already have a connection to the IP/port
             // pszDest resolved to. In that case, drop the connection that was
             // just created.
             LOCK(m_nodes_mutex);
             CNode *pnode = FindNode(static_cast<CService>(addrConnect));
             if (pnode) {
                 LogPrintf("Failed to open new connection, already connected\n");
                 return nullptr;
             }
         }
     }
 
     // Connect
     bool connected = false;
     std::unique_ptr<Sock> sock;
     proxyType proxy;
     CAddress addr_bind;
     assert(!addr_bind.IsValid());
 
     if (addrConnect.IsValid()) {
         bool proxyConnectionFailed = false;
 
         if (addrConnect.GetNetwork() == NET_I2P &&
             m_i2p_sam_session.get() != nullptr) {
             i2p::Connection conn;
             if (m_i2p_sam_session->Connect(addrConnect, conn,
                                            proxyConnectionFailed)) {
                 connected = true;
                 sock = std::move(conn.sock);
                 addr_bind = CAddress{conn.me, NODE_NONE};
             }
         } else if (GetProxy(addrConnect.GetNetwork(), proxy)) {
             sock = CreateSock(proxy.proxy);
             if (!sock) {
                 return nullptr;
             }
             connected = ConnectThroughProxy(
                 proxy, addrConnect.ToStringIP(), addrConnect.GetPort(), *sock,
                 nConnectTimeout, proxyConnectionFailed);
         } else {
             // no proxy needed (none set for target network)
             sock = CreateSock(addrConnect);
             if (!sock) {
                 return nullptr;
             }
             connected =
                 ConnectSocketDirectly(addrConnect, *sock, nConnectTimeout,
                                       conn_type == ConnectionType::MANUAL);
         }
         if (!proxyConnectionFailed) {
             // If a connection to the node was attempted, and failure (if any)
             // is not caused by a problem connecting to the proxy, mark this as
             // an attempt.
             addrman.Attempt(addrConnect, fCountFailure);
         }
     } else if (pszDest && GetNameProxy(proxy)) {
         sock = CreateSock(proxy.proxy);
         if (!sock) {
             return nullptr;
         }
         std::string host;
         uint16_t port{default_port};
         SplitHostPort(std::string(pszDest), port, host);
         bool proxyConnectionFailed;
         connected = ConnectThroughProxy(proxy, host, port, *sock,
                                         nConnectTimeout, proxyConnectionFailed);
     }
     if (!connected) {
         return nullptr;
     }
 
     // Add node
     NodeId id = GetNewNodeId();
     uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE)
                          .Write(id)
                          .Finalize();
     uint64_t extra_entropy =
         GetDeterministicRandomizer(RANDOMIZER_ID_EXTRAENTROPY)
             .Write(id)
             .Finalize();
     if (!addr_bind.IsValid()) {
         addr_bind = GetBindAddress(sock->Get());
     }
     CNode *pnode =
         new CNode(id, nLocalServices, sock->Release(), addrConnect,
                   CalculateKeyedNetGroup(addrConnect), nonce, extra_entropy,
                   addr_bind, pszDest ? pszDest : "", conn_type,
                   /* inbound_onion */ false);
     pnode->AddRef();
 
     // We're making a new connection, harvest entropy from the time (and our
     // peer count)
     RandAddEvent(uint32_t(id));
 
     return pnode;
 }
 
 void CNode::CloseSocketDisconnect() {
     fDisconnect = true;
     LOCK(cs_hSocket);
     if (hSocket != INVALID_SOCKET) {
         LogPrint(BCLog::NET, "disconnecting peer=%d\n", id);
         CloseSocket(hSocket);
     }
 }
 
 void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags &flags,
                                            const CNetAddr &addr) const {
     for (const auto &subnet : vWhitelistedRange) {
         if (subnet.m_subnet.Match(addr)) {
             NetPermissions::AddFlag(flags, subnet.m_flags);
         }
     }
 }
 
 std::string ConnectionTypeAsString(ConnectionType conn_type) {
     switch (conn_type) {
         case ConnectionType::INBOUND:
             return "inbound";
         case ConnectionType::MANUAL:
             return "manual";
         case ConnectionType::FEELER:
             return "feeler";
         case ConnectionType::OUTBOUND_FULL_RELAY:
             return "outbound-full-relay";
         case ConnectionType::BLOCK_RELAY:
             return "block-relay-only";
         case ConnectionType::ADDR_FETCH:
             return "addr-fetch";
         case ConnectionType::AVALANCHE_OUTBOUND:
             return "avalanche";
     } // no default case, so the compiler can warn about missing cases
 
     assert(false);
 }
 
 CService CNode::GetAddrLocal() const {
     LOCK(cs_addrLocal);
     return addrLocal;
 }
 
 void CNode::SetAddrLocal(const CService &addrLocalIn) {
     LOCK(cs_addrLocal);
     if (addrLocal.IsValid()) {
         error("Addr local already set for node: %i. Refusing to change from %s "
               "to %s",
               id, addrLocal.ToString(), addrLocalIn.ToString());
     } else {
         addrLocal = addrLocalIn;
     }
 }
 
 Network CNode::ConnectedThroughNetwork() const {
     return m_inbound_onion ? NET_ONION : addr.GetNetClass();
 }
 
 void CNode::copyStats(CNodeStats &stats) {
     stats.nodeid = this->GetId();
     stats.nServices = nServices;
     stats.addr = addr;
     stats.addrBind = addrBind;
     stats.m_network = ConnectedThroughNetwork();
     if (m_tx_relay != nullptr) {
         LOCK(m_tx_relay->cs_filter);
         stats.fRelayTxes = m_tx_relay->fRelayTxes;
     } else {
         stats.fRelayTxes = false;
     }
     stats.m_last_send = m_last_send;
     stats.m_last_recv = m_last_recv;
     stats.m_last_tx_time = m_last_tx_time;
     stats.m_last_proof_time = m_last_proof_time;
     stats.m_last_block_time = m_last_block_time;
     stats.m_connected = m_connected;
     stats.nTimeOffset = nTimeOffset;
     stats.m_addr_name = m_addr_name;
     stats.nVersion = nVersion;
     {
         LOCK(m_subver_mutex);
         stats.cleanSubVer = cleanSubVer;
     }
     stats.fInbound = IsInboundConn();
     stats.m_bip152_highbandwidth_to = m_bip152_highbandwidth_to;
     stats.m_bip152_highbandwidth_from = m_bip152_highbandwidth_from;
     {
         LOCK(cs_vSend);
         stats.mapSendBytesPerMsgCmd = mapSendBytesPerMsgCmd;
         stats.nSendBytes = nSendBytes;
     }
     {
         LOCK(cs_vRecv);
         stats.mapRecvBytesPerMsgCmd = mapRecvBytesPerMsgCmd;
         stats.nRecvBytes = nRecvBytes;
     }
     stats.m_permissionFlags = m_permissionFlags;
     if (m_tx_relay != nullptr) {
         stats.minFeeFilter = m_tx_relay->minFeeFilter;
     } else {
         stats.minFeeFilter = Amount::zero();
     }
 
     stats.m_last_ping_time = m_last_ping_time;
     stats.m_min_ping_time = m_min_ping_time;
 
     // Leave string empty if addrLocal invalid (not filled in yet)
     CService addrLocalUnlocked = GetAddrLocal();
     stats.addrLocal =
         addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToString() : "";
 
     stats.m_conn_type = m_conn_type;
 
     stats.m_availabilityScore = m_avalanche_enabled
                                     ? std::make_optional(getAvailabilityScore())
                                     : std::nullopt;
 }
 
 bool CNode::ReceiveMsgBytes(const Config &config, Span<const uint8_t> msg_bytes,
                             bool &complete) {
     complete = false;
     const auto time = GetTime<std::chrono::microseconds>();
     LOCK(cs_vRecv);
     m_last_recv = std::chrono::duration_cast<std::chrono::seconds>(time);
     nRecvBytes += msg_bytes.size();
     while (msg_bytes.size() > 0) {
         // Absorb network data.
         int handled = m_deserializer->Read(config, msg_bytes);
         if (handled < 0) {
             return false;
         }
 
         if (m_deserializer->Complete()) {
             // decompose a transport agnostic CNetMessage from the deserializer
             CNetMessage msg = m_deserializer->GetMessage(config, time);
 
             // Store received bytes per message command to prevent a memory DOS,
             // only allow valid commands.
             mapMsgCmdSize::iterator i =
                 mapRecvBytesPerMsgCmd.find(msg.m_command);
             if (i == mapRecvBytesPerMsgCmd.end()) {
                 i = mapRecvBytesPerMsgCmd.find(NET_MESSAGE_COMMAND_OTHER);
             }
 
             assert(i != mapRecvBytesPerMsgCmd.end());
             i->second += msg.m_raw_message_size;
 
             // push the message to the process queue,
             vRecvMsg.push_back(std::move(msg));
 
             complete = true;
         }
     }
 
     return true;
 }
 
 int V1TransportDeserializer::readHeader(const Config &config,
                                         Span<const uint8_t> msg_bytes) {
     // copy data to temporary parsing buffer
     uint32_t nRemaining = CMessageHeader::HEADER_SIZE - nHdrPos;
     uint32_t nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
 
     memcpy(&hdrbuf[nHdrPos], msg_bytes.data(), nCopy);
     nHdrPos += nCopy;
 
     // if header incomplete, exit
     if (nHdrPos < CMessageHeader::HEADER_SIZE) {
         return nCopy;
     }
 
     // deserialize to CMessageHeader
     try {
         hdrbuf >> hdr;
     } catch (const std::exception &) {
         return -1;
     }
 
     // Reject oversized messages
     if (hdr.IsOversized(config)) {
         LogPrint(BCLog::NET, "Oversized header detected\n");
         return -1;
     }
 
     // switch state to reading message data
     in_data = true;
 
     return nCopy;
 }
 
 int V1TransportDeserializer::readData(Span<const uint8_t> msg_bytes) {
     unsigned int nRemaining = hdr.nMessageSize - nDataPos;
     unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
 
     if (vRecv.size() < nDataPos + nCopy) {
         // Allocate up to 256 KiB ahead, but never more than the total message
         // size.
         vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
     }
 
     hasher.Write(msg_bytes.first(nCopy));
     memcpy(&vRecv[nDataPos], msg_bytes.data(), nCopy);
     nDataPos += nCopy;
 
     return nCopy;
 }
 
 const uint256 &V1TransportDeserializer::GetMessageHash() const {
     assert(Complete());
     if (data_hash.IsNull()) {
         hasher.Finalize(data_hash);
     }
     return data_hash;
 }
 
 CNetMessage
 V1TransportDeserializer::GetMessage(const Config &config,
                                     const std::chrono::microseconds time) {
     // decompose a single CNetMessage from the TransportDeserializer
     CNetMessage msg(std::move(vRecv));
 
     // store state about valid header, netmagic and checksum
     msg.m_valid_header = hdr.IsValid(config);
     // FIXME Split CheckHeaderMagicAndCommand() into CheckHeaderMagic() and
     // CheckCommand() to prevent the net magic check code duplication.
     msg.m_valid_netmagic =
         (memcmp(std::begin(hdr.pchMessageStart),
                 std::begin(config.GetChainParams().NetMagic()),
                 CMessageHeader::MESSAGE_START_SIZE) == 0);
     uint256 hash = GetMessageHash();
 
     // store command string, payload size
     msg.m_command = hdr.GetCommand();
     msg.m_message_size = hdr.nMessageSize;
     msg.m_raw_message_size = hdr.nMessageSize + CMessageHeader::HEADER_SIZE;
 
     // We just received a message off the wire, harvest entropy from the time
     // (and the message checksum)
     RandAddEvent(ReadLE32(hash.begin()));
 
     msg.m_valid_checksum = (memcmp(hash.begin(), hdr.pchChecksum,
                                    CMessageHeader::CHECKSUM_SIZE) == 0);
 
     if (!msg.m_valid_checksum) {
         LogPrint(
             BCLog::NET, "CHECKSUM ERROR (%s, %u bytes), expected %s was %s\n",
             SanitizeString(msg.m_command), msg.m_message_size,
             HexStr(Span<uint8_t>(hash.begin(),
                                  hash.begin() + CMessageHeader::CHECKSUM_SIZE)),
             HexStr(hdr.pchChecksum));
     }
 
     // store receive time
     msg.m_time = time;
 
     // reset the network deserializer (prepare for the next message)
     Reset();
     return msg;
 }
 
 void V1TransportSerializer::prepareForTransport(const Config &config,
                                                 CSerializedNetMsg &msg,
                                                 std::vector<uint8_t> &header) {
     // create dbl-sha256 checksum
     uint256 hash = Hash(msg.data);
 
     // create header
     CMessageHeader hdr(config.GetChainParams().NetMagic(), msg.m_type.c_str(),
                        msg.data.size());
     memcpy(hdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);
 
     // serialize header
     header.reserve(CMessageHeader::HEADER_SIZE);
     CVectorWriter{SER_NETWORK, INIT_PROTO_VERSION, header, 0, hdr};
 }
 
 size_t CConnman::SocketSendData(CNode &node) const {
     size_t nSentSize = 0;
     size_t nMsgCount = 0;
 
     for (const auto &data : node.vSendMsg) {
         assert(data.size() > node.nSendOffset);
         int nBytes = 0;
 
         {
             LOCK(node.cs_hSocket);
             if (node.hSocket == INVALID_SOCKET) {
                 break;
             }
 
             nBytes = send(
                 node.hSocket,
                 reinterpret_cast<const char *>(data.data()) + node.nSendOffset,
                 data.size() - node.nSendOffset, MSG_NOSIGNAL | MSG_DONTWAIT);
         }
 
         if (nBytes == 0) {
             // couldn't send anything at all
             break;
         }
 
         if (nBytes < 0) {
             // error
             int nErr = WSAGetLastError();
             if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE &&
                 nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
                 LogPrint(BCLog::NET, "socket send error for peer=%d: %s\n",
                          node.GetId(), NetworkErrorString(nErr));
                 node.CloseSocketDisconnect();
             }
 
             break;
         }
 
         assert(nBytes > 0);
         node.m_last_send = GetTime<std::chrono::seconds>();
         node.nSendBytes += nBytes;
         node.nSendOffset += nBytes;
         nSentSize += nBytes;
         if (node.nSendOffset != data.size()) {
             // could not send full message; stop sending more
             break;
         }
 
         node.nSendOffset = 0;
         node.nSendSize -= data.size();
         node.fPauseSend = node.nSendSize > nSendBufferMaxSize;
         nMsgCount++;
     }
 
     node.vSendMsg.erase(node.vSendMsg.begin(),
                         node.vSendMsg.begin() + nMsgCount);
 
     if (node.vSendMsg.empty()) {
         assert(node.nSendOffset == 0);
         assert(node.nSendSize == 0);
     }
 
     return nSentSize;
 }
 
 static bool ReverseCompareNodeMinPingTime(const NodeEvictionCandidate &a,
                                           const NodeEvictionCandidate &b) {
     return a.m_min_ping_time > b.m_min_ping_time;
 }
 
 static bool ReverseCompareNodeTimeConnected(const NodeEvictionCandidate &a,
                                             const NodeEvictionCandidate &b) {
     return a.m_connected > b.m_connected;
 }
 
 static bool CompareNetGroupKeyed(const NodeEvictionCandidate &a,
                                  const NodeEvictionCandidate &b) {
     return a.nKeyedNetGroup < b.nKeyedNetGroup;
 }
 
 static bool CompareNodeBlockTime(const NodeEvictionCandidate &a,
                                  const NodeEvictionCandidate &b) {
     // There is a fall-through here because it is common for a node to have many
     // peers which have not yet relayed a block.
     if (a.m_last_block_time != b.m_last_block_time) {
         return a.m_last_block_time < b.m_last_block_time;
     }
 
     if (a.fRelevantServices != b.fRelevantServices) {
         return b.fRelevantServices;
     }
 
     return a.m_connected > b.m_connected;
 }
 
 static bool CompareNodeTXTime(const NodeEvictionCandidate &a,
                               const NodeEvictionCandidate &b) {
     // There is a fall-through here because it is common for a node to have more
     // than a few peers that have not yet relayed txn.
     if (a.m_last_tx_time != b.m_last_tx_time) {
         return a.m_last_tx_time < b.m_last_tx_time;
     }
 
     if (a.fRelayTxes != b.fRelayTxes) {
         return b.fRelayTxes;
     }
 
     if (a.fBloomFilter != b.fBloomFilter) {
         return a.fBloomFilter;
     }
 
     return a.m_connected > b.m_connected;
 }
 
 static bool CompareNodeProofTime(const NodeEvictionCandidate &a,
                                  const NodeEvictionCandidate &b) {
     // There is a fall-through here because it is common for a node to have more
     // than a few peers that have not yet relayed proofs. This fallback is also
     // used in the case avalanche is not enabled.
     if (a.m_last_proof_time != b.m_last_proof_time) {
         return a.m_last_proof_time < b.m_last_proof_time;
     }
 
     return a.m_connected > b.m_connected;
 }
 
 // Pick out the potential block-relay only peers, and sort them by last block
 // time.
 static bool CompareNodeBlockRelayOnlyTime(const NodeEvictionCandidate &a,
                                           const NodeEvictionCandidate &b) {
     if (a.fRelayTxes != b.fRelayTxes) {
         return a.fRelayTxes;
     }
 
     if (a.m_last_block_time != b.m_last_block_time) {
         return a.m_last_block_time < b.m_last_block_time;
     }
 
     if (a.fRelevantServices != b.fRelevantServices) {
         return b.fRelevantServices;
     }
 
     return a.m_connected > b.m_connected;
 }
 
 static bool CompareNodeAvailabilityScore(const NodeEvictionCandidate &a,
                                          const NodeEvictionCandidate &b) {
     // Equality can happen if the nodes have no score or it has not been
     // computed yet.
     if (a.availabilityScore != b.availabilityScore) {
         return a.availabilityScore < b.availabilityScore;
     }
 
     return a.m_connected > b.m_connected;
 }
 
 /**
  * Sort eviction candidates by network/localhost and connection uptime.
  * Candidates near the beginning are more likely to be evicted, and those
  * near the end are more likely to be protected, e.g. less likely to be evicted.
  * - First, nodes that are not `is_local` and that do not belong to `network`,
  *   sorted by increasing uptime (from most recently connected to connected
  *   longer).
  * - Then, nodes that are `is_local` or belong to `network`, sorted by
  *   increasing uptime.
  */
 struct CompareNodeNetworkTime {
     const bool m_is_local;
     const Network m_network;
     CompareNodeNetworkTime(bool is_local, Network network)
         : m_is_local(is_local), m_network(network) {}
     bool operator()(const NodeEvictionCandidate &a,
                     const NodeEvictionCandidate &b) const {
         if (m_is_local && a.m_is_local != b.m_is_local) {
             return b.m_is_local;
         }
         if ((a.m_network == m_network) != (b.m_network == m_network)) {
             return b.m_network == m_network;
         }
         return a.m_connected > b.m_connected;
     };
 };
 
 //! Sort an array by the specified comparator, then erase the last K elements
 //! where predicate is true.
 template <typename T, typename Comparator>
 static void EraseLastKElements(
     std::vector<T> &elements, Comparator comparator, size_t k,
     std::function<bool(const NodeEvictionCandidate &)> predicate =
         [](const NodeEvictionCandidate &n) { return true; }) {
     std::sort(elements.begin(), elements.end(), comparator);
     size_t eraseSize = std::min(k, elements.size());
     elements.erase(
         std::remove_if(elements.end() - eraseSize, elements.end(), predicate),
         elements.end());
 }
 
 void ProtectEvictionCandidatesByRatio(
     std::vector<NodeEvictionCandidate> &eviction_candidates) {
     // Protect the half of the remaining nodes which have been connected the
     // longest. This replicates the non-eviction implicit behavior, and
     // precludes attacks that start later.
     // To promote the diversity of our peer connections, reserve up to half of
     // these protected spots for Tor/onion, localhost and I2P peers, even if
     // they're not the longest uptime overall. This helps protect these
     // higher-latency peers that tend to be otherwise disadvantaged under our
     // eviction criteria.
     const size_t initial_size = eviction_candidates.size();
     const size_t total_protect_size{initial_size / 2};
 
     // Disadvantaged networks to protect: I2P, localhost and Tor/onion. In case
     // of equal counts, earlier array members have first opportunity to recover
     // unused slots from the previous iteration.
     struct Net {
         bool is_local;
         Network id;
         size_t count;
     };
     std::array<Net, 3> networks{{{false, NET_I2P, 0},
                                  {/* localhost */ true, NET_MAX, 0},
                                  {false, NET_ONION, 0}}};
 
     // Count and store the number of eviction candidates per network.
     for (Net &n : networks) {
         n.count = std::count_if(
             eviction_candidates.cbegin(), eviction_candidates.cend(),
             [&n](const NodeEvictionCandidate &c) {
                 return n.is_local ? c.m_is_local : c.m_network == n.id;
             });
     }
     // Sort `networks` by ascending candidate count, to give networks having
     // fewer candidates the first opportunity to recover unused protected slots
     // from the previous iteration.
     std::stable_sort(networks.begin(), networks.end(),
                      [](Net a, Net b) { return a.count < b.count; });
 
     // Protect up to 25% of the eviction candidates by disadvantaged network.
     const size_t max_protect_by_network{total_protect_size / 2};
     size_t num_protected{0};
 
     while (num_protected < max_protect_by_network) {
         // Count the number of disadvantaged networks from which we have peers
         // to protect.
         auto num_networks = std::count_if(networks.begin(), networks.end(),
                                           [](const Net &n) { return n.count; });
         if (num_networks == 0) {
             break;
         }
         const size_t disadvantaged_to_protect{max_protect_by_network -
                                               num_protected};
         const size_t protect_per_network{std::max(
             disadvantaged_to_protect / num_networks, static_cast<size_t>(1))};
 
         // Early exit flag if there are no remaining candidates by disadvantaged
         // network.
         bool protected_at_least_one{false};
 
         for (Net &n : networks) {
             if (n.count == 0) {
                 continue;
             }
             const size_t before = eviction_candidates.size();
             EraseLastKElements(
                 eviction_candidates, CompareNodeNetworkTime(n.is_local, n.id),
                 protect_per_network, [&n](const NodeEvictionCandidate &c) {
                     return n.is_local ? c.m_is_local : c.m_network == n.id;
                 });
             const size_t after = eviction_candidates.size();
             if (before > after) {
                 protected_at_least_one = true;
                 const size_t delta{before - after};
                 num_protected += delta;
                 if (num_protected >= max_protect_by_network) {
                     break;
                 }
                 n.count -= delta;
             }
         }
         if (!protected_at_least_one) {
             break;
         }
     }
 
     // Calculate how many we removed, and update our total number of peers that
     // we want to protect based on uptime accordingly.
     assert(num_protected == initial_size - eviction_candidates.size());
     const size_t remaining_to_protect{total_protect_size - num_protected};
     EraseLastKElements(eviction_candidates, ReverseCompareNodeTimeConnected,
                        remaining_to_protect);
 }
 
 [[nodiscard]] std::optional<NodeId>
 SelectNodeToEvict(std::vector<NodeEvictionCandidate> &&vEvictionCandidates) {
     // Protect connections with certain characteristics
 
     // Deterministically select 4 peers to protect by netgroup.
     // An attacker cannot predict which netgroups will be protected
     EraseLastKElements(vEvictionCandidates, CompareNetGroupKeyed, 4);
     // Protect the 8 nodes with the lowest minimum ping time.
     // An attacker cannot manipulate this metric without physically moving nodes
     // closer to the target.
     EraseLastKElements(vEvictionCandidates, ReverseCompareNodeMinPingTime, 8);
     // Protect 4 nodes that most recently sent us novel transactions accepted
     // into our mempool. An attacker cannot manipulate this metric without
     // performing useful work.
     EraseLastKElements(vEvictionCandidates, CompareNodeTXTime, 4);
     // Protect 4 nodes that most recently sent us novel proofs accepted
     // into our proof pool. An attacker cannot manipulate this metric without
     // performing useful work.
     // TODO this filter must happen before the last tx time once avalanche is
     // enabled for pre-consensus.
     EraseLastKElements(vEvictionCandidates, CompareNodeProofTime, 4);
     // Protect up to 8 non-tx-relay peers that have sent us novel blocks.
     EraseLastKElements(vEvictionCandidates, CompareNodeBlockRelayOnlyTime, 8,
                        [](const NodeEvictionCandidate &n) {
                            return !n.fRelayTxes && n.fRelevantServices;
                        });
 
     // Protect 4 nodes that most recently sent us novel blocks.
     // An attacker cannot manipulate this metric without performing useful work.
     EraseLastKElements(vEvictionCandidates, CompareNodeBlockTime, 4);
 
     // Protect up to 128 nodes that have the highest avalanche availability
     // score.
     EraseLastKElements(vEvictionCandidates, CompareNodeAvailabilityScore, 128,
                        [](NodeEvictionCandidate const &n) {
                            return n.availabilityScore > 0.;
                        });
 
     // Protect some of the remaining eviction candidates by ratios of desirable
     // or disadvantaged characteristics.
     ProtectEvictionCandidatesByRatio(vEvictionCandidates);
 
     if (vEvictionCandidates.empty()) {
         return std::nullopt;
     }
 
     // If any remaining peers are preferred for eviction consider only them.
     // This happens after the other preferences since if a peer is really the
     // best by other criteria (esp relaying blocks)
     // then we probably don't want to evict it no matter what.
     if (std::any_of(
             vEvictionCandidates.begin(), vEvictionCandidates.end(),
             [](NodeEvictionCandidate const &n) { return n.prefer_evict; })) {
         vEvictionCandidates.erase(
             std::remove_if(
                 vEvictionCandidates.begin(), vEvictionCandidates.end(),
                 [](NodeEvictionCandidate const &n) { return !n.prefer_evict; }),
             vEvictionCandidates.end());
     }
 
     // Identify the network group with the most connections and youngest member.
     // (vEvictionCandidates is already sorted by reverse connect time)
     uint64_t naMostConnections;
     unsigned int nMostConnections = 0;
     std::chrono::seconds nMostConnectionsTime{0};
     std::map<uint64_t, std::vector<NodeEvictionCandidate>> mapNetGroupNodes;
     for (const NodeEvictionCandidate &node : vEvictionCandidates) {
         std::vector<NodeEvictionCandidate> &group =
             mapNetGroupNodes[node.nKeyedNetGroup];
         group.push_back(node);
         const auto grouptime{group[0].m_connected};
         size_t group_size = group.size();
         if (group_size > nMostConnections ||
             (group_size == nMostConnections &&
              grouptime > nMostConnectionsTime)) {
             nMostConnections = group_size;
             nMostConnectionsTime = grouptime;
             naMostConnections = node.nKeyedNetGroup;
         }
     }
 
     // Reduce to the network group with the most connections
     vEvictionCandidates = std::move(mapNetGroupNodes[naMostConnections]);
 
     // Disconnect from the network group with the most connections
     return vEvictionCandidates.front().id;
 }
 
 /** Try to find a connection to evict when the node is full.
  *  Extreme care must be taken to avoid opening the node to attacker
  *   triggered network partitioning.
  *  The strategy used here is to protect a small number of peers
  *   for each of several distinct characteristics which are difficult
  *   to forge.  In order to partition a node the attacker must be
  *   simultaneously better at all of them than honest peers.
  */
 bool CConnman::AttemptToEvictConnection() {
     std::vector<NodeEvictionCandidate> vEvictionCandidates;
     {
         LOCK(m_nodes_mutex);
         for (const CNode *node : m_nodes) {
             if (node->HasPermission(NetPermissionFlags::NoBan)) {
                 continue;
             }
             if (!node->IsInboundConn()) {
                 continue;
             }
             if (node->fDisconnect) {
                 continue;
             }
             bool peer_relay_txes = false;
             bool peer_filter_not_null = false;
             if (node->m_tx_relay != nullptr) {
                 LOCK(node->m_tx_relay->cs_filter);
                 peer_relay_txes = node->m_tx_relay->fRelayTxes;
                 peer_filter_not_null = node->m_tx_relay->pfilter != nullptr;
             }
 
             NodeEvictionCandidate candidate = {
                 node->GetId(),
                 node->m_connected,
                 node->m_min_ping_time,
                 node->m_last_block_time,
                 node->m_last_proof_time,
                 node->m_last_tx_time,
                 HasAllDesirableServiceFlags(node->nServices),
                 peer_relay_txes,
                 peer_filter_not_null,
                 node->nKeyedNetGroup,
                 node->m_prefer_evict,
                 node->addr.IsLocal(),
                 node->ConnectedThroughNetwork(),
                 node->m_avalanche_enabled
                     ? node->getAvailabilityScore()
                     : -std::numeric_limits<double>::infinity()};
             vEvictionCandidates.push_back(candidate);
         }
     }
     const std::optional<NodeId> node_id_to_evict =
         SelectNodeToEvict(std::move(vEvictionCandidates));
     if (!node_id_to_evict) {
         return false;
     }
     LOCK(m_nodes_mutex);
     for (CNode *pnode : m_nodes) {
         if (pnode->GetId() == *node_id_to_evict) {
             LogPrint(
                 BCLog::NET,
                 "selected %s connection for eviction peer=%d; disconnecting\n",
                 pnode->ConnectionTypeAsString(), pnode->GetId());
             pnode->fDisconnect = true;
             return true;
         }
     }
     return false;
 }
 
 void CConnman::AcceptConnection(const ListenSocket &hListenSocket) {
     struct sockaddr_storage sockaddr;
     socklen_t len = sizeof(sockaddr);
     SOCKET hSocket =
         accept(hListenSocket.socket, (struct sockaddr *)&sockaddr, &len);
     CAddress addr;
 
     if (hSocket == INVALID_SOCKET) {
         const int nErr = WSAGetLastError();
         if (nErr != WSAEWOULDBLOCK) {
             LogPrintf("socket error accept failed: %s\n",
                       NetworkErrorString(nErr));
         }
         return;
     }
 
     if (!addr.SetSockAddr((const struct sockaddr *)&sockaddr)) {
         LogPrintf("Warning: Unknown socket family\n");
     }
 
     const CAddress addr_bind = GetBindAddress(hSocket);
 
     NetPermissionFlags permissionFlags = NetPermissionFlags::None;
     hListenSocket.AddSocketPermissionFlags(permissionFlags);
 
     CreateNodeFromAcceptedSocket(hSocket, permissionFlags, addr_bind, addr);
 }
 
 void CConnman::CreateNodeFromAcceptedSocket(SOCKET hSocket,
                                             NetPermissionFlags permissionFlags,
                                             const CAddress &addr_bind,
                                             const CAddress &addr) {
     int nInbound = 0;
     int nMaxInbound = nMaxConnections - m_max_outbound;
 
     AddWhitelistPermissionFlags(permissionFlags, addr);
     if (NetPermissions::HasFlag(permissionFlags,
                                 NetPermissionFlags::Implicit)) {
         NetPermissions::ClearFlag(permissionFlags,
                                   NetPermissionFlags::Implicit);
         if (gArgs.GetBoolArg("-whitelistforcerelay",
                              DEFAULT_WHITELISTFORCERELAY)) {
             NetPermissions::AddFlag(permissionFlags,
                                     NetPermissionFlags::ForceRelay);
         }
         if (gArgs.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY)) {
             NetPermissions::AddFlag(permissionFlags, NetPermissionFlags::Relay);
         }
         NetPermissions::AddFlag(permissionFlags, NetPermissionFlags::Mempool);
         NetPermissions::AddFlag(permissionFlags, NetPermissionFlags::NoBan);
     }
 
     {
         LOCK(m_nodes_mutex);
         for (const CNode *pnode : m_nodes) {
             if (pnode->IsInboundConn()) {
                 nInbound++;
             }
         }
     }
 
     if (!fNetworkActive) {
         LogPrint(BCLog::NET,
                  "connection from %s dropped: not accepting new connections\n",
                  addr.ToString());
         CloseSocket(hSocket);
         return;
     }
 
     if (!IsSelectableSocket(hSocket)) {
         LogPrintf("connection from %s dropped: non-selectable socket\n",
                   addr.ToString());
         CloseSocket(hSocket);
         return;
     }
 
     // According to the internet TCP_NODELAY is not carried into accepted
     // sockets on all platforms.  Set it again here just to be sure.
     SetSocketNoDelay(hSocket);
 
     // Don't accept connections from banned peers.
     bool banned = m_banman && m_banman->IsBanned(addr);
     if (!NetPermissions::HasFlag(permissionFlags, NetPermissionFlags::NoBan) &&
         banned) {
         LogPrint(BCLog::NET, "connection from %s dropped (banned)\n",
                  addr.ToString());
         CloseSocket(hSocket);
         return;
     }
 
     // Only accept connections from discouraged peers if our inbound slots
     // aren't (almost) full.
     bool discouraged = m_banman && m_banman->IsDiscouraged(addr);
     if (!NetPermissions::HasFlag(permissionFlags, NetPermissionFlags::NoBan) &&
         nInbound + 1 >= nMaxInbound && discouraged) {
         LogPrint(BCLog::NET, "connection from %s dropped (discouraged)\n",
                  addr.ToString());
         CloseSocket(hSocket);
         return;
     }
 
     if (nInbound >= nMaxInbound) {
         if (!AttemptToEvictConnection()) {
             // No connection to evict, disconnect the new connection
             LogPrint(BCLog::NET, "failed to find an eviction candidate - "
                                  "connection dropped (full)\n");
             CloseSocket(hSocket);
             return;
         }
     }
 
     NodeId id = GetNewNodeId();
     uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE)
                          .Write(id)
                          .Finalize();
     uint64_t extra_entropy =
         GetDeterministicRandomizer(RANDOMIZER_ID_EXTRAENTROPY)
             .Write(id)
             .Finalize();
 
     ServiceFlags nodeServices = nLocalServices;
     if (NetPermissions::HasFlag(permissionFlags,
                                 NetPermissionFlags::BloomFilter)) {
         nodeServices = static_cast<ServiceFlags>(nodeServices | NODE_BLOOM);
     }
 
     const bool inbound_onion =
         std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) !=
         m_onion_binds.end();
     CNode *pnode = new CNode(
         id, nodeServices, hSocket, addr, CalculateKeyedNetGroup(addr), nonce,
         extra_entropy, addr_bind, "", ConnectionType::INBOUND, inbound_onion);
     pnode->AddRef();
     pnode->m_permissionFlags = permissionFlags;
     pnode->m_prefer_evict = discouraged;
     for (auto interface : m_msgproc) {
         interface->InitializeNode(*config, pnode);
     }
 
     LogPrint(BCLog::NET, "connection from %s accepted\n", addr.ToString());
 
     {
         LOCK(m_nodes_mutex);
         m_nodes.push_back(pnode);
     }
 
     // We received a new connection, harvest entropy from the time (and our peer
     // count)
     RandAddEvent(uint32_t(id));
 }
 
 bool CConnman::AddConnection(const std::string &address,
                              ConnectionType conn_type) {
     std::optional<int> max_connections;
     switch (conn_type) {
         case ConnectionType::INBOUND:
         case ConnectionType::MANUAL:
             return false;
         case ConnectionType::OUTBOUND_FULL_RELAY:
             max_connections = m_max_outbound_full_relay;
             break;
         case ConnectionType::BLOCK_RELAY:
             max_connections = m_max_outbound_block_relay;
             break;
         // no limit for ADDR_FETCH because -seednode has no limit either
         case ConnectionType::ADDR_FETCH:
             break;
         // no limit for FEELER connections since they're short-lived
         case ConnectionType::FEELER:
             break;
         case ConnectionType::AVALANCHE_OUTBOUND:
             max_connections = m_max_avalanche_outbound;
             break;
     } // no default case, so the compiler can warn about missing cases
 
     // Count existing connections
     int existing_connections =
         WITH_LOCK(m_nodes_mutex,
                   return std::count_if(
                       m_nodes.begin(), m_nodes.end(), [conn_type](CNode *node) {
                           return node->m_conn_type == conn_type;
                       }););
 
     // Max connections of specified type already exist
     if (max_connections != std::nullopt &&
         existing_connections >= max_connections) {
         return false;
     }
 
     // Max total outbound connections already exist
     CSemaphoreGrant grant(*semOutbound, true);
     if (!grant) {
         return false;
     }
 
     OpenNetworkConnection(CAddress(), false, &grant, address.c_str(),
                           conn_type);
     return true;
 }
 
 void CConnman::DisconnectNodes() {
     {
         LOCK(m_nodes_mutex);
 
         if (!fNetworkActive) {
             // Disconnect any connected nodes
             for (CNode *pnode : m_nodes) {
                 if (!pnode->fDisconnect) {
                     LogPrint(BCLog::NET,
                              "Network not active, dropping peer=%d\n",
                              pnode->GetId());
                     pnode->fDisconnect = true;
                 }
             }
         }
 
         // Disconnect unused nodes
         std::vector<CNode *> nodes_copy = m_nodes;
         for (CNode *pnode : nodes_copy) {
             if (pnode->fDisconnect) {
                 // remove from m_nodes
                 m_nodes.erase(remove(m_nodes.begin(), m_nodes.end(), pnode),
                               m_nodes.end());
 
                 // release outbound grant (if any)
                 pnode->grantOutbound.Release();
 
                 // close socket and cleanup
                 pnode->CloseSocketDisconnect();
 
                 // hold in disconnected pool until all refs are released
                 pnode->Release();
                 m_nodes_disconnected.push_back(pnode);
             }
         }
     }
     {
         // Delete disconnected nodes
         std::list<CNode *> nodes_disconnected_copy = m_nodes_disconnected;
         for (CNode *pnode : nodes_disconnected_copy) {
             // Destroy the object only after other threads have stopped using
             // it.
             if (pnode->GetRefCount() <= 0) {
                 m_nodes_disconnected.remove(pnode);
                 DeleteNode(pnode);
             }
         }
     }
 }
 
 void CConnman::NotifyNumConnectionsChanged() {
     size_t nodes_size;
     {
         LOCK(m_nodes_mutex);
         nodes_size = m_nodes.size();
     }
     if (nodes_size != nPrevNodeCount) {
         nPrevNodeCount = nodes_size;
         if (m_client_interface) {
             m_client_interface->NotifyNumConnectionsChanged(nodes_size);
         }
     }
 }
 
 bool CConnman::ShouldRunInactivityChecks(const CNode &node,
                                          std::chrono::seconds now) const {
     return node.m_connected + m_peer_connect_timeout < now;
 }
 
 bool CConnman::InactivityCheck(const CNode &node) const {
     // Tests that see disconnects after using mocktime can start nodes with a
     // large timeout. For example, -peertimeout=999999999.
     const auto now{GetTime<std::chrono::seconds>()};
     const auto last_send{node.m_last_send.load()};
     const auto last_recv{node.m_last_recv.load()};
 
     if (!ShouldRunInactivityChecks(node, now)) {
         return false;
     }
 
     if (last_recv.count() == 0 || last_send.count() == 0) {
         LogPrint(BCLog::NET,
                  "socket no message in first %i seconds, %d %d peer=%d\n",
                  count_seconds(m_peer_connect_timeout), last_recv.count() != 0,
                  last_send.count() != 0, node.GetId());
         return true;
     }
 
     if (now > last_send + TIMEOUT_INTERVAL) {
         LogPrint(BCLog::NET, "socket sending timeout: %is peer=%d\n",
                  count_seconds(now - last_send), node.GetId());
         return true;
     }
 
     if (now > last_recv + TIMEOUT_INTERVAL) {
         LogPrint(BCLog::NET, "socket receive timeout: %is peer=%d\n",
                  count_seconds(now - last_recv), node.GetId());
         return true;
     }
 
     if (!node.fSuccessfullyConnected) {
         LogPrint(BCLog::NET, "version handshake timeout peer=%d\n",
                  node.GetId());
         return true;
     }
 
     return false;
 }
 
 bool CConnman::GenerateSelectSet(std::set<SOCKET> &recv_set,
                                  std::set<SOCKET> &send_set,
                                  std::set<SOCKET> &error_set) {
     for (const ListenSocket &hListenSocket : vhListenSocket) {
         recv_set.insert(hListenSocket.socket);
     }
 
     {
         LOCK(m_nodes_mutex);
         for (CNode *pnode : m_nodes) {
             // Implement the following logic:
             // * If there is data to send, select() for sending data. As this
             //   only happens when optimistic write failed, we choose to first
             //   drain the write buffer in this case before receiving more. This
             //   avoids needlessly queueing received data, if the remote peer is
             //   not themselves receiving data. This means properly utilizing
             //   TCP flow control signalling.
             // * Otherwise, if there is space left in the receive buffer,
             //   select() for receiving data.
             // * Hand off all complete messages to the processor, to be handled
             //   without blocking here.
 
             bool select_recv = !pnode->fPauseRecv;
             bool select_send;
             {
                 LOCK(pnode->cs_vSend);
                 select_send = !pnode->vSendMsg.empty();
             }
 
             LOCK(pnode->cs_hSocket);
             if (pnode->hSocket == INVALID_SOCKET) {
                 continue;
             }
 
             error_set.insert(pnode->hSocket);
             if (select_send) {
                 send_set.insert(pnode->hSocket);
                 continue;
             }
             if (select_recv) {
                 recv_set.insert(pnode->hSocket);
             }
         }
     }
 
     return !recv_set.empty() || !send_set.empty() || !error_set.empty();
 }
 
 #ifdef USE_POLL
 void CConnman::SocketEvents(std::set<SOCKET> &recv_set,
                             std::set<SOCKET> &send_set,
                             std::set<SOCKET> &error_set) {
     std::set<SOCKET> recv_select_set, send_select_set, error_select_set;
     if (!GenerateSelectSet(recv_select_set, send_select_set,
                            error_select_set)) {
         interruptNet.sleep_for(
             std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS));
         return;
     }
 
     std::unordered_map<SOCKET, struct pollfd> pollfds;
     for (SOCKET socket_id : recv_select_set) {
         pollfds[socket_id].fd = socket_id;
         pollfds[socket_id].events |= POLLIN;
     }
 
     for (SOCKET socket_id : send_select_set) {
         pollfds[socket_id].fd = socket_id;
         pollfds[socket_id].events |= POLLOUT;
     }
 
     for (SOCKET socket_id : error_select_set) {
         pollfds[socket_id].fd = socket_id;
         // These flags are ignored, but we set them for clarity
         pollfds[socket_id].events |= POLLERR | POLLHUP;
     }
 
     std::vector<struct pollfd> vpollfds;
     vpollfds.reserve(pollfds.size());
     for (auto it : pollfds) {
         vpollfds.push_back(std::move(it.second));
     }
 
     if (poll(vpollfds.data(), vpollfds.size(), SELECT_TIMEOUT_MILLISECONDS) <
         0) {
         return;
     }
 
     if (interruptNet) {
         return;
     }
 
     for (struct pollfd pollfd_entry : vpollfds) {
         if (pollfd_entry.revents & POLLIN) {
             recv_set.insert(pollfd_entry.fd);
         }
         if (pollfd_entry.revents & POLLOUT) {
             send_set.insert(pollfd_entry.fd);
         }
         if (pollfd_entry.revents & (POLLERR | POLLHUP)) {
             error_set.insert(pollfd_entry.fd);
         }
     }
 }
 #else
 void CConnman::SocketEvents(std::set<SOCKET> &recv_set,
                             std::set<SOCKET> &send_set,
                             std::set<SOCKET> &error_set) {
     std::set<SOCKET> recv_select_set, send_select_set, error_select_set;
     if (!GenerateSelectSet(recv_select_set, send_select_set,
                            error_select_set)) {
         interruptNet.sleep_for(
             std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS));
         return;
     }
 
     //
     // Find which sockets have data to receive
     //
     struct timeval timeout;
     timeout.tv_sec = 0;
     // frequency to poll pnode->vSend
     timeout.tv_usec = SELECT_TIMEOUT_MILLISECONDS * 1000;
 
     fd_set fdsetRecv;
     fd_set fdsetSend;
     fd_set fdsetError;
     FD_ZERO(&fdsetRecv);
     FD_ZERO(&fdsetSend);
     FD_ZERO(&fdsetError);
     SOCKET hSocketMax = 0;
 
     for (SOCKET hSocket : recv_select_set) {
         FD_SET(hSocket, &fdsetRecv);
         hSocketMax = std::max(hSocketMax, hSocket);
     }
 
     for (SOCKET hSocket : send_select_set) {
         FD_SET(hSocket, &fdsetSend);
         hSocketMax = std::max(hSocketMax, hSocket);
     }
 
     for (SOCKET hSocket : error_select_set) {
         FD_SET(hSocket, &fdsetError);
         hSocketMax = std::max(hSocketMax, hSocket);
     }
 
     int nSelect =
         select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
 
     if (interruptNet) {
         return;
     }
 
     if (nSelect == SOCKET_ERROR) {
         int nErr = WSAGetLastError();
         LogPrintf("socket select error %s\n", NetworkErrorString(nErr));
         for (unsigned int i = 0; i <= hSocketMax; i++) {
             FD_SET(i, &fdsetRecv);
         }
         FD_ZERO(&fdsetSend);
         FD_ZERO(&fdsetError);
         if (!interruptNet.sleep_for(
                 std::chrono::milliseconds(SELECT_TIMEOUT_MILLISECONDS))) {
             return;
         }
     }
 
     for (SOCKET hSocket : recv_select_set) {
         if (FD_ISSET(hSocket, &fdsetRecv)) {
             recv_set.insert(hSocket);
         }
     }
 
     for (SOCKET hSocket : send_select_set) {
         if (FD_ISSET(hSocket, &fdsetSend)) {
             send_set.insert(hSocket);
         }
     }
 
     for (SOCKET hSocket : error_select_set) {
         if (FD_ISSET(hSocket, &fdsetError)) {
             error_set.insert(hSocket);
         }
     }
 }
 #endif
 
 void CConnman::SocketHandler() {
     std::set<SOCKET> recv_set, send_set, error_set;
     SocketEvents(recv_set, send_set, error_set);
 
     if (interruptNet) {
         return;
     }
 
     //
     // Accept new connections
     //
     for (const ListenSocket &hListenSocket : vhListenSocket) {
         if (hListenSocket.socket != INVALID_SOCKET &&
             recv_set.count(hListenSocket.socket) > 0) {
             AcceptConnection(hListenSocket);
         }
     }
 
     //
     // Service each socket
     //
     std::vector<CNode *> nodes_copy;
     {
         LOCK(m_nodes_mutex);
         nodes_copy = m_nodes;
         for (CNode *pnode : nodes_copy) {
             pnode->AddRef();
         }
     }
     for (CNode *pnode : nodes_copy) {
         if (interruptNet) {
             return;
         }
 
         //
         // Receive
         //
         bool recvSet = false;
         bool sendSet = false;
         bool errorSet = false;
         {
             LOCK(pnode->cs_hSocket);
             if (pnode->hSocket == INVALID_SOCKET) {
                 continue;
             }
             recvSet = recv_set.count(pnode->hSocket) > 0;
             sendSet = send_set.count(pnode->hSocket) > 0;
             errorSet = error_set.count(pnode->hSocket) > 0;
         }
         if (recvSet || errorSet) {
             // typical socket buffer is 8K-64K
             uint8_t pchBuf[0x10000];
             int32_t nBytes = 0;
             {
                 LOCK(pnode->cs_hSocket);
                 if (pnode->hSocket == INVALID_SOCKET) {
                     continue;
                 }
                 nBytes = recv(pnode->hSocket, (char *)pchBuf, sizeof(pchBuf),
                               MSG_DONTWAIT);
             }
             if (nBytes > 0) {
                 bool notify = false;
                 if (!pnode->ReceiveMsgBytes(
                         *config, Span<const uint8_t>(pchBuf, nBytes), notify)) {
                     pnode->CloseSocketDisconnect();
                 }
                 RecordBytesRecv(nBytes);
                 if (notify) {
                     size_t nSizeAdded = 0;
                     auto it(pnode->vRecvMsg.begin());
                     for (; it != pnode->vRecvMsg.end(); ++it) {
                         // vRecvMsg contains only completed CNetMessage
                         // the single possible partially deserialized message
                         // are held by TransportDeserializer
                         nSizeAdded += it->m_raw_message_size;
                     }
                     {
                         LOCK(pnode->cs_vProcessMsg);
                         pnode->vProcessMsg.splice(pnode->vProcessMsg.end(),
                                                   pnode->vRecvMsg,
                                                   pnode->vRecvMsg.begin(), it);
                         pnode->nProcessQueueSize += nSizeAdded;
                         pnode->fPauseRecv =
                             pnode->nProcessQueueSize > nReceiveFloodSize;
                     }
                     WakeMessageHandler();
                 }
             } else if (nBytes == 0) {
                 // socket closed gracefully
                 if (!pnode->fDisconnect) {
                     LogPrint(BCLog::NET, "socket closed for peer=%d\n",
                              pnode->GetId());
                 }
                 pnode->CloseSocketDisconnect();
             } else if (nBytes < 0) {
                 // error
                 int nErr = WSAGetLastError();
                 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE &&
                     nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
                     if (!pnode->fDisconnect) {
                         LogPrint(BCLog::NET,
                                  "socket recv error for peer=%d: %s\n",
                                  pnode->GetId(), NetworkErrorString(nErr));
                     }
                     pnode->CloseSocketDisconnect();
                 }
             }
         }
 
         if (sendSet) {
             // Send data
             size_t bytes_sent =
                 WITH_LOCK(pnode->cs_vSend, return SocketSendData(*pnode));
             if (bytes_sent) {
                 RecordBytesSent(bytes_sent);
             }
         }
 
         if (InactivityCheck(*pnode)) {
             pnode->fDisconnect = true;
         }
     }
     {
         LOCK(m_nodes_mutex);
         for (CNode *pnode : nodes_copy) {
             pnode->Release();
         }
     }
 }
 
 void CConnman::ThreadSocketHandler() {
     while (!interruptNet) {
         DisconnectNodes();
         NotifyNumConnectionsChanged();
         SocketHandler();
     }
 }
 
 void CConnman::WakeMessageHandler() {
     {
         LOCK(mutexMsgProc);
         fMsgProcWake = true;
     }
     condMsgProc.notify_one();
 }
 
 void CConnman::ThreadDNSAddressSeed() {
     FastRandomContext rng;
     std::vector<std::string> seeds =
         GetRandomizedDNSSeeds(config->GetChainParams());
     // Number of seeds left before testing if we have enough connections
     int seeds_right_now = 0;
     int found = 0;
 
     if (gArgs.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED)) {
         // When -forcednsseed is provided, query all.
         seeds_right_now = seeds.size();
     } else if (addrman.size() == 0) {
         // If we have no known peers, query all.
         // This will occur on the first run, or if peers.dat has been
         // deleted.
         seeds_right_now = seeds.size();
     }
 
     // goal: only query DNS seed if address need is acute
     // * If we have a reasonable number of peers in addrman, spend
     //   some time trying them first. This improves user privacy by
     //   creating fewer identifying DNS requests, reduces trust by
     //   giving seeds less influence on the network topology, and
     //   reduces traffic to the seeds.
     // * When querying DNS seeds query a few at once, this ensures
     //   that we don't give DNS seeds the ability to eclipse nodes
     //   that query them.
     // * If we continue having problems, eventually query all the
     //   DNS seeds, and if that fails too, also try the fixed seeds.
     //   (done in ThreadOpenConnections)
     const std::chrono::seconds seeds_wait_time =
         (addrman.size() >= DNSSEEDS_DELAY_PEER_THRESHOLD
              ? DNSSEEDS_DELAY_MANY_PEERS
              : DNSSEEDS_DELAY_FEW_PEERS);
 
     for (const std::string &seed : seeds) {
         if (seeds_right_now == 0) {
             seeds_right_now += DNSSEEDS_TO_QUERY_AT_ONCE;
 
             if (addrman.size() > 0) {
                 LogPrintf("Waiting %d seconds before querying DNS seeds.\n",
                           seeds_wait_time.count());
                 std::chrono::seconds to_wait = seeds_wait_time;
                 while (to_wait.count() > 0) {
                     // if sleeping for the MANY_PEERS interval, wake up
                     // early to see if we have enough peers and can stop
                     // this thread entirely freeing up its resources
                     std::chrono::seconds w =
                         std::min(DNSSEEDS_DELAY_FEW_PEERS, to_wait);
                     if (!interruptNet.sleep_for(w)) {
                         return;
                     }
                     to_wait -= w;
 
                     int nRelevant = 0;
                     {
                         LOCK(m_nodes_mutex);
                         for (const CNode *pnode : m_nodes) {
                             if (pnode->fSuccessfullyConnected &&
                                 pnode->IsFullOutboundConn()) {
                                 ++nRelevant;
                             }
                         }
                     }
                     if (nRelevant >= 2) {
                         if (found > 0) {
                             LogPrintf("%d addresses found from DNS seeds\n",
                                       found);
                             LogPrintf(
                                 "P2P peers available. Finished DNS seeding.\n");
                         } else {
                             LogPrintf(
                                 "P2P peers available. Skipped DNS seeding.\n");
                         }
                         return;
                     }
                 }
             }
         }
 
         if (interruptNet) {
             return;
         }
 
         // hold off on querying seeds if P2P network deactivated
         if (!fNetworkActive) {
             LogPrintf("Waiting for network to be reactivated before querying "
                       "DNS seeds.\n");
             do {
                 if (!interruptNet.sleep_for(std::chrono::seconds{1})) {
                     return;
                 }
             } while (!fNetworkActive);
         }
 
         LogPrintf("Loading addresses from DNS seed %s\n", seed);
         if (HaveNameProxy()) {
             AddAddrFetch(seed);
         } else {
             std::vector<CNetAddr> vIPs;
             std::vector<CAddress> vAdd;
             ServiceFlags requiredServiceBits =
                 GetDesirableServiceFlags(NODE_NONE);
             std::string host = strprintf("x%x.%s", requiredServiceBits, seed);
             CNetAddr resolveSource;
             if (!resolveSource.SetInternal(host)) {
                 continue;
             }
 
             // Limits number of IPs learned from a DNS seed
             unsigned int nMaxIPs = 256;
             if (LookupHost(host, vIPs, nMaxIPs, true)) {
                 for (const CNetAddr &ip : vIPs) {
                     int nOneDay = 24 * 3600;
                     CAddress addr = CAddress(
                         CService(ip, config->GetChainParams().GetDefaultPort()),
                         requiredServiceBits);
                     // Use a random age between 3 and 7 days old.
                     addr.nTime =
                         GetTime() - 3 * nOneDay - rng.randrange(4 * nOneDay);
                     vAdd.push_back(addr);
                     found++;
                 }
                 addrman.Add(vAdd, resolveSource);
             } else {
                 // We now avoid directly using results from DNS Seeds which do
                 // not support service bit filtering, instead using them as a
                 // addrfetch to get nodes with our desired service bits.
                 AddAddrFetch(seed);
             }
         }
         --seeds_right_now;
     }
     LogPrintf("%d addresses found from DNS seeds\n", found);
 }
 
 void CConnman::DumpAddresses() {
     int64_t nStart = GetTimeMillis();
 
     DumpPeerAddresses(config->GetChainParams(), ::gArgs, addrman);
 
     LogPrint(BCLog::NET, "Flushed %d addresses to peers.dat  %dms\n",
              addrman.size(), GetTimeMillis() - nStart);
 }
 
 void CConnman::ProcessAddrFetch() {
     std::string strDest;
     {
         LOCK(m_addr_fetches_mutex);
         if (m_addr_fetches.empty()) {
             return;
         }
         strDest = m_addr_fetches.front();
         m_addr_fetches.pop_front();
     }
     CAddress addr;
     CSemaphoreGrant grant(*semOutbound, true);
     if (grant) {
         OpenNetworkConnection(addr, false, &grant, strDest.c_str(),
                               ConnectionType::ADDR_FETCH);
     }
 }
 
 bool CConnman::GetTryNewOutboundPeer() const {
     return m_try_another_outbound_peer;
 }
 
 void CConnman::SetTryNewOutboundPeer(bool flag) {
     m_try_another_outbound_peer = flag;
     LogPrint(BCLog::NET, "net: setting try another outbound peer=%s\n",
              flag ? "true" : "false");
 }
 
 // Return the number of peers we have over our outbound connection limit.
 // Exclude peers that are marked for disconnect, or are going to be disconnected
 // soon (eg ADDR_FETCH and FEELER).
 // Also exclude peers that haven't finished initial connection handshake yet (so
 // that we don't decide we're over our desired connection limit, and then evict
 // some peer that has finished the handshake).
 int CConnman::GetExtraFullOutboundCount() const {
     int full_outbound_peers = 0;
     {
         LOCK(m_nodes_mutex);
         for (const CNode *pnode : m_nodes) {
             if (pnode->fSuccessfullyConnected && !pnode->fDisconnect &&
                 pnode->IsFullOutboundConn()) {
                 ++full_outbound_peers;
             }
         }
     }
     return std::max(full_outbound_peers - m_max_outbound_full_relay -
                         m_max_avalanche_outbound,
                     0);
 }
 
 int CConnman::GetExtraBlockRelayCount() const {
     int block_relay_peers = 0;
     {
         LOCK(m_nodes_mutex);
         for (const CNode *pnode : m_nodes) {
             if (pnode->fSuccessfullyConnected && !pnode->fDisconnect &&
                 pnode->IsBlockOnlyConn()) {
                 ++block_relay_peers;
             }
         }
     }
     return std::max(block_relay_peers - m_max_outbound_block_relay, 0);
 }
 
 void CConnman::ThreadOpenConnections(
     const std::vector<std::string> connect,
     std::function<void(const CAddress &, ConnectionType)> mockOpenConnection) {
     // Connect to specific addresses
     if (!connect.empty()) {
         for (int64_t nLoop = 0;; nLoop++) {
             ProcessAddrFetch();
             for (const std::string &strAddr : connect) {
                 CAddress addr(CService(), NODE_NONE);
                 OpenNetworkConnection(addr, false, nullptr, strAddr.c_str(),
                                       ConnectionType::MANUAL);
                 for (int i = 0; i < 10 && i < nLoop; i++) {
                     if (!interruptNet.sleep_for(
                             std::chrono::milliseconds(500))) {
                         return;
                     }
                 }
             }
             if (!interruptNet.sleep_for(std::chrono::milliseconds(500))) {
                 return;
             }
         }
     }
 
     // Initiate network connections
     auto start = GetTime<std::chrono::microseconds>();
 
     // Minimum time before next feeler connection (in microseconds).
     auto next_feeler = PoissonNextSend(start, FEELER_INTERVAL);
     auto next_extra_block_relay =
         PoissonNextSend(start, EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
     const bool dnsseed = gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED);
     bool add_fixed_seeds = gArgs.GetBoolArg("-fixedseeds", DEFAULT_FIXEDSEEDS);
 
     if (!add_fixed_seeds) {
         LogPrintf("Fixed seeds are disabled\n");
     }
 
     while (!interruptNet) {
         ProcessAddrFetch();
 
         // No need to sleep the thread if we are mocking the network connection
         if (!mockOpenConnection &&
             !interruptNet.sleep_for(std::chrono::milliseconds(500))) {
             return;
         }
 
         CSemaphoreGrant grant(*semOutbound);
         if (interruptNet) {
             return;
         }
 
         if (add_fixed_seeds && addrman.size() == 0) {
             // When the node starts with an empty peers.dat, there are a few
             // other sources of peers before we fallback on to fixed seeds:
             // -dnsseed, -seednode, -addnode If none of those are available, we
             // fallback on to fixed seeds immediately, else we allow 60 seconds
             // for any of those sources to populate addrman.
             bool add_fixed_seeds_now = false;
             // It is cheapest to check if enough time has passed first.
             if (GetTime<std::chrono::seconds>() >
                 start + std::chrono::minutes{1}) {
                 add_fixed_seeds_now = true;
                 LogPrintf("Adding fixed seeds as 60 seconds have passed and "
                           "addrman is empty\n");
             }
 
             // Checking !dnsseed is cheaper before locking 2 mutexes.
             if (!add_fixed_seeds_now && !dnsseed) {
                 LOCK2(m_addr_fetches_mutex, m_added_nodes_mutex);
                 if (m_addr_fetches.empty() && m_added_nodes.empty()) {
                     add_fixed_seeds_now = true;
                     LogPrintf(
                         "Adding fixed seeds as -dnsseed=0, -addnode is not "
                         "provided and all -seednode(s) attempted\n");
                 }
             }
 
             if (add_fixed_seeds_now) {
                 CNetAddr local;
                 local.SetInternal("fixedseeds");
                 addrman.Add(convertSeed6(config->GetChainParams().FixedSeeds()),
                             local);
                 add_fixed_seeds = false;
             }
         }
 
         //
         // Choose an address to connect to based on most recently seen
         //
         CAddress addrConnect;
 
         // Only connect out to one peer per network group (/16 for IPv4).
         int nOutboundFullRelay = 0;
         int nOutboundBlockRelay = 0;
         int nOutboundAvalanche = 0;
         std::set<std::vector<uint8_t>> setConnected;
 
         {
             LOCK(m_nodes_mutex);
             for (const CNode *pnode : m_nodes) {
                 if (pnode->IsAvalancheOutboundConnection()) {
                     nOutboundAvalanche++;
                 } else if (pnode->IsFullOutboundConn()) {
                     nOutboundFullRelay++;
                 } else if (pnode->IsBlockOnlyConn()) {
                     nOutboundBlockRelay++;
                 }
 
                 // Netgroups for inbound and manual peers are not excluded
                 // because our goal here is to not use multiple of our
                 // limited outbound slots on a single netgroup but inbound
                 // and manual peers do not use our outbound slots. Inbound
                 // peers also have the added issue that they could be attacker
                 // controlled and could be used to prevent us from connecting
                 // to particular hosts if we used them here.
                 switch (pnode->m_conn_type) {
                     case ConnectionType::INBOUND:
                     case ConnectionType::MANUAL:
                         break;
                     case ConnectionType::AVALANCHE_OUTBOUND:
                     case ConnectionType::OUTBOUND_FULL_RELAY:
                     case ConnectionType::BLOCK_RELAY:
                     case ConnectionType::ADDR_FETCH:
                     case ConnectionType::FEELER:
                         setConnected.insert(
                             pnode->addr.GetGroup(addrman.GetAsmap()));
                 } // no default case, so the compiler can warn about missing
                   // cases
             }
         }
 
         ConnectionType conn_type = ConnectionType::OUTBOUND_FULL_RELAY;
         auto now = GetTime<std::chrono::microseconds>();
         bool anchor = false;
         bool fFeeler = false;
 
         // Determine what type of connection to open. Opening
         // BLOCK_RELAY connections to addresses from anchors.dat gets the
         // highest priority. Then we open AVALANCHE_OUTBOUND connection until we
         // hit our avalanche outbound peer limit, which is 0 if avalanche is not
         // enabled. We fallback after 50 retries to OUTBOUND_FULL_RELAY if the
         // peer is not avalanche capable until we meet our full-relay capacity.
         // Then we open BLOCK_RELAY connection until we hit our block-relay-only
         // peer limit.
         // GetTryNewOutboundPeer() gets set when a stale tip is detected, so we
         // try opening an additional OUTBOUND_FULL_RELAY connection. If none of
         // these conditions are met, check to see if it's time to try an extra
         // block-relay-only peer (to confirm our tip is current, see below) or
         // the next_feeler timer to decide if we should open a FEELER.
 
         if (!m_anchors.empty() &&
             (nOutboundBlockRelay < m_max_outbound_block_relay)) {
             conn_type = ConnectionType::BLOCK_RELAY;
             anchor = true;
         } else if (g_avalanche &&
                    (nOutboundAvalanche < m_max_avalanche_outbound)) {
             conn_type = ConnectionType::AVALANCHE_OUTBOUND;
         } else if (nOutboundFullRelay < m_max_outbound_full_relay) {
             // OUTBOUND_FULL_RELAY
         } else if (nOutboundBlockRelay < m_max_outbound_block_relay) {
             conn_type = ConnectionType::BLOCK_RELAY;
         } else if (GetTryNewOutboundPeer()) {
             // OUTBOUND_FULL_RELAY
         } else if (now > next_extra_block_relay &&
                    m_start_extra_block_relay_peers) {
             // Periodically connect to a peer (using regular outbound selection
             // methodology from addrman) and stay connected long enough to sync
             // headers, but not much else.
             //
             // Then disconnect the peer, if we haven't learned anything new.
             //
             // The idea is to make eclipse attacks very difficult to pull off,
             // because every few minutes we're finding a new peer to learn
             // headers from.
             //
             // This is similar to the logic for trying extra outbound
             // (full-relay) peers, except:
             // - we do this all the time on a poisson timer, rather than just
             //   when our tip is stale
             // - we potentially disconnect our next-youngest block-relay-only
             //   peer, if our newest block-relay-only peer delivers a block more
             //   recently.
             //   See the eviction logic in net_processing.cpp.
             //
             // Because we can promote these connections to block-relay-only
             // connections, they do not get their own ConnectionType enum
             // (similar to how we deal with extra outbound peers).
             next_extra_block_relay =
                 PoissonNextSend(now, EXTRA_BLOCK_RELAY_ONLY_PEER_INTERVAL);
             conn_type = ConnectionType::BLOCK_RELAY;
         } else if (now > next_feeler) {
             next_feeler = PoissonNextSend(now, FEELER_INTERVAL);
             conn_type = ConnectionType::FEELER;
             fFeeler = true;
         } else {
             // skip to next iteration of while loop
             continue;
         }
 
         addrman.ResolveCollisions();
 
         int64_t nANow = GetAdjustedTime();
         int nTries = 0;
         while (!interruptNet) {
             if (anchor && !m_anchors.empty()) {
                 const CAddress addr = m_anchors.back();
                 m_anchors.pop_back();
                 if (!addr.IsValid() || IsLocal(addr) || !IsReachable(addr) ||
                     !HasAllDesirableServiceFlags(addr.nServices) ||
                     setConnected.count(addr.GetGroup(addrman.GetAsmap()))) {
                     continue;
                 }
                 addrConnect = addr;
                 LogPrint(BCLog::NET,
                          "Trying to make an anchor connection to %s\n",
                          addrConnect.ToString());
                 break;
             }
             // If we didn't find an appropriate destination after trying 100
             // addresses fetched from addrman, stop this loop, and let the outer
             // loop run again (which sleeps, adds seed nodes, recalculates
             // already-connected network ranges, ...) before trying new addrman
             // addresses.
             nTries++;
             if (nTries > 100) {
                 break;
             }
 
             CAddress addr;
             int64_t addr_last_try{0};
 
             if (fFeeler) {
                 // First, try to get a tried table collision address. This
                 // returns an empty (invalid) address if there are no collisions
                 // to try.
                 std::tie(addr, addr_last_try) = addrman.SelectTriedCollision();
 
                 if (!addr.IsValid()) {
                     // No tried table collisions. Select a new table address
                     // for our feeler.
                     std::tie(addr, addr_last_try) = addrman.Select(true);
                 } else if (AlreadyConnectedToAddress(addr)) {
                     // If test-before-evict logic would have us connect to a
                     // peer that we're already connected to, just mark that
                     // address as Good(). We won't be able to initiate the
                     // connection anyway, so this avoids inadvertently evicting
                     // a currently-connected peer.
                     addrman.Good(addr);
                     // Select a new table address for our feeler instead.
                     std::tie(addr, addr_last_try) = addrman.Select(true);
                 }
             } else {
                 // Not a feeler
                 std::tie(addr, addr_last_try) = addrman.Select();
             }
 
             // Require outbound connections, other than feelers and avalanche,
             // to be to distinct network groups
             if (!fFeeler && conn_type != ConnectionType::AVALANCHE_OUTBOUND &&
                 setConnected.count(addr.GetGroup(addrman.GetAsmap()))) {
                 break;
             }
 
             // if we selected an invalid or local address, restart
             if (!addr.IsValid() || IsLocal(addr)) {
                 break;
             }
 
             if (!IsReachable(addr)) {
                 continue;
             }
 
             // only consider very recently tried nodes after 30 failed attempts
             if (nANow - addr_last_try < 600 && nTries < 30) {
                 continue;
             }
 
             // for non-feelers, require all the services we'll want,
             // for feelers, only require they be a full node (only because most
             // SPV clients don't have a good address DB available)
             if (!fFeeler && !HasAllDesirableServiceFlags(addr.nServices)) {
                 continue;
             }
 
             if (fFeeler && !MayHaveUsefulAddressDB(addr.nServices)) {
                 continue;
             }
 
             // Do not connect to bad ports, unless 50 invalid addresses have
             // been selected already.
             if (nTries < 50 && (addr.IsIPv4() || addr.IsIPv6()) &&
                 IsBadPort(addr.GetPort())) {
                 continue;
             }
 
             // For avalanche peers, check they have the avalanche service bit
             // set.
             if (conn_type == ConnectionType::AVALANCHE_OUTBOUND &&
                 !(addr.nServices & NODE_AVALANCHE)) {
                 // If this peer is not suitable as an avalanche one and we tried
                 // over 50 addresses already, see if we can fallback to a non
                 // avalanche full outbound.
                 if (nTries < 50 ||
                     nOutboundFullRelay >= m_max_outbound_full_relay ||
                     setConnected.count(addr.GetGroup(addrman.GetAsmap()))) {
                     // Fallback is not desirable or possible, try another one
                     continue;
                 }
 
                 // Fallback is possible, update the connection type accordingly
                 conn_type = ConnectionType::OUTBOUND_FULL_RELAY;
             }
 
             addrConnect = addr;
             break;
         }
 
         if (addrConnect.IsValid()) {
             if (fFeeler) {
                 // Add small amount of random noise before connection to avoid
                 // synchronization.
                 int randsleep = GetRandInt(FEELER_SLEEP_WINDOW * 1000);
                 if (!interruptNet.sleep_for(
                         std::chrono::milliseconds(randsleep))) {
                     return;
                 }
                 LogPrint(BCLog::NET, "Making feeler connection to %s\n",
                          addrConnect.ToString());
             }
 
             // This mock is for testing purpose only. It prevents the thread
             // from attempting the connection which is useful for testing.
             if (mockOpenConnection) {
                 mockOpenConnection(addrConnect, conn_type);
             } else {
                 OpenNetworkConnection(addrConnect,
                                       int(setConnected.size()) >=
                                           std::min(nMaxConnections - 1, 2),
                                       &grant, nullptr, conn_type);
             }
         }
     }
 }
 
 std::vector<CAddress> CConnman::GetCurrentBlockRelayOnlyConns() const {
     std::vector<CAddress> ret;
     LOCK(m_nodes_mutex);
     for (const CNode *pnode : m_nodes) {
         if (pnode->IsBlockOnlyConn()) {
             ret.push_back(pnode->addr);
         }
     }
 
     return ret;
 }
 
 std::vector<AddedNodeInfo> CConnman::GetAddedNodeInfo() const {
     std::vector<AddedNodeInfo> ret;
 
     std::list<std::string> lAddresses(0);
     {
         LOCK(m_added_nodes_mutex);
         ret.reserve(m_added_nodes.size());
         std::copy(m_added_nodes.cbegin(), m_added_nodes.cend(),
                   std::back_inserter(lAddresses));
     }
 
     // Build a map of all already connected addresses (by IP:port and by name)
     // to inbound/outbound and resolved CService
     std::map<CService, bool> mapConnected;
     std::map<std::string, std::pair<bool, CService>> mapConnectedByName;
     {
         LOCK(m_nodes_mutex);
         for (const CNode *pnode : m_nodes) {
             if (pnode->addr.IsValid()) {
                 mapConnected[pnode->addr] = pnode->IsInboundConn();
             }
             std::string addrName{pnode->m_addr_name};
             if (!addrName.empty()) {
                 mapConnectedByName[std::move(addrName)] =
                     std::make_pair(pnode->IsInboundConn(),
                                    static_cast<const CService &>(pnode->addr));
             }
         }
     }
 
     for (const std::string &strAddNode : lAddresses) {
         CService service(
             LookupNumeric(strAddNode, Params().GetDefaultPort(strAddNode)));
         AddedNodeInfo addedNode{strAddNode, CService(), false, false};
         if (service.IsValid()) {
             // strAddNode is an IP:port
             auto it = mapConnected.find(service);
             if (it != mapConnected.end()) {
                 addedNode.resolvedAddress = service;
                 addedNode.fConnected = true;
                 addedNode.fInbound = it->second;
             }
         } else {
             // strAddNode is a name
             auto it = mapConnectedByName.find(strAddNode);
             if (it != mapConnectedByName.end()) {
                 addedNode.resolvedAddress = it->second.second;
                 addedNode.fConnected = true;
                 addedNode.fInbound = it->second.first;
             }
         }
         ret.emplace_back(std::move(addedNode));
     }
 
     return ret;
 }
 
 void CConnman::ThreadOpenAddedConnections() {
     while (true) {
         CSemaphoreGrant grant(*semAddnode);
         std::vector<AddedNodeInfo> vInfo = GetAddedNodeInfo();
         bool tried = false;
         for (const AddedNodeInfo &info : vInfo) {
             if (!info.fConnected) {
                 if (!grant.TryAcquire()) {
                     // If we've used up our semaphore and need a new one, let's
                     // not wait here since while we are waiting the
                     // addednodeinfo state might change.
                     break;
                 }
                 tried = true;
                 CAddress addr(CService(), NODE_NONE);
                 OpenNetworkConnection(addr, false, &grant,
                                       info.strAddedNode.c_str(),
                                       ConnectionType::MANUAL);
                 if (!interruptNet.sleep_for(std::chrono::milliseconds(500))) {
                     return;
                 }
             }
         }
         // Retry every 60 seconds if a connection was attempted, otherwise two
         // seconds.
         if (!interruptNet.sleep_for(std::chrono::seconds(tried ? 60 : 2))) {
             return;
         }
     }
 }
 
 // If successful, this moves the passed grant to the constructed node.
 void CConnman::OpenNetworkConnection(const CAddress &addrConnect,
                                      bool fCountFailure,
                                      CSemaphoreGrant *grantOutbound,
                                      const char *pszDest,
                                      ConnectionType conn_type) {
     assert(conn_type != ConnectionType::INBOUND);
 
     //
     // Initiate outbound network connection
     //
     if (interruptNet) {
         return;
     }
     if (!fNetworkActive) {
         return;
     }
     if (!pszDest) {
         bool banned_or_discouraged =
             m_banman && (m_banman->IsDiscouraged(addrConnect) ||
                          m_banman->IsBanned(addrConnect));
         if (IsLocal(addrConnect) || banned_or_discouraged ||
             AlreadyConnectedToAddress(addrConnect)) {
             return;
         }
     } else if (FindNode(std::string(pszDest))) {
         return;
     }
 
     CNode *pnode = ConnectNode(addrConnect, pszDest, fCountFailure, conn_type);
 
     if (!pnode) {
         return;
     }
     if (grantOutbound) {
         grantOutbound->MoveTo(pnode->grantOutbound);
     }
 
     for (auto interface : m_msgproc) {
         interface->InitializeNode(*config, pnode);
     }
 
     {
         LOCK(m_nodes_mutex);
         m_nodes.push_back(pnode);
     }
 }
 
 void CConnman::ThreadMessageHandler() {
     FastRandomContext rng;
     while (!flagInterruptMsgProc) {
         std::vector<CNode *> nodes_copy;
         {
             LOCK(m_nodes_mutex);
             nodes_copy = m_nodes;
             for (CNode *pnode : nodes_copy) {
                 pnode->AddRef();
             }
         }
 
         bool fMoreWork = false;
 
         // Randomize the order in which we process messages from/to our peers.
         // This prevents attacks in which an attacker exploits having multiple
         // consecutive connections in the m_nodes list.
         Shuffle(nodes_copy.begin(), nodes_copy.end(), rng);
 
         for (CNode *pnode : nodes_copy) {
             if (pnode->fDisconnect) {
                 continue;
             }
 
             bool fMoreNodeWork = false;
             // Receive messages
             for (auto interface : m_msgproc) {
                 fMoreNodeWork |= interface->ProcessMessages(
                     *config, pnode, flagInterruptMsgProc);
             }
             fMoreWork |= (fMoreNodeWork && !pnode->fPauseSend);
             if (flagInterruptMsgProc) {
                 return;
             }
 
             // Send messages
             {
                 LOCK(pnode->cs_sendProcessing);
                 for (auto interface : m_msgproc) {
                     interface->SendMessages(*config, pnode);
                 }
             }
 
             if (flagInterruptMsgProc) {
                 return;
             }
         }
 
         {
             LOCK(m_nodes_mutex);
             for (CNode *pnode : nodes_copy) {
                 pnode->Release();
             }
         }
 
         WAIT_LOCK(mutexMsgProc, lock);
         if (!fMoreWork) {
             condMsgProc.wait_until(lock,
                                    std::chrono::steady_clock::now() +
                                        std::chrono::milliseconds(100),
                                    [this]() EXCLUSIVE_LOCKS_REQUIRED(
                                        mutexMsgProc) { return fMsgProcWake; });
         }
         fMsgProcWake = false;
     }
 }
 
 void CConnman::ThreadI2PAcceptIncoming() {
     static constexpr auto err_wait_begin = 1s;
     static constexpr auto err_wait_cap = 5min;
     auto err_wait = err_wait_begin;
 
     bool advertising_listen_addr = false;
     i2p::Connection conn;
 
     while (!interruptNet) {
         if (!m_i2p_sam_session->Listen(conn)) {
             if (advertising_listen_addr && conn.me.IsValid()) {
                 RemoveLocal(conn.me);
                 advertising_listen_addr = false;
             }
 
             interruptNet.sleep_for(err_wait);
             if (err_wait < err_wait_cap) {
                 err_wait *= 2;
             }
 
             continue;
         }
 
         if (!advertising_listen_addr) {
             AddLocal(conn.me, LOCAL_MANUAL);
             advertising_listen_addr = true;
         }
 
         if (!m_i2p_sam_session->Accept(conn)) {
             continue;
         }
 
         CreateNodeFromAcceptedSocket(
             conn.sock->Release(), NetPermissionFlags::None,
             CAddress{conn.me, NODE_NONE}, CAddress{conn.peer, NODE_NONE});
     }
 }
 
 bool CConnman::BindListenPort(const CService &addrBind, bilingual_str &strError,
                               NetPermissionFlags permissions) {
     int nOne = 1;
 
     // Create socket for listening for incoming connections
     struct sockaddr_storage sockaddr;
     socklen_t len = sizeof(sockaddr);
     if (!addrBind.GetSockAddr((struct sockaddr *)&sockaddr, &len)) {
         strError = strprintf(
             Untranslated("Error: Bind address family for %s not supported"),
             addrBind.ToString());
         LogPrintf("%s\n", strError.original);
         return false;
     }
 
     std::unique_ptr<Sock> sock = CreateSock(addrBind);
     if (!sock) {
         strError =
             strprintf(Untranslated("Error: Couldn't open socket for incoming "
                                    "connections (socket returned error %s)"),
                       NetworkErrorString(WSAGetLastError()));
         LogPrintf("%s\n", strError.original);
         return false;
     }
 
     // Allow binding if the port is still in TIME_WAIT state after
     // the program was closed and restarted.
     setsockopt(sock->Get(), SOL_SOCKET, SO_REUSEADDR, (sockopt_arg_type)&nOne,
                sizeof(int));
 
     // Some systems don't have IPV6_V6ONLY but are always v6only; others do have
     // the option and enable it by default or not. Try to enable it, if
     // possible.
     if (addrBind.IsIPv6()) {
 #ifdef IPV6_V6ONLY
         setsockopt(sock->Get(), IPPROTO_IPV6, IPV6_V6ONLY,
                    (sockopt_arg_type)&nOne, sizeof(int));
 #endif
 #ifdef WIN32
         int nProtLevel = PROTECTION_LEVEL_UNRESTRICTED;
         setsockopt(sock->Get(), IPPROTO_IPV6, IPV6_PROTECTION_LEVEL,
                    (sockopt_arg_type)&nProtLevel, sizeof(int));
 #endif
     }
 
     if (::bind(sock->Get(), (struct sockaddr *)&sockaddr, len) ==
         SOCKET_ERROR) {
         int nErr = WSAGetLastError();
         if (nErr == WSAEADDRINUSE) {
             strError = strprintf(_("Unable to bind to %s on this computer. %s "
                                    "is probably already running."),
                                  addrBind.ToString(), PACKAGE_NAME);
         } else {
             strError = strprintf(_("Unable to bind to %s on this computer "
                                    "(bind returned error %s)"),
                                  addrBind.ToString(), NetworkErrorString(nErr));
         }
         LogPrintf("%s\n", strError.original);
         return false;
     }
     LogPrintf("Bound to %s\n", addrBind.ToString());
 
     // Listen for incoming connections
     if (listen(sock->Get(), SOMAXCONN) == SOCKET_ERROR) {
         strError = strprintf(_("Error: Listening for incoming connections "
                                "failed (listen returned error %s)"),
                              NetworkErrorString(WSAGetLastError()));
         LogPrintf("%s\n", strError.original);
         return false;
     }
 
     vhListenSocket.push_back(ListenSocket(sock->Release(), permissions));
     return true;
 }
 
 void Discover() {
     if (!fDiscover) {
         return;
     }
 
 #ifdef WIN32
     // Get local host IP
     char pszHostName[256] = "";
     if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR) {
         std::vector<CNetAddr> vaddr;
         if (LookupHost(pszHostName, vaddr, 0, true)) {
             for (const CNetAddr &addr : vaddr) {
                 if (AddLocal(addr, LOCAL_IF)) {
                     LogPrintf("%s: %s - %s\n", __func__, pszHostName,
                               addr.ToString());
                 }
             }
         }
     }
 #elif (HAVE_DECL_GETIFADDRS && HAVE_DECL_FREEIFADDRS)
     // Get local host ip
     struct ifaddrs *myaddrs;
     if (getifaddrs(&myaddrs) == 0) {
         for (struct ifaddrs *ifa = myaddrs; ifa != nullptr;
              ifa = ifa->ifa_next) {
             if (ifa->ifa_addr == nullptr || (ifa->ifa_flags & IFF_UP) == 0 ||
                 strcmp(ifa->ifa_name, "lo") == 0 ||
                 strcmp(ifa->ifa_name, "lo0") == 0) {
                 continue;
             }
             if (ifa->ifa_addr->sa_family == AF_INET) {
                 struct sockaddr_in *s4 =
                     reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr);
                 CNetAddr addr(s4->sin_addr);
                 if (AddLocal(addr, LOCAL_IF)) {
                     LogPrintf("%s: IPv4 %s: %s\n", __func__, ifa->ifa_name,
                               addr.ToString());
                 }
             } else if (ifa->ifa_addr->sa_family == AF_INET6) {
                 struct sockaddr_in6 *s6 =
                     reinterpret_cast<struct sockaddr_in6 *>(ifa->ifa_addr);
                 CNetAddr addr(s6->sin6_addr);
                 if (AddLocal(addr, LOCAL_IF)) {
                     LogPrintf("%s: IPv6 %s: %s\n", __func__, ifa->ifa_name,
                               addr.ToString());
                 }
             }
         }
         freeifaddrs(myaddrs);
     }
 #endif
 }
 
 void CConnman::SetNetworkActive(bool active) {
     LogPrintf("%s: %s\n", __func__, active);
 
     if (fNetworkActive == active) {
         return;
     }
 
     fNetworkActive = active;
 
     if (m_client_interface) {
         m_client_interface->NotifyNetworkActiveChanged(fNetworkActive);
     }
 }
 
 CConnman::CConnman(const Config &configIn, uint64_t nSeed0In, uint64_t nSeed1In,
                    AddrMan &addrmanIn, bool network_active)
     : config(&configIn), addrman(addrmanIn), nSeed0(nSeed0In),
       nSeed1(nSeed1In) {
     SetTryNewOutboundPeer(false);
 
     Options connOptions;
     Init(connOptions);
     SetNetworkActive(network_active);
 }
 
 NodeId CConnman::GetNewNodeId() {
     return nLastNodeId.fetch_add(1);
 }
 
 bool CConnman::Bind(const CService &addr, unsigned int flags,
                     NetPermissionFlags permissions) {
     if (!(flags & BF_EXPLICIT) && !IsReachable(addr)) {
         return false;
     }
     bilingual_str strError;
     if (!BindListenPort(addr, strError, permissions)) {
         if ((flags & BF_REPORT_ERROR) && m_client_interface) {
             m_client_interface->ThreadSafeMessageBox(
                 strError, "", CClientUIInterface::MSG_ERROR);
         }
         return false;
     }
 
     if (addr.IsRoutable() && fDiscover && !(flags & BF_DONT_ADVERTISE) &&
         !NetPermissions::HasFlag(permissions, NetPermissionFlags::NoBan)) {
         AddLocal(addr, LOCAL_BIND);
     }
 
     return true;
 }
 
 bool CConnman::InitBinds(const Options &options) {
     bool fBound = false;
     for (const auto &addrBind : options.vBinds) {
         fBound |= Bind(addrBind, (BF_EXPLICIT | BF_REPORT_ERROR),
                        NetPermissionFlags::None);
     }
     for (const auto &addrBind : options.vWhiteBinds) {
         fBound |= Bind(addrBind.m_service, (BF_EXPLICIT | BF_REPORT_ERROR),
                        addrBind.m_flags);
     }
     for (const auto &addr_bind : options.onion_binds) {
         fBound |= Bind(addr_bind, BF_EXPLICIT | BF_DONT_ADVERTISE,
                        NetPermissionFlags::None);
     }
     if (options.bind_on_any) {
         struct in_addr inaddr_any;
         inaddr_any.s_addr = htonl(INADDR_ANY);
         struct in6_addr inaddr6_any = IN6ADDR_ANY_INIT;
         fBound |= Bind(CService(inaddr6_any, GetListenPort()), BF_NONE,
                        NetPermissionFlags::None);
         fBound |=
             Bind(CService(inaddr_any, GetListenPort()),
                  !fBound ? BF_REPORT_ERROR : BF_NONE, NetPermissionFlags::None);
     }
     return fBound;
 }
 
 bool CConnman::Start(CScheduler &scheduler, const Options &connOptions) {
     Init(connOptions);
 
     if (fListen && !InitBinds(connOptions)) {
         if (m_client_interface) {
             m_client_interface->ThreadSafeMessageBox(
                 _("Failed to listen on any port. Use -listen=0 if you want "
                   "this."),
                 "", CClientUIInterface::MSG_ERROR);
         }
         return false;
     }
 
     proxyType i2p_sam;
     if (GetProxy(NET_I2P, i2p_sam)) {
         m_i2p_sam_session = std::make_unique<i2p::sam::Session>(
             gArgs.GetDataDirNet() / "i2p_private_key", i2p_sam.proxy,
             &interruptNet);
     }
 
     for (const auto &strDest : connOptions.vSeedNodes) {
         AddAddrFetch(strDest);
     }
 
     if (m_use_addrman_outgoing) {
         // Load addresses from anchors.dat
         m_anchors =
             ReadAnchors(config->GetChainParams(),
                         gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME);
         if (m_anchors.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
             m_anchors.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
         }
         LogPrintf(
             "%i block-relay-only anchors will be tried for connections.\n",
             m_anchors.size());
     }
 
     if (m_client_interface) {
         m_client_interface->InitMessage(
             _("Starting network threads…").translated);
     }
 
     fAddressesInitialized = true;
 
     if (semOutbound == nullptr) {
         // initialize semaphore
         semOutbound = std::make_unique<CSemaphore>(
             std::min(m_max_outbound, nMaxConnections));
     }
     if (semAddnode == nullptr) {
         // initialize semaphore
         semAddnode = std::make_unique<CSemaphore>(nMaxAddnode);
     }
 
     //
     // Start threads
     //
     assert(m_msgproc.size() > 0);
     InterruptSocks5(false);
     interruptNet.reset();
     flagInterruptMsgProc = false;
 
     {
         LOCK(mutexMsgProc);
         fMsgProcWake = false;
     }
 
     // Send and receive from sockets, accept connections
     threadSocketHandler = std::thread(&util::TraceThread, "net",
                                       [this] { ThreadSocketHandler(); });
 
     if (!gArgs.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)) {
         LogPrintf("DNS seeding disabled\n");
     } else {
         threadDNSAddressSeed = std::thread(&util::TraceThread, "dnsseed",
                                            [this] { ThreadDNSAddressSeed(); });
     }
 
     // Initiate manual connections
     threadOpenAddedConnections = std::thread(
         &util::TraceThread, "addcon", [this] { ThreadOpenAddedConnections(); });
 
     if (connOptions.m_use_addrman_outgoing &&
         !connOptions.m_specified_outgoing.empty()) {
         if (m_client_interface) {
             m_client_interface->ThreadSafeMessageBox(
                 _("Cannot provide specific connections and have addrman find "
                   "outgoing connections at the same."),
                 "", CClientUIInterface::MSG_ERROR);
         }
         return false;
     }
     if (connOptions.m_use_addrman_outgoing ||
         !connOptions.m_specified_outgoing.empty()) {
         threadOpenConnections =
             std::thread(&util::TraceThread, "opencon",
                         [this, connect = connOptions.m_specified_outgoing] {
                             ThreadOpenConnections(connect, nullptr);
                         });
     }
 
     // Process messages
     threadMessageHandler = std::thread(&util::TraceThread, "msghand",
                                        [this] { ThreadMessageHandler(); });
 
     if (connOptions.m_i2p_accept_incoming &&
         m_i2p_sam_session.get() != nullptr) {
         threadI2PAcceptIncoming =
             std::thread(&util::TraceThread, "i2paccept",
                         [this] { ThreadI2PAcceptIncoming(); });
     }
 
     // Dump network addresses
     scheduler.scheduleEvery(
         [this]() {
             this->DumpAddresses();
             return true;
         },
         DUMP_PEERS_INTERVAL);
 
     return true;
 }
 
 class CNetCleanup {
 public:
     CNetCleanup() {}
 
     ~CNetCleanup() {
 #ifdef WIN32
         // Shutdown Windows Sockets
         WSACleanup();
 #endif
     }
 };
 static CNetCleanup instance_of_cnetcleanup;
 
 void CConnman::Interrupt() {
     {
         LOCK(mutexMsgProc);
         flagInterruptMsgProc = true;
     }
     condMsgProc.notify_all();
 
     interruptNet();
     InterruptSocks5(true);
 
     if (semOutbound) {
         for (int i = 0; i < m_max_outbound; i++) {
             semOutbound->post();
         }
     }
 
     if (semAddnode) {
         for (int i = 0; i < nMaxAddnode; i++) {
             semAddnode->post();
         }
     }
 }
 
 void CConnman::StopThreads() {
     if (threadI2PAcceptIncoming.joinable()) {
         threadI2PAcceptIncoming.join();
     }
     if (threadMessageHandler.joinable()) {
         threadMessageHandler.join();
     }
     if (threadOpenConnections.joinable()) {
         threadOpenConnections.join();
     }
     if (threadOpenAddedConnections.joinable()) {
         threadOpenAddedConnections.join();
     }
     if (threadDNSAddressSeed.joinable()) {
         threadDNSAddressSeed.join();
     }
     if (threadSocketHandler.joinable()) {
         threadSocketHandler.join();
     }
 }
 
 void CConnman::StopNodes() {
     if (fAddressesInitialized) {
         DumpAddresses();
         fAddressesInitialized = false;
 
         if (m_use_addrman_outgoing) {
             // Anchor connections are only dumped during clean shutdown.
             std::vector<CAddress> anchors_to_dump =
                 GetCurrentBlockRelayOnlyConns();
             if (anchors_to_dump.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) {
                 anchors_to_dump.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS);
             }
             DumpAnchors(config->GetChainParams(),
                         gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME,
                         anchors_to_dump);
         }
     }
 
     // Delete peer connections.
     std::vector<CNode *> nodes;
     WITH_LOCK(m_nodes_mutex, nodes.swap(m_nodes));
     for (CNode *pnode : nodes) {
         pnode->CloseSocketDisconnect();
         DeleteNode(pnode);
     }
 
     // Close listening sockets.
     for (ListenSocket &hListenSocket : vhListenSocket) {
         if (hListenSocket.socket != INVALID_SOCKET) {
             if (!CloseSocket(hListenSocket.socket)) {
                 LogPrintf("CloseSocket(hListenSocket) failed with error %s\n",
                           NetworkErrorString(WSAGetLastError()));
             }
         }
     }
 
     for (CNode *pnode : m_nodes_disconnected) {
         DeleteNode(pnode);
     }
     m_nodes_disconnected.clear();
     vhListenSocket.clear();
     semOutbound.reset();
     semAddnode.reset();
 }
 
 void CConnman::DeleteNode(CNode *pnode) {
     assert(pnode);
     for (auto interface : m_msgproc) {
         interface->FinalizeNode(*config, *pnode);
     }
     delete pnode;
 }
 
 CConnman::~CConnman() {
     Interrupt();
     Stop();
 }
 
 std::vector<CAddress>
 CConnman::GetAddresses(size_t max_addresses, size_t max_pct,
                        std::optional<Network> network) const {
     std::vector<CAddress> addresses =
         addrman.GetAddr(max_addresses, max_pct, network);
     if (m_banman) {
         addresses.erase(std::remove_if(addresses.begin(), addresses.end(),
                                        [this](const CAddress &addr) {
                                            return m_banman->IsDiscouraged(
                                                       addr) ||
                                                   m_banman->IsBanned(addr);
                                        }),
                         addresses.end());
     }
     return addresses;
 }
 
 std::vector<CAddress>
 CConnman::GetAddresses(CNode &requestor, size_t max_addresses, size_t max_pct) {
     auto local_socket_bytes = requestor.addrBind.GetAddrBytes();
     uint64_t cache_id =
         GetDeterministicRandomizer(RANDOMIZER_ID_ADDRCACHE)
             .Write(requestor.addr.GetNetwork())
             .Write(local_socket_bytes.data(), local_socket_bytes.size())
             .Finalize();
     const auto current_time = GetTime<std::chrono::microseconds>();
     auto r = m_addr_response_caches.emplace(cache_id, CachedAddrResponse{});
     CachedAddrResponse &cache_entry = r.first->second;
     // New CachedAddrResponse have expiration 0.
     if (cache_entry.m_cache_entry_expiration < current_time) {
         cache_entry.m_addrs_response_cache =
             GetAddresses(max_addresses, max_pct, /* network */ std::nullopt);
         // Choosing a proper cache lifetime is a trade-off between the privacy
         // leak minimization and the usefulness of ADDR responses to honest
         // users.
         //
         // Longer cache lifetime makes it more difficult for an attacker to
         // scrape enough AddrMan data to maliciously infer something useful. By
         // the time an attacker scraped enough AddrMan records, most of the
         // records should be old enough to not leak topology info by e.g.
         // analyzing real-time changes in timestamps.
         //
         // It takes only several hundred requests to scrape everything from an
         // AddrMan containing 100,000 nodes, so ~24 hours of cache lifetime
         // indeed makes the data less inferable by the time most of it could be
         // scraped (considering that timestamps are updated via ADDR
         // self-announcements and when nodes communicate). We also should be
         // robust to those attacks which may not require scraping *full*
         // victim's AddrMan (because even several timestamps of the same handful
         // of nodes may leak privacy).
         //
         // On the other hand, longer cache lifetime makes ADDR responses
         // outdated and less useful for an honest requestor, e.g. if most nodes
         // in the ADDR response are no longer active.
         //
         // However, the churn in the network is known to be rather low. Since we
         // consider nodes to be "terrible" (see IsTerrible()) if the timestamps
         // are older than 30 days, max. 24 hours of "penalty" due to cache
         // shouldn't make any meaningful difference in terms of the freshness of
         // the response.
         cache_entry.m_cache_entry_expiration =
             current_time + std::chrono::hours(21) +
             GetRandMillis(std::chrono::hours(6));
     }
     return cache_entry.m_addrs_response_cache;
 }
 
 bool CConnman::AddNode(const std::string &strNode) {
     LOCK(m_added_nodes_mutex);
     for (const std::string &it : m_added_nodes) {
         if (strNode == it) {
             return false;
         }
     }
 
     m_added_nodes.push_back(strNode);
     return true;
 }
 
 bool CConnman::RemoveAddedNode(const std::string &strNode) {
     LOCK(m_added_nodes_mutex);
     for (std::vector<std::string>::iterator it = m_added_nodes.begin();
          it != m_added_nodes.end(); ++it) {
         if (strNode == *it) {
             m_added_nodes.erase(it);
             return true;
         }
     }
     return false;
 }
 
 size_t CConnman::GetNodeCount(NumConnections flags) const {
     LOCK(m_nodes_mutex);
     // Shortcut if we want total
     if (flags == CConnman::CONNECTIONS_ALL) {
         return m_nodes.size();
     }
 
     int nNum = 0;
     for (const auto &pnode : m_nodes) {
         if (flags &
             (pnode->IsInboundConn() ? CONNECTIONS_IN : CONNECTIONS_OUT)) {
             nNum++;
         }
     }
 
     return nNum;
 }
 
 void CConnman::GetNodeStats(std::vector<CNodeStats> &vstats) const {
     vstats.clear();
     LOCK(m_nodes_mutex);
     vstats.reserve(m_nodes.size());
     for (CNode *pnode : m_nodes) {
         vstats.emplace_back();
         pnode->copyStats(vstats.back());
         vstats.back().m_mapped_as = pnode->addr.GetMappedAS(addrman.GetAsmap());
     }
 }
 
 bool CConnman::DisconnectNode(const std::string &strNode) {
     LOCK(m_nodes_mutex);
     if (CNode *pnode = FindNode(strNode)) {
         LogPrint(BCLog::NET,
                  "disconnect by address%s matched peer=%d; disconnecting\n",
                  (fLogIPs ? strprintf("=%s", strNode) : ""), pnode->GetId());
         pnode->fDisconnect = true;
         return true;
     }
     return false;
 }
 
 bool CConnman::DisconnectNode(const CSubNet &subnet) {
     bool disconnected = false;
     LOCK(m_nodes_mutex);
     for (CNode *pnode : m_nodes) {
         if (subnet.Match(pnode->addr)) {
             LogPrint(BCLog::NET,
                      "disconnect by subnet%s matched peer=%d; disconnecting\n",
                      (fLogIPs ? strprintf("=%s", subnet.ToString()) : ""),
                      pnode->GetId());
             pnode->fDisconnect = true;
             disconnected = true;
         }
     }
     return disconnected;
 }
 
 bool CConnman::DisconnectNode(const CNetAddr &addr) {
     return DisconnectNode(CSubNet(addr));
 }
 
 bool CConnman::DisconnectNode(NodeId id) {
     LOCK(m_nodes_mutex);
     for (CNode *pnode : m_nodes) {
         if (id == pnode->GetId()) {
             LogPrint(BCLog::NET, "disconnect by id peer=%d; disconnecting\n",
                      pnode->GetId());
             pnode->fDisconnect = true;
             return true;
         }
     }
     return false;
 }
 
 void CConnman::RecordBytesRecv(uint64_t bytes) {
     nTotalBytesRecv += bytes;
 }
 
 void CConnman::RecordBytesSent(uint64_t bytes) {
     LOCK(cs_totalBytesSent);
     nTotalBytesSent += bytes;
 
     const auto now = GetTime<std::chrono::seconds>();
     if (nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME < now) {
         // timeframe expired, reset cycle
         nMaxOutboundCycleStartTime = now;
         nMaxOutboundTotalBytesSentInCycle = 0;
     }
 
     // TODO, exclude peers with download permission
     nMaxOutboundTotalBytesSentInCycle += bytes;
 }
 
 uint64_t CConnman::GetMaxOutboundTarget() const {
     LOCK(cs_totalBytesSent);
     return nMaxOutboundLimit;
 }
 
 std::chrono::seconds CConnman::GetMaxOutboundTimeframe() const {
     return MAX_UPLOAD_TIMEFRAME;
 }
 
 std::chrono::seconds CConnman::GetMaxOutboundTimeLeftInCycle() const {
     LOCK(cs_totalBytesSent);
     if (nMaxOutboundLimit == 0) {
         return 0s;
     }
 
     if (nMaxOutboundCycleStartTime.count() == 0) {
         return MAX_UPLOAD_TIMEFRAME;
     }
 
     const std::chrono::seconds cycleEndTime =
         nMaxOutboundCycleStartTime + MAX_UPLOAD_TIMEFRAME;
     const auto now = GetTime<std::chrono::seconds>();
     return (cycleEndTime < now) ? 0s : cycleEndTime - now;
 }
 
 bool CConnman::OutboundTargetReached(bool historicalBlockServingLimit) const {
     LOCK(cs_totalBytesSent);
     if (nMaxOutboundLimit == 0) {
         return false;
     }
 
     if (historicalBlockServingLimit) {
         // keep a large enough buffer to at least relay each block once.
         const std::chrono::seconds timeLeftInCycle =
             GetMaxOutboundTimeLeftInCycle();
         const uint64_t buffer =
             timeLeftInCycle / std::chrono::minutes{10} * ONE_MEGABYTE;
         if (buffer >= nMaxOutboundLimit ||
             nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit - buffer) {
             return true;
         }
     } else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) {
         return true;
     }
 
     return false;
 }
 
 uint64_t CConnman::GetOutboundTargetBytesLeft() const {
     LOCK(cs_totalBytesSent);
     if (nMaxOutboundLimit == 0) {
         return 0;
     }
 
     return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit)
                ? 0
                : nMaxOutboundLimit - nMaxOutboundTotalBytesSentInCycle;
 }
 
 uint64_t CConnman::GetTotalBytesRecv() const {
     return nTotalBytesRecv;
 }
 
 uint64_t CConnman::GetTotalBytesSent() const {
     LOCK(cs_totalBytesSent);
     return nTotalBytesSent;
 }
 
 ServiceFlags CConnman::GetLocalServices() const {
     return nLocalServices;
 }
 
 unsigned int CConnman::GetReceiveFloodSize() const {
     return nReceiveFloodSize;
 }
 
 void CNode::invsPolled(uint32_t count) {
     invCounters += count;
 }
 
 void CNode::invsVoted(uint32_t count) {
     invCounters += uint64_t(count) << 32;
 }
 
 void CNode::updateAvailabilityScore(double decayFactor) {
     if (!m_avalanche_enabled) {
         return;
     }
 
     uint64_t windowInvCounters = invCounters.exchange(0);
     double previousScore = availabilityScore;
 
     int64_t polls = windowInvCounters & std::numeric_limits<uint32_t>::max();
     int64_t votes = windowInvCounters >> 32;
 
     availabilityScore =
         decayFactor * (2 * votes - polls) + (1. - decayFactor) * previousScore;
 }
 
 double CNode::getAvailabilityScore() const {
     // The score is set atomically so there is no need to lock the statistics
     // when reading.
     return availabilityScore;
 }
 
 CNode::CNode(NodeId idIn, ServiceFlags nLocalServicesIn, SOCKET hSocketIn,
              const CAddress &addrIn, uint64_t nKeyedNetGroupIn,
              uint64_t nLocalHostNonceIn, uint64_t nLocalExtraEntropyIn,
              const CAddress &addrBindIn, const std::string &addrNameIn,
              ConnectionType conn_type_in, bool inbound_onion)
     : m_connected(GetTime<std::chrono::seconds>()), addr(addrIn),
       addrBind(addrBindIn), m_addr_name{addrNameIn.empty()
                                             ? addr.ToStringIPPort()
                                             : addrNameIn},
       m_inbound_onion(inbound_onion), nKeyedNetGroup(nKeyedNetGroupIn),
       m_tx_relay(conn_type_in != ConnectionType::BLOCK_RELAY
                      ? std::make_unique<TxRelay>()
                      : nullptr),
       m_proof_relay(isAvalancheEnabled(gArgs) ? std::make_unique<ProofRelay>()
                                               : nullptr),
       // Don't relay addr messages to peers that we connect to as
       // block-relay-only peers (to prevent adversaries from inferring these
       // links from addr traffic).
       id(idIn), nLocalHostNonce(nLocalHostNonceIn),
       nLocalExtraEntropy(nLocalExtraEntropyIn), m_conn_type(conn_type_in),
       nLocalServices(nLocalServicesIn) {
     if (inbound_onion) {
         assert(conn_type_in == ConnectionType::INBOUND);
     }
     hSocket = hSocketIn;
 
     for (const std::string &msg : getAllNetMessageTypes()) {
         mapRecvBytesPerMsgCmd[msg] = 0;
     }
     mapRecvBytesPerMsgCmd[NET_MESSAGE_COMMAND_OTHER] = 0;
 
     if (fLogIPs) {
         LogPrint(BCLog::NET, "Added connection to %s peer=%d\n", m_addr_name,
                  id);
     } else {
         LogPrint(BCLog::NET, "Added connection peer=%d\n", id);
     }
 
     m_deserializer = std::make_unique<V1TransportDeserializer>(
         V1TransportDeserializer(GetConfig().GetChainParams().NetMagic(),
                                 SER_NETWORK, INIT_PROTO_VERSION));
     m_serializer =
         std::make_unique<V1TransportSerializer>(V1TransportSerializer());
 }
 
 CNode::~CNode() {
     CloseSocket(hSocket);
 }
 
 bool CConnman::NodeFullyConnected(const CNode *pnode) {
     return pnode && pnode->fSuccessfullyConnected && !pnode->fDisconnect;
 }
 
 void CConnman::PushMessage(CNode *pnode, CSerializedNetMsg &&msg) {
     size_t nMessageSize = msg.data.size();
     LogPrint(BCLog::NET, "sending %s (%d bytes) peer=%d\n", msg.m_type,
              nMessageSize, pnode->GetId());
     if (gArgs.GetBoolArg("-capturemessages", false)) {
         CaptureMessage(pnode->addr, msg.m_type, msg.data,
                        /*is_incoming=*/false);
     }
 
     TRACE6(net, outbound_message, pnode->GetId(), pnode->m_addr_name.c_str(),
            pnode->ConnectionTypeAsString().c_str(), msg.m_type.c_str(),
            msg.data.size(), msg.data.data());
 
     // make sure we use the appropriate network transport format
     std::vector<uint8_t> serializedHeader;
     pnode->m_serializer->prepareForTransport(*config, msg, serializedHeader);
     size_t nTotalSize = nMessageSize + serializedHeader.size();
 
     size_t nBytesSent = 0;
     {
         LOCK(pnode->cs_vSend);
         bool optimisticSend(pnode->vSendMsg.empty());
 
         // log total amount of bytes per message type
         pnode->mapSendBytesPerMsgCmd[msg.m_type] += nTotalSize;
         pnode->nSendSize += nTotalSize;
 
         if (pnode->nSendSize > nSendBufferMaxSize) {
             pnode->fPauseSend = true;
         }
         pnode->vSendMsg.push_back(std::move(serializedHeader));
         if (nMessageSize) {
             pnode->vSendMsg.push_back(std::move(msg.data));
         }
 
         // If write queue empty, attempt "optimistic write"
         if (optimisticSend == true) {
             nBytesSent = SocketSendData(*pnode);
         }
     }
     if (nBytesSent) {
         RecordBytesSent(nBytesSent);
     }
 }
 
 bool CConnman::ForNode(NodeId id, std::function<bool(CNode *pnode)> func) {
     CNode *found = nullptr;
     LOCK(m_nodes_mutex);
     for (auto &&pnode : m_nodes) {
         if (pnode->GetId() == id) {
             found = pnode;
             break;
         }
     }
     return found != nullptr && NodeFullyConnected(found) && func(found);
 }
 
 std::chrono::microseconds
 CConnman::PoissonNextSendInbound(std::chrono::microseconds now,
                                  std::chrono::seconds average_interval) {
     if (m_next_send_inv_to_incoming.load() < now) {
         // If this function were called from multiple threads simultaneously
         // it would be possible that both update the next send variable, and
         // return a different result to their caller. This is not possible in
         // practice as only the net processing thread invokes this function.
         m_next_send_inv_to_incoming = PoissonNextSend(now, average_interval);
     }
     return m_next_send_inv_to_incoming;
 }
 
 std::chrono::microseconds
 PoissonNextSend(std::chrono::microseconds now,
                 std::chrono::seconds average_interval) {
     double unscaled = -log1p(GetRand(1ULL << 48) *
                              -0.0000000000000035527136788 /* -1/2^48 */);
     return now + std::chrono::duration_cast<std::chrono::microseconds>(
                      unscaled * average_interval + 0.5us);
 }
 
 CSipHasher CConnman::GetDeterministicRandomizer(uint64_t id) const {
     return CSipHasher(nSeed0, nSeed1).Write(id);
 }
 
 uint64_t CConnman::CalculateKeyedNetGroup(const CAddress &ad) const {
     std::vector<uint8_t> vchNetGroup(ad.GetGroup(addrman.GetAsmap()));
 
     return GetDeterministicRandomizer(RANDOMIZER_ID_NETGROUP)
         .Write(vchNetGroup.data(), vchNetGroup.size())
         .Finalize();
 }
 
 /**
  * This function convert MaxBlockSize from byte to
  * MB with a decimal precision one digit rounded down
  * E.g.
  * 1660000 -> 1.6
  * 2010000 -> 2.0
  * 1000000 -> 1.0
  * 230000  -> 0.2
  * 50000   -> 0.0
  *
  *  NB behavior for EB<1MB not standardized yet still
  *  the function applies the same algo used for
  *  EB greater or equal to 1MB
  */
 std::string getSubVersionEB(uint64_t MaxBlockSize) {
     // Prepare EB string we are going to add to SubVer:
     // 1) translate from byte to MB and convert to string
     // 2) limit the EB string to the first decimal digit (floored)
     std::stringstream ebMBs;
     ebMBs << (MaxBlockSize / (ONE_MEGABYTE / 10));
     std::string eb = ebMBs.str();
     eb.insert(eb.size() - 1, ".", 1);
     if (eb.substr(0, 1) == ".") {
         eb = "0" + eb;
     }
     return eb;
 }
 
 std::string userAgent(const Config &config) {
     // format excessive blocksize value
     std::string eb = getSubVersionEB(config.GetMaxBlockSize());
     std::vector<std::string> uacomments;
     uacomments.push_back("EB" + eb);
 
     // Comments are checked for char compliance at startup, it is safe to add
     // them to the user agent string
     for (const std::string &cmt : gArgs.GetArgs("-uacomment")) {
         uacomments.push_back(cmt);
     }
 
     const std::string client_name = gArgs.GetArg("-uaclientname", CLIENT_NAME);
     const std::string client_version =
         gArgs.GetArg("-uaclientversion", FormatVersion(CLIENT_VERSION));
 
     // Size compliance is checked at startup, it is safe to not check it again
     return FormatUserAgent(client_name, client_version, uacomments);
 }
 
 void CaptureMessage(const CAddress &addr, const std::string &msg_type,
                     const Span<const uint8_t> &data, bool is_incoming) {
     // Note: This function captures the message at the time of processing,
     // not at socket receive/send time.
     // This ensures that the messages are always in order from an application
     // layer (processing) perspective.
     auto now = GetTime<std::chrono::microseconds>();
 
     // Windows folder names can not include a colon
     std::string clean_addr = addr.ToString();
     std::replace(clean_addr.begin(), clean_addr.end(), ':', '_');
 
     fs::path base_path = gArgs.GetDataDirNet() / "message_capture" / clean_addr;
     fs::create_directories(base_path);
 
     fs::path path =
         base_path / (is_incoming ? "msgs_recv.dat" : "msgs_sent.dat");
     CAutoFile f(fsbridge::fopen(path, "ab"), SER_DISK, CLIENT_VERSION);
 
     ser_writedata64(f, now.count());
     f.write(msg_type.data(), msg_type.length());
     for (auto i = msg_type.length(); i < CMessageHeader::COMMAND_SIZE; ++i) {
         f << '\0';
     }
     uint32_t size = data.size();
     ser_writedata32(f, size);
     f.write((const char *)data.data(), data.size());
 }
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index 7eee09238..d60c00725 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -1,987 +1,992 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/guiutil.h>
 
 #include <cashaddrenc.h>
 #include <chainparams.h>
+#include <fs.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <protocol.h>
 #include <qt/bitcoinaddressvalidator.h>
 #include <qt/bitcoinunits.h>
 #include <qt/qvalidatedlineedit.h>
 #include <qt/sendcoinsrecipient.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/time.h>
 
 #ifdef WIN32
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 #include <shellapi.h>
 #include <shlobj.h>
 #include <shlwapi.h>
 #endif
 
 #include <QAbstractItemView>
 #include <QApplication>
 #include <QClipboard>
 #include <QDateTime>
 #include <QDesktopServices>
 #include <QDoubleValidator>
 #include <QFileDialog>
 #include <QFont>
 #include <QFontDatabase>
 #include <QFontMetrics>
 #include <QGuiApplication>
 #include <QKeyEvent>
 #include <QLineEdit>
 #include <QList>
 #include <QMenu>
 #include <QMouseEvent>
 #include <QProcess>
 #include <QProgressDialog>
 #include <QScreen>
 #include <QSettings>
 #include <QShortcut>
 #include <QSize>
 #include <QString>
 #include <QTextDocument> // for Qt::mightBeRichText
 #include <QThread>
 #include <QUrlQuery>
 #include <QtGlobal>
 
 #include <chrono>
+#include <exception>
+#include <fstream>
+#include <string>
+#include <vector>
 
 #if defined(Q_OS_MAC)
 
 void ForceActivation();
 #endif
 
 namespace GUIUtil {
 
 QString dateTimeStr(const QDateTime &date) {
     return date.date().toString(QLocale().dateFormat(QLocale::ShortFormat)) +
            QString(" ") + date.toString("hh:mm");
 }
 
 QString dateTimeStr(qint64 nTime) {
     return dateTimeStr(QDateTime::fromTime_t((qint32)nTime));
 }
 
 QFont fixedPitchFont() {
     return QFontDatabase::systemFont(QFontDatabase::FixedFont);
 }
 
 static std::string MakeAddrInvalid(std::string addr,
                                    const CChainParams &params) {
     if (addr.size() < 2) {
         return "";
     }
 
     // Checksum is at the end of the address. Swapping chars to make it invalid.
     std::swap(addr[addr.size() - 1], addr[addr.size() - 2]);
     if (!IsValidDestinationString(addr, params)) {
         return addr;
     }
 
     return "";
 }
 
 std::string DummyAddress(const CChainParams &params) {
     // Just some dummy data to generate a convincing random-looking (but
     // consistent) address
     static const std::vector<uint8_t> dummydata = {
         0xeb, 0x15, 0x23, 0x1d, 0xfc, 0xeb, 0x60, 0x92, 0x58, 0x86,
         0xb6, 0x7d, 0x06, 0x52, 0x99, 0x92, 0x59, 0x15, 0xae, 0xb1};
 
     const CTxDestination dstKey = PKHash(uint160(dummydata));
     return MakeAddrInvalid(EncodeCashAddr(dstKey, params), params);
 }
 
 // Addresses are stored in the database with the encoding that the client was
 // configured with at the time of creation.
 //
 // This converts to cashaddr.
 QString convertToCashAddr(const CChainParams &params, const QString &addr) {
     if (!IsValidDestinationString(addr.toStdString(), params)) {
         // We have something sketchy as input. Do not try to convert.
         return addr;
     }
     CTxDestination dst = DecodeDestination(addr.toStdString(), params);
     return QString::fromStdString(EncodeCashAddr(dst, params));
 }
 
 void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent) {
     parent->setFocusProxy(widget);
 
     widget->setFont(fixedPitchFont());
     // We don't want translators to use own addresses in translations
     // and this is the only place, where this address is supplied.
     widget->setPlaceholderText(
         QObject::tr("Enter a Bitcoin address (e.g. %1)")
             .arg(QString::fromStdString(DummyAddress(Params()))));
     widget->setValidator(
         new BitcoinAddressEntryValidator(Params().CashAddrPrefix(), parent));
     widget->setCheckValidator(new BitcoinAddressCheckValidator(parent));
 }
 
 bool parseBitcoinURI(const QString &scheme, const QUrl &uri,
                      SendCoinsRecipient *out) {
     // return if URI has wrong scheme.
     if (!uri.isValid() || uri.scheme() != scheme) {
         return false;
     }
 
     SendCoinsRecipient rv;
     rv.address = uri.scheme() + ":" + uri.path();
 
     // Trim any following forward slash which may have been added by the OS
     if (rv.address.endsWith("/")) {
         rv.address.truncate(rv.address.length() - 1);
     }
     rv.amount = Amount::zero();
 
     QUrlQuery uriQuery(uri);
     QList<QPair<QString, QString>> items = uriQuery.queryItems();
     for (QList<QPair<QString, QString>>::iterator i = items.begin();
          i != items.end(); i++) {
         bool fShouldReturnFalse = false;
         if (i->first.startsWith("req-")) {
             i->first.remove(0, 4);
             fShouldReturnFalse = true;
         }
 
         if (i->first == "label") {
             rv.label = i->second;
             fShouldReturnFalse = false;
         }
         if (i->first == "message") {
             rv.message = i->second;
             fShouldReturnFalse = false;
         } else if (i->first == "amount") {
             if (!i->second.isEmpty()) {
                 if (!BitcoinUnits::parse(BitcoinUnits::base, i->second,
                                          &rv.amount)) {
                     return false;
                 }
             }
             fShouldReturnFalse = false;
         }
 
         if (fShouldReturnFalse) {
             return false;
         }
     }
     if (out) {
         *out = rv;
     }
     return true;
 }
 
 bool parseBitcoinURI(const QString &scheme, QString uri,
                      SendCoinsRecipient *out) {
     //
     //    Cannot handle this later, because bitcoincash://
     //    will cause Qt to see the part after // as host,
     //    which will lower-case it (and thus invalidate the address).
     if (uri.startsWith(scheme + "://", Qt::CaseInsensitive)) {
         uri.replace(0, scheme.length() + 3, scheme + ":");
     }
     QUrl uriInstance(uri);
     return parseBitcoinURI(scheme, uriInstance, out);
 }
 
 QString formatBitcoinURI(const SendCoinsRecipient &info) {
     return formatBitcoinURI(Params(), info);
 }
 
 QString formatBitcoinURI(const CChainParams &params,
                          const SendCoinsRecipient &info) {
     QString ret = convertToCashAddr(params, info.address);
     int paramCount = 0;
 
     if (info.amount != Amount::zero()) {
         ret += QString("?amount=%1")
                    .arg(BitcoinUnits::format(
                        BitcoinUnits::base, info.amount, false,
                        BitcoinUnits::SeparatorStyle::NEVER));
         paramCount++;
     }
 
     if (!info.label.isEmpty()) {
         QString lbl(QUrl::toPercentEncoding(info.label));
         ret += QString("%1label=%2").arg(paramCount == 0 ? "?" : "&").arg(lbl);
         paramCount++;
     }
 
     if (!info.message.isEmpty()) {
         QString msg(QUrl::toPercentEncoding(info.message));
         ret +=
             QString("%1message=%2").arg(paramCount == 0 ? "?" : "&").arg(msg);
         paramCount++;
     }
 
     return ret;
 }
 
 bool isDust(interfaces::Node &node, const QString &address, const Amount amount,
             const CChainParams &chainParams) {
     CTxDestination dest = DecodeDestination(address.toStdString(), chainParams);
     CScript script = GetScriptForDestination(dest);
     CTxOut txOut(amount, script);
     return IsDust(txOut, node.getDustRelayFee());
 }
 
 QString HtmlEscape(const QString &str, bool fMultiLine) {
     QString escaped = str.toHtmlEscaped();
     if (fMultiLine) {
         escaped = escaped.replace("\n", "<br>\n");
     }
     return escaped;
 }
 
 QString HtmlEscape(const std::string &str, bool fMultiLine) {
     return HtmlEscape(QString::fromStdString(str), fMultiLine);
 }
 
 void copyEntryData(const QAbstractItemView *view, int column, int role) {
     if (!view || !view->selectionModel()) {
         return;
     }
     QModelIndexList selection = view->selectionModel()->selectedRows(column);
 
     if (!selection.isEmpty()) {
         // Copy first item
         setClipboard(selection.at(0).data(role).toString());
     }
 }
 
 QList<QModelIndex> getEntryData(const QAbstractItemView *view, int column) {
     if (!view || !view->selectionModel()) {
         return QList<QModelIndex>();
     }
     return view->selectionModel()->selectedRows(column);
 }
 
 bool hasEntryData(const QAbstractItemView *view, int column, int role) {
     QModelIndexList selection = getEntryData(view, column);
     if (selection.isEmpty()) {
         return false;
     }
     return !selection.at(0).data(role).toString().isEmpty();
 }
 
 QString getDefaultDataDirectory() {
     return boostPathToQString(GetDefaultDataDir());
 }
 
 QString getSaveFileName(QWidget *parent, const QString &caption,
                         const QString &dir, const QString &filter,
                         QString *selectedSuffixOut) {
     QString selectedFilter;
     QString myDir;
     // Default to user documents location
     if (dir.isEmpty()) {
         myDir =
             QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
     } else {
         myDir = dir;
     }
     /* Directly convert path to native OS path separators */
     QString result = QDir::toNativeSeparators(QFileDialog::getSaveFileName(
         parent, caption, myDir, filter, &selectedFilter));
 
     /* Extract first suffix from filter pattern "Description (*.foo)" or
      * "Description (*.foo *.bar ...) */
     QRegExp filter_re(".* \\(\\*\\.(.*)[ \\)]");
     QString selectedSuffix;
     if (filter_re.exactMatch(selectedFilter)) {
         selectedSuffix = filter_re.cap(1);
     }
 
     /* Add suffix if needed */
     QFileInfo info(result);
     if (!result.isEmpty()) {
         if (info.suffix().isEmpty() && !selectedSuffix.isEmpty()) {
             /* No suffix specified, add selected suffix */
             if (!result.endsWith(".")) {
                 result.append(".");
             }
             result.append(selectedSuffix);
         }
     }
 
     /* Return selected suffix if asked to */
     if (selectedSuffixOut) {
         *selectedSuffixOut = selectedSuffix;
     }
     return result;
 }
 
 QString getOpenFileName(QWidget *parent, const QString &caption,
                         const QString &dir, const QString &filter,
                         QString *selectedSuffixOut) {
     QString selectedFilter;
     QString myDir;
     // Default to user documents location
     if (dir.isEmpty()) {
         myDir =
             QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
     } else {
         myDir = dir;
     }
     /* Directly convert path to native OS path separators */
     QString result = QDir::toNativeSeparators(QFileDialog::getOpenFileName(
         parent, caption, myDir, filter, &selectedFilter));
 
     if (selectedSuffixOut) {
         /* Extract first suffix from filter pattern "Description (*.foo)" or
          * "Description (*.foo *.bar ...) */
         QRegExp filter_re(".* \\(\\*\\.(.*)[ \\)]");
         QString selectedSuffix;
         if (filter_re.exactMatch(selectedFilter)) {
             selectedSuffix = filter_re.cap(1);
         }
         *selectedSuffixOut = selectedSuffix;
     }
     return result;
 }
 
 Qt::ConnectionType blockingGUIThreadConnection() {
     if (QThread::currentThread() != qApp->thread()) {
         return Qt::BlockingQueuedConnection;
     } else {
         return Qt::DirectConnection;
     }
 }
 
 bool checkPoint(const QPoint &p, const QWidget *w) {
     QWidget *atW = QApplication::widgetAt(w->mapToGlobal(p));
     if (!atW) {
         return false;
     }
     return atW->window() == w;
 }
 
 bool isObscured(QWidget *w) {
     return !(checkPoint(QPoint(0, 0), w) &&
              checkPoint(QPoint(w->width() - 1, 0), w) &&
              checkPoint(QPoint(0, w->height() - 1), w) &&
              checkPoint(QPoint(w->width() - 1, w->height() - 1), w) &&
              checkPoint(QPoint(w->width() / 2, w->height() / 2), w));
 }
 
 void bringToFront(QWidget *w) {
 #ifdef Q_OS_MAC
     ForceActivation();
 #endif
 
     if (w) {
         // activateWindow() (sometimes) helps with keyboard focus on Windows
         if (w->isMinimized()) {
             w->showNormal();
         } else {
             w->show();
         }
         w->activateWindow();
         w->raise();
     }
 }
 
 void handleCloseWindowShortcut(QWidget *w) {
     QObject::connect(new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), w),
                      &QShortcut::activated, w, &QWidget::close);
 }
 
 void openDebugLogfile() {
     fs::path pathDebug = gArgs.GetDataDirNet() / "debug.log";
 
     /* Open debug.log with the associated application */
     if (fs::exists(pathDebug)) {
         QDesktopServices::openUrl(
             QUrl::fromLocalFile(boostPathToQString(pathDebug)));
     }
 }
 
 bool openBitcoinConf() {
     fs::path pathConfig =
         GetConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME));
 
     /* Create the file */
-    fsbridge::ofstream configFile(pathConfig, std::ios_base::app);
+    std::ofstream configFile{pathConfig, std::ios_base::app};
 
     if (!configFile.good()) {
         return false;
     }
 
     configFile.close();
 
     /* Open bitcoin.conf with the associated application */
     bool res = QDesktopServices::openUrl(
         QUrl::fromLocalFile(boostPathToQString(pathConfig)));
 #ifdef Q_OS_MAC
     // Workaround for macOS-specific behavior; see #15409.
     if (!res) {
         res = QProcess::startDetached(
             "/usr/bin/open", QStringList{"-t", boostPathToQString(pathConfig)});
     }
 #endif
 
     return res;
 }
 
 QStringList splitSkipEmptyParts(const QString &s, const QString &separator) {
     return s.split(separator,
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
                    Qt::SkipEmptyParts
 #else
                    QString::SkipEmptyParts
 #endif
     );
 }
 
 ToolTipToRichTextFilter::ToolTipToRichTextFilter(int _size_threshold,
                                                  QObject *parent)
     : QObject(parent), size_threshold(_size_threshold) {}
 
 bool ToolTipToRichTextFilter::eventFilter(QObject *obj, QEvent *evt) {
     if (evt->type() == QEvent::ToolTipChange) {
         QWidget *widget = static_cast<QWidget *>(obj);
         QString tooltip = widget->toolTip();
         if (tooltip.size() > size_threshold && !tooltip.startsWith("<qt") &&
             !Qt::mightBeRichText(tooltip)) {
             // Envelop with <qt></qt> to make sure Qt detects this as rich text
             // Escape the current message as HTML and replace \n by <br>
             tooltip = "<qt>" + HtmlEscape(tooltip, true) + "</qt>";
             widget->setToolTip(tooltip);
             return true;
         }
     }
     return QObject::eventFilter(obj, evt);
 }
 
 LabelOutOfFocusEventFilter::LabelOutOfFocusEventFilter(QObject *parent)
     : QObject(parent) {}
 
 bool LabelOutOfFocusEventFilter::eventFilter(QObject *watched, QEvent *event) {
     if (event->type() == QEvent::FocusOut) {
         auto focus_out = static_cast<QFocusEvent *>(event);
         if (focus_out->reason() != Qt::PopupFocusReason) {
             auto label = qobject_cast<QLabel *>(watched);
             if (label) {
                 auto flags = label->textInteractionFlags();
                 label->setTextInteractionFlags(Qt::NoTextInteraction);
                 label->setTextInteractionFlags(flags);
             }
         }
     }
 
     return QObject::eventFilter(watched, event);
 }
 
 void TableViewLastColumnResizingFixer::connectViewHeadersSignals() {
     connect(tableView->horizontalHeader(), &QHeaderView::sectionResized, this,
             &TableViewLastColumnResizingFixer::on_sectionResized);
     connect(tableView->horizontalHeader(), &QHeaderView::geometriesChanged,
             this, &TableViewLastColumnResizingFixer::on_geometriesChanged);
 }
 
 // We need to disconnect these while handling the resize events, otherwise we
 // can enter infinite loops.
 void TableViewLastColumnResizingFixer::disconnectViewHeadersSignals() {
     disconnect(tableView->horizontalHeader(), &QHeaderView::sectionResized,
                this, &TableViewLastColumnResizingFixer::on_sectionResized);
     disconnect(tableView->horizontalHeader(), &QHeaderView::geometriesChanged,
                this, &TableViewLastColumnResizingFixer::on_geometriesChanged);
 } // namespace GUIUtil
 
 // Setup the resize mode, handles compatibility for Qt5 and below as the method
 // signatures changed.
 // Refactored here for readability.
 void TableViewLastColumnResizingFixer::setViewHeaderResizeMode(
     int logicalIndex, QHeaderView::ResizeMode resizeMode) {
     tableView->horizontalHeader()->setSectionResizeMode(logicalIndex,
                                                         resizeMode);
 }
 
 void TableViewLastColumnResizingFixer::resizeColumn(int nColumnIndex,
                                                     int width) {
     tableView->setColumnWidth(nColumnIndex, width);
     tableView->horizontalHeader()->resizeSection(nColumnIndex, width);
 }
 
 int TableViewLastColumnResizingFixer::getColumnsWidth() {
     int nColumnsWidthSum = 0;
     for (int i = 0; i < columnCount; i++) {
         nColumnsWidthSum += tableView->horizontalHeader()->sectionSize(i);
     }
     return nColumnsWidthSum;
 }
 
 int TableViewLastColumnResizingFixer::getAvailableWidthForColumn(int column) {
     int nResult = lastColumnMinimumWidth;
     int nTableWidth = tableView->horizontalHeader()->width();
 
     if (nTableWidth > 0) {
         int nOtherColsWidth =
             getColumnsWidth() -
             tableView->horizontalHeader()->sectionSize(column);
         nResult = std::max(nResult, nTableWidth - nOtherColsWidth);
     }
 
     return nResult;
 }
 
 // Make sure we don't make the columns wider than the table's viewport width.
 void TableViewLastColumnResizingFixer::adjustTableColumnsWidth() {
     disconnectViewHeadersSignals();
     resizeColumn(lastColumnIndex, getAvailableWidthForColumn(lastColumnIndex));
     connectViewHeadersSignals();
 
     int nTableWidth = tableView->horizontalHeader()->width();
     int nColsWidth = getColumnsWidth();
     if (nColsWidth > nTableWidth) {
         resizeColumn(secondToLastColumnIndex,
                      getAvailableWidthForColumn(secondToLastColumnIndex));
     }
 }
 
 // Make column use all the space available, useful during window resizing.
 void TableViewLastColumnResizingFixer::stretchColumnWidth(int column) {
     disconnectViewHeadersSignals();
     resizeColumn(column, getAvailableWidthForColumn(column));
     connectViewHeadersSignals();
 }
 
 // When a section is resized this is a slot-proxy for ajustAmountColumnWidth().
 void TableViewLastColumnResizingFixer::on_sectionResized(int logicalIndex,
                                                          int oldSize,
                                                          int newSize) {
     adjustTableColumnsWidth();
     int remainingWidth = getAvailableWidthForColumn(logicalIndex);
     if (newSize > remainingWidth) {
         resizeColumn(logicalIndex, remainingWidth);
     }
 }
 
 // When the table's geometry is ready, we manually perform the stretch of the
 // "Message" column,
 // as the "Stretch" resize mode does not allow for interactive resizing.
 void TableViewLastColumnResizingFixer::on_geometriesChanged() {
     if ((getColumnsWidth() - this->tableView->horizontalHeader()->width()) !=
         0) {
         disconnectViewHeadersSignals();
         resizeColumn(secondToLastColumnIndex,
                      getAvailableWidthForColumn(secondToLastColumnIndex));
         connectViewHeadersSignals();
     }
 }
 
 /**
  * Initializes all internal variables and prepares the
  * the resize modes of the last 2 columns of the table and
  */
 TableViewLastColumnResizingFixer::TableViewLastColumnResizingFixer(
     QTableView *table, int lastColMinimumWidth, int allColsMinimumWidth,
     QObject *parent)
     : QObject(parent), tableView(table),
       lastColumnMinimumWidth(lastColMinimumWidth),
       allColumnsMinimumWidth(allColsMinimumWidth) {
     columnCount = tableView->horizontalHeader()->count();
     lastColumnIndex = columnCount - 1;
     secondToLastColumnIndex = columnCount - 2;
     tableView->horizontalHeader()->setMinimumSectionSize(
         allColumnsMinimumWidth);
     setViewHeaderResizeMode(secondToLastColumnIndex, QHeaderView::Interactive);
     setViewHeaderResizeMode(lastColumnIndex, QHeaderView::Interactive);
 }
 
 #ifdef WIN32
 static fs::path StartupShortcutPath() {
     std::string chain = gArgs.GetChainName();
     if (chain == CBaseChainParams::MAIN) {
         return GetSpecialFolderPath(CSIDL_STARTUP) / "Bitcoin.lnk";
     }
     // Remove this special case when CBaseChainParams::TESTNET = "testnet4"
     if (chain == CBaseChainParams::TESTNET) {
         return GetSpecialFolderPath(CSIDL_STARTUP) / "Bitcoin (testnet).lnk";
     }
     return GetSpecialFolderPath(CSIDL_STARTUP) /
            strprintf("Bitcoin (%s).lnk", chain);
 }
 
 bool GetStartOnSystemStartup() {
     // check for Bitcoin*.lnk
     return fs::exists(StartupShortcutPath());
 }
 
 bool SetStartOnSystemStartup(bool fAutoStart) {
     // If the shortcut exists already, remove it for updating
     fs::remove(StartupShortcutPath());
 
     if (fAutoStart) {
         CoInitialize(nullptr);
 
         // Get a pointer to the IShellLink interface.
         IShellLinkW *psl = nullptr;
         HRESULT hres =
             CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER,
                              IID_IShellLinkW, reinterpret_cast<void **>(&psl));
 
         if (SUCCEEDED(hres)) {
             // Get the current executable path
             WCHAR pszExePath[MAX_PATH];
             GetModuleFileNameW(nullptr, pszExePath, ARRAYSIZE(pszExePath));
 
             // Start client minimized
             QString strArgs = "-min";
             // Set -testnet /-regtest options
             strArgs += QString::fromStdString(
                 strprintf(" -chain=%s", gArgs.GetChainName()));
 
             // Set the path to the shortcut target
             psl->SetPath(pszExePath);
             PathRemoveFileSpecW(pszExePath);
             psl->SetWorkingDirectory(pszExePath);
             psl->SetShowCmd(SW_SHOWMINNOACTIVE);
             psl->SetArguments(strArgs.toStdWString().c_str());
 
             // Query IShellLink for the IPersistFile interface for
             // saving the shortcut in persistent storage.
             IPersistFile *ppf = nullptr;
             hres = psl->QueryInterface(IID_IPersistFile,
                                        reinterpret_cast<void **>(&ppf));
             if (SUCCEEDED(hres)) {
                 // Save the link by calling IPersistFile::Save.
                 hres = ppf->Save(StartupShortcutPath().wstring().c_str(), TRUE);
                 ppf->Release();
                 psl->Release();
                 CoUninitialize();
                 return true;
             }
             psl->Release();
         }
         CoUninitialize();
         return false;
     }
     return true;
 }
 #elif defined(Q_OS_LINUX)
 
 // Follow the Desktop Application Autostart Spec:
 // http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html
 
 static fs::path GetAutostartDir() {
     char *pszConfigHome = getenv("XDG_CONFIG_HOME");
     if (pszConfigHome) {
         return fs::path(pszConfigHome) / "autostart";
     }
     char *pszHome = getenv("HOME");
     if (pszHome) {
         return fs::path(pszHome) / ".config" / "autostart";
     }
     return fs::path();
 }
 
 static fs::path GetAutostartFilePath() {
     std::string chain = gArgs.GetChainName();
     if (chain == CBaseChainParams::MAIN) {
         return GetAutostartDir() / "bitcoin.desktop";
     }
     return GetAutostartDir() / strprintf("bitcoin-%s.desktop", chain);
 }
 
 bool GetStartOnSystemStartup() {
-    fsbridge::ifstream optionFile(GetAutostartFilePath());
+    std::ifstream optionFile{GetAutostartFilePath()};
     if (!optionFile.good()) {
         return false;
     }
     // Scan through file for "Hidden=true":
     std::string line;
     while (!optionFile.eof()) {
         getline(optionFile, line);
         if (line.find("Hidden") != std::string::npos &&
             line.find("true") != std::string::npos) {
             return false;
         }
     }
     optionFile.close();
 
     return true;
 }
 
 bool SetStartOnSystemStartup(bool fAutoStart) {
     if (!fAutoStart) {
         fs::remove(GetAutostartFilePath());
     } else {
         char pszExePath[MAX_PATH + 1];
         ssize_t r =
             readlink("/proc/self/exe", pszExePath, sizeof(pszExePath) - 1);
         if (r == -1) {
             return false;
         }
         pszExePath[r] = '\0';
 
         fs::create_directories(GetAutostartDir());
 
-        fsbridge::ofstream optionFile(
-            GetAutostartFilePath(), std::ios_base::out | std::ios_base::trunc);
+        std::ofstream optionFile{GetAutostartFilePath(),
+                                 std::ios_base::out | std::ios_base::trunc};
         if (!optionFile.good()) {
             return false;
         }
         std::string chain = gArgs.GetChainName();
         // Write a bitcoin.desktop file to the autostart directory:
         optionFile << "[Desktop Entry]\n";
         optionFile << "Type=Application\n";
         if (chain == CBaseChainParams::MAIN) {
             optionFile << "Name=Bitcoin\n";
         } else {
             optionFile << strprintf("Name=Bitcoin (%s)\n", chain);
         }
         optionFile << "Exec=" << pszExePath
                    << strprintf(" -min -chain=%s\n", chain);
         optionFile << "Terminal=false\n";
         optionFile << "Hidden=false\n";
         optionFile.close();
     }
     return true;
 }
 
 #else
 
 bool GetStartOnSystemStartup() {
     return false;
 }
 bool SetStartOnSystemStartup(bool fAutoStart) {
     return false;
 }
 
 #endif
 
 void setClipboard(const QString &str) {
     QApplication::clipboard()->setText(str, QClipboard::Clipboard);
     QApplication::clipboard()->setText(str, QClipboard::Selection);
 }
 
 fs::path qstringToBoostPath(const QString &path) {
     return fs::u8path(path.toStdString());
 }
 
 QString boostPathToQString(const fs::path &path) {
     return QString::fromStdString(path.u8string());
 }
 
 QString NetworkToQString(Network net) {
     switch (net) {
         case NET_UNROUTABLE:
             return QObject::tr("Unroutable");
         case NET_IPV4:
             return "IPv4";
         case NET_IPV6:
             return "IPv6";
         case NET_ONION:
             return "Onion";
         case NET_I2P:
             return "I2P";
         case NET_CJDNS:
             return "CJDNS";
         case NET_INTERNAL:
             return QObject::tr("Internal");
         case NET_MAX:
             assert(false);
     } // no default case, so the compiler can warn about missing cases
     assert(false);
 }
 
 QString formatDurationStr(std::chrono::seconds dur) {
     const auto secs = count_seconds(dur);
     QStringList strList;
     int days = secs / 86400;
     int hours = (secs % 86400) / 3600;
     int mins = (secs % 3600) / 60;
     int seconds = secs % 60;
 
     if (days) {
         strList.append(QString(QObject::tr("%1 d")).arg(days));
     }
     if (hours) {
         strList.append(QString(QObject::tr("%1 h")).arg(hours));
     }
     if (mins) {
         strList.append(QString(QObject::tr("%1 m")).arg(mins));
     }
     if (seconds || (!days && !hours && !mins)) {
         strList.append(QString(QObject::tr("%1 s")).arg(seconds));
     }
 
     return strList.join(" ");
 }
 
 QString formatServicesStr(quint64 mask) {
     QStringList strList;
 
     constexpr uint64_t nonExperimentalMask =
         (NODE_LAST_NON_EXPERIMENTAL_SERVICE_BIT << 1) - 1;
     for (const auto &flag : serviceFlagsToStr(mask & nonExperimentalMask)) {
         strList.append(QString::fromStdString(flag));
     }
 
     if (strList.size()) {
         return strList.join(" & ");
     } else {
         return QObject::tr("None");
     }
 }
 
 QString formatPingTime(std::chrono::microseconds ping_time) {
     return (ping_time == std::chrono::microseconds::max() || ping_time == 0us)
                ? QObject::tr("N/A")
                : QString(QObject::tr("%1 ms"))
                      .arg(QString::number(
                          int(count_microseconds(ping_time) / 1000), 10));
 }
 
 QString formatTimeOffset(int64_t nTimeOffset) {
     return QString(QObject::tr("%1 s"))
         .arg(QString::number((int)nTimeOffset, 10));
 }
 
 QString formatNiceTimeOffset(qint64 secs) {
     // Represent time from last generated block in human readable text
     QString timeBehindText;
     const int HOUR_IN_SECONDS = 60 * 60;
     const int DAY_IN_SECONDS = 24 * 60 * 60;
     const int WEEK_IN_SECONDS = 7 * 24 * 60 * 60;
     // Average length of year in Gregorian calendar
     const int YEAR_IN_SECONDS = 31556952;
     if (secs < 60) {
         timeBehindText = QObject::tr("%n second(s)", "", secs);
     } else if (secs < 2 * HOUR_IN_SECONDS) {
         timeBehindText = QObject::tr("%n minute(s)", "", secs / 60);
     } else if (secs < 2 * DAY_IN_SECONDS) {
         timeBehindText = QObject::tr("%n hour(s)", "", secs / HOUR_IN_SECONDS);
     } else if (secs < 2 * WEEK_IN_SECONDS) {
         timeBehindText = QObject::tr("%n day(s)", "", secs / DAY_IN_SECONDS);
     } else if (secs < YEAR_IN_SECONDS) {
         timeBehindText = QObject::tr("%n week(s)", "", secs / WEEK_IN_SECONDS);
     } else {
         qint64 years = secs / YEAR_IN_SECONDS;
         qint64 remainder = secs % YEAR_IN_SECONDS;
         timeBehindText = QObject::tr("%1 and %2")
                              .arg(QObject::tr("%n year(s)", "", years))
                              .arg(QObject::tr("%n week(s)", "",
                                               remainder / WEEK_IN_SECONDS));
     }
     return timeBehindText;
 }
 
 QString formatBytes(uint64_t bytes) {
     if (bytes < 1024) {
         return QString(QObject::tr("%1 B")).arg(bytes);
     }
     if (bytes < 1024 * 1024) {
         return QString(QObject::tr("%1 KB")).arg(bytes / 1024);
     }
     if (bytes < 1024 * 1024 * 1024) {
         return QString(QObject::tr("%1 MB")).arg(bytes / 1024 / 1024);
     }
 
     return QString(QObject::tr("%1 GB")).arg(bytes / 1024 / 1024 / 1024);
 }
 
 bool ClickableLabel::hasPixmap() const {
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 15, 0))
     return !pixmap(Qt::ReturnByValue).isNull();
 #else
     return pixmap() != nullptr;
 #endif
 }
 
 qreal calculateIdealFontSize(int width, const QString &text, QFont font,
                              qreal minPointSize, qreal font_size) {
     while (font_size >= minPointSize) {
         font.setPointSizeF(font_size);
         QFontMetrics fm(font);
         if (GUIUtil::TextWidth(fm, text) < width) {
             break;
         }
         font_size -= 0.5;
     }
     return font_size;
 }
 
 void ClickableLabel::mouseReleaseEvent(QMouseEvent *event) {
     Q_EMIT clicked(event->pos());
 }
 
 void ClickableProgressBar::mouseReleaseEvent(QMouseEvent *event) {
     Q_EMIT clicked(event->pos());
 }
 
 bool ItemDelegate::eventFilter(QObject *object, QEvent *event) {
     if (event->type() == QEvent::KeyPress) {
         if (static_cast<QKeyEvent *>(event)->key() == Qt::Key_Escape) {
             Q_EMIT keyEscapePressed();
         }
     }
     return QItemDelegate::eventFilter(object, event);
 }
 
 int TextWidth(const QFontMetrics &fm, const QString &text) {
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 11, 0))
     return fm.horizontalAdvance(text);
 #else
     return fm.width(text);
 #endif
 }
 
 void PolishProgressDialog(QProgressDialog *dialog) {
 #ifdef Q_OS_MAC
     // Workaround for macOS-only Qt bug; see: QTBUG-65750, QTBUG-70357.
     const int margin = GUIUtil::TextWidth(dialog->fontMetrics(), "X");
     dialog->resize(dialog->width() + 2 * margin, dialog->height());
     dialog->show();
 #else
     Q_UNUSED(dialog);
 #endif
 }
 
 void LogQtInfo() {
 #ifdef QT_STATIC
     const std::string qt_link{"static"};
 #else
     const std::string qt_link{"dynamic"};
 #endif
 #ifdef QT_STATICPLUGIN
     const std::string plugin_link{"static"};
 #else
     const std::string plugin_link{"dynamic"};
 #endif
     LogPrintf("Qt %s (%s), plugin=%s (%s)\n", qVersion(), qt_link,
               QGuiApplication::platformName().toStdString(), plugin_link);
     LogPrintf("System: %s, %s\n", QSysInfo::prettyProductName().toStdString(),
               QSysInfo::buildAbi().toStdString());
     for (const QScreen *s : QGuiApplication::screens()) {
         LogPrintf("Screen: %s %dx%d, pixel ratio=%.1f\n",
                   s->name().toStdString(), s->size().width(),
                   s->size().height(), s->devicePixelRatio());
     }
 }
 
 void PopupMenu(QMenu *menu, const QPoint &point, QAction *at_action) {
     // The qminimal plugin does not provide window system integration.
     if (QApplication::platformName() == "minimal") {
         return;
     }
     menu->popup(point, at_action);
 }
 
 } // namespace GUIUtil
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
index 68199f3cb..3b9cac4dd 100644
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -1,1042 +1,1045 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/forms/ui_sendcoinsdialog.h>
 #include <qt/sendcoinsdialog.h>
 
 #include <chainparams.h>
 #include <interfaces/node.h>
 #include <key_io.h>
 #include <node/ui_interface.h>
 #include <qt/addresstablemodel.h>
 #include <qt/bitcoinunits.h>
 #include <qt/clientmodel.h>
 #include <qt/coincontroldialog.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/sendcoinsentry.h>
 #include <txmempool.h>
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
 #include <wallet/wallet.h>
 
 #include <validation.h>
 
+#include <array>
+#include <fstream>
+#include <memory>
+
 #include <QScrollBar>
 #include <QSettings>
 #include <QTextDocument>
 
 SendCoinsDialog::SendCoinsDialog(const PlatformStyle *_platformStyle,
                                  WalletModel *_model, QWidget *parent)
     : QDialog(parent), ui(new Ui::SendCoinsDialog), clientModel(nullptr),
       model(_model), m_coin_control(new CCoinControl),
       fNewRecipientAllowed(true), fFeeMinimized(true),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
 
     if (!_platformStyle->getImagesOnButtons()) {
         ui->addButton->setIcon(QIcon());
         ui->clearButton->setIcon(QIcon());
         ui->sendButton->setIcon(QIcon());
     } else {
         ui->addButton->setIcon(_platformStyle->SingleColorIcon(":/icons/add"));
         ui->clearButton->setIcon(
             _platformStyle->SingleColorIcon(":/icons/remove"));
         ui->sendButton->setIcon(
             _platformStyle->SingleColorIcon(":/icons/send"));
     }
 
     GUIUtil::setupAddressWidget(ui->lineEditCoinControlChange, this);
 
     addEntry();
 
     connect(ui->addButton, &QPushButton::clicked, this,
             &SendCoinsDialog::addEntry);
     connect(ui->clearButton, &QPushButton::clicked, this,
             &SendCoinsDialog::clear);
 
     // Coin Control
     connect(ui->pushButtonCoinControl, &QPushButton::clicked, this,
             &SendCoinsDialog::coinControlButtonClicked);
     connect(ui->checkBoxCoinControlChange, &QCheckBox::stateChanged, this,
             &SendCoinsDialog::coinControlChangeChecked);
     connect(ui->lineEditCoinControlChange, &QValidatedLineEdit::textEdited,
             this, &SendCoinsDialog::coinControlChangeEdited);
 
     // Coin Control: clipboard actions
     QAction *clipboardQuantityAction = new QAction(tr("Copy quantity"), this);
     QAction *clipboardAmountAction = new QAction(tr("Copy amount"), this);
     QAction *clipboardFeeAction = new QAction(tr("Copy fee"), this);
     QAction *clipboardAfterFeeAction = new QAction(tr("Copy after fee"), this);
     QAction *clipboardBytesAction = new QAction(tr("Copy bytes"), this);
     QAction *clipboardLowOutputAction = new QAction(tr("Copy dust"), this);
     QAction *clipboardChangeAction = new QAction(tr("Copy change"), this);
     connect(clipboardQuantityAction, &QAction::triggered, this,
             &SendCoinsDialog::coinControlClipboardQuantity);
     connect(clipboardAmountAction, &QAction::triggered, this,
             &SendCoinsDialog::coinControlClipboardAmount);
     connect(clipboardFeeAction, &QAction::triggered, this,
             &SendCoinsDialog::coinControlClipboardFee);
     connect(clipboardAfterFeeAction, &QAction::triggered, this,
             &SendCoinsDialog::coinControlClipboardAfterFee);
     connect(clipboardBytesAction, &QAction::triggered, this,
             &SendCoinsDialog::coinControlClipboardBytes);
     connect(clipboardLowOutputAction, &QAction::triggered, this,
             &SendCoinsDialog::coinControlClipboardLowOutput);
     connect(clipboardChangeAction, &QAction::triggered, this,
             &SendCoinsDialog::coinControlClipboardChange);
     ui->labelCoinControlQuantity->addAction(clipboardQuantityAction);
     ui->labelCoinControlAmount->addAction(clipboardAmountAction);
     ui->labelCoinControlFee->addAction(clipboardFeeAction);
     ui->labelCoinControlAfterFee->addAction(clipboardAfterFeeAction);
     ui->labelCoinControlBytes->addAction(clipboardBytesAction);
     ui->labelCoinControlLowOutput->addAction(clipboardLowOutputAction);
     ui->labelCoinControlChange->addAction(clipboardChangeAction);
 
     // init transaction fee section
     QSettings settings;
     if (!settings.contains("fFeeSectionMinimized")) {
         settings.setValue("fFeeSectionMinimized", true);
     }
     // compatibility
     if (!settings.contains("nFeeRadio") &&
         settings.contains("nTransactionFee") &&
         settings.value("nTransactionFee").toLongLong() > 0) {
         // custom
         settings.setValue("nFeeRadio", 1);
     }
     if (!settings.contains("nFeeRadio")) {
         // recommended
         settings.setValue("nFeeRadio", 0);
     }
     if (!settings.contains("nTransactionFee")) {
         settings.setValue("nTransactionFee",
                           qint64(DEFAULT_PAY_TX_FEE / SATOSHI));
     }
     ui->groupFee->setId(ui->radioSmartFee, 0);
     ui->groupFee->setId(ui->radioCustomFee, 1);
     ui->groupFee
         ->button(
             std::max<int>(0, std::min(1, settings.value("nFeeRadio").toInt())))
         ->setChecked(true);
     ui->customFee->SetAllowEmpty(false);
     ui->customFee->setValue(
         int64_t(settings.value("nTransactionFee").toLongLong()) * SATOSHI);
     minimizeFeeSection(settings.value("fFeeSectionMinimized").toBool());
 
     // Set the model properly.
     setModel(model);
 }
 
 void SendCoinsDialog::setClientModel(ClientModel *_clientModel) {
     this->clientModel = _clientModel;
 
     if (_clientModel) {
         connect(_clientModel, &ClientModel::numBlocksChanged, this,
                 &SendCoinsDialog::updateNumberOfBlocks);
     }
 }
 
 void SendCoinsDialog::setModel(WalletModel *_model) {
     this->model = _model;
 
     if (_model && _model->getOptionsModel()) {
         for (int i = 0; i < ui->entries->count(); ++i) {
             SendCoinsEntry *entry = qobject_cast<SendCoinsEntry *>(
                 ui->entries->itemAt(i)->widget());
             if (entry) {
                 entry->setModel(_model);
             }
         }
 
         interfaces::WalletBalances balances = _model->wallet().getBalances();
         setBalance(balances);
         connect(_model, &WalletModel::balanceChanged, this,
                 &SendCoinsDialog::setBalance);
         connect(_model->getOptionsModel(), &OptionsModel::displayUnitChanged,
                 this, &SendCoinsDialog::updateDisplayUnit);
         updateDisplayUnit();
 
         // Coin Control
         connect(_model->getOptionsModel(), &OptionsModel::displayUnitChanged,
                 this, &SendCoinsDialog::coinControlUpdateLabels);
         connect(_model->getOptionsModel(),
                 &OptionsModel::coinControlFeaturesChanged, this,
                 &SendCoinsDialog::coinControlFeatureChanged);
         ui->frameCoinControl->setVisible(
             _model->getOptionsModel()->getCoinControlFeatures());
         coinControlUpdateLabels();
 
         // fee section
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 15, 0))
         const auto buttonClickedEvent =
             QOverload<int>::of(&QButtonGroup::idClicked);
 #else
         /* QOverload in introduced from Qt 5.7, but we support down to 5.5.1 */
         const auto buttonClickedEvent =
             static_cast<void (QButtonGroup::*)(int)>(
                 &QButtonGroup::buttonClicked);
 #endif
         connect(ui->groupFee, buttonClickedEvent, this,
                 &SendCoinsDialog::updateFeeSectionControls);
         connect(ui->groupFee, buttonClickedEvent, this,
                 &SendCoinsDialog::coinControlUpdateLabels);
         connect(ui->customFee, &BitcoinAmountField::valueChanged, this,
                 &SendCoinsDialog::coinControlUpdateLabels);
         Amount requiredFee = model->wallet().getRequiredFee(1000);
         ui->customFee->SetMinValue(requiredFee);
         if (ui->customFee->value() < requiredFee) {
             ui->customFee->setValue(requiredFee);
         }
         ui->customFee->setSingleStep(requiredFee);
         updateFeeSectionControls();
         updateSmartFeeLabel();
 
         if (model->wallet().privateKeysDisabled()) {
             ui->sendButton->setText(tr("Cr&eate Unsigned"));
             ui->sendButton->setToolTip(
                 tr("Creates a Partially Signed Bitcoin Transaction (PSBT) for "
                    "use with e.g. an offline %1 wallet, or a PSBT-compatible "
                    "hardware wallet.")
                     .arg(PACKAGE_NAME));
         }
     }
 }
 
 SendCoinsDialog::~SendCoinsDialog() {
     QSettings settings;
     settings.setValue("fFeeSectionMinimized", fFeeMinimized);
     settings.setValue("nFeeRadio", ui->groupFee->checkedId());
     settings.setValue("nTransactionFee",
                       qint64(ui->customFee->value() / SATOSHI));
 
     delete ui;
 }
 
 bool SendCoinsDialog::PrepareSendText(QString &question_string,
                                       QString &informative_text,
                                       QString &detailed_text) {
     QList<SendCoinsRecipient> recipients;
     bool valid = true;
 
     for (int i = 0; i < ui->entries->count(); ++i) {
         SendCoinsEntry *entry =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(i)->widget());
         if (entry) {
             if (entry->validate(model->node())) {
                 recipients.append(entry->getValue());
             } else if (valid) {
                 ui->scrollArea->ensureWidgetVisible(entry);
                 valid = false;
             }
         }
     }
 
     if (!valid || recipients.isEmpty()) {
         return false;
     }
 
     fNewRecipientAllowed = false;
     WalletModel::UnlockContext ctx(model->requestUnlock());
     if (!ctx.isValid()) {
         // Unlock wallet was cancelled
         fNewRecipientAllowed = true;
         return false;
     }
 
     // prepare transaction for getting txFee earlier
     m_current_transaction =
         std::make_unique<WalletModelTransaction>(recipients);
     WalletModel::SendCoinsReturn prepareStatus;
 
     updateCoinControlState(*m_coin_control);
 
     prepareStatus =
         model->prepareTransaction(*m_current_transaction, *m_coin_control);
 
     // process prepareStatus and on error generate message shown to user
     processSendCoinsReturn(prepareStatus,
                            BitcoinUnits::formatWithUnit(
                                model->getOptionsModel()->getDisplayUnit(),
                                m_current_transaction->getTransactionFee()));
 
     if (prepareStatus.status != WalletModel::OK) {
         fNewRecipientAllowed = true;
         return false;
     }
 
     Amount txFee = m_current_transaction->getTransactionFee();
     QStringList formatted;
     for (const SendCoinsRecipient &rcp :
          m_current_transaction->getRecipients()) {
         // generate amount string with wallet name in case of multiwallet
         QString amount = BitcoinUnits::formatWithUnit(
             model->getOptionsModel()->getDisplayUnit(), rcp.amount);
         if (model->isMultiwallet()) {
             amount.append(
                 tr(" from wallet '%1'")
                     .arg(GUIUtil::HtmlEscape(model->getWalletName())));
         }
         // generate address string
         QString address = rcp.address;
 
         QString recipientElement;
 
 #ifdef ENABLE_BIP70
         // normal payment
         if (!rcp.paymentRequest.IsInitialized())
 #endif
         {
             if (rcp.label.length() > 0) {
                 // label with address
                 recipientElement.append(
                     tr("%1 to '%2'")
                         .arg(amount, GUIUtil::HtmlEscape(rcp.label)));
                 recipientElement.append(QString(" (%1)").arg(address));
             } else {
                 // just address
                 recipientElement.append(tr("%1 to %2").arg(amount, address));
             }
         }
 #ifdef ENABLE_BIP70
         // authenticated payment request
         else if (!rcp.authenticatedMerchant.isEmpty()) {
             recipientElement.append(
                 tr("%1 to '%2'").arg(amount, rcp.authenticatedMerchant));
         } else {
             // unauthenticated payment request
             recipientElement.append(tr("%1 to %2").arg(amount, address));
         }
 #endif
 
         formatted.append(recipientElement);
     }
 
     if (model->wallet().privateKeysDisabled()) {
         question_string.append(tr("Do you want to draft this transaction?"));
     } else {
         question_string.append(tr("Are you sure you want to send?"));
     }
 
     question_string.append("<br /><span style='font-size:10pt;'>");
     if (model->wallet().privateKeysDisabled()) {
         question_string.append(
             tr("Please, review your transaction proposal. This will produce a "
                "Partially Signed Bitcoin Transaction (PSBT) which you can save "
                "or copy and then sign with e.g. an offline %1 wallet, or a "
                "PSBT-compatible hardware wallet.")
                 .arg(PACKAGE_NAME));
     } else {
         question_string.append(tr("Please, review your transaction."));
     }
     question_string.append("</span>%1");
 
     if (txFee > Amount::zero()) {
         // append fee string if a fee is required
         question_string.append("<hr /><b>");
         question_string.append(tr("Transaction fee"));
         question_string.append("</b>");
 
         // append transaction size
         question_string.append(
             " (" +
             QString::number(
                 (double)m_current_transaction->getTransactionSize() / 1000) +
             " kB): ");
 
         // append transaction fee value
         question_string.append(
             "<span style='color:#aa0000; font-weight:bold;'>");
         question_string.append(BitcoinUnits::formatHtmlWithUnit(
             model->getOptionsModel()->getDisplayUnit(), txFee));
         question_string.append("</span><br />");
     }
 
     // add total amount in all subdivision units
     question_string.append("<hr />");
     Amount totalAmount =
         m_current_transaction->getTotalTransactionAmount() + txFee;
     QStringList alternativeUnits;
     for (const BitcoinUnits::Unit u : BitcoinUnits::availableUnits()) {
         if (u != model->getOptionsModel()->getDisplayUnit()) {
             alternativeUnits.append(
                 BitcoinUnits::formatHtmlWithUnit(u, totalAmount));
         }
     }
     question_string.append(
         QString("<b>%1</b>: <b>%2</b>")
             .arg(tr("Total Amount"))
             .arg(BitcoinUnits::formatHtmlWithUnit(
                 model->getOptionsModel()->getDisplayUnit(), totalAmount)));
     question_string.append(
         QString("<br /><span style='font-size:10pt; "
                 "font-weight:normal;'>(=%1)</span>")
             .arg(alternativeUnits.join(" " + tr("or") + " ")));
 
     if (formatted.size() > 1) {
         question_string = question_string.arg("");
         informative_text =
             tr("To review recipient list click \"Show Details...\"");
         detailed_text = formatted.join("\n\n");
     } else {
         question_string = question_string.arg("<br /><br />" + formatted.at(0));
     }
 
     return true;
 }
 
 void SendCoinsDialog::on_sendButton_clicked() {
     if (!model || !model->getOptionsModel()) {
         return;
     }
 
     QString question_string, informative_text, detailed_text;
     if (!PrepareSendText(question_string, informative_text, detailed_text)) {
         return;
     }
     assert(m_current_transaction);
 
     const QString confirmation = model->wallet().privateKeysDisabled()
                                      ? tr("Confirm transaction proposal")
                                      : tr("Confirm send coins");
     const QString confirmButtonText = model->wallet().privateKeysDisabled()
                                           ? tr("Create Unsigned")
                                           : tr("Send");
     SendConfirmationDialog confirmationDialog(
         confirmation, question_string, informative_text, detailed_text,
         SEND_CONFIRM_DELAY, confirmButtonText, this);
     confirmationDialog.exec();
     QMessageBox::StandardButton retval =
         static_cast<QMessageBox::StandardButton>(confirmationDialog.result());
 
     if (retval != QMessageBox::Yes) {
         fNewRecipientAllowed = true;
         return;
     }
 
     bool send_failure = false;
     if (model->wallet().privateKeysDisabled()) {
         CMutableTransaction mtx =
             CMutableTransaction{*(m_current_transaction->getWtx())};
         PartiallySignedTransaction psbtx(mtx);
         bool complete = false;
         const TransactionError err = model->wallet().fillPSBT(
             SigHashType().withForkId(), false /* sign */,
             true /* bip32derivs */, psbtx, complete);
         assert(!complete);
         assert(err == TransactionError::OK);
         // Serialize the PSBT
         CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
         ssTx << psbtx;
         GUIUtil::setClipboard(EncodeBase64(ssTx.str()).c_str());
         QMessageBox msgBox;
         msgBox.setText("Unsigned Transaction");
         msgBox.setInformativeText(
             "The PSBT has been copied to the clipboard. You can also save it.");
         msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard);
         msgBox.setDefaultButton(QMessageBox::Discard);
         switch (msgBox.exec()) {
             case QMessageBox::Save: {
                 QString selectedFilter;
                 QString fileNameSuggestion = "";
                 bool first = true;
                 for (const SendCoinsRecipient &rcp :
                      m_current_transaction->getRecipients()) {
                     if (!first) {
                         fileNameSuggestion.append(" - ");
                     }
                     QString labelOrAddress =
                         rcp.label.isEmpty() ? rcp.address : rcp.label;
                     QString amount = BitcoinUnits::formatWithUnit(
                         model->getOptionsModel()->getDisplayUnit(), rcp.amount);
                     fileNameSuggestion.append(labelOrAddress + "-" + amount);
                     first = false;
                 }
                 fileNameSuggestion.append(".psbt");
                 QString filename = GUIUtil::getSaveFileName(
                     this, tr("Save Transaction Data"), fileNameSuggestion,
                     tr("Partially Signed Transaction (Binary) (*.psbt)"),
                     &selectedFilter);
                 if (filename.isEmpty()) {
                     return;
                 }
-                fsbridge::ofstream out{filename.toLocal8Bit().data(),
-                                       fsbridge::ofstream::out |
-                                           fsbridge::ofstream::binary};
+                std::ofstream out{filename.toLocal8Bit().data(),
+                                  std::ofstream::out | std::ofstream::binary};
                 out << ssTx.str();
                 out.close();
                 Q_EMIT message(tr("PSBT saved"), "PSBT saved to disk",
                                CClientUIInterface::MSG_INFORMATION);
                 break;
             }
             case QMessageBox::Discard:
                 break;
             default:
                 assert(false);
         }
     } else {
         // now send the prepared transaction
         WalletModel::SendCoinsReturn sendStatus =
             model->sendCoins(*m_current_transaction);
         // process sendStatus and on error generate message shown to user
         processSendCoinsReturn(sendStatus);
 
         if (sendStatus.status == WalletModel::OK) {
             Q_EMIT coinsSent(m_current_transaction->getWtx()->GetId());
         } else {
             send_failure = true;
         }
     }
     if (!send_failure) {
         accept();
         m_coin_control->UnSelectAll();
         coinControlUpdateLabels();
     }
     fNewRecipientAllowed = true;
     m_current_transaction.reset();
 }
 
 void SendCoinsDialog::clear() {
     m_current_transaction.reset();
 
     // Clear coin control settings
     m_coin_control->UnSelectAll();
     ui->checkBoxCoinControlChange->setChecked(false);
     ui->lineEditCoinControlChange->clear();
     coinControlUpdateLabels();
 
     // Remove entries until only one left
     while (ui->entries->count()) {
         ui->entries->takeAt(0)->widget()->deleteLater();
     }
     addEntry();
 
     updateTabsAndLabels();
 }
 
 void SendCoinsDialog::reject() {
     clear();
 }
 
 void SendCoinsDialog::accept() {
     clear();
 }
 
 SendCoinsEntry *SendCoinsDialog::addEntry() {
     SendCoinsEntry *entry = new SendCoinsEntry(platformStyle, model, this);
     ui->entries->addWidget(entry);
     connect(entry, &SendCoinsEntry::removeEntry, this,
             &SendCoinsDialog::removeEntry);
     connect(entry, &SendCoinsEntry::useAvailableBalance, this,
             &SendCoinsDialog::useAvailableBalance);
     connect(entry, &SendCoinsEntry::payAmountChanged, this,
             &SendCoinsDialog::coinControlUpdateLabels);
     connect(entry, &SendCoinsEntry::subtractFeeFromAmountChanged, this,
             &SendCoinsDialog::coinControlUpdateLabels);
 
     // Focus the field, so that entry can start immediately
     entry->clear();
     entry->setFocus();
     ui->scrollAreaWidgetContents->resize(
         ui->scrollAreaWidgetContents->sizeHint());
     qApp->processEvents();
     QScrollBar *bar = ui->scrollArea->verticalScrollBar();
     if (bar) {
         bar->setSliderPosition(bar->maximum());
     }
 
     updateTabsAndLabels();
     return entry;
 }
 
 void SendCoinsDialog::updateTabsAndLabels() {
     setupTabChain(nullptr);
     coinControlUpdateLabels();
 }
 
 void SendCoinsDialog::removeEntry(SendCoinsEntry *entry) {
     entry->hide();
 
     // If the last entry is about to be removed add an empty one
     if (ui->entries->count() == 1) {
         addEntry();
     }
 
     entry->deleteLater();
 
     updateTabsAndLabels();
 }
 
 QWidget *SendCoinsDialog::setupTabChain(QWidget *prev) {
     for (int i = 0; i < ui->entries->count(); ++i) {
         SendCoinsEntry *entry =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(i)->widget());
         if (entry) {
             prev = entry->setupTabChain(prev);
         }
     }
     QWidget::setTabOrder(prev, ui->sendButton);
     QWidget::setTabOrder(ui->sendButton, ui->clearButton);
     QWidget::setTabOrder(ui->clearButton, ui->addButton);
     return ui->addButton;
 }
 
 void SendCoinsDialog::setAddress(const QString &address) {
     SendCoinsEntry *entry = nullptr;
     // Replace the first entry if it is still unused
     if (ui->entries->count() == 1) {
         SendCoinsEntry *first =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(0)->widget());
         if (first->isClear()) {
             entry = first;
         }
     }
     if (!entry) {
         entry = addEntry();
     }
 
     entry->setAddress(address);
 }
 
 void SendCoinsDialog::pasteEntry(const SendCoinsRecipient &rv) {
     if (!fNewRecipientAllowed) {
         return;
     }
 
     SendCoinsEntry *entry = nullptr;
     // Replace the first entry if it is still unused
     if (ui->entries->count() == 1) {
         SendCoinsEntry *first =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(0)->widget());
         if (first->isClear()) {
             entry = first;
         }
     }
     if (!entry) {
         entry = addEntry();
     }
 
     entry->setValue(rv);
     updateTabsAndLabels();
 }
 
 bool SendCoinsDialog::handlePaymentRequest(const SendCoinsRecipient &rv) {
     // Just paste the entry, all pre-checks are done in paymentserver.cpp.
     pasteEntry(rv);
     return true;
 }
 
 void SendCoinsDialog::setBalance(const interfaces::WalletBalances &balances) {
     if (model && model->getOptionsModel()) {
         Amount balance = balances.balance;
         if (model->wallet().privateKeysDisabled()) {
             balance = balances.watch_only_balance;
             ui->labelBalanceName->setText(tr("Watch-only balance:"));
         }
         ui->labelBalance->setText(BitcoinUnits::formatWithUnit(
             model->getOptionsModel()->getDisplayUnit(), balance));
     }
 }
 
 void SendCoinsDialog::updateDisplayUnit() {
     setBalance(model->wallet().getBalances());
     ui->customFee->setDisplayUnit(model->getOptionsModel()->getDisplayUnit());
     updateSmartFeeLabel();
 }
 
 void SendCoinsDialog::processSendCoinsReturn(
     const WalletModel::SendCoinsReturn &sendCoinsReturn,
     const QString &msgArg) {
     QPair<QString, CClientUIInterface::MessageBoxFlags> msgParams;
     // Default to a warning message, override if error message is needed
     msgParams.second = CClientUIInterface::MSG_WARNING;
 
     // This comment is specific to SendCoinsDialog usage of
     // WalletModel::SendCoinsReturn.
     // All status values are used only in WalletModel::prepareTransaction()
     switch (sendCoinsReturn.status) {
         case WalletModel::InvalidAddress:
             msgParams.first =
                 tr("The recipient address is not valid. Please recheck.");
             break;
         case WalletModel::InvalidAmount:
             msgParams.first = tr("The amount to pay must be larger than 0.");
             break;
         case WalletModel::AmountExceedsBalance:
             msgParams.first = tr("The amount exceeds your balance.");
             break;
         case WalletModel::AmountWithFeeExceedsBalance:
             msgParams.first = tr("The total exceeds your balance when the %1 "
                                  "transaction fee is included.")
                                   .arg(msgArg);
             break;
         case WalletModel::DuplicateAddress:
             msgParams.first = tr("Duplicate address found: addresses should "
                                  "only be used once each.");
             break;
         case WalletModel::TransactionCreationFailed:
             msgParams.first = tr("Transaction creation failed!");
             msgParams.second = CClientUIInterface::MSG_ERROR;
             break;
         case WalletModel::AbsurdFee:
             msgParams.first =
                 tr("A fee higher than %1 is considered an absurdly high fee.")
                     .arg(BitcoinUnits::formatWithUnit(
                         model->getOptionsModel()->getDisplayUnit(),
                         model->wallet().getDefaultMaxTxFee()));
             break;
         case WalletModel::PaymentRequestExpired:
             msgParams.first = tr("Payment request expired.");
             msgParams.second = CClientUIInterface::MSG_ERROR;
             break;
         // included to prevent a compiler warning.
         case WalletModel::OK:
         default:
             return;
     }
 
     Q_EMIT message(tr("Send Coins"), msgParams.first, msgParams.second);
 }
 
 void SendCoinsDialog::minimizeFeeSection(bool fMinimize) {
     ui->labelFeeMinimized->setVisible(fMinimize);
     ui->buttonChooseFee->setVisible(fMinimize);
     ui->buttonMinimizeFee->setVisible(!fMinimize);
     ui->frameFeeSelection->setVisible(!fMinimize);
     ui->horizontalLayoutSmartFee->setContentsMargins(0, (fMinimize ? 0 : 6), 0,
                                                      0);
     fFeeMinimized = fMinimize;
 }
 
 void SendCoinsDialog::on_buttonChooseFee_clicked() {
     minimizeFeeSection(false);
 }
 
 void SendCoinsDialog::on_buttonMinimizeFee_clicked() {
     updateFeeMinimizedLabel();
     minimizeFeeSection(true);
 }
 
 void SendCoinsDialog::useAvailableBalance(SendCoinsEntry *entry) {
     // Include watch-only for wallets without private key
     m_coin_control->fAllowWatchOnly = model->wallet().privateKeysDisabled();
 
     // Calculate available amount to send.
     Amount amount = model->wallet().getAvailableBalance(*m_coin_control);
     for (int i = 0; i < ui->entries->count(); ++i) {
         SendCoinsEntry *e =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(i)->widget());
         if (e && !e->isHidden() && e != entry) {
             amount -= e->getValue().amount;
         }
     }
 
     if (amount > Amount::zero()) {
         entry->checkSubtractFeeFromAmount();
         entry->setAmount(amount);
     } else {
         entry->setAmount(Amount::zero());
     }
 }
 
 void SendCoinsDialog::updateFeeSectionControls() {
     ui->labelSmartFee->setEnabled(ui->radioSmartFee->isChecked());
     ui->labelSmartFee2->setEnabled(ui->radioSmartFee->isChecked());
     ui->labelFeeEstimation->setEnabled(ui->radioSmartFee->isChecked());
     ui->labelCustomFeeWarning->setEnabled(ui->radioCustomFee->isChecked());
     ui->labelCustomPerKilobyte->setEnabled(ui->radioCustomFee->isChecked());
     ui->customFee->setEnabled(ui->radioCustomFee->isChecked());
 }
 
 void SendCoinsDialog::updateFeeMinimizedLabel() {
     if (!model || !model->getOptionsModel()) {
         return;
     }
 
     if (ui->radioSmartFee->isChecked()) {
         ui->labelFeeMinimized->setText(ui->labelSmartFee->text());
     } else {
         ui->labelFeeMinimized->setText(
             BitcoinUnits::formatWithUnit(
                 model->getOptionsModel()->getDisplayUnit(),
                 ui->customFee->value()) +
             "/kB");
     }
 }
 
 void SendCoinsDialog::updateCoinControlState(CCoinControl &ctrl) {
     if (ui->radioCustomFee->isChecked()) {
         ctrl.m_feerate = CFeeRate(ui->customFee->value());
     } else {
         ctrl.m_feerate.reset();
     }
     // Include watch-only for wallets without private key
     ctrl.fAllowWatchOnly = model->wallet().privateKeysDisabled();
 }
 
 void SendCoinsDialog::updateNumberOfBlocks(int count,
                                            const QDateTime &blockDate,
                                            double nVerificationProgress,
                                            bool headers,
                                            SynchronizationState sync_state) {
     if (sync_state == SynchronizationState::POST_INIT) {
         updateSmartFeeLabel();
     }
 }
 
 void SendCoinsDialog::updateSmartFeeLabel() {
     if (!model || !model->getOptionsModel()) {
         return;
     }
 
     updateCoinControlState(*m_coin_control);
     // Explicitly use only fee estimation rate for smart fee labels
     m_coin_control->m_feerate.reset();
     CFeeRate feeRate(model->wallet().getMinimumFee(1000, *m_coin_control));
 
     ui->labelSmartFee->setText(
         BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(),
                                      feeRate.GetFeePerK()) +
         "/kB");
     // not enough data => minfee
     if (feeRate <= CFeeRate(Amount::zero())) {
         // (Smart fee not initialized yet. This usually takes a few blocks...)
         ui->labelSmartFee2->show();
         ui->labelFeeEstimation->setText("");
     } else {
         ui->labelSmartFee2->hide();
         ui->labelFeeEstimation->setText(
             tr("Estimated to begin confirmation by next block."));
     }
 
     updateFeeMinimizedLabel();
 }
 
 // Coin Control: copy label "Quantity" to clipboard
 void SendCoinsDialog::coinControlClipboardQuantity() {
     GUIUtil::setClipboard(ui->labelCoinControlQuantity->text());
 }
 
 // Coin Control: copy label "Amount" to clipboard
 void SendCoinsDialog::coinControlClipboardAmount() {
     GUIUtil::setClipboard(ui->labelCoinControlAmount->text().left(
         ui->labelCoinControlAmount->text().indexOf(" ")));
 }
 
 // Coin Control: copy label "Fee" to clipboard
 void SendCoinsDialog::coinControlClipboardFee() {
     GUIUtil::setClipboard(
         ui->labelCoinControlFee->text()
             .left(ui->labelCoinControlFee->text().indexOf(" "))
             .replace(ASYMP_UTF8, ""));
 }
 
 // Coin Control: copy label "After fee" to clipboard
 void SendCoinsDialog::coinControlClipboardAfterFee() {
     GUIUtil::setClipboard(
         ui->labelCoinControlAfterFee->text()
             .left(ui->labelCoinControlAfterFee->text().indexOf(" "))
             .replace(ASYMP_UTF8, ""));
 }
 
 // Coin Control: copy label "Bytes" to clipboard
 void SendCoinsDialog::coinControlClipboardBytes() {
     GUIUtil::setClipboard(
         ui->labelCoinControlBytes->text().replace(ASYMP_UTF8, ""));
 }
 
 // Coin Control: copy label "Dust" to clipboard
 void SendCoinsDialog::coinControlClipboardLowOutput() {
     GUIUtil::setClipboard(ui->labelCoinControlLowOutput->text());
 }
 
 // Coin Control: copy label "Change" to clipboard
 void SendCoinsDialog::coinControlClipboardChange() {
     GUIUtil::setClipboard(
         ui->labelCoinControlChange->text()
             .left(ui->labelCoinControlChange->text().indexOf(" "))
             .replace(ASYMP_UTF8, ""));
 }
 
 // Coin Control: settings menu - coin control enabled/disabled by user
 void SendCoinsDialog::coinControlFeatureChanged(bool checked) {
     ui->frameCoinControl->setVisible(checked);
 
     // coin control features disabled
     if (!checked && model) {
         m_coin_control->SetNull();
     }
 
     coinControlUpdateLabels();
 }
 
 // Coin Control: button inputs -> show actual coin control dialog
 void SendCoinsDialog::coinControlButtonClicked() {
     CoinControlDialog dlg(*m_coin_control, model, platformStyle);
     dlg.exec();
     coinControlUpdateLabels();
 }
 
 // Coin Control: checkbox custom change address
 void SendCoinsDialog::coinControlChangeChecked(int state) {
     if (state == Qt::Unchecked) {
         m_coin_control->destChange = CNoDestination();
         ui->labelCoinControlChangeLabel->clear();
     } else {
         // use this to re-validate an already entered address
         coinControlChangeEdited(ui->lineEditCoinControlChange->text());
     }
 
     ui->lineEditCoinControlChange->setEnabled((state == Qt::Checked));
 }
 
 // Coin Control: custom change address changed
 void SendCoinsDialog::coinControlChangeEdited(const QString &text) {
     if (model && model->getAddressTableModel()) {
         // Default to no change address until verified
         m_coin_control->destChange = CNoDestination();
         ui->labelCoinControlChangeLabel->setStyleSheet("QLabel{color:red;}");
 
         const CTxDestination dest =
             DecodeDestination(text.toStdString(), model->getChainParams());
 
         if (text.isEmpty()) {
             // Nothing entered
             ui->labelCoinControlChangeLabel->setText("");
         } else if (!IsValidDestination(dest)) {
             // Invalid address
             ui->labelCoinControlChangeLabel->setText(
                 tr("Warning: Invalid Bitcoin address"));
         } else {
             // Valid address
             if (!model->wallet().isSpendable(dest)) {
                 ui->labelCoinControlChangeLabel->setText(
                     tr("Warning: Unknown change address"));
 
                 // confirmation dialog
                 QMessageBox::StandardButton btnRetVal = QMessageBox::question(
                     this, tr("Confirm custom change address"),
                     tr("The address you selected for change is not part of "
                        "this wallet. Any or all funds in your wallet may be "
                        "sent to this address. Are you sure?"),
                     QMessageBox::Yes | QMessageBox::Cancel,
                     QMessageBox::Cancel);
 
                 if (btnRetVal == QMessageBox::Yes) {
                     m_coin_control->destChange = dest;
                 } else {
                     ui->lineEditCoinControlChange->setText("");
                     ui->labelCoinControlChangeLabel->setStyleSheet(
                         "QLabel{color:black;}");
                     ui->labelCoinControlChangeLabel->setText("");
                 }
             } else {
                 // Known change address
                 ui->labelCoinControlChangeLabel->setStyleSheet(
                     "QLabel{color:black;}");
 
                 // Query label
                 QString associatedLabel =
                     model->getAddressTableModel()->labelForAddress(text);
                 if (!associatedLabel.isEmpty()) {
                     ui->labelCoinControlChangeLabel->setText(associatedLabel);
                 } else {
                     ui->labelCoinControlChangeLabel->setText(tr("(no label)"));
                 }
 
                 m_coin_control->destChange = dest;
             }
         }
     }
 }
 
 // Coin Control: update labels
 void SendCoinsDialog::coinControlUpdateLabels() {
     if (!model || !model->getOptionsModel()) {
         return;
     }
 
     updateCoinControlState(*m_coin_control);
 
     // set pay amounts
     CoinControlDialog::payAmounts.clear();
     CoinControlDialog::fSubtractFeeFromAmount = false;
     for (int i = 0; i < ui->entries->count(); ++i) {
         SendCoinsEntry *entry =
             qobject_cast<SendCoinsEntry *>(ui->entries->itemAt(i)->widget());
         if (entry && !entry->isHidden()) {
             SendCoinsRecipient rcp = entry->getValue();
             CoinControlDialog::payAmounts.append(rcp.amount);
             if (rcp.fSubtractFeeFromAmount) {
                 CoinControlDialog::fSubtractFeeFromAmount = true;
             }
         }
     }
 
     if (m_coin_control->HasSelected()) {
         // actual coin control calculation
         CoinControlDialog::updateLabels(*m_coin_control, model, this);
 
         // show coin control stats
         ui->labelCoinControlAutomaticallySelected->hide();
         ui->widgetCoinControl->show();
     } else {
         // hide coin control stats
         ui->labelCoinControlAutomaticallySelected->show();
         ui->widgetCoinControl->hide();
         ui->labelCoinControlInsuffFunds->hide();
     }
 }
 
 SendConfirmationDialog::SendConfirmationDialog(
     const QString &title, const QString &text, const QString &informative_text,
     const QString &detailed_text, int _secDelay,
     const QString &_confirmButtonText, QWidget *parent)
     : QMessageBox(parent), secDelay(_secDelay),
       confirmButtonText(_confirmButtonText) {
     setIcon(QMessageBox::Question);
     // On macOS, the window title is ignored (as required by the macOS
     // Guidelines).
     setWindowTitle(title);
     setText(text);
     setInformativeText(informative_text);
     setDetailedText(detailed_text);
     setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
     setDefaultButton(QMessageBox::Cancel);
     yesButton = button(QMessageBox::Yes);
     updateYesButton();
     connect(&countDownTimer, &QTimer::timeout, this,
             &SendConfirmationDialog::countDown);
 }
 
 int SendConfirmationDialog::exec() {
     updateYesButton();
     countDownTimer.start(1000);
     return QMessageBox::exec();
 }
 
 void SendConfirmationDialog::countDown() {
     secDelay--;
     updateYesButton();
 
     if (secDelay <= 0) {
         countDownTimer.stop();
     }
 }
 
 void SendConfirmationDialog::updateYesButton() {
     if (secDelay > 0) {
         yesButton->setEnabled(false);
         yesButton->setText(confirmButtonText + " (" +
                            QString::number(secDelay) + ")");
     } else {
         yesButton->setEnabled(true);
         yesButton->setText(confirmButtonText);
     }
 }
diff --git a/src/qt/walletframe.cpp b/src/qt/walletframe.cpp
index 3422c0c05..f8a319df4 100644
--- a/src/qt/walletframe.cpp
+++ b/src/qt/walletframe.cpp
@@ -1,264 +1,267 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/walletframe.h>
 
+#include <fs.h>
 #include <qt/bitcoingui.h>
 #include <qt/createwalletdialog.h>
 #include <qt/overviewpage.h>
 #include <qt/walletcontroller.h>
 #include <qt/walletmodel.h>
 #include <qt/walletview.h>
 #include <util/system.h>
 
 #include <QGroupBox>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 #include <cassert>
+#include <fstream>
+#include <string>
 
 WalletFrame::WalletFrame(const PlatformStyle *_platformStyle, BitcoinGUI *_gui)
     : QFrame(_gui), gui(_gui), platformStyle(_platformStyle),
       m_size_hint(OverviewPage{platformStyle, nullptr}.sizeHint()) {
     // Leave HBox hook for adding a list view later
     QHBoxLayout *walletFrameLayout = new QHBoxLayout(this);
     setContentsMargins(0, 0, 0, 0);
     walletStack = new QStackedWidget(this);
     walletFrameLayout->setContentsMargins(0, 0, 0, 0);
     walletFrameLayout->addWidget(walletStack);
 
     // hbox for no wallet
     QGroupBox *no_wallet_group = new QGroupBox(walletStack);
     QVBoxLayout *no_wallet_layout = new QVBoxLayout(no_wallet_group);
 
     QLabel *noWallet = new QLabel(tr("No wallet has been loaded.\nGo to File > "
                                      "Open Wallet to load a wallet.\n- OR -"));
     noWallet->setAlignment(Qt::AlignCenter);
     no_wallet_layout->addWidget(noWallet, 0,
                                 Qt::AlignHCenter | Qt::AlignBottom);
 
     // A button for create wallet dialog
     QPushButton *create_wallet_button =
         new QPushButton(tr("Create a new wallet"), walletStack);
     connect(create_wallet_button, &QPushButton::clicked, [this] {
         auto activity =
             new CreateWalletActivity(gui->getWalletController(), this);
         connect(activity, &CreateWalletActivity::finished, activity,
                 &QObject::deleteLater);
         activity->create();
     });
     no_wallet_layout->addWidget(create_wallet_button, 0,
                                 Qt::AlignHCenter | Qt::AlignTop);
     no_wallet_group->setLayout(no_wallet_layout);
 
     walletStack->addWidget(no_wallet_group);
 }
 
 WalletFrame::~WalletFrame() {}
 
 void WalletFrame::setClientModel(ClientModel *_clientModel) {
     this->clientModel = _clientModel;
 
     for (auto i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd();
          ++i) {
         i.value()->setClientModel(_clientModel);
     }
 }
 
 bool WalletFrame::addWallet(WalletModel *walletModel) {
     if (!gui || !clientModel || !walletModel) {
         return false;
     }
 
     if (mapWalletViews.count(walletModel) > 0) {
         return false;
     }
 
     WalletView *walletView = new WalletView(platformStyle, walletModel, this);
     walletView->setClientModel(clientModel);
     walletView->showOutOfSyncWarning(bOutOfSync);
     walletView->setPrivacy(gui->isPrivacyModeActivated());
 
     WalletView *current_wallet_view = currentWalletView();
     if (current_wallet_view) {
         walletView->setCurrentIndex(current_wallet_view->currentIndex());
     } else {
         walletView->gotoOverviewPage();
     }
 
     walletStack->addWidget(walletView);
     mapWalletViews[walletModel] = walletView;
 
     connect(walletView, &WalletView::outOfSyncWarningClicked, this,
             &WalletFrame::outOfSyncWarningClicked);
     connect(walletView, &WalletView::transactionClicked, gui,
             &BitcoinGUI::gotoHistoryPage);
     connect(walletView, &WalletView::coinsSent, gui,
             &BitcoinGUI::gotoHistoryPage);
     connect(
         walletView, &WalletView::message,
         [this](const QString &title, const QString &message,
                unsigned int style) { gui->message(title, message, style); });
     connect(walletView, &WalletView::encryptionStatusChanged, gui,
             &BitcoinGUI::updateWalletStatus);
     connect(walletView, &WalletView::incomingTransaction, gui,
             &BitcoinGUI::incomingTransaction);
     connect(walletView, &WalletView::hdEnabledStatusChanged, gui,
             &BitcoinGUI::updateWalletStatus);
     connect(gui, &BitcoinGUI::setPrivacy, walletView, &WalletView::setPrivacy);
 
     return true;
 }
 
 void WalletFrame::setCurrentWallet(WalletModel *wallet_model) {
     if (mapWalletViews.count(wallet_model) == 0) {
         return;
     }
 
     WalletView *walletView = mapWalletViews.value(wallet_model);
     walletStack->setCurrentWidget(walletView);
     assert(walletView);
     walletView->updateEncryptionStatus();
 }
 
 void WalletFrame::removeWallet(WalletModel *wallet_model) {
     if (mapWalletViews.count(wallet_model) == 0) {
         return;
     }
 
     WalletView *walletView = mapWalletViews.take(wallet_model);
     walletStack->removeWidget(walletView);
     delete walletView;
 }
 
 void WalletFrame::removeAllWallets() {
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         walletStack->removeWidget(i.value());
     }
     mapWalletViews.clear();
 }
 
 bool WalletFrame::handlePaymentRequest(const SendCoinsRecipient &recipient) {
     WalletView *walletView = currentWalletView();
     if (!walletView) {
         return false;
     }
 
     return walletView->handlePaymentRequest(recipient);
 }
 
 void WalletFrame::showOutOfSyncWarning(bool fShow) {
     bOutOfSync = fShow;
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->showOutOfSyncWarning(fShow);
     }
 }
 
 void WalletFrame::gotoOverviewPage() {
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->gotoOverviewPage();
     }
 }
 
 void WalletFrame::gotoHistoryPage() {
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->gotoHistoryPage();
     }
 }
 
 void WalletFrame::gotoReceiveCoinsPage() {
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->gotoReceiveCoinsPage();
     }
 }
 
 void WalletFrame::gotoSendCoinsPage(QString addr) {
     QMap<WalletModel *, WalletView *>::const_iterator i;
     for (i = mapWalletViews.constBegin(); i != mapWalletViews.constEnd(); ++i) {
         i.value()->gotoSendCoinsPage(addr);
     }
 }
 
 void WalletFrame::gotoSignMessageTab(QString addr) {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->gotoSignMessageTab(addr);
     }
 }
 
 void WalletFrame::gotoVerifyMessageTab(QString addr) {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->gotoVerifyMessageTab(addr);
     }
 }
 
 void WalletFrame::gotoLoadPSBT() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->gotoLoadPSBT();
     }
 }
 
 void WalletFrame::encryptWallet() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->encryptWallet();
     }
 }
 
 void WalletFrame::backupWallet() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->backupWallet();
     }
 }
 
 void WalletFrame::changePassphrase() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->changePassphrase();
     }
 }
 
 void WalletFrame::unlockWallet() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->unlockWallet();
     }
 }
 
 void WalletFrame::usedSendingAddresses() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->usedSendingAddresses();
     }
 }
 
 void WalletFrame::usedReceivingAddresses() {
     WalletView *walletView = currentWalletView();
     if (walletView) {
         walletView->usedReceivingAddresses();
     }
 }
 
 WalletView *WalletFrame::currentWalletView() const {
     return qobject_cast<WalletView *>(walletStack->currentWidget());
 }
 
 WalletModel *WalletFrame::currentWalletModel() const {
     WalletView *wallet_view = currentWalletView();
     return wallet_view ? wallet_view->getWalletModel() : nullptr;
 }
 
 void WalletFrame::outOfSyncWarningClicked() {
     Q_EMIT requestedSyncWarningInfo();
 }
diff --git a/src/qt/walletview.cpp b/src/qt/walletview.cpp
index debc40513..9e852c57f 100644
--- a/src/qt/walletview.cpp
+++ b/src/qt/walletview.cpp
@@ -1,447 +1,449 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/walletview.h>
 
 #include <config.h> // For GetConfig
 #include <interfaces/node.h>
 #include <node/psbt.h>
 #include <node/transaction.h>
 #include <node/ui_interface.h>
 #include <policy/policy.h>
 #include <qt/addressbookpage.h>
 #include <qt/askpassphrasedialog.h>
 #include <qt/clientmodel.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <qt/overviewpage.h>
 #include <qt/platformstyle.h>
 #include <qt/receivecoinsdialog.h>
 #include <qt/sendcoinsdialog.h>
 #include <qt/signverifymessagedialog.h>
 #include <qt/transactiontablemodel.h>
 #include <qt/transactionview.h>
 #include <qt/walletmodel.h>
 #include <util/strencodings.h>
 
 #include <QAction>
 #include <QActionGroup>
 #include <QFileDialog>
 #include <QHBoxLayout>
 #include <QProgressDialog>
 #include <QPushButton>
 #include <QVBoxLayout>
 
+#include <fstream>
+
 using node::AnalyzePSBT;
 using node::DEFAULT_MAX_RAW_TX_FEE_RATE;
 using node::PSBTAnalysis;
 
 WalletView::WalletView(const PlatformStyle *_platformStyle,
                        WalletModel *_walletModel, QWidget *parent)
     : QStackedWidget(parent), clientModel(nullptr), walletModel(_walletModel),
       platformStyle(_platformStyle) {
     // Create tabs
     overviewPage = new OverviewPage(platformStyle);
 
     transactionsPage = new QWidget(this);
     QVBoxLayout *vbox = new QVBoxLayout();
     QHBoxLayout *hbox_buttons = new QHBoxLayout();
     transactionView = new TransactionView(platformStyle, this);
     vbox->addWidget(transactionView);
     QPushButton *exportButton = new QPushButton(tr("&Export"), this);
     exportButton->setToolTip(
         tr("Export the data in the current tab to a file"));
     if (platformStyle->getImagesOnButtons()) {
         exportButton->setIcon(platformStyle->SingleColorIcon(":/icons/export"));
     }
     hbox_buttons->addStretch();
     hbox_buttons->addWidget(exportButton);
     vbox->addLayout(hbox_buttons);
     transactionsPage->setLayout(vbox);
 
     receiveCoinsPage = new ReceiveCoinsDialog(platformStyle);
     sendCoinsPage = new SendCoinsDialog(platformStyle, walletModel);
 
     usedSendingAddressesPage =
         new AddressBookPage(platformStyle, AddressBookPage::ForEditing,
                             AddressBookPage::SendingTab, this);
     usedReceivingAddressesPage =
         new AddressBookPage(platformStyle, AddressBookPage::ForEditing,
                             AddressBookPage::ReceivingTab, this);
 
     addWidget(overviewPage);
     addWidget(transactionsPage);
     addWidget(receiveCoinsPage);
     addWidget(sendCoinsPage);
 
     connect(overviewPage, &OverviewPage::transactionClicked, this,
             &WalletView::transactionClicked);
     // Clicking on a transaction on the overview pre-selects the transaction on
     // the transaction history page
     connect(overviewPage, &OverviewPage::transactionClicked, transactionView,
             static_cast<void (TransactionView::*)(const QModelIndex &)>(
                 &TransactionView::focusTransaction));
 
     connect(overviewPage, &OverviewPage::outOfSyncWarningClicked, this,
             &WalletView::requestedSyncWarningInfo);
 
     connect(sendCoinsPage, &SendCoinsDialog::coinsSent, this,
             &WalletView::coinsSent);
     // Highlight transaction after send
     connect(sendCoinsPage, &SendCoinsDialog::coinsSent, transactionView,
             static_cast<void (TransactionView::*)(const uint256 &)>(
                 &TransactionView::focusTransaction));
 
     // Clicking on "Export" allows to export the transaction list
     connect(exportButton, &QPushButton::clicked, transactionView,
             &TransactionView::exportClicked);
 
     // Pass through messages from sendCoinsPage
     connect(sendCoinsPage, &SendCoinsDialog::message, this,
             &WalletView::message);
     // Pass through messages from transactionView
     connect(transactionView, &TransactionView::message, this,
             &WalletView::message);
     connect(this, &WalletView::setPrivacy, overviewPage,
             &OverviewPage::setPrivacy);
 
     // Set the model properly.
     setWalletModel(walletModel);
 }
 
 WalletView::~WalletView() {}
 
 void WalletView::setClientModel(ClientModel *_clientModel) {
     this->clientModel = _clientModel;
 
     overviewPage->setClientModel(_clientModel);
     sendCoinsPage->setClientModel(_clientModel);
     if (walletModel) {
         walletModel->setClientModel(_clientModel);
     }
 }
 
 void WalletView::setWalletModel(WalletModel *_walletModel) {
     this->walletModel = _walletModel;
 
     // Put transaction list in tabs
     transactionView->setModel(_walletModel);
     overviewPage->setWalletModel(_walletModel);
     receiveCoinsPage->setModel(_walletModel);
     sendCoinsPage->setModel(_walletModel);
     usedReceivingAddressesPage->setModel(
         _walletModel ? _walletModel->getAddressTableModel() : nullptr);
     usedSendingAddressesPage->setModel(
         _walletModel ? _walletModel->getAddressTableModel() : nullptr);
 
     if (_walletModel) {
         // Receive and pass through messages from wallet model
         connect(_walletModel, &WalletModel::message, this,
                 &WalletView::message);
 
         // Handle changes in encryption status
         connect(_walletModel, &WalletModel::encryptionStatusChanged, this,
                 &WalletView::encryptionStatusChanged);
         updateEncryptionStatus();
 
         // update HD status
         Q_EMIT hdEnabledStatusChanged();
 
         // Balloon pop-up for new transaction
         connect(_walletModel->getTransactionTableModel(),
                 &TransactionTableModel::rowsInserted, this,
                 &WalletView::processNewTransaction);
 
         // Ask for passphrase if needed
         connect(_walletModel, &WalletModel::requireUnlock, this,
                 &WalletView::unlockWallet);
 
         // Show progress dialog
         connect(_walletModel, &WalletModel::showProgress, this,
                 &WalletView::showProgress);
     }
 }
 
 void WalletView::processNewTransaction(const QModelIndex &parent, int start,
                                        int end) {
     // Prevent balloon-spam when initial block download is in progress
     if (!walletModel || !clientModel ||
         clientModel->node().isInitialBlockDownload()) {
         return;
     }
 
     TransactionTableModel *ttm = walletModel->getTransactionTableModel();
     if (!ttm || ttm->processingQueuedTransactions()) {
         return;
     }
 
     QString date = ttm->index(start, TransactionTableModel::Date, parent)
                        .data()
                        .toString();
     qint64 amount = ttm->index(start, TransactionTableModel::Amount, parent)
                         .data(Qt::EditRole)
                         .toULongLong();
     QString type = ttm->index(start, TransactionTableModel::Type, parent)
                        .data()
                        .toString();
     QModelIndex index = ttm->index(start, 0, parent);
     QString address =
         ttm->data(index, TransactionTableModel::AddressRole).toString();
     QString label = GUIUtil::HtmlEscape(
         ttm->data(index, TransactionTableModel::LabelRole).toString());
 
     Q_EMIT incomingTransaction(
         date, walletModel->getOptionsModel()->getDisplayUnit(),
         int64_t(amount) * SATOSHI, type, address, label,
         GUIUtil::HtmlEscape(walletModel->getWalletName()));
 }
 
 void WalletView::gotoOverviewPage() {
     setCurrentWidget(overviewPage);
 }
 
 void WalletView::gotoHistoryPage() {
     setCurrentWidget(transactionsPage);
 }
 
 void WalletView::gotoReceiveCoinsPage() {
     setCurrentWidget(receiveCoinsPage);
 }
 
 void WalletView::gotoSendCoinsPage(QString addr) {
     setCurrentWidget(sendCoinsPage);
 
     if (!addr.isEmpty()) {
         sendCoinsPage->setAddress(addr);
     }
 }
 
 void WalletView::gotoSignMessageTab(QString addr) {
     // calls show() in showTab_SM()
     SignVerifyMessageDialog *signVerifyMessageDialog =
         new SignVerifyMessageDialog(platformStyle, this);
     signVerifyMessageDialog->setAttribute(Qt::WA_DeleteOnClose);
     signVerifyMessageDialog->setModel(walletModel);
     signVerifyMessageDialog->showTab_SM(true);
 
     if (!addr.isEmpty()) {
         signVerifyMessageDialog->setAddress_SM(addr);
     }
 }
 
 void WalletView::gotoVerifyMessageTab(QString addr) {
     // calls show() in showTab_VM()
     SignVerifyMessageDialog *signVerifyMessageDialog =
         new SignVerifyMessageDialog(platformStyle, this);
     signVerifyMessageDialog->setAttribute(Qt::WA_DeleteOnClose);
     signVerifyMessageDialog->setModel(walletModel);
     signVerifyMessageDialog->showTab_VM(true);
 
     if (!addr.isEmpty()) {
         signVerifyMessageDialog->setAddress_VM(addr);
     }
 }
 
 void WalletView::gotoLoadPSBT() {
     QString filename = GUIUtil::getOpenFileName(
         this, tr("Load Transaction Data"), QString(),
         tr("Partially Signed Transaction (*.psbt)"), nullptr);
     if (filename.isEmpty()) {
         return;
     }
     if (GetFileSize(filename.toLocal8Bit().data(), MAX_FILE_SIZE_PSBT) ==
         MAX_FILE_SIZE_PSBT) {
         Q_EMIT message(tr("Error"),
                        tr("PSBT file must be smaller than 100 MiB"),
                        CClientUIInterface::MSG_ERROR);
         return;
     }
-    fsbridge::ifstream in{filename.toLocal8Bit().data(), std::ios::binary};
+    std::ifstream in{filename.toLocal8Bit().data(), std::ios::binary};
     std::string dataStr(std::istreambuf_iterator<char>{in}, {});
 
     std::string error;
     PartiallySignedTransaction psbtx;
     if (!DecodeRawPSBT(psbtx, dataStr, error)) {
         Q_EMIT message(tr("Error"),
                        tr("Unable to decode PSBT file") + "\n" +
                            QString::fromStdString(error),
                        CClientUIInterface::MSG_ERROR);
         return;
     }
 
     CMutableTransaction mtx;
     bool complete = false;
     PSBTAnalysis analysis = AnalyzePSBT(psbtx);
     QMessageBox msgBox;
     msgBox.setText("PSBT");
     switch (analysis.next) {
         case PSBTRole::CREATOR:
         case PSBTRole::UPDATER:
             msgBox.setInformativeText(
                 "PSBT is incomplete. Copy to clipboard for manual inspection?");
             break;
         case PSBTRole::SIGNER:
             msgBox.setInformativeText(
                 "Transaction needs more signatures. Copy to clipboard?");
             break;
         case PSBTRole::FINALIZER:
         case PSBTRole::EXTRACTOR:
             complete = FinalizeAndExtractPSBT(psbtx, mtx);
             if (complete) {
                 msgBox.setInformativeText(
                     tr("Would you like to send this transaction?"));
             } else {
                 // The analyzer missed something, e.g. if there are
                 // final_scriptSig but with invalid signatures.
                 msgBox.setInformativeText(
                     tr("There was an unexpected problem processing the PSBT. "
                        "Copy to clipboard for manual inspection?"));
             }
     }
 
     msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
     switch (msgBox.exec()) {
         case QMessageBox::Yes: {
             if (complete) {
                 std::string err_string;
                 CTransactionRef tx = MakeTransactionRef(mtx);
 
                 TransactionError result = BroadcastTransaction(
                     *clientModel->node().context(), GetConfig(), tx, err_string,
                     DEFAULT_MAX_RAW_TX_FEE_RATE.GetFeePerK(), /* relay */ true,
                     /* wait_callback */ false);
                 if (result == TransactionError::OK) {
                     Q_EMIT message(tr("Success"),
                                    tr("Broadcasted transaction successfully."),
                                    CClientUIInterface::MSG_INFORMATION |
                                        CClientUIInterface::MODAL);
                 } else {
                     Q_EMIT message(tr("Error"),
                                    QString::fromStdString(err_string),
                                    CClientUIInterface::MSG_ERROR);
                 }
             } else {
                 // Serialize the PSBT
                 CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
                 ssTx << psbtx;
                 GUIUtil::setClipboard(EncodeBase64(ssTx.str()).c_str());
                 Q_EMIT message(tr("PSBT copied"), "Copied to clipboard",
                                CClientUIInterface::MSG_INFORMATION);
                 return;
             }
         }
         case QMessageBox::Cancel:
             break;
         default:
             assert(false);
     }
 }
 
 bool WalletView::handlePaymentRequest(const SendCoinsRecipient &recipient) {
     return sendCoinsPage->handlePaymentRequest(recipient);
 }
 
 void WalletView::showOutOfSyncWarning(bool fShow) {
     overviewPage->showOutOfSyncWarning(fShow);
 }
 
 void WalletView::updateEncryptionStatus() {
     Q_EMIT encryptionStatusChanged();
 }
 
 void WalletView::encryptWallet() {
     if (!walletModel) {
         return;
     }
     AskPassphraseDialog dlg(AskPassphraseDialog::Encrypt, this);
     dlg.setModel(walletModel);
     dlg.exec();
 
     updateEncryptionStatus();
 }
 
 void WalletView::backupWallet() {
     QString filename =
         GUIUtil::getSaveFileName(this, tr("Backup Wallet"), QString(),
                                  tr("Wallet Data (*.dat)"), nullptr);
 
     if (filename.isEmpty()) {
         return;
     }
 
     if (!walletModel->wallet().backupWallet(filename.toLocal8Bit().data())) {
         Q_EMIT message(
             tr("Backup Failed"),
             tr("There was an error trying to save the wallet data to %1.")
                 .arg(filename),
             CClientUIInterface::MSG_ERROR);
     } else {
         Q_EMIT message(
             tr("Backup Successful"),
             tr("The wallet data was successfully saved to %1.").arg(filename),
             CClientUIInterface::MSG_INFORMATION);
     }
 }
 
 void WalletView::changePassphrase() {
     AskPassphraseDialog dlg(AskPassphraseDialog::ChangePass, this);
     dlg.setModel(walletModel);
     dlg.exec();
 }
 
 void WalletView::unlockWallet() {
     if (!walletModel) {
         return;
     }
 
     // Unlock wallet when requested by wallet model
     if (walletModel->getEncryptionStatus() == WalletModel::Locked) {
         AskPassphraseDialog dlg(AskPassphraseDialog::Unlock, this);
         dlg.setModel(walletModel);
         dlg.exec();
     }
 }
 
 void WalletView::usedSendingAddresses() {
     if (!walletModel) {
         return;
     }
 
     GUIUtil::bringToFront(usedSendingAddressesPage);
 }
 
 void WalletView::usedReceivingAddresses() {
     if (!walletModel) {
         return;
     }
 
     GUIUtil::bringToFront(usedReceivingAddressesPage);
 }
 
 void WalletView::showProgress(const QString &title, int nProgress) {
     if (nProgress == 0) {
         progressDialog = new QProgressDialog(title, tr("Cancel"), 0, 100);
         GUIUtil::PolishProgressDialog(progressDialog);
         progressDialog->setWindowModality(Qt::ApplicationModal);
         progressDialog->setMinimumDuration(0);
         progressDialog->setAutoClose(false);
         progressDialog->setValue(0);
     } else if (nProgress == 100) {
         if (progressDialog) {
             progressDialog->close();
             progressDialog->deleteLater();
             progressDialog = nullptr;
         }
     } else if (progressDialog) {
         if (progressDialog->wasCanceled()) {
             getWalletModel()->wallet().abortRescan();
         } else {
             progressDialog->setValue(nProgress);
         }
     }
 }
 
 void WalletView::requestedSyncWarningInfo() {
     Q_EMIT outOfSyncWarningClicked();
 }
diff --git a/src/rpc/request.cpp b/src/rpc/request.cpp
index f0d241d67..b378c0711 100644
--- a/src/rpc/request.cpp
+++ b/src/rpc/request.cpp
@@ -1,196 +1,201 @@
 // Copyright (c) 2018-2019 The Bitcoin developers
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <rpc/request.h>
 
 #include <fs.h>
 #include <logging.h>
 #include <random.h>
 #include <rpc/protocol.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
+#include <fstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
 /**
  * JSON-RPC protocol.  Bitcoin speaks version 1.0 for maximum compatibility, but
  * uses JSON-RPC 1.1/2.0 standards for parts of the 1.0 standard that were
  * unspecified (HTTP errors and contents of 'error').
  *
  * 1.0 spec: http://json-rpc.org/wiki/specification
  * 1.2 spec: http://jsonrpc.org/historical/json-rpc-over-http.html
  */
 
 UniValue JSONRPCRequestObj(const std::string &strMethod, const UniValue &params,
                            const UniValue &id) {
     UniValue request(UniValue::VOBJ);
     request.pushKV("method", strMethod);
     request.pushKV("params", params);
     request.pushKV("id", id);
     return request;
 }
 
 UniValue JSONRPCReplyObj(const UniValue &result, const UniValue &error,
                          const UniValue &id) {
     UniValue reply(UniValue::VOBJ);
     if (!error.isNull()) {
         reply.pushKV("result", NullUniValue);
     } else {
         reply.pushKV("result", result);
     }
     reply.pushKV("error", error);
     reply.pushKV("id", id);
     return reply;
 }
 
 std::string JSONRPCReply(const UniValue &result, const UniValue &error,
                          const UniValue &id) {
     UniValue reply = JSONRPCReplyObj(result, error, id);
     return reply.write() + "\n";
 }
 
 UniValue JSONRPCError(int code, const std::string &message) {
     UniValue error(UniValue::VOBJ);
     error.pushKV("code", code);
     error.pushKV("message", message);
     return error;
 }
 
 /**
  * Username used when cookie authentication is in use (arbitrary, only for
  * recognizability in debugging/logging purposes)
  */
 static const std::string COOKIEAUTH_USER = "__cookie__";
 /** Default name for auth cookie file */
 static const std::string COOKIEAUTH_FILE = ".cookie";
 
 /** Get name of RPC authentication cookie file */
 static fs::path GetAuthCookieFile(bool temp = false) {
     std::string arg = gArgs.GetArg("-rpccookiefile", COOKIEAUTH_FILE);
     if (temp) {
         arg += ".tmp";
     }
     return AbsPathForConfigVal(fs::PathFromString(arg));
 }
 
 bool GenerateAuthCookie(std::string *cookie_out) {
     const size_t COOKIE_SIZE = 32;
     uint8_t rand_pwd[COOKIE_SIZE];
     GetRandBytes(rand_pwd, COOKIE_SIZE);
     std::string cookie = COOKIEAUTH_USER + ":" + HexStr(rand_pwd);
 
     /**
      * the umask determines what permissions are used to create this file -
      * these are set to 077 in init.cpp unless overridden with -sysperms.
      */
-    fsbridge::ofstream file;
+    std::ofstream file;
     fs::path filepath_tmp = GetAuthCookieFile(true);
     file.open(filepath_tmp);
     if (!file.is_open()) {
         LogPrintf("Unable to open cookie authentication file %s for writing\n",
                   fs::PathToString(filepath_tmp));
         return false;
     }
     file << cookie;
     file.close();
 
     fs::path filepath = GetAuthCookieFile(false);
     if (!RenameOver(filepath_tmp, filepath)) {
         LogPrintf("Unable to rename cookie authentication file %s to %s\n",
                   fs::PathToString(filepath_tmp), fs::PathToString(filepath));
         return false;
     }
     LogPrintf("Generated RPC authentication cookie %s\n",
               fs::PathToString(filepath));
 
     if (cookie_out) {
         *cookie_out = cookie;
     }
     return true;
 }
 
 bool GetAuthCookie(std::string *cookie_out) {
-    fsbridge::ifstream file;
+    std::ifstream file;
     std::string cookie;
     fs::path filepath = GetAuthCookieFile();
     file.open(filepath);
     if (!file.is_open()) {
         return false;
     }
     std::getline(file, cookie);
     file.close();
 
     if (cookie_out) {
         *cookie_out = cookie;
     }
     return true;
 }
 
 void DeleteAuthCookie() {
     try {
         fs::remove(GetAuthCookieFile());
     } catch (const fs::filesystem_error &e) {
         LogPrintf("%s: Unable to remove random auth cookie file: %s\n",
                   __func__, fsbridge::get_filesystem_error_message(e));
     }
 }
 
 std::vector<UniValue> JSONRPCProcessBatchReply(const UniValue &in) {
     if (!in.isArray()) {
         throw std::runtime_error("Batch must be an array");
     }
     const size_t num{in.size()};
     std::vector<UniValue> batch(num);
     for (const UniValue &rec : in.getValues()) {
         if (!rec.isObject()) {
             throw std::runtime_error("Batch member must be an object");
         }
         size_t id = rec["id"].get_int();
         if (id >= num) {
             throw std::runtime_error(
                 "Batch member id is larger than batch size");
         }
         batch[id] = rec;
     }
     return batch;
 }
 
 void JSONRPCRequest::parse(const UniValue &valRequest) {
     // Parse request
     if (!valRequest.isObject()) {
         throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
     }
 
     const UniValue &request = valRequest.get_obj();
 
     // Parse id now so errors from here on will have the id
     id = find_value(request, "id");
 
     // Parse method
     UniValue valMethod = find_value(request, "method");
     if (valMethod.isNull()) {
         throw JSONRPCError(RPC_INVALID_REQUEST, "Missing method");
     }
     if (!valMethod.isStr()) {
         throw JSONRPCError(RPC_INVALID_REQUEST, "Method must be a string");
     }
     strMethod = valMethod.get_str();
     if (fLogIPs) {
         LogPrint(BCLog::RPC, "ThreadRPCServer method=%s user=%s peeraddr=%s\n",
                  SanitizeString(strMethod), this->authUser, this->peerAddr);
     } else {
         LogPrint(BCLog::RPC, "ThreadRPCServer method=%s user=%s\n",
                  SanitizeString(strMethod), this->authUser);
     }
 
     // Parse params
     UniValue valParams = find_value(request, "params");
     if (valParams.isArray() || valParams.isObject()) {
         params = valParams;
     } else if (valParams.isNull()) {
         params = UniValue(UniValue::VARR);
     } else {
         throw JSONRPCError(RPC_INVALID_REQUEST,
                            "Params must be an array or object");
     }
 }
diff --git a/src/seeder/main.cpp b/src/seeder/main.cpp
index 6bc418e4b..e25811358 100644
--- a/src/seeder/main.cpp
+++ b/src/seeder/main.cpp
@@ -1,450 +1,451 @@
 // 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.
 
 #include <clientversion.h>
 #include <dnsseeds.h>
 #include <fs.h>
 #include <logging.h>
 #include <protocol.h>
 #include <seeder/bitcoin.h>
 #include <seeder/db.h>
 #include <seeder/dns.h>
 #include <seeder/options.h>
 #include <streams.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <util/translation.h>
 
 #include <algorithm>
 #include <atomic>
 #include <cinttypes>
 #include <csignal>
 #include <cstdlib>
+#include <fstream>
 #include <functional>
 #include <pthread.h>
 
 const std::function<std::string(const char *)> G_TRANSLATION_FUN = nullptr;
 
 extern "C" {
 #include <seeder/dns.h>
 }
 
 CAddrDb db;
 
 extern "C" void *ThreadCrawler(void *data) {
     int *nThreads = (int *)data;
     do {
         std::vector<CServiceResult> ips;
         int wait = 5;
         db.GetMany(ips, 16, wait);
         int64_t now = GetTime();
         if (ips.empty()) {
             wait *= 1000;
             wait += rand() % (500 * *nThreads);
             UninterruptibleSleep(std::chrono::milliseconds(wait));
             continue;
         }
 
         std::vector<CAddress> addr;
         for (size_t i = 0; i < ips.size(); i++) {
             CServiceResult &res = ips[i];
             res.nBanTime = 0;
             res.nClientV = 0;
             res.nHeight = 0;
             res.strClientV = "";
             res.services = 0;
             bool getaddr = res.ourLastSuccess + 86400 < now;
             try {
                 CSeederNode node(res.service, getaddr ? &addr : nullptr);
                 bool ret = node.Run();
                 if (!ret) {
                     res.nBanTime = node.GetBan();
                 } else {
                     res.nBanTime = 0;
                 }
                 res.nClientV = node.GetClientVersion();
                 res.strClientV = node.GetClientSubVersion();
                 res.nHeight = node.GetStartingHeight();
                 res.services = node.GetServices();
                 // tfm::format(std::cout, "%s: %s!!!\n", cip.ToString(),
                 // ret ? "GOOD" : "BAD");
                 res.fGood = ret;
             } catch (std::ios_base::failure &e) {
                 res.nBanTime = 0;
                 res.fGood = false;
             }
         }
 
         db.ResultMany(ips);
         db.Add(addr);
     } while (1);
     return nullptr;
 }
 
 extern "C" uint32_t GetIPList(void *thread, char *requestedHostname,
                               addr_t *addr, uint32_t max, uint32_t ipv4,
                               uint32_t ipv6);
 
 class CDnsThread {
 public:
     struct FlagSpecificData {
         int nIPv4, nIPv6;
         std::vector<addr_t> cache;
         time_t cacheTime;
         unsigned int cacheHits;
         FlagSpecificData() : nIPv4(0), nIPv6(0), cacheTime(0), cacheHits(0) {}
     };
 
     dns_opt_t dns_opt; // must be first
     const int id;
     std::map<uint64_t, FlagSpecificData> perflag;
     std::atomic<uint64_t> dbQueries;
     std::set<uint64_t> filterWhitelist;
 
     void cacheHit(uint64_t requestedFlags, bool force = false) {
         static bool nets[NET_MAX] = {};
         if (!nets[NET_IPV4]) {
             nets[NET_IPV4] = true;
             nets[NET_IPV6] = true;
         }
         int64_t now = GetTime();
         FlagSpecificData &thisflag = perflag[requestedFlags];
         thisflag.cacheHits++;
         if (force ||
             thisflag.cacheHits * 400 >
                 (thisflag.cache.size() * thisflag.cache.size()) ||
             (thisflag.cacheHits * thisflag.cacheHits * 20 >
                  thisflag.cache.size() &&
              (now - thisflag.cacheTime > 5))) {
             std::set<CNetAddr> ips;
             db.GetIPs(ips, requestedFlags, 1000, nets);
             dbQueries++;
             thisflag.cache.clear();
             thisflag.nIPv4 = 0;
             thisflag.nIPv6 = 0;
             thisflag.cache.reserve(ips.size());
             for (auto &ip : ips) {
                 struct in_addr addr;
                 struct in6_addr addr6;
                 if (ip.GetInAddr(&addr)) {
                     addr_t a;
                     a.v = 4;
                     memcpy(&a.data.v4, &addr, 4);
                     thisflag.cache.push_back(a);
                     thisflag.nIPv4++;
                 } else if (ip.GetIn6Addr(&addr6)) {
                     addr_t a;
                     a.v = 6;
                     memcpy(&a.data.v6, &addr6, 16);
                     thisflag.cache.push_back(a);
                     thisflag.nIPv6++;
                 }
             }
             thisflag.cacheHits = 0;
             thisflag.cacheTime = now;
         }
     }
 
     CDnsThread(seeder::CDnsSeedOpts *opts, int idIn) : id(idIn) {
         dns_opt.host = opts->host.c_str();
         dns_opt.ns = opts->ns.c_str();
         dns_opt.mbox = opts->mbox.c_str();
         dns_opt.datattl = 3600;
         dns_opt.nsttl = 40000;
         dns_opt.cb = GetIPList;
         dns_opt.addr = opts->ip_addr.c_str();
         dns_opt.port = opts->nPort;
         dns_opt.nRequests = 0;
         dbQueries = 0;
         perflag.clear();
         filterWhitelist = opts->filter_whitelist;
     }
 
     void run() { dnsserver(&dns_opt); }
 };
 
 extern "C" uint32_t GetIPList(void *data, char *requestedHostname, addr_t *addr,
                               uint32_t max, uint32_t ipv4, uint32_t ipv6) {
     CDnsThread *thread = (CDnsThread *)data;
 
     uint64_t requestedFlags = 0;
     int hostlen = strlen(requestedHostname);
     if (hostlen > 1 && requestedHostname[0] == 'x' &&
         requestedHostname[1] != '0') {
         char *pEnd;
         uint64_t flags = (uint64_t)strtoull(requestedHostname + 1, &pEnd, 16);
         if (*pEnd == '.' && pEnd <= requestedHostname + 17 &&
             std::find(thread->filterWhitelist.begin(),
                       thread->filterWhitelist.end(),
                       flags) != thread->filterWhitelist.end()) {
             requestedFlags = flags;
         } else {
             return 0;
         }
     } else if (strcasecmp(requestedHostname, thread->dns_opt.host)) {
         return 0;
     }
     thread->cacheHit(requestedFlags);
     auto &thisflag = thread->perflag[requestedFlags];
     uint32_t size = thisflag.cache.size();
     uint32_t maxmax = (ipv4 ? thisflag.nIPv4 : 0) + (ipv6 ? thisflag.nIPv6 : 0);
     if (max > size) {
         max = size;
     }
     if (max > maxmax) {
         max = maxmax;
     }
     uint32_t i = 0;
     while (i < max) {
         uint32_t j = i + (rand() % (size - i));
         do {
             bool ok = (ipv4 && thisflag.cache[j].v == 4) ||
                       (ipv6 && thisflag.cache[j].v == 6);
             if (ok) {
                 break;
             }
             j++;
             if (j == size) {
                 j = i;
             }
         } while (1);
         addr[i] = thisflag.cache[j];
         thisflag.cache[j] = thisflag.cache[i];
         thisflag.cache[i] = addr[i];
         i++;
     }
     return max;
 }
 
 std::vector<CDnsThread *> dnsThread;
 
 extern "C" void *ThreadDNS(void *arg) {
     CDnsThread *thread = (CDnsThread *)arg;
     thread->run();
     return nullptr;
 }
 
 int StatCompare(const CAddrReport &a, const CAddrReport &b) {
     if (a.uptime[4] == b.uptime[4]) {
         if (a.uptime[3] == b.uptime[3]) {
             return a.clientVersion > b.clientVersion;
         } else {
             return a.uptime[3] > b.uptime[3];
         }
     } else {
         return a.uptime[4] > b.uptime[4];
     }
 }
 
 extern "C" void *ThreadDumper(void *data) {
     assert(data);
     const auto dumpInterval(*(const std::chrono::seconds *)data);
 
     // First dump should occur no later than 10 seconds. Successive dumps will
     // occur every dump interval.
     UninterruptibleSleep(std::min(10s, dumpInterval));
     do {
         std::vector<CAddrReport> v = db.GetAll();
         sort(v.begin(), v.end(), StatCompare);
         FILE *f = fsbridge::fopen("dnsseed.dat.new", "w+");
         if (f) {
             {
                 CAutoFile cf(f, SER_DISK, CLIENT_VERSION);
                 cf << db;
             }
             rename("dnsseed.dat.new", "dnsseed.dat");
         }
-        fsbridge::ofstream d{"dnsseed.dump"};
+        std::ofstream d{"dnsseed.dump"};
         tfm::format(d, "# address                                        good  "
                        "lastSuccess    %%(2h)   %%(8h)   %%(1d)   %%(7d)  "
                        "%%(30d)  blocks      svcs  version\n");
         double stat[5] = {0, 0, 0, 0, 0};
         for (CAddrReport rep : v) {
             tfm::format(
                 d,
                 "%-47s  %4d  %11" PRId64
                 "  %6.2f%% %6.2f%% %6.2f%% %6.2f%% %6.2f%%  %6i  %08" PRIx64
                 "  %5i \"%s\"\n",
                 rep.ip.ToString(), (int)rep.fGood, rep.lastSuccess,
                 100.0 * rep.uptime[0], 100.0 * rep.uptime[1],
                 100.0 * rep.uptime[2], 100.0 * rep.uptime[3],
                 100.0 * rep.uptime[4], rep.blocks, rep.services,
                 rep.clientVersion, rep.clientSubVersion);
             stat[0] += rep.uptime[0];
             stat[1] += rep.uptime[1];
             stat[2] += rep.uptime[2];
             stat[3] += rep.uptime[3];
             stat[4] += rep.uptime[4];
         }
-        fsbridge::ofstream ff{"dnsstats.log", std::ios_base::app};
+        std::ofstream ff{"dnsstats.log", std::ios_base::app};
         tfm::format(ff, "%llu %g %g %g %g %g\n", GetTime(), stat[0], stat[1],
                     stat[2], stat[3], stat[4]);
 
         UninterruptibleSleep(dumpInterval);
     } while (1);
     return nullptr;
 }
 
 extern "C" void *ThreadStats(void *) {
     bool first = true;
     do {
         char c[256];
         time_t tim = time(nullptr);
         struct tm *tmp = localtime(&tim);
         strftime(c, 256, "[%y-%m-%d %H:%M:%S]", tmp);
         CAddrDbStats stats;
         db.GetStats(stats);
         if (first) {
             first = false;
             tfm::format(std::cout, "\n\n\n\x1b[3A");
         } else {
             tfm::format(std::cout, "\x1b[2K\x1b[u");
         }
         tfm::format(std::cout, "\x1b[s");
         uint64_t requests = 0;
         uint64_t queries = 0;
         for (unsigned int i = 0; i < dnsThread.size(); i++) {
             requests += dnsThread[i]->dns_opt.nRequests;
             queries += dnsThread[i]->dbQueries;
         }
         tfm::format(
             std::cout,
             "%s %i/%i available (%i tried in %is, %i new, %i active), %i "
             "banned; %llu DNS requests, %llu db queries\n",
             c, stats.nGood, stats.nAvail, stats.nTracked, stats.nAge,
             stats.nNew, stats.nAvail - stats.nTracked - stats.nNew,
             stats.nBanned, (unsigned long long)requests,
             (unsigned long long)queries);
         UninterruptibleSleep(1s);
     } while (1);
     return nullptr;
 }
 
 const static unsigned int MAX_HOSTS_PER_SEED = 128;
 
 extern "C" void *ThreadSeeder(void *) {
     do {
         for (const std::string &seed : GetRandomizedDNSSeeds(Params())) {
             std::vector<CNetAddr> ips;
             LookupHost(seed.c_str(), ips, MAX_HOSTS_PER_SEED, true);
             for (auto &ip : ips) {
                 db.Add(CAddress(CService(ip, GetDefaultPort()), ServiceFlags()),
                        true);
             }
         }
         UninterruptibleSleep(30min);
     } while (1);
     return nullptr;
 }
 
 int main(int argc, char **argv) {
     // The logger dump everything on the console by default.
     LogInstance().m_print_to_console = true;
 
     signal(SIGPIPE, SIG_IGN);
     setbuf(stdout, nullptr);
     seeder::CDnsSeedOpts opts(&gArgs);
     opts.SetupSeederArgs();
     int parseResults =
         opts.ParseCommandLine(argc, const_cast<const char **>(argv));
     if (parseResults != seeder::CONTINUE_EXECUTION) {
         return parseResults;
     }
 
     tfm::format(std::cout, "Supporting whitelisted filters: ");
     for (std::set<uint64_t>::const_iterator it = opts.filter_whitelist.begin();
          it != opts.filter_whitelist.end(); it++) {
         if (it != opts.filter_whitelist.begin()) {
             tfm::format(std::cout, ",");
         }
         tfm::format(std::cout, "0x%lx", (unsigned long)*it);
     }
     tfm::format(std::cout, "\n");
     if (!opts.tor.empty()) {
         CService service(LookupNumeric(opts.tor.c_str(), 9050));
         if (service.IsValid()) {
             tfm::format(std::cout, "Using Tor proxy at %s\n",
                         service.ToStringIPPort());
             SetProxy(NET_ONION, proxyType(service));
         }
     }
     if (!opts.ipv4_proxy.empty()) {
         CService service(LookupNumeric(opts.ipv4_proxy.c_str(), 9050));
         if (service.IsValid()) {
             tfm::format(std::cout, "Using IPv4 proxy at %s\n",
                         service.ToStringIPPort());
             SetProxy(NET_IPV4, proxyType(service));
         }
     }
     if (!opts.ipv6_proxy.empty()) {
         CService service(LookupNumeric(opts.ipv6_proxy.c_str(), 9050));
         if (service.IsValid()) {
             tfm::format(std::cout, "Using IPv6 proxy at %s\n",
                         service.ToStringIPPort());
             SetProxy(NET_IPV6, proxyType(service));
         }
     }
     bool fDNS = true;
     tfm::format(std::cout, "Using %s.\n", gArgs.GetChainName());
     if (opts.ns.empty()) {
         tfm::format(std::cout, "No nameserver set. Not starting DNS server.\n");
         fDNS = false;
     }
     if (fDNS && opts.host.empty()) {
         tfm::format(std::cerr, "No hostname set. Please use -h.\n");
         return EXIT_FAILURE;
     }
     if (fDNS && opts.mbox.empty()) {
         tfm::format(std::cerr, "No e-mail address set. Please use -m.\n");
         return EXIT_FAILURE;
     }
     FILE *f = fsbridge::fopen("dnsseed.dat", "r");
     if (f) {
         tfm::format(std::cout, "Loading dnsseed.dat...");
         CAutoFile cf(f, SER_DISK, CLIENT_VERSION);
         cf >> db;
         if (opts.fWipeBan) {
             db.banned.clear();
             tfm::format(std::cout, "Ban list wiped...");
         }
         if (opts.fWipeIgnore) {
             db.ResetIgnores();
             tfm::format(std::cout, "Ignore list wiped...");
         }
         tfm::format(std::cout, "done\n");
     }
     pthread_t threadDns, threadSeed, threadDump, threadStats;
     if (fDNS) {
         tfm::format(std::cout,
                     "Starting %i DNS threads for %s on %s (port %i)...",
                     opts.nDnsThreads, opts.host, opts.ns, opts.nPort);
         dnsThread.clear();
         for (int i = 0; i < opts.nDnsThreads; i++) {
             dnsThread.push_back(new CDnsThread(&opts, i));
             pthread_create(&threadDns, nullptr, ThreadDNS, dnsThread[i]);
             tfm::format(std::cout, ".");
             UninterruptibleSleep(20ms);
         }
         tfm::format(std::cout, "done\n");
     }
     tfm::format(std::cout, "Starting seeder...");
     pthread_create(&threadSeed, nullptr, ThreadSeeder, nullptr);
     tfm::format(std::cout, "done\n");
     tfm::format(std::cout, "Starting %i crawler threads...", opts.nThreads);
     pthread_attr_t attr_crawler;
     pthread_attr_init(&attr_crawler);
     pthread_attr_setstacksize(&attr_crawler, 0x20000);
     for (int i = 0; i < opts.nThreads; i++) {
         pthread_t thread;
         pthread_create(&thread, &attr_crawler, ThreadCrawler, &opts.nThreads);
     }
     pthread_attr_destroy(&attr_crawler);
     tfm::format(std::cout, "done\n");
     pthread_create(&threadStats, nullptr, ThreadStats, nullptr);
     pthread_create(&threadDump, nullptr, ThreadDumper, &opts.dumpInterval);
     void *res;
     pthread_join(threadDump, &res);
     return EXIT_SUCCESS;
 }
diff --git a/src/test/fs_tests.cpp b/src/test/fs_tests.cpp
index 63078e518..1cf2107a3 100644
--- a/src/test/fs_tests.cpp
+++ b/src/test/fs_tests.cpp
@@ -1,123 +1,124 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 //
 #include <fs.h>
 
 #include <util/getuniquepath.h>
 #include <util/system.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <fstream>
+#include <ios>
+#include <string>
+
 BOOST_FIXTURE_TEST_SUITE(fs_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(fsbridge_pathtostring) {
     std::string u8_str = "fs_tests_₿_🏃";
     BOOST_CHECK_EQUAL(fs::PathToString(fs::PathFromString(u8_str)), u8_str);
     BOOST_CHECK_EQUAL(fs::u8path(u8_str).u8string(), u8_str);
     BOOST_CHECK_EQUAL(fs::PathFromString(u8_str).u8string(), u8_str);
     BOOST_CHECK_EQUAL(fs::PathToString(fs::u8path(u8_str)), u8_str);
 #ifndef WIN32
     // On non-windows systems, verify that arbitrary byte strings containing
     // invalid UTF-8 can be round tripped successfully with PathToString and
     // PathFromString. On non-windows systems, paths are just byte strings so
     // these functions do not do any encoding. On windows, paths are Unicode,
     // and these functions do encoding and decoding, so the behavior of this
     // test would be undefined.
     std::string invalid_u8_str = "\xf0";
     BOOST_CHECK_EQUAL(invalid_u8_str.size(), 1);
     BOOST_CHECK_EQUAL(fs::PathToString(fs::PathFromString(invalid_u8_str)),
                       invalid_u8_str);
 #endif
 }
 
 BOOST_AUTO_TEST_CASE(fsbridge_stem) {
     std::string test_filename = "fs_tests_₿_🏃.dat";
     std::string expected_stem = "fs_tests_₿_🏃";
     BOOST_CHECK_EQUAL(
         fs::PathToString(fs::PathFromString(test_filename).stem()),
         expected_stem);
 }
 
 BOOST_AUTO_TEST_CASE(fsbridge_fstream) {
     fs::path tmpfolder = m_args.GetDataDirBase();
     // tmpfile1 should be the same as tmpfile2
     fs::path tmpfile1 = tmpfolder / "fs_tests_₿_🏃";
     fs::path tmpfile2 = tmpfolder / "fs_tests_₿_🏃";
     {
-        fsbridge::ofstream file(tmpfile1);
+        std::ofstream file{tmpfile1};
         file << "bitcoin";
     }
     {
-        fsbridge::ifstream file(tmpfile2);
+        std::ifstream file{tmpfile2};
         std::string input_buffer;
         file >> input_buffer;
         BOOST_CHECK_EQUAL(input_buffer, "bitcoin");
     }
     {
-        fsbridge::ifstream file(tmpfile1,
-                                std::ios_base::in | std::ios_base::ate);
+        std::ifstream file{tmpfile1, std::ios_base::in | std::ios_base::ate};
         std::string input_buffer;
         file >> input_buffer;
         BOOST_CHECK_EQUAL(input_buffer, "");
     }
     {
-        fsbridge::ofstream file(tmpfile2,
-                                std::ios_base::out | std::ios_base::app);
+        std::ofstream file{tmpfile2, std::ios_base::out | std::ios_base::app};
         file << "tests";
     }
     {
-        fsbridge::ifstream file(tmpfile1);
+        std::ifstream file{tmpfile1};
         std::string input_buffer;
         file >> input_buffer;
         BOOST_CHECK_EQUAL(input_buffer, "bitcointests");
     }
     {
-        fsbridge::ofstream file(tmpfile2,
-                                std::ios_base::out | std::ios_base::trunc);
+        std::ofstream file{tmpfile2, std::ios_base::out | std::ios_base::trunc};
         file << "bitcoin";
     }
     {
-        fsbridge::ifstream file(tmpfile1);
+        std::ifstream file{tmpfile1};
         std::string input_buffer;
         file >> input_buffer;
         BOOST_CHECK_EQUAL(input_buffer, "bitcoin");
     }
     {
         // Join an absolute path and a relative path.
         fs::path p = fsbridge::AbsPathJoin(tmpfolder, "fs_tests_₿_🏃");
         BOOST_CHECK(p.is_absolute());
         BOOST_CHECK_EQUAL(tmpfile1, p);
     }
     {
         // Join two absolute paths.
         fs::path p = fsbridge::AbsPathJoin(tmpfile1, tmpfile2);
         BOOST_CHECK(p.is_absolute());
         BOOST_CHECK_EQUAL(tmpfile2, p);
     }
     {
         // Ensure joining with empty paths does not add trailing path
         // components.
         BOOST_CHECK_EQUAL(tmpfile1, fsbridge::AbsPathJoin(tmpfile1, ""));
         BOOST_CHECK_EQUAL(tmpfile1, fsbridge::AbsPathJoin(tmpfile1, {}));
     }
     {
         fs::path p1 = GetUniquePath(tmpfolder);
         fs::path p2 = GetUniquePath(tmpfolder);
         fs::path p3 = GetUniquePath(tmpfolder);
 
         // Ensure that the parent path is always the same.
         BOOST_CHECK_EQUAL(tmpfolder, p1.parent_path());
         BOOST_CHECK_EQUAL(tmpfolder, p2.parent_path());
         BOOST_CHECK_EQUAL(tmpfolder, p3.parent_path());
 
         // Ensure that generated paths are actually different.
         BOOST_CHECK(p1 != p2);
         BOOST_CHECK(p2 != p3);
         BOOST_CHECK(p1 != p3);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/settings_tests.cpp b/src/test/settings_tests.cpp
index 5f29855dc..c2cecb23f 100644
--- a/src/test/settings_tests.cpp
+++ b/src/test/settings_tests.cpp
@@ -1,295 +1,300 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <util/settings.h>
 
+#include <fs.h>
 #include <test/util/setup_common.h>
 #include <test/util/str.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
 
 #include <univalue.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <fstream>
+#include <map>
+#include <string>
+#include <system_error>
 #include <vector>
 
 inline bool operator==(const util::SettingsValue &a,
                        const util::SettingsValue &b) {
     return a.write() == b.write();
 }
 
 inline std::ostream &operator<<(std::ostream &os,
                                 const util::SettingsValue &value) {
     os << value.write();
     return os;
 }
 
 inline std::ostream &
 operator<<(std::ostream &os,
            const std::pair<std::string, util::SettingsValue> &kv) {
     util::SettingsValue out(util::SettingsValue::VOBJ);
     out.__pushKV(kv.first, kv.second);
     os << out.write();
     return os;
 }
 
 inline void WriteText(const fs::path &path, const std::string &text) {
-    fsbridge::ofstream file;
+    std::ofstream file;
     file.open(path);
     file << text;
 }
 
 BOOST_FIXTURE_TEST_SUITE(settings_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(ReadWrite) {
     fs::path path = m_args.GetDataDirBase() / "settings.json";
 
     WriteText(path, R"({
         "string": "string",
         "num": 5,
         "bool": true,
         "null": null
     })");
 
     std::map<std::string, util::SettingsValue> expected{
         {"string", "string"},
         {"num", 5},
         {"bool", true},
         {"null", {}},
     };
 
     // Check file read.
     std::map<std::string, util::SettingsValue> values;
     std::vector<std::string> errors;
     BOOST_CHECK(util::ReadSettings(path, values, errors));
     BOOST_CHECK_EQUAL_COLLECTIONS(values.begin(), values.end(),
                                   expected.begin(), expected.end());
     BOOST_CHECK(errors.empty());
 
     // Check no errors if file doesn't exist.
     fs::remove(path);
     BOOST_CHECK(util::ReadSettings(path, values, errors));
     BOOST_CHECK(values.empty());
     BOOST_CHECK(errors.empty());
 
     // Check duplicate keys not allowed
     WriteText(path, R"({
         "dupe": "string",
         "dupe": "dupe"
     })");
     BOOST_CHECK(!util::ReadSettings(path, values, errors));
     std::vector<std::string> dup_keys = {
         strprintf("Found duplicate key dupe in settings file %s",
                   fs::PathToString(path))};
     BOOST_CHECK_EQUAL_COLLECTIONS(errors.begin(), errors.end(),
                                   dup_keys.begin(), dup_keys.end());
 
     // Check non-kv json files not allowed
     WriteText(path, R"("non-kv")");
     BOOST_CHECK(!util::ReadSettings(path, values, errors));
     std::vector<std::string> non_kv = {
         strprintf("Found non-object value \"non-kv\" in settings file %s",
                   fs::PathToString(path))};
     BOOST_CHECK_EQUAL_COLLECTIONS(errors.begin(), errors.end(), non_kv.begin(),
                                   non_kv.end());
 
     // Check invalid json not allowed
     WriteText(path, R"(invalid json)");
     BOOST_CHECK(!util::ReadSettings(path, values, errors));
     std::vector<std::string> fail_parse = {
         strprintf("Unable to parse settings file %s", fs::PathToString(path))};
     BOOST_CHECK_EQUAL_COLLECTIONS(errors.begin(), errors.end(),
                                   fail_parse.begin(), fail_parse.end());
 }
 
 //! Check settings struct contents against expected json strings.
 static void CheckValues(const util::Settings &settings,
                         const std::string &single_val,
                         const std::string &list_val) {
     util::SettingsValue single_value =
         GetSetting(settings, "section", "name", false, false);
     util::SettingsValue list_value(util::SettingsValue::VARR);
     for (const auto &item :
          GetSettingsList(settings, "section", "name", false)) {
         list_value.push_back(item);
     }
     BOOST_CHECK_EQUAL(single_value.write().c_str(), single_val);
     BOOST_CHECK_EQUAL(list_value.write().c_str(), list_val);
 };
 
 // Simple settings merge test case.
 BOOST_AUTO_TEST_CASE(Simple) {
     util::Settings settings;
     settings.command_line_options["name"].push_back("val1");
     settings.command_line_options["name"].push_back("val2");
     settings.ro_config["section"]["name"].push_back(2);
 
     // The last given arg takes precedence when specified via commandline.
     CheckValues(settings, R"("val2")", R"(["val1","val2",2])");
 
     util::Settings settings2;
     settings2.ro_config["section"]["name"].push_back("val2");
     settings2.ro_config["section"]["name"].push_back("val3");
 
     // The first given arg takes precedence when specified via config file.
     CheckValues(settings2, R"("val2")", R"(["val2","val3"])");
 }
 
 // Confirm that a high priority setting overrides a lower priority setting even
 // if the high priority setting is null. This behavior is useful for a high
 // priority setting source to be able to effectively reset any setting back to
 // its default value.
 BOOST_AUTO_TEST_CASE(NullOverride) {
     util::Settings settings;
     settings.command_line_options["name"].push_back("value");
     BOOST_CHECK_EQUAL(
         R"("value")",
         GetSetting(settings, "section", "name", false, false).write().c_str());
     settings.forced_settings["name"] = {};
     BOOST_CHECK_EQUAL(
         R"(null)",
         GetSetting(settings, "section", "name", false, false).write().c_str());
 }
 
 // Test different ways settings can be merged, and verify results. This test can
 // be used to confirm that updates to settings code don't change behavior
 // unintentionally.
 struct MergeTestingSetup : public BasicTestingSetup {
     //! Max number of actions to sequence together. Can decrease this when
     //! debugging to make test results easier to understand.
     static constexpr int MAX_ACTIONS = 3;
 
     enum Action { END, SET, NEGATE, SECTION_SET, SECTION_NEGATE };
     using ActionList = Action[MAX_ACTIONS];
 
     //! Enumerate all possible test configurations.
     template <typename Fn> void ForEachMergeSetup(Fn &&fn) {
         ActionList arg_actions = {};
         // command_line_options do not have sections. Only iterate over SET and
         // NEGATE
         ForEachNoDup(arg_actions, SET, NEGATE, [&] {
             ActionList conf_actions = {};
             ForEachNoDup(conf_actions, SET, SECTION_NEGATE, [&] {
                 for (bool force_set : {false, true}) {
                     for (bool ignore_default_section_config : {false, true}) {
                         fn(arg_actions, conf_actions, force_set,
                            ignore_default_section_config);
                     }
                 }
             });
         });
     }
 };
 
 // Regression test covering different ways config settings can be merged. The
 // test parses and merges settings, representing the results as strings that get
 // compared against an expected hash. To debug, the result strings can be dumped
 // to a file (see comments below).
 BOOST_FIXTURE_TEST_CASE(Merge, MergeTestingSetup) {
     CHash256 out_sha;
     FILE *out_file = nullptr;
     if (const char *out_path = getenv("SETTINGS_MERGE_TEST_OUT")) {
         out_file = fsbridge::fopen(out_path, "w");
         if (!out_file) {
             throw std::system_error(errno, std::generic_category(),
                                     "fopen failed");
         }
     }
 
     const std::string &network = CBaseChainParams::MAIN;
     ForEachMergeSetup([&](const ActionList &arg_actions,
                           const ActionList &conf_actions, bool force_set,
                           bool ignore_default_section_config) {
         std::string desc;
         int value_suffix = 0;
         util::Settings settings;
 
         const std::string &name =
             ignore_default_section_config ? "wallet" : "server";
         auto push_values = [&](Action action, const char *value_prefix,
                                const std::string &name_prefix,
                                std::vector<util::SettingsValue> &dest) {
             if (action == SET || action == SECTION_SET) {
                 for (int i = 0; i < 2; ++i) {
                     dest.push_back(value_prefix + ToString(++value_suffix));
                     desc +=
                         " " + name_prefix + name + "=" + dest.back().get_str();
                 }
             } else if (action == NEGATE || action == SECTION_NEGATE) {
                 dest.push_back(false);
                 desc += " " + name_prefix + "no" + name;
             }
         };
 
         if (force_set) {
             settings.forced_settings[name] = "forced";
             desc += " " + name + "=forced";
         }
         for (Action arg_action : arg_actions) {
             push_values(arg_action, "a", "-",
                         settings.command_line_options[name]);
         }
         for (Action conf_action : conf_actions) {
             bool use_section =
                 conf_action == SECTION_SET || conf_action == SECTION_NEGATE;
             push_values(conf_action, "c", use_section ? network + "." : "",
                         settings.ro_config[use_section ? network : ""][name]);
         }
 
         desc += " || ";
         desc +=
             GetSetting(settings, network, name, ignore_default_section_config,
                        /* get_chain_name= */ false)
                 .write();
         desc += " |";
         for (const auto &s : GetSettingsList(settings, network, name,
                                              ignore_default_section_config)) {
             desc += " ";
             desc += s.write();
         }
         desc += " |";
         if (OnlyHasDefaultSectionSetting(settings, network, name)) {
             desc += " ignored";
         }
         desc += "\n";
 
         out_sha.Write(MakeUCharSpan(desc));
         if (out_file) {
             BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) ==
                           desc.size());
         }
     });
 
     if (out_file) {
         if (fclose(out_file)) {
             throw std::system_error(errno, std::generic_category(),
                                     "fclose failed");
         }
         out_file = nullptr;
     }
 
     uint8_t out_sha_bytes[CSHA256::OUTPUT_SIZE];
     out_sha.Finalize(out_sha_bytes);
     std::string out_sha_hex = HexStr(out_sha_bytes);
 
     // If check below fails, should manually dump the results with:
     //
     //   SETTINGS_MERGE_TEST_OUT=results.txt ./test_bitcoin
     //   --run_test=settings_tests/Merge
     //
     // And verify diff against previous results to make sure the changes are
     // expected.
     //
     // Results file is formatted like:
     //
     //   <input> || GetSetting() | GetSettingsList() |
     //   OnlyHasDefaultSectionSetting()
     BOOST_CHECK_EQUAL(
         out_sha_hex,
         "79db02d74e3e193196541b67c068b40ebd0c124a24b3ecbe9cbf7e85b1c4ba7a");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/streams_tests.cpp b/src/test/streams_tests.cpp
index e3c1e22b5..aed51e12d 100644
--- a/src/test/streams_tests.cpp
+++ b/src/test/streams_tests.cpp
@@ -1,470 +1,471 @@
 // Copyright (c) 2012-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <fs.h>
 #include <random.h>
 #include <streams.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(streams_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(streams_vector_writer) {
     uint8_t a(1);
     uint8_t b(2);
     uint8_t bytes[] = {3, 4, 5, 6};
     std::vector<uint8_t> vch;
 
     // Each test runs twice. Serializing a second time at the same starting
     // point should yield the same results, even if the first test grew the
     // vector.
 
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{1, 2}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{1, 2}}));
     vch.clear();
 
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 1, 2}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 1, 2}}));
     vch.clear();
 
     vch.resize(5, 0);
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 1, 2, 0}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 1, 2, 0}}));
     vch.clear();
 
     vch.resize(4, 0);
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 3, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 0, 1, 2}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 3, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 0, 1, 2}}));
     vch.clear();
 
     vch.resize(4, 0);
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 4, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 0, 0, 1, 2}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 4, a, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{0, 0, 0, 0, 1, 2}}));
     vch.clear();
 
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, bytes);
     BOOST_CHECK((vch == std::vector<uint8_t>{{3, 4, 5, 6}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, bytes);
     BOOST_CHECK((vch == std::vector<uint8_t>{{3, 4, 5, 6}}));
     vch.clear();
 
     vch.resize(4, 8);
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, bytes, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{8, 8, 1, 3, 4, 5, 6, 2}}));
     CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, bytes, b);
     BOOST_CHECK((vch == std::vector<uint8_t>{{8, 8, 1, 3, 4, 5, 6, 2}}));
     vch.clear();
 }
 
 BOOST_AUTO_TEST_CASE(streams_vector_reader) {
     std::vector<uint8_t> vch = {1, 255, 3, 4, 5, 6};
 
     VectorReader reader(SER_NETWORK, INIT_PROTO_VERSION, vch, 0);
     BOOST_CHECK_EQUAL(reader.size(), 6U);
     BOOST_CHECK(!reader.empty());
 
     // Read a single byte as an uint8_t.
     uint8_t a;
     reader >> a;
     BOOST_CHECK_EQUAL(a, 1);
     BOOST_CHECK_EQUAL(reader.size(), 5U);
     BOOST_CHECK(!reader.empty());
 
     // Read a single byte as a (signed) int8_t.
     int8_t b;
     reader >> b;
     BOOST_CHECK_EQUAL(b, -1);
     BOOST_CHECK_EQUAL(reader.size(), 4U);
     BOOST_CHECK(!reader.empty());
 
     // Read a 4 bytes as an unsigned uint32_t.
     uint32_t c;
     reader >> c;
     // 100992003 = 3,4,5,6 in little-endian base-256
     BOOST_CHECK_EQUAL(c, 100992003);
     BOOST_CHECK_EQUAL(reader.size(), 0U);
     BOOST_CHECK(reader.empty());
 
     // Reading after end of byte vector throws an error.
     int32_t d;
     BOOST_CHECK_THROW(reader >> d, std::ios_base::failure);
 
     // Read a 4 bytes as a (signed) int32_t from the beginning of the buffer.
     VectorReader new_reader(SER_NETWORK, INIT_PROTO_VERSION, vch, 0);
     new_reader >> d;
     // 67370753 = 1,255,3,4 in little-endian base-256
     BOOST_CHECK_EQUAL(d, 67370753);
     BOOST_CHECK_EQUAL(new_reader.size(), 2U);
     BOOST_CHECK(!new_reader.empty());
 
     // Reading after end of byte vector throws an error even if the reader is
     // not totally empty.
     BOOST_CHECK_THROW(new_reader >> d, std::ios_base::failure);
 }
 
 BOOST_AUTO_TEST_CASE(bitstream_reader_writer) {
     CDataStream data(SER_NETWORK, INIT_PROTO_VERSION);
 
     BitStreamWriter<CDataStream> bit_writer(data);
     bit_writer.Write(0, 1);
     bit_writer.Write(2, 2);
     bit_writer.Write(6, 3);
     bit_writer.Write(11, 4);
     bit_writer.Write(1, 5);
     bit_writer.Write(32, 6);
     bit_writer.Write(7, 7);
     bit_writer.Write(30497, 16);
     bit_writer.Flush();
 
     CDataStream data_copy(data);
     uint32_t serialized_int1;
     data >> serialized_int1;
     // NOTE: Serialized as LE
     BOOST_CHECK_EQUAL(serialized_int1, (uint32_t)0x7700C35A);
     uint16_t serialized_int2;
     data >> serialized_int2;
     // NOTE: Serialized as LE
     BOOST_CHECK_EQUAL(serialized_int2, (uint16_t)0x1072);
 
     BitStreamReader<CDataStream> bit_reader(data_copy);
     BOOST_CHECK_EQUAL(bit_reader.Read(1), 0U);
     BOOST_CHECK_EQUAL(bit_reader.Read(2), 2U);
     BOOST_CHECK_EQUAL(bit_reader.Read(3), 6U);
     BOOST_CHECK_EQUAL(bit_reader.Read(4), 11U);
     BOOST_CHECK_EQUAL(bit_reader.Read(5), 1U);
     BOOST_CHECK_EQUAL(bit_reader.Read(6), 32U);
     BOOST_CHECK_EQUAL(bit_reader.Read(7), 7U);
     BOOST_CHECK_EQUAL(bit_reader.Read(16), 30497U);
     BOOST_CHECK_THROW(bit_reader.Read(8), std::ios_base::failure);
 }
 
 BOOST_AUTO_TEST_CASE(streams_serializedata_xor) {
     std::vector<char> in;
     std::vector<char> expected_xor;
     std::vector<uint8_t> key;
     CDataStream ds(in, 0, 0);
 
     // Degenerate case
 
     key.push_back('\x00');
     key.push_back('\x00');
     ds.Xor(key);
     BOOST_CHECK_EQUAL(std::string(expected_xor.begin(), expected_xor.end()),
                       std::string(ds.begin(), ds.end()));
 
     in.push_back('\x0f');
     in.push_back('\xf0');
     expected_xor.push_back('\xf0');
     expected_xor.push_back('\x0f');
 
     // Single character key
 
     ds.clear();
     ds.insert(ds.begin(), in.begin(), in.end());
     key.clear();
 
     key.push_back('\xff');
     ds.Xor(key);
     BOOST_CHECK_EQUAL(std::string(expected_xor.begin(), expected_xor.end()),
                       std::string(ds.begin(), ds.end()));
 
     // Multi character key
 
     in.clear();
     expected_xor.clear();
     in.push_back('\xf0');
     in.push_back('\x0f');
     expected_xor.push_back('\x0f');
     expected_xor.push_back('\x00');
 
     ds.clear();
     ds.insert(ds.begin(), in.begin(), in.end());
 
     key.clear();
     key.push_back('\xff');
     key.push_back('\x0f');
 
     ds.Xor(key);
     BOOST_CHECK_EQUAL(std::string(expected_xor.begin(), expected_xor.end()),
                       std::string(ds.begin(), ds.end()));
 }
 
 BOOST_AUTO_TEST_CASE(streams_empty_vector) {
     std::vector<char> in;
     CDataStream ds(in, 0, 0);
 
     // read 0 bytes used to cause a segfault on some older systems.
     BOOST_CHECK_NO_THROW(ds.read(nullptr, 0));
 
     // Same goes for writing 0 bytes from a vector ...
     const std::vector<char> vdata{'f', 'o', 'o', 'b', 'a', 'r'};
     BOOST_CHECK_NO_THROW(ds.insert(ds.begin(), vdata.begin(), vdata.begin()));
     BOOST_CHECK_NO_THROW(ds.insert(ds.begin(), vdata.begin(), vdata.end()));
 
     // ... or an array.
     const char adata[6] = {'f', 'o', 'o', 'b', 'a', 'r'};
     BOOST_CHECK_NO_THROW(ds.insert(ds.begin(), &adata[0], &adata[0]));
     BOOST_CHECK_NO_THROW(ds.insert(ds.begin(), &adata[0], &adata[6]));
 }
 
 BOOST_AUTO_TEST_CASE(streams_buffered_file) {
     FILE *file = fsbridge::fopen("streams_test_tmp", "w+b");
     // The value at each offset is the offset.
     for (uint8_t j = 0; j < 40; ++j) {
         fwrite(&j, 1, 1, file);
     }
     rewind(file);
 
     // The buffer size (second arg) must be greater than the rewind
     // amount (third arg).
     try {
         CBufferedFile bfbad(file, 25, 25, 222, 333);
         BOOST_CHECK(false);
     } catch (const std::exception &e) {
         BOOST_CHECK(
             strstr(e.what(), "Rewind limit must be less than buffer size") !=
             nullptr);
     }
 
     // The buffer is 25 bytes, allow rewinding 10 bytes.
     CBufferedFile bf(file, 25, 10, 222, 333);
     BOOST_CHECK(!bf.eof());
 
     // These two members have no functional effect.
     BOOST_CHECK_EQUAL(bf.GetType(), 222);
     BOOST_CHECK_EQUAL(bf.GetVersion(), 333);
 
     uint8_t i;
     bf >> i;
     BOOST_CHECK_EQUAL(i, 0);
     bf >> i;
     BOOST_CHECK_EQUAL(i, 1);
 
     // After reading bytes 0 and 1, we're positioned at 2.
     BOOST_CHECK_EQUAL(bf.GetPos(), 2U);
 
     // Rewind to offset 0, ok (within the 10 byte window).
     BOOST_CHECK(bf.SetPos(0));
     bf >> i;
     BOOST_CHECK_EQUAL(i, 0);
 
     // We can go forward to where we've been, but beyond may fail.
     BOOST_CHECK(bf.SetPos(2));
     bf >> i;
     BOOST_CHECK_EQUAL(i, 2);
 
     // If you know the maximum number of bytes that should be
     // read to deserialize the variable, you can limit the read
     // extent. The current file offset is 3, so the following
     // SetLimit() allows zero bytes to be read.
     BOOST_CHECK(bf.SetLimit(3));
     try {
         bf >> i;
         BOOST_CHECK(false);
     } catch (const std::exception &e) {
         BOOST_CHECK(strstr(e.what(), "Read attempted past buffer limit") !=
                     nullptr);
     }
     // The default argument removes the limit completely.
     BOOST_CHECK(bf.SetLimit());
     // The read position should still be at 3 (no change).
     BOOST_CHECK_EQUAL(bf.GetPos(), 3U);
 
     // Read from current offset, 3, forward until position 10.
     for (uint8_t j = 3; j < 10; ++j) {
         bf >> i;
         BOOST_CHECK_EQUAL(i, j);
     }
     BOOST_CHECK_EQUAL(bf.GetPos(), 10U);
 
     // We're guaranteed (just barely) to be able to rewind to zero.
     BOOST_CHECK(bf.SetPos(0));
     BOOST_CHECK_EQUAL(bf.GetPos(), 0U);
     bf >> i;
     BOOST_CHECK_EQUAL(i, 0);
 
     // We can set the position forward again up to the farthest
     // into the stream we've been, but no farther. (Attempting
     // to go farther may succeed, but it's not guaranteed.)
     BOOST_CHECK(bf.SetPos(10));
     bf >> i;
     BOOST_CHECK_EQUAL(i, 10);
     BOOST_CHECK_EQUAL(bf.GetPos(), 11U);
 
     // Now it's only guaranteed that we can rewind to offset 1
     // (current read position, 11, minus rewind amount, 10).
     BOOST_CHECK(bf.SetPos(1));
     BOOST_CHECK_EQUAL(bf.GetPos(), 1U);
     bf >> i;
     BOOST_CHECK_EQUAL(i, 1);
 
     // We can stream into large variables, even larger than
     // the buffer size.
     BOOST_CHECK(bf.SetPos(11));
     {
         uint8_t a[40 - 11];
         bf >> a;
         for (uint8_t j = 0; j < sizeof(a); ++j) {
             BOOST_CHECK_EQUAL(a[j], 11 + j);
         }
     }
     BOOST_CHECK_EQUAL(bf.GetPos(), 40U);
 
     // We've read the entire file, the next read should throw.
     try {
         bf >> i;
         BOOST_CHECK(false);
     } catch (const std::exception &e) {
         BOOST_CHECK(strstr(e.what(), "CBufferedFile::Fill: end of file") !=
                     nullptr);
     }
     // Attempting to read beyond the end sets the EOF indicator.
     BOOST_CHECK(bf.eof());
 
     // Still at offset 40, we can go back 10, to 30.
     BOOST_CHECK_EQUAL(bf.GetPos(), 40U);
     BOOST_CHECK(bf.SetPos(30));
     bf >> i;
     BOOST_CHECK_EQUAL(i, 30);
     BOOST_CHECK_EQUAL(bf.GetPos(), 31U);
 
     // We're too far to rewind to position zero.
     BOOST_CHECK(!bf.SetPos(0));
     // But we should now be positioned at least as far back as allowed
     // by the rewind window (relative to our farthest read position, 40).
     BOOST_CHECK(bf.GetPos() <= 30);
 
     // We can explicitly close the file, or the destructor will do it.
     bf.fclose();
 
     fs::remove("streams_test_tmp");
 }
 
 BOOST_AUTO_TEST_CASE(streams_buffered_file_rand) {
     // Make this test deterministic.
     SeedInsecureRand(SeedRand::ZEROS);
 
     for (int rep = 0; rep < 50; ++rep) {
         FILE *file = fsbridge::fopen("streams_test_tmp", "w+b");
         size_t fileSize = InsecureRandRange(256);
         for (uint8_t i = 0; i < fileSize; ++i) {
             fwrite(&i, 1, 1, file);
         }
         rewind(file);
 
         size_t bufSize = InsecureRandRange(300) + 1;
         size_t rewindSize = InsecureRandRange(bufSize);
         CBufferedFile bf(file, bufSize, rewindSize, 222, 333);
         size_t currentPos = 0;
         size_t maxPos = 0;
         for (int step = 0; step < 100; ++step) {
             if (currentPos >= fileSize) {
                 break;
             }
 
             // We haven't read to the end of the file yet.
             BOOST_CHECK(!bf.eof());
             BOOST_CHECK_EQUAL(bf.GetPos(), currentPos);
 
             // Pretend the file consists of a series of objects of varying
             // sizes; the boundaries of the objects can interact arbitrarily
             // with the CBufferFile's internal buffer. These first three
             // cases simulate objects of various sizes (1, 2, 5 bytes).
             switch (InsecureRandRange(5)) {
                 case 0: {
                     uint8_t a[1];
                     if (currentPos + 1 > fileSize) {
                         continue;
                     }
                     bf.SetLimit(currentPos + 1);
                     bf >> a;
                     for (uint8_t i = 0; i < 1; ++i) {
                         BOOST_CHECK_EQUAL(a[i], currentPos);
                         currentPos++;
                     }
                     break;
                 }
                 case 1: {
                     uint8_t a[2];
                     if (currentPos + 2 > fileSize) {
                         continue;
                     }
                     bf.SetLimit(currentPos + 2);
                     bf >> a;
                     for (uint8_t i = 0; i < 2; ++i) {
                         BOOST_CHECK_EQUAL(a[i], currentPos);
                         currentPos++;
                     }
                     break;
                 }
                 case 2: {
                     uint8_t a[5];
                     if (currentPos + 5 > fileSize) {
                         continue;
                     }
                     bf.SetLimit(currentPos + 5);
                     bf >> a;
                     for (uint8_t i = 0; i < 5; ++i) {
                         BOOST_CHECK_EQUAL(a[i], currentPos);
                         currentPos++;
                     }
                     break;
                 }
                 case 3: {
                     // Find a byte value (that is at or ahead of the current
                     // position).
                     size_t find = currentPos + InsecureRandRange(8);
                     if (find >= fileSize) {
                         find = fileSize - 1;
                     }
                     bf.FindByte(static_cast<char>(find));
                     // The value at each offset is the offset.
                     BOOST_CHECK_EQUAL(bf.GetPos(), find);
                     currentPos = find;
 
                     bf.SetLimit(currentPos + 1);
                     uint8_t i;
                     bf >> i;
                     BOOST_CHECK_EQUAL(i, currentPos);
                     currentPos++;
                     break;
                 }
                 case 4: {
                     size_t requestPos = InsecureRandRange(maxPos + 4);
                     bool okay = bf.SetPos(requestPos);
                     // The new position may differ from the requested position
                     // because we may not be able to rewind beyond the rewind
                     // window, and we may not be able to move forward beyond the
                     // farthest position we've reached so far.
                     currentPos = bf.GetPos();
                     BOOST_CHECK_EQUAL(okay, currentPos == requestPos);
                     // Check that we can position within the rewind window.
                     if (requestPos <= maxPos && maxPos > rewindSize &&
                         requestPos >= maxPos - rewindSize) {
                         // We requested a position within the rewind window.
                         BOOST_CHECK(okay);
                     }
                     break;
                 }
             }
             if (maxPos < currentPos) {
                 maxPos = currentPos;
             }
         }
     }
     fs::remove("streams_test_tmp");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
index f6be44c2b..585added4 100644
--- a/src/test/util_tests.cpp
+++ b/src/test/util_tests.cpp
@@ -1,2647 +1,2651 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <util/system.h>
 
 #include <chainparams.h>
 #include <clientversion.h>
+#include <fs.h>
 #include <hash.h> // For Hash()
 #include <key.h>  // For CKey
 #include <sync.h>
 #include <test/util/logging.h>
 #include <test/util/str.h>
 #include <uint256.h>
 #include <util/check.h>
 #include <util/getuniquepath.h>
 #include <util/message.h> // For MessageSign(), MessageVerify(), MESSAGE_MAGIC
 #include <util/moneystr.h>
 #include <util/spanparsing.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/time.h>
 #include <util/vector.h>
 
 #include <test/util/setup_common.h>
 
 #include <univalue.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <array>
 #include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <optional>
 #include <utility>
 #ifndef WIN32
 #include <csignal>
 #include <sys/types.h>
 #include <sys/wait.h>
 #endif
 #include <thread>
 #include <vector>
 
 using namespace std::literals;
 static const std::string STRING_WITH_EMBEDDED_NULL_CHAR{"1"s
                                                         "\0"
                                                         "1"s};
 
 /* defined in logging.cpp */
 namespace BCLog {
 std::string LogEscapeMessage(const std::string &str);
 }
 
 BOOST_FIXTURE_TEST_SUITE(util_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(util_datadir) {
     // Use local args variable instead of m_args to avoid making assumptions
     // about test setup
     ArgsManager args;
     args.ForceSetArg("-datadir", fs::PathToString(m_path_root));
 
     const fs::path dd_norm = args.GetDataDirBase();
 
     args.ForceSetArg("-datadir", fs::PathToString(dd_norm) + "/");
     args.ClearPathCache();
     BOOST_CHECK_EQUAL(dd_norm, args.GetDataDirBase());
 
     args.ForceSetArg("-datadir", fs::PathToString(dd_norm) + "/.");
     args.ClearPathCache();
     BOOST_CHECK_EQUAL(dd_norm, args.GetDataDirBase());
 
     args.ForceSetArg("-datadir", fs::PathToString(dd_norm) + "/./");
     args.ClearPathCache();
     BOOST_CHECK_EQUAL(dd_norm, args.GetDataDirBase());
 
+#ifndef WIN32
+    // Windows does not consider "datadir/.//" to be a valid directory path.
     args.ForceSetArg("-datadir", fs::PathToString(dd_norm) + "/.//");
     args.ClearPathCache();
     BOOST_CHECK_EQUAL(dd_norm, args.GetDataDirBase());
+#endif
 }
 
 BOOST_AUTO_TEST_CASE(util_check) {
     // Check that Assert can forward
     const std::unique_ptr<int> p_two = Assert(std::make_unique<int>(2));
     // Check that Assert works on lvalues and rvalues
     const int two = *Assert(p_two);
     Assert(two == 2);
     Assert(true);
     // Check that Assume can be used as unary expression
     const bool result{Assume(two == 2)};
     Assert(result);
 }
 
 BOOST_AUTO_TEST_CASE(util_criticalsection) {
     RecursiveMutex cs;
 
     do {
         LOCK(cs);
         break;
 
         BOOST_ERROR("break was swallowed!");
     } while (0);
 
     do {
         TRY_LOCK(cs, lockTest);
         if (lockTest) {
             // Needed to suppress "Test case [...] did not check any assertions"
             BOOST_CHECK(true);
             break;
         }
 
         BOOST_ERROR("break was swallowed!");
     } while (0);
 }
 
 static const uint8_t ParseHex_expected[65] = {
     0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67,
     0xf1, 0xa6, 0x71, 0x30, 0xb7, 0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0,
     0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde, 0xb6,
     0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04,
     0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b,
     0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d, 0x5f};
 BOOST_AUTO_TEST_CASE(util_ParseHex) {
     std::vector<uint8_t> result;
     std::vector<uint8_t> expected(
         ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
     // Basic test vector
     result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0"
                       "ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d"
                       "578a4c702b6bf11d5f");
     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
                                   expected.begin(), expected.end());
 
     // Spaces between bytes must be supported
     result = ParseHex("12 34 56 78");
     BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 &&
                 result[2] == 0x56 && result[3] == 0x78);
 
     // Leading space must be supported (used in BerkeleyEnvironment::Salvage)
     result = ParseHex(" 89 34 56 78");
     BOOST_CHECK(result.size() == 4 && result[0] == 0x89 && result[1] == 0x34 &&
                 result[2] == 0x56 && result[3] == 0x78);
 
     // Stop parsing at invalid value
     result = ParseHex("1234 invalid 1234");
     BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
 }
 
 BOOST_AUTO_TEST_CASE(util_HexStr) {
     BOOST_CHECK_EQUAL(HexStr(ParseHex_expected),
                       "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0"
                       "ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d"
                       "578a4c702b6bf11d5f");
 
     BOOST_CHECK_EQUAL(HexStr(Span<const uint8_t>(
                           ParseHex_expected + sizeof(ParseHex_expected),
                           ParseHex_expected + sizeof(ParseHex_expected))),
                       "");
 
     BOOST_CHECK_EQUAL(
         HexStr(Span<const uint8_t>(ParseHex_expected, ParseHex_expected)), "");
 
     std::vector<uint8_t> ParseHex_vec(ParseHex_expected, ParseHex_expected + 5);
 
     BOOST_CHECK_EQUAL(HexStr(ParseHex_vec), "04678afdb0");
 }
 
 BOOST_AUTO_TEST_CASE(util_Join) {
     // Normal version
     BOOST_CHECK_EQUAL(Join({}, ", "), "");
     BOOST_CHECK_EQUAL(Join({"foo"}, ", "), "foo");
     BOOST_CHECK_EQUAL(Join({"foo", "bar"}, ", "), "foo, bar");
 
     // Version with unary operator
     const auto op_upper = [](const std::string &s) { return ToUpper(s); };
     BOOST_CHECK_EQUAL(Join<std::string>({}, ", ", op_upper), "");
     BOOST_CHECK_EQUAL(Join<std::string>({"foo"}, ", ", op_upper), "FOO");
     BOOST_CHECK_EQUAL(Join<std::string>({"foo", "bar"}, ", ", op_upper),
                       "FOO, BAR");
 }
 
 BOOST_AUTO_TEST_CASE(util_FormatParseISO8601DateTime) {
     BOOST_CHECK_EQUAL(FormatISO8601DateTime(1317425777),
                       "2011-09-30T23:36:17Z");
     BOOST_CHECK_EQUAL(FormatISO8601DateTime(0), "1970-01-01T00:00:00Z");
 
     BOOST_CHECK_EQUAL(ParseISO8601DateTime("1970-01-01T00:00:00Z"), 0);
     BOOST_CHECK_EQUAL(ParseISO8601DateTime("1960-01-01T00:00:00Z"), 0);
     BOOST_CHECK_EQUAL(ParseISO8601DateTime("2011-09-30T23:36:17Z"), 1317425777);
 
     auto time = GetTimeSeconds();
     BOOST_CHECK_EQUAL(ParseISO8601DateTime(FormatISO8601DateTime(time)), time);
 }
 
 BOOST_AUTO_TEST_CASE(util_FormatISO8601Date) {
     BOOST_CHECK_EQUAL(FormatISO8601Date(1317425777), "2011-09-30");
 }
 
 struct TestArgsManager : public ArgsManager {
     TestArgsManager() { m_network_only_args.clear(); }
     void ReadConfigString(const std::string str_config) {
         std::istringstream streamConfig(str_config);
         {
             LOCK(cs_args);
             m_settings.ro_config.clear();
             m_config_sections.clear();
         }
         std::string error;
         BOOST_REQUIRE(ReadConfigStream(streamConfig, "", error));
     }
     void SetNetworkOnlyArg(const std::string arg) {
         LOCK(cs_args);
         m_network_only_args.insert(arg);
     }
     void
     SetupArgs(const std::vector<std::pair<std::string, unsigned int>> &args) {
         for (const auto &arg : args) {
             AddArg(arg.first, "", arg.second, OptionsCategory::OPTIONS);
         }
     }
     using ArgsManager::cs_args;
     using ArgsManager::GetSetting;
     using ArgsManager::GetSettingsList;
     using ArgsManager::m_network;
     using ArgsManager::m_settings;
     using ArgsManager::ReadConfigStream;
 };
 
 //! Test GetSetting and GetArg type coercion, negation, and default value
 //! handling.
 class CheckValueTest : public TestChain100Setup {
 public:
     struct Expect {
         util::SettingsValue setting;
         bool default_string = false;
         bool default_int = false;
         bool default_bool = false;
         const char *string_value = nullptr;
         std::optional<int64_t> int_value;
         std::optional<bool> bool_value;
         std::optional<std::vector<std::string>> list_value;
         const char *error = nullptr;
 
         explicit Expect(util::SettingsValue s) : setting(std::move(s)) {}
         Expect &DefaultString() {
             default_string = true;
             return *this;
         }
         Expect &DefaultInt() {
             default_int = true;
             return *this;
         }
         Expect &DefaultBool() {
             default_bool = true;
             return *this;
         }
         Expect &String(const char *s) {
             string_value = s;
             return *this;
         }
         Expect &Int(int64_t i) {
             int_value = i;
             return *this;
         }
         Expect &Bool(bool b) {
             bool_value = b;
             return *this;
         }
         Expect &List(std::vector<std::string> m) {
             list_value = std::move(m);
             return *this;
         }
         Expect &Error(const char *e) {
             error = e;
             return *this;
         }
     };
 
     void CheckValue(unsigned int flags, const char *arg, const Expect &expect) {
         TestArgsManager test;
         test.SetupArgs({{"-value", flags}});
         const char *argv[] = {"ignored", arg};
         std::string error;
         bool success = test.ParseParameters(arg ? 2 : 1, (char **)argv, error);
 
         BOOST_CHECK_EQUAL(test.GetSetting("-value").write(),
                           expect.setting.write());
         auto settings_list = test.GetSettingsList("-value");
         if (expect.setting.isNull() || expect.setting.isFalse()) {
             BOOST_CHECK_EQUAL(settings_list.size(), 0U);
         } else {
             BOOST_CHECK_EQUAL(settings_list.size(), 1U);
             BOOST_CHECK_EQUAL(settings_list[0].write(), expect.setting.write());
         }
 
         if (expect.error) {
             BOOST_CHECK(!success);
             BOOST_CHECK_NE(error.find(expect.error), std::string::npos);
         } else {
             BOOST_CHECK(success);
             BOOST_CHECK_EQUAL(error, "");
         }
 
         if (expect.default_string) {
             BOOST_CHECK_EQUAL(test.GetArg("-value", "zzzzz"), "zzzzz");
         } else if (expect.string_value) {
             BOOST_CHECK_EQUAL(test.GetArg("-value", "zzzzz"),
                               expect.string_value);
         } else {
             BOOST_CHECK(!success);
         }
 
         if (expect.default_int) {
             BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99999), 99999);
         } else if (expect.int_value) {
             BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99999),
                               *expect.int_value);
         } else {
             BOOST_CHECK(!success);
         }
 
         if (expect.default_bool) {
             BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), false);
             BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), true);
         } else if (expect.bool_value) {
             BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false),
                               *expect.bool_value);
             BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true),
                               *expect.bool_value);
         } else {
             BOOST_CHECK(!success);
         }
 
         if (expect.list_value) {
             auto l = test.GetArgs("-value");
             BOOST_CHECK_EQUAL_COLLECTIONS(l.begin(), l.end(),
                                           expect.list_value->begin(),
                                           expect.list_value->end());
         } else {
             BOOST_CHECK(!success);
         }
     }
 };
 
 BOOST_FIXTURE_TEST_CASE(util_CheckValue, CheckValueTest) {
     using M = ArgsManager;
 
     CheckValue(M::ALLOW_ANY, nullptr,
                Expect{{}}.DefaultString().DefaultInt().DefaultBool().List({}));
     CheckValue(M::ALLOW_ANY, "-novalue",
                Expect{false}.String("0").Int(0).Bool(false).List({}));
     CheckValue(M::ALLOW_ANY, "-novalue=",
                Expect{false}.String("0").Int(0).Bool(false).List({}));
     CheckValue(M::ALLOW_ANY, "-novalue=0",
                Expect{true}.String("1").Int(1).Bool(true).List({"1"}));
     CheckValue(M::ALLOW_ANY, "-novalue=1",
                Expect{false}.String("0").Int(0).Bool(false).List({}));
     CheckValue(M::ALLOW_ANY, "-novalue=2",
                Expect{false}.String("0").Int(0).Bool(false).List({}));
     CheckValue(M::ALLOW_ANY, "-novalue=abc",
                Expect{true}.String("1").Int(1).Bool(true).List({"1"}));
     CheckValue(M::ALLOW_ANY, "-value",
                Expect{""}.String("").Int(0).Bool(true).List({""}));
     CheckValue(M::ALLOW_ANY,
                "-value=", Expect{""}.String("").Int(0).Bool(true).List({""}));
     CheckValue(M::ALLOW_ANY, "-value=0",
                Expect{"0"}.String("0").Int(0).Bool(false).List({"0"}));
     CheckValue(M::ALLOW_ANY, "-value=1",
                Expect{"1"}.String("1").Int(1).Bool(true).List({"1"}));
     CheckValue(M::ALLOW_ANY, "-value=2",
                Expect{"2"}.String("2").Int(2).Bool(true).List({"2"}));
     CheckValue(M::ALLOW_ANY, "-value=abc",
                Expect{"abc"}.String("abc").Int(0).Bool(false).List({"abc"}));
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseParameters) {
     TestArgsManager testArgs;
     const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);
     const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);
     const auto ccc = std::make_pair("-ccc", ArgsManager::ALLOW_ANY);
     const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);
 
     const char *argv_test[] = {"-ignored",      "-a", "-b",  "-ccc=argument",
                                "-ccc=multiple", "f",  "-d=e"};
 
     std::string error;
     LOCK(testArgs.cs_args);
     testArgs.SetupArgs({a, b, ccc, d});
     BOOST_CHECK(testArgs.ParseParameters(0, (char **)argv_test, error));
     BOOST_CHECK(testArgs.m_settings.command_line_options.empty() &&
                 testArgs.m_settings.ro_config.empty());
 
     BOOST_CHECK(testArgs.ParseParameters(1, (char **)argv_test, error));
     BOOST_CHECK(testArgs.m_settings.command_line_options.empty() &&
                 testArgs.m_settings.ro_config.empty());
 
     BOOST_CHECK(testArgs.ParseParameters(7, (char **)argv_test, error));
     // expectation: -ignored is ignored (program name argument),
     // -a, -b and -ccc end up in map, -d ignored because it is after
     // a non-option argument (non-GNU option parsing)
     BOOST_CHECK(testArgs.m_settings.command_line_options.size() == 3 &&
                 testArgs.m_settings.ro_config.empty());
     BOOST_CHECK(testArgs.IsArgSet("-a") && testArgs.IsArgSet("-b") &&
                 testArgs.IsArgSet("-ccc") && !testArgs.IsArgSet("f") &&
                 !testArgs.IsArgSet("-d"));
     BOOST_CHECK(testArgs.m_settings.command_line_options.count("a") &&
                 testArgs.m_settings.command_line_options.count("b") &&
                 testArgs.m_settings.command_line_options.count("ccc") &&
                 !testArgs.m_settings.command_line_options.count("f") &&
                 !testArgs.m_settings.command_line_options.count("d"));
 
     BOOST_CHECK(testArgs.m_settings.command_line_options["a"].size() == 1);
     BOOST_CHECK(
         testArgs.m_settings.command_line_options["a"].front().get_str() == "");
     BOOST_CHECK(testArgs.m_settings.command_line_options["ccc"].size() == 2);
     BOOST_CHECK(
         testArgs.m_settings.command_line_options["ccc"].front().get_str() ==
         "argument");
     BOOST_CHECK(
         testArgs.m_settings.command_line_options["ccc"].back().get_str() ==
         "multiple");
     BOOST_CHECK(testArgs.GetArgs("-ccc").size() == 2);
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseKeyValue) {
     {
         std::string key = "badarg";
         std::string value;
         BOOST_CHECK(!ParseKeyValue(key, value));
     }
     {
         std::string key = "badarg=v";
         std::string value;
         BOOST_CHECK(!ParseKeyValue(key, value));
     }
     {
         std::string key = "-a";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-a");
         BOOST_CHECK_EQUAL(value, "");
     }
     {
         std::string key = "-a=1";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-a");
         BOOST_CHECK_EQUAL(value, "1");
     }
     {
         std::string key = "--b";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-b");
         BOOST_CHECK_EQUAL(value, "");
     }
     {
         std::string key = "--b=abc";
         std::string value;
         BOOST_CHECK(ParseKeyValue(key, value));
         BOOST_CHECK_EQUAL(key, "-b");
         BOOST_CHECK_EQUAL(value, "abc");
     }
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseInvalidParameters) {
     TestArgsManager test;
     test.SetupArgs({{"-registered", ArgsManager::ALLOW_ANY}});
 
     const char *argv[] = {"ignored", "-registered"};
     std::string error;
     BOOST_CHECK(test.ParseParameters(2, (char **)argv, error));
     BOOST_CHECK_EQUAL(error, "");
 
     argv[1] = "-unregistered";
     BOOST_CHECK(!test.ParseParameters(2, (char **)argv, error));
     BOOST_CHECK_EQUAL(error, "Invalid parameter -unregistered");
 
     // Make sure registered parameters prefixed with a chain name trigger
     // errors. (Previously, they were accepted and ignored.)
     argv[1] = "-test.registered";
     BOOST_CHECK(!test.ParseParameters(2, (char **)argv, error));
     BOOST_CHECK_EQUAL(error, "Invalid parameter -test.registered");
 }
 
 static void TestParse(const std::string &str, bool expected_bool,
                       int64_t expected_int) {
     TestArgsManager test;
     test.SetupArgs({{"-value", ArgsManager::ALLOW_ANY}});
     std::string arg = "-value=" + str;
     const char *argv[] = {"ignored", arg.c_str()};
     std::string error;
     BOOST_CHECK(test.ParseParameters(2, (char **)argv, error));
     BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), expected_bool);
     BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), expected_bool);
     BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99998), expected_int);
     BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99999), expected_int);
 }
 
 // Test bool and int parsing.
 BOOST_AUTO_TEST_CASE(util_ArgParsing) {
     // Some of these cases could be ambiguous or surprising to users, and might
     // be worth triggering errors or warnings in the future. But for now basic
     // test coverage is useful to avoid breaking backwards compatibility
     // unintentionally.
     TestParse("", true, 0);
     TestParse(" ", false, 0);
     TestParse("0", false, 0);
     TestParse("0 ", false, 0);
     TestParse(" 0", false, 0);
     TestParse("+0", false, 0);
     TestParse("-0", false, 0);
     TestParse("5", true, 5);
     TestParse("5 ", true, 5);
     TestParse(" 5", true, 5);
     TestParse("+5", true, 5);
     TestParse("-5", true, -5);
     TestParse("0 5", false, 0);
     TestParse("5 0", true, 5);
     TestParse("050", true, 50);
     TestParse("0.", false, 0);
     TestParse("5.", true, 5);
     TestParse("0.0", false, 0);
     TestParse("0.5", false, 0);
     TestParse("5.0", true, 5);
     TestParse("5.5", true, 5);
     TestParse("x", false, 0);
     TestParse("x0", false, 0);
     TestParse("x5", false, 0);
     TestParse("0x", false, 0);
     TestParse("5x", true, 5);
     TestParse("0x5", false, 0);
     TestParse("false", false, 0);
     TestParse("true", false, 0);
     TestParse("yes", false, 0);
     TestParse("no", false, 0);
 }
 
 BOOST_AUTO_TEST_CASE(util_GetBoolArg) {
     TestArgsManager testArgs;
     const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);
     const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);
     const auto c = std::make_pair("-c", ArgsManager::ALLOW_ANY);
     const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);
     const auto e = std::make_pair("-e", ArgsManager::ALLOW_ANY);
     const auto f = std::make_pair("-f", ArgsManager::ALLOW_ANY);
 
     const char *argv_test[] = {"ignored", "-a",       "-nob",   "-c=0",
                                "-d=1",    "-e=false", "-f=true"};
     std::string error;
     LOCK(testArgs.cs_args);
     testArgs.SetupArgs({a, b, c, d, e, f});
     BOOST_CHECK(testArgs.ParseParameters(7, (char **)argv_test, error));
 
     // Each letter should be set.
     for (const char opt : "abcdef") {
         BOOST_CHECK(testArgs.IsArgSet({'-', opt}) || !opt);
     }
 
     // Nothing else should be in the map
     BOOST_CHECK(testArgs.m_settings.command_line_options.size() == 6 &&
                 testArgs.m_settings.ro_config.empty());
 
     // The -no prefix should get stripped on the way in.
     BOOST_CHECK(!testArgs.IsArgSet("-nob"));
 
     // The -b option is flagged as negated, and nothing else is
     BOOST_CHECK(testArgs.IsArgNegated("-b"));
     BOOST_CHECK(!testArgs.IsArgNegated("-a"));
 
     // Check expected values.
     BOOST_CHECK(testArgs.GetBoolArg("-a", false) == true);
     BOOST_CHECK(testArgs.GetBoolArg("-b", true) == false);
     BOOST_CHECK(testArgs.GetBoolArg("-c", true) == false);
     BOOST_CHECK(testArgs.GetBoolArg("-d", false) == true);
     BOOST_CHECK(testArgs.GetBoolArg("-e", true) == false);
     BOOST_CHECK(testArgs.GetBoolArg("-f", true) == false);
 }
 
 BOOST_AUTO_TEST_CASE(util_GetBoolArgEdgeCases) {
     // Test some awful edge cases that hopefully no user will ever exercise.
     TestArgsManager testArgs;
 
     // Params test
     const auto foo = std::make_pair("-foo", ArgsManager::ALLOW_ANY);
     const auto bar = std::make_pair("-bar", ArgsManager::ALLOW_ANY);
     const char *argv_test[] = {"ignored", "-nofoo", "-foo", "-nobar=0"};
     testArgs.SetupArgs({foo, bar});
     std::string error;
     BOOST_CHECK(testArgs.ParseParameters(4, (char **)argv_test, error));
 
     // This was passed twice, second one overrides the negative setting.
     BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
     BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "");
 
     // A double negative is a positive, and not marked as negated.
     BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
     BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");
 
     // Config test
     const char *conf_test = "nofoo=1\nfoo=1\nnobar=0\n";
     BOOST_CHECK(testArgs.ParseParameters(1, (char **)argv_test, error));
     testArgs.ReadConfigString(conf_test);
 
     // This was passed twice, second one overrides the negative setting,
     // and the value.
     BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
     BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "1");
 
     // A double negative is a positive, and does not count as negated.
     BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
     BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");
 
     // Combined test
     const char *combo_test_args[] = {"ignored", "-nofoo", "-bar"};
     const char *combo_test_conf = "foo=1\nnobar=1\n";
     BOOST_CHECK(testArgs.ParseParameters(3, (char **)combo_test_args, error));
     testArgs.ReadConfigString(combo_test_conf);
 
     // Command line overrides, but doesn't erase old setting
     BOOST_CHECK(testArgs.IsArgNegated("-foo"));
     BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "0");
     BOOST_CHECK(testArgs.GetArgs("-foo").size() == 0);
 
     // Command line overrides, but doesn't erase old setting
     BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
     BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "");
     BOOST_CHECK(testArgs.GetArgs("-bar").size() == 1 &&
                 testArgs.GetArgs("-bar").front() == "");
 }
 
 BOOST_AUTO_TEST_CASE(util_ReadConfigStream) {
     const char *str_config = "a=\n"
                              "b=1\n"
                              "ccc=argument\n"
                              "ccc=multiple\n"
                              "d=e\n"
                              "nofff=1\n"
                              "noggg=0\n"
                              "h=1\n"
                              "noh=1\n"
                              "noi=1\n"
                              "i=1\n"
                              "sec1.ccc=extend1\n"
                              "\n"
                              "[sec1]\n"
                              "ccc=extend2\n"
                              "d=eee\n"
                              "h=1\n"
                              "[sec2]\n"
                              "ccc=extend3\n"
                              "iii=2\n";
 
     TestArgsManager test_args;
     LOCK(test_args.cs_args);
     const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);
     const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);
     const auto ccc = std::make_pair("-ccc", ArgsManager::ALLOW_ANY);
     const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);
     const auto e = std::make_pair("-e", ArgsManager::ALLOW_ANY);
     const auto fff = std::make_pair("-fff", ArgsManager::ALLOW_ANY);
     const auto ggg = std::make_pair("-ggg", ArgsManager::ALLOW_ANY);
     const auto h = std::make_pair("-h", ArgsManager::ALLOW_ANY);
     const auto i = std::make_pair("-i", ArgsManager::ALLOW_ANY);
     const auto iii = std::make_pair("-iii", ArgsManager::ALLOW_ANY);
     test_args.SetupArgs({a, b, ccc, d, e, fff, ggg, h, i, iii});
 
     test_args.ReadConfigString(str_config);
     // expectation: a, b, ccc, d, fff, ggg, h, i end up in map
     // so do sec1.ccc, sec1.d, sec1.h, sec2.ccc, sec2.iii
 
     BOOST_CHECK(test_args.m_settings.command_line_options.empty());
     BOOST_CHECK(test_args.m_settings.ro_config.size() == 3);
     BOOST_CHECK(test_args.m_settings.ro_config[""].size() == 8);
     BOOST_CHECK(test_args.m_settings.ro_config["sec1"].size() == 3);
     BOOST_CHECK(test_args.m_settings.ro_config["sec2"].size() == 2);
 
     BOOST_CHECK(test_args.m_settings.ro_config[""].count("a") &&
                 test_args.m_settings.ro_config[""].count("b") &&
                 test_args.m_settings.ro_config[""].count("ccc") &&
                 test_args.m_settings.ro_config[""].count("d") &&
                 test_args.m_settings.ro_config[""].count("fff") &&
                 test_args.m_settings.ro_config[""].count("ggg") &&
                 test_args.m_settings.ro_config[""].count("h") &&
                 test_args.m_settings.ro_config[""].count("i"));
     BOOST_CHECK(test_args.m_settings.ro_config["sec1"].count("ccc") &&
                 test_args.m_settings.ro_config["sec1"].count("h") &&
                 test_args.m_settings.ro_config["sec2"].count("ccc") &&
                 test_args.m_settings.ro_config["sec2"].count("iii"));
 
     BOOST_CHECK(test_args.IsArgSet("-a") && test_args.IsArgSet("-b") &&
                 test_args.IsArgSet("-ccc") && test_args.IsArgSet("-d") &&
                 test_args.IsArgSet("-fff") && test_args.IsArgSet("-ggg") &&
                 test_args.IsArgSet("-h") && test_args.IsArgSet("-i") &&
                 !test_args.IsArgSet("-zzz") && !test_args.IsArgSet("-iii"));
 
     BOOST_CHECK(test_args.GetArg("-a", "xxx") == "" &&
                 test_args.GetArg("-b", "xxx") == "1" &&
                 test_args.GetArg("-ccc", "xxx") == "argument" &&
                 test_args.GetArg("-d", "xxx") == "e" &&
                 test_args.GetArg("-fff", "xxx") == "0" &&
                 test_args.GetArg("-ggg", "xxx") == "1" &&
                 test_args.GetArg("-h", "xxx") == "0" &&
                 test_args.GetArg("-i", "xxx") == "1" &&
                 test_args.GetArg("-zzz", "xxx") == "xxx" &&
                 test_args.GetArg("-iii", "xxx") == "xxx");
 
     for (const bool def : {false, true}) {
         BOOST_CHECK(test_args.GetBoolArg("-a", def) &&
                     test_args.GetBoolArg("-b", def) &&
                     !test_args.GetBoolArg("-ccc", def) &&
                     !test_args.GetBoolArg("-d", def) &&
                     !test_args.GetBoolArg("-fff", def) &&
                     test_args.GetBoolArg("-ggg", def) &&
                     !test_args.GetBoolArg("-h", def) &&
                     test_args.GetBoolArg("-i", def) &&
                     test_args.GetBoolArg("-zzz", def) == def &&
                     test_args.GetBoolArg("-iii", def) == def);
     }
 
     BOOST_CHECK(test_args.GetArgs("-a").size() == 1 &&
                 test_args.GetArgs("-a").front() == "");
     BOOST_CHECK(test_args.GetArgs("-b").size() == 1 &&
                 test_args.GetArgs("-b").front() == "1");
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2 &&
                 test_args.GetArgs("-ccc").front() == "argument" &&
                 test_args.GetArgs("-ccc").back() == "multiple");
     BOOST_CHECK(test_args.GetArgs("-fff").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-nofff").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-ggg").size() == 1 &&
                 test_args.GetArgs("-ggg").front() == "1");
     BOOST_CHECK(test_args.GetArgs("-noggg").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-h").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-noh").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-i").size() == 1 &&
                 test_args.GetArgs("-i").front() == "1");
     BOOST_CHECK(test_args.GetArgs("-noi").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-zzz").size() == 0);
 
     BOOST_CHECK(!test_args.IsArgNegated("-a"));
     BOOST_CHECK(!test_args.IsArgNegated("-b"));
     BOOST_CHECK(!test_args.IsArgNegated("-ccc"));
     BOOST_CHECK(!test_args.IsArgNegated("-d"));
     BOOST_CHECK(test_args.IsArgNegated("-fff"));
     BOOST_CHECK(!test_args.IsArgNegated("-ggg"));
     // last setting takes precedence
     BOOST_CHECK(test_args.IsArgNegated("-h"));
     // last setting takes precedence
     BOOST_CHECK(!test_args.IsArgNegated("-i"));
     BOOST_CHECK(!test_args.IsArgNegated("-zzz"));
 
     // Test sections work
     test_args.SelectConfigNetwork("sec1");
 
     // same as original
     BOOST_CHECK(test_args.GetArg("-a", "xxx") == "" &&
                 test_args.GetArg("-b", "xxx") == "1" &&
                 test_args.GetArg("-fff", "xxx") == "0" &&
                 test_args.GetArg("-ggg", "xxx") == "1" &&
                 test_args.GetArg("-zzz", "xxx") == "xxx" &&
                 test_args.GetArg("-iii", "xxx") == "xxx");
     // d is overridden
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");
     // section-specific setting
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");
     // section takes priority for multiple values
     BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend1");
     // check multiple values works
     const std::vector<std::string> sec1_ccc_expected = {"extend1", "extend2",
                                                         "argument", "multiple"};
     const auto &sec1_ccc_res = test_args.GetArgs("-ccc");
     BOOST_CHECK_EQUAL_COLLECTIONS(sec1_ccc_res.begin(), sec1_ccc_res.end(),
                                   sec1_ccc_expected.begin(),
                                   sec1_ccc_expected.end());
 
     test_args.SelectConfigNetwork("sec2");
 
     // same as original
     BOOST_CHECK(test_args.GetArg("-a", "xxx") == "" &&
                 test_args.GetArg("-b", "xxx") == "1" &&
                 test_args.GetArg("-d", "xxx") == "e" &&
                 test_args.GetArg("-fff", "xxx") == "0" &&
                 test_args.GetArg("-ggg", "xxx") == "1" &&
                 test_args.GetArg("-zzz", "xxx") == "xxx" &&
                 test_args.GetArg("-h", "xxx") == "0");
     // section-specific setting
     BOOST_CHECK(test_args.GetArg("-iii", "xxx") == "2");
     // section takes priority for multiple values
     BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend3");
     // check multiple values works
     const std::vector<std::string> sec2_ccc_expected = {"extend3", "argument",
                                                         "multiple"};
     const auto &sec2_ccc_res = test_args.GetArgs("-ccc");
     BOOST_CHECK_EQUAL_COLLECTIONS(sec2_ccc_res.begin(), sec2_ccc_res.end(),
                                   sec2_ccc_expected.begin(),
                                   sec2_ccc_expected.end());
 
     // Test section only options
 
     test_args.SetNetworkOnlyArg("-d");
     test_args.SetNetworkOnlyArg("-ccc");
     test_args.SetNetworkOnlyArg("-h");
 
     test_args.SelectConfigNetwork(CBaseChainParams::MAIN);
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "e");
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
 
     test_args.SelectConfigNetwork("sec1");
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");
     BOOST_CHECK(test_args.GetArgs("-d").size() == 1);
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");
 
     test_args.SelectConfigNetwork("sec2");
     BOOST_CHECK(test_args.GetArg("-d", "xxx") == "xxx");
     BOOST_CHECK(test_args.GetArgs("-d").size() == 0);
     BOOST_CHECK(test_args.GetArgs("-ccc").size() == 1);
     BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
 }
 
 BOOST_AUTO_TEST_CASE(util_GetArg) {
     TestArgsManager testArgs;
     LOCK(testArgs.cs_args);
     testArgs.m_settings.command_line_options.clear();
     testArgs.m_settings.command_line_options["strtest1"] = {"string..."};
     // strtest2 undefined on purpose
     testArgs.m_settings.command_line_options["inttest1"] = {"12345"};
     testArgs.m_settings.command_line_options["inttest2"] = {
         "81985529216486895"};
     // inttest3 undefined on purpose
     testArgs.m_settings.command_line_options["booltest1"] = {""};
     // booltest2 undefined on purpose
     testArgs.m_settings.command_line_options["booltest3"] = {"0"};
     testArgs.m_settings.command_line_options["booltest4"] = {"1"};
 
     // priorities
     testArgs.m_settings.command_line_options["pritest1"] = {"a", "b"};
     testArgs.m_settings.ro_config[""]["pritest2"] = {"a", "b"};
     testArgs.m_settings.command_line_options["pritest3"] = {"a"};
     testArgs.m_settings.ro_config[""]["pritest3"] = {"b"};
     testArgs.m_settings.command_line_options["pritest4"] = {"a", "b"};
     testArgs.m_settings.ro_config[""]["pritest4"] = {"c", "d"};
 
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.GetIntArg("inttest1", -1), 12345);
     BOOST_CHECK_EQUAL(testArgs.GetIntArg("inttest2", -1), 81985529216486895LL);
     BOOST_CHECK_EQUAL(testArgs.GetIntArg("inttest3", -1), -1);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest2", false), false);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest3", false), false);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest4", false), true);
 
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest1", "default"), "b");
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest2", "default"), "a");
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest3", "default"), "a");
     BOOST_CHECK_EQUAL(testArgs.GetArg("pritest4", "default"), "b");
 }
 
 BOOST_AUTO_TEST_CASE(util_ClearForcedArg) {
     TestArgsManager testArgs;
     LOCK(testArgs.cs_args);
 
     // Clear command line arg
     testArgs.m_settings.command_line_options["cmdarg"] = {"cmdval"};
     BOOST_CHECK_EQUAL(testArgs.GetArg("cmdarg", "default"), "cmdval");
     testArgs.ClearForcedArg("cmdarg");
     BOOST_CHECK_EQUAL(testArgs.GetArg("cmdarg", "default"), "cmdval");
 
     // Clear config arg
     testArgs.m_settings.ro_config[""]["configarg"] = {"configval"};
     BOOST_CHECK_EQUAL(testArgs.GetArg("configarg", "default"), "configval");
     testArgs.ClearForcedArg("configarg");
     BOOST_CHECK_EQUAL(testArgs.GetArg("configarg", "default"), "configval");
 
     // Clear forced arg
     testArgs.m_settings.forced_settings["forcedarg"] = {"forcedval"};
     BOOST_CHECK_EQUAL(testArgs.GetArg("forcedarg", "default"), "forcedval");
     testArgs.ClearForcedArg("forcedarg");
     BOOST_CHECK_EQUAL(testArgs.GetArg("forcedarg", "default"), "default");
 }
 
 BOOST_AUTO_TEST_CASE(util_SetArg) {
     TestArgsManager testArgs;
 
     // SoftSetArg
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.SoftSetArg("strtest1", "string..."), true);
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest1").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest1").front(), "string...");
     BOOST_CHECK_EQUAL(testArgs.SoftSetArg("strtest1", "...gnirts"), false);
     testArgs.ClearForcedArg("strtest1");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.SoftSetArg("strtest1", "...gnirts"), true);
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "...gnirts");
 
     // SoftSetBoolArg
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), false);
     BOOST_CHECK_EQUAL(testArgs.SoftSetBoolArg("booltest1", true), true);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
     BOOST_CHECK_EQUAL(testArgs.SoftSetBoolArg("booltest1", false), false);
     testArgs.ClearForcedArg("booltest1");
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", true), true);
     BOOST_CHECK_EQUAL(testArgs.SoftSetBoolArg("booltest1", false), true);
     BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", true), false);
 
     // ForceSetArg
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
     testArgs.ForceSetArg("strtest2", "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "string...");
     testArgs.ForceSetArg("strtest2", "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "...gnirts");
 
     // ForceSetMultiArg
     testArgs.ForceSetMultiArg("strtest2", {"string...", "...gnirts"});
     BOOST_CHECK_THROW(testArgs.GetArg("strtest2", "default"),
                       std::runtime_error);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 2);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "string...");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").back(), "...gnirts");
     testArgs.ClearForcedArg("strtest2");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 0);
 
     // If there are multi args, ForceSetArg should erase them
     testArgs.ForceSetMultiArg("strtest2", {"string..."});
     BOOST_CHECK_THROW(testArgs.GetArg("strtest2", "default"),
                       std::runtime_error);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "string...");
     testArgs.ForceSetArg("strtest2", "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "...gnirts");
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").size(), 1);
     BOOST_CHECK_EQUAL(testArgs.GetArgs("strtest2").front(), "...gnirts");
 }
 
 BOOST_AUTO_TEST_CASE(util_GetChainName) {
     TestArgsManager test_args;
     const auto testnet = std::make_pair("-testnet", ArgsManager::ALLOW_ANY);
     const auto regtest = std::make_pair("-regtest", ArgsManager::ALLOW_ANY);
     test_args.SetupArgs({testnet, regtest});
 
     const char *argv_testnet[] = {"cmd", "-testnet"};
     const char *argv_regtest[] = {"cmd", "-regtest"};
     const char *argv_test_no_reg[] = {"cmd", "-testnet", "-noregtest"};
     const char *argv_both[] = {"cmd", "-testnet", "-regtest"};
 
     // equivalent to "-testnet"
     // regtest in testnet section is ignored
     const char *testnetconf = "testnet=1\nregtest=0\n[test]\nregtest=1";
     std::string error;
 
     BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "main");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "regtest");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_test_no_reg, error));
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     // check setting the network to test (and thus making
     // [test] regtest=1 potentially relevant) doesn't break things
     test_args.SelectConfigNetwork("test");
 
     BOOST_CHECK(test_args.ParseParameters(0, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_testnet, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_regtest, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 
     BOOST_CHECK(test_args.ParseParameters(2, (char **)argv_test_no_reg, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_EQUAL(test_args.GetChainName(), "test");
 
     BOOST_CHECK(test_args.ParseParameters(3, (char **)argv_both, error));
     test_args.ReadConfigString(testnetconf);
     BOOST_CHECK_THROW(test_args.GetChainName(), std::runtime_error);
 }
 
 // Test different ways settings can be merged, and verify results. This test can
 // be used to confirm that updates to settings code don't change behavior
 // unintentionally.
 //
 // The test covers:
 //
 // - Combining different setting actions. Possible actions are: configuring a
 //   setting, negating a setting (adding "-no" prefix), and configuring/negating
 //   settings in a network section (adding "main." or "test." prefixes).
 //
 // - Combining settings from command line arguments and a config file.
 //
 // - Combining SoftSet and ForceSet calls.
 //
 // - Testing "main" and "test" network values to make sure settings from network
 //   sections are applied and to check for mainnet-specific behaviors like
 //   inheriting settings from the default section.
 //
 // - Testing network-specific settings like "-wallet", that may be ignored
 //   outside a network section, and non-network specific settings like "-server"
 //   that aren't sensitive to the network.
 //
 struct ArgsMergeTestingSetup : public BasicTestingSetup {
     //! Max number of actions to sequence together. Can decrease this when
     //! debugging to make test results easier to understand.
     static constexpr int MAX_ACTIONS = 3;
 
     enum Action { NONE, SET, NEGATE, SECTION_SET, SECTION_NEGATE };
     using ActionList = Action[MAX_ACTIONS];
 
     //! Enumerate all possible test configurations.
     template <typename Fn> void ForEachMergeSetup(Fn &&fn) {
         ActionList arg_actions = {};
         // command_line_options do not have sections. Only iterate over SET and
         // NEGATE
         ForEachNoDup(arg_actions, SET, NEGATE, [&] {
             ActionList conf_actions = {};
             ForEachNoDup(conf_actions, SET, SECTION_NEGATE, [&] {
                 for (bool soft_set : {false, true}) {
                     for (bool force_set : {false, true}) {
                         for (const std::string &section :
                              {CBaseChainParams::MAIN,
                               CBaseChainParams::TESTNET}) {
                             for (const std::string &network :
                                  {CBaseChainParams::MAIN,
                                   CBaseChainParams::TESTNET}) {
                                 for (bool net_specific : {false, true}) {
                                     fn(arg_actions, conf_actions, soft_set,
                                        force_set, section, network,
                                        net_specific);
                                 }
                             }
                         }
                     }
                 }
             });
         });
     }
 
     //! Translate actions into a list of <key>=<value> setting strings.
     std::vector<std::string> GetValues(const ActionList &actions,
                                        const std::string &section,
                                        const std::string &name,
                                        const std::string &value_prefix) {
         std::vector<std::string> values;
         int suffix = 0;
         for (Action action : actions) {
             if (action == NONE) {
                 break;
             }
             std::string prefix;
             if (action == SECTION_SET || action == SECTION_NEGATE) {
                 prefix = section + ".";
             }
             if (action == SET || action == SECTION_SET) {
                 for (int i = 0; i < 2; ++i) {
                     values.push_back(prefix + name + "=" + value_prefix +
                                      ToString(++suffix));
                 }
             }
             if (action == NEGATE || action == SECTION_NEGATE) {
                 values.push_back(prefix + "no" + name + "=1");
             }
         }
         return values;
     }
 };
 
 // Regression test covering different ways config settings can be merged. The
 // test parses and merges settings, representing the results as strings that get
 // compared against an expected hash. To debug, the result strings can be dumped
 // to a file (see comments below).
 BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup) {
     CHash256 out_sha;
     FILE *out_file = nullptr;
     if (const char *out_path = getenv("ARGS_MERGE_TEST_OUT")) {
         out_file = fsbridge::fopen(out_path, "w");
         if (!out_file) {
             throw std::system_error(errno, std::generic_category(),
                                     "fopen failed");
         }
     }
 
     ForEachMergeSetup([&](const ActionList &arg_actions,
                           const ActionList &conf_actions, bool soft_set,
                           bool force_set, const std::string &section,
                           const std::string &network, bool net_specific) {
         TestArgsManager parser;
         LOCK(parser.cs_args);
 
         std::string desc = "net=";
         desc += network;
         parser.m_network = network;
 
         const std::string &name = net_specific ? "wallet" : "server";
         const std::string key = "-" + name;
         parser.AddArg(key, name, ArgsManager::ALLOW_ANY,
                       OptionsCategory::OPTIONS);
         if (net_specific) {
             parser.SetNetworkOnlyArg(key);
         }
 
         auto args = GetValues(arg_actions, section, name, "a");
         std::vector<const char *> argv = {"ignored"};
         for (auto &arg : args) {
             arg.insert(0, "-");
             desc += " ";
             desc += arg;
             argv.push_back(arg.c_str());
         }
         std::string error;
         BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error));
         BOOST_CHECK_EQUAL(error, "");
 
         std::string conf;
         for (auto &conf_val : GetValues(conf_actions, section, name, "c")) {
             desc += " ";
             desc += conf_val;
             conf += conf_val;
             conf += "\n";
         }
         std::istringstream conf_stream(conf);
         BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error));
         BOOST_CHECK_EQUAL(error, "");
 
         if (soft_set) {
             desc += " soft";
             parser.SoftSetArg(key, "soft1");
             parser.SoftSetArg(key, "soft2");
         }
 
         if (force_set) {
             desc += " force";
             parser.ForceSetArg(key, "force1");
             parser.ForceSetArg(key, "force2");
         }
 
         desc += " || ";
 
         if (!parser.IsArgSet(key)) {
             desc += "unset";
             BOOST_CHECK(!parser.IsArgNegated(key));
             BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "default");
             BOOST_CHECK(parser.GetArgs(key).empty());
         } else if (parser.IsArgNegated(key)) {
             desc += "negated";
             BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "0");
             BOOST_CHECK(parser.GetArgs(key).empty());
         } else {
             desc += parser.GetArg(key, "default");
             desc += " |";
             for (const auto &arg : parser.GetArgs(key)) {
                 desc += " ";
                 desc += arg;
             }
         }
 
         std::set<std::string> ignored = parser.GetUnsuitableSectionOnlyArgs();
         if (!ignored.empty()) {
             desc += " | ignored";
             for (const auto &arg : ignored) {
                 desc += " ";
                 desc += arg;
             }
         }
 
         desc += "\n";
 
         out_sha.Write(MakeUCharSpan(desc));
         if (out_file) {
             BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) ==
                           desc.size());
         }
     });
 
     if (out_file) {
         if (fclose(out_file)) {
             throw std::system_error(errno, std::generic_category(),
                                     "fclose failed");
         }
         out_file = nullptr;
     }
 
     uint8_t out_sha_bytes[CSHA256::OUTPUT_SIZE];
     out_sha.Finalize(out_sha_bytes);
     std::string out_sha_hex = HexStr(out_sha_bytes);
 
     // If check below fails, should manually dump the results with:
     //
     //   ARGS_MERGE_TEST_OUT=results.txt ./test_bitcoin
     //   --run_test=util_tests/util_ArgsMerge
     //
     // And verify diff against previous results to make sure the changes are
     // expected.
     //
     // Results file is formatted like:
     //
     //   <input> || <IsArgSet/IsArgNegated/GetArg output> | <GetArgs output> |
     //   <GetUnsuitable output>
     BOOST_CHECK_EQUAL(
         out_sha_hex,
         "8fd4877bb8bf337badca950ede6c917441901962f160e52514e06a60dea46cde");
 }
 
 // Similar test as above, but for ArgsManager::GetChainName function.
 struct ChainMergeTestingSetup : public BasicTestingSetup {
     static constexpr int MAX_ACTIONS = 2;
 
     enum Action {
         NONE,
         ENABLE_TEST,
         DISABLE_TEST,
         NEGATE_TEST,
         ENABLE_REG,
         DISABLE_REG,
         NEGATE_REG
     };
     using ActionList = Action[MAX_ACTIONS];
 
     //! Enumerate all possible test configurations.
     template <typename Fn> void ForEachMergeSetup(Fn &&fn) {
         ActionList arg_actions = {};
         ForEachNoDup(arg_actions, ENABLE_TEST, NEGATE_REG, [&] {
             ActionList conf_actions = {};
             ForEachNoDup(conf_actions, ENABLE_TEST, NEGATE_REG,
                          [&] { fn(arg_actions, conf_actions); });
         });
     }
 };
 
 BOOST_FIXTURE_TEST_CASE(util_ChainMerge, ChainMergeTestingSetup) {
     CHash256 out_sha;
     FILE *out_file = nullptr;
     if (const char *out_path = getenv("CHAIN_MERGE_TEST_OUT")) {
         out_file = fsbridge::fopen(out_path, "w");
         if (!out_file) {
             throw std::system_error(errno, std::generic_category(),
                                     "fopen failed");
         }
     }
 
     ForEachMergeSetup([&](const ActionList &arg_actions,
                           const ActionList &conf_actions) {
         TestArgsManager parser;
         LOCK(parser.cs_args);
         parser.AddArg("-regtest", "regtest", ArgsManager::ALLOW_ANY,
                       OptionsCategory::OPTIONS);
         parser.AddArg("-testnet", "testnet", ArgsManager::ALLOW_ANY,
                       OptionsCategory::OPTIONS);
 
         auto arg = [](Action action) -> const char * {
             switch (action) {
                 case ENABLE_TEST:
                     return "-testnet=1";
                 case DISABLE_TEST:
                     return "-testnet=0";
                 case NEGATE_TEST:
                     return "-notestnet=1";
                 case ENABLE_REG:
                     return "-regtest=1";
                 case DISABLE_REG:
                     return "-regtest=0";
                 case NEGATE_REG:
                     return "-noregtest=1";
                 default:
                     return nullptr;
             }
         };
 
         std::string desc;
         std::vector<const char *> argv = {"ignored"};
         for (Action action : arg_actions) {
             const char *argstr = arg(action);
             if (!argstr) {
                 break;
             }
             argv.push_back(argstr);
             desc += " ";
             desc += argv.back();
         }
         std::string error;
         BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error));
         BOOST_CHECK_EQUAL(error, "");
 
         std::string conf;
         for (Action action : conf_actions) {
             const char *argstr = arg(action);
             if (!argstr) {
                 break;
             }
             desc += " ";
             desc += argstr + 1;
             conf += argstr + 1;
             conf += "\n";
         }
         std::istringstream conf_stream(conf);
         BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error));
         BOOST_CHECK_EQUAL(error, "");
 
         desc += " || ";
         try {
             desc += parser.GetChainName();
         } catch (const std::runtime_error &e) {
             desc += "error: ";
             desc += e.what();
         }
         desc += "\n";
 
         out_sha.Write(MakeUCharSpan(desc));
         if (out_file) {
             BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) ==
                           desc.size());
         }
     });
 
     if (out_file) {
         if (fclose(out_file)) {
             throw std::system_error(errno, std::generic_category(),
                                     "fclose failed");
         }
         out_file = nullptr;
     }
 
     uint8_t out_sha_bytes[CSHA256::OUTPUT_SIZE];
     out_sha.Finalize(out_sha_bytes);
     std::string out_sha_hex = HexStr(out_sha_bytes);
 
     // If check below fails, should manually dump the results with:
     //
     //   CHAIN_MERGE_TEST_OUT=results.txt ./test_bitcoin
     //   --run_test=util_tests/util_ChainMerge
     //
     // And verify diff against previous results to make sure the changes are
     // expected.
     //
     // Results file is formatted like:
     //
     //   <input> || <output>
     BOOST_CHECK_EQUAL(
         out_sha_hex,
         "f0b3a3c29869edc765d579c928f7f1690a71fbb673b49ccf39cbc4de18156a0d");
 }
 
 BOOST_AUTO_TEST_CASE(util_ReadWriteSettings) {
     // Test writing setting.
     TestArgsManager args1;
     args1.ForceSetArg("-datadir", fs::PathToString(m_path_root));
     args1.LockSettings([&](util::Settings &settings) {
         settings.rw_settings["name"] = "value";
     });
     args1.WriteSettingsFile();
 
     // Test reading setting.
     TestArgsManager args2;
     args2.ForceSetArg("-datadir", fs::PathToString(m_path_root));
     args2.ReadSettingsFile();
     args2.LockSettings([&](util::Settings &settings) {
         BOOST_CHECK_EQUAL(settings.rw_settings["name"].get_str(), "value");
     });
 
     // Test error logging, and remove previously written setting.
     {
         ASSERT_DEBUG_LOG("Failed renaming settings file");
         fs::remove(args1.GetDataDirBase() / "settings.json");
         fs::create_directory(args1.GetDataDirBase() / "settings.json");
         args2.WriteSettingsFile();
         fs::remove(args1.GetDataDirBase() / "settings.json");
     }
 }
 
 BOOST_AUTO_TEST_CASE(util_FormatMoney) {
     BOOST_CHECK_EQUAL(FormatMoney(Amount::zero()), "0.00");
     BOOST_CHECK_EQUAL(FormatMoney(123456789 * (COIN / 10000)),
                       "12345678900.00");
     BOOST_CHECK_EQUAL(FormatMoney(-1 * COIN), "-1000000.00");
 
     BOOST_CHECK_EQUAL(FormatMoney(100000000 * COIN), "100000000000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(10000000 * COIN), "10000000000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(1000000 * COIN), "1000000000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(100000 * COIN), "100000000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(10000 * COIN), "10000000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(1000 * COIN), "1000000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(100 * COIN), "100000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(10 * COIN), "10000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN), "1000000.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 10), "100000.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 100), "10000.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 1000), "1000.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 10000), "100.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 100000), "10.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 1000000), "1.00");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 10000000), "0.10");
     BOOST_CHECK_EQUAL(FormatMoney(COIN / 100000000), "0.01");
 }
 
 BOOST_AUTO_TEST_CASE(util_ParseMoney) {
     Amount ret = Amount::zero();
     BOOST_CHECK(ParseMoney("0.0", ret));
     BOOST_CHECK_EQUAL(ret, Amount::zero());
 
     BOOST_CHECK(ParseMoney("1234567.89", ret));
     BOOST_CHECK_EQUAL(ret, 123456789 * SATOSHI);
 
     BOOST_CHECK(ParseMoney("21000000000000.00", ret));
     BOOST_CHECK_EQUAL(ret, MAX_MONEY);
 
     const auto XEC = Currency::get().baseunit;
     BOOST_CHECK(ParseMoney("100000000.00", ret));
     BOOST_CHECK_EQUAL(ret, 100000000 * XEC);
     BOOST_CHECK(ParseMoney("10000000.00", ret));
     BOOST_CHECK_EQUAL(ret, 10000000 * XEC);
     BOOST_CHECK(ParseMoney("1000000.00", ret));
     BOOST_CHECK_EQUAL(ret, 1000000 * XEC);
     BOOST_CHECK(ParseMoney("100000.00", ret));
     BOOST_CHECK_EQUAL(ret, 100000 * XEC);
     BOOST_CHECK(ParseMoney("10000.00", ret));
     BOOST_CHECK_EQUAL(ret, 10000 * XEC);
     BOOST_CHECK(ParseMoney("1000.00", ret));
     BOOST_CHECK_EQUAL(ret, 1000 * XEC);
     BOOST_CHECK(ParseMoney("100.00", ret));
     BOOST_CHECK_EQUAL(ret, 100 * XEC);
     BOOST_CHECK(ParseMoney("10.00", ret));
     BOOST_CHECK_EQUAL(ret, 10 * XEC);
     BOOST_CHECK(ParseMoney("1.00", ret));
     BOOST_CHECK_EQUAL(ret, XEC);
     BOOST_CHECK(ParseMoney("1", ret));
     BOOST_CHECK_EQUAL(ret, XEC);
     BOOST_CHECK(ParseMoney("   1", ret));
     BOOST_CHECK_EQUAL(ret, XEC);
     BOOST_CHECK(ParseMoney("1   ", ret));
     BOOST_CHECK_EQUAL(ret, XEC);
     BOOST_CHECK(ParseMoney("  1 ", ret));
     BOOST_CHECK_EQUAL(ret, XEC);
     BOOST_CHECK(ParseMoney("0.1", ret));
     BOOST_CHECK_EQUAL(ret, XEC / 10);
     BOOST_CHECK(ParseMoney("0.01", ret));
     BOOST_CHECK_EQUAL(ret, XEC / 100);
     BOOST_CHECK(ParseMoney(" 0.01 ", ret));
     BOOST_CHECK_EQUAL(ret, XEC / 100);
     BOOST_CHECK(ParseMoney("0.01 ", ret));
     BOOST_CHECK_EQUAL(ret, XEC / 100);
     BOOST_CHECK(ParseMoney(" 0.01", ret));
     BOOST_CHECK_EQUAL(ret, XEC / 100);
 
     // Parsing amount that can not be represented in ret should fail
     BOOST_CHECK(!ParseMoney("0.001", ret));
     BOOST_CHECK(!ParseMoney("0.0001", ret));
     BOOST_CHECK(!ParseMoney("0.00001", ret));
     BOOST_CHECK(!ParseMoney("0.000001", ret));
     BOOST_CHECK(!ParseMoney("0.0000001", ret));
     BOOST_CHECK(!ParseMoney("0.00000001", ret));
     BOOST_CHECK(!ParseMoney("0.000000001", ret));
 
     // Parsing empty string should fail
     BOOST_CHECK(!ParseMoney("", ret));
     BOOST_CHECK(!ParseMoney(" ", ret));
     BOOST_CHECK(!ParseMoney("  ", ret));
 
     // Parsing two numbers should fail
     BOOST_CHECK(!ParseMoney("1 2", ret));
     BOOST_CHECK(!ParseMoney(" 1 2 ", ret));
     BOOST_CHECK(!ParseMoney(" 1.2 3 ", ret));
     BOOST_CHECK(!ParseMoney(" 1 2.3 ", ret));
 
     // Max possible value with the max number of digits
     BOOST_CHECK(ParseMoney("9999999999999999.99", ret));
     BOOST_CHECK_EQUAL(ret, int64_t(999999999999999999) * SATOSHI);
     // Attempted 63 bit overflow should fail
     BOOST_CHECK(!ParseMoney("10000000000000000.00", ret));
     BOOST_CHECK(!ParseMoney("92233720368547758.08", ret));
 
     // Parsing negative amounts must fail
     BOOST_CHECK(!ParseMoney("-1", ret));
 
     // Parsing strings with embedded NUL characters should fail
     BOOST_CHECK(!ParseMoney("\0-1"s, ret));
     BOOST_CHECK(!ParseMoney(STRING_WITH_EMBEDDED_NULL_CHAR, ret));
     BOOST_CHECK(!ParseMoney("1\0"s, ret));
 }
 
 BOOST_AUTO_TEST_CASE(util_IsHex) {
     BOOST_CHECK(IsHex("00"));
     BOOST_CHECK(IsHex("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
     BOOST_CHECK(IsHex("ff"));
     BOOST_CHECK(IsHex("FF"));
 
     BOOST_CHECK(!IsHex(""));
     BOOST_CHECK(!IsHex("0"));
     BOOST_CHECK(!IsHex("a"));
     BOOST_CHECK(!IsHex("eleven"));
     BOOST_CHECK(!IsHex("00xx00"));
     BOOST_CHECK(!IsHex("0x0000"));
 }
 
 BOOST_AUTO_TEST_CASE(util_IsHexNumber) {
     BOOST_CHECK(IsHexNumber("0x0"));
     BOOST_CHECK(IsHexNumber("0"));
     BOOST_CHECK(IsHexNumber("0x10"));
     BOOST_CHECK(IsHexNumber("10"));
     BOOST_CHECK(IsHexNumber("0xff"));
     BOOST_CHECK(IsHexNumber("ff"));
     BOOST_CHECK(IsHexNumber("0xFfa"));
     BOOST_CHECK(IsHexNumber("Ffa"));
     BOOST_CHECK(IsHexNumber("0x00112233445566778899aabbccddeeffAABBCCDDEEFF"));
     BOOST_CHECK(IsHexNumber("00112233445566778899aabbccddeeffAABBCCDDEEFF"));
 
     BOOST_CHECK(!IsHexNumber(""));      // empty string not allowed
     BOOST_CHECK(!IsHexNumber("0x"));    // empty string after prefix not allowed
     BOOST_CHECK(!IsHexNumber("0x0 "));  // no spaces at end,
     BOOST_CHECK(!IsHexNumber(" 0x0"));  // or beginning,
     BOOST_CHECK(!IsHexNumber("0x 0"));  // or middle,
     BOOST_CHECK(!IsHexNumber(" "));     // etc.
     BOOST_CHECK(!IsHexNumber("0x0ga")); // invalid character
     BOOST_CHECK(!IsHexNumber("x0"));    // broken prefix
     BOOST_CHECK(!IsHexNumber("0x0x00")); // two prefixes not allowed
 }
 
 BOOST_AUTO_TEST_CASE(util_seed_insecure_rand) {
     SeedInsecureRand(SeedRand::ZEROS);
     for (int mod = 2; mod < 11; mod++) {
         int mask = 1;
         // Really rough binomial confidence approximation.
         int err =
             30 * 10000. / mod * sqrt((1. / mod * (1 - 1. / mod)) / 10000.);
         // mask is 2^ceil(log2(mod))-1
         while (mask < mod - 1) {
             mask = (mask << 1) + 1;
         }
 
         int count = 0;
         // How often does it get a zero from the uniform range [0,mod)?
         for (int i = 0; i < 10000; i++) {
             uint32_t rval;
             do {
                 rval = InsecureRand32() & mask;
             } while (rval >= uint32_t(mod));
             count += rval == 0;
         }
         BOOST_CHECK(count <= 10000 / mod + err);
         BOOST_CHECK(count >= 10000 / mod - err);
     }
 }
 
 BOOST_AUTO_TEST_CASE(util_TimingResistantEqual) {
     BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
     BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
     BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
     BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
     BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
     BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
     BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
 }
 
 /* Test strprintf formatting directives.
  * Put a string before and after to ensure sanity of element sizes on stack. */
 #define B "check_prefix"
 #define E "check_postfix"
 BOOST_AUTO_TEST_CASE(strprintf_numbers) {
     int64_t s64t = -9223372036854775807LL;   /* signed 64 bit test value */
     uint64_t u64t = 18446744073709551615ULL; /* unsigned 64 bit test value */
     BOOST_CHECK(strprintf("%s %d %s", B, s64t, E) == B
                 " -9223372036854775807 " E);
     BOOST_CHECK(strprintf("%s %u %s", B, u64t, E) == B
                 " 18446744073709551615 " E);
     BOOST_CHECK(strprintf("%s %x %s", B, u64t, E) == B " ffffffffffffffff " E);
 
     size_t st = 12345678;    /* unsigned size_t test value */
     ssize_t sst = -12345678; /* signed size_t test value */
     BOOST_CHECK(strprintf("%s %d %s", B, sst, E) == B " -12345678 " E);
     BOOST_CHECK(strprintf("%s %u %s", B, st, E) == B " 12345678 " E);
     BOOST_CHECK(strprintf("%s %x %s", B, st, E) == B " bc614e " E);
 
     ptrdiff_t pt = 87654321;   /* positive ptrdiff_t test value */
     ptrdiff_t spt = -87654321; /* negative ptrdiff_t test value */
     BOOST_CHECK(strprintf("%s %d %s", B, spt, E) == B " -87654321 " E);
     BOOST_CHECK(strprintf("%s %u %s", B, pt, E) == B " 87654321 " E);
     BOOST_CHECK(strprintf("%s %x %s", B, pt, E) == B " 5397fb1 " E);
 }
 #undef B
 #undef E
 
 /* Check for mingw/wine issue #3494
  * Remove this test before time.ctime(0xffffffff) == 'Sun Feb  7 07:28:15 2106'
  */
 BOOST_AUTO_TEST_CASE(gettime) {
     BOOST_CHECK((GetTime() & ~0xFFFFFFFFLL) == 0);
 }
 
 BOOST_AUTO_TEST_CASE(util_time_GetTime) {
     SetMockTime(111);
     // Check that mock time does not change after a sleep
     for (const auto &num_sleep : {0, 1}) {
         UninterruptibleSleep(std::chrono::milliseconds{num_sleep});
         BOOST_CHECK_EQUAL(111, GetTime()); // Deprecated time getter
         BOOST_CHECK_EQUAL(111, GetTime<std::chrono::seconds>().count());
         BOOST_CHECK_EQUAL(111000, GetTime<std::chrono::milliseconds>().count());
         BOOST_CHECK_EQUAL(111000000,
                           GetTime<std::chrono::microseconds>().count());
     }
 
     SetMockTime(0);
     // Check that system time changes after a sleep
     const auto ms_0 = GetTime<std::chrono::milliseconds>();
     const auto us_0 = GetTime<std::chrono::microseconds>();
     UninterruptibleSleep(std::chrono::milliseconds{1});
     BOOST_CHECK(ms_0 < GetTime<std::chrono::milliseconds>());
     BOOST_CHECK(us_0 < GetTime<std::chrono::microseconds>());
 }
 
 BOOST_AUTO_TEST_CASE(test_IsDigit) {
     BOOST_CHECK_EQUAL(IsDigit('0'), true);
     BOOST_CHECK_EQUAL(IsDigit('1'), true);
     BOOST_CHECK_EQUAL(IsDigit('8'), true);
     BOOST_CHECK_EQUAL(IsDigit('9'), true);
 
     BOOST_CHECK_EQUAL(IsDigit('0' - 1), false);
     BOOST_CHECK_EQUAL(IsDigit('9' + 1), false);
     BOOST_CHECK_EQUAL(IsDigit(0), false);
     BOOST_CHECK_EQUAL(IsDigit(1), false);
     BOOST_CHECK_EQUAL(IsDigit(8), false);
     BOOST_CHECK_EQUAL(IsDigit(9), false);
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseInt32) {
     int32_t n;
     // Valid values
     BOOST_CHECK(ParseInt32("1234", nullptr));
     BOOST_CHECK(ParseInt32("0", &n) && n == 0);
     BOOST_CHECK(ParseInt32("1234", &n) && n == 1234);
     BOOST_CHECK(ParseInt32("01234", &n) && n == 1234); // no octal
     BOOST_CHECK(ParseInt32("2147483647", &n) && n == 2147483647);
     // (-2147483647 - 1) equals INT_MIN
     BOOST_CHECK(ParseInt32("-2147483648", &n) && n == (-2147483647 - 1));
     BOOST_CHECK(ParseInt32("-1234", &n) && n == -1234);
     BOOST_CHECK(ParseInt32("00000000000000001234", &n) && n == 1234);
     BOOST_CHECK(ParseInt32("-00000000000000001234", &n) && n == -1234);
     BOOST_CHECK(ParseInt32("00000000000000000000", &n) && n == 0);
     BOOST_CHECK(ParseInt32("-00000000000000000000", &n) && n == 0);
     // Invalid values
     BOOST_CHECK(!ParseInt32("", &n));
     BOOST_CHECK(!ParseInt32(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseInt32("1 ", &n));
     BOOST_CHECK(!ParseInt32("++1", &n));
     BOOST_CHECK(!ParseInt32("+-1", &n));
     BOOST_CHECK(!ParseInt32("-+1", &n));
     BOOST_CHECK(!ParseInt32("--1", &n));
     BOOST_CHECK(!ParseInt32("1a", &n));
     BOOST_CHECK(!ParseInt32("aap", &n));
     BOOST_CHECK(!ParseInt32("0x1", &n)); // no hex
     BOOST_CHECK(!ParseInt32(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     // Overflow and underflow
     BOOST_CHECK(!ParseInt32("-2147483649", nullptr));
     BOOST_CHECK(!ParseInt32("2147483648", nullptr));
     BOOST_CHECK(!ParseInt32("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseInt32("32482348723847471234", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseInt64) {
     int64_t n;
     // Valid values
     BOOST_CHECK(ParseInt64("1234", nullptr));
     BOOST_CHECK(ParseInt64("0", &n) && n == 0LL);
     BOOST_CHECK(ParseInt64("1234", &n) && n == 1234LL);
     BOOST_CHECK(ParseInt64("01234", &n) && n == 1234LL); // no octal
     BOOST_CHECK(ParseInt64("2147483647", &n) && n == 2147483647LL);
     BOOST_CHECK(ParseInt64("-2147483648", &n) && n == -2147483648LL);
     BOOST_CHECK(ParseInt64("9223372036854775807", &n) &&
                 n == (int64_t)9223372036854775807);
     BOOST_CHECK(ParseInt64("-9223372036854775808", &n) &&
                 n == (int64_t)-9223372036854775807 - 1);
     BOOST_CHECK(ParseInt64("-1234", &n) && n == -1234LL);
     // Invalid values
     BOOST_CHECK(!ParseInt64("", &n));
     BOOST_CHECK(!ParseInt64(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseInt64("1 ", &n));
     BOOST_CHECK(!ParseInt64("1a", &n));
     BOOST_CHECK(!ParseInt64("aap", &n));
     BOOST_CHECK(!ParseInt64("0x1", &n)); // no hex
     BOOST_CHECK(!ParseInt64(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     // Overflow and underflow
     BOOST_CHECK(!ParseInt64("-9223372036854775809", nullptr));
     BOOST_CHECK(!ParseInt64("9223372036854775808", nullptr));
     BOOST_CHECK(!ParseInt64("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseInt64("32482348723847471234", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseUInt8) {
     uint8_t n;
     // Valid values
     BOOST_CHECK(ParseUInt8("255", nullptr));
     BOOST_CHECK(ParseUInt8("0", &n) && n == 0);
     BOOST_CHECK(ParseUInt8("255", &n) && n == 255);
     BOOST_CHECK(ParseUInt8("0255", &n) && n == 255); // no octal
     BOOST_CHECK(ParseUInt8("255", &n) && n == static_cast<uint8_t>(255));
     BOOST_CHECK(ParseUInt8("+255", &n) && n == 255);
     BOOST_CHECK(ParseUInt8("00000000000000000012", &n) && n == 12);
     BOOST_CHECK(ParseUInt8("00000000000000000000", &n) && n == 0);
     // Invalid values
     BOOST_CHECK(!ParseUInt8("-00000000000000000000", &n));
     BOOST_CHECK(!ParseUInt8("", &n));
     BOOST_CHECK(!ParseUInt8(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseUInt8(" -1", &n));
     BOOST_CHECK(!ParseUInt8("++1", &n));
     BOOST_CHECK(!ParseUInt8("+-1", &n));
     BOOST_CHECK(!ParseUInt8("-+1", &n));
     BOOST_CHECK(!ParseUInt8("--1", &n));
     BOOST_CHECK(!ParseUInt8("-1", &n));
     BOOST_CHECK(!ParseUInt8("1 ", &n));
     BOOST_CHECK(!ParseUInt8("1a", &n));
     BOOST_CHECK(!ParseUInt8("aap", &n));
     BOOST_CHECK(!ParseUInt8("0x1", &n)); // no hex
     BOOST_CHECK(!ParseUInt8(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     // Overflow and underflow
     BOOST_CHECK(!ParseUInt8("-255", &n));
     BOOST_CHECK(!ParseUInt8("256", &n));
     BOOST_CHECK(!ParseUInt8("-123", &n));
     BOOST_CHECK(!ParseUInt8("-123", nullptr));
     BOOST_CHECK(!ParseUInt8("256", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseUInt16) {
     uint16_t n;
     // Valid values
     BOOST_CHECK(ParseUInt16("1234", nullptr));
     BOOST_CHECK(ParseUInt16("0", &n) && n == 0);
     BOOST_CHECK(ParseUInt16("1234", &n) && n == 1234);
     BOOST_CHECK(ParseUInt16("01234", &n) && n == 1234); // no octal
     BOOST_CHECK(ParseUInt16("65535", &n) && n == static_cast<uint16_t>(65535));
     BOOST_CHECK(ParseUInt16("+65535", &n) && n == 65535);
     BOOST_CHECK(ParseUInt16("00000000000000000012", &n) && n == 12);
     BOOST_CHECK(ParseUInt16("00000000000000000000", &n) && n == 0);
     // Invalid values
     BOOST_CHECK(!ParseUInt16("-00000000000000000000", &n));
     BOOST_CHECK(!ParseUInt16("", &n));
     BOOST_CHECK(!ParseUInt16(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseUInt16(" -1", &n));
     BOOST_CHECK(!ParseUInt16("++1", &n));
     BOOST_CHECK(!ParseUInt16("+-1", &n));
     BOOST_CHECK(!ParseUInt16("-+1", &n));
     BOOST_CHECK(!ParseUInt16("--1", &n));
     BOOST_CHECK(!ParseUInt16("-1", &n));
     BOOST_CHECK(!ParseUInt16("1 ", &n));
     BOOST_CHECK(!ParseUInt16("1a", &n));
     BOOST_CHECK(!ParseUInt16("aap", &n));
     BOOST_CHECK(!ParseUInt16("0x1", &n)); // no hex
     BOOST_CHECK(!ParseUInt16(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     // Overflow and underflow
     BOOST_CHECK(!ParseUInt16("-65535", &n));
     BOOST_CHECK(!ParseUInt16("65536", &n));
     BOOST_CHECK(!ParseUInt16("-123", &n));
     BOOST_CHECK(!ParseUInt16("-123", nullptr));
     BOOST_CHECK(!ParseUInt16("65536", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseUInt32) {
     uint32_t n;
     // Valid values
     BOOST_CHECK(ParseUInt32("1234", nullptr));
     BOOST_CHECK(ParseUInt32("0", &n) && n == 0);
     BOOST_CHECK(ParseUInt32("1234", &n) && n == 1234);
     BOOST_CHECK(ParseUInt32("01234", &n) && n == 1234); // no octal
     BOOST_CHECK(ParseUInt32("2147483647", &n) && n == 2147483647);
     BOOST_CHECK(ParseUInt32("2147483648", &n) && n == (uint32_t)2147483648);
     BOOST_CHECK(ParseUInt32("4294967295", &n) && n == (uint32_t)4294967295);
     BOOST_CHECK(ParseUInt32("+1234", &n) && n == 1234);
     BOOST_CHECK(ParseUInt32("00000000000000001234", &n) && n == 1234);
     BOOST_CHECK(ParseUInt32("00000000000000000000", &n) && n == 0);
     // Invalid values
     BOOST_CHECK(!ParseUInt32("-00000000000000000000", &n));
     BOOST_CHECK(!ParseUInt32("", &n));
     BOOST_CHECK(!ParseUInt32(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseUInt32(" -1", &n));
     BOOST_CHECK(!ParseUInt32("++1", &n));
     BOOST_CHECK(!ParseUInt32("+-1", &n));
     BOOST_CHECK(!ParseUInt32("-+1", &n));
     BOOST_CHECK(!ParseUInt32("--1", &n));
     BOOST_CHECK(!ParseUInt32("-1", &n));
     BOOST_CHECK(!ParseUInt32("1 ", &n));
     BOOST_CHECK(!ParseUInt32("1a", &n));
     BOOST_CHECK(!ParseUInt32("aap", &n));
     BOOST_CHECK(!ParseUInt32("0x1", &n)); // no hex
     BOOST_CHECK(!ParseUInt32(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     // Overflow and underflow
     BOOST_CHECK(!ParseUInt32("-2147483648", &n));
     BOOST_CHECK(!ParseUInt32("4294967296", &n));
     BOOST_CHECK(!ParseUInt32("-1234", &n));
     BOOST_CHECK(!ParseUInt32("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseUInt32("32482348723847471234", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseUInt64) {
     uint64_t n;
     // Valid values
     BOOST_CHECK(ParseUInt64("1234", nullptr));
     BOOST_CHECK(ParseUInt64("0", &n) && n == 0LL);
     BOOST_CHECK(ParseUInt64("1234", &n) && n == 1234LL);
     BOOST_CHECK(ParseUInt64("01234", &n) && n == 1234LL); // no octal
     BOOST_CHECK(ParseUInt64("2147483647", &n) && n == 2147483647LL);
     BOOST_CHECK(ParseUInt64("9223372036854775807", &n) &&
                 n == 9223372036854775807ULL);
     BOOST_CHECK(ParseUInt64("9223372036854775808", &n) &&
                 n == 9223372036854775808ULL);
     BOOST_CHECK(ParseUInt64("18446744073709551615", &n) &&
                 n == 18446744073709551615ULL);
     // Invalid values
     BOOST_CHECK(!ParseUInt64("", &n));
     BOOST_CHECK(!ParseUInt64(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseUInt64(" -1", &n));
     BOOST_CHECK(!ParseUInt64("1 ", &n));
     BOOST_CHECK(!ParseUInt64("1a", &n));
     BOOST_CHECK(!ParseUInt64("aap", &n));
     BOOST_CHECK(!ParseUInt64("0x1", &n)); // no hex
     BOOST_CHECK(!ParseUInt64(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     // Overflow and underflow
     BOOST_CHECK(!ParseUInt64("-9223372036854775809", nullptr));
     BOOST_CHECK(!ParseUInt64("18446744073709551616", nullptr));
     BOOST_CHECK(!ParseUInt64("-32482348723847471234", nullptr));
     BOOST_CHECK(!ParseUInt64("-2147483648", &n));
     BOOST_CHECK(!ParseUInt64("-9223372036854775808", &n));
     BOOST_CHECK(!ParseUInt64("-1234", &n));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseDouble) {
     double n;
     // Valid values
     BOOST_CHECK(ParseDouble("1234", nullptr));
     BOOST_CHECK(ParseDouble("0", &n) && n == 0.0);
     BOOST_CHECK(ParseDouble("1234", &n) && n == 1234.0);
     BOOST_CHECK(ParseDouble("01234", &n) && n == 1234.0); // no octal
     BOOST_CHECK(ParseDouble("2147483647", &n) && n == 2147483647.0);
     BOOST_CHECK(ParseDouble("-2147483648", &n) && n == -2147483648.0);
     BOOST_CHECK(ParseDouble("-1234", &n) && n == -1234.0);
     BOOST_CHECK(ParseDouble("1e6", &n) && n == 1e6);
     BOOST_CHECK(ParseDouble("-1e6", &n) && n == -1e6);
     // Invalid values
     BOOST_CHECK(!ParseDouble("", &n));
     BOOST_CHECK(!ParseDouble(" 1", &n)); // no padding inside
     BOOST_CHECK(!ParseDouble("1 ", &n));
     BOOST_CHECK(!ParseDouble("1a", &n));
     BOOST_CHECK(!ParseDouble("aap", &n));
     BOOST_CHECK(!ParseDouble("0x1", &n)); // no hex
     BOOST_CHECK(!ParseDouble(STRING_WITH_EMBEDDED_NULL_CHAR, &n));
     // Overflow and underflow
     BOOST_CHECK(!ParseDouble("-1e10000", nullptr));
     BOOST_CHECK(!ParseDouble("1e10000", nullptr));
 }
 
 BOOST_AUTO_TEST_CASE(test_FormatParagraph) {
     BOOST_CHECK_EQUAL(FormatParagraph("", 79, 0), "");
     BOOST_CHECK_EQUAL(FormatParagraph("test", 79, 0), "test");
     BOOST_CHECK_EQUAL(FormatParagraph(" test", 79, 0), " test");
     BOOST_CHECK_EQUAL(FormatParagraph("test test", 79, 0), "test test");
     BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 0), "test\ntest");
     BOOST_CHECK_EQUAL(FormatParagraph("testerde test", 4, 0), "testerde\ntest");
     BOOST_CHECK_EQUAL(FormatParagraph("test test", 4, 4), "test\n    test");
 
     // Make sure we don't indent a fully-new line following a too-long line
     // ending
     BOOST_CHECK_EQUAL(FormatParagraph("test test\nabc", 4, 4),
                       "test\n    test\nabc");
 
     BOOST_CHECK_EQUAL(
         FormatParagraph("This_is_a_very_long_test_string_without_any_spaces_so_"
                         "it_should_just_get_returned_as_is_despite_the_length "
                         "until it gets here",
                         79),
         "This_is_a_very_long_test_string_without_any_spaces_so_it_should_just_"
         "get_returned_as_is_despite_the_length\nuntil it gets here");
 
     // Test wrap length is exact
     BOOST_CHECK_EQUAL(
         FormatParagraph("a b c d e f g h i j k l m n o p q r s t u v w x y z 1 "
                         "2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p",
                         79),
         "a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 8 9 "
         "a b c de\nf g h i j k l m n o p");
     BOOST_CHECK_EQUAL(
         FormatParagraph("x\na b c d e f g h i j k l m n o p q r s t u v w x y "
                         "z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p",
                         79),
         "x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 "
         "8 9 a b c de\nf g h i j k l m n o p");
     // Indent should be included in length of lines
     BOOST_CHECK_EQUAL(
         FormatParagraph("x\na b c d e f g h i j k l m n o p q r s t u v w x y "
                         "z 1 2 3 4 5 6 7 8 9 a b c de f g h i j k l m n o p q "
                         "r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 a b c d e fg h "
                         "i j k",
                         79, 4),
         "x\na b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4 5 6 7 "
         "8 9 a b c de\n    f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 "
         "5 6 7 8 9 a b c d e fg\n    h i j k");
 
     BOOST_CHECK_EQUAL(
         FormatParagraph("This is a very long test string. This is a second "
                         "sentence in the very long test string.",
                         79),
         "This is a very long test string. This is a second sentence in the "
         "very long\ntest string.");
     BOOST_CHECK_EQUAL(
         FormatParagraph("This is a very long test string.\nThis is a second "
                         "sentence in the very long test string. This is a "
                         "third sentence in the very long test string.",
                         79),
         "This is a very long test string.\nThis is a second sentence in the "
         "very long test string. This is a third\nsentence in the very long "
         "test string.");
     BOOST_CHECK_EQUAL(
         FormatParagraph("This is a very long test string.\n\nThis is a second "
                         "sentence in the very long test string. This is a "
                         "third sentence in the very long test string.",
                         79),
         "This is a very long test string.\n\nThis is a second sentence in the "
         "very long test string. This is a third\nsentence in the very long "
         "test string.");
     BOOST_CHECK_EQUAL(
         FormatParagraph(
             "Testing that normal newlines do not get indented.\nLike here.",
             79),
         "Testing that normal newlines do not get indented.\nLike here.");
 }
 
 BOOST_AUTO_TEST_CASE(test_FormatVersion) {
     BOOST_CHECK_EQUAL(FormatVersion(98700), std::string("0.9.87"));
     BOOST_CHECK_EQUAL(FormatVersion(98701), std::string("0.9.87.1"));
     BOOST_CHECK_EQUAL(FormatVersion(9098700), std::string("9.9.87"));
     BOOST_CHECK_EQUAL(FormatVersion(9098701), std::string("9.9.87.1"));
 }
 
 BOOST_AUTO_TEST_CASE(test_FormatUserAgent) {
     std::vector<std::string> comments;
     comments.push_back(std::string("comment1"));
     std::vector<std::string> comments2;
     comments2.push_back(std::string("comment1"));
     // Semicolon is discouraged but not forbidden by BIP-0014
     comments2.push_back(SanitizeString(
         std::string("Comment2; .,_?@-; !\"#$%&'()*+/<=>[]\\^`{|}~"),
         SAFE_CHARS_UA_COMMENT));
     BOOST_CHECK_EQUAL(
         FormatUserAgent("Test", "0.9.99", std::vector<std::string>()),
         std::string("/Test:0.9.99/"));
     BOOST_CHECK_EQUAL(FormatUserAgent("Test", "0.9.99", comments),
                       std::string("/Test:0.9.99(comment1)/"));
     BOOST_CHECK_EQUAL(
         FormatUserAgent("Test", "0.9.99", comments2),
         std::string("/Test:0.9.99(comment1; Comment2; .,_?@-; )/"));
 }
 
 BOOST_AUTO_TEST_CASE(test_ParseFixedPoint) {
     int64_t amount = 0;
     BOOST_CHECK(ParseFixedPoint("0", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 0LL);
     BOOST_CHECK(ParseFixedPoint("1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 100000000LL);
     BOOST_CHECK(ParseFixedPoint("0.0", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 0LL);
     BOOST_CHECK(ParseFixedPoint("-0.1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -10000000LL);
     BOOST_CHECK(ParseFixedPoint("1.1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 110000000LL);
     BOOST_CHECK(ParseFixedPoint("1.10000000000000000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 110000000LL);
     BOOST_CHECK(ParseFixedPoint("1.1e1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 1100000000LL);
     BOOST_CHECK(ParseFixedPoint("1.1e-1", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 11000000LL);
     BOOST_CHECK(ParseFixedPoint("1000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 100000000000LL);
     BOOST_CHECK(ParseFixedPoint("-1000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -100000000000LL);
     BOOST_CHECK(ParseFixedPoint("0.00000001", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 1LL);
     BOOST_CHECK(ParseFixedPoint("0.0000000100000000", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 1LL);
     BOOST_CHECK(ParseFixedPoint("-0.00000001", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -1LL);
     BOOST_CHECK(ParseFixedPoint("1000000000.00000001", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 100000000000000001LL);
     BOOST_CHECK(ParseFixedPoint("9999999999.99999999", 8, &amount));
     BOOST_CHECK_EQUAL(amount, 999999999999999999LL);
     BOOST_CHECK(ParseFixedPoint("-9999999999.99999999", 8, &amount));
     BOOST_CHECK_EQUAL(amount, -999999999999999999LL);
 
     BOOST_CHECK(!ParseFixedPoint("", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("a-1000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-a1000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-1000a", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-01000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("00.1", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint(".1", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("--0.1", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("0.000000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-0.000000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("0.00000001000000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("10000000000.00000000", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("10000000000.00000001", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-10000000000.00000009", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("10000000000.00000009", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-99999999999.99999999", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("99999909999.09999999", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("92233720368.54775807", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("92233720368.54775808", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-92233720368.54775808", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("-92233720368.54775809", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("1.1e", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("1.1e-", 8, &amount));
     BOOST_CHECK(!ParseFixedPoint("1.", 8, &amount));
 }
 
 static void TestOtherThread(fs::path dirname, std::string lockname,
                             bool *result) {
     *result = LockDirectory(dirname, lockname);
 }
 
 #ifndef WIN32 // Cannot do this test on WIN32 due to lack of fork()
 static constexpr char LockCommand = 'L';
 static constexpr char UnlockCommand = 'U';
 static constexpr char ExitCommand = 'X';
 
 static void TestOtherProcess(fs::path dirname, std::string lockname, int fd) {
     char ch;
     while (true) {
         // Wait for command
         int rv = read(fd, &ch, 1);
         assert(rv == 1);
         switch (ch) {
             case LockCommand:
                 ch = LockDirectory(dirname, lockname);
                 rv = write(fd, &ch, 1);
                 assert(rv == 1);
                 break;
             case UnlockCommand:
                 ReleaseDirectoryLocks();
                 ch = true; // Always succeeds
                 rv = write(fd, &ch, 1);
                 assert(rv == 1);
                 break;
             case ExitCommand:
                 close(fd);
                 // As an alternative to exit() which runs the exit handlers
                 // (which seem to be flakey with Boost test suite with JUNIT
                 // logging in a forked process), just vanish this process as
                 // fast as possible. `quick_exit()` would also work, but it is
                 // not available on all non glibc platforms.
                 // Using exec also stops valgrind from thinking it needs to
                 // analyze the memory leaks in this forked process.
                 execlp("true", "true", (char *)NULL);
             default:
                 assert(0);
         }
     }
 }
 #endif
 
 BOOST_AUTO_TEST_CASE(test_LockDirectory) {
     fs::path dirname = m_args.GetDataDirBase() / "lock_dir";
     const std::string lockname = ".lock";
 #ifndef WIN32
     // Revert SIGCHLD to default, otherwise boost.test will catch and fail on
     // it: there is BOOST_TEST_IGNORE_SIGCHLD but that only works when defined
     // at build-time of the boost library
     void (*old_handler)(int) = signal(SIGCHLD, SIG_DFL);
 
     // Fork another process for testing before creating the lock, so that we
     // won't fork while holding the lock (which might be undefined, and is not
     // relevant as test case as that is avoided with -daemonize).
     int fd[2];
     BOOST_CHECK_EQUAL(socketpair(AF_UNIX, SOCK_STREAM, 0, fd), 0);
     pid_t pid = fork();
     if (!pid) {
         BOOST_CHECK_EQUAL(close(fd[1]), 0); // Child: close parent end
         TestOtherProcess(dirname, lockname, fd[0]);
     }
     BOOST_CHECK_EQUAL(close(fd[0]), 0); // Parent: close child end
 #endif
     // Lock on non-existent directory should fail
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), false);
 
     fs::create_directories(dirname);
 
     // Probing lock on new directory should succeed
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Persistent lock on new directory should succeed
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), true);
 
     // Another lock on the directory from the same thread should succeed
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname), true);
 
     // Another lock on the directory from a different thread within the same
     // process should succeed
     bool threadresult;
     std::thread thr(TestOtherThread, dirname, lockname, &threadresult);
     thr.join();
     BOOST_CHECK_EQUAL(threadresult, true);
 #ifndef WIN32
     // Try to acquire lock in child process while we're holding it, this should
     // fail.
     char ch;
     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
     BOOST_CHECK_EQUAL((bool)ch, false);
 
     // Give up our lock
     ReleaseDirectoryLocks();
     // Probing lock from our side now should succeed, but not hold on to the
     // lock.
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Try to acquire the lock in the child process, this should be successful.
     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
     BOOST_CHECK_EQUAL((bool)ch, true);
 
     // When we try to probe the lock now, it should fail.
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), false);
 
     // Unlock the lock in the child process
     BOOST_CHECK_EQUAL(write(fd[1], &UnlockCommand, 1), 1);
     BOOST_CHECK_EQUAL(read(fd[1], &ch, 1), 1);
     BOOST_CHECK_EQUAL((bool)ch, true);
 
     // When we try to probe the lock now, it should succeed.
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Re-lock the lock in the child process, then wait for it to exit, check
     // successful return. After that, we check that exiting the process
     // has released the lock as we would expect by probing it.
     int processstatus;
     BOOST_CHECK_EQUAL(write(fd[1], &LockCommand, 1), 1);
     BOOST_CHECK_EQUAL(write(fd[1], &ExitCommand, 1), 1);
     BOOST_CHECK_EQUAL(waitpid(pid, &processstatus, 0), pid);
     BOOST_CHECK_EQUAL(processstatus, 0);
     BOOST_CHECK_EQUAL(LockDirectory(dirname, lockname, true), true);
 
     // Restore SIGCHLD
     signal(SIGCHLD, old_handler);
     BOOST_CHECK_EQUAL(close(fd[1]), 0); // Close our side of the socketpair
 #endif
     // Clean up
     ReleaseDirectoryLocks();
     fs::remove_all(dirname);
 }
 
 BOOST_AUTO_TEST_CASE(test_DirIsWritable) {
     // Should be able to write to the data dir.
     fs::path tmpdirname = m_args.GetDataDirBase();
     BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), true);
 
     // Should not be able to write to a non-existent dir.
     tmpdirname = GetUniquePath(tmpdirname);
     BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), false);
 
     fs::create_directory(tmpdirname);
     // Should be able to write to it now.
     BOOST_CHECK_EQUAL(DirIsWritable(tmpdirname), true);
     fs::remove(tmpdirname);
 }
 
 template <int F, int T>
 static void CheckConvertBits(const std::vector<uint8_t> &in,
                              const std::vector<uint8_t> &expected) {
     std::vector<uint8_t> outpad;
     bool ret = ConvertBits<F, T, true>([&](uint8_t c) { outpad.push_back(c); },
                                        in.begin(), in.end());
     BOOST_CHECK(ret);
     BOOST_CHECK(outpad == expected);
 
     const bool dopad = (in.size() * F) % T;
     std::vector<uint8_t> outnopad;
     ret = ConvertBits<F, T, false>([&](uint8_t c) { outnopad.push_back(c); },
                                    in.begin(), in.end());
     BOOST_CHECK(ret != (dopad && !outpad.empty() && outpad.back()));
 
     if (dopad) {
         // We should have skipped the last digit.
         outnopad.push_back(expected.back());
     }
 
     BOOST_CHECK(outnopad == expected);
 
     // Check the other way around.
     // Check with padding. We may get an extra 0 in that case.
     std::vector<uint8_t> origpad;
     ret = ConvertBits<T, F, true>([&](uint8_t c) { origpad.push_back(c); },
                                   expected.begin(), expected.end());
     BOOST_CHECK(ret);
 
     std::vector<uint8_t> orignopad;
     ret = ConvertBits<T, F, false>([&](uint8_t c) { orignopad.push_back(c); },
                                    expected.begin(), expected.end());
     BOOST_CHECK(ret != ((expected.size() * T) % F && !origpad.empty() &&
                         origpad.back()));
     BOOST_CHECK(orignopad == in);
 
     if (dopad) {
         BOOST_CHECK_EQUAL(origpad.back(), 0);
         origpad.pop_back();
     }
 
     BOOST_CHECK(origpad == in);
 }
 
 BOOST_AUTO_TEST_CASE(test_ConvertBits) {
     CheckConvertBits<8, 5>({}, {});
     CheckConvertBits<8, 5>({0xff}, {0x1f, 0x1c});
     CheckConvertBits<8, 5>({0xff, 0xff}, {0x1f, 0x1f, 0x1f, 0x10});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff}, {0x1f, 0x1f, 0x1f, 0x1f, 0x1e});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x18});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f});
     CheckConvertBits<8, 5>({0xff, 0xff, 0xff, 0xff, 0xff},
                            {0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f});
     CheckConvertBits<8, 5>({0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
                            {0x00, 0x04, 0x11, 0x14, 0x0a, 0x19, 0x1c, 0x09,
                             0x15, 0x0f, 0x06, 0x1e, 0x1e});
     CheckConvertBits<8, 5>({0x00}, {0x00, 0x00});
     CheckConvertBits<8, 5>({0xf8}, {0x1f, 0x00});
     CheckConvertBits<8, 5>({0x00, 0x00}, {0x00, 0x00, 0x00, 0x00});
 }
 
 BOOST_AUTO_TEST_CASE(test_ToLower) {
     BOOST_CHECK_EQUAL(ToLower('@'), '@');
     BOOST_CHECK_EQUAL(ToLower('A'), 'a');
     BOOST_CHECK_EQUAL(ToLower('Z'), 'z');
     BOOST_CHECK_EQUAL(ToLower('['), '[');
     BOOST_CHECK_EQUAL(ToLower(0), 0);
     BOOST_CHECK_EQUAL(ToLower('\xff'), '\xff');
 
     BOOST_CHECK_EQUAL(ToLower(""), "");
     BOOST_CHECK_EQUAL(ToLower("#HODL"), "#hodl");
     BOOST_CHECK_EQUAL(ToLower("\x00\xfe\xff"), "\x00\xfe\xff");
 }
 
 BOOST_AUTO_TEST_CASE(test_ToUpper) {
     BOOST_CHECK_EQUAL(ToUpper('`'), '`');
     BOOST_CHECK_EQUAL(ToUpper('a'), 'A');
     BOOST_CHECK_EQUAL(ToUpper('z'), 'Z');
     BOOST_CHECK_EQUAL(ToUpper('{'), '{');
     BOOST_CHECK_EQUAL(ToUpper(0), 0);
     BOOST_CHECK_EQUAL(ToUpper('\xff'), '\xff');
 
     BOOST_CHECK_EQUAL(ToUpper(""), "");
     BOOST_CHECK_EQUAL(ToUpper("#hodl"), "#HODL");
     BOOST_CHECK_EQUAL(ToUpper("\x00\xfe\xff"), "\x00\xfe\xff");
 }
 
 BOOST_AUTO_TEST_CASE(test_Capitalize) {
     BOOST_CHECK_EQUAL(Capitalize(""), "");
     BOOST_CHECK_EQUAL(Capitalize("bitcoin"), "Bitcoin");
     BOOST_CHECK_EQUAL(Capitalize("\x00\xfe\xff"), "\x00\xfe\xff");
 }
 
 static std::string SpanToStr(const Span<const char> &span) {
     return std::string(span.begin(), span.end());
 }
 
 BOOST_AUTO_TEST_CASE(test_spanparsing) {
     using namespace spanparsing;
     std::string input;
     Span<const char> sp;
     bool success;
 
     // Const(...): parse a constant, update span to skip it if successful
     input = "MilkToastHoney";
     sp = input;
     success = Const("", sp); // empty
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "MilkToastHoney");
 
     success = Const("Milk", sp);
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "ToastHoney");
 
     success = Const("Bread", sp);
     BOOST_CHECK(!success);
 
     success = Const("Toast", sp);
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "Honey");
 
     success = Const("Honeybadger", sp);
     BOOST_CHECK(!success);
 
     success = Const("Honey", sp);
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "");
 
     // Func(...): parse a function call, update span to argument if successful
     input = "Foo(Bar(xy,z()))";
     sp = input;
 
     success = Func("FooBar", sp);
     BOOST_CHECK(!success);
 
     success = Func("Foo(", sp);
     BOOST_CHECK(!success);
 
     success = Func("Foo", sp);
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "Bar(xy,z())");
 
     success = Func("Bar", sp);
     BOOST_CHECK(success);
     BOOST_CHECK_EQUAL(SpanToStr(sp), "xy,z()");
 
     success = Func("xy", sp);
     BOOST_CHECK(!success);
 
     // Expr(...): return expression that span begins with, update span to skip
     // it
     Span<const char> result;
 
     input = "(n*(n-1))/2";
     sp = input;
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "(n*(n-1))/2");
     BOOST_CHECK_EQUAL(SpanToStr(sp), "");
 
     input = "foo,bar";
     sp = input;
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "foo");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ",bar");
 
     input = "(aaaaa,bbbbb()),c";
     sp = input;
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "(aaaaa,bbbbb())");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ",c");
 
     input = "xyz)foo";
     sp = input;
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "xyz");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ")foo");
 
     input = "((a),(b),(c)),xxx";
     sp = input;
     result = Expr(sp);
     BOOST_CHECK_EQUAL(SpanToStr(result), "((a),(b),(c))");
     BOOST_CHECK_EQUAL(SpanToStr(sp), ",xxx");
 
     // Split(...): split a string on every instance of sep, return vector
     std::vector<Span<const char>> results;
 
     input = "xxx";
     results = Split(input, 'x');
     BOOST_CHECK_EQUAL(results.size(), 4U);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "");
     BOOST_CHECK_EQUAL(SpanToStr(results[2]), "");
     BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
 
     input = "one#two#three";
     results = Split(input, '-');
     BOOST_CHECK_EQUAL(results.size(), 1U);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one#two#three");
 
     input = "one#two#three";
     results = Split(input, '#');
     BOOST_CHECK_EQUAL(results.size(), 3U);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "one");
     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "two");
     BOOST_CHECK_EQUAL(SpanToStr(results[2]), "three");
 
     input = "*foo*bar*";
     results = Split(input, '*');
     BOOST_CHECK_EQUAL(results.size(), 4U);
     BOOST_CHECK_EQUAL(SpanToStr(results[0]), "");
     BOOST_CHECK_EQUAL(SpanToStr(results[1]), "foo");
     BOOST_CHECK_EQUAL(SpanToStr(results[2]), "bar");
     BOOST_CHECK_EQUAL(SpanToStr(results[3]), "");
 }
 
 BOOST_AUTO_TEST_CASE(test_LogEscapeMessage) {
     // ASCII and UTF-8 must pass through unaltered.
     BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage("Valid log message貓"),
                       "Valid log message貓");
     // Newlines must pass through unaltered.
     BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage("Message\n with newlines\n"),
                       "Message\n with newlines\n");
     // Other control characters are escaped in C syntax.
     BOOST_CHECK_EQUAL(
         BCLog::LogEscapeMessage("\x01\x7f Corrupted log message\x0d"),
         R"(\x01\x7f Corrupted log message\x0d)");
     // Embedded NULL characters are escaped too.
     const std::string NUL("O\x00O", 3);
     BOOST_CHECK_EQUAL(BCLog::LogEscapeMessage(NUL), R"(O\x00O)");
 }
 
 namespace {
 
 struct Tracker {
     //! Points to the original object (possibly itself) we moved/copied from
     const Tracker *origin;
     //! How many copies where involved between the original object and this one
     //! (moves are not counted)
     int copies;
 
     Tracker() noexcept : origin(this), copies(0) {}
     Tracker(const Tracker &t) noexcept
         : origin(t.origin), copies(t.copies + 1) {}
     Tracker(Tracker &&t) noexcept : origin(t.origin), copies(t.copies) {}
     Tracker &operator=(const Tracker &t) noexcept {
         origin = t.origin;
         copies = t.copies + 1;
         return *this;
     }
     Tracker &operator=(Tracker &&t) noexcept {
         origin = t.origin;
         copies = t.copies;
         return *this;
     }
 };
 
 } // namespace
 
 BOOST_AUTO_TEST_CASE(test_tracked_vector) {
     Tracker t1;
     Tracker t2;
     Tracker t3;
 
     BOOST_CHECK(t1.origin == &t1);
     BOOST_CHECK(t2.origin == &t2);
     BOOST_CHECK(t3.origin == &t3);
 
     auto v1 = Vector(t1);
     BOOST_CHECK_EQUAL(v1.size(), 1U);
     BOOST_CHECK(v1[0].origin == &t1);
     BOOST_CHECK_EQUAL(v1[0].copies, 1);
 
     auto v2 = Vector(std::move(t2));
     BOOST_CHECK_EQUAL(v2.size(), 1U);
     BOOST_CHECK(v2[0].origin == &t2);
     BOOST_CHECK_EQUAL(v2[0].copies, 0);
 
     auto v3 = Vector(t1, std::move(t2));
     BOOST_CHECK_EQUAL(v3.size(), 2U);
     BOOST_CHECK(v3[0].origin == &t1);
     BOOST_CHECK(v3[1].origin == &t2);
     BOOST_CHECK_EQUAL(v3[0].copies, 1);
     BOOST_CHECK_EQUAL(v3[1].copies, 0);
 
     auto v4 = Vector(std::move(v3[0]), v3[1], std::move(t3));
     BOOST_CHECK_EQUAL(v4.size(), 3U);
     BOOST_CHECK(v4[0].origin == &t1);
     BOOST_CHECK(v4[1].origin == &t2);
     BOOST_CHECK(v4[2].origin == &t3);
     BOOST_CHECK_EQUAL(v4[0].copies, 1);
     BOOST_CHECK_EQUAL(v4[1].copies, 1);
     BOOST_CHECK_EQUAL(v4[2].copies, 0);
 
     auto v5 = Cat(v1, v4);
     BOOST_CHECK_EQUAL(v5.size(), 4U);
     BOOST_CHECK(v5[0].origin == &t1);
     BOOST_CHECK(v5[1].origin == &t1);
     BOOST_CHECK(v5[2].origin == &t2);
     BOOST_CHECK(v5[3].origin == &t3);
     BOOST_CHECK_EQUAL(v5[0].copies, 2);
     BOOST_CHECK_EQUAL(v5[1].copies, 2);
     BOOST_CHECK_EQUAL(v5[2].copies, 2);
     BOOST_CHECK_EQUAL(v5[3].copies, 1);
 
     auto v6 = Cat(std::move(v1), v3);
     BOOST_CHECK_EQUAL(v6.size(), 3U);
     BOOST_CHECK(v6[0].origin == &t1);
     BOOST_CHECK(v6[1].origin == &t1);
     BOOST_CHECK(v6[2].origin == &t2);
     BOOST_CHECK_EQUAL(v6[0].copies, 1);
     BOOST_CHECK_EQUAL(v6[1].copies, 2);
     BOOST_CHECK_EQUAL(v6[2].copies, 1);
 
     auto v7 = Cat(v2, std::move(v4));
     BOOST_CHECK_EQUAL(v7.size(), 4U);
     BOOST_CHECK(v7[0].origin == &t2);
     BOOST_CHECK(v7[1].origin == &t1);
     BOOST_CHECK(v7[2].origin == &t2);
     BOOST_CHECK(v7[3].origin == &t3);
     BOOST_CHECK_EQUAL(v7[0].copies, 1);
     BOOST_CHECK_EQUAL(v7[1].copies, 1);
     BOOST_CHECK_EQUAL(v7[2].copies, 1);
     BOOST_CHECK_EQUAL(v7[3].copies, 0);
 
     auto v8 = Cat(std::move(v2), std::move(v3));
     BOOST_CHECK_EQUAL(v8.size(), 3U);
     BOOST_CHECK(v8[0].origin == &t2);
     BOOST_CHECK(v8[1].origin == &t1);
     BOOST_CHECK(v8[2].origin == &t2);
     BOOST_CHECK_EQUAL(v8[0].copies, 0);
     BOOST_CHECK_EQUAL(v8[1].copies, 1);
     BOOST_CHECK_EQUAL(v8[2].copies, 0);
 }
 
 BOOST_AUTO_TEST_CASE(message_sign) {
     const std::array<uint8_t, 32> privkey_bytes = {
         {// just some random data
          // derived address from this private key:
          // 15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs
          0xD9, 0x7F, 0x51, 0x08, 0xF1, 0x1C, 0xDA, 0x6E, 0xEE, 0xBA, 0xAA,
          0x42, 0x0F, 0xEF, 0x07, 0x26, 0xB1, 0xF8, 0x98, 0x06, 0x0B, 0x98,
          0x48, 0x9F, 0xA3, 0x09, 0x84, 0x63, 0xC0, 0x03, 0x28, 0x66}};
 
     const std::string message = "Trust no one";
 
     const std::string expected_signature =
         "H3CcyS18y471Ya5WTYAke25spvA5eyBMvAuNhxDkuAjsdNGX+"
         "NoouNlY1KoselGvF65Werf7OdtKAoOZ9WB17Rc=";
 
     CKey privkey;
     std::string generated_signature;
 
     BOOST_REQUIRE_MESSAGE(!privkey.IsValid(),
                           "Confirm the private key is invalid");
 
     BOOST_CHECK_MESSAGE(!MessageSign(privkey, message, generated_signature),
                         "Sign with an invalid private key");
 
     privkey.Set(privkey_bytes.begin(), privkey_bytes.end(), true);
 
     BOOST_REQUIRE_MESSAGE(privkey.IsValid(),
                           "Confirm the private key is valid");
 
     BOOST_CHECK_MESSAGE(MessageSign(privkey, message, generated_signature),
                         "Sign with a valid private key");
 
     BOOST_CHECK_EQUAL(expected_signature, generated_signature);
 }
 
 BOOST_AUTO_TEST_CASE(message_verify) {
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
     BOOST_CHECK_EQUAL(MessageVerify(*params, "invalid address",
                                     "signature should be irrelevant",
                                     "message too"),
                       MessageVerificationResult::ERR_INVALID_ADDRESS);
 
     BOOST_CHECK_EQUAL(
         MessageVerify(*params, "3B5fQsEXEaV8v6U3ejYc8XaKXAkyQj2MjV",
                       "signature should be irrelevant", "message too"),
         MessageVerificationResult::ERR_ADDRESS_NO_KEY);
 
     BOOST_CHECK_EQUAL(MessageVerify(*params,
                                     "1KqbBpLy5FARmTPD4VZnDDpYjkUvkr82Pm",
                                     "invalid signature, not in base64 encoding",
                                     "message should be irrelevant"),
                       MessageVerificationResult::ERR_MALFORMED_SIGNATURE);
 
     BOOST_CHECK_EQUAL(
         MessageVerify(*params, "1KqbBpLy5FARmTPD4VZnDDpYjkUvkr82Pm",
                       "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                       "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
                       "message should be irrelevant"),
         MessageVerificationResult::ERR_PUBKEY_NOT_RECOVERED);
 
     BOOST_CHECK_EQUAL(
         MessageVerify(*params, "15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs",
                       "IPojfrX2dfPnH26UegfbGQQLrdK844DlHq5157/P6h57WyuS/Qsl+h/"
                       "WSVGDF4MUi4rWSswW38oimDYfNNUBUOk=",
                       "I never signed this"),
         MessageVerificationResult::ERR_NOT_SIGNED);
 
     BOOST_CHECK_EQUAL(
         MessageVerify(*params, "15CRxFdyRpGZLW9w8HnHvVduizdL5jKNbs",
                       "H3CcyS18y471Ya5WTYAke25spvA5eyBMvAuNhxDkuAjsdNGX+"
                       "NoouNlY1KoselGvF65Werf7OdtKAoOZ9WB17Rc=",
                       "Trust no one"),
         MessageVerificationResult::OK);
 
     BOOST_CHECK_EQUAL(
         MessageVerify(*params, "1NoJrossxPBKfCHuJXT4HadJrXRE9Fxiqs",
                       "HxO6qEsMrNvPA7QTMUbdzF/uXbW78yPG6gFITses9XVvMdBULIFwrfhN"
                       "f196N+rxnK5eSl8eF3aKe4INunzFJXg=",
                       "Trust me"),
         MessageVerificationResult::OK);
 }
 
 BOOST_AUTO_TEST_CASE(message_hash) {
     const std::string unsigned_tx = "...";
     const std::string prefixed_message =
         std::string(1, (char)MESSAGE_MAGIC.length()) + MESSAGE_MAGIC +
         std::string(1, (char)unsigned_tx.length()) + unsigned_tx;
 
     const uint256 signature_hash = Hash(unsigned_tx);
     const uint256 message_hash1 = Hash(prefixed_message);
     const uint256 message_hash2 = MessageHash(unsigned_tx);
 
     BOOST_CHECK_EQUAL(message_hash1, message_hash2);
     BOOST_CHECK_NE(message_hash1, signature_hash);
 }
 
 BOOST_AUTO_TEST_CASE(remove_prefix) {
     BOOST_CHECK_EQUAL(RemovePrefix("./util/system.h", "./"), "util/system.h");
     BOOST_CHECK_EQUAL(RemovePrefix("foo", "foo"), "");
     BOOST_CHECK_EQUAL(RemovePrefix("foo", "fo"), "o");
     BOOST_CHECK_EQUAL(RemovePrefix("foo", "f"), "oo");
     BOOST_CHECK_EQUAL(RemovePrefix("foo", ""), "foo");
     BOOST_CHECK_EQUAL(RemovePrefix("fo", "foo"), "fo");
     BOOST_CHECK_EQUAL(RemovePrefix("f", "foo"), "f");
     BOOST_CHECK_EQUAL(RemovePrefix("", "foo"), "");
     BOOST_CHECK_EQUAL(RemovePrefix("", ""), "");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/util/asmap.cpp b/src/util/asmap.cpp
index 36c40dafa..5730cb41e 100644
--- a/src/util/asmap.cpp
+++ b/src/util/asmap.cpp
@@ -1,319 +1,320 @@
 // Copyright (c) 2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <util/asmap.h>
 
 #include <clientversion.h>
 #include <crypto/common.h>
+#include <fs.h>
 #include <logging.h>
 #include <streams.h>
 
 #include <cassert>
 #include <map>
 #include <vector>
 
 namespace {
 
 constexpr uint32_t INVALID = 0xFFFFFFFF;
 
 uint32_t DecodeBits(std::vector<bool>::const_iterator &bitpos,
                     const std::vector<bool>::const_iterator &endpos,
                     uint8_t minval, const std::vector<uint8_t> &bit_sizes) {
     uint32_t val = minval;
     bool bit;
     for (std::vector<uint8_t>::const_iterator bit_sizes_it = bit_sizes.begin();
          bit_sizes_it != bit_sizes.end(); ++bit_sizes_it) {
         if (bit_sizes_it + 1 != bit_sizes.end()) {
             if (bitpos == endpos) {
                 break;
             }
             bit = *bitpos;
             bitpos++;
         } else {
             bit = 0;
         }
         if (bit) {
             val += (1 << *bit_sizes_it);
         } else {
             for (int b = 0; b < *bit_sizes_it; b++) {
                 if (bitpos == endpos) {
                     // Reached EOF in mantissa
                     return INVALID;
                 }
                 bit = *bitpos;
                 bitpos++;
                 val += bit << (*bit_sizes_it - 1 - b);
             }
             return val;
         }
     }
     // Reached EOF in exponent
     return INVALID;
 }
 
 enum class Instruction : uint32_t {
     RETURN = 0,
     JUMP = 1,
     MATCH = 2,
     DEFAULT = 3,
 };
 
 const std::vector<uint8_t> TYPE_BIT_SIZES{0, 0, 1};
 Instruction DecodeType(std::vector<bool>::const_iterator &bitpos,
                        const std::vector<bool>::const_iterator &endpos) {
     return Instruction(DecodeBits(bitpos, endpos, 0, TYPE_BIT_SIZES));
 }
 
 const std::vector<uint8_t> ASN_BIT_SIZES{15, 16, 17, 18, 19,
                                          20, 21, 22, 23, 24};
 uint32_t DecodeASN(std::vector<bool>::const_iterator &bitpos,
                    const std::vector<bool>::const_iterator &endpos) {
     return DecodeBits(bitpos, endpos, 1, ASN_BIT_SIZES);
 }
 
 const std::vector<uint8_t> MATCH_BIT_SIZES{1, 2, 3, 4, 5, 6, 7, 8};
 uint32_t DecodeMatch(std::vector<bool>::const_iterator &bitpos,
                      const std::vector<bool>::const_iterator &endpos) {
     return DecodeBits(bitpos, endpos, 2, MATCH_BIT_SIZES);
 }
 
 const std::vector<uint8_t> JUMP_BIT_SIZES{5,  6,  7,  8,  9,  10, 11, 12, 13,
                                           14, 15, 16, 17, 18, 19, 20, 21, 22,
                                           23, 24, 25, 26, 27, 28, 29, 30};
 uint32_t DecodeJump(std::vector<bool>::const_iterator &bitpos,
                     const std::vector<bool>::const_iterator &endpos) {
     return DecodeBits(bitpos, endpos, 17, JUMP_BIT_SIZES);
 }
 
 } // namespace
 
 uint32_t Interpret(const std::vector<bool> &asmap,
                    const std::vector<bool> &ip) {
     std::vector<bool>::const_iterator pos = asmap.begin();
     const std::vector<bool>::const_iterator endpos = asmap.end();
     uint8_t bits = ip.size();
     uint32_t default_asn = 0;
     uint32_t jump, match, matchlen;
     Instruction opcode;
     while (pos != endpos) {
         opcode = DecodeType(pos, endpos);
         if (opcode == Instruction::RETURN) {
             default_asn = DecodeASN(pos, endpos);
             if (default_asn == INVALID) {
                 // ASN straddles EOF
                 break;
             }
             return default_asn;
         } else if (opcode == Instruction::JUMP) {
             jump = DecodeJump(pos, endpos);
             if (jump == INVALID) {
                 // Jump offset straddles EOF
                 break;
             }
             if (bits == 0) {
                 // No input bits left
                 break;
             }
             if (pos + jump < pos) {
                 // overflow
                 break;
             }
             if (pos + jump >= endpos) {
                 // Jumping past EOF
                 break;
             }
             if (ip[ip.size() - bits]) {
                 pos += jump;
             }
             bits--;
         } else if (opcode == Instruction::MATCH) {
             match = DecodeMatch(pos, endpos);
             if (match == INVALID) {
                 // Match bits straddle EOF
                 break;
             }
             matchlen = CountBits(match) - 1;
             if (bits < matchlen) {
                 // Not enough input bits
                 break;
             }
             for (uint32_t bit = 0; bit < matchlen; bit++) {
                 if ((ip[ip.size() - bits]) !=
                     ((match >> (matchlen - 1 - bit)) & 1)) {
                     return default_asn;
                 }
                 bits--;
             }
         } else if (opcode == Instruction::DEFAULT) {
             default_asn = DecodeASN(pos, endpos);
             if (default_asn == INVALID) {
                 // ASN straddles EOF
                 break;
             }
         } else {
             // Instruction straddles EOF
             break;
         }
     }
 
     // Reached EOF without RETURN, or aborted (see any of the breaks above) -
     // should have been caught by SanityCheckASMap below
     assert(false);
 
     // 0 is not a valid ASN
     return 0;
 }
 
 bool SanityCheckASMap(const std::vector<bool> &asmap, int bits) {
     const std::vector<bool>::const_iterator begin = asmap.begin(),
                                             endpos = asmap.end();
     std::vector<bool>::const_iterator pos = begin;
     // All future positions we may jump to (bit offset in asmap -> bits to
     // consume left)
     std::vector<std::pair<uint32_t, int>> jumps;
     jumps.reserve(bits);
     Instruction prevopcode = Instruction::JUMP;
     bool had_incomplete_match = false;
     while (pos != endpos) {
         uint32_t offset = pos - begin;
         if (!jumps.empty() && offset >= jumps.back().first) {
             // There was a jump into the middle of the previous instruction
             return false;
         }
         Instruction opcode = DecodeType(pos, endpos);
         if (opcode == Instruction::RETURN) {
             if (prevopcode == Instruction::DEFAULT) {
                 // There should not be any RETURN immediately after a DEFAULT
                 // (could be combined into just RETURN)
                 return false;
             }
             uint32_t asn = DecodeASN(pos, endpos);
             if (asn == INVALID) {
                 // ASN straddles EOF
                 return false;
             }
             if (jumps.empty()) {
                 // Nothing to execute anymore
                 if (endpos - pos > 7) {
                     // Excessive padding
                     return false;
                 }
                 while (pos != endpos) {
                     if (*pos) {
                         // Nonzero padding bit
                         return false;
                     }
                     ++pos;
                 }
                 // Sanely reached EOF
                 return true;
             } else {
                 // Continue by pretending we jumped to the next instruction
                 offset = pos - begin;
                 if (offset != jumps.back().first) {
                     // Unreachable code
                     return false;
                 }
                 // Restore the number of bits we would have had left after this
                 // jump
                 bits = jumps.back().second;
                 jumps.pop_back();
                 prevopcode = Instruction::JUMP;
             }
         } else if (opcode == Instruction::JUMP) {
             uint32_t jump = DecodeJump(pos, endpos);
             if (jump == INVALID) {
                 // Jump offset straddles EOF
                 return false;
             }
             if (pos + jump < pos) {
                 // overflow
                 return false;
             }
             if (pos + jump > endpos) {
                 // Jump out of range
                 return false;
             }
             if (bits == 0) {
                 // Consuming bits past the end of the input
                 return false;
             }
             --bits;
             uint32_t jump_offset = pos - begin + jump;
             if (!jumps.empty() && jump_offset >= jumps.back().first) {
                 // Intersecting jumps
                 return false;
             }
             jumps.emplace_back(jump_offset, bits);
             prevopcode = Instruction::JUMP;
         } else if (opcode == Instruction::MATCH) {
             uint32_t match = DecodeMatch(pos, endpos);
             if (match == INVALID) {
                 // Match bits straddle EOF
                 return false;
             }
             int matchlen = CountBits(match) - 1;
             if (prevopcode != Instruction::MATCH) {
                 had_incomplete_match = false;
             }
             if (matchlen < 8 && had_incomplete_match) {
                 // Within a sequence of matches only at most one should be
                 // incomplete
                 return false;
             }
             had_incomplete_match = (matchlen < 8);
             if (bits < matchlen) {
                 // Consuming bits past the end of the input
                 return false;
             }
             bits -= matchlen;
             prevopcode = Instruction::MATCH;
         } else if (opcode == Instruction::DEFAULT) {
             if (prevopcode == Instruction::DEFAULT) {
                 // There should not be two successive DEFAULTs (they could be
                 // combined into one)
                 return false;
             }
             uint32_t asn = DecodeASN(pos, endpos);
             if (asn == INVALID) {
                 // ASN straddles EOF
                 return false;
             }
             prevopcode = Instruction::DEFAULT;
         } else {
             // Instruction straddles EOF
             return false;
         }
     }
     // Reached EOF without RETURN instruction
     return false;
 }
 
 std::vector<bool> DecodeAsmap(fs::path path) {
     std::vector<bool> bits;
     FILE *filestr = fsbridge::fopen(path, "rb");
     CAutoFile file(filestr, SER_DISK, CLIENT_VERSION);
     if (file.IsNull()) {
         LogPrintf("Failed to open asmap file from disk\n");
         return bits;
     }
     fseek(filestr, 0, SEEK_END);
     int length = ftell(filestr);
     LogPrintf("Opened asmap file %s (%d bytes) from disk\n",
               fs::quoted(fs::PathToString(path)), length);
     fseek(filestr, 0, SEEK_SET);
     char cur_byte;
     for (int i = 0; i < length; ++i) {
         file >> cur_byte;
         for (int bit = 0; bit < 8; ++bit) {
             bits.push_back((cur_byte >> bit) & 1);
         }
     }
     if (!SanityCheckASMap(bits, 128)) {
         LogPrintf("Sanity check of asmap file %s failed\n",
                   fs::quoted(fs::PathToString(path)));
         return {};
     }
     return bits;
 }
diff --git a/src/util/settings.cpp b/src/util/settings.cpp
index bdf866993..fde3a808b 100644
--- a/src/util/settings.cpp
+++ b/src/util/settings.cpp
@@ -1,294 +1,300 @@
 // Copyright (c) 2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <fs.h>
 #include <util/settings.h>
 
 #include <tinyformat.h>
 #include <univalue.h>
 
+#include <fstream>
+#include <map>
+#include <string>
+#include <vector>
+
 namespace util {
 namespace {
 
     enum class Source {
         FORCED,
         COMMAND_LINE,
         RW_SETTINGS,
         CONFIG_FILE_NETWORK_SECTION,
         CONFIG_FILE_DEFAULT_SECTION
     };
 
     //! Merge settings from multiple sources in precedence order:
     //! Forced config > command line > read-write settings file > config file
     //! network-specific section > config file default section
     //!
     //! This function is provided with a callback function fn that contains
     //! specific logic for how to merge the sources.
     template <typename Fn>
     static void MergeSettings(const Settings &settings,
                               const std::string &section,
                               const std::string &name, Fn &&fn) {
         // Merge in the forced settings
         if (auto *value = FindKey(settings.forced_settings, name)) {
             fn(SettingsSpan(*value), Source::FORCED);
         }
         // Merge in the command-line options
         if (auto *values = FindKey(settings.command_line_options, name)) {
             fn(SettingsSpan(*values), Source::COMMAND_LINE);
         }
         // Merge in the read-write settings
         if (const SettingsValue *value = FindKey(settings.rw_settings, name)) {
             fn(SettingsSpan(*value), Source::RW_SETTINGS);
         }
         // Merge in the network-specific section of the config file
         if (!section.empty()) {
             if (auto *map = FindKey(settings.ro_config, section)) {
                 if (auto *values = FindKey(*map, name)) {
                     fn(SettingsSpan(*values),
                        Source::CONFIG_FILE_NETWORK_SECTION);
                 }
             }
         }
         // Merge in the default section of the config file
         if (auto *map = FindKey(settings.ro_config, "")) {
             if (auto *values = FindKey(*map, name)) {
                 fn(SettingsSpan(*values), Source::CONFIG_FILE_DEFAULT_SECTION);
             }
         }
     }
 } // namespace
 
 bool ReadSettings(const fs::path &path,
                   std::map<std::string, SettingsValue> &values,
                   std::vector<std::string> &errors) {
     values.clear();
     errors.clear();
 
     // Ok for file to not exist
     if (!fs::exists(path)) {
         return true;
     }
 
-    fsbridge::ifstream file;
+    std::ifstream file;
     file.open(path);
     if (!file.is_open()) {
         errors.emplace_back(
             strprintf("%s. Please check permissions.", fs::PathToString(path)));
         return false;
     }
 
     SettingsValue in;
     if (!in.read(std::string{std::istreambuf_iterator<char>(file),
                              std::istreambuf_iterator<char>()})) {
         errors.emplace_back(strprintf("Unable to parse settings file %s",
                                       fs::PathToString(path)));
         return false;
     }
 
     if (file.fail()) {
         errors.emplace_back(strprintf("Failed reading settings file %s",
                                       fs::PathToString(path)));
         return false;
     }
     // Done with file descriptor. Release while copying data.
     file.close();
 
     if (!in.isObject()) {
         errors.emplace_back(
             strprintf("Found non-object value %s in settings file %s",
                       in.write(), fs::PathToString(path)));
         return false;
     }
 
     const std::vector<std::string> &in_keys = in.getKeys();
     const std::vector<SettingsValue> &in_values = in.getValues();
     for (size_t i = 0; i < in_keys.size(); ++i) {
         auto inserted = values.emplace(in_keys[i], in_values[i]);
         if (!inserted.second) {
             errors.emplace_back(
                 strprintf("Found duplicate key %s in settings file %s",
                           in_keys[i], fs::PathToString(path)));
         }
     }
     return errors.empty();
 }
 
 bool WriteSettings(const fs::path &path,
                    const std::map<std::string, SettingsValue> &values,
                    std::vector<std::string> &errors) {
     SettingsValue out(SettingsValue::VOBJ);
     for (const auto &value : values) {
         out.__pushKV(value.first, value.second);
     }
-    fsbridge::ofstream file;
+    std::ofstream file;
     file.open(path);
     if (file.fail()) {
         errors.emplace_back(
             strprintf("Error: Unable to open settings file %s for writing",
                       fs::PathToString(path)));
         return false;
     }
     file << out.write(/* prettyIndent= */ 1, /* indentLevel= */ 4) << std::endl;
     file.close();
     return true;
 }
 
 SettingsValue GetSetting(const Settings &settings, const std::string &section,
                          const std::string &name,
                          bool ignore_default_section_config,
                          bool get_chain_name) {
     SettingsValue result;
     // Done merging any more settings sources.
     bool done = false;
     MergeSettings(
         settings, section, name, [&](SettingsSpan span, Source source) {
             // Weird behavior preserved for backwards compatibility: Apply
             // negated setting even if non-negated setting would be ignored. A
             // negated value in the default section is applied to network
             // specific options, even though normal non-negated values there
             // would be ignored.
             const bool never_ignore_negated_setting = span.last_negated();
 
             // Weird behavior preserved for backwards compatibility: Take first
             // assigned value instead of last. In general, later settings take
             // precedence over early settings, but for backwards compatibility
             // in the config file the precedence is reversed for all settings
             // except chain name settings.
             const bool reverse_precedence =
                 (source == Source::CONFIG_FILE_NETWORK_SECTION ||
                  source == Source::CONFIG_FILE_DEFAULT_SECTION) &&
                 !get_chain_name;
 
             // Weird behavior preserved for backwards compatibility: Negated
             // -regtest and -testnet arguments which you would expect to
             // override values set in the configuration file are currently
             // accepted but silently ignored. It would be better to apply these
             // just like other negated values, or at least warn they are
             // ignored.
             const bool skip_negated_command_line = get_chain_name;
 
             if (done) {
                 return;
             }
 
             // Ignore settings in default config section if requested.
             if (ignore_default_section_config &&
                 source == Source::CONFIG_FILE_DEFAULT_SECTION &&
                 !never_ignore_negated_setting) {
                 return;
             }
 
             // Skip negated command line settings.
             if (skip_negated_command_line && span.last_negated()) {
                 return;
             }
 
             if (!span.empty()) {
                 result = reverse_precedence ? span.begin()[0] : span.end()[-1];
                 done = true;
             } else if (span.last_negated()) {
                 result = false;
                 done = true;
             }
         });
     return result;
 }
 
 std::vector<SettingsValue> GetSettingsList(const Settings &settings,
                                            const std::string &section,
                                            const std::string &name,
                                            bool ignore_default_section_config) {
     std::vector<SettingsValue> result;
     // Done merging any more settings sources.
     bool done = false;
     bool prev_negated_empty = false;
     MergeSettings(
         settings, section, name, [&](SettingsSpan span, Source source) {
             // Weird behavior preserved for backwards compatibility: Apply
             // config file settings even if negated on command line. Negating a
             // setting on command line will ignore earlier settings on the
             // command line and ignore settings in the config file, unless the
             // negated command line value is followed by non-negated value, in
             // which case config file settings will be brought back from the
             // dead (but earlier command line settings will still be ignored).
             const bool add_zombie_config_values =
                 (source == Source::CONFIG_FILE_NETWORK_SECTION ||
                  source == Source::CONFIG_FILE_DEFAULT_SECTION) &&
                 !prev_negated_empty;
 
             // Ignore settings in default config section if requested.
             if (ignore_default_section_config &&
                 source == Source::CONFIG_FILE_DEFAULT_SECTION) {
                 return;
             }
 
             // Add new settings to the result if isn't already complete, or if
             // the values are zombies.
             if (!done || add_zombie_config_values) {
                 for (const auto &value : span) {
                     if (value.isArray()) {
                         result.insert(result.end(), value.getValues().begin(),
                                       value.getValues().end());
                     } else {
                         result.push_back(value);
                     }
                 }
             }
 
             // If a setting was negated, or if a setting was forced, set done to
             // true to ignore any later lower priority settings.
             done |= span.negated() > 0 || source == Source::FORCED;
 
             // Update the negated and empty state used for the zombie values
             // check.
             prev_negated_empty |= span.last_negated() && result.empty();
         });
     return result;
 }
 
 bool OnlyHasDefaultSectionSetting(const Settings &settings,
                                   const std::string &section,
                                   const std::string &name) {
     bool has_default_section_setting = false;
     bool has_other_setting = false;
     MergeSettings(
         settings, section, name, [&](SettingsSpan span, Source source) {
             if (span.empty()) {
                 return;
             } else if (source == Source::CONFIG_FILE_DEFAULT_SECTION) {
                 has_default_section_setting = true;
             } else {
                 has_other_setting = true;
             }
         });
     // If a value is set in the default section and not explicitly overwritten
     // by the user on the command line or in a different section, then we want
     // to enable warnings about the value being ignored.
     return has_default_section_setting && !has_other_setting;
 }
 
 SettingsSpan::SettingsSpan(const std::vector<SettingsValue> &vec) noexcept
     : SettingsSpan(vec.data(), vec.size()) {}
 const SettingsValue *SettingsSpan::begin() const {
     return data + negated();
 }
 const SettingsValue *SettingsSpan::end() const {
     return data + size;
 }
 bool SettingsSpan::empty() const {
     return size == 0 || last_negated();
 }
 bool SettingsSpan::last_negated() const {
     return size > 0 && data[size - 1].isFalse();
 }
 size_t SettingsSpan::negated() const {
     for (size_t i = size; i > 0; --i) {
         if (data[i - 1].isFalse()) {
             // Return number of negated values (position of last false value)
             return i;
         }
     }
     return 0;
 }
 
 } // namespace util
diff --git a/src/util/system.cpp b/src/util/system.cpp
index d5738b9d0..538c26f70 100644
--- a/src/util/system.cpp
+++ b/src/util/system.cpp
@@ -1,1426 +1,1419 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <util/system.h>
 
 #include <chainparamsbase.h>
+#include <fs.h>
 #include <sync.h>
 #include <util/getuniquepath.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/translation.h>
 
 #include <univalue.h>
 
+#include <fstream>
 #include <memory>
+#include <optional>
+#include <string>
 #include <thread>
 #include <typeinfo>
 
 #if (defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__))
 #include <pthread.h>
 #include <pthread_np.h>
 #endif
 
 #ifndef WIN32
 // for posix_fallocate, in config/CMakeLists.txt we check if it is present after
 // this
 #ifdef __linux__
 
 #ifdef _POSIX_C_SOURCE
 #undef _POSIX_C_SOURCE
 #endif
 
 #define _POSIX_C_SOURCE 200112L
 
 #endif // __linux__
 
 #include <algorithm>
 #include <cassert>
 #include <fcntl.h>
 #include <sched.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 
 #else
 
 #ifdef _MSC_VER
 #pragma warning(disable : 4786)
 #pragma warning(disable : 4804)
 #pragma warning(disable : 4805)
 #pragma warning(disable : 4717)
 #endif
 
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 #include <codecvt>
 
 #include <io.h> /* for _commit */
 #include <shellapi.h>
 #include <shlobj.h>
 #endif
 
 #ifdef HAVE_MALLOPT_ARENA_MAX
 #include <malloc.h>
 #endif
 
 // Application startup time (used for uptime calculation)
 const int64_t nStartupTime = GetTime();
 
 const char *const BITCOIN_CONF_FILENAME = "bitcoin.conf";
 const char *const BITCOIN_SETTINGS_FILENAME = "settings.json";
 
 ArgsManager gArgs;
 
 /** Mutex to protect dir_locks. */
 static Mutex cs_dir_locks;
 /**
  * A map that contains all the currently held directory locks. After successful
  * locking, these will be held here until the global destructor cleans them up
  * and thus automatically unlocks them, or ReleaseDirectoryLocks is called.
  */
 static std::map<std::string, std::unique_ptr<fsbridge::FileLock>>
     dir_locks GUARDED_BY(cs_dir_locks);
 
 bool LockDirectory(const fs::path &directory, const std::string lockfile_name,
                    bool probe_only) {
     LOCK(cs_dir_locks);
     fs::path pathLockFile = directory / lockfile_name;
 
     // If a lock for this directory already exists in the map, don't try to
     // re-lock it
     if (dir_locks.count(fs::PathToString(pathLockFile))) {
         return true;
     }
 
     // Create empty lock file if it doesn't exist.
     FILE *file = fsbridge::fopen(pathLockFile, "a");
     if (file) {
         fclose(file);
     }
     auto lock = std::make_unique<fsbridge::FileLock>(pathLockFile);
     if (!lock->TryLock()) {
         return error("Error while attempting to lock directory %s: %s",
                      fs::PathToString(directory), lock->GetReason());
     }
     if (!probe_only) {
         // Lock successful and we're not just probing, put it into the map
         dir_locks.emplace(fs::PathToString(pathLockFile), std::move(lock));
     }
     return true;
 }
 
 void UnlockDirectory(const fs::path &directory,
                      const std::string &lockfile_name) {
     LOCK(cs_dir_locks);
     dir_locks.erase(fs::PathToString(directory / lockfile_name));
 }
 
 void ReleaseDirectoryLocks() {
     LOCK(cs_dir_locks);
     dir_locks.clear();
 }
 
 bool DirIsWritable(const fs::path &directory) {
     fs::path tmpFile = GetUniquePath(directory);
 
     FILE *file = fsbridge::fopen(tmpFile, "a");
     if (!file) {
         return false;
     }
 
     fclose(file);
     remove(tmpFile);
 
     return true;
 }
 
 bool CheckDiskSpace(const fs::path &dir, uint64_t additional_bytes) {
     // 50 MiB
     constexpr uint64_t min_disk_space = 52428800;
 
     uint64_t free_bytes_available = fs::space(dir).available;
     return free_bytes_available >= min_disk_space + additional_bytes;
 }
 
 std::streampos GetFileSize(const char *path, std::streamsize max) {
-    fsbridge::ifstream file{path, std::ios::binary};
+    std::ifstream file{path, std::ios::binary};
     file.ignore(max);
     return file.gcount();
 }
 
 /**
  * Interpret a string argument as a boolean.
  *
  * The definition of atoi() requires that non-numeric string values like "foo",
  * return 0. This means that if a user unintentionally supplies a non-integer
  * argument here, the return value is always false. This means that -foo=false
  * does what the user probably expects, but -foo=true is well defined but does
  * not do what they probably expected.
  *
  * The return value of atoi() is undefined when given input not representable as
  * an int. On most systems this means string value between "-2147483648" and
  * "2147483647" are well defined (this method will return true). Setting
  * -txindex=2147483648 on most systems, however, is probably undefined.
  *
  * For a more extensive discussion of this topic (and a wide range of opinions
  * on the Right Way to change this code), see PR12713.
  */
 static bool InterpretBool(const std::string &strValue) {
     if (strValue.empty()) {
         return true;
     }
     return (atoi(strValue) != 0);
 }
 
 static std::string SettingName(const std::string &arg) {
     return arg.size() > 0 && arg[0] == '-' ? arg.substr(1) : arg;
 }
 
 /**
  * Interpret -nofoo as if the user supplied -foo=0.
  *
  * This method also tracks when the -no form was supplied, and if so, checks
  * whether there was a double-negative (-nofoo=0 -> -foo=1).
  *
  * If there was not a double negative, it removes the "no" from the key
  * and returns false.
  *
  * If there was a double negative, it removes "no" from the key, and
  * returns true.
  *
  * If there was no "no", it returns the string value untouched.
  *
  * Where an option was negated can be later checked using the IsArgNegated()
  * method. One use case for this is to have a way to disable options that are
  * not normally boolean (e.g. using -nodebuglogfile to request that debug log
  * output is not sent to any file at all).
  */
 
 static util::SettingsValue InterpretOption(std::string &section,
                                            std::string &key,
                                            const std::string &value) {
     // Split section name from key name for keys like "testnet.foo" or
     // "regtest.bar"
     size_t option_index = key.find('.');
     if (option_index != std::string::npos) {
         section = key.substr(0, option_index);
         key.erase(0, option_index + 1);
     }
     if (key.substr(0, 2) == "no") {
         key.erase(0, 2);
         // Double negatives like -nofoo=0 are supported (but discouraged)
         if (!InterpretBool(value)) {
             LogPrintf("Warning: parsed potentially confusing double-negative "
                       "-%s=%s\n",
                       key, value);
             return true;
         }
         return false;
     }
     return value;
 }
 
 /**
  * Check settings value validity according to flags.
  *
  * TODO: Add more meaningful error checks here in the future
  * See "here's how the flags are meant to behave" in
  * https://github.com/bitcoin/bitcoin/pull/16097#issuecomment-514627823
  */
 static bool CheckValid(const std::string &key, const util::SettingsValue &val,
                        unsigned int flags, std::string &error) {
     if (val.isBool() && !(flags & ArgsManager::ALLOW_BOOL)) {
         error = strprintf(
             "Negating of -%s is meaningless and therefore forbidden", key);
         return false;
     }
     return true;
 }
 
 namespace {
 fs::path StripRedundantLastElementsOfPath(const fs::path &path) {
     auto result = path;
-    while (fs::PathToString(result.filename()) == ".") {
+    while (result.filename().empty() ||
+           fs::PathToString(result.filename()) == ".") {
         result = result.parent_path();
     }
 
     assert(fs::equivalent(result, path));
     return result;
 }
 } // namespace
 
 // Define default constructor and destructor that are not inline, so code
 // instantiating this class doesn't need to #include class definitions for all
 // members. For example, m_settings has an internal dependency on univalue.
 ArgsManager::ArgsManager() {}
 ArgsManager::~ArgsManager() {}
 
 const std::set<std::string> ArgsManager::GetUnsuitableSectionOnlyArgs() const {
     std::set<std::string> unsuitables;
 
     LOCK(cs_args);
 
     // if there's no section selected, don't worry
     if (m_network.empty()) {
         return std::set<std::string>{};
     }
 
     // if it's okay to use the default section for this network, don't worry
     if (m_network == CBaseChainParams::MAIN) {
         return std::set<std::string>{};
     }
 
     for (const auto &arg : m_network_only_args) {
         if (OnlyHasDefaultSectionSetting(m_settings, m_network,
                                          SettingName(arg))) {
             unsuitables.insert(arg);
         }
     }
     return unsuitables;
 }
 
 const std::list<SectionInfo> ArgsManager::GetUnrecognizedSections() const {
     // Section names to be recognized in the config file.
     static const std::set<std::string> available_sections{
         CBaseChainParams::REGTEST, CBaseChainParams::TESTNET,
         CBaseChainParams::MAIN};
 
     LOCK(cs_args);
     std::list<SectionInfo> unrecognized = m_config_sections;
     unrecognized.remove_if([](const SectionInfo &appeared) {
         return available_sections.find(appeared.m_name) !=
                available_sections.end();
     });
     return unrecognized;
 }
 
 void ArgsManager::SelectConfigNetwork(const std::string &network) {
     LOCK(cs_args);
     m_network = network;
 }
 
 bool ParseKeyValue(std::string &key, std::string &val) {
     size_t is_index = key.find('=');
     if (is_index != std::string::npos) {
         val = key.substr(is_index + 1);
         key.erase(is_index);
     }
 #ifdef WIN32
     key = ToLower(key);
     if (key[0] == '/') {
         key[0] = '-';
     }
 #endif
 
     if (key[0] != '-') {
         return false;
     }
 
     // Transform --foo to -foo
     if (key.length() > 1 && key[1] == '-') {
         key.erase(0, 1);
     }
     return true;
 }
 
 bool ArgsManager::ParseParameters(int argc, const char *const argv[],
                                   std::string &error) {
     LOCK(cs_args);
     m_settings.command_line_options.clear();
 
     for (int i = 1; i < argc; i++) {
         std::string key(argv[i]);
 
 #ifdef MAC_OSX
         // At the first time when a user gets the "App downloaded from the
         // internet" warning, and clicks the Open button, macOS passes
         // a unique process serial number (PSN) as -psn_... command-line
         // argument, which we filter out.
         if (key.substr(0, 5) == "-psn_") {
             continue;
         }
 #endif
 
         if (key == "-") {
             // bitcoin-tx using stdin
             break;
         }
         std::string val;
         if (!ParseKeyValue(key, val)) {
             break;
         }
 
         // Transform -foo to foo
         key.erase(0, 1);
         std::string section;
         util::SettingsValue value = InterpretOption(section, key, val);
         std::optional<unsigned int> flags = GetArgFlags('-' + key);
 
         // Unknown command line options and command line options with dot
         // characters (which are returned from InterpretOption with nonempty
         // section strings) are not valid.
         if (!flags || !section.empty()) {
             error = strprintf("Invalid parameter %s", argv[i]);
             return false;
         }
 
         if (!CheckValid(key, value, *flags, error)) {
             return false;
         }
 
         m_settings.command_line_options[key].push_back(value);
     }
 
     // we do not allow -includeconf from command line
     bool success = true;
     if (auto *includes =
             util::FindKey(m_settings.command_line_options, "includeconf")) {
         for (const auto &include : util::SettingsSpan(*includes)) {
             error +=
                 "-includeconf cannot be used from commandline; -includeconf=" +
                 include.get_str() + "\n";
             success = false;
         }
     }
     return success;
 }
 
 std::optional<unsigned int>
 ArgsManager::GetArgFlags(const std::string &name) const {
     LOCK(cs_args);
     for (const auto &arg_map : m_available_args) {
         const auto search = arg_map.second.find(name);
         if (search != arg_map.second.end()) {
             return search->second.m_flags;
         }
     }
     return std::nullopt;
 }
 
 const fs::path &ArgsManager::GetBlocksDirPath() const {
     LOCK(cs_args);
     fs::path &path = m_cached_blocks_path;
 
     // Cache the path to avoid calling fs::create_directories on every call of
     // this function
     if (!path.empty()) {
         return path;
     }
 
     if (IsArgSet("-blocksdir")) {
-        path =
-            fs::system_complete(fs::PathFromString(GetArg("-blocksdir", "")));
+        path = fs::absolute(fs::PathFromString(GetArg("-blocksdir", "")));
         if (!fs::is_directory(path)) {
             path = "";
             return path;
         }
     } else {
         path = GetDataDirBase();
     }
 
     path /= fs::PathFromString(BaseParams().DataDir());
     path /= "blocks";
     fs::create_directories(path);
-    path = StripRedundantLastElementsOfPath(path);
     return path;
 }
 
 const fs::path &ArgsManager::GetDataDir(bool net_specific) const {
     LOCK(cs_args);
     fs::path &path =
         net_specific ? m_cached_network_datadir_path : m_cached_datadir_path;
 
     // Cache the path to avoid calling fs::create_directories on every call of
     // this function
     if (!path.empty()) {
         return path;
     }
     std::string datadir = GetArg("-datadir", "");
     if (!datadir.empty()) {
-        path = fs::system_complete(fs::PathFromString(datadir));
+        path = fs::absolute(
+            StripRedundantLastElementsOfPath(fs::PathFromString(datadir)));
         if (!fs::is_directory(path)) {
             path = "";
             return path;
         }
     } else {
         path = GetDefaultDataDir();
     }
 
     if (!fs::exists(path)) {
         fs::create_directories(path / "wallets");
     }
 
     if (net_specific && !BaseParams().DataDir().empty()) {
         path /= fs::PathFromString(BaseParams().DataDir());
         if (!fs::exists(path)) {
             fs::create_directories(path / "wallets");
         }
     }
 
     path = StripRedundantLastElementsOfPath(path);
     return path;
 }
 
 void ArgsManager::ClearPathCache() {
     LOCK(cs_args);
 
     m_cached_datadir_path = fs::path();
     m_cached_network_datadir_path = fs::path();
     m_cached_blocks_path = fs::path();
 }
 
 std::vector<std::string> ArgsManager::GetArgs(const std::string &strArg) const {
     std::vector<std::string> result;
     for (const util::SettingsValue &value : GetSettingsList(strArg)) {
         result.push_back(value.isFalse()  ? "0"
                          : value.isTrue() ? "1"
                                           : value.get_str());
     }
     return result;
 }
 
 bool ArgsManager::IsArgSet(const std::string &strArg) const {
     return !GetSetting(strArg).isNull();
 }
 
 bool ArgsManager::InitSettings(std::string &error) {
     if (!GetSettingsPath()) {
         return true; // Do nothing if settings file disabled.
     }
 
     std::vector<std::string> errors;
     if (!ReadSettingsFile(&errors)) {
         error = strprintf("Failed loading settings file:\n- %s\n",
                           Join(errors, "\n- "));
         return false;
     }
     if (!WriteSettingsFile(&errors)) {
         error = strprintf("Failed saving settings file:\n- %s\n",
                           Join(errors, "\n- "));
         return false;
     }
     return true;
 }
 
 bool ArgsManager::GetSettingsPath(fs::path *filepath, bool temp) const {
     if (IsArgNegated("-settings")) {
         return false;
     }
     if (filepath) {
         std::string settings = GetArg("-settings", BITCOIN_SETTINGS_FILENAME);
         *filepath = fsbridge::AbsPathJoin(
             GetDataDirNet(),
             fs::PathFromString(temp ? settings + ".tmp" : settings));
     }
     return true;
 }
 
 static void SaveErrors(const std::vector<std::string> errors,
                        std::vector<std::string> *error_out) {
     for (const auto &error : errors) {
         if (error_out) {
             error_out->emplace_back(error);
         } else {
             LogPrintf("%s\n", error);
         }
     }
 }
 
 bool ArgsManager::ReadSettingsFile(std::vector<std::string> *errors) {
     fs::path path;
     if (!GetSettingsPath(&path, /* temp= */ false)) {
         return true; // Do nothing if settings file disabled.
     }
 
     LOCK(cs_args);
     m_settings.rw_settings.clear();
     std::vector<std::string> read_errors;
     if (!util::ReadSettings(path, m_settings.rw_settings, read_errors)) {
         SaveErrors(read_errors, errors);
         return false;
     }
     for (const auto &setting : m_settings.rw_settings) {
         std::string section;
         std::string key = setting.first;
         // Split setting key into section and argname
         (void)InterpretOption(section, key, /* value */ {});
         if (!GetArgFlags('-' + key)) {
             LogPrintf("Ignoring unknown rw_settings value %s\n", setting.first);
         }
     }
     return true;
 }
 
 bool ArgsManager::WriteSettingsFile(std::vector<std::string> *errors) const {
     fs::path path, path_tmp;
     if (!GetSettingsPath(&path, /* temp= */ false) ||
         !GetSettingsPath(&path_tmp, /* temp= */ true)) {
         throw std::logic_error("Attempt to write settings file when dynamic "
                                "settings are disabled.");
     }
 
     LOCK(cs_args);
     std::vector<std::string> write_errors;
     if (!util::WriteSettings(path_tmp, m_settings.rw_settings, write_errors)) {
         SaveErrors(write_errors, errors);
         return false;
     }
     if (!RenameOver(path_tmp, path)) {
         SaveErrors(
             {strprintf("Failed renaming settings file %s to %s\n",
                        fs::PathToString(path_tmp), fs::PathToString(path))},
             errors);
         return false;
     }
     return true;
 }
 
 bool ArgsManager::IsArgNegated(const std::string &strArg) const {
     return GetSetting(strArg).isFalse();
 }
 
 std::string ArgsManager::GetArg(const std::string &strArg,
                                 const std::string &strDefault) const {
     const util::SettingsValue value = GetSetting(strArg);
     return value.isNull()    ? strDefault
            : value.isFalse() ? "0"
            : value.isTrue()  ? "1"
                              : value.get_str();
 }
 
 int64_t ArgsManager::GetIntArg(const std::string &strArg,
                                int64_t nDefault) const {
     const util::SettingsValue value = GetSetting(strArg);
     return value.isNull()    ? nDefault
            : value.isFalse() ? 0
            : value.isTrue()  ? 1
            : value.isNum()   ? value.get_int64()
                              : atoi64(value.get_str());
 }
 
 bool ArgsManager::GetBoolArg(const std::string &strArg, bool fDefault) const {
     const util::SettingsValue value = GetSetting(strArg);
     return value.isNull()   ? fDefault
            : value.isBool() ? value.get_bool()
                             : InterpretBool(value.get_str());
 }
 
 bool ArgsManager::SoftSetArg(const std::string &strArg,
                              const std::string &strValue) {
     LOCK(cs_args);
     if (IsArgSet(strArg)) {
         return false;
     }
     ForceSetArg(strArg, strValue);
     return true;
 }
 
 bool ArgsManager::SoftSetBoolArg(const std::string &strArg, bool fValue) {
     if (fValue) {
         return SoftSetArg(strArg, std::string("1"));
     } else {
         return SoftSetArg(strArg, std::string("0"));
     }
 }
 
 void ArgsManager::ForceSetArg(const std::string &strArg,
                               const std::string &strValue) {
     LOCK(cs_args);
     m_settings.forced_settings[SettingName(strArg)] = strValue;
 }
 
 /**
  * This function is only used for testing purpose so
  * so we should not worry about element uniqueness and
  * integrity of the data structure
  */
 void ArgsManager::ForceSetMultiArg(const std::string &strArg,
                                    const std::vector<std::string> &values) {
     LOCK(cs_args);
     util::SettingsValue value;
     value.setArray();
     for (const std::string &s : values) {
         value.push_back(s);
     }
 
     m_settings.forced_settings[SettingName(strArg)] = value;
 }
 
 void ArgsManager::AddArg(const std::string &name, const std::string &help,
                          unsigned int flags, const OptionsCategory &cat) {
     // Split arg name from its help param
     size_t eq_index = name.find('=');
     if (eq_index == std::string::npos) {
         eq_index = name.size();
     }
     std::string arg_name = name.substr(0, eq_index);
 
     LOCK(cs_args);
     std::map<std::string, Arg> &arg_map = m_available_args[cat];
     auto ret = arg_map.emplace(
         arg_name,
         Arg{name.substr(eq_index, name.size() - eq_index), help, flags});
     // Make sure an insertion actually happened.
     assert(ret.second);
 
     if (flags & ArgsManager::NETWORK_ONLY) {
         m_network_only_args.emplace(arg_name);
     }
 }
 
 void ArgsManager::AddHiddenArgs(const std::vector<std::string> &names) {
     for (const std::string &name : names) {
         AddArg(name, "", ArgsManager::ALLOW_ANY, OptionsCategory::HIDDEN);
     }
 }
 
 void ArgsManager::ClearForcedArg(const std::string &strArg) {
     LOCK(cs_args);
     m_settings.forced_settings.erase(SettingName(strArg));
 }
 
 std::string ArgsManager::GetHelpMessage() const {
     const bool show_debug = GetBoolArg("-help-debug", false);
 
     std::string usage = "";
     LOCK(cs_args);
     for (const auto &arg_map : m_available_args) {
         switch (arg_map.first) {
             case OptionsCategory::OPTIONS:
                 usage += HelpMessageGroup("Options:");
                 break;
             case OptionsCategory::CONNECTION:
                 usage += HelpMessageGroup("Connection options:");
                 break;
             case OptionsCategory::ZMQ:
                 usage += HelpMessageGroup("ZeroMQ notification options:");
                 break;
             case OptionsCategory::DEBUG_TEST:
                 usage += HelpMessageGroup("Debugging/Testing options:");
                 break;
             case OptionsCategory::NODE_RELAY:
                 usage += HelpMessageGroup("Node relay options:");
                 break;
             case OptionsCategory::BLOCK_CREATION:
                 usage += HelpMessageGroup("Block creation options:");
                 break;
             case OptionsCategory::RPC:
                 usage += HelpMessageGroup("RPC server options:");
                 break;
             case OptionsCategory::WALLET:
                 usage += HelpMessageGroup("Wallet options:");
                 break;
             case OptionsCategory::WALLET_DEBUG_TEST:
                 if (show_debug) {
                     usage +=
                         HelpMessageGroup("Wallet debugging/testing options:");
                 }
                 break;
             case OptionsCategory::CHAINPARAMS:
                 usage += HelpMessageGroup("Chain selection options:");
                 break;
             case OptionsCategory::GUI:
                 usage += HelpMessageGroup("UI Options:");
                 break;
             case OptionsCategory::COMMANDS:
                 usage += HelpMessageGroup("Commands:");
                 break;
             case OptionsCategory::REGISTER_COMMANDS:
                 usage += HelpMessageGroup("Register Commands:");
                 break;
             case OptionsCategory::AVALANCHE:
                 usage += HelpMessageGroup("Avalanche options:");
                 break;
             case OptionsCategory::CHRONIK:
                 usage += HelpMessageGroup("Chronik options:");
                 break;
             default:
                 break;
         }
 
         // When we get to the hidden options, stop
         if (arg_map.first == OptionsCategory::HIDDEN) {
             break;
         }
 
         for (const auto &arg : arg_map.second) {
             if (show_debug || !(arg.second.m_flags & ArgsManager::DEBUG_ONLY)) {
                 std::string name;
                 if (arg.second.m_help_param.empty()) {
                     name = arg.first;
                 } else {
                     name = arg.first + arg.second.m_help_param;
                 }
                 usage += HelpMessageOpt(name, arg.second.m_help_text);
             }
         }
     }
     return usage;
 }
 
 bool HelpRequested(const ArgsManager &args) {
     return args.IsArgSet("-?") || args.IsArgSet("-h") ||
            args.IsArgSet("-help") || args.IsArgSet("-help-debug");
 }
 
 void SetupHelpOptions(ArgsManager &args) {
     args.AddArg("-?", "Print this help message and exit", false,
                 OptionsCategory::OPTIONS);
     args.AddHiddenArgs({"-h", "-help"});
 }
 
 static const int screenWidth = 79;
 static const int optIndent = 2;
 static const int msgIndent = 7;
 
 std::string HelpMessageGroup(const std::string &message) {
     return std::string(message) + std::string("\n\n");
 }
 
 std::string HelpMessageOpt(const std::string &option,
                            const std::string &message) {
     return std::string(optIndent, ' ') + std::string(option) +
            std::string("\n") + std::string(msgIndent, ' ') +
            FormatParagraph(message, screenWidth - msgIndent, msgIndent) +
            std::string("\n\n");
 }
 
 static std::string FormatException(const std::exception *pex,
                                    const char *pszThread) {
 #ifdef WIN32
     char pszModule[MAX_PATH] = "";
     GetModuleFileNameA(nullptr, pszModule, sizeof(pszModule));
 #else
     const char *pszModule = "bitcoin";
 #endif
     if (pex) {
         return strprintf("EXCEPTION: %s       \n%s       \n%s in %s       \n",
                          typeid(*pex).name(), pex->what(), pszModule,
                          pszThread);
     } else {
         return strprintf("UNKNOWN EXCEPTION       \n%s in %s       \n",
                          pszModule, pszThread);
     }
 }
 
 void PrintExceptionContinue(const std::exception *pex, const char *pszThread) {
     std::string message = FormatException(pex, pszThread);
     LogPrintf("\n\n************************\n%s\n", message);
     tfm::format(std::cerr, "\n\n************************\n%s\n", message);
 }
 
 fs::path GetDefaultDataDir() {
     // Windows: C:\Users\Username\AppData\Roaming\Bitcoin
     // macOS: ~/Library/Application Support/Bitcoin
     // Unix-like: ~/.bitcoin
 #ifdef WIN32
     // Windows
     return GetSpecialFolderPath(CSIDL_APPDATA) / "Bitcoin";
 #else
     fs::path pathRet;
     char *pszHome = getenv("HOME");
     if (pszHome == nullptr || strlen(pszHome) == 0) {
         pathRet = fs::path("/");
     } else {
         pathRet = fs::path(pszHome);
     }
 #ifdef MAC_OSX
     // macOS
     return pathRet / "Library/Application Support/Bitcoin";
 #else
     // Unix-like
     return pathRet / ".bitcoin";
 #endif
 #endif
 }
 
 bool CheckDataDirOption() {
     std::string datadir = gArgs.GetArg("-datadir", "");
     return datadir.empty() ||
-           fs::is_directory(fs::system_complete(fs::PathFromString(datadir)));
+           fs::is_directory(fs::absolute(fs::PathFromString(datadir)));
 }
 
 fs::path GetConfigFile(const std::string &confPath) {
     return AbsPathForConfigVal(fs::PathFromString(confPath), false);
 }
 
 static bool
 GetConfigOptions(std::istream &stream, const std::string &filepath,
                  std::string &error,
                  std::vector<std::pair<std::string, std::string>> &options,
                  std::list<SectionInfo> &sections) {
     std::string str, prefix;
     std::string::size_type pos;
     int linenr = 1;
     while (std::getline(stream, str)) {
         bool used_hash = false;
         if ((pos = str.find('#')) != std::string::npos) {
             str = str.substr(0, pos);
             used_hash = true;
         }
         const static std::string pattern = " \t\r\n";
         str = TrimString(str, pattern);
         if (!str.empty()) {
             if (*str.begin() == '[' && *str.rbegin() == ']') {
                 const std::string section = str.substr(1, str.size() - 2);
                 sections.emplace_back(SectionInfo{section, filepath, linenr});
                 prefix = section + '.';
             } else if (*str.begin() == '-') {
                 error = strprintf(
                     "parse error on line %i: %s, options in configuration file "
                     "must be specified without leading -",
                     linenr, str);
                 return false;
             } else if ((pos = str.find('=')) != std::string::npos) {
                 std::string name =
                     prefix + TrimString(str.substr(0, pos), pattern);
                 std::string value = TrimString(str.substr(pos + 1), pattern);
                 if (used_hash &&
                     name.find("rpcpassword") != std::string::npos) {
                     error = strprintf(
                         "parse error on line %i, using # in rpcpassword can be "
                         "ambiguous and should be avoided",
                         linenr);
                     return false;
                 }
                 options.emplace_back(name, value);
                 if ((pos = name.rfind('.')) != std::string::npos &&
                     prefix.length() <= pos) {
                     sections.emplace_back(
                         SectionInfo{name.substr(0, pos), filepath, linenr});
                 }
             } else {
                 error = strprintf("parse error on line %i: %s", linenr, str);
                 if (str.size() >= 2 && str.substr(0, 2) == "no") {
                     error += strprintf(", if you intended to specify a negated "
                                        "option, use %s=1 instead",
                                        str);
                 }
                 return false;
             }
         }
         ++linenr;
     }
     return true;
 }
 
 bool ArgsManager::ReadConfigStream(std::istream &stream,
                                    const std::string &filepath,
                                    std::string &error,
                                    bool ignore_invalid_keys) {
     LOCK(cs_args);
     std::vector<std::pair<std::string, std::string>> options;
     if (!GetConfigOptions(stream, filepath, error, options,
                           m_config_sections)) {
         return false;
     }
     for (const std::pair<std::string, std::string> &option : options) {
         std::string section;
         std::string key = option.first;
         util::SettingsValue value =
             InterpretOption(section, key, option.second);
         std::optional<unsigned int> flags = GetArgFlags('-' + key);
         if (flags) {
             if (!CheckValid(key, value, *flags, error)) {
                 return false;
             }
             m_settings.ro_config[section][key].push_back(value);
         } else {
             if (ignore_invalid_keys) {
                 LogPrintf("Ignoring unknown configuration value %s\n",
                           option.first);
             } else {
                 error = strprintf("Invalid configuration value %s",
                                   option.first.c_str());
                 return false;
             }
         }
     }
     return true;
 }
 
 bool ArgsManager::ReadConfigFiles(std::string &error,
                                   bool ignore_invalid_keys) {
     {
         LOCK(cs_args);
         m_settings.ro_config.clear();
         m_config_sections.clear();
     }
 
     const std::string confPath = GetArg("-conf", BITCOIN_CONF_FILENAME);
-    fsbridge::ifstream stream(GetConfigFile(confPath));
+    std::ifstream stream{GetConfigFile(confPath)};
 
     // ok to not have a config file
     if (stream.good()) {
         if (!ReadConfigStream(stream, confPath, error, ignore_invalid_keys)) {
             return false;
         }
         // `-includeconf` cannot be included in the command line arguments
         // except as `-noincludeconf` (which indicates that no included conf
         // file should be used).
         bool use_conf_file{true};
         {
             LOCK(cs_args);
             if (auto *includes = util::FindKey(m_settings.command_line_options,
                                                "includeconf")) {
                 // ParseParameters() fails if a non-negated -includeconf is
                 // passed on the command-line
                 assert(util::SettingsSpan(*includes).last_negated());
                 use_conf_file = false;
             }
         }
         if (use_conf_file) {
             std::string chain_id = GetChainName();
             std::vector<std::string> conf_file_names;
 
             auto add_includes = [&](const std::string &network,
                                     size_t skip = 0) {
                 size_t num_values = 0;
                 LOCK(cs_args);
                 if (auto *section =
                         util::FindKey(m_settings.ro_config, network)) {
                     if (auto *values = util::FindKey(*section, "includeconf")) {
                         for (size_t i = std::max(
                                  skip, util::SettingsSpan(*values).negated());
                              i < values->size(); ++i) {
                             conf_file_names.push_back((*values)[i].get_str());
                         }
                         num_values = values->size();
                     }
                 }
                 return num_values;
             };
 
             // We haven't set m_network yet (that happens in SelectParams()), so
             // manually check for network.includeconf args.
             const size_t chain_includes = add_includes(chain_id);
             const size_t default_includes = add_includes({});
 
             for (const std::string &conf_file_name : conf_file_names) {
-                fsbridge::ifstream conf_file_stream(
-                    GetConfigFile(conf_file_name));
+                std::ifstream conf_file_stream{GetConfigFile(conf_file_name)};
                 if (conf_file_stream.good()) {
                     if (!ReadConfigStream(conf_file_stream, conf_file_name,
                                           error, ignore_invalid_keys)) {
                         return false;
                     }
                     LogPrintf("Included configuration file %s\n",
                               conf_file_name);
                 } else {
                     error = "Failed to include configuration file " +
                             conf_file_name;
                     return false;
                 }
             }
 
             // Warn about recursive -includeconf
             conf_file_names.clear();
             add_includes(chain_id, /* skip= */ chain_includes);
             add_includes({}, /* skip= */ default_includes);
             std::string chain_id_final = GetChainName();
             if (chain_id_final != chain_id) {
                 // Also warn about recursive includeconf for the chain that was
                 // specified in one of the includeconfs
                 add_includes(chain_id_final);
             }
             for (const std::string &conf_file_name : conf_file_names) {
                 tfm::format(std::cerr,
                             "warning: -includeconf cannot be used from "
                             "included files; ignoring -includeconf=%s\n",
                             conf_file_name);
             }
         }
     }
 
     // If datadir is changed in .conf file:
     gArgs.ClearPathCache();
     if (!CheckDataDirOption()) {
         error = strprintf("specified data directory \"%s\" does not exist.",
                           GetArg("-datadir", "").c_str());
         return false;
     }
     return true;
 }
 
 std::string ArgsManager::GetChainName() const {
     auto get_net = [&](const std::string &arg) {
         LOCK(cs_args);
         util::SettingsValue value =
             util::GetSetting(m_settings, /* section= */ "", SettingName(arg),
                              /* ignore_default_section_config= */ false,
                              /* get_chain_name= */ true);
         return value.isNull()   ? false
                : value.isBool() ? value.get_bool()
                                 : InterpretBool(value.get_str());
     };
 
     const bool fRegTest = get_net("-regtest");
     const bool fTestNet = get_net("-testnet");
     const bool is_chain_arg_set = IsArgSet("-chain");
 
     if (int(is_chain_arg_set) + int(fRegTest) + int(fTestNet) > 1) {
         throw std::runtime_error("Invalid combination of -regtest, -testnet "
                                  "and -chain. Can use at most one.");
     }
     if (fRegTest) {
         return CBaseChainParams::REGTEST;
     }
     if (fTestNet) {
         return CBaseChainParams::TESTNET;
     }
     return GetArg("-chain", CBaseChainParams::MAIN);
 }
 
 bool ArgsManager::UseDefaultSection(const std::string &arg) const {
     return m_network == CBaseChainParams::MAIN ||
            m_network_only_args.count(arg) == 0;
 }
 
 util::SettingsValue ArgsManager::GetSetting(const std::string &arg) const {
     LOCK(cs_args);
     return util::GetSetting(m_settings, m_network, SettingName(arg),
                             !UseDefaultSection(arg),
                             /* get_chain_name= */ false);
 }
 
 std::vector<util::SettingsValue>
 ArgsManager::GetSettingsList(const std::string &arg) const {
     LOCK(cs_args);
     return util::GetSettingsList(m_settings, m_network, SettingName(arg),
                                  !UseDefaultSection(arg));
 }
 
 void ArgsManager::logArgsPrefix(
     const std::string &prefix, const std::string &section,
     const std::map<std::string, std::vector<util::SettingsValue>> &args) const {
     std::string section_str = section.empty() ? "" : "[" + section + "] ";
     for (const auto &arg : args) {
         for (const auto &value : arg.second) {
             std::optional<unsigned int> flags = GetArgFlags('-' + arg.first);
             if (flags) {
                 std::string value_str =
                     (*flags & SENSITIVE) ? "****" : value.write();
                 LogPrintf("%s %s%s=%s\n", prefix, section_str, arg.first,
                           value_str);
             }
         }
     }
 }
 
 void ArgsManager::LogArgs() const {
     LOCK(cs_args);
     for (const auto &section : m_settings.ro_config) {
         logArgsPrefix("Config file arg:", section.first, section.second);
     }
     for (const auto &setting : m_settings.rw_settings) {
         LogPrintf("Setting file arg: %s = %s\n", setting.first,
                   setting.second.write());
     }
     logArgsPrefix("Command-line arg:", "", m_settings.command_line_options);
 }
 
 bool RenameOver(fs::path src, fs::path dest) {
 #ifdef WIN32
     return MoveFileExW(src.wstring().c_str(), dest.wstring().c_str(),
                        MOVEFILE_REPLACE_EXISTING) != 0;
 #else
     int rc = std::rename(src.c_str(), dest.c_str());
     return (rc == 0);
 #endif /* WIN32 */
 }
 
 /**
- * Ignores exceptions thrown by Boost's create_directories if the requested
+ * Ignores exceptions thrown by create_directories if the requested
  * directory exists. Specifically handles case where path p exists, but it
  * wasn't possible for the user to write to the parent directory.
  */
 bool TryCreateDirectories(const fs::path &p) {
     try {
         return fs::create_directories(p);
     } catch (const fs::filesystem_error &) {
         if (!fs::exists(p) || !fs::is_directory(p)) {
             throw;
         }
     }
 
     // create_directory didn't create the directory, it had to have existed
     // already.
     return false;
 }
 
 bool FileCommit(FILE *file) {
     // harmless if redundantly called
     if (fflush(file) != 0) {
         LogPrintf("%s: fflush failed: %d\n", __func__, errno);
         return false;
     }
 #ifdef WIN32
     HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
     if (FlushFileBuffers(hFile) == 0) {
         LogPrintf("%s: FlushFileBuffers failed: %d\n", __func__,
                   GetLastError());
         return false;
     }
 #else
 #if defined(HAVE_FDATASYNC)
     // Ignore EINVAL for filesystems that don't support sync
     if (fdatasync(fileno(file)) != 0 && errno != EINVAL) {
         LogPrintf("%s: fdatasync failed: %d\n", __func__, errno);
         return false;
     }
 #elif defined(MAC_OSX) && defined(F_FULLFSYNC)
     // Manpage says "value other than -1" is returned on success
     if (fcntl(fileno(file), F_FULLFSYNC, 0) == -1) {
         LogPrintf("%s: fcntl F_FULLFSYNC failed: %d\n", __func__, errno);
         return false;
     }
 #else
     if (fsync(fileno(file)) != 0 && errno != EINVAL) {
         LogPrintf("%s: fsync failed: %d\n", __func__, errno);
         return false;
     }
 #endif
 #endif
     return true;
 }
 
 bool TruncateFile(FILE *file, unsigned int length) {
 #if defined(WIN32)
     return _chsize(_fileno(file), length) == 0;
 #else
     return ftruncate(fileno(file), length) == 0;
 #endif
 }
 
 /**
  * This function tries to raise the file descriptor limit to the requested
  * number. It returns the actual file descriptor limit (which may be more or
  * less than nMinFD)
  */
 int RaiseFileDescriptorLimit(int nMinFD) {
 #if defined(WIN32)
     return 8192;
 #else
     struct rlimit limitFD;
     if (getrlimit(RLIMIT_NOFILE, &limitFD) != -1) {
         if (limitFD.rlim_cur < (rlim_t)nMinFD) {
             limitFD.rlim_cur = nMinFD;
             if (limitFD.rlim_cur > limitFD.rlim_max) {
                 limitFD.rlim_cur = limitFD.rlim_max;
             }
             setrlimit(RLIMIT_NOFILE, &limitFD);
             getrlimit(RLIMIT_NOFILE, &limitFD);
         }
         return limitFD.rlim_cur;
     }
     // getrlimit failed, assume it's fine.
     return nMinFD;
 #endif
 }
 
 /**
  * This function tries to make a particular range of a file allocated
  * (corresponding to disk space) it is advisory, and the range specified in the
  * arguments will never contain live data.
  */
 void AllocateFileRange(FILE *file, unsigned int offset, unsigned int length) {
 #if defined(WIN32)
     // Windows-specific version.
     HANDLE hFile = (HANDLE)_get_osfhandle(_fileno(file));
     LARGE_INTEGER nFileSize;
     int64_t nEndPos = (int64_t)offset + length;
     nFileSize.u.LowPart = nEndPos & 0xFFFFFFFF;
     nFileSize.u.HighPart = nEndPos >> 32;
     SetFilePointerEx(hFile, nFileSize, 0, FILE_BEGIN);
     SetEndOfFile(hFile);
 #elif defined(MAC_OSX)
     // OSX specific version
     // NOTE: Contrary to other OS versions, the OSX version assumes that
     // NOTE: offset is the size of the file.
     fstore_t fst;
     fst.fst_flags = F_ALLOCATECONTIG;
     fst.fst_posmode = F_PEOFPOSMODE;
     fst.fst_offset = 0;
     // mac os fst_length takes the number of free bytes to allocate,
     // not the desired file size
     fst.fst_length = length;
     fst.fst_bytesalloc = 0;
     if (fcntl(fileno(file), F_PREALLOCATE, &fst) == -1) {
         fst.fst_flags = F_ALLOCATEALL;
         fcntl(fileno(file), F_PREALLOCATE, &fst);
     }
     ftruncate(fileno(file), static_cast<off_t>(offset) + length);
 #elif defined(HAVE_POSIX_FALLOCATE)
     // Version using posix_fallocate
     off_t nEndPos = (off_t)offset + length;
     posix_fallocate(fileno(file), 0, nEndPos);
 #else
     // Fallback version
     // TODO: just write one byte per block
     static const char buf[65536] = {};
     if (fseek(file, offset, SEEK_SET)) {
         return;
     }
     while (length > 0) {
         unsigned int now = 65536;
         if (length < now) {
             now = length;
         }
         // Allowed to fail; this function is advisory anyway.
         fwrite(buf, 1, now, file);
         length -= now;
     }
 #endif
 }
 
 #ifdef WIN32
 fs::path GetSpecialFolderPath(int nFolder, bool fCreate) {
     WCHAR pszPath[MAX_PATH] = L"";
 
     if (SHGetSpecialFolderPathW(nullptr, pszPath, nFolder, fCreate)) {
         return fs::path(pszPath);
     }
 
     LogPrintf(
         "SHGetSpecialFolderPathW() failed, could not obtain requested path.\n");
     return fs::path("");
 }
 #endif
 
 #ifndef WIN32
 std::string ShellEscape(const std::string &arg) {
     std::string escaped = arg;
     ReplaceAll(escaped, "'", "'\"'\"'");
     return "'" + escaped + "'";
 }
 #endif
 
 #if defined(HAVE_SYSTEM)
 void runCommand(const std::string &strCommand) {
     if (strCommand.empty()) {
         return;
     }
 #ifndef WIN32
     int nErr = ::system(strCommand.c_str());
 #else
     int nErr = ::_wsystem(
         std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t>()
             .from_bytes(strCommand)
             .c_str());
 #endif
     if (nErr) {
         LogPrintf("runCommand error: system(%s) returned %d\n", strCommand,
                   nErr);
     }
 }
 #endif
 
 void SetupEnvironment() {
 #ifdef HAVE_MALLOPT_ARENA_MAX
     // glibc-specific: On 32-bit systems set the number of arenas to 1. By
     // default, since glibc 2.10, the C library will create up to two heap
     // arenas per core. This is known to cause excessive virtual address space
     // usage in our usage. Work around it by setting the maximum number of
     // arenas to 1.
     if (sizeof(void *) == 4) {
         mallopt(M_ARENA_MAX, 1);
     }
 #endif
 // On most POSIX systems (e.g. Linux, but not BSD) the environment's locale may
 // be invalid, in which case the "C.UTF-8" locale is used as fallback.
 #if !defined(WIN32) && !defined(MAC_OSX) && !defined(__FreeBSD__) &&           \
     !defined(__OpenBSD__)
     try {
         // Raises a runtime error if current locale is invalid.
         std::locale("");
     } catch (const std::runtime_error &) {
         setenv("LC_ALL", "C.UTF-8", 1);
     }
 #elif defined(WIN32)
     // Set the default input/output charset is utf-8
     SetConsoleCP(CP_UTF8);
     SetConsoleOutputCP(CP_UTF8);
-#endif
-    // The path locale is lazy initialized and to avoid deinitialization errors
-    // in multithreading environments, it is set explicitly by the main thread.
-    // A dummy locale is used to extract the internal default locale, used by
-    // fs::path, which is then used to explicitly imbue the path.
-    std::locale loc = fs::path::imbue(std::locale::classic());
-#ifndef WIN32
-    fs::path::imbue(loc);
-#else
-    fs::path::imbue(std::locale(loc, new std::codecvt_utf8_utf16<wchar_t>()));
 #endif
 }
 
 bool SetupNetworking() {
 #ifdef WIN32
     // Initialize Windows Sockets.
     WSADATA wsadata;
     int ret = WSAStartup(MAKEWORD(2, 2), &wsadata);
     if (ret != NO_ERROR || LOBYTE(wsadata.wVersion) != 2 ||
         HIBYTE(wsadata.wVersion) != 2) {
         return false;
     }
 #endif
     return true;
 }
 
 int GetNumCores() {
     return std::thread::hardware_concurrency();
 }
 
 std::string CopyrightHolders(const std::string &strPrefix) {
     return strPrefix + strprintf(_(COPYRIGHT_HOLDERS).translated,
                                  COPYRIGHT_HOLDERS_SUBSTITUTION);
 }
 
 // Obtain the application startup time (used for uptime calculation)
 int64_t GetStartupTime() {
     return nStartupTime;
 }
 
 fs::path AbsPathForConfigVal(const fs::path &path, bool net_specific) {
     if (path.is_absolute()) {
         return path;
     }
     return fsbridge::AbsPathJoin(
         net_specific ? gArgs.GetDataDirNet() : gArgs.GetDataDirBase(), path);
 }
 
 void ScheduleBatchPriority() {
 #ifdef SCHED_BATCH
     const static sched_param param{};
     const int rc = pthread_setschedparam(pthread_self(), SCHED_BATCH, &param);
     if (rc != 0) {
         LogPrintf("Failed to pthread_setschedparam: %s\n", strerror(rc));
     }
 #endif
 }
 
 namespace util {
 #ifdef WIN32
 WinCmdLineArgs::WinCmdLineArgs() {
     wchar_t **wargv = CommandLineToArgvW(GetCommandLineW(), &argc);
     std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> utf8_cvt;
     argv = new char *[argc];
     args.resize(argc);
     for (int i = 0; i < argc; i++) {
         args[i] = utf8_cvt.to_bytes(wargv[i]);
         argv[i] = &*args[i].begin();
     }
     LocalFree(wargv);
 }
 
 WinCmdLineArgs::~WinCmdLineArgs() {
     delete[] argv;
 }
 
 std::pair<int, char **> WinCmdLineArgs::get() {
     return std::make_pair(argc, argv);
 }
 #endif
 } // namespace util
diff --git a/src/wallet/bdb.cpp b/src/wallet/bdb.cpp
index 735b49560..b68302b3e 100644
--- a/src/wallet/bdb.cpp
+++ b/src/wallet/bdb.cpp
@@ -1,927 +1,929 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2020 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <fs.h>
 #include <wallet/bdb.h>
 #include <wallet/db.h>
 
 #include <util/strencodings.h>
 #include <util/translation.h>
 
 #include <cstdint>
 #ifndef WIN32
 #include <sys/stat.h>
 #endif
 
 namespace {
 //! Make sure database has a unique fileid within the environment. If it
 //! doesn't, throw an error. BDB caches do not work properly when more than one
 //! open database has the same fileid (values written to one database may show
 //! up in reads to other databases).
 //!
 //! BerkeleyDB generates unique fileids by default
 //! (https://docs.oracle.com/cd/E17275_01/html/programmer_reference/program_copy.html),
 //! so bitcoin should never create different databases with the same fileid, but
 //! this error can be triggered if users manually copy database files.
 void CheckUniqueFileid(const BerkeleyEnvironment &env,
                        const std::string &filename, Db &db,
                        WalletDatabaseFileId &fileid) {
     if (env.IsMock()) {
         return;
     }
 
     int ret = db.get_mpf()->get_fileid(fileid.value);
     if (ret != 0) {
         throw std::runtime_error(
             strprintf("BerkeleyDatabase: Can't open database %s (get_fileid "
                       "failed with %d)",
                       filename, ret));
     }
 
     for (const auto &item : env.m_fileids) {
         if (fileid == item.second && &fileid != &item.second) {
             throw std::runtime_error(
                 strprintf("BerkeleyDatabase: Can't open database %s "
                           "(duplicates fileid %s "
                           "from %s)",
                           filename, HexStr(item.second.value), item.first));
         }
     }
 }
 
 RecursiveMutex cs_db;
 
 //! Map from directory name to db environment.
 std::map<std::string, std::weak_ptr<BerkeleyEnvironment>>
     g_dbenvs GUARDED_BY(cs_db);
 } // namespace
 
 bool WalletDatabaseFileId::operator==(const WalletDatabaseFileId &rhs) const {
     return memcmp(value, &rhs.value, sizeof(value)) == 0;
 }
 
 /**
  * @param[in] wallet_path Path to wallet directory. Or (for backwards
  * compatibility only) a path to a berkeley btree data file inside a wallet
  * directory.
  * @param[out] database_filename Filename of berkeley btree data file inside the
  * wallet directory.
  * @return A shared pointer to the BerkeleyEnvironment object for the wallet
  * directory, never empty because ~BerkeleyEnvironment erases the weak pointer
  * from the g_dbenvs map.
  * @post A new BerkeleyEnvironment weak pointer is inserted into g_dbenvs if the
  * directory path key was not already in the map.
  */
 std::shared_ptr<BerkeleyEnvironment>
 GetWalletEnv(const fs::path &wallet_path, std::string &database_filename) {
     fs::path env_directory;
     SplitWalletPath(wallet_path, env_directory, database_filename);
     LOCK(cs_db);
     auto inserted = g_dbenvs.emplace(fs::PathToString(env_directory),
                                      std::weak_ptr<BerkeleyEnvironment>());
     if (inserted.second) {
         auto env = std::make_shared<BerkeleyEnvironment>(env_directory);
         inserted.first->second = env;
         return env;
     }
     return inserted.first->second.lock();
 }
 
 //
 // BerkeleyBatch
 //
 
 void BerkeleyEnvironment::Close() {
     if (!fDbEnvInit) {
         return;
     }
 
     fDbEnvInit = false;
 
     for (auto &db : m_databases) {
         BerkeleyDatabase &database = db.second.get();
         assert(database.m_refcount <= 0);
         if (database.m_db) {
             database.m_db->close(0);
             database.m_db.reset();
         }
     }
 
     FILE *error_file = nullptr;
     dbenv->get_errfile(&error_file);
 
     int ret = dbenv->close(0);
     if (ret != 0) {
         LogPrintf("BerkeleyEnvironment::Close: Error %d closing database "
                   "environment: %s\n",
                   ret, DbEnv::strerror(ret));
     }
     if (!fMockDb) {
         DbEnv(uint32_t(0)).remove(strPath.c_str(), 0);
     }
 
     if (error_file) {
         fclose(error_file);
     }
 
     UnlockDirectory(fs::PathFromString(strPath), ".walletlock");
 }
 
 void BerkeleyEnvironment::Reset() {
     dbenv.reset(new DbEnv(DB_CXX_NO_EXCEPTIONS));
     fDbEnvInit = false;
     fMockDb = false;
 }
 
 BerkeleyEnvironment::BerkeleyEnvironment(const fs::path &dir_path)
     : strPath(fs::PathToString(dir_path)) {
     Reset();
 }
 
 BerkeleyEnvironment::~BerkeleyEnvironment() {
     LOCK(cs_db);
     g_dbenvs.erase(strPath);
     Close();
 }
 
 bool BerkeleyEnvironment::Open(bilingual_str &err) {
     if (fDbEnvInit) {
         return true;
     }
 
     fs::path pathIn = fs::PathFromString(strPath);
     TryCreateDirectories(pathIn);
     if (!LockDirectory(pathIn, ".walletlock")) {
         LogPrintf("Cannot obtain a lock on wallet directory %s. Another "
                   "instance of bitcoin may be using it.\n",
                   strPath);
         err = strprintf(_("Error initializing wallet database environment %s!"),
                         fs::quoted(fs::PathToString(Directory())));
         return false;
     }
 
     fs::path pathLogDir = pathIn / "database";
     TryCreateDirectories(pathLogDir);
     fs::path pathErrorFile = pathIn / "db.log";
     LogPrintf("BerkeleyEnvironment::Open: LogDir=%s ErrorFile=%s\n",
               fs::PathToString(pathLogDir), fs::PathToString(pathErrorFile));
 
     unsigned int nEnvFlags = 0;
     if (gArgs.GetBoolArg("-privdb", DEFAULT_WALLET_PRIVDB)) {
         nEnvFlags |= DB_PRIVATE;
     }
 
     dbenv->set_lg_dir(fs::PathToString(pathLogDir).c_str());
     // 1 MiB should be enough for just the wallet
     dbenv->set_cachesize(0, 0x100000, 1);
     dbenv->set_lg_bsize(0x10000);
     dbenv->set_lg_max(1048576);
     dbenv->set_lk_max_locks(40000);
     dbenv->set_lk_max_objects(40000);
     /// debug
     dbenv->set_errfile(fsbridge::fopen(pathErrorFile, "a"));
     dbenv->set_flags(DB_AUTO_COMMIT, 1);
     dbenv->set_flags(DB_TXN_WRITE_NOSYNC, 1);
     dbenv->log_set_config(DB_LOG_AUTO_REMOVE, 1);
     int ret =
         dbenv->open(strPath.c_str(),
                     DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL |
                         DB_INIT_TXN | DB_THREAD | DB_RECOVER | nEnvFlags,
                     S_IRUSR | S_IWUSR);
     if (ret != 0) {
         LogPrintf("BerkeleyEnvironment::Open: Error %d opening database "
                   "environment: %s\n",
                   ret, DbEnv::strerror(ret));
         int ret2 = dbenv->close(0);
         if (ret2 != 0) {
             LogPrintf("BerkeleyEnvironment::Open: Error %d closing failed "
                       "database environment: %s\n",
                       ret2, DbEnv::strerror(ret2));
         }
         Reset();
         err = strprintf(_("Error initializing wallet database environment %s!"),
                         fs::quoted(fs::PathToString(Directory())));
         if (ret == DB_RUNRECOVERY) {
             err += Untranslated(" ") +
                    _("This error could occur if this wallet was not shutdown "
                      "cleanly and was last loaded using a build with a newer "
                      "version of Berkeley DB. If so, please use the software "
                      "that last loaded this wallet");
         }
         return false;
     }
 
     fDbEnvInit = true;
     fMockDb = false;
     return true;
 }
 
 //! Construct an in-memory mock Berkeley environment for testing
 BerkeleyEnvironment::BerkeleyEnvironment() {
     Reset();
 
     LogPrint(BCLog::WALLETDB, "BerkeleyEnvironment::MakeMock\n");
 
     dbenv->set_cachesize(1, 0, 1);
     dbenv->set_lg_bsize(10485760 * 4);
     dbenv->set_lg_max(10485760);
     dbenv->set_lk_max_locks(10000);
     dbenv->set_lk_max_objects(10000);
     dbenv->set_flags(DB_AUTO_COMMIT, 1);
     dbenv->log_set_config(DB_LOG_IN_MEMORY, 1);
     int ret =
         dbenv->open(nullptr,
                     DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL |
                         DB_INIT_TXN | DB_THREAD | DB_PRIVATE,
                     S_IRUSR | S_IWUSR);
     if (ret > 0) {
         throw std::runtime_error(
             strprintf("BerkeleyEnvironment::MakeMock: Error %d opening "
                       "database environment.",
                       ret));
     }
 
     fDbEnvInit = true;
     fMockDb = true;
 }
 
 BerkeleyBatch::SafeDbt::SafeDbt() {
     m_dbt.set_flags(DB_DBT_MALLOC);
 }
 
 BerkeleyBatch::SafeDbt::SafeDbt(void *data, size_t size) : m_dbt(data, size) {}
 
 BerkeleyBatch::SafeDbt::~SafeDbt() {
     if (m_dbt.get_data() != nullptr) {
         // Clear memory, e.g. in case it was a private key
         memory_cleanse(m_dbt.get_data(), m_dbt.get_size());
         // under DB_DBT_MALLOC, data is malloced by the Dbt, but must be
         // freed by the caller.
         // https://docs.oracle.com/cd/E17275_01/html/api_reference/C/dbt.html
         if (m_dbt.get_flags() & DB_DBT_MALLOC) {
             free(m_dbt.get_data());
         }
     }
 }
 
 const void *BerkeleyBatch::SafeDbt::get_data() const {
     return m_dbt.get_data();
 }
 
 uint32_t BerkeleyBatch::SafeDbt::get_size() const {
     return m_dbt.get_size();
 }
 
 BerkeleyBatch::SafeDbt::operator Dbt *() {
     return &m_dbt;
 }
 
 bool BerkeleyDatabase::Verify(bilingual_str &errorStr) {
     fs::path walletDir = env->Directory();
     fs::path file_path = walletDir / strFile;
 
     LogPrintf("Using BerkeleyDB version %s\n", BerkeleyDatabaseVersion());
     LogPrintf("Using wallet %s\n", fs::PathToString(file_path));
 
     if (!env->Open(errorStr)) {
         return false;
     }
 
     if (fs::exists(file_path)) {
         assert(m_refcount == 0);
 
         Db db(env->dbenv.get(), 0);
         int result = db.verify(strFile.c_str(), nullptr, nullptr, 0);
         if (result != 0) {
             errorStr =
                 strprintf(_("%s corrupt. Try using the wallet tool "
                             "bitcoin-wallet to salvage or restoring a backup."),
                           fs::quoted(fs::PathToString(file_path)));
             return false;
         }
     }
     // also return true if files does not exists
     return true;
 }
 
 void BerkeleyEnvironment::CheckpointLSN(const std::string &strFile) {
     dbenv->txn_checkpoint(0, 0, 0);
     if (fMockDb) {
         return;
     }
     dbenv->lsn_reset(strFile.c_str(), 0);
 }
 
 BerkeleyDatabase::~BerkeleyDatabase() {
     if (env) {
         LOCK(cs_db);
         env->CloseDb(strFile);
         assert(!m_db);
         size_t erased = env->m_databases.erase(strFile);
         assert(erased == 1);
         env->m_fileids.erase(strFile);
     }
 }
 
 BerkeleyBatch::BerkeleyBatch(BerkeleyDatabase &database, const bool read_only,
                              bool fFlushOnCloseIn)
     : pdb(nullptr), activeTxn(nullptr), m_cursor(nullptr),
       m_database(database) {
     database.AddRef();
     database.Open();
     fReadOnly = read_only;
     fFlushOnClose = fFlushOnCloseIn;
     env = database.env.get();
     pdb = database.m_db.get();
     strFile = database.strFile;
     if (!Exists(std::string("version"))) {
         bool fTmp = fReadOnly;
         fReadOnly = false;
         Write(std::string("version"), CLIENT_VERSION);
         fReadOnly = fTmp;
     }
 }
 
 void BerkeleyDatabase::Open() {
     unsigned int nFlags = DB_THREAD | DB_CREATE;
 
     {
         LOCK(cs_db);
         bilingual_str open_err;
         if (!env->Open(open_err)) {
             throw std::runtime_error(
                 "BerkeleyDatabase: Failed to open database environment.");
         }
 
         if (m_db == nullptr) {
             int ret;
             std::unique_ptr<Db> pdb_temp =
                 std::make_unique<Db>(env->dbenv.get(), 0);
 
             bool fMockDb = env->IsMock();
             if (fMockDb) {
                 DbMpoolFile *mpf = pdb_temp->get_mpf();
                 ret = mpf->set_flags(DB_MPOOL_NOFILE, 1);
                 if (ret != 0) {
                     throw std::runtime_error(strprintf(
                         "BerkeleyDatabase: Failed to configure for no "
                         "temp file backing for database %s",
                         strFile));
                 }
             }
 
             ret = pdb_temp->open(
                 nullptr,                             // Txn pointer
                 fMockDb ? nullptr : strFile.c_str(), // Filename
                 fMockDb ? strFile.c_str() : "main",  // Logical db name
                 DB_BTREE,                            // Database type
                 nFlags,                              // Flags
                 0);
 
             if (ret != 0) {
                 throw std::runtime_error(strprintf(
                     "BerkeleyDatabase: Error %d, can't open database %s", ret,
                     strFile));
             }
 
             // Call CheckUniqueFileid on the containing BDB environment to
             // avoid BDB data consistency bugs that happen when different data
             // files in the same environment have the same fileid.
             CheckUniqueFileid(*env, strFile, *pdb_temp,
                               this->env->m_fileids[strFile]);
 
             m_db.reset(pdb_temp.release());
         }
     }
 }
 
 void BerkeleyBatch::Flush() {
     if (activeTxn) {
         return;
     }
 
     // Flush database activity from memory pool to disk log
     unsigned int nMinutes = 0;
     if (fReadOnly) {
         nMinutes = 1;
     }
 
     // env is nullptr for dummy databases (i.e. in tests). Don't actually flush
     // if env is nullptr so we don't segfault
     if (env) {
         env->dbenv->txn_checkpoint(
             nMinutes
                 ? gArgs.GetIntArg("-dblogsize", DEFAULT_WALLET_DBLOGSIZE) * 1024
                 : 0,
             nMinutes, 0);
     }
 }
 
 void BerkeleyDatabase::IncrementUpdateCounter() {
     ++nUpdateCounter;
 }
 
 BerkeleyBatch::~BerkeleyBatch() {
     Close();
     m_database.RemoveRef();
 }
 
 void BerkeleyBatch::Close() {
     if (!pdb) {
         return;
     }
     if (activeTxn) {
         activeTxn->abort();
     }
     activeTxn = nullptr;
     pdb = nullptr;
     CloseCursor();
 
     if (fFlushOnClose) {
         Flush();
     }
 }
 
 void BerkeleyEnvironment::CloseDb(const std::string &strFile) {
     LOCK(cs_db);
     auto it = m_databases.find(strFile);
     assert(it != m_databases.end());
     BerkeleyDatabase &database = it->second.get();
     if (database.m_db) {
         // Close the database handle
         database.m_db->close(0);
         database.m_db.reset();
     }
 }
 
 void BerkeleyEnvironment::ReloadDbEnv() {
     // Make sure that no Db's are in use
     AssertLockNotHeld(cs_db);
     std::unique_lock<RecursiveMutex> lock(cs_db);
     m_db_in_use.wait(lock, [this]() {
         for (auto &db : m_databases) {
             if (db.second.get().m_refcount > 0) {
                 return false;
             }
         }
         return true;
     });
 
     std::vector<std::string> filenames;
     for (auto it : m_databases) {
         filenames.push_back(it.first);
     }
     // Close the individual Db's
     for (const std::string &filename : filenames) {
         CloseDb(filename);
     }
     // Reset the environment
     // This will flush and close the environment
     Flush(true);
     Reset();
     bilingual_str open_err;
     Open(open_err);
 }
 
 bool BerkeleyDatabase::Rewrite(const char *pszSkip) {
     while (true) {
         {
             LOCK(cs_db);
             if (m_refcount <= 0) {
                 // Flush log data to the dat file
                 env->CloseDb(strFile);
                 env->CheckpointLSN(strFile);
                 m_refcount = -1;
 
                 bool fSuccess = true;
                 LogPrintf("BerkeleyBatch::Rewrite: Rewriting %s...\n", strFile);
                 std::string strFileRes = strFile + ".rewrite";
                 { // surround usage of db with extra {}
                     BerkeleyBatch db(*this, true);
                     std::unique_ptr<Db> pdbCopy =
                         std::make_unique<Db>(env->dbenv.get(), 0);
 
                     int ret = pdbCopy->open(nullptr,            // Txn pointer
                                             strFileRes.c_str(), // Filename
                                             "main",    // Logical db name
                                             DB_BTREE,  // Database type
                                             DB_CREATE, // Flags
                                             0);
                     if (ret > 0) {
                         LogPrintf("BerkeleyBatch::Rewrite: Can't create "
                                   "database file %s\n",
                                   strFileRes);
                         fSuccess = false;
                     }
 
                     if (db.StartCursor()) {
                         while (fSuccess) {
                             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
                             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
                             bool complete;
                             bool ret1 =
                                 db.ReadAtCursor(ssKey, ssValue, complete);
                             if (complete) {
                                 break;
                             }
                             if (!ret1) {
                                 fSuccess = false;
                                 break;
                             }
                             if (pszSkip &&
                                 strncmp(ssKey.data(), pszSkip,
                                         std::min(ssKey.size(),
                                                  strlen(pszSkip))) == 0) {
                                 continue;
                             }
                             if (strncmp(ssKey.data(), "\x07version", 8) == 0) {
                                 // Update version:
                                 ssValue.clear();
                                 ssValue << CLIENT_VERSION;
                             }
                             Dbt datKey(ssKey.data(), ssKey.size());
                             Dbt datValue(ssValue.data(), ssValue.size());
                             int ret2 = pdbCopy->put(nullptr, &datKey, &datValue,
                                                     DB_NOOVERWRITE);
                             if (ret2 > 0) {
                                 fSuccess = false;
                             }
                         }
                         db.CloseCursor();
                     }
                     if (fSuccess) {
                         db.Close();
                         env->CloseDb(strFile);
                         if (pdbCopy->close(0)) {
                             fSuccess = false;
                         }
                     } else {
                         pdbCopy->close(0);
                     }
                 }
                 if (fSuccess) {
                     Db dbA(env->dbenv.get(), 0);
                     if (dbA.remove(strFile.c_str(), nullptr, 0)) {
                         fSuccess = false;
                     }
                     Db dbB(env->dbenv.get(), 0);
                     if (dbB.rename(strFileRes.c_str(), nullptr, strFile.c_str(),
                                    0)) {
                         fSuccess = false;
                     }
                 }
                 if (!fSuccess) {
                     LogPrintf("BerkeleyBatch::Rewrite: Failed to rewrite "
                               "database file %s\n",
                               strFileRes);
                 }
                 return fSuccess;
             }
         }
         UninterruptibleSleep(std::chrono::milliseconds{100});
     }
 }
 
 void BerkeleyEnvironment::Flush(bool fShutdown) {
     int64_t nStart = GetTimeMillis();
     // Flush log data to the actual data file on all files that are not in use
     LogPrint(BCLog::WALLETDB, "BerkeleyEnvironment::Flush: [%s] Flush(%s)%s\n",
              strPath, fShutdown ? "true" : "false",
              fDbEnvInit ? "" : " database not started");
     if (!fDbEnvInit) {
         return;
     }
     {
         LOCK(cs_db);
         bool no_dbs_accessed = true;
         for (auto &db_it : m_databases) {
             std::string strFile = db_it.first;
             int nRefCount = db_it.second.get().m_refcount;
             if (nRefCount < 0) {
                 continue;
             }
             LogPrint(
                 BCLog::WALLETDB,
                 "BerkeleyEnvironment::Flush: Flushing %s (refcount = %d)...\n",
                 strFile, nRefCount);
             if (nRefCount == 0) {
                 // Move log data to the dat file
                 CloseDb(strFile);
                 LogPrint(BCLog::WALLETDB,
                          "BerkeleyEnvironment::Flush: %s checkpoint\n",
                          strFile);
                 dbenv->txn_checkpoint(0, 0, 0);
                 LogPrint(BCLog::WALLETDB,
                          "BerkeleyEnvironment::Flush: %s detach\n", strFile);
                 if (!fMockDb) {
                     dbenv->lsn_reset(strFile.c_str(), 0);
                 }
                 LogPrint(BCLog::WALLETDB,
                          "BerkeleyEnvironment::Flush: %s closed\n", strFile);
                 nRefCount = -1;
             } else {
                 no_dbs_accessed = false;
             }
         }
         LogPrint(BCLog::WALLETDB,
                  "BerkeleyEnvironment::Flush: Flush(%s)%s took %15dms\n",
                  fShutdown ? "true" : "false",
                  fDbEnvInit ? "" : " database not started",
                  GetTimeMillis() - nStart);
         if (fShutdown) {
             char **listp;
             if (no_dbs_accessed) {
                 dbenv->log_archive(&listp, DB_ARCH_REMOVE);
                 Close();
                 if (!fMockDb) {
                     fs::remove_all(fs::PathFromString(strPath) / "database");
                 }
             }
         }
     }
 }
 
 bool BerkeleyDatabase::PeriodicFlush() {
     // Don't flush if we can't acquire the lock.
     TRY_LOCK(cs_db, lockDb);
     if (!lockDb) {
         return false;
     }
 
     // Don't flush if any databases are in use
     for (auto &it : env->m_databases) {
         if (it.second.get().m_refcount > 0) {
             return false;
         }
     }
 
     // Don't flush if there haven't been any batch writes for this database.
     if (m_refcount < 0) {
         return false;
     }
 
     LogPrint(BCLog::WALLETDB, "Flushing %s\n", strFile);
     int64_t nStart = GetTimeMillis();
 
     // Flush wallet file so it's self contained
     env->CloseDb(strFile);
     env->CheckpointLSN(strFile);
     m_refcount = -1;
 
     LogPrint(BCLog::WALLETDB, "Flushed %s %dms\n", strFile,
              GetTimeMillis() - nStart);
 
     return true;
 }
 
 bool BerkeleyDatabase::Backup(const std::string &strDest) const {
     while (true) {
         {
             LOCK(cs_db);
             if (m_refcount <= 0) {
                 // Flush log data to the dat file
                 env->CloseDb(strFile);
                 env->CheckpointLSN(strFile);
 
                 // Copy wallet file.
                 fs::path pathSrc = env->Directory() / strFile;
                 fs::path pathDest(fs::PathFromString(strDest));
                 if (fs::is_directory(pathDest)) {
                     pathDest /= fs::PathFromString(strFile);
                 }
 
                 try {
-                    if (fs::equivalent(pathSrc, pathDest)) {
+                    if (fs::exists(pathDest) &&
+                        fs::equivalent(pathSrc, pathDest)) {
                         LogPrintf("cannot backup to wallet source file %s\n",
                                   fs::PathToString(pathDest));
                         return false;
                     }
 
                     fs::copy_file(pathSrc, pathDest,
-                                  fs::copy_option::overwrite_if_exists);
+                                  fs::copy_options::overwrite_existing);
                     LogPrintf("copied %s to %s\n", strFile,
                               fs::PathToString(pathDest));
                     return true;
                 } catch (const fs::filesystem_error &e) {
                     LogPrintf("error copying %s to %s - %s\n", strFile,
                               fs::PathToString(pathDest),
                               fsbridge::get_filesystem_error_message(e));
                     return false;
                 }
             }
         }
         UninterruptibleSleep(std::chrono::milliseconds{100});
     }
 }
 
 void BerkeleyDatabase::Flush() {
     env->Flush(false);
 }
 
 void BerkeleyDatabase::Close() {
     env->Flush(true);
 }
 
 void BerkeleyDatabase::ReloadDbEnv() {
     env->ReloadDbEnv();
 }
 
 bool BerkeleyBatch::StartCursor() {
     assert(!m_cursor);
     if (!pdb) {
         return false;
     }
     int ret = pdb->cursor(nullptr, &m_cursor, 0);
     return ret == 0;
 }
 
 bool BerkeleyBatch::ReadAtCursor(CDataStream &ssKey, CDataStream &ssValue,
                                  bool &complete) {
     complete = false;
     if (m_cursor == nullptr) {
         return false;
     }
     // Read at cursor
     SafeDbt datKey;
     SafeDbt datValue;
     int ret = m_cursor->get(datKey, datValue, DB_NEXT);
     if (ret == DB_NOTFOUND) {
         complete = true;
     }
     if (ret != 0) {
         return false;
     } else if (datKey.get_data() == nullptr || datValue.get_data() == nullptr) {
         return false;
     }
 
     // Convert to streams
     ssKey.SetType(SER_DISK);
     ssKey.clear();
     ssKey.write((char *)datKey.get_data(), datKey.get_size());
     ssValue.SetType(SER_DISK);
     ssValue.clear();
     ssValue.write((char *)datValue.get_data(), datValue.get_size());
     return true;
 }
 
 void BerkeleyBatch::CloseCursor() {
     if (!m_cursor) {
         return;
     }
     m_cursor->close();
     m_cursor = nullptr;
 }
 
 bool BerkeleyBatch::TxnBegin() {
     if (!pdb || activeTxn) {
         return false;
     }
     DbTxn *ptxn = env->TxnBegin();
     if (!ptxn) {
         return false;
     }
     activeTxn = ptxn;
     return true;
 }
 
 bool BerkeleyBatch::TxnCommit() {
     if (!pdb || !activeTxn) {
         return false;
     }
     int ret = activeTxn->commit(0);
     activeTxn = nullptr;
     return (ret == 0);
 }
 
 bool BerkeleyBatch::TxnAbort() {
     if (!pdb || !activeTxn) {
         return false;
     }
     int ret = activeTxn->abort();
     activeTxn = nullptr;
     return (ret == 0);
 }
 
 std::string BerkeleyDatabaseVersion() {
     return DbEnv::version(nullptr, nullptr, nullptr);
 }
 
 bool BerkeleyBatch::ReadKey(CDataStream &&key, CDataStream &value) {
     if (!pdb) {
         return false;
     }
 
     SafeDbt datKey(key.data(), key.size());
 
     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 false;
     }
 
     if (fReadOnly) {
         assert(!"Write called on database in read-only mode");
     }
 
     SafeDbt datKey(key.data(), key.size());
 
     SafeDbt datValue(value.data(), value.size());
 
     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");
     }
 
     SafeDbt datKey(key.data(), key.size());
 
     int ret = pdb->del(activeTxn, datKey, 0);
     return (ret == 0 || ret == DB_NOTFOUND);
 }
 
 bool BerkeleyBatch::HasKey(CDataStream &&key) {
     if (!pdb) {
         return false;
     }
 
     SafeDbt datKey(key.data(), key.size());
 
     int ret = pdb->exists(activeTxn, datKey, 0);
     return ret == 0;
 }
 
 void BerkeleyDatabase::AddRef() {
     LOCK(cs_db);
     if (m_refcount < 0) {
         m_refcount = 1;
     } else {
         m_refcount++;
     }
 }
 
 void BerkeleyDatabase::RemoveRef() {
     LOCK(cs_db);
     m_refcount--;
     if (env) {
         env->m_db_in_use.notify_all();
     }
 }
 
 std::unique_ptr<DatabaseBatch>
 BerkeleyDatabase::MakeBatch(bool flush_on_close) {
     return std::make_unique<BerkeleyBatch>(*this, false, flush_on_close);
 }
 
 bool ExistsBerkeleyDatabase(const fs::path &path) {
     fs::path env_directory;
     std::string data_filename;
     SplitWalletPath(path, env_directory, data_filename);
     return IsBerkeleyBtree(env_directory / data_filename);
 }
 
 std::unique_ptr<BerkeleyDatabase>
 MakeBerkeleyDatabase(const fs::path &path, const DatabaseOptions &options,
                      DatabaseStatus &status, bilingual_str &error) {
     std::unique_ptr<BerkeleyDatabase> db;
     {
         // Lock env.m_databases until insert in BerkeleyDatabase constructor
         LOCK(cs_db);
         std::string data_filename;
         std::shared_ptr<BerkeleyEnvironment> env =
             GetWalletEnv(path, data_filename);
         if (env->m_databases.count(data_filename)) {
             error = Untranslated(strprintf(
                 "Refusing to load database. Data file '%s' is already loaded.",
                 fs::PathToString(env->Directory() / data_filename)));
             status = DatabaseStatus::FAILED_ALREADY_LOADED;
             return nullptr;
         }
         db = std::make_unique<BerkeleyDatabase>(std::move(env),
                                                 std::move(data_filename));
     }
 
     if (options.verify && !db->Verify(error)) {
         status = DatabaseStatus::FAILED_VERIFY;
         return nullptr;
     }
 
     status = DatabaseStatus::SUCCESS;
     return db;
 }
diff --git a/src/wallet/load.cpp b/src/wallet/load.cpp
index 4cd995021..1b211d42f 100644
--- a/src/wallet/load.cpp
+++ b/src/wallet/load.cpp
@@ -1,178 +1,179 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/load.h>
 
 #include <fs.h>
 #include <interfaces/chain.h>
 #include <scheduler.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <wallet/spend.h>
 #include <wallet/wallet.h>
 #include <wallet/walletdb.h>
 
 #include <univalue.h>
 
+#include <system_error>
+
 bool VerifyWallets(interfaces::Chain &chain) {
     if (gArgs.IsArgSet("-walletdir")) {
         fs::path wallet_dir =
             fs::PathFromString(gArgs.GetArg("-walletdir", ""));
-        boost::system::error_code error;
+        std::error_code error;
         // The canonical path cleans the path, preventing >1 Berkeley
         // environment instances for the same directory
-        fs::path canonical_wallet_dir =
-            fs::canonical(wallet_dir, error).remove_trailing_separator();
+        fs::path canonical_wallet_dir = fs::canonical(wallet_dir, error);
         if (error || !fs::exists(wallet_dir)) {
             chain.initError(
                 strprintf(_("Specified -walletdir \"%s\" does not exist"),
                           fs::PathToString(wallet_dir)));
             return false;
         } else if (!fs::is_directory(wallet_dir)) {
             chain.initError(
                 strprintf(_("Specified -walletdir \"%s\" is not a directory"),
                           fs::PathToString(wallet_dir)));
             return false;
             // The canonical path transforms relative paths into absolute ones,
             // so we check the non-canonical version
         } else if (!wallet_dir.is_absolute()) {
             chain.initError(
                 strprintf(_("Specified -walletdir \"%s\" is a relative path"),
                           fs::PathToString(wallet_dir)));
             return false;
         }
         gArgs.ForceSetArg("-walletdir", fs::PathToString(canonical_wallet_dir));
     }
 
     LogPrintf("Using wallet directory %s\n", fs::PathToString(GetWalletDir()));
 
     chain.initMessage(_("Verifying wallet(s)...").translated);
 
     // For backwards compatibility if an unnamed top level wallet exists in the
     // wallets directory, include it in the default list of wallets to load.
     if (!gArgs.IsArgSet("wallet")) {
         DatabaseOptions options;
         DatabaseStatus status;
         bilingual_str error_string;
         options.require_existing = true;
         options.verify = false;
         if (MakeWalletDatabase("", options, status, error_string)) {
             gArgs.LockSettings([&](util::Settings &settings) {
                 util::SettingsValue wallets(util::SettingsValue::VARR);
                 // Default wallet name is ""
                 wallets.push_back("");
                 settings.rw_settings["wallet"] = wallets;
             });
         }
     }
 
     // Keep track of each wallet absolute path to detect duplicates.
     std::set<fs::path> wallet_paths;
 
     for (const auto &wallet_file : gArgs.GetArgs("-wallet")) {
         const fs::path path = fsbridge::AbsPathJoin(
             GetWalletDir(), fs::PathFromString(wallet_file));
 
         if (!wallet_paths.insert(path).second) {
             chain.initWarning(
                 strprintf(_("Ignoring duplicate -wallet %s."), wallet_file));
             continue;
         }
 
         DatabaseOptions options;
         DatabaseStatus status;
         options.verify = true;
         bilingual_str error_string;
         if (!MakeWalletDatabase(wallet_file, options, status, error_string)) {
             chain.initError(error_string);
             return false;
         }
     }
 
     return true;
 }
 
 bool LoadWallets(interfaces::Chain &chain) {
     try {
         std::set<fs::path> wallet_paths;
         for (const std::string &name : gArgs.GetArgs("-wallet")) {
             if (!wallet_paths.insert(fs::PathFromString(name)).second) {
                 continue;
             }
             DatabaseOptions options;
             DatabaseStatus status;
             // No need to verify, assuming verified earlier in VerifyWallets()
             options.verify = false;
             bilingual_str error;
             std::vector<bilingual_str> warnings;
             std::unique_ptr<WalletDatabase> database =
                 MakeWalletDatabase(name, options, status, error);
             std::shared_ptr<CWallet> pwallet =
                 database
                     ? CWallet::Create(chain, name, std::move(database),
                                       options.create_flags, error, warnings)
                     : nullptr;
 
             if (!warnings.empty()) {
                 chain.initWarning(Join(warnings, Untranslated("\n")));
             }
             if (!pwallet) {
                 chain.initError(error);
                 return false;
             }
             AddWallet(pwallet);
         }
         return true;
     } catch (const std::runtime_error &e) {
         chain.initError(Untranslated(e.what()));
         return false;
     }
 }
 
 void StartWallets(CScheduler &scheduler, const ArgsManager &args) {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->postInitProcess();
     }
 
     // Schedule periodic wallet flushes and tx rebroadcasts
     if (args.GetBoolArg("-flushwallet", DEFAULT_FLUSHWALLET)) {
         scheduler.scheduleEvery(
             [] {
                 MaybeCompactWalletDB();
                 return true;
             },
             std::chrono::milliseconds{500});
     }
     scheduler.scheduleEvery(
         [] {
             MaybeResendWalletTxs();
             return true;
         },
         std::chrono::milliseconds{1000});
 }
 
 void FlushWallets() {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->Flush();
     }
 }
 
 void StopWallets() {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->Close();
     }
 }
 
 void UnloadWallets() {
     auto wallets = GetWallets();
     while (!wallets.empty()) {
         auto wallet = wallets.back();
         wallets.pop_back();
         std::vector<bilingual_str> warnings;
         RemoveWallet(wallet, std::nullopt, warnings);
         UnloadWallet(std::move(wallet));
     }
 }
diff --git a/src/wallet/rpc/backup.cpp b/src/wallet/rpc/backup.cpp
index 2f6af7f88..04c0d3fff 100644
--- a/src/wallet/rpc/backup.cpp
+++ b/src/wallet/rpc/backup.cpp
@@ -1,2520 +1,2525 @@
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/rpc/backup.h>
 
 #include <chain.h>
 #include <config.h>
 #include <core_io.h>
+#include <fs.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <merkleblock.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <sync.h>
 #include <util/bip32.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <util/translation.h>
 #include <wallet/rpc/util.h>
 #include <wallet/rpcwallet.h>
 #include <wallet/spend.h>
 #include <wallet/wallet.h>
 
 #include <boost/algorithm/string.hpp>
 
+#include <algorithm>
 #include <cstdint>
+#include <fstream>
+#include <string>
 #include <tuple>
+#include <utility>
+#include <vector>
 
 using interfaces::FoundBlock;
 
 static std::string EncodeDumpString(const std::string &str) {
     std::stringstream ret;
     for (const uint8_t c : str) {
         if (c <= 32 || c >= 128 || c == '%') {
             ret << '%' << HexStr(Span<const uint8_t>(&c, 1));
         } else {
             ret << c;
         }
     }
     return ret.str();
 }
 
 static std::string DecodeDumpString(const std::string &str) {
     std::stringstream ret;
     for (unsigned int pos = 0; pos < str.length(); pos++) {
         uint8_t c = str[pos];
         if (c == '%' && pos + 2 < str.length()) {
             c = (((str[pos + 1] >> 6) * 9 + ((str[pos + 1] - '0') & 15)) << 4) |
                 ((str[pos + 2] >> 6) * 9 + ((str[pos + 2] - '0') & 15));
             pos += 2;
         }
         ret << c;
     }
     return ret.str();
 }
 
 static bool
 GetWalletAddressesForKey(const Config &config, LegacyScriptPubKeyMan *spk_man,
                          const CWallet *const pwallet, const CKeyID &keyid,
                          std::string &strAddr, std::string &strLabel)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     bool fLabelFound = false;
     CKey key;
     spk_man->GetKey(keyid, key);
     for (const auto &dest : GetAllDestinationsForKey(key.GetPubKey())) {
         const auto *address_book_entry = pwallet->FindAddressBookEntry(dest);
         if (address_book_entry) {
             if (!strAddr.empty()) {
                 strAddr += ",";
             }
             strAddr += EncodeDestination(dest, config);
             strLabel = EncodeDumpString(address_book_entry->GetLabel());
             fLabelFound = true;
         }
     }
     if (!fLabelFound) {
         strAddr = EncodeDestination(
             GetDestinationForKey(key.GetPubKey(),
                                  pwallet->m_default_address_type),
             config);
     }
     return fLabelFound;
 }
 
 static const int64_t TIMESTAMP_MIN = 0;
 
 static void RescanWallet(CWallet &wallet, const WalletRescanReserver &reserver,
                          int64_t time_begin = TIMESTAMP_MIN,
                          bool update = true) {
     int64_t scanned_time = wallet.RescanFromTime(time_begin, reserver, update);
     if (wallet.IsAbortingRescan()) {
         throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted by user.");
     } else if (scanned_time > time_begin) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Rescan was unable to fully rescan the blockchain. "
                            "Some transactions may be missing.");
     }
 }
 
 RPCHelpMan importprivkey() {
     return RPCHelpMan{
         "importprivkey",
         "Adds a private key (as returned by dumpprivkey) to your wallet. "
         "Requires a new wallet backup.\n"
         "Hint: use importmulti to import more than one private key.\n"
         "\nNote: This call can take minutes to complete if rescan is true, "
         "during that time, other rpc calls\n"
         "may report that the imported key exists but related transactions are "
         "still missing, leading to temporarily incorrect/bogus balances and "
         "unspent outputs until rescan completes.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
         {
             {"privkey", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The private key (see dumpprivkey)"},
             {"label", RPCArg::Type::STR, /* default */
              "current label if address exists, otherwise \"\"",
              "An optional label"},
             {"rescan", RPCArg::Type::BOOL, /* default */ "true",
              "Rescan the wallet for transactions"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
             "\nDump a private key\n" +
             HelpExampleCli("dumpprivkey", "\"myaddress\"") +
             "\nImport the private key with rescan\n" +
             HelpExampleCli("importprivkey", "\"mykey\"") +
             "\nImport using a label and without rescan\n" +
             HelpExampleCli("importprivkey", "\"mykey\" \"testing\" false") +
             "\nImport using default blank label and without rescan\n" +
             HelpExampleCli("importprivkey", "\"mykey\" \"\" false") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("importprivkey", "\"mykey\", \"testing\", false")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
                 throw JSONRPCError(
                     RPC_WALLET_ERROR,
                     "Cannot import private keys to a wallet with "
                     "private keys disabled");
             }
 
             EnsureLegacyScriptPubKeyMan(*wallet, true);
 
             WalletRescanReserver reserver(*pwallet);
             bool fRescan = true;
             {
                 LOCK(pwallet->cs_wallet);
 
                 EnsureWalletIsUnlocked(pwallet);
 
                 std::string strSecret = request.params[0].get_str();
                 std::string strLabel = "";
                 if (!request.params[1].isNull()) {
                     strLabel = request.params[1].get_str();
                 }
 
                 // Whether to perform rescan after import
                 if (!request.params[2].isNull()) {
                     fRescan = request.params[2].get_bool();
                 }
 
                 if (fRescan && pwallet->chain().havePruned()) {
                     // Exit early and print an error.
                     // If a block is pruned after this check, we will import the
                     // key(s), but fail the rescan with a generic error.
                     throw JSONRPCError(
                         RPC_WALLET_ERROR,
                         "Rescan is disabled when blocks are pruned");
                 }
 
                 if (fRescan && !reserver.reserve()) {
                     throw JSONRPCError(
                         RPC_WALLET_ERROR,
                         "Wallet is currently rescanning. Abort existing "
                         "rescan or wait.");
                 }
 
                 CKey key = DecodeSecret(strSecret);
                 if (!key.IsValid()) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Invalid private key encoding");
                 }
 
                 CPubKey pubkey = key.GetPubKey();
                 CHECK_NONFATAL(key.VerifyPubKey(pubkey));
                 CKeyID vchAddress = pubkey.GetID();
                 {
                     pwallet->MarkDirty();
 
                     // We don't know which corresponding address will be used;
                     // label all new addresses, and label existing addresses if
                     // a label was passed.
                     for (const auto &dest : GetAllDestinationsForKey(pubkey)) {
                         if (!request.params[1].isNull() ||
                             !pwallet->FindAddressBookEntry(dest)) {
                             pwallet->SetAddressBook(dest, strLabel, "receive");
                         }
                     }
 
                     // Use timestamp of 1 to scan the whole chain
                     if (!pwallet->ImportPrivKeys({{vchAddress, key}}, 1)) {
                         throw JSONRPCError(RPC_WALLET_ERROR,
                                            "Error adding key to wallet");
                     }
                 }
             }
             if (fRescan) {
                 RescanWallet(*pwallet, reserver);
             }
 
             return NullUniValue;
         },
     };
 }
 
 RPCHelpMan abortrescan() {
     return RPCHelpMan{
         "abortrescan",
         "Stops current wallet rescan triggered by an RPC call, e.g. by an "
         "importprivkey call.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
         {},
         RPCResult{RPCResult::Type::BOOL, "",
                   "Whether the abort was successful"},
         RPCExamples{"\nImport a private key\n" +
                     HelpExampleCli("importprivkey", "\"mykey\"") +
                     "\nAbort the running wallet rescan\n" +
                     HelpExampleCli("abortrescan", "") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("abortrescan", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) {
                 return false;
             }
             pwallet->AbortRescan();
             return true;
         },
     };
 }
 
 RPCHelpMan importaddress() {
     return RPCHelpMan{
         "importaddress",
         "Adds an address or script (in hex) that can be watched as if it "
         "were in your wallet but cannot be used to spend. Requires a new "
         "wallet backup.\n"
         "\nNote: This call can take minutes to complete if rescan is true, "
         "during that time, other rpc calls\n"
         "may report that the imported address exists but related transactions "
         "are still missing, leading to temporarily incorrect/bogus balances "
         "and unspent outputs until rescan completes.\n"
         "If you have the full public key, you should call importpubkey instead "
         "of this.\n"
         "Hint: use importmulti to import more than one address.\n"
         "\nNote: If you import a non-standard raw script in hex form, outputs "
         "sending to it will be treated\n"
         "as change, and not show up in many RPCs.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The Bitcoin address (or hex-encoded script)"},
             {"label", RPCArg::Type::STR, /* default */ "\"\"",
              "An optional label"},
             {"rescan", RPCArg::Type::BOOL, /* default */ "true",
              "Rescan the wallet for transactions"},
             {"p2sh", RPCArg::Type::BOOL, /* default */ "false",
              "Add the P2SH version of the script as well"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
             "\nImport an address with rescan\n" +
             HelpExampleCli("importaddress", "\"myaddress\"") +
             "\nImport using a label without rescan\n" +
             HelpExampleCli("importaddress", "\"myaddress\" \"testing\" false") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("importaddress",
                            "\"myaddress\", \"testing\", false")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             EnsureLegacyScriptPubKeyMan(*pwallet, true);
 
             std::string strLabel;
             if (!request.params[1].isNull()) {
                 strLabel = request.params[1].get_str();
             }
 
             // Whether to perform rescan after import
             bool fRescan = true;
             if (!request.params[2].isNull()) {
                 fRescan = request.params[2].get_bool();
             }
 
             if (fRescan && pwallet->chain().havePruned()) {
                 // Exit early and print an error.
                 // If a block is pruned after this check, we will import the
                 // key(s), but fail the rescan with a generic error.
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Rescan is disabled when blocks are pruned");
             }
 
             WalletRescanReserver reserver(*pwallet);
             if (fRescan && !reserver.reserve()) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Wallet is currently rescanning. Abort "
                                    "existing rescan or wait.");
             }
 
             // Whether to import a p2sh version, too
             bool fP2SH = false;
             if (!request.params[3].isNull()) {
                 fP2SH = request.params[3].get_bool();
             }
 
             {
                 LOCK(pwallet->cs_wallet);
 
                 CTxDestination dest = DecodeDestination(
                     request.params[0].get_str(), wallet->GetChainParams());
                 if (IsValidDestination(dest)) {
                     if (fP2SH) {
                         throw JSONRPCError(
                             RPC_INVALID_ADDRESS_OR_KEY,
                             "Cannot use the p2sh flag with an address - "
                             "use a script instead");
                     }
 
                     pwallet->MarkDirty();
 
                     pwallet->ImportScriptPubKeys(
                         strLabel, {GetScriptForDestination(dest)},
                         false /* have_solving_data */, true /* apply_label */,
                         1 /* timestamp */);
                 } else if (IsHex(request.params[0].get_str())) {
                     std::vector<uint8_t> data(
                         ParseHex(request.params[0].get_str()));
                     CScript redeem_script(data.begin(), data.end());
 
                     std::set<CScript> scripts = {redeem_script};
                     pwallet->ImportScripts(scripts, 0 /* timestamp */);
 
                     if (fP2SH) {
                         scripts.insert(
                             GetScriptForDestination(ScriptHash(redeem_script)));
                     }
 
                     pwallet->ImportScriptPubKeys(
                         strLabel, scripts, false /* have_solving_data */,
                         true /* apply_label */, 1 /* timestamp */);
                 } else {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Invalid Bitcoin address or script");
                 }
             }
             if (fRescan) {
                 RescanWallet(*pwallet, reserver);
                 {
                     LOCK(pwallet->cs_wallet);
                     pwallet->ReacceptWalletTransactions();
                 }
             }
 
             return NullUniValue;
         },
     };
 }
 
 RPCHelpMan importprunedfunds() {
     return RPCHelpMan{
         "importprunedfunds",
         "Imports funds without rescan. Corresponding address or script must "
         "previously be included in wallet. Aimed towards pruned wallets. The "
         "end-user is responsible to import additional transactions that "
         "subsequently spend the imported outputs or rescan after the point in "
         "the blockchain the transaction is included.\n",
         {
             {"rawtransaction", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "A raw transaction in hex funding an already-existing address in "
              "wallet"},
             {"txoutproof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex output from gettxoutproof that contains the transaction"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{""},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             CMutableTransaction tx;
             if (!DecodeHexTx(tx, request.params[0].get_str())) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "TX decode failed");
             }
             uint256 txid = tx.GetId();
 
             CDataStream ssMB(ParseHexV(request.params[1], "proof"), SER_NETWORK,
                              PROTOCOL_VERSION);
             CMerkleBlock merkleBlock;
             ssMB >> merkleBlock;
 
             // Search partial merkle tree in proof for our transaction and index
             // in valid block
             std::vector<uint256> vMatch;
             std::vector<size_t> vIndex;
             if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) !=
                 merkleBlock.header.hashMerkleRoot) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Something wrong with merkleblock");
             }
 
             LOCK(pwallet->cs_wallet);
             int height;
             if (!pwallet->chain().findAncestorByHash(
                     pwallet->GetLastBlockHash(), merkleBlock.header.GetHash(),
                     FoundBlock().height(height))) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Block not found in chain");
             }
 
             std::vector<uint256>::const_iterator it;
             if ((it = std::find(vMatch.begin(), vMatch.end(), txid)) ==
                 vMatch.end()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Transaction given doesn't exist in proof");
             }
 
             size_t txnIndex = vIndex[it - vMatch.begin()];
 
             CWalletTx::Confirmation confirm(
                 CWalletTx::Status::CONFIRMED, height,
                 merkleBlock.header.GetHash(), txnIndex);
 
             CTransactionRef tx_ref = MakeTransactionRef(tx);
             if (pwallet->IsMine(*tx_ref)) {
                 pwallet->AddToWallet(std::move(tx_ref), confirm);
                 return NullUniValue;
             }
 
             throw JSONRPCError(
                 RPC_INVALID_ADDRESS_OR_KEY,
                 "No addresses in wallet correspond to included transaction");
         },
     };
 }
 
 RPCHelpMan removeprunedfunds() {
     return RPCHelpMan{
         "removeprunedfunds",
         "Deletes the specified transaction from the wallet. Meant for use "
         "with pruned wallets and as a companion to importprunedfunds. This "
         "will affect wallet balances.\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The hex-encoded id of the transaction you are deleting"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("removeprunedfunds",
                                    "\"a8d0c0184dde994a09ec054286f1ce581bebf4644"
                                    "6a512166eae7628734ea0a5\"") +
                     "\nAs a JSON-RPC call\n" +
                     HelpExampleRpc("removeprunedfunds",
                                    "\"a8d0c0184dde994a09ec054286f1ce581bebf4644"
                                    "6a512166eae7628734ea0a5\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             LOCK(pwallet->cs_wallet);
 
             TxId txid(ParseHashV(request.params[0], "txid"));
             std::vector<TxId> txIds;
             txIds.push_back(txid);
             std::vector<TxId> txIdsOut;
 
             if (pwallet->ZapSelectTx(txIds, txIdsOut) != DBErrors::LOAD_OK) {
                 throw JSONRPCError(
                     RPC_WALLET_ERROR,
                     "Could not properly delete the transaction.");
             }
 
             if (txIdsOut.empty()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Transaction does not exist in wallet.");
             }
 
             return NullUniValue;
         },
     };
 }
 
 RPCHelpMan importpubkey() {
     return RPCHelpMan{
         "importpubkey",
         "Adds a public key (in hex) that can be watched as if it were in "
         "your wallet but cannot be used to spend. Requires a new wallet "
         "backup.\n"
         "Hint: use importmulti to import more than one public key.\n"
         "\nNote: This call can take minutes to complete if rescan is true, "
         "during that time, other rpc calls\n"
         "may report that the imported pubkey exists but related transactions "
         "are still missing, leading to temporarily incorrect/bogus balances "
         "and unspent outputs until rescan completes.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
         {
             {"pubkey", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The hex-encoded public key"},
             {"label", RPCArg::Type::STR, /* default */ "\"\"",
              "An optional label"},
             {"rescan", RPCArg::Type::BOOL, /* default */ "true",
              "Rescan the wallet for transactions"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
             "\nImport a public key with rescan\n" +
             HelpExampleCli("importpubkey", "\"mypubkey\"") +
             "\nImport using a label without rescan\n" +
             HelpExampleCli("importpubkey", "\"mypubkey\" \"testing\" false") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("importpubkey", "\"mypubkey\", \"testing\", false")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             EnsureLegacyScriptPubKeyMan(*wallet, true);
 
             std::string strLabel;
             if (!request.params[1].isNull()) {
                 strLabel = request.params[1].get_str();
             }
 
             // Whether to perform rescan after import
             bool fRescan = true;
             if (!request.params[2].isNull()) {
                 fRescan = request.params[2].get_bool();
             }
 
             if (fRescan && pwallet->chain().havePruned()) {
                 // Exit early and print an error.
                 // If a block is pruned after this check, we will import the
                 // key(s), but fail the rescan with a generic error.
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Rescan is disabled when blocks are pruned");
             }
 
             WalletRescanReserver reserver(*pwallet);
             if (fRescan && !reserver.reserve()) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Wallet is currently rescanning. Abort "
                                    "existing rescan or wait.");
             }
 
             if (!IsHex(request.params[0].get_str())) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Pubkey must be a hex string");
             }
             std::vector<uint8_t> data(ParseHex(request.params[0].get_str()));
             CPubKey pubKey(data.begin(), data.end());
             if (!pubKey.IsFullyValid()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Pubkey is not a valid public key");
             }
 
             {
                 LOCK(pwallet->cs_wallet);
 
                 std::set<CScript> script_pub_keys;
                 for (const auto &dest : GetAllDestinationsForKey(pubKey)) {
                     script_pub_keys.insert(GetScriptForDestination(dest));
                 }
 
                 pwallet->MarkDirty();
 
                 pwallet->ImportScriptPubKeys(
                     strLabel, script_pub_keys, true /* have_solving_data */,
                     true /* apply_label */, 1 /* timestamp */);
 
                 pwallet->ImportPubKeys(
                     {pubKey.GetID()}, {{pubKey.GetID(), pubKey}},
                     {} /* key_origins */, false /* add_keypool */,
                     false /* internal */, 1 /* timestamp */);
             }
             if (fRescan) {
                 RescanWallet(*pwallet, reserver);
                 {
                     LOCK(pwallet->cs_wallet);
                     pwallet->ReacceptWalletTransactions();
                 }
             }
 
             return NullUniValue;
         },
     };
 }
 
 RPCHelpMan importwallet() {
     return RPCHelpMan{
         "importwallet",
         "Imports keys from a wallet dump file (see dumpwallet). Requires a "
         "new wallet backup to include imported keys.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
         {
             {"filename", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The wallet file"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{"\nDump the wallet\n" +
                     HelpExampleCli("dumpwallet", "\"test\"") +
                     "\nImport the wallet\n" +
                     HelpExampleCli("importwallet", "\"test\"") +
                     "\nImport using the json rpc call\n" +
                     HelpExampleRpc("importwallet", "\"test\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             EnsureLegacyScriptPubKeyMan(*wallet, true);
 
             if (pwallet->chain().havePruned()) {
                 // Exit early and print an error.
                 // If a block is pruned after this check, we will import the
                 // key(s), but fail the rescan with a generic error.
                 throw JSONRPCError(
                     RPC_WALLET_ERROR,
                     "Importing wallets is disabled when blocks are pruned");
             }
 
             WalletRescanReserver reserver(*pwallet);
             if (!reserver.reserve()) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Wallet is currently rescanning. Abort "
                                    "existing rescan or wait.");
             }
 
             int64_t nTimeBegin = 0;
             bool fGood = true;
             {
                 LOCK(pwallet->cs_wallet);
 
                 EnsureWalletIsUnlocked(pwallet);
 
-                fsbridge::ifstream file;
+                std::ifstream file;
                 file.open(fs::u8path(request.params[0].get_str()),
                           std::ios::in | std::ios::ate);
                 if (!file.is_open()) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Cannot open wallet dump file");
                 }
                 CHECK_NONFATAL(
                     pwallet->chain().findBlock(pwallet->GetLastBlockHash(),
                                                FoundBlock().time(nTimeBegin)));
 
                 int64_t nFilesize = std::max<int64_t>(1, file.tellg());
                 file.seekg(0, file.beg);
 
                 // Use uiInterface.ShowProgress instead of pwallet.ShowProgress
                 // because pwallet.ShowProgress has a cancel button tied to
                 // AbortRescan which we don't want for this progress bar showing
                 // the import progress. uiInterface.ShowProgress does not have a
                 // cancel button.
 
                 // show progress dialog in GUI
                 pwallet->chain().showProgress(
                     strprintf("%s " + _("Importing...").translated,
                               pwallet->GetDisplayName()),
                     0, false);
                 std::vector<std::tuple<CKey, int64_t, bool, std::string>> keys;
                 std::vector<std::pair<CScript, int64_t>> scripts;
                 while (file.good()) {
                     pwallet->chain().showProgress(
                         "",
                         std::max(1,
                                  std::min<int>(50, 100 * double(file.tellg()) /
                                                        double(nFilesize))),
                         false);
                     std::string line;
                     std::getline(file, line);
                     if (line.empty() || line[0] == '#') {
                         continue;
                     }
 
                     std::vector<std::string> vstr;
                     boost::split(vstr, line, boost::is_any_of(" "));
                     if (vstr.size() < 2) {
                         continue;
                     }
                     CKey key = DecodeSecret(vstr[0]);
                     if (key.IsValid()) {
                         int64_t nTime = ParseISO8601DateTime(vstr[1]);
                         std::string strLabel;
                         bool fLabel = true;
                         for (size_t nStr = 2; nStr < vstr.size(); nStr++) {
                             if (vstr[nStr].front() == '#') {
                                 break;
                             }
                             if (vstr[nStr] == "change=1") {
                                 fLabel = false;
                             }
                             if (vstr[nStr] == "reserve=1") {
                                 fLabel = false;
                             }
                             if (vstr[nStr].substr(0, 6) == "label=") {
                                 strLabel =
                                     DecodeDumpString(vstr[nStr].substr(6));
                                 fLabel = true;
                             }
                         }
                         keys.push_back(
                             std::make_tuple(key, nTime, fLabel, strLabel));
                     } else if (IsHex(vstr[0])) {
                         std::vector<uint8_t> vData(ParseHex(vstr[0]));
                         CScript script = CScript(vData.begin(), vData.end());
                         int64_t birth_time = ParseISO8601DateTime(vstr[1]);
                         scripts.push_back(
                             std::pair<CScript, int64_t>(script, birth_time));
                     }
                 }
                 file.close();
                 // We now know whether we are importing private keys, so we can
                 // error if private keys are disabled
                 if (keys.size() > 0 && pwallet->IsWalletFlagSet(
                                            WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
                     // hide progress dialog in GUI
                     pwallet->chain().showProgress("", 100, false);
                     throw JSONRPCError(RPC_WALLET_ERROR,
                                        "Importing wallets is disabled when "
                                        "private keys are disabled");
                 }
                 double total = double(keys.size() + scripts.size());
                 double progress = 0;
                 for (const auto &key_tuple : keys) {
                     pwallet->chain().showProgress(
                         "",
                         std::max(50, std::min<int>(75, 100 * progress / total) +
                                          50),
                         false);
                     const CKey &key = std::get<0>(key_tuple);
                     int64_t time = std::get<1>(key_tuple);
                     bool has_label = std::get<2>(key_tuple);
                     std::string label = std::get<3>(key_tuple);
 
                     CPubKey pubkey = key.GetPubKey();
                     CHECK_NONFATAL(key.VerifyPubKey(pubkey));
                     CKeyID keyid = pubkey.GetID();
 
                     pwallet->WalletLogPrintf(
                         "Importing %s...\n",
                         EncodeDestination(PKHash(keyid), config));
 
                     if (!pwallet->ImportPrivKeys({{keyid, key}}, time)) {
                         pwallet->WalletLogPrintf(
                             "Error importing key for %s\n",
                             EncodeDestination(PKHash(keyid), config));
                         fGood = false;
                         continue;
                     }
 
                     if (has_label) {
                         pwallet->SetAddressBook(PKHash(keyid), label,
                                                 "receive");
                     }
 
                     nTimeBegin = std::min(nTimeBegin, time);
                     progress++;
                 }
                 for (const auto &script_pair : scripts) {
                     pwallet->chain().showProgress(
                         "",
                         std::max(50, std::min<int>(75, 100 * progress / total) +
                                          50),
                         false);
                     const CScript &script = script_pair.first;
                     int64_t time = script_pair.second;
 
                     if (!pwallet->ImportScripts({script}, time)) {
                         pwallet->WalletLogPrintf("Error importing script %s\n",
                                                  HexStr(script));
                         fGood = false;
                         continue;
                     }
                     if (time > 0) {
                         nTimeBegin = std::min(nTimeBegin, time);
                     }
 
                     progress++;
                 }
 
                 // hide progress dialog in GUI
                 pwallet->chain().showProgress("", 100, false);
             }
             // hide progress dialog in GUI
             pwallet->chain().showProgress("", 100, false);
             RescanWallet(*pwallet, reserver, nTimeBegin, false /* update */);
             pwallet->MarkDirty();
 
             if (!fGood) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error adding some keys/scripts to wallet");
             }
 
             return NullUniValue;
         },
     };
 }
 
 RPCHelpMan dumpprivkey() {
     return RPCHelpMan{
         "dumpprivkey",
         "Reveals the private key corresponding to 'address'.\n"
         "Then the importprivkey can be used with this output\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The bitcoin address for the private key"},
         },
         RPCResult{RPCResult::Type::STR, "key", "The private key"},
         RPCExamples{HelpExampleCli("dumpprivkey", "\"myaddress\"") +
                     HelpExampleCli("importprivkey", "\"mykey\"") +
                     HelpExampleRpc("dumpprivkey", "\"myaddress\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             LegacyScriptPubKeyMan &spk_man =
                 EnsureLegacyScriptPubKeyMan(*wallet);
 
             LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);
 
             EnsureWalletIsUnlocked(pwallet);
 
             std::string strAddress = request.params[0].get_str();
             CTxDestination dest =
                 DecodeDestination(strAddress, wallet->GetChainParams());
             if (!IsValidDestination(dest)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid Bitcoin address");
             }
             auto keyid = GetKeyForDestination(spk_man, dest);
             if (keyid.IsNull()) {
                 throw JSONRPCError(RPC_TYPE_ERROR,
                                    "Address does not refer to a key");
             }
             CKey vchSecret;
             if (!spk_man.GetKey(keyid, vchSecret)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Private key for address " + strAddress +
                                        " is not known");
             }
             return EncodeSecret(vchSecret);
         },
     };
 }
 
 RPCHelpMan dumpwallet() {
     return RPCHelpMan{
         "dumpwallet",
         "Dumps all wallet keys in a human-readable format to a server-side "
         "file. This does not allow overwriting existing files.\n"
         "Imported scripts are included in the dumpsfile, but corresponding "
         "addresses may not be added automatically by importwallet.\n"
         "Note that if your wallet contains keys which are not derived from "
         "your HD seed (e.g. imported keys), these are not covered by\n"
         "only backing up the seed itself, and must be backed up too (e.g. "
         "ensure you back up the whole dumpfile).\n",
         {
             {"filename", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The filename with path (absolute path recommended)"},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "filename",
                        "The filename with full absolute path"},
                   }},
         RPCExamples{HelpExampleCli("dumpwallet", "\"test\"") +
                     HelpExampleRpc("dumpwallet", "\"test\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const pwallet =
                 GetWalletForJSONRPCRequest(request);
             if (!pwallet) {
                 return NullUniValue;
             }
 
             CWallet &wallet = *pwallet;
             LegacyScriptPubKeyMan &spk_man =
                 EnsureLegacyScriptPubKeyMan(wallet);
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             wallet.BlockUntilSyncedToCurrentChain();
 
             LOCK(wallet.cs_wallet);
 
             EnsureWalletIsUnlocked(&wallet);
 
             fs::path filepath = fs::u8path(request.params[0].get_str());
             filepath = fs::absolute(filepath);
 
             /**
              * Prevent arbitrary files from being overwritten. There have been
              * reports that users have overwritten wallet files this way:
              * https://github.com/bitcoin/bitcoin/issues/9934
              * It may also avoid other security issues.
              */
             if (fs::exists(filepath)) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    filepath.u8string() +
                                        " already exists. If you are "
                                        "sure this is what you want, "
                                        "move it out of the way first");
             }
 
-            fsbridge::ofstream file;
+            std::ofstream file;
             file.open(filepath);
             if (!file.is_open()) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Cannot open wallet dump file");
             }
 
             std::map<CKeyID, int64_t> mapKeyBirth;
             wallet.GetKeyBirthTimes(mapKeyBirth);
 
             int64_t block_time = 0;
             CHECK_NONFATAL(wallet.chain().findBlock(
                 wallet.GetLastBlockHash(), FoundBlock().time(block_time)));
 
             // Note: To avoid a lock order issue, access to cs_main must be
             // locked before cs_KeyStore. So we do the two things in this
             // function that lock cs_main first: GetKeyBirthTimes, and
             // findBlock.
             LOCK(spk_man.cs_KeyStore);
 
             const std::map<CKeyID, int64_t> &mapKeyPool =
                 spk_man.GetAllReserveKeys();
             std::set<CScriptID> scripts = spk_man.GetCScripts();
 
             // sort time/key pairs
             std::vector<std::pair<int64_t, CKeyID>> vKeyBirth;
             for (const auto &entry : mapKeyBirth) {
                 vKeyBirth.push_back(std::make_pair(entry.second, entry.first));
             }
             mapKeyBirth.clear();
             std::sort(vKeyBirth.begin(), vKeyBirth.end());
 
             // produce output
             file << strprintf("# Wallet dump created by %s %s\n", CLIENT_NAME,
                               CLIENT_BUILD);
             file << strprintf("# * Created on %s\n",
                               FormatISO8601DateTime(GetTime()));
             file << strprintf("# * Best block at time of backup was %i (%s),\n",
                               wallet.GetLastBlockHeight(),
                               wallet.GetLastBlockHash().ToString());
             file << strprintf("#   mined on %s\n",
                               FormatISO8601DateTime(block_time));
             file << "\n";
 
             // add the base58check encoded extended master if the wallet uses HD
             CKeyID seed_id = spk_man.GetHDChain().seed_id;
             if (!seed_id.IsNull()) {
                 CKey seed;
                 if (spk_man.GetKey(seed_id, seed)) {
                     CExtKey masterKey;
                     masterKey.SetSeed(seed.begin(), seed.size());
 
                     file << "# extended private masterkey: "
                          << EncodeExtKey(masterKey) << "\n\n";
                 }
             }
             for (std::vector<std::pair<int64_t, CKeyID>>::const_iterator it =
                      vKeyBirth.begin();
                  it != vKeyBirth.end(); it++) {
                 const CKeyID &keyid = it->second;
                 std::string strTime = FormatISO8601DateTime(it->first);
                 std::string strAddr;
                 std::string strLabel;
                 CKey key;
                 if (spk_man.GetKey(keyid, key)) {
                     file << strprintf("%s %s ", EncodeSecret(key), strTime);
                     if (GetWalletAddressesForKey(config, &spk_man, &wallet,
                                                  keyid, strAddr, strLabel)) {
                         file << strprintf("label=%s", strLabel);
                     } else if (keyid == seed_id) {
                         file << "hdseed=1";
                     } else if (mapKeyPool.count(keyid)) {
                         file << "reserve=1";
                     } else if (spk_man.mapKeyMetadata[keyid].hdKeypath == "s") {
                         file << "inactivehdseed=1";
                     } else {
                         file << "change=1";
                     }
                     file << strprintf(
                         " # addr=%s%s\n", strAddr,
                         (spk_man.mapKeyMetadata[keyid].has_key_origin
                              ? " hdkeypath=" +
                                    WriteHDKeypath(spk_man.mapKeyMetadata[keyid]
                                                       .key_origin.path)
                              : ""));
                 }
             }
             file << "\n";
             for (const CScriptID &scriptid : scripts) {
                 CScript script;
                 std::string create_time = "0";
                 std::string address =
                     EncodeDestination(ScriptHash(scriptid), config);
                 // get birth times for scripts with metadata
                 auto it = spk_man.m_script_metadata.find(scriptid);
                 if (it != spk_man.m_script_metadata.end()) {
                     create_time = FormatISO8601DateTime(it->second.nCreateTime);
                 }
                 if (spk_man.GetCScript(scriptid, script)) {
                     file << strprintf("%s %s script=1", HexStr(script),
                                       create_time);
                     file << strprintf(" # addr=%s\n", address);
                 }
             }
             file << "\n";
             file << "# End of dump\n";
             file.close();
 
             UniValue reply(UniValue::VOBJ);
             reply.pushKV("filename", filepath.u8string());
 
             return reply;
         },
     };
 }
 
 static RPCHelpMan dumpcoins() {
     return RPCHelpMan{
         "dumpcoins",
         "dump all the UTXO tracked by the wallet.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ_DYN,
             "",
             "",
             {{
                 RPCResult::Type::ARR,
                 "address",
                 "The list of UTXO corresponding to this address.",
                 {{
                     RPCResult::Type::OBJ,
                     "",
                     "",
                     {
                         {RPCResult::Type::STR_HEX, "txid",
                          "The transaction id"},
                         {RPCResult::Type::NUM, "vout", "The output number"},
                         {RPCResult::Type::NUM, "depth", "The output's depth"},
                         {RPCResult::Type::STR_AMOUNT, "value",
                          "The output's amount"},
                     },
                 }},
             }},
         },
         RPCExamples{HelpExampleCli("dumpcoins", "") +
                     HelpExampleRpc("dumpcoins", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const pwallet =
                 GetWalletForJSONRPCRequest(request);
             if (!pwallet) {
                 return NullUniValue;
             }
 
             CWallet &wallet = *pwallet;
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             wallet.BlockUntilSyncedToCurrentChain();
 
             LOCK(wallet.cs_wallet);
 
             EnsureWalletIsUnlocked(&wallet);
 
             UniValue result(UniValue::VOBJ);
             for (const auto &p : ListCoins(wallet)) {
                 UniValue coins(UniValue::VARR);
                 for (const auto &o : p.second) {
                     UniValue utxo(UniValue::VOBJ);
                     utxo.pushKV("txid", o.tx->GetId().ToString());
                     utxo.pushKV("vout", o.i);
                     utxo.pushKV("depth", o.nDepth);
                     utxo.pushKV("value", o.tx->tx->vout[o.i].nValue);
 
                     coins.push_back(std::move(utxo));
                 }
 
                 result.pushKV(EncodeDestination(p.first, config), coins);
             }
 
             return result;
         },
     };
 }
 
 struct ImportData {
     // Input data
     //! Provided redeemScript; will be moved to `import_scripts` if relevant.
     std::unique_ptr<CScript> redeemscript;
 
     // Output data
     std::set<CScript> import_scripts;
     //! Import these private keys if available (the value indicates whether if
     //! the key is required for solvability)
     std::map<CKeyID, bool> used_keys;
     std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> key_origins;
 };
 
 enum class ScriptContext {
     //! Top-level scriptPubKey
     TOP,
     //! P2SH redeemScript
     P2SH,
 };
 
 // Analyse the provided scriptPubKey, determining which keys and which redeem
 // scripts from the ImportData struct are needed to spend it, and mark them as
 // used. Returns an error string, or the empty string for success.
 static std::string RecurseImportData(const CScript &script,
                                      ImportData &import_data,
                                      const ScriptContext script_ctx) {
     // Use Solver to obtain script type and parsed pubkeys or hashes:
     std::vector<std::vector<uint8_t>> solverdata;
     TxoutType script_type = Solver(script, solverdata);
 
     switch (script_type) {
         case TxoutType::PUBKEY: {
             CPubKey pubkey(solverdata[0].begin(), solverdata[0].end());
             import_data.used_keys.emplace(pubkey.GetID(), false);
             return "";
         }
         case TxoutType::PUBKEYHASH: {
             CKeyID id = CKeyID(uint160(solverdata[0]));
             import_data.used_keys[id] = true;
             return "";
         }
         case TxoutType::SCRIPTHASH: {
             if (script_ctx == ScriptContext::P2SH) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Trying to nest P2SH inside another P2SH");
             }
             CHECK_NONFATAL(script_ctx == ScriptContext::TOP);
             CScriptID id = CScriptID(uint160(solverdata[0]));
             // Remove redeemscript from import_data to check for superfluous
             // script later.
             auto subscript = std::move(import_data.redeemscript);
             if (!subscript) {
                 return "missing redeemscript";
             }
             if (CScriptID(*subscript) != id) {
                 return "redeemScript does not match the scriptPubKey";
             }
             import_data.import_scripts.emplace(*subscript);
             return RecurseImportData(*subscript, import_data,
                                      ScriptContext::P2SH);
         }
         case TxoutType::MULTISIG: {
             for (size_t i = 1; i + 1 < solverdata.size(); ++i) {
                 CPubKey pubkey(solverdata[i].begin(), solverdata[i].end());
                 import_data.used_keys.emplace(pubkey.GetID(), false);
             }
             return "";
         }
         case TxoutType::NULL_DATA:
             return "unspendable script";
         case TxoutType::NONSTANDARD:
         default:
             return "unrecognized script";
     }
 }
 
 static UniValue ProcessImportLegacy(
     CWallet *const pwallet, ImportData &import_data,
     std::map<CKeyID, CPubKey> &pubkey_map, std::map<CKeyID, CKey> &privkey_map,
     std::set<CScript> &script_pub_keys, bool &have_solving_data,
     const UniValue &data, std::vector<CKeyID> &ordered_pubkeys) {
     UniValue warnings(UniValue::VARR);
 
     // First ensure scriptPubKey has either a script or JSON with "address"
     // string
     const UniValue &scriptPubKey = data["scriptPubKey"];
     bool isScript = scriptPubKey.getType() == UniValue::VSTR;
     if (!isScript && !(scriptPubKey.getType() == UniValue::VOBJ &&
                        scriptPubKey.exists("address"))) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "scriptPubKey must be string with script or JSON "
                            "with address string");
     }
     const std::string &output =
         isScript ? scriptPubKey.get_str() : scriptPubKey["address"].get_str();
 
     // Optional fields.
     const std::string &strRedeemScript =
         data.exists("redeemscript") ? data["redeemscript"].get_str() : "";
     const UniValue &pubKeys =
         data.exists("pubkeys") ? data["pubkeys"].get_array() : UniValue();
     const UniValue &keys =
         data.exists("keys") ? data["keys"].get_array() : UniValue();
     const bool internal =
         data.exists("internal") ? data["internal"].get_bool() : false;
     const bool watchOnly =
         data.exists("watchonly") ? data["watchonly"].get_bool() : false;
 
     if (data.exists("range")) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Range should not be specified for a non-descriptor import");
     }
 
     // Generate the script and destination for the scriptPubKey provided
     CScript script;
     if (!isScript) {
         CTxDestination dest =
             DecodeDestination(output, pwallet->GetChainParams());
         if (!IsValidDestination(dest)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid address \"" + output + "\"");
         }
         script = GetScriptForDestination(dest);
     } else {
         if (!IsHex(output)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid scriptPubKey \"" + output + "\"");
         }
         std::vector<uint8_t> vData(ParseHex(output));
         script = CScript(vData.begin(), vData.end());
         CTxDestination dest;
         if (!ExtractDestination(script, dest) && !internal) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Internal must be set to true for "
                                "nonstandard scriptPubKey imports.");
         }
     }
     script_pub_keys.emplace(script);
 
     // Parse all arguments
     if (strRedeemScript.size()) {
         if (!IsHex(strRedeemScript)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid redeem script \"" + strRedeemScript +
                                    "\": must be hex string");
         }
         auto parsed_redeemscript = ParseHex(strRedeemScript);
         import_data.redeemscript = std::make_unique<CScript>(
             parsed_redeemscript.begin(), parsed_redeemscript.end());
     }
     for (size_t i = 0; i < pubKeys.size(); ++i) {
         const auto &str = pubKeys[i].get_str();
         if (!IsHex(str)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Pubkey \"" + str + "\" must be a hex string");
         }
         auto parsed_pubkey = ParseHex(str);
         CPubKey pubkey(parsed_pubkey.begin(), parsed_pubkey.end());
         if (!pubkey.IsFullyValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Pubkey \"" + str +
                                    "\" is not a valid public key");
         }
         pubkey_map.emplace(pubkey.GetID(), pubkey);
         ordered_pubkeys.push_back(pubkey.GetID());
     }
     for (size_t i = 0; i < keys.size(); ++i) {
         const auto &str = keys[i].get_str();
         CKey key = DecodeSecret(str);
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key encoding");
         }
         CPubKey pubkey = key.GetPubKey();
         CKeyID id = pubkey.GetID();
         if (pubkey_map.count(id)) {
             pubkey_map.erase(id);
         }
         privkey_map.emplace(id, key);
     }
 
     // Verify and process input data
     have_solving_data =
         import_data.redeemscript || pubkey_map.size() || privkey_map.size();
     if (have_solving_data) {
         // Match up data in import_data with the scriptPubKey in script.
         auto error = RecurseImportData(script, import_data, ScriptContext::TOP);
 
         // Verify whether the watchonly option corresponds to the
         // availability of private keys.
         bool spendable = std::all_of(
             import_data.used_keys.begin(), import_data.used_keys.end(),
             [&](const std::pair<CKeyID, bool> &used_key) {
                 return privkey_map.count(used_key.first) > 0;
             });
         if (!watchOnly && !spendable) {
             warnings.push_back("Some private keys are missing, outputs "
                                "will be considered watchonly. If this is "
                                "intentional, specify the watchonly flag.");
         }
         if (watchOnly && spendable) {
             warnings.push_back(
                 "All private keys are provided, outputs will be considered "
                 "spendable. If this is intentional, do not specify the "
                 "watchonly flag.");
         }
 
         // Check that all required keys for solvability are provided.
         if (error.empty()) {
             for (const auto &require_key : import_data.used_keys) {
                 if (!require_key.second) {
                     // Not a required key
                     continue;
                 }
 
                 if (pubkey_map.count(require_key.first) == 0 &&
                     privkey_map.count(require_key.first) == 0) {
                     error = "some required keys are missing";
                 }
             }
         }
 
         if (!error.empty()) {
             warnings.push_back("Importing as non-solvable: " + error +
                                ". If this is intentional, don't provide "
                                "any keys, pubkeys or redeemscript.");
             import_data = ImportData();
             pubkey_map.clear();
             privkey_map.clear();
             have_solving_data = false;
         } else {
             // RecurseImportData() removes any relevant redeemscript from
             // import_data, so we can use that to discover if a superfluous
             // one was provided.
             if (import_data.redeemscript) {
                 warnings.push_back(
                     "Ignoring redeemscript as this is not a P2SH script.");
             }
             for (auto it = privkey_map.begin(); it != privkey_map.end();) {
                 auto oldit = it++;
                 if (import_data.used_keys.count(oldit->first) == 0) {
                     warnings.push_back("Ignoring irrelevant private key.");
                     privkey_map.erase(oldit);
                 }
             }
             for (auto it = pubkey_map.begin(); it != pubkey_map.end();) {
                 auto oldit = it++;
                 auto key_data_it = import_data.used_keys.find(oldit->first);
                 if (key_data_it == import_data.used_keys.end() ||
                     !key_data_it->second) {
                     warnings.push_back("Ignoring public key \"" +
                                        HexStr(oldit->first) +
                                        "\" as it doesn't appear inside P2PKH.");
                     pubkey_map.erase(oldit);
                 }
             }
         }
     }
 
     return warnings;
 }
 
 static UniValue ProcessImportDescriptor(ImportData &import_data,
                                         std::map<CKeyID, CPubKey> &pubkey_map,
                                         std::map<CKeyID, CKey> &privkey_map,
                                         std::set<CScript> &script_pub_keys,
                                         bool &have_solving_data,
                                         const UniValue &data,
                                         std::vector<CKeyID> &ordered_pubkeys) {
     UniValue warnings(UniValue::VARR);
 
     const std::string &descriptor = data["desc"].get_str();
     FlatSigningProvider keys;
     std::string error;
     auto parsed_desc =
         Parse(descriptor, keys, error, /* require_checksum = */ true);
     if (!parsed_desc) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
     }
 
     have_solving_data = parsed_desc->IsSolvable();
     const bool watch_only =
         data.exists("watchonly") ? data["watchonly"].get_bool() : false;
 
     int64_t range_start = 0, range_end = 0;
     if (!parsed_desc->IsRange() && data.exists("range")) {
         throw JSONRPCError(
             RPC_INVALID_PARAMETER,
             "Range should not be specified for an un-ranged descriptor");
     } else if (parsed_desc->IsRange()) {
         if (!data.exists("range")) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Descriptor is ranged, please specify the range");
         }
         std::tie(range_start, range_end) = ParseDescriptorRange(data["range"]);
     }
 
     const UniValue &priv_keys =
         data.exists("keys") ? data["keys"].get_array() : UniValue();
 
     // Expand all descriptors to get public keys and scripts, and private keys
     // if available.
     for (int i = range_start; i <= range_end; ++i) {
         FlatSigningProvider out_keys;
         std::vector<CScript> scripts_temp;
         parsed_desc->Expand(i, keys, scripts_temp, out_keys);
         std::copy(scripts_temp.begin(), scripts_temp.end(),
                   std::inserter(script_pub_keys, script_pub_keys.end()));
         for (const auto &key_pair : out_keys.pubkeys) {
             ordered_pubkeys.push_back(key_pair.first);
         }
 
         for (const auto &x : out_keys.scripts) {
             import_data.import_scripts.emplace(x.second);
         }
 
         parsed_desc->ExpandPrivate(i, keys, out_keys);
 
         std::copy(out_keys.pubkeys.begin(), out_keys.pubkeys.end(),
                   std::inserter(pubkey_map, pubkey_map.end()));
         std::copy(out_keys.keys.begin(), out_keys.keys.end(),
                   std::inserter(privkey_map, privkey_map.end()));
         import_data.key_origins.insert(out_keys.origins.begin(),
                                        out_keys.origins.end());
     }
 
     for (size_t i = 0; i < priv_keys.size(); ++i) {
         const auto &str = priv_keys[i].get_str();
         CKey key = DecodeSecret(str);
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key encoding");
         }
         CPubKey pubkey = key.GetPubKey();
         CKeyID id = pubkey.GetID();
 
         // Check if this private key corresponds to a public key from the
         // descriptor
         if (!pubkey_map.count(id)) {
             warnings.push_back("Ignoring irrelevant private key.");
         } else {
             privkey_map.emplace(id, key);
         }
     }
 
     // Check if all the public keys have corresponding private keys in the
     // import for spendability. This does not take into account threshold
     // multisigs which could be spendable without all keys. Thus, threshold
     // multisigs without all keys will be considered not spendable here, even if
     // they are, perhaps triggering a false warning message. This is consistent
     // with the current wallet IsMine check.
     bool spendable =
         std::all_of(pubkey_map.begin(), pubkey_map.end(),
                     [&](const std::pair<CKeyID, CPubKey> &used_key) {
                         return privkey_map.count(used_key.first) > 0;
                     }) &&
         std::all_of(
             import_data.key_origins.begin(), import_data.key_origins.end(),
             [&](const std::pair<CKeyID, std::pair<CPubKey, KeyOriginInfo>>
                     &entry) { return privkey_map.count(entry.first) > 0; });
     if (!watch_only && !spendable) {
         warnings.push_back(
             "Some private keys are missing, outputs will be considered "
             "watchonly. If this is intentional, specify the watchonly flag.");
     }
     if (watch_only && spendable) {
         warnings.push_back("All private keys are provided, outputs will be "
                            "considered spendable. If this is intentional, do "
                            "not specify the watchonly flag.");
     }
 
     return warnings;
 }
 
 static UniValue ProcessImport(CWallet *const pwallet, const UniValue &data,
                               const int64_t timestamp)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     UniValue warnings(UniValue::VARR);
     UniValue result(UniValue::VOBJ);
 
     try {
         const bool internal =
             data.exists("internal") ? data["internal"].get_bool() : false;
         // Internal addresses should not have a label
         if (internal && data.exists("label")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Internal addresses should not have a label");
         }
         const std::string &label =
             data.exists("label") ? data["label"].get_str() : "";
         const bool add_keypool =
             data.exists("keypool") ? data["keypool"].get_bool() : false;
 
         // Add to keypool only works with privkeys disabled
         if (add_keypool &&
             !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Keys can only be imported to the keypool when "
                                "private keys are disabled");
         }
 
         ImportData import_data;
         std::map<CKeyID, CPubKey> pubkey_map;
         std::map<CKeyID, CKey> privkey_map;
         std::set<CScript> script_pub_keys;
         std::vector<CKeyID> ordered_pubkeys;
         bool have_solving_data;
 
         if (data.exists("scriptPubKey") && data.exists("desc")) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Both a descriptor and a scriptPubKey should not be provided.");
         } else if (data.exists("scriptPubKey")) {
             warnings = ProcessImportLegacy(
                 pwallet, import_data, pubkey_map, privkey_map, script_pub_keys,
                 have_solving_data, data, ordered_pubkeys);
         } else if (data.exists("desc")) {
             warnings = ProcessImportDescriptor(
                 import_data, pubkey_map, privkey_map, script_pub_keys,
                 have_solving_data, data, ordered_pubkeys);
         } else {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Either a descriptor or scriptPubKey must be provided.");
         }
 
         // If private keys are disabled, abort if private keys are being
         // imported
         if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
             !privkey_map.empty()) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Cannot import private keys to a wallet with "
                                "private keys disabled");
         }
 
         // Check whether we have any work to do
         for (const CScript &script : script_pub_keys) {
             if (pwallet->IsMine(script) & ISMINE_SPENDABLE) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "The wallet already contains the private "
                                    "key for this address or script (\"" +
                                        HexStr(script) + "\")");
             }
         }
 
         // All good, time to import
         pwallet->MarkDirty();
         if (!pwallet->ImportScripts(import_data.import_scripts, timestamp)) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Error adding script to wallet");
         }
         if (!pwallet->ImportPrivKeys(privkey_map, timestamp)) {
             throw JSONRPCError(RPC_WALLET_ERROR, "Error adding key to wallet");
         }
         if (!pwallet->ImportPubKeys(ordered_pubkeys, pubkey_map,
                                     import_data.key_origins, add_keypool,
                                     internal, timestamp)) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Error adding address to wallet");
         }
         if (!pwallet->ImportScriptPubKeys(label, script_pub_keys,
                                           have_solving_data, !internal,
                                           timestamp)) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Error adding address to wallet");
         }
 
         result.pushKV("success", UniValue(true));
     } catch (const UniValue &e) {
         result.pushKV("success", UniValue(false));
         result.pushKV("error", e);
     } catch (...) {
         result.pushKV("success", UniValue(false));
         result.pushKV("error",
                       JSONRPCError(RPC_MISC_ERROR, "Missing required fields"));
     }
 
     if (warnings.size()) {
         result.pushKV("warnings", warnings);
     }
     return result;
 }
 
 static int64_t GetImportTimestamp(const UniValue &data, int64_t now) {
     if (data.exists("timestamp")) {
         const UniValue &timestamp = data["timestamp"];
         if (timestamp.isNum()) {
             return timestamp.get_int64();
         } else if (timestamp.isStr() && timestamp.get_str() == "now") {
             return now;
         }
         throw JSONRPCError(RPC_TYPE_ERROR,
                            strprintf("Expected number or \"now\" timestamp "
                                      "value for key. got type %s",
                                      uvTypeName(timestamp.type())));
     }
     throw JSONRPCError(RPC_TYPE_ERROR,
                        "Missing required timestamp field for key");
 }
 
 static std::string GetRescanErrorMessage(const std::string &object,
                                          const int64_t objectTimestamp,
                                          const int64_t blockTimestamp) {
     return strprintf(
         "Rescan failed for %s with creation timestamp %d. There was an error "
         "reading a block from time %d, which is after or within %d seconds of "
         "key creation, and could contain transactions pertaining to the %s. As "
         "a result, transactions and coins using this %s may not appear in "
         "the wallet. This error could be caused by pruning or data corruption "
         "(see bitcoind log for details) and could be dealt with by downloading "
         "and rescanning the relevant blocks (see -reindex and -rescan "
         "options).",
         object, objectTimestamp, blockTimestamp, TIMESTAMP_WINDOW, object,
         object);
 }
 
 RPCHelpMan importmulti() {
     return RPCHelpMan{
         "importmulti",
         "Import addresses/scripts (with private or public keys, redeem "
         "script (P2SH)), optionally rescanning the blockchain from the "
         "earliest creation time of the imported scripts. Requires a new wallet "
         "backup.\n"
         "If an address/script is imported without all of the private keys "
         "required to spend from that address, it will be watchonly. The "
         "'watchonly' option must be set to true in this case or a warning will "
         "be returned.\n"
         "Conversely, if all the private keys are provided and the "
         "address/script is spendable, the watchonly option must be set to "
         "false, or a warning will be returned.\n"
         "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
         {
             {"requests",
              RPCArg::Type::ARR,
              RPCArg::Optional::NO,
              "Data to be imported",
              {
                  {
                      "",
                      RPCArg::Type::OBJ,
                      RPCArg::Optional::OMITTED,
                      "",
                      {
                          {"desc", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                           "Descriptor to import. If using descriptor, do not "
                           "also provide address/scriptPubKey, scripts, or "
                           "pubkeys"},
                          {"scriptPubKey",
                           RPCArg::Type::STR,
                           RPCArg::Optional::NO,
                           "Type of scriptPubKey (string for script, json for "
                           "address). Should not be provided if using a "
                           "descriptor",
                           /* oneline_description */ "",
                           {"\"<script>\" | { \"address\":\"<address>\" }",
                            "string / json"}},
                          {"timestamp",
                           RPCArg::Type::NUM,
                           RPCArg::Optional::NO,
                           "Creation time of the key expressed in " +
                               UNIX_EPOCH_TIME +
                               ",\n"
                               "                                            "
                               "                  or the string \"now\" to "
                               "substitute the current synced blockchain time. "
                               "The "
                               "timestamp of the oldest\n"
                               "                                            "
                               "                  key will determine how far "
                               "back "
                               "blockchain rescans need to begin for missing "
                               "wallet "
                               "transactions.\n"
                               "                                            "
                               "                  \"now\" can be specified to "
                               "bypass scanning, for keys which are known to "
                               "never "
                               "have been used, and\n"
                               "                                            "
                               "                  0 can be specified to scan "
                               "the "
                               "entire blockchain. Blocks up to 2 hours before "
                               "the "
                               "earliest key\n"
                               "                                            "
                               "                  creation time of all keys "
                               "being "
                               "imported by the importmulti call will be "
                               "scanned.",
                           /* oneline_description */ "",
                           {"timestamp | \"now\"", "integer / string"}},
                          {"redeemscript", RPCArg::Type::STR,
                           RPCArg::Optional::OMITTED,
                           "Allowed only if the scriptPubKey is a P2SH "
                           "address/scriptPubKey"},
                          {"pubkeys",
                           RPCArg::Type::ARR,
                           /* default */ "empty array",
                           "Array of strings giving pubkeys to import. They "
                           "must occur in P2PKH scripts. They are not required "
                           "when the private key is also provided (see the "
                           "\"keys\" argument).",
                           {
                               {"pubKey", RPCArg::Type::STR,
                                RPCArg::Optional::OMITTED, ""},
                           }},
                          {"keys",
                           RPCArg::Type::ARR,
                           /* default */ "empty array",
                           "Array of strings giving private keys to import. The "
                           "corresponding public keys must occur in the output "
                           "or redeemscript.",
                           {
                               {"key", RPCArg::Type::STR,
                                RPCArg::Optional::OMITTED, ""},
                           }},
                          {"range", RPCArg::Type::RANGE,
                           RPCArg::Optional::OMITTED,
                           "If a ranged descriptor is used, this specifies the "
                           "end or the range (in the form [begin,end]) to "
                           "import"},
                          {"internal", RPCArg::Type::BOOL,
                           /* default */ "false",
                           "Stating whether matching outputs should be treated "
                           "as not incoming payments (also known as change)"},
                          {"watchonly", RPCArg::Type::BOOL,
                           /* default */ "false",
                           "Stating whether matching outputs should be "
                           "considered watchonly."},
                          {"label", RPCArg::Type::STR, /* default */ "''",
                           "Label to assign to the address, only allowed with "
                           "internal=false"},
                          {"keypool", RPCArg::Type::BOOL, /* default */ "false",
                           "Stating whether imported public keys should be "
                           "added to the keypool for when users request new "
                           "addresses. Only allowed when wallet private keys "
                           "are disabled"},
                      },
                  },
              },
              "\"requests\""},
             {"options",
              RPCArg::Type::OBJ,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "",
              {
                  {"rescan", RPCArg::Type::BOOL, /* default */ "true",
                   "Stating if should rescan the blockchain after all imports"},
              },
              "\"options\""},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "Response is an array with the same size as the input that "
                   "has the execution result",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::BOOL, "success", ""},
                            {RPCResult::Type::ARR,
                             "warnings",
                             /* optional */ true,
                             "",
                             {
                                 {RPCResult::Type::STR, "", ""},
                             }},
                            {RPCResult::Type::OBJ,
                             "error",
                             /* optional */ true,
                             "",
                             {
                                 {RPCResult::Type::ELISION, "", "JSONRPC error"},
                             }},
                        }},
                   }},
         RPCExamples{
             HelpExampleCli(
                 "importmulti",
                 "'[{ \"scriptPubKey\": { \"address\": \"<my address>\" }, "
                 "\"timestamp\":1455191478 }, "
                 "{ \"scriptPubKey\": { \"address\": \"<my 2nd address>\" "
                 "}, "
                 "\"label\": \"example 2\", \"timestamp\": 1455191480 }]'") +
             HelpExampleCli(
                 "importmulti",
                 "'[{ \"scriptPubKey\": { \"address\": \"<my address>\" }, "
                 "\"timestamp\":1455191478 }]' '{ \"rescan\": false}'")
 
         },
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &mainRequest) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(mainRequest);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             RPCTypeCheck(mainRequest.params, {UniValue::VARR, UniValue::VOBJ});
 
             EnsureLegacyScriptPubKeyMan(*wallet, true);
 
             const UniValue &requests = mainRequest.params[0];
 
             // Default options
             bool fRescan = true;
 
             if (!mainRequest.params[1].isNull()) {
                 const UniValue &options = mainRequest.params[1];
 
                 if (options.exists("rescan")) {
                     fRescan = options["rescan"].get_bool();
                 }
             }
 
             WalletRescanReserver reserver(*pwallet);
             if (fRescan && !reserver.reserve()) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Wallet is currently rescanning. Abort "
                                    "existing rescan or wait.");
             }
 
             int64_t now = 0;
             bool fRunScan = false;
             int64_t nLowestTimestamp = 0;
             UniValue response(UniValue::VARR);
             {
                 LOCK(pwallet->cs_wallet);
                 EnsureWalletIsUnlocked(pwallet);
 
                 // Verify all timestamps are present before importing any keys.
                 CHECK_NONFATAL(pwallet->chain().findBlock(
                     pwallet->GetLastBlockHash(),
                     FoundBlock().time(nLowestTimestamp).mtpTime(now)));
                 for (const UniValue &data : requests.getValues()) {
                     GetImportTimestamp(data, now);
                 }
 
                 const int64_t minimumTimestamp = 1;
 
                 for (const UniValue &data : requests.getValues()) {
                     const int64_t timestamp = std::max(
                         GetImportTimestamp(data, now), minimumTimestamp);
                     const UniValue result =
                         ProcessImport(pwallet, data, timestamp);
                     response.push_back(result);
 
                     if (!fRescan) {
                         continue;
                     }
 
                     // If at least one request was successful then allow rescan.
                     if (result["success"].get_bool()) {
                         fRunScan = true;
                     }
 
                     // Get the lowest timestamp.
                     if (timestamp < nLowestTimestamp) {
                         nLowestTimestamp = timestamp;
                     }
                 }
             }
             if (fRescan && fRunScan && requests.size()) {
                 int64_t scannedTime = pwallet->RescanFromTime(
                     nLowestTimestamp, reserver, true /* update */);
                 {
                     LOCK(pwallet->cs_wallet);
                     pwallet->ReacceptWalletTransactions();
                 }
 
                 if (pwallet->IsAbortingRescan()) {
                     throw JSONRPCError(RPC_MISC_ERROR,
                                        "Rescan aborted by user.");
                 }
                 if (scannedTime > nLowestTimestamp) {
                     std::vector<UniValue> results = response.getValues();
                     response.clear();
                     response.setArray();
                     size_t i = 0;
                     for (const UniValue &request : requests.getValues()) {
                         // If key creation date is within the successfully
                         // scanned range, or if the import result already has an
                         // error set, let the result stand unmodified. Otherwise
                         // replace the result with an error message.
                         if (scannedTime <= GetImportTimestamp(request, now) ||
                             results.at(i).exists("error")) {
                             response.push_back(results.at(i));
                         } else {
                             UniValue result = UniValue(UniValue::VOBJ);
                             result.pushKV("success", UniValue(false));
                             result.pushKV(
                                 "error",
                                 JSONRPCError(
                                     RPC_MISC_ERROR,
                                     GetRescanErrorMessage(
                                         "key", GetImportTimestamp(request, now),
                                         scannedTime - TIMESTAMP_WINDOW - 1)));
                             response.push_back(std::move(result));
                         }
                         ++i;
                     }
                 }
             }
 
             return response;
         },
     };
 }
 
 static UniValue ProcessDescriptorImport(CWallet *const pwallet,
                                         const UniValue &data,
                                         const int64_t timestamp)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     UniValue warnings(UniValue::VARR);
     UniValue result(UniValue::VOBJ);
 
     try {
         if (!data.exists("desc")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Descriptor not found.");
         }
 
         const std::string &descriptor = data["desc"].get_str();
         const bool active =
             data.exists("active") ? data["active"].get_bool() : false;
         const bool internal =
             data.exists("internal") ? data["internal"].get_bool() : false;
         const std::string &label =
             data.exists("label") ? data["label"].get_str() : "";
 
         // Parse descriptor string
         FlatSigningProvider keys;
         std::string error;
         auto parsed_desc =
             Parse(descriptor, keys, error, /* require_checksum = */ true);
         if (!parsed_desc) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
         }
 
         // Range check
         int64_t range_start = 0, range_end = 1, next_index = 0;
         if (!parsed_desc->IsRange() && data.exists("range")) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Range should not be specified for an un-ranged descriptor");
         } else if (parsed_desc->IsRange()) {
             if (data.exists("range")) {
                 auto range = ParseDescriptorRange(data["range"]);
                 range_start = range.first;
                 // Specified range end is inclusive, but we need range end as
                 // exclusive
                 range_end = range.second + 1;
             } else {
                 warnings.push_back(
                     "Range not given, using default keypool range");
                 range_start = 0;
                 range_end = gArgs.GetIntArg("-keypool", DEFAULT_KEYPOOL_SIZE);
             }
             next_index = range_start;
 
             if (data.exists("next_index")) {
                 next_index = data["next_index"].get_int64();
                 // bound checks
                 if (next_index < range_start || next_index >= range_end) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "next_index is out of range");
                 }
             }
         }
 
         // Active descriptors must be ranged
         if (active && !parsed_desc->IsRange()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Active descriptors must be ranged");
         }
 
         // Ranged descriptors should not have a label
         if (data.exists("range") && data.exists("label")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Ranged descriptors should not have a label");
         }
 
         // Internal addresses should not have a label either
         if (internal && data.exists("label")) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Internal addresses should not have a label");
         }
 
         // Combo descriptor check
         if (active && !parsed_desc->IsSingleType()) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Combo descriptors cannot be set to active");
         }
 
         // If the wallet disabled private keys, abort if private keys exist
         if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
             !keys.keys.empty()) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Cannot import private keys to a wallet with "
                                "private keys disabled");
         }
 
         // Need to ExpandPrivate to check if private keys are available for all
         // pubkeys
         FlatSigningProvider expand_keys;
         std::vector<CScript> scripts;
         if (!parsed_desc->Expand(0, keys, scripts, expand_keys)) {
             throw JSONRPCError(
                 RPC_WALLET_ERROR,
                 "Cannot expand descriptor. Probably because of hardened "
                 "derivations without private keys provided");
         }
         parsed_desc->ExpandPrivate(0, keys, expand_keys);
 
         // Check if all private keys are provided
         bool have_all_privkeys = !expand_keys.keys.empty();
         for (const auto &entry : expand_keys.origins) {
             const CKeyID &key_id = entry.first;
             CKey key;
             if (!expand_keys.GetKey(key_id, key)) {
                 have_all_privkeys = false;
                 break;
             }
         }
 
         // If private keys are enabled, check some things.
         if (!pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
             if (keys.keys.empty()) {
                 throw JSONRPCError(
                     RPC_WALLET_ERROR,
                     "Cannot import descriptor without private keys to a wallet "
                     "with private keys enabled");
             }
             if (!have_all_privkeys) {
                 warnings.push_back(
                     "Not all private keys provided. Some wallet functionality "
                     "may return unexpected errors");
             }
         }
 
         WalletDescriptor w_desc(std::move(parsed_desc), timestamp, range_start,
                                 range_end, next_index);
 
         // Check if the wallet already contains the descriptor
         auto existing_spk_manager =
             pwallet->GetDescriptorScriptPubKeyMan(w_desc);
         if (existing_spk_manager) {
             LOCK(existing_spk_manager->cs_desc_man);
             if (range_start >
                 existing_spk_manager->GetWalletDescriptor().range_start) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMS,
                     strprintf(
                         "range_start can only decrease; current range = "
                         "[%d,%d]",
                         existing_spk_manager->GetWalletDescriptor().range_start,
                         existing_spk_manager->GetWalletDescriptor().range_end));
             }
         }
 
         // Add descriptor to the wallet
         auto spk_manager =
             pwallet->AddWalletDescriptor(w_desc, keys, label, internal);
         if (spk_manager == nullptr) {
             throw JSONRPCError(
                 RPC_WALLET_ERROR,
                 strprintf("Could not add descriptor '%s'", descriptor));
         }
 
         // Set descriptor as active if necessary
         if (active) {
             if (!w_desc.descriptor->GetOutputType()) {
                 warnings.push_back(
                     "Unknown output type, cannot set descriptor to active.");
             } else {
                 pwallet->AddActiveScriptPubKeyMan(
                     spk_manager->GetID(), *w_desc.descriptor->GetOutputType(),
                     internal);
             }
         }
 
         result.pushKV("success", UniValue(true));
     } catch (const UniValue &e) {
         result.pushKV("success", UniValue(false));
         result.pushKV("error", e);
     } catch (...) {
         result.pushKV("success", UniValue(false));
 
         result.pushKV("error",
                       JSONRPCError(RPC_MISC_ERROR, "Missing required fields"));
     }
     if (warnings.size()) {
         result.pushKV("warnings", warnings);
     }
     return result;
 }
 
 RPCHelpMan importdescriptors() {
     return RPCHelpMan{
         "importdescriptors",
         "Import descriptors. This will trigger a rescan of the blockchain "
         "based on the earliest timestamp of all descriptors being imported. "
         "Requires a new wallet backup.\n"
         "\nNote: This call can take over an hour to complete if using an early "
         "timestamp; during that time, other rpc calls\n"
         "may report that the imported keys, addresses or scripts exist but "
         "related transactions are still missing.\n",
         {
             {"requests",
              RPCArg::Type::ARR,
              RPCArg::Optional::NO,
              "Data to be imported",
              {
                  {
                      "",
                      RPCArg::Type::OBJ,
                      RPCArg::Optional::OMITTED,
                      "",
                      {
                          {"desc", RPCArg::Type::STR, RPCArg::Optional::NO,
                           "Descriptor to import."},
                          {"active", RPCArg::Type::BOOL, /* default */ "false",
                           "Set this descriptor to be the active descriptor for "
                           "the corresponding output type/externality"},
                          {"range", RPCArg::Type::RANGE,
                           RPCArg::Optional::OMITTED,
                           "If a ranged descriptor is used, this specifies the "
                           "end or the range (in the form [begin,end]) to "
                           "import"},
                          {"next_index", RPCArg::Type::NUM,
                           RPCArg::Optional::OMITTED,
                           "If a ranged descriptor is set to active, this "
                           "specifies the next index to generate addresses "
                           "from"},
                          {"timestamp",
                           RPCArg::Type::NUM,
                           RPCArg::Optional::NO,
                           "Time from which to start rescanning the blockchain "
                           "for this descriptor, in " +
                               UNIX_EPOCH_TIME +
                               "\n"
                               "                                                "
                               "              Use the string \"now\" to "
                               "substitute the current synced blockchain time.\n"
                               "                                                "
                               "              \"now\" can be specified to "
                               "bypass scanning, for outputs which are known to "
                               "never have been used, and\n"
                               "                                                "
                               "              0 can be specified to scan the "
                               "entire blockchain. Blocks up to 2 hours before "
                               "the earliest timestamp\n"
                               "                                                "
                               "              of all descriptors being imported "
                               "will be scanned.",
                           /* oneline_description */ "",
                           {"timestamp | \"now\"", "integer / string"}},
                          {"internal", RPCArg::Type::BOOL, /* default */ "false",
                           "Whether matching outputs should be treated as not "
                           "incoming payments (e.g. change)"},
                          {"label", RPCArg::Type::STR, /* default */ "''",
                           "Label to assign to the address, only allowed with "
                           "internal=false"},
                      },
                  },
              },
              "\"requests\""},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "Response is an array with the same size as the input that "
                   "has the execution result",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::BOOL, "success", ""},
                            {RPCResult::Type::ARR,
                             "warnings",
                             /* optional */ true,
                             "",
                             {
                                 {RPCResult::Type::STR, "", ""},
                             }},
                            {RPCResult::Type::OBJ,
                             "error",
                             /* optional */ true,
                             "",
                             {
                                 {RPCResult::Type::ELISION, "", "JSONRPC error"},
                             }},
                        }},
                   }},
         RPCExamples{
             HelpExampleCli("importdescriptors",
                            "'[{ \"desc\": \"<my descriptor>\", "
                            "\"timestamp\":1455191478, \"internal\": true }, "
                            "{ \"desc\": \"<my desccriptor 2>\", \"label\": "
                            "\"example 2\", \"timestamp\": 1455191480 }]'") +
             HelpExampleCli(
                 "importdescriptors",
                 "'[{ \"desc\": \"<my descriptor>\", \"timestamp\":1455191478, "
                 "\"active\": true, \"range\": [0,100], \"label\": \"<my "
                 "cashaddr wallet>\" }]'")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &main_request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(main_request);
             if (!wallet) {
                 return NullUniValue;
             }
             CWallet *const pwallet = wallet.get();
 
             //  Make sure wallet is a descriptor wallet
             if (!pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "importdescriptors is not available for "
                                    "non-descriptor wallets");
             }
 
             RPCTypeCheck(main_request.params, {UniValue::VARR, UniValue::VOBJ});
 
             WalletRescanReserver reserver(*pwallet);
             if (!reserver.reserve()) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Wallet is currently rescanning. Abort "
                                    "existing rescan or wait.");
             }
 
             const UniValue &requests = main_request.params[0];
             const int64_t minimum_timestamp = 1;
             int64_t now = 0;
             int64_t lowest_timestamp = 0;
             bool rescan = false;
             UniValue response(UniValue::VARR);
             {
                 LOCK(pwallet->cs_wallet);
                 EnsureWalletIsUnlocked(pwallet);
 
                 CHECK_NONFATAL(pwallet->chain().findBlock(
                     pwallet->GetLastBlockHash(),
                     FoundBlock().time(lowest_timestamp).mtpTime(now)));
 
                 // Get all timestamps and extract the lowest timestamp
                 for (const UniValue &request : requests.getValues()) {
                     // This throws an error if "timestamp" doesn't exist
                     const int64_t timestamp = std::max(
                         GetImportTimestamp(request, now), minimum_timestamp);
                     const UniValue result =
                         ProcessDescriptorImport(pwallet, request, timestamp);
                     response.push_back(result);
 
                     if (lowest_timestamp > timestamp) {
                         lowest_timestamp = timestamp;
                     }
 
                     // If we know the chain tip, and at least one request was
                     // successful then allow rescan
                     if (!rescan && result["success"].get_bool()) {
                         rescan = true;
                     }
                 }
                 pwallet->ConnectScriptPubKeyManNotifiers();
             }
 
             // Rescan the blockchain using the lowest timestamp
             if (rescan) {
                 int64_t scanned_time = pwallet->RescanFromTime(
                     lowest_timestamp, reserver, true /* update */);
                 {
                     LOCK(pwallet->cs_wallet);
                     pwallet->ReacceptWalletTransactions();
                 }
 
                 if (pwallet->IsAbortingRescan()) {
                     throw JSONRPCError(RPC_MISC_ERROR,
                                        "Rescan aborted by user.");
                 }
 
                 if (scanned_time > lowest_timestamp) {
                     std::vector<UniValue> results = response.getValues();
                     response.clear();
                     response.setArray();
 
                     // Compose the response
                     for (unsigned int i = 0; i < requests.size(); ++i) {
                         const UniValue &request = requests.getValues().at(i);
 
                         // If the descriptor timestamp is within the
                         // successfully scanned range, or if the import result
                         // already has an error set, let the result stand
                         // unmodified. Otherwise replace the result with an
                         // error message.
                         if (scanned_time <= GetImportTimestamp(request, now) ||
                             results.at(i).exists("error")) {
                             response.push_back(results.at(i));
                         } else {
                             UniValue result = UniValue(UniValue::VOBJ);
                             result.pushKV("success", UniValue(false));
                             result.pushKV(
                                 "error",
                                 JSONRPCError(
                                     RPC_MISC_ERROR,
                                     GetRescanErrorMessage(
                                         "descriptor",
                                         GetImportTimestamp(request, now),
                                         scanned_time - TIMESTAMP_WINDOW - 1)));
                             response.push_back(std::move(result));
                         }
                     }
                 }
             }
 
             return response;
         },
     };
 }
 
 RPCHelpMan backupwallet() {
     return RPCHelpMan{
         "backupwallet",
         "Safely copies current wallet file to destination, which can be a "
         "directory or a path with filename.\n",
         {
             {"destination", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The destination directory or file"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("backupwallet", "\"backup.dat\"") +
                     HelpExampleRpc("backupwallet", "\"backup.dat\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CWallet> const wallet =
                 GetWalletForJSONRPCRequest(request);
             if (!wallet) {
                 return NullUniValue;
             }
             const CWallet *const pwallet = wallet.get();
 
             // Make sure the results are valid at least up to the most recent
             // block the user could have gotten from another RPC command prior
             // to now
             pwallet->BlockUntilSyncedToCurrentChain();
 
             LOCK(pwallet->cs_wallet);
 
             std::string strDest = request.params[0].get_str();
             if (!pwallet->BackupWallet(strDest)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error: Wallet backup failed!");
             }
 
             return NullUniValue;
         },
     };
 }
 
 RPCHelpMan restorewallet() {
     return RPCHelpMan{
         "restorewallet",
         "\nRestore and loads a wallet from backup.\n",
         {
             {"wallet_name", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The name that will be applied to the restored wallet"},
             {"backup_file", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The backup file that will be used to restore the wallet."},
             {"load_on_startup", RPCArg::Type::BOOL,
              RPCArg::Optional::OMITTED_NAMED_ARG,
              "Save wallet name to persistent settings and load on startup. "
              "True to add wallet to startup list, false to remove, null to "
              "leave unchanged."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "name",
                        "The wallet name if restored successfully."},
                       {RPCResult::Type::STR, "warning",
                        "Warning message if wallet was not loaded cleanly."},
                   }},
         RPCExamples{HelpExampleCli(
                         "restorewallet",
                         "\"testwallet\" \"home\\backups\\backup-file.bak\"") +
                     HelpExampleRpc(
                         "restorewallet",
                         "\"testwallet\" \"home\\backups\\backup-file.bak\"") +
                     HelpExampleCliNamed(
                         "restorewallet",
                         {{"wallet_name", "testwallet"},
                          {"backup_file", "home\\backups\\backup-file.bak\""},
                          {"load_on_startup", true}}) +
                     HelpExampleRpcNamed(
                         "restorewallet",
                         {{"wallet_name", "testwallet"},
                          {"backup_file", "home\\backups\\backup-file.bak\""},
                          {"load_on_startup", true}})},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             WalletContext &context = EnsureWalletContext(request.context);
 
             fs::path backup_file =
                 fs::PathFromString(request.params[1].get_str());
 
             if (!fs::exists(backup_file)) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Backup file does not exist");
             }
 
             std::string wallet_name = request.params[0].get_str();
 
             const fs::path wallet_path = fsbridge::AbsPathJoin(
                 GetWalletDir(), fs::PathFromString(wallet_name));
 
             if (fs::exists(wallet_path)) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Wallet name already exists.");
             }
 
             if (!TryCreateDirectories(wallet_path)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    strprintf("Failed to create database path "
                                              "'%s'. Database already exists.",
                                              fs::PathToString(wallet_path)));
             }
 
             auto wallet_file = wallet_path / "wallet.dat";
 
-            fs::copy_file(backup_file, wallet_file,
-                          fs::copy_option::fail_if_exists);
+            fs::copy_file(backup_file, wallet_file, fs::copy_options::none);
 
             auto [wallet, warnings] =
                 LoadWalletHelper(context, request.params[2], wallet_name);
 
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("name", wallet->GetName());
             obj.pushKV("warning", Join(warnings, Untranslated("\n")).original);
 
             return obj;
         },
     };
 }
 
 Span<const CRPCCommand> GetWalletDumpRPCCommands() {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            actor (function)
         //  ------------------  ----------------------
         { "wallet",             abortrescan,              },
         { "wallet",             backupwallet,             },
         { "wallet",             dumpprivkey,              },
         { "wallet",             dumpwallet,               },
         { "wallet",             dumpcoins,                },
         { "wallet",             importdescriptors,        },
         { "wallet",             importmulti,              },
         { "wallet",             importprivkey,            },
         { "wallet",             importwallet,             },
         { "wallet",             importaddress,            },
         { "wallet",             importprunedfunds,        },
         { "wallet",             importpubkey,             },
         { "wallet",             removeprunedfunds,        },
         { "wallet",             restorewallet,            },
     };
     // clang-format on
 
     return MakeSpan(commands);
 }
diff --git a/src/wallet/test/db_tests.cpp b/src/wallet/test/db_tests.cpp
index 939461430..64438077e 100644
--- a/src/wallet/test/db_tests.cpp
+++ b/src/wallet/test/db_tests.cpp
@@ -1,77 +1,79 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/bdb.h>
 
 #include <fs.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <fstream>
 #include <memory>
+#include <string>
 
 BOOST_FIXTURE_TEST_SUITE(db_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(getwalletenv_file) {
     std::string test_name = "test_name.dat";
     const fs::path datadir = gArgs.GetDataDirNet();
     fs::path file_path = datadir / test_name;
-    fs::ofstream f(file_path);
+    std::ofstream f{file_path};
     f.close();
 
     std::string filename;
     std::shared_ptr<BerkeleyEnvironment> env =
         GetWalletEnv(file_path, filename);
     BOOST_CHECK(filename == test_name);
     BOOST_CHECK(env->Directory() == datadir);
 }
 
 BOOST_AUTO_TEST_CASE(getwalletenv_directory) {
     std::string expected_name = "wallet.dat";
     const fs::path datadir = gArgs.GetDataDirNet();
 
     std::string filename;
     std::shared_ptr<BerkeleyEnvironment> env = GetWalletEnv(datadir, filename);
     BOOST_CHECK(filename == expected_name);
     BOOST_CHECK(env->Directory() == datadir);
 }
 
 BOOST_AUTO_TEST_CASE(getwalletenv_g_dbenvs_multiple) {
     fs::path datadir = gArgs.GetDataDirNet() / "1";
     fs::path datadir_2 = gArgs.GetDataDirNet() / "2";
     std::string filename;
 
     std::shared_ptr<BerkeleyEnvironment> env_1 =
         GetWalletEnv(datadir, filename);
     std::shared_ptr<BerkeleyEnvironment> env_2 =
         GetWalletEnv(datadir, filename);
     std::shared_ptr<BerkeleyEnvironment> env_3 =
         GetWalletEnv(datadir_2, filename);
 
     BOOST_CHECK(env_1 == env_2);
     BOOST_CHECK(env_2 != env_3);
 }
 
 BOOST_AUTO_TEST_CASE(getwalletenv_g_dbenvs_free_instance) {
     fs::path datadir = gArgs.GetDataDirNet() / "1";
     fs::path datadir_2 = gArgs.GetDataDirNet() / "2";
     std::string filename;
 
     std::shared_ptr<BerkeleyEnvironment> env_1_a =
         GetWalletEnv(datadir, filename);
     std::shared_ptr<BerkeleyEnvironment> env_2_a =
         GetWalletEnv(datadir_2, filename);
     env_1_a.reset();
 
     std::shared_ptr<BerkeleyEnvironment> env_1_b =
         GetWalletEnv(datadir, filename);
     std::shared_ptr<BerkeleyEnvironment> env_2_b =
         GetWalletEnv(datadir_2, filename);
 
     BOOST_CHECK(env_1_a != env_1_b);
     BOOST_CHECK(env_2_a == env_2_b);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/test/init_test_fixture.cpp b/src/wallet/test/init_test_fixture.cpp
index 56f563ec5..33737f59e 100644
--- a/src/wallet/test/init_test_fixture.cpp
+++ b/src/wallet/test/init_test_fixture.cpp
@@ -1,50 +1,53 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/test/init_test_fixture.h>
 
 #include <chainparams.h>
 #include <fs.h>
 #include <univalue.h>
 #include <util/check.h>
 #include <util/system.h>
 
+#include <fstream>
+#include <string>
+
 InitWalletDirTestingSetup::InitWalletDirTestingSetup(
     const std::string &chainName)
     : BasicTestingSetup(chainName) {
     m_wallet_client = MakeWalletClient(*m_node.chain, *Assert(m_node.args));
 
     std::string sep;
     sep += fs::path::preferred_separator;
 
     m_datadir = gArgs.GetDataDirNet();
     m_cwd = fs::current_path();
 
     m_walletdir_path_cases["default"] = m_datadir / "wallets";
     m_walletdir_path_cases["custom"] = m_datadir / "my_wallets";
     m_walletdir_path_cases["nonexistent"] = m_datadir / "path_does_not_exist";
     m_walletdir_path_cases["file"] = m_datadir / "not_a_directory.dat";
-    m_walletdir_path_cases["trailing"] = m_datadir / "wallets" / sep;
-    m_walletdir_path_cases["trailing2"] = m_datadir / "wallets" / sep / sep;
+    m_walletdir_path_cases["trailing"] = m_datadir / ("wallets" + sep);
+    m_walletdir_path_cases["trailing2"] = m_datadir / ("wallets" + sep + sep);
 
     fs::current_path(m_datadir);
     m_walletdir_path_cases["relative"] = "wallets";
 
     fs::create_directories(m_walletdir_path_cases["default"]);
     fs::create_directories(m_walletdir_path_cases["custom"]);
     fs::create_directories(m_walletdir_path_cases["relative"]);
-    fs::ofstream f(m_walletdir_path_cases["file"]);
+    std::ofstream f{m_walletdir_path_cases["file"]};
     f.close();
 }
 
 InitWalletDirTestingSetup::~InitWalletDirTestingSetup() {
     gArgs.LockSettings([&](util::Settings &settings) {
         settings.forced_settings.erase("walletdir");
     });
     fs::current_path(m_cwd);
 }
 
 void InitWalletDirTestingSetup::SetWalletDir(const fs::path &walletdir_path) {
     gArgs.ForceSetArg("-walletdir", fs::PathToString(walletdir_path));
 }
diff --git a/src/wallet/test/init_tests.cpp b/src/wallet/test/init_tests.cpp
index 497d8bc57..7523967ef 100644
--- a/src/wallet/test/init_tests.cpp
+++ b/src/wallet/test/init_tests.cpp
@@ -1,79 +1,83 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <noui.h>
 #include <test/util/logging.h>
 #include <util/system.h>
 
 #include <test/util/setup_common.h>
 #include <wallet/test/init_test_fixture.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(init_tests, InitWalletDirTestingSetup)
 
 BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_default) {
     SetWalletDir(m_walletdir_path_cases["default"]);
     bool result = m_wallet_client->verify();
     BOOST_CHECK(result == true);
     fs::path walletdir = fs::PathFromString(gArgs.GetArg("-walletdir", ""));
     fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]);
     BOOST_CHECK(walletdir == expected_path);
 }
 
 BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_custom) {
     SetWalletDir(m_walletdir_path_cases["custom"]);
     bool result = m_wallet_client->verify();
     BOOST_CHECK(result == true);
     fs::path walletdir = fs::PathFromString(gArgs.GetArg("-walletdir", ""));
     fs::path expected_path = fs::canonical(m_walletdir_path_cases["custom"]);
     BOOST_CHECK(walletdir == expected_path);
 }
 
 BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_does_not_exist) {
     SetWalletDir(m_walletdir_path_cases["nonexistent"]);
     {
         ASSERT_DEBUG_LOG("does not exist");
         bool result = m_wallet_client->verify();
         BOOST_CHECK(result == false);
     }
 }
 
 BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_is_not_directory) {
     SetWalletDir(m_walletdir_path_cases["file"]);
     {
         ASSERT_DEBUG_LOG("is not a directory");
         bool result = m_wallet_client->verify();
         BOOST_CHECK(result == false);
     }
 }
 
 BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_is_not_relative) {
     SetWalletDir(m_walletdir_path_cases["relative"]);
     {
         ASSERT_DEBUG_LOG("is a relative path");
         bool result = m_wallet_client->verify();
         BOOST_CHECK(result == false);
     }
 }
 
+#ifndef WIN32
+// Windows does not consider "datadir/wallets//" to be a valid directory path.
+// FIXME: enable these tests again ASAP (D13730 & core#24251)
 BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_no_trailing) {
     SetWalletDir(m_walletdir_path_cases["trailing"]);
     bool result = m_wallet_client->verify();
     BOOST_CHECK(result == true);
     fs::path walletdir = fs::PathFromString(gArgs.GetArg("-walletdir", ""));
     fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]);
     BOOST_CHECK(walletdir == expected_path);
 }
 
 BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_no_trailing2) {
     SetWalletDir(m_walletdir_path_cases["trailing2"]);
     bool result = m_wallet_client->verify();
     BOOST_CHECK(result == true);
     fs::path walletdir = fs::PathFromString(gArgs.GetArg("-walletdir", ""));
     fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]);
     BOOST_CHECK(walletdir == expected_path);
 }
+#endif
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 40d0ba31f..33f0860ef 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1,3489 +1,3491 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/wallet.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <fs.h>
 #include <interfaces/wallet.h>
 #include <key.h>
 #include <key_io.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/sighashtype.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <support/cleanse.h>
 #include <txmempool.h>
 #include <univalue.h>
 #include <util/bip32.h>
 #include <util/check.h>
 #include <util/error.h>
 #include <util/moneystr.h>
 #include <util/string.h>
 #include <util/translation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/fees.h>
 
 using interfaces::FoundBlock;
 
 const std::map<uint64_t, std::string> WALLET_FLAG_CAVEATS{
     {WALLET_FLAG_AVOID_REUSE,
      "You need to rescan the blockchain in order to correctly mark used "
      "destinations in the past. Until this is done, some destinations may "
      "be considered unused, even if the opposite is the case."},
 };
 
 RecursiveMutex cs_wallets;
 static std::vector<std::shared_ptr<CWallet>> vpwallets GUARDED_BY(cs_wallets);
 static std::list<LoadWalletFn> g_load_wallet_fns GUARDED_BY(cs_wallets);
 
 bool AddWalletSetting(interfaces::Chain &chain,
                       const std::string &wallet_name) {
     util::SettingsValue setting_value = chain.getRwSetting("wallet");
     if (!setting_value.isArray()) {
         setting_value.setArray();
     }
     for (const util::SettingsValue &value : setting_value.getValues()) {
         if (value.isStr() && value.get_str() == wallet_name) {
             return true;
         }
     }
     setting_value.push_back(wallet_name);
     return chain.updateRwSetting("wallet", setting_value);
 }
 
 bool RemoveWalletSetting(interfaces::Chain &chain,
                          const std::string &wallet_name) {
     util::SettingsValue setting_value = chain.getRwSetting("wallet");
     if (!setting_value.isArray()) {
         return true;
     }
     util::SettingsValue new_value(util::SettingsValue::VARR);
     for (const util::SettingsValue &value : setting_value.getValues()) {
         if (!value.isStr() || value.get_str() != wallet_name) {
             new_value.push_back(value);
         }
     }
     if (new_value.size() == setting_value.size()) {
         return true;
     }
     return chain.updateRwSetting("wallet", new_value);
 }
 
 static void UpdateWalletSetting(interfaces::Chain &chain,
                                 const std::string &wallet_name,
                                 std::optional<bool> load_on_startup,
                                 std::vector<bilingual_str> &warnings) {
     if (!load_on_startup) {
         return;
     }
     if (load_on_startup.value() && !AddWalletSetting(chain, wallet_name)) {
         warnings.emplace_back(
             Untranslated("Wallet load on startup setting could not be updated, "
                          "so wallet may not be loaded next node startup."));
     } else if (!load_on_startup.value() &&
                !RemoveWalletSetting(chain, wallet_name)) {
         warnings.emplace_back(
             Untranslated("Wallet load on startup setting could not be updated, "
                          "so wallet may still be loaded next node startup."));
     }
 }
 
 bool AddWallet(const std::shared_ptr<CWallet> &wallet) {
     LOCK(cs_wallets);
     assert(wallet);
     std::vector<std::shared_ptr<CWallet>>::const_iterator i =
         std::find(vpwallets.begin(), vpwallets.end(), wallet);
     if (i != vpwallets.end()) {
         return false;
     }
     vpwallets.push_back(wallet);
     wallet->ConnectScriptPubKeyManNotifiers();
     wallet->NotifyCanGetAddressesChanged();
     return true;
 }
 
 bool RemoveWallet(const std::shared_ptr<CWallet> &wallet,
                   std::optional<bool> load_on_start,
                   std::vector<bilingual_str> &warnings) {
     assert(wallet);
 
     interfaces::Chain &chain = wallet->chain();
     std::string name = wallet->GetName();
 
     // Unregister with the validation interface which also drops shared ponters.
     wallet->m_chain_notifications_handler.reset();
     LOCK(cs_wallets);
     std::vector<std::shared_ptr<CWallet>>::iterator i =
         std::find(vpwallets.begin(), vpwallets.end(), wallet);
     if (i == vpwallets.end()) {
         return false;
     }
     vpwallets.erase(i);
 
     // Write the wallet setting
     UpdateWalletSetting(chain, name, load_on_start, warnings);
 
     return true;
 }
 
 bool RemoveWallet(const std::shared_ptr<CWallet> &wallet,
                   std::optional<bool> load_on_start) {
     std::vector<bilingual_str> warnings;
     return RemoveWallet(wallet, load_on_start, warnings);
 }
 
 std::vector<std::shared_ptr<CWallet>> GetWallets() {
     LOCK(cs_wallets);
     return vpwallets;
 }
 
 std::shared_ptr<CWallet> GetWallet(const std::string &name) {
     LOCK(cs_wallets);
     for (const std::shared_ptr<CWallet> &wallet : vpwallets) {
         if (wallet->GetName() == name) {
             return wallet;
         }
     }
     return nullptr;
 }
 
 std::unique_ptr<interfaces::Handler>
 HandleLoadWallet(LoadWalletFn load_wallet) {
     LOCK(cs_wallets);
     auto it = g_load_wallet_fns.emplace(g_load_wallet_fns.end(),
                                         std::move(load_wallet));
     return interfaces::MakeHandler([it] {
         LOCK(cs_wallets);
         g_load_wallet_fns.erase(it);
     });
 }
 
 static Mutex g_loading_wallet_mutex;
 static Mutex g_wallet_release_mutex;
 static std::condition_variable g_wallet_release_cv;
 static std::set<std::string>
     g_loading_wallet_set GUARDED_BY(g_loading_wallet_mutex);
 static std::set<std::string>
     g_unloading_wallet_set GUARDED_BY(g_wallet_release_mutex);
 
 // Custom deleter for shared_ptr<CWallet>.
 static void ReleaseWallet(CWallet *wallet) {
     const std::string name = wallet->GetName();
     wallet->WalletLogPrintf("Releasing wallet\n");
     wallet->Flush();
     delete wallet;
     // Wallet is now released, notify UnloadWallet, if any.
     {
         LOCK(g_wallet_release_mutex);
         if (g_unloading_wallet_set.erase(name) == 0) {
             // UnloadWallet was not called for this wallet, all done.
             return;
         }
     }
     g_wallet_release_cv.notify_all();
 }
 
 void UnloadWallet(std::shared_ptr<CWallet> &&wallet) {
     // Mark wallet for unloading.
     const std::string name = wallet->GetName();
     {
         LOCK(g_wallet_release_mutex);
         auto it = g_unloading_wallet_set.insert(name);
         assert(it.second);
     }
     // The wallet can be in use so it's not possible to explicitly unload here.
     // Notify the unload intent so that all remaining shared pointers are
     // released.
     wallet->NotifyUnload();
 
     // Time to ditch our shared_ptr and wait for ReleaseWallet call.
     wallet.reset();
     {
         WAIT_LOCK(g_wallet_release_mutex, lock);
         while (g_unloading_wallet_set.count(name) == 1) {
             g_wallet_release_cv.wait(lock);
         }
     }
 }
 
 namespace {
 std::shared_ptr<CWallet>
 LoadWalletInternal(interfaces::Chain &chain, const std::string &name,
                    std::optional<bool> load_on_start,
                    const DatabaseOptions &options, DatabaseStatus &status,
                    bilingual_str &error, std::vector<bilingual_str> &warnings) {
     try {
         std::unique_ptr<WalletDatabase> database =
             MakeWalletDatabase(name, options, status, error);
         if (!database) {
             error = Untranslated("Wallet file verification failed.") +
                     Untranslated(" ") + error;
             return nullptr;
         }
 
         std::shared_ptr<CWallet> wallet =
             CWallet::Create(chain, name, std::move(database),
                             options.create_flags, error, warnings);
         if (!wallet) {
             error = Untranslated("Wallet loading failed.") + Untranslated(" ") +
                     error;
             status = DatabaseStatus::FAILED_LOAD;
             return nullptr;
         }
         AddWallet(wallet);
         wallet->postInitProcess();
 
         // Write the wallet setting
         UpdateWalletSetting(chain, name, load_on_start, warnings);
 
         return wallet;
     } catch (const std::runtime_error &e) {
         error = Untranslated(e.what());
         status = DatabaseStatus::FAILED_LOAD;
         return nullptr;
     }
 }
 } // namespace
 
 std::shared_ptr<CWallet>
 LoadWallet(interfaces::Chain &chain, const std::string &name,
            std::optional<bool> load_on_start, const DatabaseOptions &options,
            DatabaseStatus &status, bilingual_str &error,
            std::vector<bilingual_str> &warnings) {
     auto result = WITH_LOCK(g_loading_wallet_mutex,
                             return g_loading_wallet_set.insert(name));
     if (!result.second) {
         error = Untranslated("Wallet already being loading.");
         status = DatabaseStatus::FAILED_LOAD;
         return nullptr;
     }
     auto wallet = LoadWalletInternal(chain, name, load_on_start, options,
                                      status, error, warnings);
     WITH_LOCK(g_loading_wallet_mutex, g_loading_wallet_set.erase(result.first));
     return wallet;
 }
 
 std::shared_ptr<CWallet>
 CreateWallet(interfaces::Chain &chain, const std::string &name,
              std::optional<bool> load_on_start, const DatabaseOptions &options,
              DatabaseStatus &status, bilingual_str &error,
              std::vector<bilingual_str> &warnings) {
     uint64_t wallet_creation_flags = options.create_flags;
     const SecureString &passphrase = options.create_passphrase;
 
     // Indicate that the wallet is actually supposed to be blank and not just
     // blank to make it encrypted
     bool create_blank = (wallet_creation_flags & WALLET_FLAG_BLANK_WALLET);
 
     // Born encrypted wallets need to be created blank first.
     if (!passphrase.empty()) {
         wallet_creation_flags |= WALLET_FLAG_BLANK_WALLET;
     }
 
     // Wallet::Verify will check if we're trying to create a wallet with a
     // duplicate name.
     std::unique_ptr<WalletDatabase> database =
         MakeWalletDatabase(name, options, status, error);
     if (!database) {
         error = Untranslated("Wallet file verification failed.") +
                 Untranslated(" ") + error;
         status = DatabaseStatus::FAILED_VERIFY;
         return nullptr;
     }
 
     // Do not allow a passphrase when private keys are disabled
     if (!passphrase.empty() &&
         (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         error = Untranslated(
             "Passphrase provided but private keys are disabled. A passphrase "
             "is only used to encrypt private keys, so cannot be used for "
             "wallets with private keys disabled.");
         status = DatabaseStatus::FAILED_CREATE;
         return nullptr;
     }
 
     // Make the wallet
     std::shared_ptr<CWallet> wallet =
         CWallet::Create(chain, name, std::move(database), wallet_creation_flags,
                         error, warnings);
     if (!wallet) {
         error =
             Untranslated("Wallet creation failed.") + Untranslated(" ") + error;
         status = DatabaseStatus::FAILED_CREATE;
         return nullptr;
     }
 
     // Encrypt the wallet
     if (!passphrase.empty() &&
         !(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         if (!wallet->EncryptWallet(passphrase)) {
             error =
                 Untranslated("Error: Wallet created but failed to encrypt.");
             status = DatabaseStatus::FAILED_ENCRYPT;
             return nullptr;
         }
         if (!create_blank) {
             // Unlock the wallet
             if (!wallet->Unlock(passphrase)) {
                 error = Untranslated(
                     "Error: Wallet was encrypted but could not be unlocked");
                 status = DatabaseStatus::FAILED_ENCRYPT;
                 return nullptr;
             }
 
             // Set a seed for the wallet
             {
                 LOCK(wallet->cs_wallet);
                 if (wallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
                     wallet->SetupDescriptorScriptPubKeyMans();
                 } else {
                     for (auto spk_man : wallet->GetActiveScriptPubKeyMans()) {
                         if (!spk_man->SetupGeneration()) {
                             error =
                                 Untranslated("Unable to generate initial keys");
                             status = DatabaseStatus::FAILED_CREATE;
                             return nullptr;
                         }
                     }
                 }
             }
 
             // Relock the wallet
             wallet->Lock();
         }
     }
     AddWallet(wallet);
     wallet->postInitProcess();
 
     // Write the wallet settings
     UpdateWalletSetting(chain, name, load_on_start, warnings);
 
     status = DatabaseStatus::SUCCESS;
     return wallet;
 }
 
 /** @defgroup mapWallet
  *
  * @{
  */
 
 const CChainParams &CWallet::GetChainParams() const {
     // Get CChainParams from interfaces::Chain, unless wallet doesn't have a
     // chain (i.e. bitcoin-wallet), in which case return global Params()
     return m_chain ? m_chain->params() : Params();
 }
 
 const CWalletTx *CWallet::GetWalletTx(const TxId &txid) const {
     AssertLockHeld(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
     if (it == mapWallet.end()) {
         return nullptr;
     }
 
     return &(it->second);
 }
 
 void CWallet::UpgradeKeyMetadata() {
     if (IsLocked() || IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
         return;
     }
 
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return;
     }
 
     spk_man->UpgradeKeyMetadata();
     SetWalletFlag(WALLET_FLAG_KEY_ORIGIN_METADATA);
 }
 
 bool CWallet::Unlock(const SecureString &strWalletPassphrase,
                      bool accept_no_keys) {
     CCrypter crypter;
     CKeyingMaterial _vMasterKey;
 
     {
         LOCK(cs_wallet);
         for (const MasterKeyMap::value_type &pMasterKey : mapMasterKeys) {
             if (!crypter.SetKeyFromPassphrase(
                     strWalletPassphrase, pMasterKey.second.vchSalt,
                     pMasterKey.second.nDeriveIterations,
                     pMasterKey.second.nDerivationMethod)) {
                 return false;
             }
             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey,
                                  _vMasterKey)) {
                 // try another master key
                 continue;
             }
             if (Unlock(_vMasterKey, accept_no_keys)) {
                 // Now that we've unlocked, upgrade the key metadata
                 UpgradeKeyMetadata();
                 return true;
             }
         }
     }
 
     return false;
 }
 
 bool CWallet::ChangeWalletPassphrase(
     const SecureString &strOldWalletPassphrase,
     const SecureString &strNewWalletPassphrase) {
     bool fWasLocked = IsLocked();
 
     LOCK(cs_wallet);
     Lock();
 
     CCrypter crypter;
     CKeyingMaterial _vMasterKey;
     for (MasterKeyMap::value_type &pMasterKey : mapMasterKeys) {
         if (!crypter.SetKeyFromPassphrase(
                 strOldWalletPassphrase, pMasterKey.second.vchSalt,
                 pMasterKey.second.nDeriveIterations,
                 pMasterKey.second.nDerivationMethod)) {
             return false;
         }
 
         if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey)) {
             return false;
         }
 
         if (Unlock(_vMasterKey)) {
             int64_t nStartTime = GetTimeMillis();
             crypter.SetKeyFromPassphrase(strNewWalletPassphrase,
                                          pMasterKey.second.vchSalt,
                                          pMasterKey.second.nDeriveIterations,
                                          pMasterKey.second.nDerivationMethod);
             pMasterKey.second.nDeriveIterations = static_cast<unsigned int>(
                 pMasterKey.second.nDeriveIterations *
                 (100 / ((double)(GetTimeMillis() - nStartTime))));
 
             nStartTime = GetTimeMillis();
             crypter.SetKeyFromPassphrase(strNewWalletPassphrase,
                                          pMasterKey.second.vchSalt,
                                          pMasterKey.second.nDeriveIterations,
                                          pMasterKey.second.nDerivationMethod);
             pMasterKey.second.nDeriveIterations =
                 (pMasterKey.second.nDeriveIterations +
                  static_cast<unsigned int>(
                      pMasterKey.second.nDeriveIterations * 100 /
                      double(GetTimeMillis() - nStartTime))) /
                 2;
 
             if (pMasterKey.second.nDeriveIterations < 25000) {
                 pMasterKey.second.nDeriveIterations = 25000;
             }
 
             WalletLogPrintf(
                 "Wallet passphrase changed to an nDeriveIterations of %i\n",
                 pMasterKey.second.nDeriveIterations);
 
             if (!crypter.SetKeyFromPassphrase(
                     strNewWalletPassphrase, pMasterKey.second.vchSalt,
                     pMasterKey.second.nDeriveIterations,
                     pMasterKey.second.nDerivationMethod)) {
                 return false;
             }
 
             if (!crypter.Encrypt(_vMasterKey,
                                  pMasterKey.second.vchCryptedKey)) {
                 return false;
             }
 
             WalletBatch(*database).WriteMasterKey(pMasterKey.first,
                                                   pMasterKey.second);
             if (fWasLocked) {
                 Lock();
             }
 
             return true;
         }
     }
 
     return false;
 }
 
 void CWallet::chainStateFlushed(const CBlockLocator &loc) {
     WalletBatch batch(*database);
     batch.WriteBestBlock(loc);
 }
 
 void CWallet::SetMinVersion(enum WalletFeature nVersion, WalletBatch *batch_in,
                             bool fExplicit) {
     LOCK(cs_wallet);
     if (nWalletVersion >= nVersion) {
         return;
     }
 
     // When doing an explicit upgrade, if we pass the max version permitted,
     // upgrade all the way.
     if (fExplicit && nVersion > nWalletMaxVersion) {
         nVersion = FEATURE_LATEST;
     }
 
     nWalletVersion = nVersion;
 
     if (nVersion > nWalletMaxVersion) {
         nWalletMaxVersion = nVersion;
     }
 
     WalletBatch *batch = batch_in ? batch_in : new WalletBatch(*database);
     if (nWalletVersion > 40000) {
         batch->WriteMinVersion(nWalletVersion);
     }
     if (!batch_in) {
         delete batch;
     }
 }
 
 bool CWallet::SetMaxVersion(int nVersion) {
     LOCK(cs_wallet);
 
     // Cannot downgrade below current version
     if (nWalletVersion > nVersion) {
         return false;
     }
 
     nWalletMaxVersion = nVersion;
 
     return true;
 }
 
 std::set<TxId> CWallet::GetConflicts(const TxId &txid) const {
     std::set<TxId> result;
     AssertLockHeld(cs_wallet);
 
     std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
     if (it == mapWallet.end()) {
         return result;
     }
 
     const CWalletTx &wtx = it->second;
 
     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
 
     for (const CTxIn &txin : wtx.tx->vin) {
         if (mapTxSpends.count(txin.prevout) <= 1) {
             // No conflict if zero or one spends.
             continue;
         }
 
         range = mapTxSpends.equal_range(txin.prevout);
         for (TxSpends::const_iterator _it = range.first; _it != range.second;
              ++_it) {
             result.insert(_it->second);
         }
     }
 
     return result;
 }
 
 bool CWallet::HasWalletSpend(const TxId &txid) const {
     AssertLockHeld(cs_wallet);
     auto iter = mapTxSpends.lower_bound(COutPoint(txid, 0));
     return (iter != mapTxSpends.end() && iter->first.GetTxId() == txid);
 }
 
 void CWallet::Flush() {
     database->Flush();
 }
 
 void CWallet::Close() {
     database->Close();
 }
 
 void CWallet::SyncMetaData(
     std::pair<TxSpends::iterator, TxSpends::iterator> range) {
     // We want all the wallet transactions in range to have the same metadata as
     // the oldest (smallest nOrderPos).
     // So: find smallest nOrderPos:
 
     int nMinOrderPos = std::numeric_limits<int>::max();
     const CWalletTx *copyFrom = nullptr;
     for (TxSpends::iterator it = range.first; it != range.second; ++it) {
         const CWalletTx *wtx = &mapWallet.at(it->second);
         if (wtx->nOrderPos < nMinOrderPos) {
             nMinOrderPos = wtx->nOrderPos;
             copyFrom = wtx;
         }
     }
 
     if (!copyFrom) {
         return;
     }
 
     // Now copy data from copyFrom to rest:
     for (TxSpends::iterator it = range.first; it != range.second; ++it) {
         const TxId &txid = it->second;
         CWalletTx *copyTo = &mapWallet.at(txid);
         if (copyFrom == copyTo) {
             continue;
         }
 
         assert(
             copyFrom &&
             "Oldest wallet transaction in range assumed to have been found.");
 
         if (!copyFrom->IsEquivalentTo(*copyTo)) {
             continue;
         }
 
         copyTo->mapValue = copyFrom->mapValue;
         copyTo->vOrderForm = copyFrom->vOrderForm;
         // fTimeReceivedIsTxTime not copied on purpose nTimeReceived not copied
         // on purpose.
         copyTo->nTimeSmart = copyFrom->nTimeSmart;
         copyTo->fFromMe = copyFrom->fFromMe;
         // nOrderPos not copied on purpose cached members not copied on purpose.
     }
 }
 
 /**
  * Outpoint is spent if any non-conflicted transaction, spends it:
  */
 bool CWallet::IsSpent(const COutPoint &outpoint) const {
     AssertLockHeld(cs_wallet);
 
     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range =
         mapTxSpends.equal_range(outpoint);
 
     for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
         const TxId &wtxid = it->second;
         std::map<TxId, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
         if (mit != mapWallet.end()) {
             int depth = GetTxDepthInMainChain(mit->second);
             if (depth > 0 || (depth == 0 && !mit->second.isAbandoned())) {
                 // Spent
                 return true;
             }
         }
     }
 
     return false;
 }
 
 void CWallet::AddToSpends(const COutPoint &outpoint, const TxId &wtxid) {
     mapTxSpends.insert(std::make_pair(outpoint, wtxid));
 
     setLockedCoins.erase(outpoint);
 
     std::pair<TxSpends::iterator, TxSpends::iterator> range;
     range = mapTxSpends.equal_range(outpoint);
     SyncMetaData(range);
 }
 
 void CWallet::AddToSpends(const TxId &wtxid) {
     auto it = mapWallet.find(wtxid);
     assert(it != mapWallet.end());
     const CWalletTx &thisTx = it->second;
     // Coinbases don't spend anything!
     if (thisTx.IsCoinBase()) {
         return;
     }
 
     for (const CTxIn &txin : thisTx.tx->vin) {
         AddToSpends(txin.prevout, wtxid);
     }
 }
 
 bool CWallet::EncryptWallet(const SecureString &strWalletPassphrase) {
     if (IsCrypted()) {
         return false;
     }
 
     CKeyingMaterial _vMasterKey;
 
     _vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
     GetStrongRandBytes(&_vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
 
     CMasterKey kMasterKey;
 
     kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
     GetStrongRandBytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);
 
     CCrypter crypter;
     int64_t nStartTime = GetTimeMillis();
     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000,
                                  kMasterKey.nDerivationMethod);
     kMasterKey.nDeriveIterations = static_cast<unsigned int>(
         2500000 / double(GetTimeMillis() - nStartTime));
 
     nStartTime = GetTimeMillis();
     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt,
                                  kMasterKey.nDeriveIterations,
                                  kMasterKey.nDerivationMethod);
     kMasterKey.nDeriveIterations =
         (kMasterKey.nDeriveIterations +
          static_cast<unsigned int>(kMasterKey.nDeriveIterations * 100 /
                                    double(GetTimeMillis() - nStartTime))) /
         2;
 
     if (kMasterKey.nDeriveIterations < 25000) {
         kMasterKey.nDeriveIterations = 25000;
     }
 
     WalletLogPrintf("Encrypting Wallet with an nDeriveIterations of %i\n",
                     kMasterKey.nDeriveIterations);
 
     if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt,
                                       kMasterKey.nDeriveIterations,
                                       kMasterKey.nDerivationMethod)) {
         return false;
     }
 
     if (!crypter.Encrypt(_vMasterKey, kMasterKey.vchCryptedKey)) {
         return false;
     }
 
     {
         LOCK(cs_wallet);
         mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
         WalletBatch *encrypted_batch = new WalletBatch(*database);
         if (!encrypted_batch->TxnBegin()) {
             delete encrypted_batch;
             encrypted_batch = nullptr;
             return false;
         }
         encrypted_batch->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
 
         for (const auto &spk_man_pair : m_spk_managers) {
             auto spk_man = spk_man_pair.second.get();
             if (!spk_man->Encrypt(_vMasterKey, encrypted_batch)) {
                 encrypted_batch->TxnAbort();
                 delete encrypted_batch;
                 encrypted_batch = nullptr;
                 // We now probably have half of our keys encrypted in memory,
                 // and half not... die and let the user reload the unencrypted
                 // wallet.
                 assert(false);
             }
         }
 
         // Encryption was introduced in version 0.4.0
         SetMinVersion(FEATURE_WALLETCRYPT, encrypted_batch, true);
 
         if (!encrypted_batch->TxnCommit()) {
             delete encrypted_batch;
             encrypted_batch = nullptr;
             // We now have keys encrypted in memory, but not on disk...
             // die to avoid confusion and let the user reload the unencrypted
             // wallet.
             assert(false);
         }
 
         delete encrypted_batch;
         encrypted_batch = nullptr;
 
         Lock();
         Unlock(strWalletPassphrase);
 
         // If we are using descriptors, make new descriptors with a new seed
         if (IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS) &&
             !IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET)) {
             SetupDescriptorScriptPubKeyMans();
         } else if (auto spk_man = GetLegacyScriptPubKeyMan()) {
             // if we are using HD, replace the HD seed with a new one
             if (spk_man->IsHDEnabled()) {
                 if (!spk_man->SetupGeneration(true)) {
                     return false;
                 }
             }
         }
         Lock();
 
         // Need to completely rewrite the wallet file; if we don't, bdb might
         // keep bits of the unencrypted private key in slack space in the
         // database file.
         database->Rewrite();
 
         // BDB seems to have a bad habit of writing old data into
         // slack space in .dat files; that is bad if the old data is
         // unencrypted private keys. So:
         database->ReloadDbEnv();
     }
 
     NotifyStatusChanged(this);
     return true;
 }
 
 DBErrors CWallet::ReorderTransactions() {
     LOCK(cs_wallet);
     WalletBatch batch(*database);
 
     // Old wallets didn't have any defined order for transactions. Probably a
     // bad idea to change the output of this.
 
     // First: get all CWalletTx into a sorted-by-time
     // multimap.
     TxItems txByTime;
 
     for (auto &entry : mapWallet) {
         CWalletTx *wtx = &entry.second;
         txByTime.insert(std::make_pair(wtx->nTimeReceived, wtx));
     }
 
     nOrderPosNext = 0;
     std::vector<int64_t> nOrderPosOffsets;
     for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it) {
         CWalletTx *const pwtx = (*it).second;
         int64_t &nOrderPos = pwtx->nOrderPos;
 
         if (nOrderPos == -1) {
             nOrderPos = nOrderPosNext++;
             nOrderPosOffsets.push_back(nOrderPos);
 
             if (!batch.WriteTx(*pwtx)) {
                 return DBErrors::LOAD_FAIL;
             }
         } else {
             int64_t nOrderPosOff = 0;
             for (const int64_t &nOffsetStart : nOrderPosOffsets) {
                 if (nOrderPos >= nOffsetStart) {
                     ++nOrderPosOff;
                 }
             }
 
             nOrderPos += nOrderPosOff;
             nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
 
             if (!nOrderPosOff) {
                 continue;
             }
 
             // Since we're changing the order, write it back.
             if (!batch.WriteTx(*pwtx)) {
                 return DBErrors::LOAD_FAIL;
             }
         }
     }
 
     batch.WriteOrderPosNext(nOrderPosNext);
 
     return DBErrors::LOAD_OK;
 }
 
 int64_t CWallet::IncOrderPosNext(WalletBatch *batch) {
     AssertLockHeld(cs_wallet);
     int64_t nRet = nOrderPosNext++;
     if (batch) {
         batch->WriteOrderPosNext(nOrderPosNext);
     } else {
         WalletBatch(*database).WriteOrderPosNext(nOrderPosNext);
     }
 
     return nRet;
 }
 
 void CWallet::MarkDirty() {
     LOCK(cs_wallet);
     for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
         item.second.MarkDirty();
     }
 }
 
 void CWallet::SetSpentKeyState(WalletBatch &batch, const TxId &txid,
                                unsigned int n, bool used,
                                std::set<CTxDestination> &tx_destinations) {
     AssertLockHeld(cs_wallet);
     const CWalletTx *srctx = GetWalletTx(txid);
     if (!srctx) {
         return;
     }
 
     CTxDestination dst;
     if (ExtractDestination(srctx->tx->vout[n].scriptPubKey, dst)) {
         if (IsMine(dst)) {
             if (used && !GetDestData(dst, "used", nullptr)) {
                 // p for "present", opposite of absent (null)
                 if (AddDestData(batch, dst, "used", "p")) {
                     tx_destinations.insert(dst);
                 }
             } else if (!used && GetDestData(dst, "used", nullptr)) {
                 EraseDestData(batch, dst, "used");
             }
         }
     }
 }
 
 bool CWallet::IsSpentKey(const TxId &txid, unsigned int n) const {
     AssertLockHeld(cs_wallet);
     const CWalletTx *srctx = GetWalletTx(txid);
     if (srctx) {
         assert(srctx->tx->vout.size() > n);
         CTxDestination dest;
         if (!ExtractDestination(srctx->tx->vout[n].scriptPubKey, dest)) {
             return false;
         }
         if (GetDestData(dest, "used", nullptr)) {
             return true;
         }
         if (IsLegacy()) {
             LegacyScriptPubKeyMan *spk_man = GetLegacyScriptPubKeyMan();
             assert(spk_man != nullptr);
             for (const auto &keyid :
                  GetAffectedKeys(srctx->tx->vout[n].scriptPubKey, *spk_man)) {
                 PKHash pkh_dest(keyid);
                 if (GetDestData(pkh_dest, "used", nullptr)) {
                     return true;
                 }
             }
         }
     }
     return false;
 }
 
 CWalletTx *CWallet::AddToWallet(CTransactionRef tx,
                                 const CWalletTx::Confirmation &confirm,
                                 const UpdateWalletTxFn &update_wtx,
                                 bool fFlushOnClose) {
     LOCK(cs_wallet);
 
     WalletBatch batch(*database, fFlushOnClose);
 
     const TxId &txid = tx->GetId();
 
     if (IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
         // Mark used destinations
         std::set<CTxDestination> tx_destinations;
 
         for (const CTxIn &txin : tx->vin) {
             const COutPoint &op = txin.prevout;
             SetSpentKeyState(batch, op.GetTxId(), op.GetN(), true,
                              tx_destinations);
         }
 
         MarkDestinationsDirty(tx_destinations);
     }
 
     // Inserts only if not already there, returns tx inserted or tx found.
     auto ret =
         mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(txid),
                           std::forward_as_tuple(tx));
     CWalletTx &wtx = (*ret.first).second;
     bool fInsertedNew = ret.second;
     bool fUpdated = update_wtx && update_wtx(wtx, fInsertedNew);
     if (fInsertedNew) {
         wtx.m_confirm = confirm;
         wtx.nTimeReceived = chain().getAdjustedTime();
         wtx.nOrderPos = IncOrderPosNext(&batch);
         wtx.m_it_wtxOrdered =
             wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
         wtx.nTimeSmart = ComputeTimeSmart(wtx);
         AddToSpends(txid);
     }
 
     if (!fInsertedNew) {
         if (confirm.status != wtx.m_confirm.status) {
             wtx.m_confirm.status = confirm.status;
             wtx.m_confirm.nIndex = confirm.nIndex;
             wtx.m_confirm.hashBlock = confirm.hashBlock;
             wtx.m_confirm.block_height = confirm.block_height;
             fUpdated = true;
         } else {
             assert(wtx.m_confirm.nIndex == confirm.nIndex);
             assert(wtx.m_confirm.hashBlock == confirm.hashBlock);
             assert(wtx.m_confirm.block_height == confirm.block_height);
         }
     }
 
     //// debug print
     WalletLogPrintf("AddToWallet %s  %s%s\n", txid.ToString(),
                     (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
 
     // Write to disk
     if ((fInsertedNew || fUpdated) && !batch.WriteTx(wtx)) {
         return nullptr;
     }
 
     // Break debit/credit balance caches:
     wtx.MarkDirty();
 
     // Notify UI of new or updated transaction.
     NotifyTransactionChanged(this, txid, fInsertedNew ? CT_NEW : CT_UPDATED);
 
 #if defined(HAVE_SYSTEM)
     // Notify an external script when a wallet transaction comes in or is
     // updated.
     std::string strCmd = gArgs.GetArg("-walletnotify", "");
 
     if (!strCmd.empty()) {
         ReplaceAll(strCmd, "%s", txid.GetHex());
 #ifndef WIN32
         // Substituting the wallet name isn't currently supported on windows
         // because windows shell escaping has not been implemented yet:
         // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-537384875
         // A few ways it could be implemented in the future are described in:
         // https://github.com/bitcoin/bitcoin/pull/13339#issuecomment-461288094
         ReplaceAll(strCmd, "%w", ShellEscape(GetName()));
 #endif
 
         std::thread t(runCommand, strCmd);
         // Thread runs free.
         t.detach();
     }
 #endif
 
     return &wtx;
 }
 
 bool CWallet::LoadToWallet(const TxId &txid, const UpdateWalletTxFn &fill_wtx) {
     const auto &ins =
         mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(txid),
                           std::forward_as_tuple(nullptr));
     CWalletTx &wtx = ins.first->second;
     if (!fill_wtx(wtx, ins.second)) {
         return false;
     }
     // If wallet doesn't have a chain (e.g wallet-tool), don't bother to update
     // txn.
     if (HaveChain()) {
         bool active;
         int height;
         if (chain().findBlock(
                 wtx.m_confirm.hashBlock,
                 FoundBlock().inActiveChain(active).height(height)) &&
             active) {
             // Update cached block height variable since it not stored in the
             // serialized transaction.
             wtx.m_confirm.block_height = height;
         } else if (wtx.isConflicted() || wtx.isConfirmed()) {
             // If tx block (or conflicting block) was reorged out of chain
             // while the wallet was shutdown, change tx status to UNCONFIRMED
             // and reset block height, hash, and index. ABANDONED tx don't have
             // associated blocks and don't need to be updated. The case where a
             // transaction was reorged out while online and then reconfirmed
             // while offline is covered by the rescan logic.
             wtx.setUnconfirmed();
             wtx.m_confirm.hashBlock = BlockHash();
             wtx.m_confirm.block_height = 0;
             wtx.m_confirm.nIndex = 0;
         }
     }
     if (/* insertion took place */ ins.second) {
         wtx.m_it_wtxOrdered =
             wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
     }
     AddToSpends(txid);
     for (const CTxIn &txin : wtx.tx->vin) {
         auto it = mapWallet.find(txin.prevout.GetTxId());
         if (it != mapWallet.end()) {
             CWalletTx &prevtx = it->second;
             if (prevtx.isConflicted()) {
                 MarkConflicted(prevtx.m_confirm.hashBlock,
                                prevtx.m_confirm.block_height, wtx.GetId());
             }
         }
     }
     return true;
 }
 
 bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef &ptx,
                                        CWalletTx::Confirmation confirm,
                                        bool fUpdate) {
     AssertLockHeld(cs_wallet);
 
     const TxId &txid = ptx->GetId();
 
     if (!confirm.hashBlock.IsNull()) {
         for (const CTxIn &txin : ptx->vin) {
             std::pair<TxSpends::const_iterator, TxSpends::const_iterator>
                 range = mapTxSpends.equal_range(txin.prevout);
             while (range.first != range.second) {
                 if (range.first->second != txid) {
                     WalletLogPrintf(
                         "Transaction %s (in block %s) conflicts with wallet "
                         "transaction %s (both spend %s:%i)\n",
                         txid.ToString(), confirm.hashBlock.ToString(),
                         range.first->second.ToString(),
                         range.first->first.GetTxId().ToString(),
                         range.first->first.GetN());
                     MarkConflicted(confirm.hashBlock, confirm.block_height,
                                    range.first->second);
                 }
                 range.first++;
             }
         }
     }
 
     bool fExisted = mapWallet.count(txid) != 0;
     if (fExisted && !fUpdate) {
         return false;
     }
     if (fExisted || IsMine(*ptx) || IsFromMe(*ptx)) {
         /**
          * Check if any keys in the wallet keypool that were supposed to be
          * unused have appeared in a new transaction. If so, remove those keys
          * from the keypool. This can happen when restoring an old wallet backup
          * that does not contain the mostly recently created transactions from
          * newer versions of the wallet.
          */
 
         // loop though all outputs
         for (const CTxOut &txout : ptx->vout) {
             for (const auto &spk_man_pair : m_spk_managers) {
                 spk_man_pair.second->MarkUnusedAddresses(txout.scriptPubKey);
             }
         }
 
         // Block disconnection override an abandoned tx as unconfirmed
         // which means user may have to call abandontransaction again
         return AddToWallet(ptx, confirm,
                            /* update_wtx= */ nullptr,
                            /* fFlushOnClose= */ false);
     }
     return false;
 }
 
 bool CWallet::TransactionCanBeAbandoned(const TxId &txid) const {
     LOCK(cs_wallet);
     const CWalletTx *wtx = GetWalletTx(txid);
     return wtx && !wtx->isAbandoned() && GetTxDepthInMainChain(*wtx) == 0 &&
            !wtx->InMempool();
 }
 
 void CWallet::MarkInputsDirty(const CTransactionRef &tx) {
     for (const CTxIn &txin : tx->vin) {
         auto it = mapWallet.find(txin.prevout.GetTxId());
         if (it != mapWallet.end()) {
             it->second.MarkDirty();
         }
     }
 }
 
 bool CWallet::AbandonTransaction(const TxId &txid) {
     LOCK(cs_wallet);
 
     WalletBatch batch(*database);
 
     std::set<TxId> todo;
     std::set<TxId> done;
 
     // Can't mark abandoned if confirmed or in mempool
     auto it = mapWallet.find(txid);
     assert(it != mapWallet.end());
     const CWalletTx &origtx = it->second;
     if (GetTxDepthInMainChain(origtx) != 0 || origtx.InMempool()) {
         return false;
     }
 
     todo.insert(txid);
 
     while (!todo.empty()) {
         const TxId now = *todo.begin();
         todo.erase(now);
         done.insert(now);
         it = mapWallet.find(now);
         assert(it != mapWallet.end());
         CWalletTx &wtx = it->second;
         int currentconfirm = GetTxDepthInMainChain(wtx);
         // If the orig tx was not in block, none of its spends can be.
         assert(currentconfirm <= 0);
         // If (currentconfirm < 0) {Tx and spends are already conflicted, no
         // need to abandon}
         if (currentconfirm == 0 && !wtx.isAbandoned()) {
             // If the orig tx was not in block/mempool, none of its spends can
             // be in mempool.
             assert(!wtx.InMempool());
             wtx.setAbandoned();
             wtx.MarkDirty();
             batch.WriteTx(wtx);
             NotifyTransactionChanged(this, wtx.GetId(), CT_UPDATED);
             // Iterate over all its outputs, and mark transactions in the wallet
             // that spend them abandoned too.
             TxSpends::const_iterator iter =
                 mapTxSpends.lower_bound(COutPoint(now, 0));
             while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
                 if (!done.count(iter->second)) {
                     todo.insert(iter->second);
                 }
                 iter++;
             }
 
             // If a transaction changes 'conflicted' state, that changes the
             // balance available of the outputs it spends. So force those to be
             // recomputed.
             MarkInputsDirty(wtx.tx);
         }
     }
 
     return true;
 }
 
 void CWallet::MarkConflicted(const BlockHash &hashBlock, int conflicting_height,
                              const TxId &txid) {
     LOCK(cs_wallet);
 
     int conflictconfirms =
         (m_last_block_processed_height - conflicting_height + 1) * -1;
 
     // If number of conflict confirms cannot be determined, this means that the
     // block is still unknown or not yet part of the main chain, for example
     // when loading the wallet during a reindex. Do nothing in that case.
     if (conflictconfirms >= 0) {
         return;
     }
 
     // Do not flush the wallet here for performance reasons.
     WalletBatch batch(*database, false);
 
     std::set<TxId> todo;
     std::set<TxId> done;
 
     todo.insert(txid);
 
     while (!todo.empty()) {
         const TxId now = *todo.begin();
         todo.erase(now);
         done.insert(now);
         auto it = mapWallet.find(now);
         assert(it != mapWallet.end());
         CWalletTx &wtx = it->second;
         int currentconfirm = GetTxDepthInMainChain(wtx);
         if (conflictconfirms < currentconfirm) {
             // Block is 'more conflicted' than current confirm; update.
             // Mark transaction as conflicted with this block.
             wtx.m_confirm.nIndex = 0;
             wtx.m_confirm.hashBlock = hashBlock;
             wtx.m_confirm.block_height = conflicting_height;
             wtx.setConflicted();
             wtx.MarkDirty();
             batch.WriteTx(wtx);
             // Iterate over all its outputs, and mark transactions in the wallet
             // that spend them conflicted too.
             TxSpends::const_iterator iter =
                 mapTxSpends.lower_bound(COutPoint(now, 0));
             while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
                 if (!done.count(iter->second)) {
                     todo.insert(iter->second);
                 }
                 iter++;
             }
             // If a transaction changes 'conflicted' state, that changes the
             // balance available of the outputs it spends. So force those to be
             // recomputed.
             MarkInputsDirty(wtx.tx);
         }
     }
 }
 
 void CWallet::SyncTransaction(const CTransactionRef &ptx,
                               CWalletTx::Confirmation confirm, bool update_tx) {
     if (!AddToWalletIfInvolvingMe(ptx, confirm, update_tx)) {
         // Not one of ours
         return;
     }
 
     // If a transaction changes 'conflicted' state, that changes the balance
     // available of the outputs it spends. So force those to be
     // recomputed, also:
     MarkInputsDirty(ptx);
 }
 
 void CWallet::transactionAddedToMempool(const CTransactionRef &tx,
                                         uint64_t mempool_sequence) {
     LOCK(cs_wallet);
 
     SyncTransaction(tx, {CWalletTx::Status::UNCONFIRMED, /* block_height */ 0,
                          BlockHash(), /* nIndex */ 0});
 
     auto it = mapWallet.find(tx->GetId());
     if (it != mapWallet.end()) {
         it->second.fInMempool = true;
     }
 }
 
 void CWallet::transactionRemovedFromMempool(const CTransactionRef &tx,
                                             MemPoolRemovalReason reason,
                                             uint64_t mempool_sequence) {
     LOCK(cs_wallet);
     auto it = mapWallet.find(tx->GetId());
     if (it != mapWallet.end()) {
         it->second.fInMempool = false;
     }
     // Handle transactions that were removed from the mempool because they
     // conflict with transactions in a newly connected block.
     if (reason == MemPoolRemovalReason::CONFLICT) {
         // Call SyncNotifications, so external -walletnotify notifications will
         // be triggered for these transactions. Set Status::UNCONFIRMED instead
         // of Status::CONFLICTED for a few reasons:
         //
         // 1. The transactionRemovedFromMempool callback does not currently
         //    provide the conflicting block's hash and height, and for backwards
         //    compatibility reasons it may not be not safe to store conflicted
         //    wallet transactions with a null block hash. See
         //    https://github.com/bitcoin/bitcoin/pull/18600#discussion_r420195993.
         // 2. For most of these transactions, the wallet's internal conflict
         //    detection in the blockConnected handler will subsequently call
         //    MarkConflicted and update them with CONFLICTED status anyway. This
         //    applies to any wallet transaction that has inputs spent in the
         //    block, or that has ancestors in the wallet with inputs spent by
         //    the block.
         // 3. Longstanding behavior since the sync implementation in
         //    https://github.com/bitcoin/bitcoin/pull/9371 and the prior sync
         //    implementation before that was to mark these transactions
         //    unconfirmed rather than conflicted.
         //
         // Nothing described above should be seen as an unchangeable requirement
         // when improving this code in the future. The wallet's heuristics for
         // distinguishing between conflicted and unconfirmed transactions are
         // imperfect, and could be improved in general, see
         // https://github.com/bitcoin-core/bitcoin-devwiki/wiki/Wallet-Transaction-Conflict-Tracking
         SyncTransaction(tx,
                         {CWalletTx::Status::UNCONFIRMED, /* block height  */ 0,
                          BlockHash(), /* index */ 0});
     }
 }
 
 void CWallet::blockConnected(const CBlock &block, int height) {
     const BlockHash &block_hash = block.GetHash();
     LOCK(cs_wallet);
 
     m_last_block_processed_height = height;
     m_last_block_processed = block_hash;
     for (size_t index = 0; index < block.vtx.size(); index++) {
         SyncTransaction(block.vtx[index], {CWalletTx::Status::CONFIRMED, height,
                                            block_hash, int(index)});
         transactionRemovedFromMempool(block.vtx[index],
                                       MemPoolRemovalReason::BLOCK,
                                       0 /* mempool_sequence */);
     }
 }
 
 void CWallet::blockDisconnected(const CBlock &block, int height) {
     LOCK(cs_wallet);
 
     // At block disconnection, this will change an abandoned transaction to
     // be unconfirmed, whether or not the transaction is added back to the
     // mempool. User may have to call abandontransaction again. It may be
     // addressed in the future with a stickier abandoned state or even removing
     // abandontransaction call.
     m_last_block_processed_height = height - 1;
     m_last_block_processed = block.hashPrevBlock;
     for (const CTransactionRef &ptx : block.vtx) {
         SyncTransaction(ptx,
                         {CWalletTx::Status::UNCONFIRMED, /* block_height */ 0,
                          BlockHash(), /* nIndex */ 0});
     }
 }
 
 void CWallet::updatedBlockTip() {
     m_best_block_time = GetTime();
 }
 
 void CWallet::BlockUntilSyncedToCurrentChain() const {
     AssertLockNotHeld(cs_wallet);
     // Skip the queue-draining stuff if we know we're caught up with
     // chain().Tip(), otherwise put a callback in the validation interface
     // queue and wait for the queue to drain enough to execute it (indicating we
     // are caught up at least with the time we entered this function).
     const BlockHash last_block_hash =
         WITH_LOCK(cs_wallet, return m_last_block_processed);
     chain().waitForNotificationsIfTipChanged(last_block_hash);
 }
 
 // Note that this function doesn't distinguish between a 0-valued input, and a
 // not-"is mine" (according to the filter) input.
 Amount CWallet::GetDebit(const CTxIn &txin, const isminefilter &filter) const {
     LOCK(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator mi =
         mapWallet.find(txin.prevout.GetTxId());
     if (mi != mapWallet.end()) {
         const CWalletTx &prev = (*mi).second;
         if (txin.prevout.GetN() < prev.tx->vout.size()) {
             if (IsMine(prev.tx->vout[txin.prevout.GetN()]) & filter) {
                 return prev.tx->vout[txin.prevout.GetN()].nValue;
             }
         }
     }
 
     return Amount::zero();
 }
 
 isminetype CWallet::IsMine(const CTxOut &txout) const {
     AssertLockHeld(cs_wallet);
     return IsMine(txout.scriptPubKey);
 }
 
 isminetype CWallet::IsMine(const CTxDestination &dest) const {
     AssertLockHeld(cs_wallet);
     return IsMine(GetScriptForDestination(dest));
 }
 
 isminetype CWallet::IsMine(const CScript &script) const {
     AssertLockHeld(cs_wallet);
     isminetype result = ISMINE_NO;
     for (const auto &spk_man_pair : m_spk_managers) {
         result = std::max(result, spk_man_pair.second->IsMine(script));
     }
     return result;
 }
 
 bool CWallet::IsMine(const CTransaction &tx) const {
     AssertLockHeld(cs_wallet);
     for (const CTxOut &txout : tx.vout) {
         if (IsMine(txout)) {
             return true;
         }
     }
 
     return false;
 }
 
 bool CWallet::IsFromMe(const CTransaction &tx) const {
     return GetDebit(tx, ISMINE_ALL) > Amount::zero();
 }
 
 Amount CWallet::GetDebit(const CTransaction &tx,
                          const isminefilter &filter) const {
     Amount nDebit = Amount::zero();
     for (const CTxIn &txin : tx.vin) {
         nDebit += GetDebit(txin, filter);
         if (!MoneyRange(nDebit)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nDebit;
 }
 
 bool CWallet::IsHDEnabled() const {
     // All Active ScriptPubKeyMans must be HD for this to be true
     bool result = true;
     for (const auto &spk_man : GetActiveScriptPubKeyMans()) {
         result &= spk_man->IsHDEnabled();
     }
     return result;
 }
 
 bool CWallet::CanGetAddresses(bool internal) const {
     LOCK(cs_wallet);
     if (m_spk_managers.empty()) {
         return false;
     }
     for (OutputType t : OUTPUT_TYPES) {
         auto spk_man = GetScriptPubKeyMan(t, internal);
         if (spk_man && spk_man->CanGetAddresses(internal)) {
             return true;
         }
     }
     return false;
 }
 
 void CWallet::SetWalletFlag(uint64_t flags) {
     LOCK(cs_wallet);
     m_wallet_flags |= flags;
     if (!WalletBatch(*database).WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 }
 
 void CWallet::UnsetWalletFlag(uint64_t flag) {
     WalletBatch batch(*database);
     UnsetWalletFlagWithDB(batch, flag);
 }
 
 void CWallet::UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag) {
     LOCK(cs_wallet);
     m_wallet_flags &= ~flag;
     if (!batch.WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 }
 
 void CWallet::UnsetBlankWalletFlag(WalletBatch &batch) {
     UnsetWalletFlagWithDB(batch, WALLET_FLAG_BLANK_WALLET);
 }
 
 bool CWallet::IsWalletFlagSet(uint64_t flag) const {
     return (m_wallet_flags & flag);
 }
 
 bool CWallet::LoadWalletFlags(uint64_t flags) {
     LOCK(cs_wallet);
     if (((flags & KNOWN_WALLET_FLAGS) >> 32) ^ (flags >> 32)) {
         // contains unknown non-tolerable wallet flags
         return false;
     }
     m_wallet_flags = flags;
 
     return true;
 }
 
 bool CWallet::AddWalletFlags(uint64_t flags) {
     LOCK(cs_wallet);
     // We should never be writing unknown non-tolerable wallet flags
     assert(((flags & KNOWN_WALLET_FLAGS) >> 32) == (flags >> 32));
     if (!WalletBatch(*database).WriteWalletFlags(flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 
     return LoadWalletFlags(flags);
 }
 
 // Helper for producing a max-sized low-S low-R signature (eg 71 bytes)
 // or a max-sized low-S signature (e.g. 72 bytes) if use_max_sig is true
 bool CWallet::DummySignInput(CTxIn &tx_in, const CTxOut &txout,
                              bool use_max_sig) const {
     // Fill in dummy signatures for fee calculation.
     const CScript &scriptPubKey = txout.scriptPubKey;
     SignatureData sigdata;
 
     std::unique_ptr<SigningProvider> provider =
         GetSolvingProvider(scriptPubKey);
     if (!provider) {
         // We don't know about this scriptpbuKey;
         return false;
     }
 
     if (!ProduceSignature(*provider,
                           use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR
                                       : DUMMY_SIGNATURE_CREATOR,
                           scriptPubKey, sigdata)) {
         return false;
     }
 
     UpdateInput(tx_in, sigdata);
     return true;
 }
 
 // Helper for producing a bunch of max-sized low-S low-R signatures (eg 71
 // bytes)
 bool CWallet::DummySignTx(CMutableTransaction &txNew,
                           const std::vector<CTxOut> &txouts,
                           bool use_max_sig) const {
     // Fill in dummy signatures for fee calculation.
     int nIn = 0;
     for (const auto &txout : txouts) {
         if (!DummySignInput(txNew.vin[nIn], txout, use_max_sig)) {
             return false;
         }
 
         nIn++;
     }
     return true;
 }
 
 bool CWallet::ImportScripts(const std::set<CScript> scripts,
                             int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     return spk_man->ImportScripts(scripts, timestamp);
 }
 
 bool CWallet::ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,
                              const int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     return spk_man->ImportPrivKeys(privkey_map, timestamp);
 }
 
 bool CWallet::ImportPubKeys(
     const std::vector<CKeyID> &ordered_pubkeys,
     const std::map<CKeyID, CPubKey> &pubkey_map,
     const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
     const bool add_keypool, const bool internal, const int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     return spk_man->ImportPubKeys(ordered_pubkeys, pubkey_map, key_origins,
                                   add_keypool, internal, timestamp);
 }
 
 bool CWallet::ImportScriptPubKeys(const std::string &label,
                                   const std::set<CScript> &script_pub_keys,
                                   const bool have_solving_data,
                                   const bool apply_label,
                                   const int64_t timestamp) {
     auto spk_man = GetLegacyScriptPubKeyMan();
     if (!spk_man) {
         return false;
     }
     LOCK(spk_man->cs_KeyStore);
     if (!spk_man->ImportScriptPubKeys(script_pub_keys, have_solving_data,
                                       timestamp)) {
         return false;
     }
     if (apply_label) {
         WalletBatch batch(*database);
         for (const CScript &script : script_pub_keys) {
             CTxDestination dest;
             ExtractDestination(script, dest);
             if (IsValidDestination(dest)) {
                 SetAddressBookWithDB(batch, dest, label, "receive");
             }
         }
     }
     return true;
 }
 
 /**
  * Scan active chain for relevant transactions after importing keys. This should
  * be called whenever new keys are added to the wallet, with the oldest key
  * creation time.
  *
  * @return Earliest timestamp that could be successfully scanned from. Timestamp
  * returned will be higher than startTime if relevant blocks could not be read.
  */
 int64_t CWallet::RescanFromTime(int64_t startTime,
                                 const WalletRescanReserver &reserver,
                                 bool update) {
     // Find starting block. May be null if nCreateTime is greater than the
     // highest blockchain timestamp, in which case there is nothing that needs
     // to be scanned.
     int start_height = 0;
     BlockHash start_block;
     bool start = chain().findFirstBlockWithTimeAndHeight(
         startTime - TIMESTAMP_WINDOW, 0,
         FoundBlock().hash(start_block).height(start_height));
     WalletLogPrintf("%s: Rescanning last %i blocks\n", __func__,
                     start ? WITH_LOCK(cs_wallet, return GetLastBlockHeight()) -
                                 start_height + 1
                           : 0);
 
     if (start) {
         // TODO: this should take into account failure by ScanResult::USER_ABORT
         ScanResult result = ScanForWalletTransactions(
             start_block, start_height, {} /* max_height */, reserver, update);
         if (result.status == ScanResult::FAILURE) {
             int64_t time_max;
             CHECK_NONFATAL(chain().findBlock(result.last_failed_block,
                                              FoundBlock().maxTime(time_max)));
             return time_max + TIMESTAMP_WINDOW + 1;
         }
     }
     return startTime;
 }
 
 /**
  * Scan the block chain (starting in start_block) for transactions from or to
  * us. If fUpdate is true, found transactions that already exist in the wallet
  * will be updated.
  *
  * @param[in] start_block Scan starting block. If block is not on the active
  *                        chain, the scan will return SUCCESS immediately.
  * @param[in] start_height Height of start_block
  * @param[in] max_height  Optional max scanning height. If unset there is
  *                        no maximum and scanning can continue to the tip
  *
  * @return ScanResult returning scan information and indicating success or
  *         failure. Return status will be set to SUCCESS if scan was
  *         successful. FAILURE if a complete rescan was not possible (due to
  *         pruning or corruption). USER_ABORT if the rescan was aborted before
  *         it could complete.
  *
  * @pre Caller needs to make sure start_block (and the optional stop_block) are
  * on the main chain after to the addition of any new keys you want to detect
  * transactions for.
  */
 CWallet::ScanResult CWallet::ScanForWalletTransactions(
     const BlockHash &start_block, int start_height,
     std::optional<int> max_height, const WalletRescanReserver &reserver,
     bool fUpdate) {
     int64_t nNow = GetTime();
     int64_t start_time = GetTimeMillis();
 
     assert(reserver.isReserved());
 
     BlockHash block_hash = start_block;
     ScanResult result;
 
     WalletLogPrintf("Rescan started from block %s...\n",
                     start_block.ToString());
 
     fAbortRescan = false;
     // Show rescan progress in GUI as dialog or on splashscreen, if -rescan on
     // startup.
     ShowProgress(
         strprintf("%s " + _("Rescanning...").translated, GetDisplayName()), 0);
     BlockHash tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
     BlockHash end_hash = tip_hash;
     if (max_height) {
         chain().findAncestorByHeight(tip_hash, *max_height,
                                      FoundBlock().hash(end_hash));
     }
     double progress_begin = chain().guessVerificationProgress(block_hash);
     double progress_end = chain().guessVerificationProgress(end_hash);
     double progress_current = progress_begin;
     int block_height = start_height;
     while (!fAbortRescan && !chain().shutdownRequested()) {
         if (progress_end - progress_begin > 0.0) {
             m_scanning_progress = (progress_current - progress_begin) /
                                   (progress_end - progress_begin);
         } else {
             // avoid divide-by-zero for single block scan range (i.e. start and
             // stop hashes are equal)
             m_scanning_progress = 0;
         }
         if (block_height % 100 == 0 && progress_end - progress_begin > 0.0) {
             ShowProgress(
                 strprintf("%s " + _("Rescanning...").translated,
                           GetDisplayName()),
                 std::max(1, std::min(99, (int)(m_scanning_progress * 100))));
         }
         if (GetTime() >= nNow + 60) {
             nNow = GetTime();
             WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n",
                             block_height, progress_current);
         }
 
         // Read block data
         CBlock block;
         chain().findBlock(block_hash, FoundBlock().data(block));
 
         // Find next block separately from reading data above, because reading
         // is slow and there might be a reorg while it is read.
         bool block_still_active = false;
         bool next_block = false;
         BlockHash next_block_hash;
         chain().findBlock(block_hash,
                           FoundBlock()
                               .inActiveChain(block_still_active)
                               .nextBlock(FoundBlock()
                                              .inActiveChain(next_block)
                                              .hash(next_block_hash)));
 
         if (!block.IsNull()) {
             LOCK(cs_wallet);
             if (!block_still_active) {
                 // Abort scan if current block is no longer active, to prevent
                 // marking transactions as coming from the wrong block.
                 result.last_failed_block = block_hash;
                 result.status = ScanResult::FAILURE;
                 break;
             }
             for (size_t posInBlock = 0; posInBlock < block.vtx.size();
                  ++posInBlock) {
                 CWalletTx::Confirmation confirm(CWalletTx::Status::CONFIRMED,
                                                 block_height, block_hash,
                                                 posInBlock);
                 SyncTransaction(block.vtx[posInBlock],
                                 {CWalletTx::Status::CONFIRMED, block_height,
                                  block_hash, int(posInBlock)},
                                 fUpdate);
             }
             // scan succeeded, record block as most recent successfully
             // scanned
             result.last_scanned_block = block_hash;
             result.last_scanned_height = block_height;
         } else {
             // could not scan block, keep scanning but record this block as
             // the most recent failure
             result.last_failed_block = block_hash;
             result.status = ScanResult::FAILURE;
         }
         if (max_height && block_height >= *max_height) {
             break;
         }
         {
             if (!next_block) {
                 // break successfully when rescan has reached the tip, or
                 // previous block is no longer on the chain due to a reorg
                 break;
             }
 
             // increment block and verification progress
             block_hash = next_block_hash;
             ++block_height;
             progress_current = chain().guessVerificationProgress(block_hash);
 
             // handle updated tip hash
             const BlockHash prev_tip_hash = tip_hash;
             tip_hash = WITH_LOCK(cs_wallet, return GetLastBlockHash());
             if (!max_height && prev_tip_hash != tip_hash) {
                 // in case the tip has changed, update progress max
                 progress_end = chain().guessVerificationProgress(tip_hash);
             }
         }
     }
 
     // Hide progress dialog in GUI.
     ShowProgress(
         strprintf("%s " + _("Rescanning...").translated, GetDisplayName()),
         100);
     if (block_height && fAbortRescan) {
         WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n",
                         block_height, progress_current);
         result.status = ScanResult::USER_ABORT;
     } else if (block_height && chain().shutdownRequested()) {
         WalletLogPrintf(
             "Rescan interrupted by shutdown request at block %d. Progress=%f\n",
             block_height, progress_current);
         result.status = ScanResult::USER_ABORT;
     } else {
         WalletLogPrintf("Rescan completed in %15dms\n",
                         GetTimeMillis() - start_time);
     }
     return result;
 }
 
 void CWallet::ReacceptWalletTransactions() {
     AssertLockHeld(cs_wallet);
 
     // If transactions aren't being broadcasted, don't let them into local
     // mempool either.
     if (!fBroadcastTransactions) {
         return;
     }
 
     std::map<int64_t, CWalletTx *> mapSorted;
 
     // Sort pending wallet transactions based on their initial wallet insertion
     // order.
     for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
         const TxId &wtxid = item.first;
         CWalletTx &wtx = item.second;
         assert(wtx.GetId() == wtxid);
 
         int nDepth = GetTxDepthInMainChain(wtx);
 
         if (!wtx.IsCoinBase() && (nDepth == 0 && !wtx.isAbandoned())) {
             mapSorted.insert(std::make_pair(wtx.nOrderPos, &wtx));
         }
     }
 
     // Try to add wallet transactions to memory pool.
     for (const std::pair<const int64_t, CWalletTx *> &item : mapSorted) {
         CWalletTx &wtx = *(item.second);
         std::string unused_err_string;
         SubmitTxMemoryPoolAndRelay(wtx, unused_err_string, false);
     }
 }
 
 bool CWallet::SubmitTxMemoryPoolAndRelay(const CWalletTx &wtx,
                                          std::string &err_string,
                                          bool relay) const {
     AssertLockHeld(cs_wallet);
 
     // Can't relay if wallet is not broadcasting
     if (!GetBroadcastTransactions()) {
         return false;
     }
     // Don't relay abandoned transactions
     if (wtx.isAbandoned()) {
         return false;
     }
     // Don't try to submit coinbase transactions. These would fail anyway but
     // would cause log spam.
     if (wtx.IsCoinBase()) {
         return false;
     }
     // Don't try to submit conflicted or confirmed transactions.
     if (GetTxDepthInMainChain(wtx) != 0) {
         return false;
     }
 
     // Submit transaction to mempool for relay
     WalletLogPrintf("Submitting wtx %s to mempool for relay\n",
                     wtx.GetId().ToString());
     // We must set fInMempool here - while it will be re-set to true by the
     // entered-mempool callback, if we did not there would be a race where a
     // user could call sendmoney in a loop and hit spurious out of funds errors
     // because we think that this newly generated transaction's change is
     // unavailable as we're not yet aware that it is in the mempool.
     //
     // Irrespective of the failure reason, un-marking fInMempool
     // out-of-order is incorrect - it should be unmarked when
     // TransactionRemovedFromMempool fires.
     bool ret = chain().broadcastTransaction(
         GetConfig(), wtx.tx, m_default_max_tx_fee, relay, err_string);
     wtx.fInMempool |= ret;
     return ret;
 }
 
 std::set<TxId> CWallet::GetTxConflicts(const CWalletTx &wtx) const {
     AssertLockHeld(cs_wallet);
 
     std::set<TxId> result;
     const TxId &txid = wtx.GetId();
     result = GetConflicts(txid);
     result.erase(txid);
 
     return result;
 }
 
 // Rebroadcast transactions from the wallet. We do this on a random timer
 // to slightly obfuscate which transactions come from our wallet.
 //
 // Ideally, we'd only resend transactions that we think should have been
 // mined in the most recent block. Any transaction that wasn't in the top
 // blockweight of transactions in the mempool shouldn't have been mined,
 // and so is probably just sitting in the mempool waiting to be confirmed.
 // Rebroadcasting does nothing to speed up confirmation and only damages
 // privacy.
 void CWallet::ResendWalletTransactions() {
     // During reindex, importing and IBD, old wallet transactions become
     // unconfirmed. Don't resend them as that would spam other nodes.
     if (!chain().isReadyToBroadcast()) {
         return;
     }
 
     // Do this infrequently and randomly to avoid giving away that these are our
     // transactions.
     if (GetTime() < nNextResend || !fBroadcastTransactions) {
         return;
     }
 
     bool fFirst = (nNextResend == 0);
     // resend 12-36 hours from now, ~1 day on average.
     nNextResend = GetTime() + (12 * 60 * 60) + GetRand(24 * 60 * 60);
     if (fFirst) {
         return;
     }
 
     int submitted_tx_count = 0;
 
     { // cs_wallet scope
         LOCK(cs_wallet);
 
         // Relay transactions
         for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
             CWalletTx &wtx = item.second;
             // Attempt to rebroadcast all txes more than 5 minutes older than
             // the last block. SubmitTxMemoryPoolAndRelay() will not rebroadcast
             // any confirmed or conflicting txs.
             if (wtx.nTimeReceived > m_best_block_time - 5 * 60) {
                 continue;
             }
             std::string unused_err_string;
             if (SubmitTxMemoryPoolAndRelay(wtx, unused_err_string, true)) {
                 ++submitted_tx_count;
             }
         }
     } // cs_wallet
 
     if (submitted_tx_count > 0) {
         WalletLogPrintf("%s: resubmit %u unconfirmed transactions\n", __func__,
                         submitted_tx_count);
     }
 }
 
 /** @} */ // end of mapWallet
 
 void MaybeResendWalletTxs() {
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         pwallet->ResendWalletTransactions();
     }
 }
 
 /**
  * @defgroup Actions
  *
  * @{
  */
 
 bool CWallet::SignTransaction(CMutableTransaction &tx) const {
     AssertLockHeld(cs_wallet);
 
     // Build coins map
     std::map<COutPoint, Coin> coins;
     for (auto &input : tx.vin) {
         auto mi = mapWallet.find(input.prevout.GetTxId());
         if (mi == mapWallet.end() ||
             input.prevout.GetN() >= mi->second.tx->vout.size()) {
             return false;
         }
         const CWalletTx &wtx = mi->second;
         coins[input.prevout] =
             Coin(wtx.tx->vout[input.prevout.GetN()], wtx.m_confirm.block_height,
                  wtx.IsCoinBase());
     }
     std::map<int, std::string> input_errors;
     return SignTransaction(tx, coins, SigHashType().withForkId(), input_errors);
 }
 
 bool CWallet::SignTransaction(CMutableTransaction &tx,
                               const std::map<COutPoint, Coin> &coins,
                               SigHashType sighash,
                               std::map<int, std::string> &input_errors) const {
     // Try to sign with all ScriptPubKeyMans
     for (ScriptPubKeyMan *spk_man : GetAllScriptPubKeyMans()) {
         // spk_man->SignTransaction will return true if the transaction is
         // complete, so we can exit early and return true if that happens
         if (spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
             return true;
         }
     }
 
     // At this point, one input was not fully signed otherwise we would have
     // exited already
 
     // When there are no available providers for the remaining inputs, use the
     // legacy provider so we can get proper error messages.
     auto legacy_spk_man = GetLegacyScriptPubKeyMan();
     if (legacy_spk_man &&
         legacy_spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
         return true;
     }
 
     return false;
 }
 
 TransactionError CWallet::FillPSBT(PartiallySignedTransaction &psbtx,
                                    bool &complete, SigHashType sighash_type,
                                    bool sign, bool bip32derivs) const {
     LOCK(cs_wallet);
     // Get all of the previous transactions
     for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
         const CTxIn &txin = psbtx.tx->vin[i];
         PSBTInput &input = psbtx.inputs.at(i);
 
         if (PSBTInputSigned(input)) {
             continue;
         }
 
         // If we have no utxo, grab it from the wallet.
         if (input.utxo.IsNull()) {
             const TxId &txid = txin.prevout.GetTxId();
             const auto it = mapWallet.find(txid);
             if (it != mapWallet.end()) {
                 const CWalletTx &wtx = it->second;
                 CTxOut utxo = wtx.tx->vout[txin.prevout.GetN()];
                 // Update UTXOs from the wallet.
                 input.utxo = utxo;
             }
         }
     }
 
     // Fill in information from ScriptPubKeyMans
     for (ScriptPubKeyMan *spk_man : GetAllScriptPubKeyMans()) {
         TransactionError res =
             spk_man->FillPSBT(psbtx, sighash_type, sign, bip32derivs);
         if (res != TransactionError::OK) {
             return res;
         }
     }
 
     // Complete if every input is now signed
     complete = true;
     for (const auto &input : psbtx.inputs) {
         complete &= PSBTInputSigned(input);
     }
 
     return TransactionError::OK;
 }
 
 SigningResult CWallet::SignMessage(const std::string &message,
                                    const PKHash &pkhash,
                                    std::string &str_sig) const {
     SignatureData sigdata;
     CScript script_pub_key = GetScriptForDestination(pkhash);
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script_pub_key, sigdata)) {
             return spk_man_pair.second->SignMessage(message, pkhash, str_sig);
         }
     }
     return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
 }
 
 OutputType
 CWallet::TransactionChangeType(const std::optional<OutputType> &change_type,
                                const std::vector<CRecipient> &vecSend) const {
     // If -changetype is specified, always use that change type.
     if (change_type) {
         return *change_type;
     }
 
     // if m_default_address_type is legacy, use legacy address as change.
     if (m_default_address_type == OutputType::LEGACY) {
         return OutputType::LEGACY;
     }
 
     // else use m_default_address_type for change
     return m_default_address_type;
 }
 
 void CWallet::CommitTransaction(
     CTransactionRef tx, mapValue_t mapValue,
     std::vector<std::pair<std::string, std::string>> orderForm) {
     LOCK(cs_wallet);
 
     WalletLogPrintfToBeContinued("CommitTransaction:\n%s", tx->ToString());
 
     // Add tx to wallet, because if it has change it's also ours, otherwise just
     // for transaction history.
     AddToWallet(tx, {}, [&](CWalletTx &wtx, bool new_tx) {
         CHECK_NONFATAL(wtx.mapValue.empty());
         CHECK_NONFATAL(wtx.vOrderForm.empty());
         wtx.mapValue = std::move(mapValue);
         wtx.vOrderForm = std::move(orderForm);
         wtx.fTimeReceivedIsTxTime = true;
         wtx.fFromMe = true;
         return true;
     });
 
     // Notify that old coins are spent.
     for (const CTxIn &txin : tx->vin) {
         CWalletTx &coin = mapWallet.at(txin.prevout.GetTxId());
         coin.MarkDirty();
         NotifyTransactionChanged(this, coin.GetId(), CT_UPDATED);
     }
 
     // Get the inserted-CWalletTx from mapWallet so that the
     // fInMempool flag is cached properly
     CWalletTx &wtx = mapWallet.at(tx->GetId());
 
     if (!fBroadcastTransactions) {
         // Don't submit tx to the mempool
         return;
     }
 
     std::string err_string;
     if (!SubmitTxMemoryPoolAndRelay(wtx, err_string, true)) {
         WalletLogPrintf("CommitTransaction(): Transaction cannot be broadcast "
                         "immediately, %s\n",
                         err_string);
         // TODO: if we expect the failure to be long term or permanent, instead
         // delete wtx from the wallet and return failure.
     }
 }
 
 DBErrors CWallet::LoadWallet(bool &fFirstRunRet) {
     LOCK(cs_wallet);
 
     fFirstRunRet = false;
     DBErrors nLoadWalletRet = WalletBatch(*database).LoadWallet(this);
     if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             for (const auto &spk_man_pair : m_spk_managers) {
                 spk_man_pair.second->RewriteDB();
             }
         }
     }
 
     // This wallet is in its first run if there are no ScriptPubKeyMans and it
     // isn't blank or no privkeys
     fFirstRunRet = m_spk_managers.empty() &&
                    !IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
                    !IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET);
     if (fFirstRunRet) {
         assert(m_external_spk_managers.empty());
         assert(m_internal_spk_managers.empty());
     }
 
     if (nLoadWalletRet != DBErrors::LOAD_OK) {
         return nLoadWalletRet;
     }
 
     return DBErrors::LOAD_OK;
 }
 
 DBErrors CWallet::ZapSelectTx(std::vector<TxId> &txIdsIn,
                               std::vector<TxId> &txIdsOut) {
     AssertLockHeld(cs_wallet);
     DBErrors nZapSelectTxRet =
         WalletBatch(*database).ZapSelectTx(txIdsIn, txIdsOut);
     for (const TxId &txid : txIdsOut) {
         const auto &it = mapWallet.find(txid);
         wtxOrdered.erase(it->second.m_it_wtxOrdered);
         for (const auto &txin : it->second.tx->vin) {
             mapTxSpends.erase(txin.prevout);
         }
         mapWallet.erase(it);
         NotifyTransactionChanged(this, txid, CT_DELETED);
     }
 
     if (nZapSelectTxRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             for (const auto &spk_man_pair : m_spk_managers) {
                 spk_man_pair.second->RewriteDB();
             }
         }
     }
 
     if (nZapSelectTxRet != DBErrors::LOAD_OK) {
         return nZapSelectTxRet;
     }
 
     MarkDirty();
 
     return DBErrors::LOAD_OK;
 }
 
 bool CWallet::SetAddressBookWithDB(WalletBatch &batch,
                                    const CTxDestination &address,
                                    const std::string &strName,
                                    const std::string &strPurpose) {
     bool fUpdated = false;
     bool is_mine;
     {
         LOCK(cs_wallet);
         std::map<CTxDestination, CAddressBookData>::iterator mi =
             m_address_book.find(address);
         fUpdated = (mi != m_address_book.end() && !mi->second.IsChange());
         m_address_book[address].SetLabel(strName);
         // Update purpose only if requested.
         if (!strPurpose.empty()) {
             m_address_book[address].purpose = strPurpose;
         }
         is_mine = IsMine(address) != ISMINE_NO;
     }
 
     NotifyAddressBookChanged(this, address, strName, is_mine, strPurpose,
                              (fUpdated ? CT_UPDATED : CT_NEW));
     if (!strPurpose.empty() && !batch.WritePurpose(address, strPurpose)) {
         return false;
     }
     return batch.WriteName(address, strName);
 }
 
 bool CWallet::SetAddressBook(const CTxDestination &address,
                              const std::string &strName,
                              const std::string &strPurpose) {
     WalletBatch batch(*database);
     return SetAddressBookWithDB(batch, address, strName, strPurpose);
 }
 
 bool CWallet::DelAddressBook(const CTxDestination &address) {
     bool is_mine;
     WalletBatch batch(*database);
     {
         LOCK(cs_wallet);
         // If we want to delete receiving addresses, we need to take care that
         // DestData "used" (and possibly newer DestData) gets preserved (and the
         // "deleted" address transformed into a change entry instead of actually
         // being deleted)
         // NOTE: This isn't a problem for sending addresses because they never
         // have any DestData yet! When adding new DestData, it should be
         // considered here whether to retain or delete it (or move it?).
         if (IsMine(address)) {
             WalletLogPrintf(
                 "%s called with IsMine address, NOT SUPPORTED. Please "
                 "report this bug! %s\n",
                 __func__, PACKAGE_BUGREPORT);
             return false;
         }
         // Delete destdata tuples associated with address
         for (const std::pair<const std::string, std::string> &item :
              m_address_book[address].destdata) {
             batch.EraseDestData(address, item.first);
         }
         m_address_book.erase(address);
         is_mine = IsMine(address) != ISMINE_NO;
     }
 
     NotifyAddressBookChanged(this, address, "", is_mine, "", CT_DELETED);
 
     batch.ErasePurpose(address);
     return batch.EraseName(address);
 }
 
 size_t CWallet::KeypoolCountExternalKeys() const {
     AssertLockHeld(cs_wallet);
 
     unsigned int count = 0;
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         count += spk_man->KeypoolCountExternalKeys();
     }
 
     return count;
 }
 
 unsigned int CWallet::GetKeyPoolSize() const {
     AssertLockHeld(cs_wallet);
 
     unsigned int count = 0;
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         count += spk_man->GetKeyPoolSize();
     }
     return count;
 }
 
 bool CWallet::TopUpKeyPool(unsigned int kpSize) {
     LOCK(cs_wallet);
     bool res = true;
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         res &= spk_man->TopUp(kpSize);
     }
     return res;
 }
 
 bool CWallet::GetNewDestination(const OutputType type, const std::string label,
                                 CTxDestination &dest, std::string &error) {
     LOCK(cs_wallet);
     error.clear();
     bool result = false;
     auto spk_man = GetScriptPubKeyMan(type, false /* internal */);
     if (spk_man) {
         spk_man->TopUp();
         result = spk_man->GetNewDestination(type, dest, error);
     } else {
         error = strprintf("Error: No %s addresses available.",
                           FormatOutputType(type));
     }
     if (result) {
         SetAddressBook(dest, label, "receive");
     }
 
     return result;
 }
 
 bool CWallet::GetNewChangeDestination(const OutputType type,
                                       CTxDestination &dest,
                                       std::string &error) {
     LOCK(cs_wallet);
     error.clear();
 
     ReserveDestination reservedest(this, type);
     if (!reservedest.GetReservedDestination(dest, true)) {
         error = _("Error: Keypool ran out, please call keypoolrefill first")
                     .translated;
         return false;
     }
 
     reservedest.KeepDestination();
     return true;
 }
 
 int64_t CWallet::GetOldestKeyPoolTime() const {
     LOCK(cs_wallet);
     int64_t oldestKey = std::numeric_limits<int64_t>::max();
     for (const auto &spk_man_pair : m_spk_managers) {
         oldestKey =
             std::min(oldestKey, spk_man_pair.second->GetOldestKeyPoolTime());
     }
     return oldestKey;
 }
 
 void CWallet::MarkDestinationsDirty(
     const std::set<CTxDestination> &destinations) {
     for (auto &entry : mapWallet) {
         CWalletTx &wtx = entry.second;
         if (wtx.m_is_cache_empty) {
             continue;
         }
 
         for (size_t i = 0; i < wtx.tx->vout.size(); i++) {
             CTxDestination dst;
 
             if (ExtractDestination(wtx.tx->vout[i].scriptPubKey, dst) &&
                 destinations.count(dst)) {
                 wtx.MarkDirty();
                 break;
             }
         }
     }
 }
 
 std::set<CTxDestination>
 CWallet::GetLabelAddresses(const std::string &label) const {
     LOCK(cs_wallet);
     std::set<CTxDestination> result;
     for (const std::pair<const CTxDestination, CAddressBookData> &item :
          m_address_book) {
         if (item.second.IsChange()) {
             continue;
         }
         const CTxDestination &address = item.first;
         const std::string &strName = item.second.GetLabel();
         if (strName == label) {
             result.insert(address);
         }
     }
 
     return result;
 }
 
 bool ReserveDestination::GetReservedDestination(CTxDestination &dest,
                                                 bool internal) {
     m_spk_man = pwallet->GetScriptPubKeyMan(type, internal);
     if (!m_spk_man) {
         return false;
     }
 
     if (nIndex == -1) {
         m_spk_man->TopUp();
 
         CKeyPool keypool;
         if (!m_spk_man->GetReservedDestination(type, internal, address, nIndex,
                                                keypool)) {
             return false;
         }
         fInternal = keypool.fInternal;
     }
     dest = address;
     return true;
 }
 
 void ReserveDestination::KeepDestination() {
     if (nIndex != -1) {
         m_spk_man->KeepDestination(nIndex, type);
     }
 
     nIndex = -1;
     address = CNoDestination();
 }
 
 void ReserveDestination::ReturnDestination() {
     if (nIndex != -1) {
         m_spk_man->ReturnDestination(nIndex, fInternal, address);
     }
     nIndex = -1;
     address = CNoDestination();
 }
 
 void CWallet::LockCoin(const COutPoint &output) {
     AssertLockHeld(cs_wallet);
     setLockedCoins.insert(output);
 }
 
 void CWallet::UnlockCoin(const COutPoint &output) {
     AssertLockHeld(cs_wallet);
     setLockedCoins.erase(output);
 }
 
 void CWallet::UnlockAllCoins() {
     AssertLockHeld(cs_wallet);
     setLockedCoins.clear();
 }
 
 bool CWallet::IsLockedCoin(const COutPoint &outpoint) const {
     AssertLockHeld(cs_wallet);
 
     return setLockedCoins.count(outpoint) > 0;
 }
 
 void CWallet::ListLockedCoins(std::vector<COutPoint> &vOutpts) const {
     AssertLockHeld(cs_wallet);
     for (COutPoint outpoint : setLockedCoins) {
         vOutpts.push_back(outpoint);
     }
 }
 
 /** @} */ // end of Actions
 
 void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const {
     AssertLockHeld(cs_wallet);
     mapKeyBirth.clear();
 
     // map in which we'll infer heights of other keys
     std::map<CKeyID, const CWalletTx::Confirmation *> mapKeyFirstBlock;
     CWalletTx::Confirmation max_confirm;
     // the tip can be reorganized; use a 144-block safety margin
     max_confirm.block_height =
         GetLastBlockHeight() > 144 ? GetLastBlockHeight() - 144 : 0;
     CHECK_NONFATAL(chain().findAncestorByHeight(
         GetLastBlockHash(), max_confirm.block_height,
         FoundBlock().hash(max_confirm.hashBlock)));
 
     {
         LegacyScriptPubKeyMan *spk_man = GetLegacyScriptPubKeyMan();
         assert(spk_man != nullptr);
         LOCK(spk_man->cs_KeyStore);
 
         // Get birth times for keys with metadata.
         for (const auto &entry : spk_man->mapKeyMetadata) {
             if (entry.second.nCreateTime) {
                 mapKeyBirth[entry.first] = entry.second.nCreateTime;
             }
         }
 
         // Prepare to infer birth heights for keys without metadata.
         for (const CKeyID &keyid : spk_man->GetKeys()) {
             if (mapKeyBirth.count(keyid) == 0) {
                 mapKeyFirstBlock[keyid] = &max_confirm;
             }
         }
 
         // If there are no such keys, we're done.
         if (mapKeyFirstBlock.empty()) {
             return;
         }
 
         // Find first block that affects those keys, if there are any left.
         for (const auto &entry : mapWallet) {
             // iterate over all wallet transactions...
             const CWalletTx &wtx = entry.second;
             if (wtx.m_confirm.status == CWalletTx::CONFIRMED) {
                 // ... which are already in a block
                 for (const CTxOut &txout : wtx.tx->vout) {
                     // Iterate over all their outputs...
                     for (const auto &keyid :
                          GetAffectedKeys(txout.scriptPubKey, *spk_man)) {
                         // ... and all their affected keys.
                         auto rit = mapKeyFirstBlock.find(keyid);
                         if (rit != mapKeyFirstBlock.end() &&
                             wtx.m_confirm.block_height <
                                 rit->second->block_height) {
                             rit->second = &wtx.m_confirm;
                         }
                     }
                 }
             }
         }
     }
 
     // Extract block timestamps for those keys.
     for (const auto &entry : mapKeyFirstBlock) {
         int64_t block_time;
         CHECK_NONFATAL(chain().findBlock(entry.second->hashBlock,
                                          FoundBlock().time(block_time)));
         // block times can be 2h off
         mapKeyBirth[entry.first] = block_time - TIMESTAMP_WINDOW;
     }
 }
 
 /**
  * Compute smart timestamp for a transaction being added to the wallet.
  *
  * Logic:
  * - If sending a transaction, assign its timestamp to the current time.
  * - If receiving a transaction outside a block, assign its timestamp to the
  *   current time.
  * - If receiving a block with a future timestamp, assign all its (not already
  *   known) transactions' timestamps to the current time.
  * - If receiving a block with a past timestamp, before the most recent known
  *   transaction (that we care about), assign all its (not already known)
  *   transactions' timestamps to the same timestamp as that most-recent-known
  *   transaction.
  * - If receiving a block with a past timestamp, but after the most recent known
  *   transaction, assign all its (not already known) transactions' timestamps to
  *   the block time.
  *
  * For more information see CWalletTx::nTimeSmart,
  * https://bitcointalk.org/?topic=54527, or
  * https://github.com/bitcoin/bitcoin/pull/1393.
  */
 unsigned int CWallet::ComputeTimeSmart(const CWalletTx &wtx) const {
     unsigned int nTimeSmart = wtx.nTimeReceived;
     if (!wtx.isUnconfirmed() && !wtx.isAbandoned()) {
         int64_t blocktime;
         if (chain().findBlock(wtx.m_confirm.hashBlock,
                               FoundBlock().time(blocktime))) {
             int64_t latestNow = wtx.nTimeReceived;
             int64_t latestEntry = 0;
 
             // Tolerate times up to the last timestamp in the wallet not more
             // than 5 minutes into the future
             int64_t latestTolerated = latestNow + 300;
             const TxItems &txOrdered = wtxOrdered;
             for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
                 CWalletTx *const pwtx = it->second;
                 if (pwtx == &wtx) {
                     continue;
                 }
                 int64_t nSmartTime;
                 nSmartTime = pwtx->nTimeSmart;
                 if (!nSmartTime) {
                     nSmartTime = pwtx->nTimeReceived;
                 }
                 if (nSmartTime <= latestTolerated) {
                     latestEntry = nSmartTime;
                     if (nSmartTime > latestNow) {
                         latestNow = nSmartTime;
                     }
                     break;
                 }
             }
 
             nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
         } else {
             WalletLogPrintf("%s: found %s in block %s not in index\n", __func__,
                             wtx.GetId().ToString(),
                             wtx.m_confirm.hashBlock.ToString());
         }
     }
     return nTimeSmart;
 }
 
 bool CWallet::AddDestData(WalletBatch &batch, const CTxDestination &dest,
                           const std::string &key, const std::string &value) {
     if (boost::get<CNoDestination>(&dest)) {
         return false;
     }
 
     m_address_book[dest].destdata.insert(std::make_pair(key, value));
     return batch.WriteDestData(dest, key, value);
 }
 
 bool CWallet::EraseDestData(WalletBatch &batch, const CTxDestination &dest,
                             const std::string &key) {
     if (!m_address_book[dest].destdata.erase(key)) {
         return false;
     }
 
     return batch.EraseDestData(dest, key);
 }
 
 void CWallet::LoadDestData(const CTxDestination &dest, const std::string &key,
                            const std::string &value) {
     m_address_book[dest].destdata.insert(std::make_pair(key, value));
 }
 
 bool CWallet::GetDestData(const CTxDestination &dest, const std::string &key,
                           std::string *value) const {
     std::map<CTxDestination, CAddressBookData>::const_iterator i =
         m_address_book.find(dest);
     if (i != m_address_book.end()) {
         CAddressBookData::StringMap::const_iterator j =
             i->second.destdata.find(key);
         if (j != i->second.destdata.end()) {
             if (value) {
                 *value = j->second;
             }
 
             return true;
         }
     }
     return false;
 }
 
 std::vector<std::string>
 CWallet::GetDestValues(const std::string &prefix) const {
     std::vector<std::string> values;
     for (const auto &address : m_address_book) {
         for (const auto &data : address.second.destdata) {
             if (!data.first.compare(0, prefix.size(), prefix)) {
                 values.emplace_back(data.second);
             }
         }
     }
     return values;
 }
 
 std::unique_ptr<WalletDatabase>
 MakeWalletDatabase(const std::string &name, const DatabaseOptions &options,
                    DatabaseStatus &status, bilingual_str &error_string) {
     // Do some checking on wallet path. It should be either a:
     //
     // 1. Path where a directory can be created.
     // 2. Path to an existing directory.
     // 3. Path to a symlink to a directory.
     // 4. For backwards compatibility, the name of a data file in -walletdir.
     const fs::path wallet_path =
         fsbridge::AbsPathJoin(GetWalletDir(), fs::PathFromString(name));
     fs::file_type path_type = fs::symlink_status(wallet_path).type();
-    if (!(path_type == fs::file_not_found || path_type == fs::directory_file ||
-          (path_type == fs::symlink_file && fs::is_directory(wallet_path)) ||
-          (path_type == fs::regular_file &&
+    if (!(path_type == fs::file_type::not_found ||
+          path_type == fs::file_type::directory ||
+          (path_type == fs::file_type::symlink &&
+           fs::is_directory(wallet_path)) ||
+          (path_type == fs::file_type::regular &&
            fs::PathFromString(name).filename() == fs::PathFromString(name)))) {
         error_string = Untranslated(
             strprintf("Invalid -wallet path '%s'. -wallet path should point to "
                       "a directory where wallet.dat and "
                       "database/log.?????????? files can be stored, a location "
                       "where such a directory could be created, "
                       "or (for backwards compatibility) the name of an "
                       "existing data file in -walletdir (%s)",
                       name, fs::quoted(fs::PathToString(GetWalletDir()))));
         status = DatabaseStatus::FAILED_BAD_PATH;
         return nullptr;
     }
     return MakeDatabase(wallet_path, options, status, error_string);
 }
 
 std::shared_ptr<CWallet>
 CWallet::Create(interfaces::Chain &chain, const std::string &name,
                 std::unique_ptr<WalletDatabase> database,
                 uint64_t wallet_creation_flags, bilingual_str &error,
                 std::vector<bilingual_str> &warnings) {
     const std::string &walletFile = database->Filename();
 
     chain.initMessage(_("Loading wallet...").translated);
 
     int64_t nStart = GetTimeMillis();
     bool fFirstRun = true;
     // TODO: Can't use std::make_shared because we need a custom deleter but
     // should be possible to use std::allocate_shared.
     std::shared_ptr<CWallet> walletInstance(
         new CWallet(&chain, name, std::move(database)), ReleaseWallet);
     DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun);
     if (nLoadWalletRet != DBErrors::LOAD_OK) {
         if (nLoadWalletRet == DBErrors::CORRUPT) {
             error =
                 strprintf(_("Error loading %s: Wallet corrupted"), walletFile);
             return nullptr;
         }
 
         if (nLoadWalletRet == DBErrors::NONCRITICAL_ERROR) {
             warnings.push_back(
                 strprintf(_("Error reading %s! All keys read correctly, but "
                             "transaction data or address book entries might be "
                             "missing or incorrect."),
                           walletFile));
         } else if (nLoadWalletRet == DBErrors::TOO_NEW) {
             error = strprintf(
                 _("Error loading %s: Wallet requires newer version of %s"),
                 walletFile, PACKAGE_NAME);
             return nullptr;
         } else if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
             error = strprintf(
                 _("Wallet needed to be rewritten: restart %s to complete"),
                 PACKAGE_NAME);
             return nullptr;
         } else {
             error = strprintf(_("Error loading %s"), walletFile);
             return nullptr;
         }
     }
 
     if (fFirstRun) {
         // Ensure this wallet.dat can only be opened by clients supporting
         // HD with chain split and expects no default key.
         walletInstance->SetMinVersion(FEATURE_LATEST);
 
         walletInstance->AddWalletFlags(wallet_creation_flags);
 
         // Only create LegacyScriptPubKeyMan when not descriptor wallet
         if (!walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
             walletInstance->SetupLegacyScriptPubKeyMan();
         }
 
         if (!(wallet_creation_flags &
               (WALLET_FLAG_DISABLE_PRIVATE_KEYS | WALLET_FLAG_BLANK_WALLET))) {
             LOCK(walletInstance->cs_wallet);
             if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
                 walletInstance->SetupDescriptorScriptPubKeyMans();
                 // SetupDescriptorScriptPubKeyMans already calls SetupGeneration
                 // for us so we don't need to call SetupGeneration separately
             } else {
                 // Legacy wallets need SetupGeneration here.
                 for (auto spk_man :
                      walletInstance->GetActiveScriptPubKeyMans()) {
                     if (!spk_man->SetupGeneration()) {
                         error = _("Unable to generate initial keys");
                         return nullptr;
                     }
                 }
             }
         }
 
         walletInstance->chainStateFlushed(chain.getTipLocator());
     } else if (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS) {
         // Make it impossible to disable private keys after creation
         error = strprintf(_("Error loading %s: Private keys can only be "
                             "disabled during creation"),
                           walletFile);
         return nullptr;
     } else if (walletInstance->IsWalletFlagSet(
                    WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         for (auto spk_man : walletInstance->GetActiveScriptPubKeyMans()) {
             if (spk_man->HavePrivateKeys()) {
                 warnings.push_back(
                     strprintf(_("Warning: Private keys detected in wallet {%s} "
                                 "with disabled private keys"),
                               walletFile));
             }
         }
     }
 
     if (gArgs.IsArgSet("-mintxfee")) {
         Amount n = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-mintxfee", ""), n) ||
             n == Amount::zero()) {
             error = AmountErrMsg("mintxfee", gArgs.GetArg("-mintxfee", ""));
             return nullptr;
         }
         if (n > HIGH_TX_FEE_PER_KB) {
             warnings.push_back(AmountHighWarn("-mintxfee") + Untranslated(" ") +
                                _("This is the minimum transaction fee you pay "
                                  "on every transaction."));
         }
         walletInstance->m_min_fee = CFeeRate(n);
     }
 
     if (gArgs.IsArgSet("-maxapsfee")) {
         const std::string max_aps_fee{gArgs.GetArg("-maxapsfee", "")};
         Amount n = Amount::zero();
         if (max_aps_fee == "-1") {
             n = -1 * SATOSHI;
         } else if (!ParseMoney(max_aps_fee, n)) {
             error = AmountErrMsg("maxapsfee", max_aps_fee);
             return nullptr;
         }
         if (n > HIGH_APS_FEE) {
             warnings.push_back(
                 AmountHighWarn("-maxapsfee") + Untranslated(" ") +
                 _("This is the maximum transaction fee you pay (in addition to"
                   " the normal fee) to prioritize partial spend avoidance over"
                   " regular coin selection."));
         }
         walletInstance->m_max_aps_fee = n;
     }
 
     if (gArgs.IsArgSet("-fallbackfee")) {
         Amount nFeePerK = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-fallbackfee", ""), nFeePerK)) {
             error =
                 strprintf(_("Invalid amount for -fallbackfee=<amount>: '%s'"),
                           gArgs.GetArg("-fallbackfee", ""));
             return nullptr;
         }
         if (nFeePerK > HIGH_TX_FEE_PER_KB) {
             warnings.push_back(AmountHighWarn("-fallbackfee") +
                                Untranslated(" ") +
                                _("This is the transaction fee you may pay when "
                                  "fee estimates are not available."));
         }
         walletInstance->m_fallback_fee = CFeeRate(nFeePerK);
     }
     // Disable fallback fee in case value was set to 0, enable if non-null value
     walletInstance->m_allow_fallback_fee =
         walletInstance->m_fallback_fee.GetFeePerK() != Amount::zero();
 
     if (gArgs.IsArgSet("-paytxfee")) {
         Amount nFeePerK = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-paytxfee", ""), nFeePerK)) {
             error = AmountErrMsg("paytxfee", gArgs.GetArg("-paytxfee", ""));
             return nullptr;
         }
         if (nFeePerK > HIGH_TX_FEE_PER_KB) {
             warnings.push_back(AmountHighWarn("-paytxfee") + Untranslated(" ") +
                                _("This is the transaction fee you will pay if "
                                  "you send a transaction."));
         }
         walletInstance->m_pay_tx_fee = CFeeRate(nFeePerK, 1000);
         if (walletInstance->m_pay_tx_fee < chain.relayMinFee()) {
             error = strprintf(_("Invalid amount for -paytxfee=<amount>: '%s' "
                                 "(must be at least %s)"),
                               gArgs.GetArg("-paytxfee", ""),
                               chain.relayMinFee().ToString());
             return nullptr;
         }
     }
 
     if (gArgs.IsArgSet("-maxtxfee")) {
         Amount nMaxFee = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-maxtxfee", ""), nMaxFee)) {
             error = AmountErrMsg("maxtxfee", gArgs.GetArg("-maxtxfee", ""));
             return nullptr;
         }
         if (nMaxFee > HIGH_MAX_TX_FEE) {
             warnings.push_back(_("-maxtxfee is set very high! Fees this large "
                                  "could be paid on a single transaction."));
         }
         if (CFeeRate(nMaxFee, 1000) < chain.relayMinFee()) {
             error = strprintf(
                 _("Invalid amount for -maxtxfee=<amount>: '%s' (must be at "
                   "least the minrelay fee of %s to prevent stuck "
                   "transactions)"),
                 gArgs.GetArg("-maxtxfee", ""), chain.relayMinFee().ToString());
             return nullptr;
         }
         walletInstance->m_default_max_tx_fee = nMaxFee;
     }
 
     if (chain.relayMinFee().GetFeePerK() > HIGH_TX_FEE_PER_KB) {
         warnings.push_back(
             AmountHighWarn("-minrelaytxfee") + Untranslated(" ") +
             _("The wallet will avoid paying less than the minimum relay fee."));
     }
 
     walletInstance->m_spend_zero_conf_change =
         gArgs.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
 
     walletInstance->m_default_address_type = DEFAULT_ADDRESS_TYPE;
 
     walletInstance->WalletLogPrintf("Wallet completed loading in %15dms\n",
                                     GetTimeMillis() - nStart);
 
     // Try to top up keypool. No-op if the wallet is locked.
     walletInstance->TopUpKeyPool();
 
     LOCK(walletInstance->cs_wallet);
 
     // Register wallet with validationinterface. It's done before rescan to
     // avoid missing block connections between end of rescan and validation
     // subscribing. Because of wallet lock being hold, block connection
     // notifications are going to be pending on the validation-side until lock
     // release. It's likely to have block processing duplicata (if rescan block
     // range overlaps with notification one) but we guarantee at least than
     // wallet state is correct after notifications delivery. This is temporary
     // until rescan and notifications delivery are unified under same interface.
     walletInstance->m_chain_notifications_handler =
         walletInstance->chain().handleNotifications(walletInstance);
 
     int rescan_height = 0;
     if (!gArgs.GetBoolArg("-rescan", false)) {
         WalletBatch batch(*walletInstance->database);
         CBlockLocator locator;
         if (batch.ReadBestBlock(locator)) {
             if (const std::optional<int> fork_height =
                     chain.findLocatorFork(locator)) {
                 rescan_height = *fork_height;
             }
         }
     }
 
     const std::optional<int> tip_height = chain.getHeight();
     if (tip_height) {
         walletInstance->m_last_block_processed =
             chain.getBlockHash(*tip_height);
         walletInstance->m_last_block_processed_height = *tip_height;
     } else {
         walletInstance->m_last_block_processed.SetNull();
         walletInstance->m_last_block_processed_height = -1;
     }
 
     if (tip_height && *tip_height != rescan_height) {
         // We can't rescan beyond non-pruned blocks, stop and throw an error.
         // This might happen if a user uses an old wallet within a pruned node
         // or if they ran -disablewallet for a longer time, then decided to
         // re-enable
         if (chain.havePruned()) {
             // Exit early and print an error.
             // If a block is pruned after this check, we will load the wallet,
             // but fail the rescan with a generic error.
             int block_height = *tip_height;
             while (block_height > 0 &&
                    chain.haveBlockOnDisk(block_height - 1) &&
                    rescan_height != block_height) {
                 --block_height;
             }
 
             if (rescan_height != block_height) {
                 error = _("Prune: last wallet synchronisation goes beyond "
                           "pruned data. You need to -reindex (download the "
                           "whole blockchain again in case of pruned node)");
                 return nullptr;
             }
         }
 
         chain.initMessage(_("Rescanning...").translated);
         walletInstance->WalletLogPrintf(
             "Rescanning last %i blocks (from block %i)...\n",
             *tip_height - rescan_height, rescan_height);
 
         // No need to read and scan block if block was created before our wallet
         // birthday (as adjusted for block time variability)
         std::optional<int64_t> time_first_key;
         for (auto spk_man : walletInstance->GetAllScriptPubKeyMans()) {
             int64_t time = spk_man->GetTimeFirstKey();
             if (!time_first_key || time < *time_first_key) {
                 time_first_key = time;
             }
         }
         if (time_first_key) {
             chain.findFirstBlockWithTimeAndHeight(
                 *time_first_key - TIMESTAMP_WINDOW, rescan_height,
                 FoundBlock().height(rescan_height));
         }
 
         {
             WalletRescanReserver reserver(*walletInstance);
             if (!reserver.reserve() ||
                 (ScanResult::SUCCESS !=
                  walletInstance
                      ->ScanForWalletTransactions(
                          chain.getBlockHash(rescan_height), rescan_height,
                          {} /* max height */, reserver, true /* update */)
                      .status)) {
                 error = _("Failed to rescan the wallet during initialization");
                 return nullptr;
             }
         }
         walletInstance->chainStateFlushed(chain.getTipLocator());
         walletInstance->database->IncrementUpdateCounter();
     }
 
     {
         LOCK(cs_wallets);
         for (auto &load_wallet : g_load_wallet_fns) {
             load_wallet(interfaces::MakeWallet(walletInstance));
         }
     }
 
     walletInstance->SetBroadcastTransactions(
         gArgs.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));
 
     walletInstance->WalletLogPrintf("setKeyPool.size() = %u\n",
                                     walletInstance->GetKeyPoolSize());
     walletInstance->WalletLogPrintf("mapWallet.size() = %u\n",
                                     walletInstance->mapWallet.size());
     walletInstance->WalletLogPrintf("m_address_book.size() = %u\n",
                                     walletInstance->m_address_book.size());
 
     return walletInstance;
 }
 
 const CAddressBookData *
 CWallet::FindAddressBookEntry(const CTxDestination &dest,
                               bool allow_change) const {
     const auto &address_book_it = m_address_book.find(dest);
     if (address_book_it == m_address_book.end()) {
         return nullptr;
     }
     if ((!allow_change) && address_book_it->second.IsChange()) {
         return nullptr;
     }
     return &address_book_it->second;
 }
 
 bool CWallet::UpgradeWallet(int version, bilingual_str &error) {
     int prev_version = GetVersion();
     int nMaxVersion = version;
     // The -upgradewallet without argument case
     if (nMaxVersion == 0) {
         WalletLogPrintf("Performing wallet upgrade to %i\n", FEATURE_LATEST);
         nMaxVersion = FEATURE_LATEST;
         // permanently upgrade the wallet immediately
         SetMinVersion(FEATURE_LATEST);
     } else {
         WalletLogPrintf("Allowing wallet upgrade up to %i\n", nMaxVersion);
     }
 
     if (nMaxVersion < GetVersion()) {
         error = _("Cannot downgrade wallet");
         return false;
     }
 
     SetMaxVersion(nMaxVersion);
 
     LOCK(cs_wallet);
 
     // Do not upgrade versions to any version between HD_SPLIT and
     // FEATURE_PRE_SPLIT_KEYPOOL unless already supporting HD_SPLIT
     int max_version = GetVersion();
     if (!CanSupportFeature(FEATURE_HD_SPLIT) &&
         max_version >= FEATURE_HD_SPLIT &&
         max_version < FEATURE_PRE_SPLIT_KEYPOOL) {
         error = _("Cannot upgrade a non HD split wallet without upgrading to "
                   "support pre split keypool. Please use version 200300 or no "
                   "version specified.");
         return false;
     }
 
     for (auto spk_man : GetActiveScriptPubKeyMans()) {
         if (!spk_man->Upgrade(prev_version, error)) {
             return false;
         }
     }
 
     return true;
 }
 
 void CWallet::postInitProcess() {
     LOCK(cs_wallet);
 
     // Add wallet transactions that aren't already in a block to mempool.
     // Do this here as mempool requires genesis block to be loaded.
     ReacceptWalletTransactions();
 
     // Update wallet transactions with current mempool transactions.
     chain().requestMempoolTransactions(*this);
 }
 
 bool CWallet::BackupWallet(const std::string &strDest) const {
     return database->Backup(strDest);
 }
 
 CKeyPool::CKeyPool() {
     nTime = GetTime();
     fInternal = false;
     m_pre_split = false;
 }
 
 CKeyPool::CKeyPool(const CPubKey &vchPubKeyIn, bool internalIn) {
     nTime = GetTime();
     vchPubKey = vchPubKeyIn;
     fInternal = internalIn;
     m_pre_split = false;
 }
 
 int CWallet::GetTxDepthInMainChain(const CWalletTx &wtx) const {
     AssertLockHeld(cs_wallet);
     if (wtx.isUnconfirmed() || wtx.isAbandoned()) {
         return 0;
     }
 
     return (GetLastBlockHeight() - wtx.m_confirm.block_height + 1) *
            (wtx.isConflicted() ? -1 : 1);
 }
 
 int CWallet::GetTxBlocksToMaturity(const CWalletTx &wtx) const {
     AssertLockHeld(cs_wallet);
 
     if (!wtx.IsCoinBase()) {
         return 0;
     }
     int chain_depth = GetTxDepthInMainChain(wtx);
     // coinbase tx should not be conflicted
     assert(chain_depth >= 0);
     return std::max(0, (COINBASE_MATURITY + 1) - chain_depth);
 }
 
 bool CWallet::IsTxImmatureCoinBase(const CWalletTx &wtx) const {
     AssertLockHeld(cs_wallet);
 
     // note GetBlocksToMaturity is 0 for non-coinbase tx
     return GetTxBlocksToMaturity(wtx) > 0;
 }
 
 bool CWallet::IsCrypted() const {
     return HasEncryptionKeys();
 }
 
 bool CWallet::IsLocked() const {
     if (!IsCrypted()) {
         return false;
     }
     LOCK(cs_wallet);
     return vMasterKey.empty();
 }
 
 bool CWallet::Lock() {
     if (!IsCrypted()) {
         return false;
     }
 
     {
         LOCK(cs_wallet);
         if (!vMasterKey.empty()) {
             memory_cleanse(vMasterKey.data(),
                            vMasterKey.size() *
                                sizeof(decltype(vMasterKey)::value_type));
             vMasterKey.clear();
         }
     }
 
     NotifyStatusChanged(this);
     return true;
 }
 
 bool CWallet::Unlock(const CKeyingMaterial &vMasterKeyIn, bool accept_no_keys) {
     {
         LOCK(cs_wallet);
         for (const auto &spk_man_pair : m_spk_managers) {
             if (!spk_man_pair.second->CheckDecryptionKey(vMasterKeyIn,
                                                          accept_no_keys)) {
                 return false;
             }
         }
         vMasterKey = vMasterKeyIn;
     }
     NotifyStatusChanged(this);
     return true;
 }
 
 std::set<ScriptPubKeyMan *> CWallet::GetActiveScriptPubKeyMans() const {
     std::set<ScriptPubKeyMan *> spk_mans;
     for (bool internal : {false, true}) {
         for (OutputType t : OUTPUT_TYPES) {
             auto spk_man = GetScriptPubKeyMan(t, internal);
             if (spk_man) {
                 spk_mans.insert(spk_man);
             }
         }
     }
     return spk_mans;
 }
 
 std::set<ScriptPubKeyMan *> CWallet::GetAllScriptPubKeyMans() const {
     std::set<ScriptPubKeyMan *> spk_mans;
     for (const auto &spk_man_pair : m_spk_managers) {
         spk_mans.insert(spk_man_pair.second.get());
     }
     return spk_mans;
 }
 
 ScriptPubKeyMan *CWallet::GetScriptPubKeyMan(const OutputType &type,
                                              bool internal) const {
     const std::map<OutputType, ScriptPubKeyMan *> &spk_managers =
         internal ? m_internal_spk_managers : m_external_spk_managers;
     std::map<OutputType, ScriptPubKeyMan *>::const_iterator it =
         spk_managers.find(type);
     if (it == spk_managers.end()) {
         WalletLogPrintf(
             "%s scriptPubKey Manager for output type %d does not exist\n",
             internal ? "Internal" : "External", static_cast<int>(type));
         return nullptr;
     }
     return it->second;
 }
 
 std::set<ScriptPubKeyMan *>
 CWallet::GetScriptPubKeyMans(const CScript &script,
                              SignatureData &sigdata) const {
     std::set<ScriptPubKeyMan *> spk_mans;
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script, sigdata)) {
             spk_mans.insert(spk_man_pair.second.get());
         }
     }
     return spk_mans;
 }
 
 ScriptPubKeyMan *CWallet::GetScriptPubKeyMan(const CScript &script) const {
     SignatureData sigdata;
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script, sigdata)) {
             return spk_man_pair.second.get();
         }
     }
     return nullptr;
 }
 
 ScriptPubKeyMan *CWallet::GetScriptPubKeyMan(const uint256 &id) const {
     if (m_spk_managers.count(id) > 0) {
         return m_spk_managers.at(id).get();
     }
     return nullptr;
 }
 
 std::unique_ptr<SigningProvider>
 CWallet::GetSolvingProvider(const CScript &script) const {
     SignatureData sigdata;
     return GetSolvingProvider(script, sigdata);
 }
 
 std::unique_ptr<SigningProvider>
 CWallet::GetSolvingProvider(const CScript &script,
                             SignatureData &sigdata) const {
     for (const auto &spk_man_pair : m_spk_managers) {
         if (spk_man_pair.second->CanProvide(script, sigdata)) {
             return spk_man_pair.second->GetSolvingProvider(script);
         }
     }
     return nullptr;
 }
 
 LegacyScriptPubKeyMan *CWallet::GetLegacyScriptPubKeyMan() const {
     if (IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
         return nullptr;
     }
     // Legacy wallets only have one ScriptPubKeyMan which is a
     // LegacyScriptPubKeyMan. Everything in m_internal_spk_managers and
     // m_external_spk_managers point to the same legacyScriptPubKeyMan.
     auto it = m_internal_spk_managers.find(OutputType::LEGACY);
     if (it == m_internal_spk_managers.end()) {
         return nullptr;
     }
     return dynamic_cast<LegacyScriptPubKeyMan *>(it->second);
 }
 
 LegacyScriptPubKeyMan *CWallet::GetOrCreateLegacyScriptPubKeyMan() {
     SetupLegacyScriptPubKeyMan();
     return GetLegacyScriptPubKeyMan();
 }
 
 void CWallet::SetupLegacyScriptPubKeyMan() {
     if (!m_internal_spk_managers.empty() || !m_external_spk_managers.empty() ||
         !m_spk_managers.empty() || IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
         return;
     }
 
     auto spk_manager =
         std::unique_ptr<ScriptPubKeyMan>(new LegacyScriptPubKeyMan(*this));
     for (const auto &type : OUTPUT_TYPES) {
         m_internal_spk_managers[type] = spk_manager.get();
         m_external_spk_managers[type] = spk_manager.get();
     }
     m_spk_managers[spk_manager->GetID()] = std::move(spk_manager);
 }
 
 const CKeyingMaterial &CWallet::GetEncryptionKey() const {
     return vMasterKey;
 }
 
 bool CWallet::HasEncryptionKeys() const {
     return !mapMasterKeys.empty();
 }
 
 void CWallet::ConnectScriptPubKeyManNotifiers() {
     for (const auto &spk_man : GetActiveScriptPubKeyMans()) {
         spk_man->NotifyWatchonlyChanged.connect(NotifyWatchonlyChanged);
         spk_man->NotifyCanGetAddressesChanged.connect(
             NotifyCanGetAddressesChanged);
     }
 }
 
 void CWallet::LoadDescriptorScriptPubKeyMan(uint256 id,
                                             WalletDescriptor &desc) {
     auto spk_manager = std::unique_ptr<ScriptPubKeyMan>(
         new DescriptorScriptPubKeyMan(*this, desc));
     m_spk_managers[id] = std::move(spk_manager);
 }
 
 void CWallet::SetupDescriptorScriptPubKeyMans() {
     AssertLockHeld(cs_wallet);
 
     // Make a seed
     CKey seed_key;
     seed_key.MakeNewKey(true);
     CPubKey seed = seed_key.GetPubKey();
     assert(seed_key.VerifyPubKey(seed));
 
     // Get the extended key
     CExtKey master_key;
     master_key.SetSeed(seed_key.begin(), seed_key.size());
 
     for (bool internal : {false, true}) {
         for (OutputType t : OUTPUT_TYPES) {
             auto spk_manager =
                 std::make_unique<DescriptorScriptPubKeyMan>(*this, internal);
             if (IsCrypted()) {
                 if (IsLocked()) {
                     throw std::runtime_error(
                         std::string(__func__) +
                         ": Wallet is locked, cannot setup new descriptors");
                 }
                 if (!spk_manager->CheckDecryptionKey(vMasterKey) &&
                     !spk_manager->Encrypt(vMasterKey, nullptr)) {
                     throw std::runtime_error(
                         std::string(__func__) +
                         ": Could not encrypt new descriptors");
                 }
             }
             spk_manager->SetupDescriptorGeneration(master_key, t);
             uint256 id = spk_manager->GetID();
             m_spk_managers[id] = std::move(spk_manager);
             AddActiveScriptPubKeyMan(id, t, internal);
         }
     }
 }
 
 void CWallet::AddActiveScriptPubKeyMan(uint256 id, OutputType type,
                                        bool internal) {
     WalletBatch batch(*database);
     if (!batch.WriteActiveScriptPubKeyMan(static_cast<uint8_t>(type), id,
                                           internal)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing active ScriptPubKeyMan id failed");
     }
     LoadActiveScriptPubKeyMan(id, type, internal);
 }
 
 void CWallet::LoadActiveScriptPubKeyMan(uint256 id, OutputType type,
                                         bool internal) {
     WalletLogPrintf(
         "Setting spkMan to active: id = %s, type = %d, internal = %d\n",
         id.ToString(), static_cast<int>(type), static_cast<int>(internal));
     auto &spk_mans =
         internal ? m_internal_spk_managers : m_external_spk_managers;
     auto spk_man = m_spk_managers.at(id).get();
     spk_man->SetInternal(internal);
     spk_mans[type] = spk_man;
 
     NotifyCanGetAddressesChanged();
 }
 
 bool CWallet::IsLegacy() const {
     if (m_internal_spk_managers.count(OutputType::LEGACY) == 0) {
         return false;
     }
     auto spk_man = dynamic_cast<LegacyScriptPubKeyMan *>(
         m_internal_spk_managers.at(OutputType::LEGACY));
     return spk_man != nullptr;
 }
 
 DescriptorScriptPubKeyMan *
 CWallet::GetDescriptorScriptPubKeyMan(const WalletDescriptor &desc) const {
     for (auto &spk_man_pair : m_spk_managers) {
         // Try to downcast to DescriptorScriptPubKeyMan then check if the
         // descriptors match
         DescriptorScriptPubKeyMan *spk_manager =
             dynamic_cast<DescriptorScriptPubKeyMan *>(
                 spk_man_pair.second.get());
         if (spk_manager != nullptr && spk_manager->HasWalletDescriptor(desc)) {
             return spk_manager;
         }
     }
 
     return nullptr;
 }
 
 ScriptPubKeyMan *
 CWallet::AddWalletDescriptor(WalletDescriptor &desc,
                              const FlatSigningProvider &signing_provider,
                              const std::string &label, bool internal) {
     if (!IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS)) {
         WalletLogPrintf(
             "Cannot add WalletDescriptor to a non-descriptor wallet\n");
         return nullptr;
     }
 
     LOCK(cs_wallet);
     auto new_spk_man = std::make_unique<DescriptorScriptPubKeyMan>(*this, desc);
 
     // If we already have this descriptor, remove it from the maps but add the
     // existing cache to desc
     auto old_spk_man = GetDescriptorScriptPubKeyMan(desc);
     if (old_spk_man) {
         WalletLogPrintf("Update existing descriptor: %s\n",
                         desc.descriptor->ToString());
 
         {
             LOCK(old_spk_man->cs_desc_man);
             new_spk_man->SetCache(old_spk_man->GetWalletDescriptor().cache);
         }
 
         // Remove from maps of active spkMans
         auto old_spk_man_id = old_spk_man->GetID();
         for (bool internal_ : {false, true}) {
             for (OutputType t : OUTPUT_TYPES) {
                 auto active_spk_man = GetScriptPubKeyMan(t, internal_);
                 if (active_spk_man &&
                     active_spk_man->GetID() == old_spk_man_id) {
                     if (internal_) {
                         m_internal_spk_managers.erase(t);
                     } else {
                         m_external_spk_managers.erase(t);
                     }
                     break;
                 }
             }
         }
         m_spk_managers.erase(old_spk_man_id);
     }
 
     // Add the private keys to the descriptor
     for (const auto &entry : signing_provider.keys) {
         const CKey &key = entry.second;
         new_spk_man->AddDescriptorKey(key, key.GetPubKey());
     }
 
     // Top up key pool, the manager will generate new scriptPubKeys internally
     if (!new_spk_man->TopUp()) {
         WalletLogPrintf("Could not top up scriptPubKeys\n");
         return nullptr;
     }
 
     // Apply the label if necessary
     // Note: we disable labels for ranged descriptors
     if (!desc.descriptor->IsRange()) {
         auto script_pub_keys = new_spk_man->GetScriptPubKeys();
         if (script_pub_keys.empty()) {
             WalletLogPrintf(
                 "Could not generate scriptPubKeys (cache is empty)\n");
             return nullptr;
         }
 
         CTxDestination dest;
         if (!internal && ExtractDestination(script_pub_keys.at(0), dest)) {
             SetAddressBook(dest, label, "receive");
         }
     }
 
     // Save the descriptor to memory
     auto ret = new_spk_man.get();
     m_spk_managers[new_spk_man->GetID()] = std::move(new_spk_man);
 
     // Save the descriptor to DB
     ret->WriteDescriptor();
 
     return ret;
 }
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index 9970d45f9..3bd4c1c2c 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -1,1172 +1,1172 @@
 // 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.
 
 #include <wallet/walletdb.h>
 
 #include <chainparams.h>
 #include <fs.h>
 #include <key_io.h>
 #include <protocol.h>
 #include <serialize.h>
 #include <sync.h>
 #include <util/bip32.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <util/translation.h>
 #include <wallet/bdb.h>
 #include <wallet/wallet.h>
 
 #include <atomic>
 
 namespace DBKeys {
 const std::string ACENTRY{"acentry"};
 const std::string ACTIVEEXTERNALSPK{"activeexternalspk"};
 const std::string ACTIVEINTERNALSPK{"activeinternalspk"};
 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 SETTINGS{"settings"};
 const std::string TX{"tx"};
 const std::string VERSION{"version"};
 const std::string WALLETDESCRIPTOR{"walletdescriptor"};
 const std::string WALLETDESCRIPTORCACHE{"walletdescriptorcache"};
 const std::string WALLETDESCRIPTORCKEY{"walletdescriptorckey"};
 const std::string WALLETDESCRIPTORKEY{"walletdescriptorkey"};
 const std::string WATCHMETA{"watchmeta"};
 const std::string WATCHS{"watchs"};
 } // namespace DBKeys
 
 //
 // WalletBatch
 //
 
 bool WalletBatch::WriteName(const CTxDestination &address,
                             const std::string &strName) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return WriteIC(
         std::make_pair(DBKeys::NAME, EncodeLegacyAddr(address, Params())),
         strName);
 }
 
 bool WalletBatch::EraseName(const CTxDestination &address) {
     // This should only be used for sending addresses, never for receiving
     // addresses, receiving addresses must always have an address book entry if
     // they're not change return.
     if (!IsValidDestination(address)) {
         return false;
     }
     return EraseIC(
         std::make_pair(DBKeys::NAME, EncodeLegacyAddr(address, Params())));
 }
 
 bool WalletBatch::WritePurpose(const CTxDestination &address,
                                const std::string &strPurpose) {
     if (!IsValidDestination(address)) {
         return false;
     }
     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(DBKeys::PURPOSE, EncodeLegacyAddr(address, Params())));
 }
 
 bool WalletBatch::WriteTx(const CWalletTx &wtx) {
     return WriteIC(std::make_pair(DBKeys::TX, wtx.GetId()), wtx);
 }
 
 bool WalletBatch::EraseTx(uint256 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(DBKeys::KEYMETA, pubkey), meta, overwrite);
 }
 
 bool WalletBatch::WriteKey(const CPubKey &vchPubKey, const CPrivKey &vchPrivKey,
                            const CKeyMetadata &keyMeta) {
     if (!WriteKeyMetadata(keyMeta, vchPubKey, false)) {
         return false;
     }
 
     // hash pubkey/privkey to accelerate wallet load
     std::vector<uint8_t> vchKey;
     vchKey.reserve(vchPubKey.size() + vchPrivKey.size());
     vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
     vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());
 
     return WriteIC(std::make_pair(DBKeys::KEY, vchPubKey),
                    std::make_pair(vchPrivKey, Hash(vchKey)), false);
 }
 
 bool WalletBatch::WriteCryptedKey(const CPubKey &vchPubKey,
                                   const std::vector<uint8_t> &vchCryptedSecret,
                                   const CKeyMetadata &keyMeta) {
     if (!WriteKeyMetadata(keyMeta, vchPubKey, true)) {
         return false;
     }
 
     // Compute a checksum of the encrypted key
     uint256 checksum = Hash(vchCryptedSecret);
 
     const auto key = std::make_pair(DBKeys::CRYPTED_KEY, vchPubKey);
     if (!WriteIC(key, std::make_pair(vchCryptedSecret, checksum), false)) {
         // It may already exist, so try writing just the checksum
         std::vector<uint8_t> val;
         if (!m_batch->Read(key, val)) {
             return false;
         }
         if (!WriteIC(key, std::make_pair(val, checksum), true)) {
             return false;
         }
     }
     EraseIC(std::make_pair(DBKeys::KEY, vchPubKey));
     return true;
 }
 
 bool WalletBatch::WriteMasterKey(unsigned int nID,
                                  const CMasterKey &kMasterKey) {
     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(DBKeys::CSCRIPT, hash), redeemScript, false);
 }
 
 bool WalletBatch::WriteWatchOnly(const CScript &dest,
                                  const CKeyMetadata &keyMeta) {
     if (!WriteIC(std::make_pair(DBKeys::WATCHMETA, dest), keyMeta)) {
         return false;
     }
     return WriteIC(std::make_pair(DBKeys::WATCHS, dest), '1');
 }
 
 bool WalletBatch::EraseWatchOnly(const CScript &dest) {
     if (!EraseIC(std::make_pair(DBKeys::WATCHMETA, dest))) {
         return false;
     }
     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(DBKeys::BESTBLOCK, CBlockLocator());
     return WriteIC(DBKeys::BESTBLOCK_NOMERKLE, locator);
 }
 
 bool WalletBatch::ReadBestBlock(CBlockLocator &locator) {
     if (m_batch->Read(DBKeys::BESTBLOCK, locator) && !locator.vHave.empty()) {
         return true;
     }
     return m_batch->Read(DBKeys::BESTBLOCK_NOMERKLE, locator);
 }
 
 bool WalletBatch::WriteOrderPosNext(int64_t nOrderPosNext) {
     return WriteIC(DBKeys::ORDERPOSNEXT, nOrderPosNext);
 }
 
 bool WalletBatch::ReadPool(int64_t nPool, CKeyPool &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(DBKeys::POOL, nPool), keypool);
 }
 
 bool WalletBatch::ErasePool(int64_t nPool) {
     return EraseIC(std::make_pair(DBKeys::POOL, nPool));
 }
 
 bool WalletBatch::WriteMinVersion(int nVersion) {
     return WriteIC(DBKeys::MINVERSION, nVersion);
 }
 
 bool WalletBatch::WriteActiveScriptPubKeyMan(uint8_t type, const uint256 &id,
                                              bool internal) {
     std::string key =
         internal ? DBKeys::ACTIVEINTERNALSPK : DBKeys::ACTIVEEXTERNALSPK;
     return WriteIC(make_pair(key, type), id);
 }
 
 bool WalletBatch::WriteDescriptorKey(const uint256 &desc_id,
                                      const CPubKey &pubkey,
                                      const CPrivKey &privkey) {
     // hash pubkey/privkey to accelerate wallet load
     std::vector<uint8_t> key;
     key.reserve(pubkey.size() + privkey.size());
     key.insert(key.end(), pubkey.begin(), pubkey.end());
     key.insert(key.end(), privkey.begin(), privkey.end());
 
     return WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY,
                                   std::make_pair(desc_id, pubkey)),
                    std::make_pair(privkey, Hash(key)), false);
 }
 
 bool WalletBatch::WriteCryptedDescriptorKey(
     const uint256 &desc_id, const CPubKey &pubkey,
     const std::vector<uint8_t> &secret) {
     if (!WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORCKEY,
                                 std::make_pair(desc_id, pubkey)),
                  secret, false)) {
         return false;
     }
     EraseIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY,
                            std::make_pair(desc_id, pubkey)));
     return true;
 }
 
 bool WalletBatch::WriteDescriptor(const uint256 &desc_id,
                                   const WalletDescriptor &descriptor) {
     return WriteIC(make_pair(DBKeys::WALLETDESCRIPTOR, desc_id), descriptor);
 }
 
 bool WalletBatch::WriteDescriptorDerivedCache(const CExtPubKey &xpub,
                                               const uint256 &desc_id,
                                               uint32_t key_exp_index,
                                               uint32_t der_index) {
     std::vector<uint8_t> ser_xpub(BIP32_EXTKEY_SIZE);
     xpub.Encode(ser_xpub.data());
     return WriteIC(
         std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORCACHE, desc_id),
                        std::make_pair(key_exp_index, der_index)),
         ser_xpub);
 }
 
 bool WalletBatch::WriteDescriptorParentCache(const CExtPubKey &xpub,
                                              const uint256 &desc_id,
                                              uint32_t key_exp_index) {
     std::vector<uint8_t> ser_xpub(BIP32_EXTKEY_SIZE);
     xpub.Encode(ser_xpub.data());
     return WriteIC(
         std::make_pair(std::make_pair(DBKeys::WALLETDESCRIPTORCACHE, desc_id),
                        key_exp_index),
         ser_xpub);
 }
 
 class CWalletScanState {
 public:
     unsigned int nKeys{0};
     unsigned int nCKeys{0};
     unsigned int nWatchKeys{0};
     unsigned int nKeyMeta{0};
     unsigned int m_unknown_records{0};
     bool fIsEncrypted{false};
     bool fAnyUnordered{false};
     std::vector<TxId> vWalletUpgrade;
     std::map<OutputType, uint256> m_active_external_spks;
     std::map<OutputType, uint256> m_active_internal_spks;
     std::map<uint256, DescriptorCache> m_descriptor_caches;
     std::map<std::pair<uint256, CKeyID>, CKey> m_descriptor_keys;
     std::map<std::pair<uint256, CKeyID>,
              std::pair<CPubKey, std::vector<uint8_t>>>
         m_descriptor_crypt_keys;
     std::map<uint160, CHDChain> m_hd_chains;
 
     CWalletScanState() {}
 };
 
 static bool ReadKeyValue(CWallet *pwallet, CDataStream &ssKey,
                          CDataStream &ssValue, CWalletScanState &wss,
                          std::string &strType, std::string &strErr,
                          const KeyFilterFn &filter_fn = nullptr)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     try {
         // Unserialize
         // Taking advantage of the fact that pair serialization is just the two
         // items serialized one after the other.
         ssKey >> strType;
         // If we have a filter, check if this matches the filter
         if (filter_fn && !filter_fn(strType)) {
             return true;
         }
         if (strType == DBKeys::NAME) {
             std::string strAddress;
             ssKey >> strAddress;
             std::string label;
             ssValue >> label;
             pwallet
                 ->m_address_book[DecodeDestination(strAddress,
                                                    pwallet->GetChainParams())]
                 .SetLabel(label);
         } else if (strType == DBKeys::PURPOSE) {
             std::string strAddress;
             ssKey >> strAddress;
             ssValue >> pwallet
                            ->m_address_book[DecodeDestination(
                                strAddress, pwallet->GetChainParams())]
                            .purpose;
         } else if (strType == DBKeys::TX) {
             TxId txid;
             ssKey >> txid;
             // LoadToWallet call below creates a new CWalletTx that fill_wtx
             // callback fills with transaction metadata.
             auto fill_wtx = [&](CWalletTx &wtx, bool new_tx) {
                 assert(new_tx);
                 ssValue >> wtx;
                 if (wtx.GetId() != txid) {
                     return false;
                 }
 
                 // Undo serialize changes in 31600
                 if (31404 <= wtx.fTimeReceivedIsTxTime &&
                     wtx.fTimeReceivedIsTxTime <= 31703) {
                     if (!ssValue.empty()) {
                         char fTmp;
                         char fUnused;
                         std::string unused_string;
                         ssValue >> fTmp >> fUnused >> unused_string;
                         strErr = strprintf(
                             "LoadWallet() upgrading tx ver=%d %d %s",
                             wtx.fTimeReceivedIsTxTime, fTmp, txid.ToString());
                         wtx.fTimeReceivedIsTxTime = fTmp;
                     } else {
                         strErr = strprintf(
                             "LoadWallet() repairing tx ver=%d %s",
                             wtx.fTimeReceivedIsTxTime, txid.ToString());
                         wtx.fTimeReceivedIsTxTime = 0;
                     }
                     wss.vWalletUpgrade.push_back(txid);
                 }
 
                 if (wtx.nOrderPos == -1) {
                     wss.fAnyUnordered = true;
                 }
 
                 return true;
             };
             if (!pwallet->LoadToWallet(txid, fill_wtx)) {
                 return false;
             }
         } else if (strType == DBKeys::WATCHS) {
             wss.nWatchKeys++;
             CScript script;
             ssKey >> script;
             char fYes;
             ssValue >> fYes;
             if (fYes == '1') {
                 pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadWatchOnly(
                     script);
             }
         } else if (strType == DBKeys::KEY) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             if (!vchPubKey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             CKey key;
             CPrivKey pkey;
             uint256 hash;
 
             wss.nKeys++;
             ssValue >> pkey;
 
             // 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 {
                 ssValue >> hash;
             } catch (...) {
             }
 
             bool fSkipCheck = false;
 
             if (!hash.IsNull()) {
                 // hash pubkey/privkey to accelerate wallet load
                 std::vector<uint8_t> vchKey;
                 vchKey.reserve(vchPubKey.size() + pkey.size());
                 vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
                 vchKey.insert(vchKey.end(), pkey.begin(), pkey.end());
 
                 if (Hash(vchKey) != hash) {
                     strErr = "Error reading wallet database: CPubKey/CPrivKey "
                              "corrupt";
                     return false;
                 }
 
                 fSkipCheck = true;
             }
 
             if (!key.Load(pkey, vchPubKey, fSkipCheck)) {
                 strErr = "Error reading wallet database: CPrivKey corrupt";
                 return false;
             }
             if (!pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadKey(
                     key, vchPubKey)) {
                 strErr = "Error reading wallet database: "
                          "LegacyScriptPubKeyMan::LoadKey failed";
                 return false;
             }
         } else if (strType == DBKeys::MASTER_KEY) {
             // Master encryption key is loaded into only the wallet and not any
             // of the ScriptPubKeyMans.
             unsigned int nID;
             ssKey >> nID;
             CMasterKey kMasterKey;
             ssValue >> kMasterKey;
             if (pwallet->mapMasterKeys.count(nID) != 0) {
                 strErr = strprintf(
                     "Error reading wallet database: duplicate CMasterKey id %u",
                     nID);
                 return false;
             }
             pwallet->mapMasterKeys[nID] = kMasterKey;
             if (pwallet->nMasterKeyMaxID < nID) {
                 pwallet->nMasterKeyMaxID = nID;
             }
         } else if (strType == DBKeys::CRYPTED_KEY) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             if (!vchPubKey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             std::vector<uint8_t> vchPrivKey;
             ssValue >> vchPrivKey;
 
             // Get the checksum and check it
             bool checksum_valid = false;
             if (!ssValue.eof()) {
                 uint256 checksum;
                 ssValue >> checksum;
                 if ((checksum_valid = Hash(vchPrivKey) != checksum)) {
                     strErr =
                         "Error reading wallet database: Crypted key corrupt";
                     return false;
                 }
             }
 
             wss.nCKeys++;
 
             if (!pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadCryptedKey(
                     vchPubKey, vchPrivKey, checksum_valid)) {
                 strErr = "Error reading wallet database: "
                          "LegacyScriptPubKeyMan::LoadCryptedKey failed";
                 return false;
             }
             wss.fIsEncrypted = true;
         } else if (strType == DBKeys::KEYMETA) {
             CPubKey vchPubKey;
             ssKey >> vchPubKey;
             CKeyMetadata keyMeta;
             ssValue >> keyMeta;
             wss.nKeyMeta++;
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadKeyMetadata(
                 vchPubKey.GetID(), keyMeta);
 
             // Extract some CHDChain info from this metadata if it has any
             if (keyMeta.nVersion >= CKeyMetadata::VERSION_WITH_HDDATA &&
                 !keyMeta.hd_seed_id.IsNull() && keyMeta.hdKeypath.size() > 0) {
                 // Get the path from the key origin or from the path string
                 // Not applicable when path is "s" or "m" as those indicate a
                 // seed.
                 // See https://reviews.bitcoinabc.org/D4175
                 bool internal = false;
                 uint32_t index = 0;
                 if (keyMeta.hdKeypath != "s" && keyMeta.hdKeypath != "m") {
                     std::vector<uint32_t> path;
                     if (keyMeta.has_key_origin) {
                         // We have a key origin, so pull it from its path vector
                         path = keyMeta.key_origin.path;
                     } else {
                         // No key origin, have to parse the string
                         if (!ParseHDKeypath(keyMeta.hdKeypath, path)) {
                             strErr = "Error reading wallet database: keymeta "
                                      "with invalid HD keypath";
                             return false;
                         }
                     }
 
                     // Extract the index and internal from the path
                     // Path string is m/0'/k'/i'
                     // Path vector is [0', k', i'] (but as ints OR'd with the
                     // hardened bit k == 0 for external, 1 for internal. i is
                     // the index
                     if (path.size() != 3) {
                         strErr = "Error reading wallet database: keymeta found "
                                  "with unexpected path";
                         return false;
                     }
                     if (path[0] != 0x80000000) {
                         strErr = strprintf(
                             "Unexpected path index of 0x%08x (expected "
                             "0x80000000) for the element at index 0",
                             path[0]);
                         return false;
                     }
                     if (path[1] != 0x80000000 && path[1] != (1 | 0x80000000)) {
                         strErr =
                             strprintf("Unexpected path index of 0x%08x "
                                       "(expected 0x80000000 or 0x80000001) for "
                                       "the element at index 1",
                                       path[1]);
                         return false;
                     }
                     if ((path[2] & 0x80000000) == 0) {
                         strErr = strprintf(
                             "Unexpected path index of 0x%08x (expected to be "
                             "greater than or equal to 0x80000000)",
                             path[2]);
                         return false;
                     }
                     internal = path[1] == (1 | 0x80000000);
                     index = path[2] & ~0x80000000;
                 }
 
                 // Insert a new CHDChain, or get the one that already exists
                 auto ins =
                     wss.m_hd_chains.emplace(keyMeta.hd_seed_id, CHDChain());
                 CHDChain &chain = ins.first->second;
                 if (ins.second) {
                     // For new chains, we want to default to VERSION_HD_BASE
                     // until we see an internal
                     chain.nVersion = CHDChain::VERSION_HD_BASE;
                     chain.seed_id = keyMeta.hd_seed_id;
                 }
                 if (internal) {
                     chain.nVersion = CHDChain::VERSION_HD_CHAIN_SPLIT;
                     chain.nInternalChainCounter =
                         std::max(chain.nInternalChainCounter, index);
                 } else {
                     chain.nExternalChainCounter =
                         std::max(chain.nExternalChainCounter, index);
                 }
             }
         } else if (strType == DBKeys::WATCHMETA) {
             CScript script;
             ssKey >> script;
             CKeyMetadata keyMeta;
             ssValue >> keyMeta;
             wss.nKeyMeta++;
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadScriptMetadata(
                 CScriptID(script), keyMeta);
         } 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
             CPubKey vchPubKey;
             ssValue >> vchPubKey;
             if (!vchPubKey.IsValid()) {
                 strErr = "Error reading wallet database: Default Key corrupt";
                 return false;
             }
         } else if (strType == DBKeys::POOL) {
             int64_t nIndex;
             ssKey >> nIndex;
             CKeyPool keypool;
             ssValue >> keypool;
 
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadKeyPool(nIndex,
                                                                      keypool);
         } else if (strType == DBKeys::CSCRIPT) {
             uint160 hash;
             ssKey >> hash;
             CScript script;
             ssValue >> script;
             if (!pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadCScript(
                     script)) {
                 strErr = "Error reading wallet database: "
                          "LegacyScriptPubKeyMan::LoadCScript failed";
                 return false;
             }
         } else if (strType == DBKeys::ORDERPOSNEXT) {
             ssValue >> pwallet->nOrderPosNext;
         } else if (strType == DBKeys::DESTDATA) {
             std::string strAddress, strKey, strValue;
             ssKey >> strAddress;
             ssKey >> strKey;
             ssValue >> strValue;
             pwallet->LoadDestData(
                 DecodeDestination(strAddress, pwallet->GetChainParams()),
                 strKey, strValue);
         } else if (strType == DBKeys::HDCHAIN) {
             CHDChain chain;
             ssValue >> chain;
             pwallet->GetOrCreateLegacyScriptPubKeyMan()->LoadHDChain(chain);
         } else if (strType == DBKeys::FLAGS) {
             uint64_t flags;
             ssValue >> flags;
             if (!pwallet->LoadWalletFlags(flags)) {
                 strErr = "Error reading wallet database: Unknown non-tolerable "
                          "wallet flags found";
                 return false;
             }
         } else if (strType == DBKeys::OLD_KEY) {
             strErr = "Found unsupported 'wkey' record, try loading with "
                      "version 0.20";
             return false;
         } else if (strType == DBKeys::ACTIVEEXTERNALSPK ||
                    strType == DBKeys::ACTIVEINTERNALSPK) {
             uint8_t type;
             ssKey >> type;
             uint256 id;
             ssValue >> id;
 
             bool internal = strType == DBKeys::ACTIVEINTERNALSPK;
             auto &spk_mans = internal ? wss.m_active_internal_spks
                                       : wss.m_active_external_spks;
             if (spk_mans.count(static_cast<OutputType>(type)) > 0) {
                 strErr =
                     "Multiple ScriptPubKeyMans specified for a single type";
                 return false;
             }
             spk_mans[static_cast<OutputType>(type)] = id;
         } else if (strType == DBKeys::WALLETDESCRIPTOR) {
             uint256 id;
             ssKey >> id;
             WalletDescriptor desc;
             ssValue >> desc;
             if (wss.m_descriptor_caches.count(id) == 0) {
                 wss.m_descriptor_caches[id] = DescriptorCache();
             }
             pwallet->LoadDescriptorScriptPubKeyMan(id, desc);
         } else if (strType == DBKeys::WALLETDESCRIPTORCACHE) {
             bool parent = true;
             uint256 desc_id;
             uint32_t key_exp_index;
             uint32_t der_index;
             ssKey >> desc_id;
             ssKey >> key_exp_index;
 
             // if the der_index exists, it's a derived xpub
             try {
                 ssKey >> der_index;
                 parent = false;
             } catch (...) {
             }
 
             std::vector<uint8_t> ser_xpub(BIP32_EXTKEY_SIZE);
             ssValue >> ser_xpub;
             CExtPubKey xpub;
             xpub.Decode(ser_xpub.data());
             if (parent) {
                 wss.m_descriptor_caches[desc_id].CacheParentExtPubKey(
                     key_exp_index, xpub);
             } else {
                 wss.m_descriptor_caches[desc_id].CacheDerivedExtPubKey(
                     key_exp_index, der_index, xpub);
             }
         } else if (strType == DBKeys::WALLETDESCRIPTORKEY) {
             uint256 desc_id;
             CPubKey pubkey;
             ssKey >> desc_id;
             ssKey >> pubkey;
             if (!pubkey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             CKey key;
             CPrivKey pkey;
             uint256 hash;
 
             wss.nKeys++;
             ssValue >> pkey;
             ssValue >> hash;
 
             // hash pubkey/privkey to accelerate wallet load
             std::vector<uint8_t> to_hash;
             to_hash.reserve(pubkey.size() + pkey.size());
             to_hash.insert(to_hash.end(), pubkey.begin(), pubkey.end());
             to_hash.insert(to_hash.end(), pkey.begin(), pkey.end());
 
             if (Hash(to_hash) != hash) {
                 strErr =
                     "Error reading wallet database: CPubKey/CPrivKey corrupt";
                 return false;
             }
 
             if (!key.Load(pkey, pubkey, true)) {
                 strErr = "Error reading wallet database: CPrivKey corrupt";
                 return false;
             }
             wss.m_descriptor_keys.insert(
                 std::make_pair(std::make_pair(desc_id, pubkey.GetID()), key));
         } else if (strType == DBKeys::WALLETDESCRIPTORCKEY) {
             uint256 desc_id;
             CPubKey pubkey;
             ssKey >> desc_id;
             ssKey >> pubkey;
             if (!pubkey.IsValid()) {
                 strErr = "Error reading wallet database: CPubKey corrupt";
                 return false;
             }
             std::vector<uint8_t> privkey;
             ssValue >> privkey;
             wss.nCKeys++;
 
             wss.m_descriptor_crypt_keys.insert(
                 std::make_pair(std::make_pair(desc_id, pubkey.GetID()),
                                std::make_pair(pubkey, privkey)));
             wss.fIsEncrypted = true;
         } else if (strType != DBKeys::BESTBLOCK &&
                    strType != DBKeys::BESTBLOCK_NOMERKLE &&
                    strType != DBKeys::MINVERSION &&
                    strType != DBKeys::ACENTRY && strType != DBKeys::VERSION &&
                    strType != DBKeys::SETTINGS) {
             wss.m_unknown_records++;
         }
     } catch (const std::exception &e) {
         if (strErr.empty()) {
             strErr = e.what();
         }
         return false;
     } catch (...) {
         if (strErr.empty()) {
             strErr = "Caught unknown exception in ReadKeyValue";
         }
         return false;
     }
     return true;
 }
 
 bool ReadKeyValue(CWallet *pwallet, CDataStream &ssKey, CDataStream &ssValue,
                   std::string &strType, std::string &strErr,
                   const KeyFilterFn &filter_fn) {
     CWalletScanState dummy_wss;
     LOCK(pwallet->cs_wallet);
     return ReadKeyValue(pwallet, ssKey, ssValue, dummy_wss, strType, strErr,
                         filter_fn);
 }
 
 bool WalletBatch::IsKeyType(const std::string &strType) {
     return (strType == DBKeys::KEY || strType == DBKeys::MASTER_KEY ||
             strType == DBKeys::CRYPTED_KEY);
 }
 
 DBErrors WalletBatch::LoadWallet(CWallet *pwallet) {
     CWalletScanState wss;
     bool fNoncriticalErrors = false;
     DBErrors result = DBErrors::LOAD_OK;
 
     LOCK(pwallet->cs_wallet);
     try {
         int nMinVersion = 0;
         if (m_batch->Read(DBKeys::MINVERSION, nMinVersion)) {
             if (nMinVersion > FEATURE_LATEST) {
                 return DBErrors::TOO_NEW;
             }
             pwallet->LoadMinVersion(nMinVersion);
         }
 
         // Get cursor
         if (!m_batch->StartCursor()) {
             pwallet->WalletLogPrintf("Error getting wallet database cursor\n");
             return DBErrors::CORRUPT;
         }
 
         while (true) {
             // Read next record
             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
             bool complete;
             bool ret = m_batch->ReadAtCursor(ssKey, ssValue, complete);
             if (complete) {
                 break;
             }
             if (!ret) {
                 m_batch->CloseCursor();
                 pwallet->WalletLogPrintf(
                     "Error reading next record from wallet database\n");
                 return DBErrors::CORRUPT;
             }
 
             // Try to be tolerant of single corrupt records:
             std::string strType, strErr;
             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 == DBKeys::DEFAULTKEY) {
                     result = DBErrors::CORRUPT;
                 } else if (strType == DBKeys::FLAGS) {
                     // Reading the wallet flags can only fail if unknown flags
                     // are present.
                     result = DBErrors::TOO_NEW;
                 } else {
                     // Leave other errors alone, if we try to fix them we might
                     // make things worse. But do warn the user there is
                     // something wrong.
                     fNoncriticalErrors = true;
                     if (strType == DBKeys::TX) {
                         // Rescan if there is a bad transaction record:
                         gArgs.SoftSetBoolArg("-rescan", true);
                     }
                 }
             }
             if (!strErr.empty()) {
                 pwallet->WalletLogPrintf("%s\n", strErr);
             }
         }
     } catch (...) {
         result = DBErrors::CORRUPT;
     }
     m_batch->CloseCursor();
 
     // Set the active ScriptPubKeyMans
     for (auto spk_man_pair : wss.m_active_external_spks) {
         pwallet->LoadActiveScriptPubKeyMan(
             spk_man_pair.second, spk_man_pair.first, /* internal */ false);
     }
     for (auto spk_man_pair : wss.m_active_internal_spks) {
         pwallet->LoadActiveScriptPubKeyMan(
             spk_man_pair.second, spk_man_pair.first, /* internal */ true);
     }
 
     // Set the descriptor caches
     for (auto desc_cache_pair : wss.m_descriptor_caches) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_cache_pair.first);
         assert(spk_man);
         ((DescriptorScriptPubKeyMan *)spk_man)
             ->SetCache(desc_cache_pair.second);
     }
 
     // Set the descriptor keys
     for (auto desc_key_pair : wss.m_descriptor_keys) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_key_pair.first.first);
         ((DescriptorScriptPubKeyMan *)spk_man)
             ->AddKey(desc_key_pair.first.second, desc_key_pair.second);
     }
     for (auto desc_key_pair : wss.m_descriptor_crypt_keys) {
         auto spk_man = pwallet->GetScriptPubKeyMan(desc_key_pair.first.first);
         ((DescriptorScriptPubKeyMan *)spk_man)
             ->AddCryptedKey(desc_key_pair.first.second,
                             desc_key_pair.second.first,
                             desc_key_pair.second.second);
     }
 
     if (fNoncriticalErrors && result == DBErrors::LOAD_OK) {
         result = DBErrors::NONCRITICAL_ERROR;
     }
 
     // Any wallet corruption at all: skip any rewriting or upgrading, we don't
     // want to make it worse.
     if (result != DBErrors::LOAD_OK) {
         return result;
     }
 
     // Last client version to open this wallet, was previously the file version
     // number
     int last_client = CLIENT_VERSION;
     m_batch->Read(DBKeys::VERSION, last_client);
 
     int wallet_version = pwallet->GetVersion();
     pwallet->WalletLogPrintf("Wallet File Version = %d\n",
                              wallet_version > 0 ? wallet_version : last_client);
 
     pwallet->WalletLogPrintf("Keys: %u plaintext, %u encrypted, %u w/ "
                              "metadata, %u total. Unknown wallet records: %u\n",
                              wss.nKeys, wss.nCKeys, wss.nKeyMeta,
                              wss.nKeys + wss.nCKeys, wss.m_unknown_records);
 
     // nTimeFirstKey is only reliable if all keys have metadata
     if (pwallet->IsLegacy() &&
         (wss.nKeys + wss.nCKeys + wss.nWatchKeys) != wss.nKeyMeta) {
         auto spk_man = pwallet->GetOrCreateLegacyScriptPubKeyMan();
         if (spk_man) {
             LOCK(spk_man->cs_KeyStore);
             spk_man->UpdateTimeFirstKey(1);
         }
     }
 
     for (const TxId &txid : wss.vWalletUpgrade) {
         WriteTx(pwallet->mapWallet.at(txid));
     }
 
     // Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
     if (wss.fIsEncrypted && (last_client == 40000 || last_client == 50000)) {
         return DBErrors::NEED_REWRITE;
     }
 
     if (last_client < CLIENT_VERSION) {
         // Update
         m_batch->Write(DBKeys::VERSION, CLIENT_VERSION);
     }
 
     if (wss.fAnyUnordered) {
         result = pwallet->ReorderTransactions();
     }
 
     // Upgrade all of the wallet keymetadata to have the hd master key id
     // This operation is not atomic, but if it fails, updated entries are still
     // backwards compatible with older software
     try {
         pwallet->UpgradeKeyMetadata();
     } catch (...) {
         result = DBErrors::CORRUPT;
     }
 
     // Set the inactive chain
     if (wss.m_hd_chains.size() > 0) {
         LegacyScriptPubKeyMan *legacy_spkm =
             pwallet->GetLegacyScriptPubKeyMan();
         if (!legacy_spkm) {
             pwallet->WalletLogPrintf(
                 "Inactive HD Chains found but no Legacy ScriptPubKeyMan\n");
             return DBErrors::CORRUPT;
         }
         for (const auto &chain_pair : wss.m_hd_chains) {
             if (chain_pair.first !=
                 pwallet->GetLegacyScriptPubKeyMan()->GetHDChain().seed_id) {
                 pwallet->GetLegacyScriptPubKeyMan()->AddInactiveHDChain(
                     chain_pair.second);
             }
         }
     }
 
     return result;
 }
 
 DBErrors WalletBatch::FindWalletTx(std::vector<TxId> &txIds,
                                    std::list<CWalletTx> &vWtx) {
     DBErrors result = DBErrors::LOAD_OK;
 
     try {
         int nMinVersion = 0;
         if (m_batch->Read(DBKeys::MINVERSION, nMinVersion)) {
             if (nMinVersion > FEATURE_LATEST) {
                 return DBErrors::TOO_NEW;
             }
         }
 
         // Get cursor
         if (!m_batch->StartCursor()) {
             LogPrintf("Error getting wallet database cursor\n");
             return DBErrors::CORRUPT;
         }
 
         while (true) {
             // Read next record
             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
             bool complete;
             bool ret = m_batch->ReadAtCursor(ssKey, ssValue, complete);
             if (complete) {
                 break;
             }
 
             if (!ret) {
                 m_batch->CloseCursor();
                 LogPrintf("Error reading next record from wallet database\n");
                 return DBErrors::CORRUPT;
             }
 
             std::string strType;
             ssKey >> strType;
             if (strType == DBKeys::TX) {
                 TxId txid;
                 ssKey >> txid;
                 txIds.push_back(txid);
                 vWtx.emplace_back(nullptr /* tx */);
                 ssValue >> vWtx.back();
             }
         }
     } catch (...) {
         result = DBErrors::CORRUPT;
     }
     m_batch->CloseCursor();
 
     return result;
 }
 
 DBErrors WalletBatch::ZapSelectTx(std::vector<TxId> &txIdsIn,
                                   std::vector<TxId> &txIdsOut) {
     // Build list of wallet TXs and hashes.
     std::vector<TxId> txIds;
     std::list<CWalletTx> vWtx;
     DBErrors err = FindWalletTx(txIds, vWtx);
     if (err != DBErrors::LOAD_OK) {
         return err;
     }
 
     std::sort(txIds.begin(), txIds.end());
     std::sort(txIdsIn.begin(), txIdsIn.end());
 
     // Erase each matching wallet TX.
     bool delerror = false;
     std::vector<TxId>::iterator it = txIdsIn.begin();
     for (const TxId &txid : txIds) {
         while (it < txIdsIn.end() && (*it) < txid) {
             it++;
         }
         if (it == txIdsIn.end()) {
             break;
         }
 
         if ((*it) == txid) {
             if (!EraseTx(txid)) {
                 LogPrint(BCLog::WALLETDB,
                          "Transaction was found for deletion but returned "
                          "database error: %s\n",
                          txid.GetHex());
                 delerror = true;
             }
             txIdsOut.push_back(txid);
         }
     }
 
     if (delerror) {
         return DBErrors::CORRUPT;
     }
     return DBErrors::LOAD_OK;
 }
 
 void MaybeCompactWalletDB() {
     static std::atomic<bool> fOneThread;
     if (fOneThread.exchange(true)) {
         return;
     }
 
     for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
         WalletDatabase &dbh = pwallet->GetDBHandle();
 
         unsigned int nUpdateCounter = dbh.nUpdateCounter;
 
         if (dbh.nLastSeen != nUpdateCounter) {
             dbh.nLastSeen = nUpdateCounter;
             dbh.nLastWalletUpdate = GetTime();
         }
 
         if (dbh.nLastFlushed != nUpdateCounter &&
             GetTime() - dbh.nLastWalletUpdate >= 2) {
             if (dbh.PeriodicFlush()) {
                 dbh.nLastFlushed = nUpdateCounter;
             }
         }
     }
 
     fOneThread = false;
 }
 
 bool WalletBatch::WriteDestData(const CTxDestination &address,
                                 const std::string &key,
                                 const std::string &value) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return WriteIC(
         std::make_pair(
             DBKeys::DESTDATA,
             std::make_pair(EncodeLegacyAddr(address, Params()), key)),
         value);
 }
 
 bool WalletBatch::EraseDestData(const CTxDestination &address,
                                 const std::string &key) {
     if (!IsValidDestination(address)) {
         return false;
     }
     return EraseIC(std::make_pair(
         DBKeys::DESTDATA,
         std::make_pair(EncodeLegacyAddr(address, Params()), key)));
 }
 
 bool WalletBatch::WriteHDChain(const CHDChain &chain) {
     return WriteIC(DBKeys::HDCHAIN, chain);
 }
 
 bool WalletBatch::WriteWalletFlags(const uint64_t flags) {
     return WriteIC(DBKeys::FLAGS, flags);
 }
 
 bool WalletBatch::TxnBegin() {
     return m_batch->TxnBegin();
 }
 
 bool WalletBatch::TxnCommit() {
     return m_batch->TxnCommit();
 }
 
 bool WalletBatch::TxnAbort() {
     return m_batch->TxnAbort();
 }
 
 std::unique_ptr<WalletDatabase> MakeDatabase(const fs::path &path,
                                              const DatabaseOptions &options,
                                              DatabaseStatus &status,
                                              bilingual_str &error) {
     bool exists;
     try {
-        exists = fs::symlink_status(path).type() != fs::file_not_found;
+        exists = fs::symlink_status(path).type() != fs::file_type::not_found;
     } catch (const fs::filesystem_error &e) {
         error = Untranslated(strprintf(
             "Failed to access database path '%s': %s", fs::PathToString(path),
             fsbridge::get_filesystem_error_message(e)));
         status = DatabaseStatus::FAILED_BAD_PATH;
         return nullptr;
     }
 
     std::optional<DatabaseFormat> format;
     if (exists) {
         if (ExistsBerkeleyDatabase(path)) {
             format = DatabaseFormat::BERKELEY;
         }
     } else if (options.require_existing) {
         error = Untranslated(
             strprintf("Failed to load database path '%s'. Path does not exist.",
                       fs::PathToString(path)));
         status = DatabaseStatus::FAILED_NOT_FOUND;
         return nullptr;
     }
 
     if (!format && options.require_existing) {
         error = Untranslated(strprintf("Failed to load database path '%s'. "
                                        "Data is not in recognized format.",
                                        fs::PathToString(path)));
         status = DatabaseStatus::FAILED_BAD_FORMAT;
         return nullptr;
     }
 
     if (format && options.require_create) {
         error = Untranslated(strprintf(
             "Failed to create database path '%s'. Database already exists.",
             fs::PathToString(path)));
         status = DatabaseStatus::FAILED_ALREADY_EXISTS;
         return nullptr;
     }
 
     return MakeBerkeleyDatabase(path, options, status, error);
 }
 
 /**
  * Return object for accessing dummy database with no read/write capabilities.
  */
 std::unique_ptr<WalletDatabase> CreateDummyWalletDatabase() {
     return std::make_unique<DummyDatabase>();
 }
 
 /** Return object for accessing temporary in-memory database. */
 std::unique_ptr<WalletDatabase> CreateMockWalletDatabase() {
     return std::make_unique<BerkeleyDatabase>(
         std::make_shared<BerkeleyEnvironment>(), "");
 }
diff --git a/src/wallet/walletutil.cpp b/src/wallet/walletutil.cpp
index 2c28493d1..9fe9a0875 100644
--- a/src/wallet/walletutil.cpp
+++ b/src/wallet/walletutil.cpp
@@ -1,111 +1,114 @@
 // Copyright (c) 2017 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/walletutil.h>
 
 #include <logging.h>
 #include <util/system.h>
 
+#include <exception>
+#include <fstream>
+
 fs::path GetWalletDir() {
     fs::path path;
 
     if (gArgs.IsArgSet("-walletdir")) {
         path = fs::PathFromString(gArgs.GetArg("-walletdir", ""));
         if (!fs::is_directory(path)) {
             // If the path specified doesn't exist, we return the deliberately
             // invalid empty string.
             path = "";
         }
     } else {
         path = gArgs.GetDataDirNet();
         // If a wallets directory exists, use that, otherwise default to
         // GetDataDir
         if (fs::is_directory(path / "wallets")) {
             path /= "wallets";
         }
     }
 
     return path;
 }
 
 bool IsBerkeleyBtree(const fs::path &path) {
     if (!fs::exists(path)) {
         return false;
     }
 
     // A Berkeley DB Btree file has at least 4K.
     // This check also prevents opening lock files.
-    boost::system::error_code ec;
+    std::error_code ec;
     auto size = fs::file_size(path, ec);
     if (ec) {
         LogPrintf("%s: %s %s\n", __func__, ec.message(),
                   fs::PathToString(path));
     }
     if (size < 4096) {
         return false;
     }
 
-    fsbridge::ifstream file(path, std::ios::binary);
+    std::ifstream file{path, std::ios::binary};
     if (!file.is_open()) {
         return false;
     }
 
     // Magic bytes start at offset 12
     file.seekg(12, std::ios::beg);
     uint32_t data = 0;
     // Read 4 bytes of file to compare against magic
     file.read((char *)&data, sizeof(data));
 
     // Berkeley DB Btree magic bytes, from:
     //  https://github.com/file/file/blob/5824af38469ec1ca9ac3ffd251e7afe9dc11e227/magic/Magdir/database#L74-L75
     //  - big endian systems - 00 05 31 62
     //  - little endian systems - 62 31 05 00
     return data == 0x00053162 || data == 0x62310500;
 }
 
 std::vector<fs::path> ListWalletDir() {
     const fs::path wallet_dir = GetWalletDir();
     const size_t offset = fs::PathToString(wallet_dir).size() + 1;
     std::vector<fs::path> paths;
-    boost::system::error_code ec;
+    std::error_code ec;
 
     for (auto it = fs::recursive_directory_iterator(wallet_dir, ec);
          it != fs::recursive_directory_iterator(); it.increment(ec)) {
         if (ec) {
             LogPrintf("%s: %s %s\n", __func__, ec.message(),
                       fs::PathToString(it->path()));
             continue;
         }
 
         // Get wallet path relative to walletdir by removing walletdir from the
         // wallet path. This can be replaced by
         // boost::filesystem::lexically_relative once boost is bumped to 1.60.
         const auto path_str = it->path().native().substr(offset);
         const fs::path path{path_str.begin(), path_str.end()};
 
-        if (it->status().type() == fs::directory_file &&
+        if (it->status().type() == fs::file_type::directory &&
             IsBerkeleyBtree(it->path() / "wallet.dat")) {
             // Found a directory which contains wallet.dat btree file, add it as
             // a wallet.
             paths.emplace_back(path);
-        } else if (it.level() == 0 &&
-                   it->symlink_status().type() == fs::regular_file &&
+        } else if (it.depth() == 0 &&
+                   it->symlink_status().type() == fs::file_type::regular &&
                    IsBerkeleyBtree(it->path())) {
             if (it->path().filename() == "wallet.dat") {
                 // Found top-level wallet.dat btree file, add top level
                 // directory "" as a wallet.
                 paths.emplace_back();
             } else {
                 // Found top-level btree file not called wallet.dat. Current
                 // bitcoin software will never create these files but will allow
                 // them to be opened in a shared database environment for
                 // backwards compatibility. Add it to the list of available
                 // wallets.
                 paths.emplace_back(path);
             }
         }
     }
 
     return paths;
 }
diff --git a/test/functional/wallet_multiwallet.py b/test/functional/wallet_multiwallet.py
index 780de78f9..515affa5e 100755
--- a/test/functional/wallet_multiwallet.py
+++ b/test/functional/wallet_multiwallet.py
@@ -1,483 +1,487 @@
 #!/usr/bin/env python3
 # Copyright (c) 2017-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test multiwallet.
 
 Verify that a bitcoind node can load multiple wallet files
 """
 import os
 import shutil
+import sys
 import time
 from decimal import Decimal
 from threading import Thread
 
 from test_framework.authproxy import JSONRPCException
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.test_node import ErrorMatch
 from test_framework.util import assert_equal, assert_raises_rpc_error, get_rpc_proxy
 
 got_loading_error = False
 
 
 def test_load_unload(node, name, timeout=60.):
     global got_loading_error
     t0 = time.time()
     while time.time() - t0 < timeout and not got_loading_error:
         try:
             node.loadwallet(name)
             node.unloadwallet(name)
         except JSONRPCException as e:
             if e.error['code'] == - \
                     4 and 'Wallet already being loading' in e.error['message']:
                 got_loading_error = True
                 return
         # Add a small sleep to avoid CPU exhaustion in the unlikely case
         # the race never happens.
         time.sleep(0.001)
 
 
 class MultiWalletTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.rpc_timeout = 120
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     def add_options(self, parser):
         parser.add_argument(
             '--data_wallets_dir',
             default=os.path.join(
                 os.path.dirname(
                     os.path.realpath(__file__)),
                 'data/wallets/'),
             help='Test data with wallet directories (default: %(default)s)',
         )
 
     def run_test(self):
         node = self.nodes[0]
 
         def data_dir(*p): return os.path.join(node.datadir, self.chain, *p)
 
         def wallet_dir(*p): return data_dir('wallets', *p)
 
         def wallet(name): return node.get_wallet_rpc(name)
 
         def wallet_file(name):
             if os.path.isdir(wallet_dir(name)):
                 return wallet_dir(name, self.wallet_data_filename)
             return wallet_dir(name)
 
         assert_equal(self.nodes[0].listwalletdir(),
                      {'wallets': [{'name': self.default_wallet_name}]})
 
         # check wallet.dat is created
         self.stop_nodes()
         assert_equal(os.path.isfile(wallet_dir(self.default_wallet_name,
                                                self.wallet_data_filename)),
                      True)
 
         # create symlink to verify wallet directory path can be referenced
         # through symlink
         if os.name != 'nt':
             os.mkdir(wallet_dir('w7'))
             os.symlink('w7', wallet_dir('w7_symlink'))
 
         # rename wallet.dat to make sure plain wallet file paths (as opposed to
         # directory paths) can be loaded
         os.rename(wallet_dir(self.default_wallet_name, self.wallet_data_filename),
                   wallet_dir("w8"))
 
         # create another dummy wallet for use in testing backups later
         self.start_node(
             0, ["-nowallet", f"-wallet={self.default_wallet_name}"])
         self.stop_nodes()
         empty_wallet = os.path.join(self.options.tmpdir, 'empty.dat')
         os.rename(wallet_dir(self.default_wallet_name, self.wallet_data_filename),
                   empty_wallet)
 
         # restart node with a mix of wallet names:
         #   w1, w2, w3 - to verify new wallets created when non-existing paths specified
         #   w          - to verify wallet name matching works when one wallet path is prefix of another
         #   sub/w5     - to verify relative wallet path is created correctly
         #   extern/w6  - to verify absolute wallet path is created correctly
         #   w7_symlink - to verify symlinked wallet path is initialized correctly
         #   w8         - to verify existing wallet file is loaded correctly
         #   ''         - to verify default wallet file is created correctly
         wallet_names = ['w1', 'w2', 'w3', 'w', 'sub/w5',
                         os.path.join(self.options.tmpdir, 'extern/w6'),
                         'w7_symlink', 'w8', self.default_wallet_name]
         if os.name == 'nt':
             wallet_names.remove('w7_symlink')
         extra_args = ['-nowallet'] + \
             [f'-wallet={n}' for n in wallet_names]
         self.start_node(0, extra_args)
         assert_equal(
             sorted(w['name'] for w in self.nodes[0].listwalletdir()['wallets']),
             [self.default_wallet_name, os.path.join('sub', 'w5'), 'w', 'w1',
              'w2', 'w3', 'w7', 'w7_symlink', 'w8'])
 
         assert_equal(set(node.listwallets()), set(wallet_names))
 
         # check that all requested wallets were created
         self.stop_node(0)
         for wallet_name in wallet_names:
             assert_equal(os.path.isfile(wallet_file(wallet_name)), True)
 
         # should not initialize if wallet path can't be created
-        exp_stderr = "boost::filesystem::create_director"
+        exp_stderr = (
+            "filesystem error:" if sys.platform != 'win32'
+            else "create_directories:"
+        )
         self.nodes[0].assert_start_raises_init_error(
             ['-wallet=w8/bad'], exp_stderr, match=ErrorMatch.PARTIAL_REGEX)
 
         self.nodes[0].assert_start_raises_init_error(
             ['-walletdir=wallets'], 'Error: Specified -walletdir "wallets" does not exist')
         self.nodes[0].assert_start_raises_init_error(
             ['-walletdir=wallets'], 'Error: Specified -walletdir "wallets" is a relative path', cwd=data_dir())
         self.nodes[0].assert_start_raises_init_error(
             ['-walletdir=debug.log'], 'Error: Specified -walletdir "debug.log" is not a directory', cwd=data_dir())
 
         self.start_node(0, ['-wallet=w1', '-wallet=w1'])
         self.stop_node(0, 'Warning: Ignoring duplicate -wallet w1.')
 
         # should not initialize if one wallet is a copy of another
         shutil.copyfile(wallet_dir('w8'), wallet_dir('w8_copy'))
         exp_stderr = r"BerkeleyDatabase: Can't open database w8_copy \(duplicates fileid \w+ from w8\)"
         self.nodes[0].assert_start_raises_init_error(
             ['-wallet=w8', '-wallet=w8_copy'], exp_stderr, match=ErrorMatch.PARTIAL_REGEX)
 
         # should not initialize if wallet file is a symlink
         if os.name != 'nt':
             os.symlink('w8', wallet_dir('w8_symlink'))
             self.nodes[0].assert_start_raises_init_error(
                 ['-wallet=w8_symlink'], r'Error: Invalid -wallet path \'w8_symlink\'\. .*', match=ErrorMatch.FULL_REGEX)
 
         # should not initialize if the specified walletdir does not exist
         self.nodes[0].assert_start_raises_init_error(
             ['-walletdir=bad'], 'Error: Specified -walletdir "bad" does not exist')
         # should not initialize if the specified walletdir is not a directory
         not_a_dir = wallet_dir('notadir')
         open(not_a_dir, 'a', encoding="utf8").close()
         self.nodes[0].assert_start_raises_init_error(
             [f"-walletdir={not_a_dir}"], f"Error: Specified -walletdir \"{not_a_dir}\" is not a directory")
 
         # if wallets/ doesn't exist, datadir should be the default wallet dir
         wallet_dir2 = data_dir('walletdir')
         os.rename(wallet_dir(), wallet_dir2)
         self.start_node(0, ['-nowallet', '-wallet=w4', '-wallet=w5'])
         assert_equal(set(node.listwallets()), {"w4", "w5"})
         w5 = wallet("w5")
         self.generatetoaddress(
             node,
             nblocks=1,
             address=w5.getnewaddress(),
             sync_fun=self.no_op)
 
         # now if wallets/ exists again, but the rootdir is specified as the
         # walletdir, w4 and w5 should still be loaded
         os.rename(wallet_dir2, wallet_dir())
         self.restart_node(0, ['-nowallet', '-wallet=w4', '-wallet=w5',
                               f"-walletdir={data_dir()}"])
         assert_equal(set(node.listwallets()), {"w4", "w5"})
         w5 = wallet("w5")
         w5_info = w5.getwalletinfo()
         assert_equal(w5_info['immature_balance'], 50000000)
 
         competing_wallet_dir = os.path.join(
             self.options.tmpdir, 'competing_walletdir')
         os.mkdir(competing_wallet_dir)
         self.restart_node(0, [f"-walletdir={competing_wallet_dir}"])
         exp_stderr = r"Error: Error initializing wallet database environment \"\S+competing_walletdir\"!"
         self.nodes[1].assert_start_raises_init_error(
             [f"-walletdir={competing_wallet_dir}"], exp_stderr, match=ErrorMatch.PARTIAL_REGEX)
 
         self.restart_node(0, extra_args)
 
         assert_equal(
             sorted(w['name'] for w in self.nodes[0].listwalletdir()['wallets']),
             [self.default_wallet_name, os.path.join('sub', 'w5'), 'w', 'w1', 'w2',
              'w3', 'w7', 'w7_symlink', 'w8', 'w8_copy'])
 
         wallets = [wallet(w) for w in wallet_names]
         wallet_bad = wallet("bad")
 
         # check wallet names and balances
         self.generatetoaddress(
             node, nblocks=1, address=wallets[0].getnewaddress(), sync_fun=self.no_op)
         for wallet_name, wallet in zip(wallet_names, wallets):
             info = wallet.getwalletinfo()
             assert_equal(info['immature_balance'],
                          50000000 if wallet is wallets[0] else 0)
             assert_equal(info['walletname'], wallet_name)
 
         # accessing invalid wallet fails
         assert_raises_rpc_error(-18, "Requested wallet does not exist or is not loaded",
                                 wallet_bad.getwalletinfo)
 
         # accessing wallet RPC without using wallet endpoint fails
         assert_raises_rpc_error(-19, "Wallet file not specified (must request wallet RPC through /wallet/<filename> uri-path).",
                                 node.getwalletinfo)
 
         w1, w2, w3, w4, *_ = wallets
         self.generatetoaddress(
             node,
             nblocks=101,
             address=w1.getnewaddress(),
             sync_fun=self.no_op)
         assert_equal(w1.getbalance(), 100000000)
         assert_equal(w2.getbalance(), 0)
         assert_equal(w3.getbalance(), 0)
         assert_equal(w4.getbalance(), 0)
 
         w1.sendtoaddress(w2.getnewaddress(), 1000000)
         w1.sendtoaddress(w3.getnewaddress(), 2000000)
         w1.sendtoaddress(w4.getnewaddress(), 3000000)
         self.generatetoaddress(
             node,
             nblocks=1,
             address=w1.getnewaddress(),
             sync_fun=self.no_op)
         assert_equal(w2.getbalance(), 1000000)
         assert_equal(w3.getbalance(), 2000000)
         assert_equal(w4.getbalance(), 3000000)
 
         batch = w1.batch([w1.getblockchaininfo.get_request(),
                           w1.getwalletinfo.get_request()])
         assert_equal(batch[0]["result"]["chain"], self.chain)
         assert_equal(batch[1]["result"]["walletname"], "w1")
 
         self.log.info('Check for per-wallet settxfee call')
         assert_equal(w1.getwalletinfo()['paytxfee'], 0)
         assert_equal(w2.getwalletinfo()['paytxfee'], 0)
         w2.settxfee(1000)
         assert_equal(w1.getwalletinfo()['paytxfee'], 0)
         assert_equal(w2.getwalletinfo()['paytxfee'], Decimal('1000.00'))
 
         self.log.info("Test dynamic wallet loading")
 
         self.restart_node(0, ['-nowallet'])
         assert_equal(node.listwallets(), [])
         assert_raises_rpc_error(
             -18,
             "No wallet is loaded. Load a wallet using loadwallet or create a new"
             " one with createwallet. (Note: A default wallet is no longer "
             "automatically created)",
             node.getwalletinfo
         )
 
         self.log.info("Load first wallet")
         loadwallet_name = node.loadwallet(wallet_names[0])
         assert_equal(loadwallet_name['name'], wallet_names[0])
         assert_equal(node.listwallets(), wallet_names[0:1])
         node.getwalletinfo()
         w1 = node.get_wallet_rpc(wallet_names[0])
         w1.getwalletinfo()
 
         self.log.info("Load second wallet")
         loadwallet_name = node.loadwallet(wallet_names[1])
         assert_equal(loadwallet_name['name'], wallet_names[1])
         assert_equal(node.listwallets(), wallet_names[0:2])
         assert_raises_rpc_error(-19,
                                 "Wallet file not specified", node.getwalletinfo)
         w2 = node.get_wallet_rpc(wallet_names[1])
         w2.getwalletinfo()
 
         self.log.info("Concurrent wallet loading")
         threads = []
         for _ in range(3):
             n = node.cli if self.options.usecli else get_rpc_proxy(
                 node.url, 1, timeout=600, coveragedir=node.coverage_dir)
             t = Thread(
                 target=test_load_unload,
                 args=(
                     n,
                     wallet_names[2],
                     20 * self.rpc_timeout))
             t.start()
             threads.append(t)
         for t in threads:
             t.join()
         global got_loading_error
         assert_equal(got_loading_error, True)
 
         self.log.info("Load remaining wallets")
         for wallet_name in wallet_names[2:]:
             loadwallet_name = self.nodes[0].loadwallet(wallet_name)
             assert_equal(loadwallet_name['name'], wallet_name)
 
         assert_equal(set(self.nodes[0].listwallets()), set(wallet_names))
 
         # Fail to load if wallet doesn't exist
         path = os.path.join(self.options.tmpdir, "node0", "regtest",
                             "wallets", "wallets")
         assert_raises_rpc_error(
             -18,
             f"Wallet file verification failed. Failed to load database path '{path}'. "
             "Path does not exist.",
             self.nodes[0].loadwallet, 'wallets')
 
         # Fail to load duplicate wallets
         path = os.path.join(
             self.options.tmpdir,
             "node0",
             "regtest",
             "wallets",
             "w1",
             self.wallet_data_filename)
         assert_raises_rpc_error(
             -4,
             "Wallet file verification failed. Refusing to load database. "
             f"Data file '{path}' is already loaded.",
             self.nodes[0].loadwallet,
             wallet_names[0])
 
         # Fail to load duplicate wallets by different ways (directory and
         # filepath)
         path = os.path.join(
             self.options.tmpdir,
             "node0",
             "regtest",
             "wallets",
             self.wallet_data_filename)
         assert_raises_rpc_error(
             -4,
             "Wallet file verification failed. Refusing to load database. "
             f"Data file '{path}' is already loaded.",
             self.nodes[0].loadwallet,
             self.wallet_data_filename)
 
         # Fail to load if one wallet is a copy of another
         assert_raises_rpc_error(-4, "BerkeleyDatabase: Can't open database w8_copy (duplicates fileid",
                                 self.nodes[0].loadwallet, 'w8_copy')
 
         # Fail to load if one wallet is a copy of another.
         # Test this twice to make sure that we don't re-introduce
         # https://github.com/bitcoin/bitcoin/issues/14304
         assert_raises_rpc_error(-4, "BerkeleyDatabase: Can't open database w8_copy (duplicates fileid",
                                 self.nodes[0].loadwallet, 'w8_copy')
 
         # Fail to load if wallet file is a symlink
         if os.name != 'nt':
             assert_raises_rpc_error(
                 -4,
                 "Wallet file verification failed. Invalid -wallet path 'w8_symlink'",
                 self.nodes[0].loadwallet,
                 'w8_symlink')
 
         # Fail to load if a directory is specified that doesn't contain a
         # wallet
         os.mkdir(wallet_dir('empty_wallet_dir'))
         path = os.path.join(self.options.tmpdir, "node0", "regtest",
                             "wallets", "empty_wallet_dir")
         assert_raises_rpc_error(
             -18,
             f"Wallet file verification failed. Failed to load database path '{path}'. "
             "Data is not in recognized format.",
             self.nodes[0].loadwallet, 'empty_wallet_dir')
 
         self.log.info("Test dynamic wallet creation.")
 
         # Fail to create a wallet if it already exists.
         path = os.path.join(self.options.tmpdir, "node0", "regtest",
                             "wallets", "w2")
         assert_raises_rpc_error(
             -4,
             f"Failed to create database path '{path}'. Database already exists.",
             self.nodes[0].createwallet, 'w2')
 
         # Successfully create a wallet with a new name
         loadwallet_name = self.nodes[0].createwallet('w9')
         assert_equal(loadwallet_name['name'], 'w9')
         w9 = node.get_wallet_rpc('w9')
         assert_equal(w9.getwalletinfo()['walletname'], 'w9')
 
         assert 'w9' in self.nodes[0].listwallets()
 
         # Successfully create a wallet using a full path
         new_wallet_dir = os.path.join(self.options.tmpdir, 'new_walletdir')
         new_wallet_name = os.path.join(new_wallet_dir, 'w10')
         loadwallet_name = self.nodes[0].createwallet(new_wallet_name)
         assert_equal(loadwallet_name['name'], new_wallet_name)
         w10 = node.get_wallet_rpc(new_wallet_name)
         assert_equal(w10.getwalletinfo()['walletname'], new_wallet_name)
 
         assert new_wallet_name in self.nodes[0].listwallets()
 
         self.log.info("Test dynamic wallet unloading")
 
         # Test `unloadwallet` errors
         assert_raises_rpc_error(-1, "JSON value is not a string as expected",
                                 self.nodes[0].unloadwallet)
         assert_raises_rpc_error(-18, "Requested wallet does not exist or is not loaded",
                                 self.nodes[0].unloadwallet, "dummy")
         assert_raises_rpc_error(-18, "Requested wallet does not exist or is not loaded",
                                 node.get_wallet_rpc("dummy").unloadwallet)
         assert_raises_rpc_error(-8, "Cannot unload the requested wallet",
                                 w1.unloadwallet, "w2"),
 
         # Successfully unload the specified wallet name
         self.nodes[0].unloadwallet("w1")
         assert 'w1' not in self.nodes[0].listwallets()
 
         # Successfully unload the wallet referenced by the request endpoint
         # Also ensure unload works during walletpassphrase timeout
         w2.encryptwallet('test')
         w2.walletpassphrase('test', 1)
         w2.unloadwallet()
         time.sleep(1.1)
         assert 'w2' not in self.nodes[0].listwallets()
 
         # Successfully unload all wallets
         for wallet_name in self.nodes[0].listwallets():
             self.nodes[0].unloadwallet(wallet_name)
         assert_equal(self.nodes[0].listwallets(), [])
         assert_raises_rpc_error(
             -18,
             "No wallet is loaded. Load a wallet using loadwallet or create a new"
             " one with createwallet. (Note: A default wallet is no longer "
             "automatically created)",
             self.nodes[0].getwalletinfo
         )
 
         # Successfully load a previously unloaded wallet
         self.nodes[0].loadwallet('w1')
         assert_equal(self.nodes[0].listwallets(), ['w1'])
         assert_equal(w1.getwalletinfo()['walletname'], 'w1')
 
         assert_equal(
             sorted(w['name'] for w in self.nodes[0].listwalletdir()['wallets']),
             [self.default_wallet_name, os.path.join('sub', 'w5'), 'w', 'w1', 'w2',
              'w3', 'w7', 'w7_symlink', 'w8', 'w8_copy', 'w9'])
 
         # Test backing up and restoring wallets
         self.log.info("Test wallet backup")
         self.restart_node(0, ['-nowallet'])
         for wallet_name in wallet_names:
             self.nodes[0].loadwallet(wallet_name)
         for wallet_name in wallet_names:
             rpc = self.nodes[0].get_wallet_rpc(wallet_name)
             addr = rpc.getnewaddress()
             backup = os.path.join(self.options.tmpdir, 'backup.dat')
             rpc.backupwallet(backup)
             self.nodes[0].unloadwallet(wallet_name)
             shutil.copyfile(empty_wallet, wallet_file(wallet_name))
             self.nodes[0].loadwallet(wallet_name)
             assert_equal(rpc.getaddressinfo(addr)['ismine'], False)
             self.nodes[0].unloadwallet(wallet_name)
             shutil.copyfile(backup, wallet_file(wallet_name))
             self.nodes[0].loadwallet(wallet_name)
             assert_equal(rpc.getaddressinfo(addr)['ismine'], True)
 
         # Test .walletlock file is closed
         self.start_node(1)
         wallet = os.path.join(self.options.tmpdir, 'my_wallet')
         self.nodes[0].createwallet(wallet)
         assert_raises_rpc_error(-4, "Error initializing wallet database environment",
                                 self.nodes[1].loadwallet, wallet)
         self.nodes[0].unloadwallet(wallet)
         self.nodes[1].loadwallet(wallet)
 
 
 if __name__ == '__main__':
     MultiWalletTest().main()
diff --git a/test/lint/lint-boost-dependencies.sh b/test/lint/lint-boost-dependencies.sh
index f316832ef..2018e0b0a 100755
--- a/test/lint/lint-boost-dependencies.sh
+++ b/test/lint/lint-boost-dependencies.sh
@@ -1,63 +1,61 @@
 #!/usr/bin/env bash
 #
 # Copyright (c) 2018 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 # Guard against accidental introduction of new Boost dependencies.
 
 export LC_ALL=C
 
 EXPECTED_BOOST_INCLUDES=(
     boost/algorithm/string.hpp
     boost/algorithm/string/classification.hpp
     boost/algorithm/string/replace.hpp
     boost/algorithm/string/split.hpp
     boost/date_time/posix_time/posix_time.hpp
-    boost/filesystem.hpp
-    boost/filesystem/fstream.hpp
     boost/mpl/list.hpp
     boost/multiprecision/cpp_int.hpp
     boost/multi_index/composite_key.hpp
     boost/multi_index/hashed_index.hpp
     boost/multi_index/member.hpp
     boost/multi_index/mem_fun.hpp
     boost/multi_index/ordered_index.hpp
     boost/multi_index/sequenced_index.hpp
     boost/multi_index_container.hpp
     boost/range/iterator.hpp
     boost/range/adaptor/sliced.hpp
     boost/signals2/connection.hpp
     boost/signals2/optional_last_value.hpp
     boost/signals2/signal.hpp
     boost/test/unit_test.hpp
     boost/thread/lock_types.hpp
     boost/thread/shared_mutex.hpp
     boost/variant.hpp
     boost/variant/apply_visitor.hpp
     boost/variant/static_visitor.hpp
 )
 
 for BOOST_INCLUDE in $(git grep '^#include <boost/' -- "*.cpp" "*.h" | cut -f2 -d: | cut -f2 -d'<' | cut -f1 -d'>' | sort -u); do
     IS_EXPECTED_INCLUDE=0
     for EXPECTED_BOOST_INCLUDE in "${EXPECTED_BOOST_INCLUDES[@]}"; do
         if [[ "${BOOST_INCLUDE}" == "${EXPECTED_BOOST_INCLUDE}" ]]; then
             IS_EXPECTED_INCLUDE=1
             break
         fi
     done
     if [[ ${IS_EXPECTED_INCLUDE} == 0 ]]; then
         echo "A new Boost dependency in the form of \"${BOOST_INCLUDE}\" appears to have been introduced:"
         git grep "${BOOST_INCLUDE}" -- "*.cpp" "*.h"
         echo
     fi
 done
 
 for EXPECTED_BOOST_INCLUDE in "${EXPECTED_BOOST_INCLUDES[@]}"; do
     if ! git grep -q "^#include <${EXPECTED_BOOST_INCLUDE}>" -- "*.cpp" "*.h"; then
         echo "Good job! The Boost dependency \"${EXPECTED_BOOST_INCLUDE}\" is no longer used."
         echo "Please remove it from EXPECTED_BOOST_INCLUDES in $0"
         echo "to make sure this dependency is not accidentally reintroduced."
         echo
     fi
 done