diff --git a/share/qt/extract_strings_qt.py b/share/qt/extract_strings_qt.py
index 72cc8d175..dd6bad057 100755
--- a/share/qt/extract_strings_qt.py
+++ b/share/qt/extract_strings_qt.py
@@ -1,93 +1,89 @@
 #!/usr/bin/env python3
 # Copyright (c) 2012-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.
 '''
 Extract _("...") strings for translation and convert to Qt stringdefs so that
 they can be picked up by Qt linguist.
 '''
 from subprocess import Popen, PIPE
 import operator
 import os
 import sys
 
 OUT_CPP = "qt/bitcoinstrings.cpp"
 EMPTY = ['""']
 
 
 def parse_po(text):
     """
     Parse 'po' format produced by xgettext.
     Return a list of (msgid,msgstr) tuples.
     """
     messages = []
     msgid = []
     msgstr = []
     in_msgid = False
     in_msgstr = False
 
     for line in text.split('\n'):
         line = line.rstrip('\r')
         if line.startswith('msgid '):
             if in_msgstr:
                 messages.append((msgid, msgstr))
                 in_msgstr = False
             # message start
             in_msgid = True
 
             msgid = [line[6:]]
         elif line.startswith('msgstr '):
             in_msgid = False
             in_msgstr = True
             msgstr = [line[7:]]
         elif line.startswith('"'):
             if in_msgid:
                 msgid.append(line)
             if in_msgstr:
                 msgstr.append(line)
 
     if in_msgstr:
         messages.append((msgid, msgstr))
 
     return messages
 
 
 files = sys.argv[1:]
 
 # xgettext -n --keyword=_ $FILES
 XGETTEXT = os.getenv('XGETTEXT', 'xgettext')
 if not XGETTEXT:
     print(
         'Cannot extract strings: xgettext utility is not installed or not configured.',
         file=sys.stderr)
     print('Please install package "gettext" and re-run \'./configure\'.',
           file=sys.stderr)
     sys.exit(1)
 child = Popen([XGETTEXT, '--output=-', '-n',
                '--keyword=_'] + files, stdout=PIPE)
 (out, err) = child.communicate()
 
 messages = parse_po(out.decode('utf-8'))
 
 f = open(OUT_CPP, 'w', encoding="utf8")
 f.write('#include <QtGlobal>\n')
 f.write('// Automatically @{} by extract_strings_qt.py\n'.format('generated'))
 f.write("""
 #ifdef __GNUC__
 #define UNUSED __attribute__((unused))
 #else
 #define UNUSED
 #endif
 """)
 f.write('static const char UNUSED *bitcoin_strings[] = {\n')
-f.write('QT_TRANSLATE_NOOP("bitcoin-abc", "{}"),\n'.format(os.getenv('PACKAGE_NAME'),))
 f.write('QT_TRANSLATE_NOOP("bitcoin-abc", "{}"),\n'.format(os.getenv('COPYRIGHT_HOLDERS'),))
-if os.getenv('COPYRIGHT_HOLDERS_SUBSTITUTION') != os.getenv('PACKAGE_NAME'):
-    f.write('QT_TRANSLATE_NOOP("bitcoin-abc", "{}"),\n'.format(
-        os.getenv('COPYRIGHT_HOLDERS_SUBSTITUTION'),))
 messages.sort(key=operator.itemgetter(0))
 for (msgid, msgstr) in messages:
     if msgid != EMPTY:
         f.write('QT_TRANSLATE_NOOP("bitcoin-abc", {}),\n'.format('\n'.join(msgid)))
 f.write('};\n')
 f.close()
diff --git a/src/Makefile.qt.include b/src/Makefile.qt.include
index 418973604..9cd49af41 100644
--- a/src/Makefile.qt.include
+++ b/src/Makefile.qt.include
@@ -1,483 +1,483 @@
 # Copyright (c) 2013-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.
 
 bin_PROGRAMS += qt/bitcoin-qt
 EXTRA_LIBRARIES += qt/libbitcoinqt.a
 
 # bitcoin qt core #
 QT_TS = \
   qt/locale/bitcoin_af.ts \
   qt/locale/bitcoin_af_ZA.ts \
   qt/locale/bitcoin_ar.ts \
   qt/locale/bitcoin_be_BY.ts \
   qt/locale/bitcoin_bg_BG.ts \
   qt/locale/bitcoin_bg.ts \
   qt/locale/bitcoin_ca_ES.ts \
   qt/locale/bitcoin_ca.ts \
   qt/locale/bitcoin_ca@valencia.ts \
   qt/locale/bitcoin_cs.ts \
   qt/locale/bitcoin_cy.ts \
   qt/locale/bitcoin_da.ts \
   qt/locale/bitcoin_de.ts \
   qt/locale/bitcoin_el_GR.ts \
   qt/locale/bitcoin_el.ts \
   qt/locale/bitcoin_en_GB.ts \
   qt/locale/bitcoin_en.ts \
   qt/locale/bitcoin_eo.ts \
   qt/locale/bitcoin_es_AR.ts \
   qt/locale/bitcoin_es_CL.ts \
   qt/locale/bitcoin_es_CO.ts \
   qt/locale/bitcoin_es_DO.ts \
   qt/locale/bitcoin_es_ES.ts \
   qt/locale/bitcoin_es_MX.ts \
   qt/locale/bitcoin_es.ts \
   qt/locale/bitcoin_es_UY.ts \
   qt/locale/bitcoin_es_VE.ts \
   qt/locale/bitcoin_et_EE.ts \
   qt/locale/bitcoin_et.ts \
   qt/locale/bitcoin_eu_ES.ts \
   qt/locale/bitcoin_fa_IR.ts \
   qt/locale/bitcoin_fa.ts \
   qt/locale/bitcoin_fi.ts \
   qt/locale/bitcoin_fr_CA.ts \
   qt/locale/bitcoin_fr_FR.ts \
   qt/locale/bitcoin_fr.ts \
   qt/locale/bitcoin_gl.ts \
   qt/locale/bitcoin_he.ts \
   qt/locale/bitcoin_hi_IN.ts \
   qt/locale/bitcoin_hr.ts \
   qt/locale/bitcoin_hu.ts \
   qt/locale/bitcoin_id_ID.ts \
   qt/locale/bitcoin_it_IT.ts \
   qt/locale/bitcoin_it.ts \
   qt/locale/bitcoin_ja.ts \
   qt/locale/bitcoin_ka.ts \
   qt/locale/bitcoin_kk_KZ.ts \
   qt/locale/bitcoin_ko_KR.ts \
   qt/locale/bitcoin_ku_IQ.ts \
   qt/locale/bitcoin_ky.ts \
   qt/locale/bitcoin_la.ts \
   qt/locale/bitcoin_lt.ts \
   qt/locale/bitcoin_lv_LV.ts \
   qt/locale/bitcoin_mk_MK.ts \
   qt/locale/bitcoin_mn.ts \
   qt/locale/bitcoin_ms_MY.ts \
   qt/locale/bitcoin_nb.ts \
   qt/locale/bitcoin_ne.ts \
   qt/locale/bitcoin_nl.ts \
   qt/locale/bitcoin_pam.ts \
   qt/locale/bitcoin_pl.ts \
   qt/locale/bitcoin_pt_BR.ts \
   qt/locale/bitcoin_pt_PT.ts \
   qt/locale/bitcoin_ro_RO.ts \
   qt/locale/bitcoin_ro.ts \
   qt/locale/bitcoin_ru_RU.ts \
   qt/locale/bitcoin_ru.ts \
   qt/locale/bitcoin_sk.ts \
   qt/locale/bitcoin_sl_SI.ts \
   qt/locale/bitcoin_sq.ts \
   qt/locale/bitcoin_sr@latin.ts \
   qt/locale/bitcoin_sr.ts \
   qt/locale/bitcoin_sv.ts \
   qt/locale/bitcoin_ta.ts \
   qt/locale/bitcoin_th_TH.ts \
   qt/locale/bitcoin_tr_TR.ts \
   qt/locale/bitcoin_tr.ts \
   qt/locale/bitcoin_uk.ts \
   qt/locale/bitcoin_ur_PK.ts \
   qt/locale/bitcoin_uz@Cyrl.ts \
   qt/locale/bitcoin_vi.ts \
   qt/locale/bitcoin_vi_VN.ts \
   qt/locale/bitcoin_zh_CN.ts \
   qt/locale/bitcoin_zh_HK.ts \
   qt/locale/bitcoin_zh.ts \
   qt/locale/bitcoin_zh_TW.ts
 
 QT_FORMS_UI = \
   qt/forms/addressbookpage.ui \
   qt/forms/askpassphrasedialog.ui \
   qt/forms/coincontroldialog.ui \
   qt/forms/editaddressdialog.ui \
   qt/forms/helpmessagedialog.ui \
   qt/forms/intro.ui \
   qt/forms/modaloverlay.ui \
   qt/forms/openuridialog.ui \
   qt/forms/optionsdialog.ui \
   qt/forms/overviewpage.ui \
   qt/forms/receivecoinsdialog.ui \
   qt/forms/receiverequestdialog.ui \
   qt/forms/debugwindow.ui \
   qt/forms/sendcoinsdialog.ui \
   qt/forms/sendcoinsentry.ui \
   qt/forms/signverifymessagedialog.ui \
   qt/forms/transactiondescdialog.ui
 
 QT_MOC_CPP = \
   qt/moc_addressbookpage.cpp \
   qt/moc_addresstablemodel.cpp \
   qt/moc_askpassphrasedialog.cpp \
   qt/moc_bantablemodel.cpp \
   qt/moc_bitcoinaddressvalidator.cpp \
   qt/moc_bitcoinamountfield.cpp \
   qt/moc_bitcoin.cpp \
   qt/moc_bitcoingui.cpp \
   qt/moc_bitcoinunits.cpp \
   qt/moc_clientmodel.cpp \
   qt/moc_coincontroldialog.cpp \
   qt/moc_coincontroltreewidget.cpp \
   qt/moc_csvmodelwriter.cpp \
   qt/moc_editaddressdialog.cpp \
   qt/moc_guiutil.cpp \
   qt/moc_intro.cpp \
   qt/moc_macdockiconhandler.cpp \
   qt/moc_macnotificationhandler.cpp \
   qt/moc_modaloverlay.cpp \
   qt/moc_notificator.cpp \
   qt/moc_openuridialog.cpp \
   qt/moc_optionsdialog.cpp \
   qt/moc_optionsmodel.cpp \
   qt/moc_overviewpage.cpp \
   qt/moc_peertablemodel.cpp \
   qt/moc_paymentserver.cpp \
   qt/moc_qvalidatedlineedit.cpp \
   qt/moc_qvaluecombobox.cpp \
   qt/moc_receivecoinsdialog.cpp \
   qt/moc_receiverequestdialog.cpp \
   qt/moc_recentrequeststablemodel.cpp \
   qt/moc_rpcconsole.cpp \
   qt/moc_sendcoinsdialog.cpp \
   qt/moc_sendcoinsentry.cpp \
   qt/moc_signverifymessagedialog.cpp \
   qt/moc_splashscreen.cpp \
   qt/moc_trafficgraphwidget.cpp \
   qt/moc_transactiondesc.cpp \
   qt/moc_transactiondescdialog.cpp \
   qt/moc_transactionfilterproxy.cpp \
   qt/moc_transactiontablemodel.cpp \
   qt/moc_transactionview.cpp \
   qt/moc_utilitydialog.cpp \
   qt/moc_walletcontroller.cpp \
   qt/moc_walletframe.cpp \
   qt/moc_walletmodel.cpp \
   qt/moc_walletview.cpp
 
 BITCOIN_MM = \
   qt/macdockiconhandler.mm \
   qt/macnotificationhandler.mm
 
 QT_MOC = \
   qt/bitcoinamountfield.moc \
   qt/intro.moc \
   qt/overviewpage.moc \
   qt/rpcconsole.moc
 
 QT_QRC_CPP = qt/qrc_bitcoin.cpp
 QT_QRC = qt/bitcoin.qrc
 QT_QRC_LOCALE_CPP = qt/qrc_bitcoin_locale.cpp
 QT_QRC_LOCALE = qt/bitcoin_locale.qrc
 
 if ENABLE_BIP70
 PROTOBUF_CC = qt/paymentrequest.pb.cc
 PROTOBUF_H = qt/paymentrequest.pb.h
 PROTOBUF_PROTO = qt/paymentrequest.proto
 else
 PROTOBUF_CC =
 PROTOBUF_H =
 PROTOBUF_PROTO =
 endif
 
 BITCOIN_QT_H = \
   qt/addressbookpage.h \
   qt/addresstablemodel.h \
   qt/askpassphrasedialog.h \
   qt/bantablemodel.h \
   qt/bitcoinaddressvalidator.h \
   qt/bitcoinamountfield.h \
   qt/bitcoin.h \
   qt/bitcoingui.h \
   qt/bitcoinunits.h \
   qt/clientmodel.h \
   qt/coincontroldialog.h \
   qt/coincontroltreewidget.h \
   qt/csvmodelwriter.h \
   qt/editaddressdialog.h \
   qt/guiconstants.h \
   qt/guiutil.h \
   qt/intro.h \
   qt/macdockiconhandler.h \
   qt/macnotificationhandler.h \
   qt/modaloverlay.h \
   qt/networkstyle.h \
   qt/notificator.h \
   qt/openuridialog.h \
   qt/optionsdialog.h \
   qt/optionsmodel.h \
   qt/overviewpage.h \
   qt/paymentrequestplus.h \
   qt/paymentserver.h \
   qt/peertablemodel.h \
   qt/platformstyle.h \
   qt/qvalidatedlineedit.h \
   qt/qvaluecombobox.h \
   qt/receivecoinsdialog.h \
   qt/receiverequestdialog.h \
   qt/recentrequeststablemodel.h \
   qt/rpcconsole.h \
   qt/sendcoinsdialog.h \
   qt/sendcoinsentry.h \
   qt/signverifymessagedialog.h \
   qt/splashscreen.h \
   qt/trafficgraphwidget.h \
   qt/transactiondesc.h \
   qt/transactiondescdialog.h \
   qt/transactionfilterproxy.h \
   qt/transactionrecord.h \
   qt/transactiontablemodel.h \
   qt/transactionview.h \
   qt/utilitydialog.h \
   qt/walletcontroller.h \
   qt/walletframe.h \
   qt/walletmodel.h \
   qt/walletmodeltransaction.h \
   qt/walletview.h \
   qt/winshutdownmonitor.h
 
 RES_ICONS = \
   qt/res/icons/add.png \
   qt/res/icons/address-book.png \
   qt/res/icons/about.png \
   qt/res/icons/about_qt.png \
   qt/res/icons/bitcoin.ico \
   qt/res/icons/bitcoin_testnet.ico \
   qt/res/icons/bitcoin.png \
   qt/res/icons/chevron.png \
   qt/res/icons/clock1.png \
   qt/res/icons/clock2.png \
   qt/res/icons/clock3.png \
   qt/res/icons/clock4.png \
   qt/res/icons/clock5.png \
   qt/res/icons/configure.png \
   qt/res/icons/connect0.png \
   qt/res/icons/connect1.png \
   qt/res/icons/connect2.png \
   qt/res/icons/connect3.png \
   qt/res/icons/connect4.png \
   qt/res/icons/debugwindow.png \
   qt/res/icons/edit.png \
   qt/res/icons/editcopy.png \
   qt/res/icons/editpaste.png \
   qt/res/icons/export.png \
   qt/res/icons/eye.png \
   qt/res/icons/eye_minus.png \
   qt/res/icons/eye_plus.png \
   qt/res/icons/filesave.png \
   qt/res/icons/fontbigger.png \
   qt/res/icons/fontsmaller.png \
   qt/res/icons/hd_disabled.png \
   qt/res/icons/hd_enabled.png \
   qt/res/icons/history.png \
   qt/res/icons/info.png \
   qt/res/icons/key.png \
   qt/res/icons/lock_closed.png \
   qt/res/icons/lock_open.png \
   qt/res/icons/network_disabled.png \
   qt/res/icons/open.png \
   qt/res/icons/overview.png \
   qt/res/icons/proxy.png \
   qt/res/icons/quit.png \
   qt/res/icons/receive.png \
   qt/res/icons/remove.png \
   qt/res/icons/send.png \
   qt/res/icons/synced.png \
   qt/res/icons/transaction0.png \
   qt/res/icons/transaction2.png \
   qt/res/icons/transaction_abandoned.png \
   qt/res/icons/transaction_conflicted.png \
   qt/res/icons/tx_inout.png \
   qt/res/icons/tx_input.png \
   qt/res/icons/tx_output.png \
   qt/res/icons/tx_mined.png \
   qt/res/icons/warning.png \
   qt/res/icons/verify.png
 
 BITCOIN_QT_BASE_CPP = \
   qt/bantablemodel.cpp \
   qt/bitcoin.cpp \
   qt/bitcoinaddressvalidator.cpp \
   qt/bitcoinamountfield.cpp \
   qt/bitcoingui.cpp \
   qt/bitcoinunits.cpp \
   qt/clientmodel.cpp \
   qt/csvmodelwriter.cpp \
   qt/guiutil.cpp \
   qt/intro.cpp \
   qt/modaloverlay.cpp \
   qt/networkstyle.cpp \
   qt/notificator.cpp \
   qt/optionsdialog.cpp \
   qt/optionsmodel.cpp \
   qt/peertablemodel.cpp \
   qt/platformstyle.cpp \
   qt/qvalidatedlineedit.cpp \
   qt/qvaluecombobox.cpp \
   qt/rpcconsole.cpp \
   qt/splashscreen.cpp \
   qt/trafficgraphwidget.cpp \
   qt/utilitydialog.cpp
 
 BITCOIN_QT_WINDOWS_CPP = qt/winshutdownmonitor.cpp
 
 BITCOIN_QT_WALLET_CPP = \
   qt/addressbookpage.cpp \
   qt/addresstablemodel.cpp \
   qt/askpassphrasedialog.cpp \
   qt/coincontroldialog.cpp \
   qt/coincontroltreewidget.cpp \
   qt/editaddressdialog.cpp \
   qt/openuridialog.cpp \
   qt/overviewpage.cpp \
   qt/paymentserver.cpp \
   qt/receivecoinsdialog.cpp \
   qt/receiverequestdialog.cpp \
   qt/recentrequeststablemodel.cpp \
   qt/sendcoinsdialog.cpp \
   qt/sendcoinsentry.cpp \
   qt/signverifymessagedialog.cpp \
   qt/transactiondesc.cpp \
   qt/transactiondescdialog.cpp \
   qt/transactionfilterproxy.cpp \
   qt/transactionrecord.cpp \
   qt/transactiontablemodel.cpp \
   qt/transactionview.cpp \
   qt/walletcontroller.cpp \
   qt/walletframe.cpp \
   qt/walletmodel.cpp \
   qt/walletmodeltransaction.cpp \
   qt/walletview.cpp
 
 BITCOIN_QT_WALLET_BIP70_CPP = \
   qt/paymentrequestplus.cpp
 
 BITCOIN_QT_CPP = $(BITCOIN_QT_BASE_CPP)
 if TARGET_WINDOWS
 BITCOIN_QT_CPP += $(BITCOIN_QT_WINDOWS_CPP)
 endif
 if ENABLE_WALLET
 BITCOIN_QT_CPP += $(BITCOIN_QT_WALLET_CPP)
 if ENABLE_BIP70
 BITCOIN_QT_CPP += $(BITCOIN_QT_WALLET_BIP70_CPP)
 endif # ENABLE_BIP70
 endif # ENABLE_WALLET
 
 RES_IMAGES =
 
 RES_MOVIES = $(wildcard $(srcdir)/qt/res/movies/spinner-*.png)
 
 BITCOIN_RC = qt/res/bitcoin-qt-res.rc
 
 BITCOIN_QT_INCLUDES = -DQT_NO_KEYWORDS
 
 qt_libbitcoinqt_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(BITCOIN_QT_INCLUDES) \
   $(QT_INCLUDES) $(QT_DBUS_INCLUDES) $(PROTOBUF_CFLAGS) $(QR_CFLAGS)
 qt_libbitcoinqt_a_CXXFLAGS = $(AM_CXXFLAGS) $(QT_PIE_FLAGS)
 
 qt_libbitcoinqt_a_SOURCES = $(BITCOIN_QT_CPP) $(BITCOIN_QT_H) $(QT_FORMS_UI) \
   $(QT_QRC) $(QT_QRC_LOCALE) $(QT_TS) $(PROTOBUF_PROTO) $(RES_ICONS) $(RES_IMAGES) $(RES_MOVIES)
 if TARGET_DARWIN
   qt_libbitcoinqt_a_SOURCES += $(BITCOIN_MM)
 endif
 
 nodist_qt_libbitcoinqt_a_SOURCES = $(QT_MOC_CPP) $(QT_MOC) $(PROTOBUF_CC) \
   $(PROTOBUF_H) $(QT_QRC_CPP) $(QT_QRC_LOCALE_CPP)
 
 # forms/foo.h -> forms/ui_foo.h
 QT_FORMS_H=$(join $(dir $(QT_FORMS_UI)),$(addprefix ui_, $(notdir $(QT_FORMS_UI:.ui=.h))))
 
 # Most files will depend on the forms and moc files as includes. Generate them
 # before anything else.
 $(QT_MOC): $(QT_FORMS_H)
 $(qt_libbitcoinqt_a_OBJECTS) $(qt_bitcoin_qt_OBJECTS) : | $(QT_MOC)
 
 #Generating these with a half-written protobuf header leads to wacky results.
 #This makes sure it's done.
 $(QT_MOC): $(PROTOBUF_H)
 $(QT_MOC_CPP): $(PROTOBUF_H)
 
 # bitcoin-qt binary #
 qt_bitcoin_qt_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(BITCOIN_QT_INCLUDES) \
   $(QT_INCLUDES) $(PROTOBUF_CFLAGS) $(QR_CFLAGS)
 qt_bitcoin_qt_CXXFLAGS = $(AM_CXXFLAGS) $(QT_PIE_FLAGS)
 
 qt_bitcoin_qt_SOURCES = qt/main.cpp
 if TARGET_WINDOWS
   qt_bitcoin_qt_SOURCES += $(BITCOIN_RC)
 endif
 qt_bitcoin_qt_LDADD = qt/libbitcoinqt.a $(LIBBITCOIN_SERVER)
 if ENABLE_WALLET
 qt_bitcoin_qt_LDADD += $(LIBBITCOIN_UTIL) $(LIBBITCOIN_WALLET)
 endif
 if ENABLE_ZMQ
 qt_bitcoin_qt_LDADD += $(LIBBITCOIN_ZMQ) $(ZMQ_LIBS)
 endif
 qt_bitcoin_qt_LDADD += $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) $(LIBLEVELDB) $(LIBLEVELDB_SSE42) $(LIBMEMENV) \
   $(BOOST_LIBS) $(QT_LIBS) $(QT_DBUS_LIBS) $(QR_LIBS) $(PROTOBUF_LIBS) $(BDB_LIBS) $(MINIUPNPC_LIBS) $(LIBSECP256K1) \
   $(EVENT_PTHREADS_LIBS) $(EVENT_LIBS)
 if ENABLE_BIP70
 qt_bitcoin_qt_LDADD += $(SSL_LIBS)
 endif
 qt_bitcoin_qt_LDADD += $(CRYPTO_LIBS)
 qt_bitcoin_qt_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(QT_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
 qt_bitcoin_qt_LIBTOOLFLAGS = $(AM_LIBTOOLFLAGS) --tag CXX
 
 #locale/foo.ts -> locale/foo.qm
 QT_QM=$(QT_TS:.ts=.qm)
 
 SECONDARY: $(QT_QM)
 
 $(srcdir)/qt/bitcoinstrings.cpp: FORCE
 	@test -n $(XGETTEXT) || echo "xgettext is required for updating translations"
-	$(AM_V_GEN) cd $(srcdir); XGETTEXT=$(XGETTEXT) PACKAGE_NAME="$(PACKAGE_NAME)" COPYRIGHT_HOLDERS="$(COPYRIGHT_HOLDERS)" COPYRIGHT_HOLDERS_SUBSTITUTION="$(COPYRIGHT_HOLDERS_SUBSTITUTION)" $(PYTHON) ../share/qt/extract_strings_qt.py $(libbitcoin_server_a_SOURCES) $(libbitcoin_wallet_a_SOURCES) $(libbitcoin_common_a_SOURCES) $(libbitcoin_zmq_a_SOURCES) $(libbitcoin_consensus_a_SOURCES) $(libbitcoin_util_a_SOURCES)
+	$(AM_V_GEN) cd $(srcdir); XGETTEXT=$(XGETTEXT) COPYRIGHT_HOLDERS="$(COPYRIGHT_HOLDERS)" $(PYTHON) ../share/qt/extract_strings_qt.py $(libbitcoin_server_a_SOURCES) $(libbitcoin_wallet_a_SOURCES) $(libbitcoin_common_a_SOURCES) $(libbitcoin_zmq_a_SOURCES) $(libbitcoin_consensus_a_SOURCES) $(libbitcoin_util_a_SOURCES)
 
 translate: $(srcdir)/qt/bitcoinstrings.cpp $(QT_FORMS_UI) $(QT_FORMS_UI) $(BITCOIN_QT_BASE_CPP) qt/bitcoin.cpp $(BITCOIN_QT_WINDOWS_CPP) $(BITCOIN_QT_WALLET_CPP) $(BITCOIN_QT_H) $(BITCOIN_MM)
 	@test -n $(LUPDATE) || echo "lupdate is required for updating translations"
 	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(LUPDATE) $^ -locations relative -no-obsolete -ts $(srcdir)/qt/locale/bitcoin_en.ts
 
 $(QT_QRC_LOCALE_CPP): $(QT_QRC_LOCALE) $(QT_QM)
 	@test -f $(RCC)
 	@cp -f $< $(@D)/temp_$(<F)
 	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(RCC) -name bitcoin_locale $(@D)/temp_$(<F) | \
 	  $(SED) -e '/^\*\*.*Created:/d' -e '/^\*\*.*by:/d' > $@
 	@rm $(@D)/temp_$(<F)
 
 $(QT_QRC_CPP): $(QT_QRC) $(QT_FORMS_H) $(RES_ICONS) $(RES_IMAGES) $(RES_MOVIES) $(PROTOBUF_H)
 	@test -f $(RCC)
 	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(RCC) -name bitcoin $< | \
 	  $(SED) -e '/^\*\*.*Created:/d' -e '/^\*\*.*by:/d' > $@
 
 CLEAN_QT = $(nodist_qt_libbitcoinqt_a_SOURCES) $(QT_QM) $(QT_FORMS_H) qt/*.gcda qt/*.gcno qt/temp_bitcoin_locale.qrc
 
 CLEANFILES += $(CLEAN_QT)
 
 bitcoin_qt_clean: FORCE
 	rm -f $(CLEAN_QT) $(qt_libbitcoinqt_a_OBJECTS) $(qt_bitcoin_qt_OBJECTS) qt/bitcoin-qt$(EXEEXT) $(LIBBITCOINQT)
 
 bitcoin_qt : qt/bitcoin-qt$(EXEEXT)
 
 ui_%.h: %.ui
 	@test -f $(UIC)
 	@$(MKDIR_P) $(@D)
 	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(UIC) -o $@ $< || (echo "Error creating $@"; false)
 
 %.moc: %.cpp
 	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(MOC) $(DEFAULT_INCLUDES) $(QT_INCLUDES) $(MOC_DEFS) $< | \
 	  $(SED) -e '/^\*\*.*Created:/d' -e '/^\*\*.*by:/d' > $@
 
 moc_%.cpp: %.h
 	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(MOC) $(DEFAULT_INCLUDES) $(QT_INCLUDES) $(MOC_DEFS) $< | \
 	  $(SED) -e '/^\*\*.*Created:/d' -e '/^\*\*.*by:/d' > $@
 
 %.qm: %.ts
 	@test -f $(LRELEASE)
 	@$(MKDIR_P) $(@D)
 	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(LRELEASE) -silent $< -qm $@
diff --git a/src/init.cpp b/src/init.cpp
index fe8ef26a6..eca98a37d 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1,2597 +1,2597 @@
 // 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 <amount.h>
 #include <avalanche.h>
 #include <banman.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <checkpoints.h>
 #include <compat/sanity.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <flatfile.h>
 #include <fs.h>
 #include <httprpc.h>
 #include <httpserver.h>
 #include <index/txindex.h>
 #include <interfaces/chain.h>
 #include <key.h>
 #include <miner.h>
 #include <net.h>
 #include <net_processing.h>
 #include <netbase.h>
 #include <policy/mempool.h>
 #include <policy/policy.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 <timedata.h>
 #include <torcontrol.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <ui_interface.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <util/threadnames.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <walletinitinterface.h>
 #include <warnings.h>
 
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/thread.hpp>
 
 #if ENABLE_ZMQ
 #include <zmq/zmqnotificationinterface.h>
 #include <zmq/zmqrpc.h>
 #endif
 
 #ifndef WIN32
 #include <attributes.h>
 #include <cerrno>
 #include <csignal>
 #include <sys/stat.h>
 #endif
 #include <cstdint>
 #include <cstdio>
 #include <memory>
 
 static const bool DEFAULT_PROXYRANDOMIZE = true;
 static const bool DEFAULT_REST_ENABLE = false;
 static const bool DEFAULT_STOPAFTERBLOCKIMPORT = false;
 
 // Dump addresses to banlist.dat every 15 minutes (900s)
 static constexpr int DUMP_BANS_INTERVAL = 60 * 15;
 
 std::unique_ptr<CConnman> g_connman;
 std::unique_ptr<PeerLogicValidation> peerLogic;
 std::unique_ptr<BanMan> g_banman;
 
 #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
 
 /**
  * The PID file facilities.
  */
 static const char *BITCOIN_PID_FILENAME = "bitcoind.pid";
 
 static fs::path GetPidFile() {
     return AbsPathForConfigVal(
         fs::path(gArgs.GetArg("-pid", BITCOIN_PID_FILENAME)));
 }
 
 NODISCARD static bool CreatePidFile() {
     fsbridge::ofstream file{GetPidFile()};
     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"),
                                    GetPidFile().string(),
                                    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
 // ShutdownRequested(), which triggers the DetectShutdownThread(), which
 // interrupts the main thread group. DetectShutdownThread() then exits, which
 // causes AppInit() to continue (it .joins the shutdown 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.
 //
 
 /**
  * This is a minimally invasive approach to shutdown on LevelDB read errors from
  * the chainstate, while keeping user interface out of the common library, which
  * is shared between bitcoind, and bitcoin-qt and non-server tools.
  */
 class CCoinsViewErrorCatcher final : public CCoinsViewBacked {
 public:
     explicit CCoinsViewErrorCatcher(CCoinsView *view)
         : CCoinsViewBacked(view) {}
     bool GetCoin(const COutPoint &outpoint, Coin &coin) const override {
         try {
             return CCoinsViewBacked::GetCoin(outpoint, coin);
         } catch (const std::runtime_error &e) {
             uiInterface.ThreadSafeMessageBox(
                 _("Error reading from database, shutting down."), "",
                 CClientUIInterface::MSG_ERROR);
             LogPrintf("Error reading from database: %s\n", e.what());
             // Starting the shutdown sequence and returning false to the caller
             // would be interpreted as 'entry not found' (as opposed to unable
             // to read data), and could lead to invalid interpretation. Just
             // exit immediately, as we can't continue anyway, and all writes
             // should be atomic.
             abort();
         }
     }
     // Writes do not need similar protection, as failure to write is handled by
     // the caller.
 };
 
 static std::unique_ptr<CCoinsViewErrorCatcher> pcoinscatcher;
 static std::unique_ptr<ECCVerifyHandle> globalVerifyHandle;
 
 static boost::thread_group threadGroup;
 static CScheduler scheduler;
 
 void Interrupt() {
     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 (g_connman) {
         g_connman->Interrupt();
     }
     if (g_txindex) {
         g_txindex->Interrupt();
     }
 }
 
 void Shutdown(InitInterfaces &interfaces) {
     LogPrintf("%s: In progress...\n", __func__);
     static CCriticalSection cs_Shutdown;
     TRY_LOCK(cs_Shutdown, lockShutdown);
     if (!lockShutdown) {
         return;
     }
 
     /// 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");
     g_mempool.AddTransactionsUpdated(1);
 
     StopHTTPRPC();
     StopREST();
     StopRPC();
     StopHTTPServer();
     for (const auto &client : interfaces.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 AvalancheProcessor.
     // 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 (peerLogic) {
         UnregisterValidationInterface(peerLogic.get());
     }
     if (g_connman) {
         g_connman->Stop();
     }
     if (g_txindex) {
         g_txindex->Stop();
     }
 
     StopTorControl();
 
     // After everything has been shut down, but before things get flushed, stop
     // the CScheduler/checkqueue threadGroup
     threadGroup.interrupt_all();
     threadGroup.join_all();
 
     // After the threads that potentially access these pointers have been
     // stopped, destruct and reset all to nullptr.
     peerLogic.reset();
 
     // Destroy various global instances
     g_avalanche.reset();
     g_connman.reset();
     g_banman.reset();
     g_txindex.reset();
 
     if (::g_mempool.IsLoaded() &&
         gArgs.GetArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
         DumpMempool(::g_mempool);
     }
 
     // FlushStateToDisk generates a ChainStateFlushed callback, which we should
     // avoid missing
     if (pcoinsTip != nullptr) {
         FlushStateToDisk();
     }
 
     // After there are no more peers/RPC left to give us new data which may
     // generate CValidationInterface callbacks, flush them...
     GetMainSignals().FlushBackgroundCallbacks();
 
     // 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.
 
     {
         LOCK(cs_main);
         if (pcoinsTip != nullptr) {
             FlushStateToDisk();
         }
         pcoinsTip.reset();
         pcoinscatcher.reset();
         pcoinsdbview.reset();
         pblocktree.reset();
     }
     for (const auto &client : interfaces.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
 
     try {
         if (!fs::remove(GetPidFile())) {
             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));
     }
     interfaces.chain_clients.clear();
     UnregisterAllValidationInterfaces();
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     GetMainSignals().UnregisterWithMempoolSignals(g_mempool);
     globalVerifyHandle.reset();
     ECC_Stop();
     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 void OnRPCStarted() {
     uiInterface.NotifyBlockTip_connect(&RPCNotifyBlockChange);
 }
 
 static void OnRPCStopped() {
     uiInterface.NotifyBlockTip_disconnect(&RPCNotifyBlockChange);
     RPCNotifyBlockChange(false, nullptr);
     g_best_block_cv.notify_all();
     LogPrint(BCLog::RPC, "RPC stopped.\n");
 }
 
 void SetupServerArgs() {
     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 = {
         "-h", "-help", "-dbcrashratio", "-forcecompactdb", "-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 2020 upgrade
         "-phononactivationtime"};
 
     // 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.
     gArgs.AddArg("-?", "Print this help message and exit",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY,
                  OptionsCategory::OPTIONS);
     gArgs.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);
     gArgs.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);
     gArgs.AddArg("-blocksdir=<dir>",
                  "Specify directory to hold blocks subdirectory for *.dat "
                  "files (default: <datadir>)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-blocknotify=<cmd>",
                  "Execute command when the best block changes (%s in cmd is "
                  "replaced by block hash)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.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);
     gArgs.AddArg(
         "-blocksonly",
         strprintf("Whether to operate in a blocks only mode (default: %d)",
                   DEFAULT_BLOCKSONLY),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::OPTIONS);
     gArgs.AddArg("-conf=<file>",
                  strprintf("Specify configuration file. Relative paths will be "
                            "prefixed by datadir location. (default: %s)",
                            BITCOIN_CONF_FILENAME),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-datadir=<dir>", "Specify data directory",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-dbbatchsize",
         strprintf("Maximum database write batch size in bytes (default: %u)",
                   nDefaultDbBatchSize),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::OPTIONS);
     gArgs.AddArg(
         "-dbcache=<n>",
         strprintf(
             "Set database cache size in megabytes (%d to %d, default: %d)",
             nMinDbCache, nMaxDbCache, nDefaultDbCache),
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-debuglogfile=<file>",
                  strprintf("Specify location of debug log file. Relative paths "
                            "will be prefixed by a net-specific datadir "
                            "location. (0 to disable; default: %s)",
                            DEFAULT_DEBUGLOGFILE),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-feefilter",
                  strprintf("Tell other nodes to filter invs to us by our "
                            "mempool min fee (default: %d)",
                            DEFAULT_FEEFILTER),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::OPTIONS);
     gArgs.AddArg("-finalizationdelay=<n>",
                  strprintf("Set the minimum amount of time to wait between a "
                            "block header reception and the block finalization. "
                            "Unit is seconds (default: %d)",
                            DEFAULT_MIN_FINALIZATION_DELAY),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.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);
     gArgs.AddArg("-maxreorgdepth=<n>",
                  strprintf("Configure at what depth blocks are considered "
                            "final (default: %d). Use -1 to disable.",
                            DEFAULT_MAX_REORG_DEPTH),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-loadblock=<file>",
                  "Imports blocks from external blk000??.dat file on startup",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-maxmempool=<n>",
                  strprintf("Keep the transaction memory pool below <n> "
                            "megabytes (default: %u)",
                            DEFAULT_MAX_MEMPOOL_SIZE),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-maxorphantx=<n>",
                  strprintf("Keep at most <n> unconnectable transactions in "
                            "memory (default: %u)",
                            DEFAULT_MAX_ORPHAN_TRANSACTIONS),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.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);
     gArgs.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);
     gArgs.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);
     gArgs.AddArg("-persistmempool",
                  strprintf("Whether to save the mempool on shutdown and load "
                            "on restart (default: %u)",
                            DEFAULT_PERSIST_MEMPOOL),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.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);
     gArgs.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 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);
     gArgs.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);
     gArgs.AddArg(
         "-reindex",
         "Rebuild chain state and block index from the blk*.dat files on disk",
         ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #ifndef WIN32
     gArgs.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
     gArgs.AddArg("-txindex",
                  strprintf("Maintain a full transaction index, used by the "
                            "getrawtransaction rpc call (default: %d)",
                            DEFAULT_TXINDEX),
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     gArgs.AddArg("-usecashaddr",
                  "Use Cash Address for destination encoding instead of base58 "
                  "(activate by default on Jan, 14)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 
     gArgs.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);
     gArgs.AddArg(
         "-banscore=<n>",
         strprintf("Threshold for disconnecting misbehaving peers (default: %u)",
                   DEFAULT_BANSCORE_THRESHOLD),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-bantime=<n>",
                  strprintf("Number of seconds to keep misbehaving peers from "
                            "reconnecting (default: %u)",
                            DEFAULT_MISBEHAVING_BANTIME),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-bind=<addr>",
                  "Bind to given address and always listen on it. Use "
                  "[host]:port notation for IPv6",
                  ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                  OptionsCategory::CONNECTION);
     gArgs.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);
     gArgs.AddArg("-discover",
                  "Discover own IP addresses (default: 1 when listening and no "
                  "-externalip or -proxy)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-dns",
                  strprintf("Allow DNS lookups for -addnode, -seednode and "
                            "-connect (default: %d)",
                            DEFAULT_NAME_LOOKUP),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-dnsseed",
                  "Query for peer addresses via DNS lookup, if low on addresses "
                  "(default: 1 unless -connect used)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-enablebip61",
                  strprintf("Send reject messages per BIP61 (default: %u)",
                            DEFAULT_ENABLE_BIP61),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 
     gArgs.AddArg("-externalip=<ip>", "Specify your own public address",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-forcednsseed",
         strprintf(
             "Always query for peer addresses via DNS lookup (default: %d)",
             DEFAULT_FORCEDNSSEED),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-listen",
         "Accept connections from outside (default: 1 if no -proxy or -connect)",
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-listenonion",
         strprintf("Automatically create Tor hidden service (default: %d)",
                   DEFAULT_LISTEN_ONION),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-maxconnections=<n>",
         strprintf("Maintain at most <n> connections to peers (default: %u)",
                   DEFAULT_MAX_PEER_CONNECTIONS),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-maxreceivebuffer=<n>",
                  strprintf("Maximum per-connection receive buffer, <n>*1000 "
                            "bytes (default: %u)",
                            DEFAULT_MAXRECEIVEBUFFER),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-maxsendbuffer=<n>",
         strprintf(
             "Maximum per-connection send buffer, <n>*1000 bytes (default: %u)",
             DEFAULT_MAXSENDBUFFER),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.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);
     gArgs.AddArg("-onion=<ip:port>",
                  strprintf("Use separate SOCKS5 proxy to reach peers via Tor "
                            "hidden services (default: %s)",
                            "-proxy"),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-onlynet=<net>",
                  "Only connect to nodes in network <net> (ipv4, ipv6 or onion)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-peerbloomfilters",
                  strprintf("Support filtering of blocks and transaction with "
                            "bloom filters (default: %d)",
                            DEFAULT_PEERBLOOMFILTERS),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-permitbaremultisig",
                  strprintf("Relay non-P2SH multisig (default: %d)",
                            DEFAULT_PERMIT_BAREMULTISIG),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-port=<port>",
                  strprintf("Listen for connections on <port> (default: %u, "
                            "testnet: %u, regtest: %u)",
                            defaultChainParams->GetDefaultPort(),
                            testnetChainParams->GetDefaultPort(),
                            regtestChainParams->GetDefaultPort()),
                  ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
                  OptionsCategory::CONNECTION);
     gArgs.AddArg("-proxy=<ip:port>", "Connect through SOCKS5 proxy",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-proxyrandomize",
                  strprintf("Randomize credentials for every proxy connection. "
                            "This enables Tor stream isolation (default: %d)",
                            DEFAULT_PROXYRANDOMIZE),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-seednode=<ip>",
                  "Connect to a node to retrieve peer addresses, and disconnect",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-timeout=<n>",
                  strprintf("Specify connection timeout in milliseconds "
                            "(minimum: 1, default: %d)",
                            DEFAULT_CONNECT_TIMEOUT),
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-torcontrol=<ip>:<port>",
         strprintf(
             "Tor control port to use if onion listening enabled (default: %s)",
             DEFAULT_TOR_CONTROL),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-torpassword=<pass>",
                  "Tor control port password (default: empty)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 #ifdef USE_UPNP
 #if USE_UPNP
     gArgs.AddArg("-upnp",
                  "Use UPnP to map the listening port (default: 1 when "
                  "listening and no -proxy)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 #else
     gArgs.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
     gArgs.AddArg("-whitebind=<addr>",
                  "Bind to given address and whitelist peers connecting to it. "
                  "Use [host]:port notation for IPv6",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg("-whitelist=<IP address or network>",
                  "Whitelist peers connecting from the given IP address (e.g. "
                  "1.2.3.4) or CIDR notated network (e.g. 1.2.3.0/24). Can be "
                  "specified multiple times. "
                  "Whitelisted peers cannot be DoS banned and their "
                  "transactions are always relayed, even if they are already in "
                  "the mempool, useful e.g. for a gateway",
                  ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     gArgs.AddArg(
         "-maxuploadtarget=<n>",
         strprintf("Tries to keep outbound traffic under the given target (in "
                   "MiB per 24h), 0 = no limit (default: %d)",
                   DEFAULT_MAX_UPLOAD_TARGET),
         ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
 
     g_wallet_init_interface.AddWalletOptions();
 
 #if ENABLE_ZMQ
     gArgs.AddArg("-zmqpubhashblock=<address>",
                  "Enable publish hash block in <address>",
                  ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     gArgs.AddArg("-zmqpubhashtx=<address>",
                  "Enable publish hash transaction in <address>",
                  ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     gArgs.AddArg("-zmqpubrawblock=<address>",
                  "Enable publish raw block in <address>",
                  ArgsManager::ALLOW_ANY, OptionsCategory::ZMQ);
     gArgs.AddArg("-zmqpubrawtx=<address>",
                  "Enable publish raw transaction in <address>",
                  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>");
 #endif
 
     gArgs.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);
     gArgs.AddArg(
         "-checklevel=<n>",
         strprintf("How thorough the block verification of "
                   "-checkblocks is: "
                   "level 0 reads the blocks from disk, "
                   "level 1 verifies block validity, "
                   "level 2 verifies undo data, "
                   "level 3 checks disconnection of tip blocks, "
                   "and level 4 tries to reconnect the blocks. "
                   "Each level includes the checks of the previous levels "
                   "(0-4, default: %u)",
                   DEFAULT_CHECKLEVEL),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-checkblockindex",
         strprintf("Do a full consistency check for mapBlockIndex, "
                   "setBlockIndexCandidates, ::ChainActive() and "
                   "mapBlocksUnlinked occasionally. (default: %u, regtest: %u)",
                   defaultChainParams->DefaultConsistencyChecks(),
                   regtestChainParams->DefaultConsistencyChecks()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-checkmempool=<n>",
         strprintf(
             "Run checks every <n> transactions (default: %u, regtest: %u)",
             defaultChainParams->DefaultConsistencyChecks(),
             regtestChainParams->DefaultConsistencyChecks()),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.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);
     gArgs.AddArg("-deprecatedrpc=<method>",
                  "Allows deprecated RPC method(s) to be used",
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-dropmessagestest=<n>",
                  "Randomly drop 1 of every <n> network messages",
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-stopafterblockimport",
         strprintf("Stop running after importing blocks from disk (default: %d)",
                   DEFAULT_STOPAFTERBLOCKIMPORT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.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);
     gArgs.AddArg("-limitancestorcount=<n>",
                  strprintf("Do not accept transactions if number of in-mempool "
                            "ancestors is <n> or more (pre-phonon-upgrade "
                            "default: %u, post-phonon-upgrade default: %u)",
                            DEFAULT_ANCESTOR_LIMIT,
                            DEFAULT_ANCESTOR_LIMIT_LONGER),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-limitancestorsize=<n>",
         strprintf("Do not accept transactions whose size with all in-mempool "
                   "ancestors exceeds <n> kilobytes (default: %u)",
                   DEFAULT_ANCESTOR_SIZE_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-limitdescendantcount=<n>",
         strprintf("Do not accept transactions if any ancestor would have <n> "
                   "or more in-mempool descendants (default pre-phonon-upgrade: "
                   "%u, default post-phonon-upgrade: %u)",
                   DEFAULT_DESCENDANT_LIMIT, DEFAULT_DESCENDANT_LIMIT_LONGER),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-limitdescendantsize=<n>",
         strprintf("Do not accept transactions if any ancestor would have more "
                   "than <n> kilobytes of in-mempool descendants (default: %u).",
                   DEFAULT_DESCENDANT_SIZE_LIMIT),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-addrmantest", "Allows to test address relay on localhost",
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
 
     gArgs.AddArg("-debug=<category>",
                  strprintf("Output debugging information (default: %u, "
                            "supplying <category> is optional)",
                            0) +
                      ". " +
                      "If <category> is not supplied or if <category> = 1, "
                      "output all debugging information."
                      "<category> can be: " +
                      ListLogCategories() + ".",
                  ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-debugexclude=<category>",
         strprintf("Exclude debugging information for a category. Can be used "
                   "in conjunction with -debug=1 to output debug logs for all "
                   "categories except one or more specified categories."),
         ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-help-debug",
                  "Print help message with debugging options and exit",
                  ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-logips",
                  strprintf("Include IP addresses in debug output (default: %d)",
                            DEFAULT_LOGIPS),
                  ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-logtimestamps",
                  strprintf("Prepend debug output with timestamp (default: %d)",
                            DEFAULT_LOGTIMESTAMPS),
                  ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-logthreadnames",
         strprintf(
             "Prepend debug output with name of the originating thread (only "
             "available on platforms supporting thread_local) (default: %u)",
             DEFAULT_LOGTHREADNAMES),
         ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-logtimemicros",
         strprintf("Add microsecond precision to debug timestamps (default: %d)",
                   DEFAULT_LOGTIMEMICROS),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-mocktime=<n>",
         "Replace actual time with <n> seconds since epoch (default: 0)",
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::DEBUG_TEST);
     gArgs.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);
     gArgs.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);
     gArgs.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);
 
     gArgs.AddArg(
         "-printtoconsole",
         "Send trace/debug info to console instead of debug.log file (default: "
         "1 when no -daemon. To disable logging to file, set debuglogfile=0)",
         ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     gArgs.AddArg("-printpriority",
                  strprintf("Log transaction priority and fee per kB when "
                            "mining blocks (default: %d)",
                            DEFAULT_PRINTPRIORITY),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::DEBUG_TEST);
     gArgs.AddArg(
         "-shrinkdebugfile",
         "Shrink debug.log file on client startup (default: 1 when no -debug)",
         ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
 
     gArgs.AddArg("-uacomment=<cmt>", "Append comment to the user agent string",
                  ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
 
     SetupChainParamsBaseOptions();
 
     gArgs.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);
     gArgs.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);
     gArgs.AddArg(
         "-dustrelayfee=<amt>",
         strprintf("Fee rate (in %s/kB) used to defined 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)",
                   CURRENCY_UNIT, FormatMoney(DUST_RELAY_TX_FEE)),
         ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
         OptionsCategory::NODE_RELAY);
 
     gArgs.AddArg("-bytespersigop",
                  strprintf("Equivalent bytes per sigop in transactions for "
                            "relay and mining (default: %u)",
                            DEFAULT_BYTES_PER_SIGOP),
                  ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     gArgs.AddArg(
         "-datacarrier",
         strprintf("Relay and mine data carrier transactions (default: %d)",
                   DEFAULT_ACCEPT_DATACARRIER),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     gArgs.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);
     gArgs.AddArg(
         "-minrelaytxfee=<amt>",
         strprintf("Fees (in %s/kB) smaller than this are rejected for "
                   "relaying, mining and transaction creation (default: %s)",
                   CURRENCY_UNIT, FormatMoney(DEFAULT_MIN_RELAY_TX_FEE_PER_KB)),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     gArgs.AddArg(
         "-whitelistrelay",
         strprintf("Accept relayed transactions received from whitelisted "
                   "peers even when not relaying transactions (default: %d)",
                   DEFAULT_WHITELISTRELAY),
         ArgsManager::ALLOW_ANY, OptionsCategory::NODE_RELAY);
     gArgs.AddArg(
         "-whitelistforcerelay",
         strprintf("Force relay of transactions from whitelisted peers even if "
                   "they violate local relay policy (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.
     gArgs.AddArg("-excessutxocharge=<amt>",
                  strprintf("Fees (in %s/kB) to charge per utxo created for "
                            "relaying, and mining (default: %s)",
                            CURRENCY_UNIT, FormatMoney(DEFAULT_UTXO_FEE)),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::NODE_RELAY);
 
     gArgs.AddArg("-blockmaxsize=<n>",
                  strprintf("Set maximum block size in bytes (default: %d)",
                            DEFAULT_MAX_GENERATED_BLOCK_SIZE),
                  ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
     gArgs.AddArg("-blockmintxfee=<amt>",
                  strprintf("Set lowest fee rate (in %s/kB) for transactions to "
                            "be included in block creation. (default: %s)",
                            CURRENCY_UNIT,
                            FormatMoney(DEFAULT_BLOCK_MIN_TX_FEE_PER_KB)),
                  ArgsManager::ALLOW_ANY, OptionsCategory::BLOCK_CREATION);
 
     gArgs.AddArg("-blockversion=<n>",
                  "Override block version to test forking scenarios",
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::BLOCK_CREATION);
 
     gArgs.AddArg("-server", "Accept command line and JSON-RPC commands",
                  ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg("-rest",
                  strprintf("Accept public REST requests (default: %d)",
                            DEFAULT_REST_ENABLE),
                  ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg(
         "-rpcbind=<addr>[:port]",
         "Bind to given address to listen for JSON-RPC connections. 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, or if -rpcallowip has been specified, 0.0.0.0 and :: i.e., "
         "all addresses)",
         ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY,
         OptionsCategory::RPC);
     gArgs.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);
     gArgs.AddArg("-rpcuser=<user>", "Username for JSON-RPC connections",
                  ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg("-rpcpassword=<pw>", "Password for JSON-RPC connections",
                  ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg(
         "-rpcauth=<userpw>",
         "Username and 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, OptionsCategory::RPC);
     gArgs.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);
     gArgs.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);
     gArgs.AddArg(
         "-rpcthreads=<n>",
         strprintf(
             "Set the number of threads to service RPC calls (default: %d)",
             DEFAULT_HTTP_THREADS),
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
     gArgs.AddArg(
         "-rpccorsdomain=value",
         "Domain from which to accept cross origin requests (browser enforced)",
         ArgsManager::ALLOW_ANY, OptionsCategory::RPC);
 
     gArgs.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);
     gArgs.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_DAEMON
     gArgs.AddArg("-daemon",
                  "Run in the background as a daemon and accept commands",
                  ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 #else
     hidden_args.emplace_back("-daemon");
 #endif
 
     // Avalanche options.
     gArgs.AddArg(
         "-enableavalanche",
         strprintf("Enable avalanche (default: %u)", AVALANCHE_DEFAULT_ENABLED),
         ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
     gArgs.AddArg(
         "-avacooldown",
         strprintf("Mandatory cooldown between two avapoll (default: %u)",
                   AVALANCHE_DEFAULT_COOLDOWN),
         ArgsManager::ALLOW_ANY, OptionsCategory::AVALANCHE);
 
     // Add the hidden options
     gArgs.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"), 2009, COPYRIGHT_YEAR) +
                " ") +
            "\n" + "\n" +
            strprintf(_("Please contribute if you find %s useful. "
                        "Visit %s for further information about the software."),
                      PACKAGE_NAME, URL_WEBSITE) +
            "\n" +
            strprintf(_("The source code is available from %s."),
                      URL_SOURCE_CODE) +
            "\n" + "\n" + _("This is experimental software.") + "\n" +
            strprintf(_("Distributed under the MIT software license, see the "
                        "accompanying file %s or %s"),
                      "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."),
                      "<https://www.openssl.org>") +
            "\n";
 }
 
 static void BlockNotifyCallback(bool initialSync,
                                 const CBlockIndex *pBlockIndex) {
     if (initialSync || !pBlockIndex) {
         return;
     }
 
     std::string strCmd = gArgs.GetArg("-blocknotify", "");
     if (!strCmd.empty()) {
         boost::replace_all(strCmd, "%s", pBlockIndex->GetBlockHash().GetHex());
         std::thread t(runCommand, strCmd);
         // thread runs free
         t.detach();
     }
 }
 
 static bool fHaveGenesis = false;
 static Mutex g_genesis_wait_mutex;
 static std::condition_variable g_genesis_wait_cv;
 
 static void BlockNotifyGenesisWait(bool, const CBlockIndex *pBlockIndex) {
     if (pBlockIndex != nullptr) {
         {
             LOCK(g_genesis_wait_mutex);
             fHaveGenesis = true;
         }
         g_genesis_wait_cv.notify_all();
     }
 }
 
 struct CImportingNow {
     CImportingNow() {
         assert(fImporting == false);
         fImporting = true;
     }
 
     ~CImportingNow() {
         assert(fImporting == true);
         fImporting = false;
     }
 };
 
 // If we're using -prune with -reindex, then delete block files that will be
 // ignored by the reindex.  Since reindexing works by starting at block file 0
 // and looping until a blockfile is missing, do the same here to delete any
 // later block files after a gap. Also delete all rev files since they'll be
 // rewritten by the reindex anyway. This ensures that vinfoBlockFile is in sync
 // with what's actually on disk by the time we start downloading, so that
 // pruning works correctly.
 static void CleanupBlockRevFiles() {
     std::map<std::string, fs::path> mapBlockFiles;
 
     // Glob all blk?????.dat and rev?????.dat files from the blocks directory.
     // Remove the rev files immediately and insert the blk file paths into an
     // ordered map keyed by block file index.
     LogPrintf("Removing unusable blk?????.dat and rev?????.dat files for "
               "-reindex with -prune\n");
     const auto directoryIterator = fs::directory_iterator{GetBlocksDir()};
     for (const auto &file : directoryIterator) {
         const auto fileName = file.path().filename().string();
         if (fs::is_regular_file(file) && fileName.length() == 12 &&
             fileName.substr(8, 4) == ".dat") {
             if (fileName.substr(0, 3) == "blk") {
                 mapBlockFiles[fileName.substr(3, 5)] = file.path();
             } else if (fileName.substr(0, 3) == "rev") {
                 remove(file.path());
             }
         }
     }
 
     // Remove all block files that aren't part of a contiguous set starting at
     // zero by walking the ordered map (keys are block file indices) by keeping
     // a separate counter. Once we hit a gap (or if 0 doesn't exist) start
     // removing block files.
     int contiguousCounter = 0;
     for (const auto &item : mapBlockFiles) {
         if (atoi(item.first) == contiguousCounter) {
             contiguousCounter++;
             continue;
         }
         remove(item.second);
     }
 }
 
 static void ThreadImport(const Config &config,
                          std::vector<fs::path> vImportFiles) {
     util::ThreadRename("loadblk");
     ScheduleBatchPriority();
 
     {
         CImportingNow imp;
 
         // -reindex
         if (fReindex) {
             int nFile = 0;
             while (true) {
                 FlatFilePos pos(nFile, 0);
                 if (!fs::exists(GetBlockPosFilename(pos))) {
                     // No block files left to reindex
                     break;
                 }
                 FILE *file = OpenBlockFile(pos, true);
                 if (!file) {
                     // This error is logged in OpenBlockFile
                     break;
                 }
                 LogPrintf("Reindexing block file blk%05u.dat...\n",
                           (unsigned int)nFile);
                 LoadExternalBlockFile(config, file, &pos);
                 nFile++;
             }
             pblocktree->WriteReindexing(false);
             fReindex = false;
             LogPrintf("Reindexing finished\n");
             // To avoid ending up in a situation without genesis block, re-try
             // initializing (no-op if reindexing worked):
             LoadGenesisBlock(config.GetChainParams());
         }
 
         // hardcoded $DATADIR/bootstrap.dat
         fs::path pathBootstrap = GetDataDir() / "bootstrap.dat";
         if (fs::exists(pathBootstrap)) {
             FILE *file = fsbridge::fopen(pathBootstrap, "rb");
             if (file) {
                 fs::path pathBootstrapOld = GetDataDir() / "bootstrap.dat.old";
                 LogPrintf("Importing bootstrap.dat...\n");
                 LoadExternalBlockFile(config, file);
                 RenameOver(pathBootstrap, pathBootstrapOld);
             } else {
                 LogPrintf("Warning: Could not open bootstrap file %s\n",
                           pathBootstrap.string());
             }
         }
 
         // -loadblock=
         for (const fs::path &path : vImportFiles) {
             FILE *file = fsbridge::fopen(path, "rb");
             if (file) {
                 LogPrintf("Importing blocks file %s...\n", path.string());
                 LoadExternalBlockFile(config, file);
             } else {
                 LogPrintf("Warning: Could not open blocks file %s\n",
                           path.string());
             }
         }
 
         // scan for better chains in the block chain database, that are not yet
         // connected in the active best chain
         CValidationState state;
         if (!ActivateBestChain(config, state)) {
             LogPrintf("Failed to connect best block (%s)\n",
                       FormatStateMessage(state));
             StartShutdown();
             return;
         }
 
         if (gArgs.GetBoolArg("-stopafterblockimport",
                              DEFAULT_STOPAFTERBLOCKIMPORT)) {
             LogPrintf("Stopping after block import\n");
             StartShutdown();
             return;
         }
     } // End scope of CImportingNow
     if (gArgs.GetArg("-persistmempool", DEFAULT_PERSIST_MEMPOOL)) {
         LoadMempool(config, ::g_mempool);
     }
     ::g_mempool.SetIsLoaded(!ShutdownRequested());
 }
 
 /** Sanity checks
  *  Ensure that Bitcoin is running in a usable environment with all
  *  necessary library support.
  */
 static bool InitSanityCheck() {
     if (!ECC_InitSanityCheck()) {
         InitError(
             "Elliptic curve cryptography sanity check failure. Aborting.");
         return false;
     }
 
     if (!glibc_sanity_test() || !glibcxx_sanity_test()) {
         return false;
     }
 
     if (!Random_SanityCheck()) {
         InitError("OS cryptographic RNG sanity check failure. Aborting.");
         return false;
     }
 
     return true;
 }
 
 static bool AppInitServers(Config &config,
                            HTTPRPCRequestProcessor &httpRPCRequestProcessor) {
     RPCServerSignals::OnStarted(&OnRPCStarted);
     RPCServerSignals::OnStopped(&OnRPCStopped);
     if (!InitHTTPServer(config)) {
         return false;
     }
 
     StartRPC();
 
     if (!StartHTTPRPC(config, httpRPCRequestProcessor)) {
         return false;
     }
     if (gArgs.GetBoolArg("-rest", DEFAULT_REST_ENABLE)) {
         StartREST();
     }
 
     StartHTTPServer();
     return true;
 }
 
 // Parameter interaction based on rules
 void InitParameterInteraction() {
     // when specifying an explicit binding address, you want to listen on it
     // even when -connect or -proxy is specified.
     if (gArgs.IsArgSet("-bind")) {
         if (gArgs.SoftSetBoolArg("-listen", true)) {
             LogPrintf(
                 "%s: parameter interaction: -bind set -> setting -listen=1\n",
                 __func__);
         }
     }
     if (gArgs.IsArgSet("-whitebind")) {
         if (gArgs.SoftSetBoolArg("-listen", true)) {
             LogPrintf("%s: parameter interaction: -whitebind set -> setting "
                       "-listen=1\n",
                       __func__);
         }
     }
 
     if (gArgs.IsArgSet("-connect")) {
         // when only connecting to trusted nodes, do not seed via DNS, or listen
         // by default.
         if (gArgs.SoftSetBoolArg("-dnsseed", false)) {
             LogPrintf("%s: parameter interaction: -connect set -> setting "
                       "-dnsseed=0\n",
                       __func__);
         }
         if (gArgs.SoftSetBoolArg("-listen", false)) {
             LogPrintf("%s: parameter interaction: -connect set -> setting "
                       "-listen=0\n",
                       __func__);
         }
     }
 
     if (gArgs.IsArgSet("-proxy")) {
         // to protect privacy, do not listen by default if a default proxy
         // server is specified.
         if (gArgs.SoftSetBoolArg("-listen", false)) {
             LogPrintf(
                 "%s: parameter interaction: -proxy set -> setting -listen=0\n",
                 __func__);
         }
         // to protect privacy, do not use UPNP 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 (gArgs.SoftSetBoolArg("-upnp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -proxy set -> setting -upnp=0\n",
                 __func__);
         }
         // to protect privacy, do not discover addresses by default
         if (gArgs.SoftSetBoolArg("-discover", false)) {
             LogPrintf("%s: parameter interaction: -proxy set -> setting "
                       "-discover=0\n",
                       __func__);
         }
     }
 
     if (!gArgs.GetBoolArg("-listen", DEFAULT_LISTEN)) {
         // do not map ports or try to retrieve public IP when not listening
         // (pointless)
         if (gArgs.SoftSetBoolArg("-upnp", false)) {
             LogPrintf(
                 "%s: parameter interaction: -listen=0 -> setting -upnp=0\n",
                 __func__);
         }
         if (gArgs.SoftSetBoolArg("-discover", false)) {
             LogPrintf(
                 "%s: parameter interaction: -listen=0 -> setting -discover=0\n",
                 __func__);
         }
         if (gArgs.SoftSetBoolArg("-listenonion", false)) {
             LogPrintf("%s: parameter interaction: -listen=0 -> setting "
                       "-listenonion=0\n",
                       __func__);
         }
     }
 
     if (gArgs.IsArgSet("-externalip")) {
         // if an explicit public IP is specified, do not try to find others
         if (gArgs.SoftSetBoolArg("-discover", false)) {
             LogPrintf("%s: parameter interaction: -externalip set -> setting "
                       "-discover=0\n",
                       __func__);
         }
     }
 
     // disable whitelistrelay in blocksonly mode
     if (gArgs.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY)) {
         if (gArgs.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 (gArgs.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY)) {
         if (gArgs.SoftSetBoolArg("-whitelistrelay", true)) {
             LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> "
                       "setting -whitelistrelay=1\n",
                       __func__);
         }
     }
 }
 
 static std::string ResolveErrMsg(const char *const optname,
                                  const std::string &strBind) {
     return strprintf(_("Cannot resolve -%s address: '%s'"), optname, strBind);
 }
 
 /**
  * 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() {
     LogInstance().m_print_to_file = !gArgs.IsArgNegated("-debuglogfile");
     LogInstance().m_file_path = AbsPathForConfigVal(
         gArgs.GetArg("-debuglogfile", DEFAULT_DEBUGLOGFILE));
 
     LogInstance().m_print_to_console = gArgs.GetBoolArg(
         "-printtoconsole", !gArgs.GetBoolArg("-daemon", false));
     LogInstance().m_log_timestamps =
         gArgs.GetBoolArg("-logtimestamps", DEFAULT_LOGTIMESTAMPS);
     LogInstance().m_log_time_micros =
         gArgs.GetBoolArg("-logtimemicros", DEFAULT_LOGTIMEMICROS);
     LogInstance().m_log_threadnames =
         gArgs.GetBoolArg("-logthreadnames", DEFAULT_LOGTHREADNAMES);
 
     fLogIPs = gArgs.GetBoolArg("-logips", DEFAULT_LOGIPS);
 
     std::string version_string = FormatFullVersion();
 #ifdef DEBUG
     version_string += " (debug build)";
 #else
     version_string += " (release build)";
 #endif
     LogPrintf("%s version %s\n", CLIENT_NAME, version_string);
 }
 
 namespace { // Variables internal to initialization process only
 
 int nMaxConnections;
 int nUserMaxConnections;
 int nFD;
 ServiceFlags nLocalServices = ServiceFlags(NODE_NETWORK | NODE_NETWORK_LIMITED);
 } // 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() {
 // 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)
 // Minimum supported OS versions: WinXP SP3, WinVista >= SP1, Win Server 2008
 // A failure is non-critical and needs no further attention!
 #ifndef PROCESS_DEP_ENABLE
 // We define this here, because GCCs winbase.h limits this to _WIN32_WINNT >=
 // 0x0601 (Windows 7), which is not correct. Can be removed, when GCCs winbase.h
 // is fixed!
 #define PROCESS_DEP_ENABLE 0x00000001
 #endif
     typedef BOOL(WINAPI * PSETPROCDEPPOL)(DWORD);
     PSETPROCDEPPOL setProcDEPPol = (PSETPROCDEPPOL)GetProcAddress(
         GetModuleHandleA("Kernel32.dll"), "SetProcessDEPPolicy");
     if (setProcDEPPol != nullptr) {
         setProcDEPPol(PROCESS_DEP_ENABLE);
     }
 #endif
 
     if (!SetupNetworking()) {
         return InitError("Initializing networking failed");
     }
 
 #ifndef WIN32
     if (!gArgs.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 CChainParams &chainparams = config.GetChainParams();
     // Step 2: parameter interactions
 
     // also see: InitParameterInteraction()
 
     // Warn 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 = gArgs.GetChainName();
     for (const auto &arg : gArgs.GetUnsuitableSectionOnlyArgs()) {
         return InitError(strprintf(_("Config setting for %s only applied on %s "
                                      "network when in [%s] section."),
                                    arg, network, network));
     }
 
     // Warn if unrecognized section name are present in the config file.
     for (const auto &section : gArgs.GetUnrecognizedSections()) {
         InitWarning(strprintf("%s:%i " + _("Section [%s] is not recognized."),
                               section.m_file, section.m_line, section.m_name));
     }
 
     if (!fs::is_directory(GetBlocksDir())) {
         return InitError(
             strprintf(_("Specified blocks directory \"%s\" does not exist."),
                       gArgs.GetArg("-blocksdir", "").c_str()));
     }
 
     // if using block pruning, then disallow txindex
     if (gArgs.GetArg("-prune", 0)) {
         if (gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
             return InitError(_("Prune mode is incompatible with -txindex."));
         }
     }
 
     // -bind and -whitebind can't be set when not listening
     size_t nUserBind =
         gArgs.GetArgs("-bind").size() + gArgs.GetArgs("-whitebind").size();
     if (nUserBind != 0 && !gArgs.GetBoolArg("-listen", DEFAULT_LISTEN)) {
         return InitError(
             "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 =
         gArgs.GetArg("-maxconnections", DEFAULT_MAX_PEER_CONNECTIONS);
     nMaxConnections = std::max(nUserMaxConnections, 0);
 
     // Trim requested connection counts, to fit into system limitations
     nMaxConnections =
         std::max(std::min(nMaxConnections, FD_SETSIZE - nBind -
                                                MIN_CORE_FILEDESCRIPTORS -
                                                MAX_ADDNODE_CONNECTIONS),
                  0);
     nFD = RaiseFileDescriptorLimit(nMaxConnections + MIN_CORE_FILEDESCRIPTORS +
                                    MAX_ADDNODE_CONNECTIONS);
     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) {
         InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, "
                                 "because of system limitations."),
                               nUserMaxConnections, nMaxConnections));
     }
 
     // Step 3: parameter-to-internal-flags
     if (gArgs.IsArgSet("-debug")) {
         // Special-case: if -debug=0/-nodebug is set, turn off debugging
         // messages
         const std::vector<std::string> &categories = gArgs.GetArgs("-debug");
         if (std::none_of(
                 categories.begin(), categories.end(),
                 [](std::string cat) { return cat == "0" || cat == "none"; })) {
             for (const auto &cat : categories) {
                 if (!LogInstance().EnableCategory(cat)) {
                     InitWarning(
                         strprintf(_("Unsupported logging category %s=%s."),
                                   "-debug", cat));
                 }
             }
         }
     }
 
     // Now remove the logging categories which were explicitly excluded
     for (const std::string &cat : gArgs.GetArgs("-debugexclude")) {
         if (!LogInstance().DisableCategory(cat)) {
             InitWarning(strprintf(_("Unsupported logging category %s=%s."),
                                   "-debugexclude", cat));
         }
     }
 
     // Checkmempool and checkblockindex default to true in regtest mode
     int ratio = std::min<int>(
         std::max<int>(
             gArgs.GetArg("-checkmempool",
                          chainparams.DefaultConsistencyChecks() ? 1 : 0),
             0),
         1000000);
     if (ratio != 0) {
         g_mempool.setSanityCheck(1.0 / ratio);
     }
     fCheckBlockIndex = gArgs.GetBoolArg("-checkblockindex",
                                         chainparams.DefaultConsistencyChecks());
     fCheckpointsEnabled =
         gArgs.GetBoolArg("-checkpoints", DEFAULT_CHECKPOINTS_ENABLED);
     if (fCheckpointsEnabled) {
         LogPrintf("Checkpoints will be verified.\n");
     } else {
         LogPrintf("Skipping checkpoint verification.\n");
     }
 
     hashAssumeValid = BlockHash::fromHex(
         gArgs.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 (gArgs.IsArgSet("-minimumchainwork")) {
         const std::string minChainWorkStr =
             gArgs.GetArg("-minimumchainwork", "");
         if (!IsHexNumber(minChainWorkStr)) {
             return InitError(strprintf(
                 "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 =
         gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     int64_t nMempoolSizeMin =
         gArgs.GetArg("-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)));
     }
 
     // -par=0 means autodetect, but nScriptCheckThreads==0 means no concurrency
     nScriptCheckThreads = gArgs.GetArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
     if (nScriptCheckThreads <= 0) {
         nScriptCheckThreads += GetNumCores();
     }
     if (nScriptCheckThreads <= 1) {
         nScriptCheckThreads = 0;
     } else if (nScriptCheckThreads > MAX_SCRIPTCHECK_THREADS) {
         nScriptCheckThreads = MAX_SCRIPTCHECK_THREADS;
     }
 
     // Configure excessive block size.
     const uint64_t nProposedExcessiveBlockSize =
         gArgs.GetArg("-excessiveblocksize", DEFAULT_MAX_BLOCK_SIZE);
     if (!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 uint64_t nProposedMaxGeneratedBlockSize =
         gArgs.GetArg("-blockmaxsize", DEFAULT_MAX_GENERATED_BLOCK_SIZE);
     if (nProposedMaxGeneratedBlockSize > config.GetMaxBlockSize()) {
         auto msg = _("Max generated block size (blockmaxsize) cannot exceed "
                      "the excessive block size (excessiveblocksize)");
         return InitError(msg);
     }
 
     // block pruning; get the amount of disk space (in MiB) to allot for block &
     // undo files
     int64_t nPruneArg = gArgs.GetArg("-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 %uMiB on disk for block and undo "
                   "files.\n",
                   nPruneTarget / 1024 / 1024);
         fPruneMode = true;
     }
 
     nConnectTimeout = gArgs.GetArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
     if (nConnectTimeout <= 0) {
         nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;
     }
 
     // Obtain the amount to charge excess UTXO
     if (gArgs.IsArgSet("-excessutxocharge")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(gArgs.GetArg("-excessutxocharge", ""), n);
         if (!parsed || Amount::zero() > n) {
             return InitError(AmountErrMsg(
                 "excessutxocharge", gArgs.GetArg("-excessutxocharge", "")));
         }
         config.SetExcessUTXOCharge(n);
     } else {
         config.SetExcessUTXOCharge(DEFAULT_UTXO_FEE);
     }
 
     if (gArgs.IsArgSet("-minrelaytxfee")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(gArgs.GetArg("-minrelaytxfee", ""), n);
         if (!parsed || n == Amount::zero()) {
             return InitError(AmountErrMsg("minrelaytxfee",
                                           gArgs.GetArg("-minrelaytxfee", "")));
         }
         // High fee check is done afterward in WalletParameterInteraction()
         ::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 (gArgs.IsArgSet("-blockmintxfee")) {
         Amount n = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-blockmintxfee", ""), n)) {
             return InitError(AmountErrMsg("blockmintxfee",
                                           gArgs.GetArg("-blockmintxfee", "")));
         }
     }
 
     // Feerate used to define dust.  Shouldn't be changed lightly as old
     // implementations may inadvertently create non-standard transactions.
     if (gArgs.IsArgSet("-dustrelayfee")) {
         Amount n = Amount::zero();
         auto parsed = ParseMoney(gArgs.GetArg("-dustrelayfee", ""), n);
         if (!parsed || Amount::zero() == n) {
             return InitError(AmountErrMsg("dustrelayfee",
                                           gArgs.GetArg("-dustrelayfee", "")));
         }
         dustRelayFee = CFeeRate(n);
     }
 
     fRequireStandard =
         !gArgs.GetBoolArg("-acceptnonstdtxn", !chainparams.RequireStandard());
     if (!chainparams.IsTestChain() && !fRequireStandard) {
         return InitError(
             strprintf("acceptnonstdtxn is not currently supported for %s chain",
                       chainparams.NetworkIDString()));
     }
     nBytesPerSigOp = gArgs.GetArg("-bytespersigop", nBytesPerSigOp);
 
     if (!g_wallet_init_interface.ParameterInteraction()) {
         return false;
     }
 
     fIsBareMultisigStd =
         gArgs.GetBoolArg("-permitbaremultisig", DEFAULT_PERMIT_BAREMULTISIG);
     fAcceptDatacarrier =
         gArgs.GetBoolArg("-datacarrier", DEFAULT_ACCEPT_DATACARRIER);
 
     // Option to startup with mocktime set (used for regression testing):
     SetMockTime(gArgs.GetArg("-mocktime", 0)); // SetMockTime(0) is a no-op
 
     if (gArgs.GetBoolArg("-peerbloomfilters", DEFAULT_PEERBLOOMFILTERS)) {
         nLocalServices = ServiceFlags(nLocalServices | NODE_BLOOM);
     }
 
     // Signal Bitcoin Cash support.
     // TODO: remove some time after the hardfork when no longer needed
     // to differentiate the network nodes.
     nLocalServices = ServiceFlags(nLocalServices | NODE_BITCOIN_CASH);
 
     nMaxTipAge = gArgs.GetArg("-maxtipage", DEFAULT_MAX_TIP_AGE);
 
     return true;
 }
 
 static bool LockDataDirectory(bool probeOnly) {
     // Make sure only a single Bitcoin process is using the data directory.
     fs::path datadir = GetDataDir();
     if (!DirIsWritable(datadir)) {
         return InitError(strprintf(
             _("Cannot write to data directory '%s'; check permissions."),
             datadir.string()));
     }
     if (!LockDirectory(datadir, ".lock", probeOnly)) {
         return InitError(strprintf(_("Cannot obtain a lock on data directory "
                                      "%s. %s is probably already running."),
-                                   datadir.string(), _(PACKAGE_NAME)));
+                                   datadir.string(), PACKAGE_NAME));
     }
     return true;
 }
 
 bool AppInitSanityChecks() {
     // Step 4: sanity checks
 
     // Initialize elliptic curve code
     std::string sha256_algo = SHA256AutoDetect();
     LogPrintf("Using the '%s' SHA256 implementation\n", sha256_algo);
     RandomInit();
     ECC_Start();
     globalVerifyHandle.reset(new ECCVerifyHandle());
 
     // Sanity check
     if (!InitSanityCheck()) {
         return InitError(strprintf(
             _("Initialization sanity check failed. %s is shutting down."),
-            _(PACKAGE_NAME)));
+            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 AppInitMain(Config &config, RPCServer &rpcServer,
                  HTTPRPCRequestProcessor &httpRPCRequestProcessor,
                  InitInterfaces &interfaces) {
     // Step 4a: application initialization
     const CChainParams &chainparams = config.GetChainParams();
 
     if (!CreatePidFile()) {
         // Detailed error printed inside CreatePidFile().
         return false;
     }
 
     BCLog::Logger &logger = LogInstance();
     if (logger.m_print_to_file) {
         if (gArgs.GetBoolArg("-shrinkdebugfile",
                              logger.DefaultShrinkDebugFile())) {
             // Do this first since it both loads a bunch of debug.log into
             // memory, and because this needs to happen before any other
             // debug.log printing.
             logger.ShrinkDebugFile();
         }
     }
 
     if (!logger.StartLogging()) {
         return InitError(strprintf("Could not open debug log file %s",
                                    logger.m_file_path.string()));
     }
 
     if (!logger.m_log_timestamps) {
         LogPrintf("Startup time: %s\n", FormatISO8601DateTime(GetTime()));
     }
     LogPrintf("Default data directory %s\n", GetDefaultDataDir().string());
     LogPrintf("Using data directory %s\n", GetDataDir().string());
     LogPrintf(
         "Using config file %s\n",
         GetConfigFile(gArgs.GetArg("-conf", BITCOIN_CONF_FILENAME)).string());
     LogPrintf("Using at most %i automatic connections (%i file descriptors "
               "available)\n",
               nMaxConnections, nFD);
 
     // Warn about relative -datadir path.
     if (gArgs.IsArgSet("-datadir") &&
         !fs::path(gArgs.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",
                   gArgs.GetArg("-datadir", ""), fs::current_path().string());
     }
 
     InitSignatureCache();
     InitScriptExecutionCache();
 
     LogPrintf("Using %u threads for script verification\n",
               nScriptCheckThreads);
     if (nScriptCheckThreads) {
         for (int i = 0; i < nScriptCheckThreads - 1; i++) {
             threadGroup.create_thread([i]() { return ThreadScriptCheck(i); });
         }
     }
 
     // Start the lightweight task scheduler thread
     CScheduler::Function serviceLoop =
         std::bind(&CScheduler::serviceQueue, &scheduler);
     threadGroup.create_thread(std::bind(&TraceThread<CScheduler::Function>,
                                         "scheduler", serviceLoop));
 
     GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
     GetMainSignals().RegisterWithMempoolSignals(g_mempool);
 
     // 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(interfaces);
 
     /**
      * 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 : interfaces.chain_clients) {
         client->registerRpcs();
     }
     g_rpc_interfaces = &interfaces;
 #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 (gArgs.GetBoolArg("-server", false)) {
         uiInterface.InitMessage_connect(SetRPCWarmupStatus);
         if (!AppInitServers(config, httpRPCRequestProcessor)) {
             return InitError(
                 _("Unable to start HTTP server. See debug log for details."));
         }
     }
 
     // Step 5: verify wallet database integrity
     for (const auto &client : interfaces.chain_clients) {
         if (!client->verify(chainparams)) {
             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.
 
     assert(!g_banman);
     g_banman = std::make_unique<BanMan>(
         GetDataDir() / "banlist.dat", config.GetChainParams(), &uiInterface,
         gArgs.GetArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
     assert(!g_connman);
     g_connman = std::make_unique<CConnman>(
         config, GetRand(std::numeric_limits<uint64_t>::max()),
         GetRand(std::numeric_limits<uint64_t>::max()));
 
     peerLogic = std::make_unique<PeerLogicValidation>(
         g_connman.get(), g_banman.get(), scheduler,
         gArgs.GetBoolArg("-enablebip61", DEFAULT_ENABLE_BIP61));
     RegisterValidationInterface(peerLogic.get());
 
     // sanitize comments per BIP-0014, format user agent and check total size
     std::vector<std::string> uacomments;
     for (const std::string &cmt : gArgs.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 strSubVersion =
         FormatSubVersion(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 (gArgs.IsArgSet("-onlynet")) {
         std::set<enum Network> nets;
         for (const std::string &snet : gArgs.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 = gArgs.GetBoolArg("-dns", DEFAULT_NAME_LOOKUP);
 
     bool proxyRandomize =
         gArgs.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 = gArgs.GetArg("-proxy", "");
     SetReachable(NET_ONION, false);
     if (proxyArg != "" && proxyArg != "0") {
         CService proxyAddr;
         if (!Lookup(proxyArg.c_str(), 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 = gArgs.GetArg("-onion", "");
     if (onionArg != "") {
         if (onionArg == "0") {
             // Handle -noonion/-onion=0
             SetReachable(NET_ONION, false);
         } else {
             CService onionProxy;
             if (!Lookup(onionArg.c_str(), 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);
         }
     }
 
     // see Step 2: parameter interactions for more information about these
     fListen = gArgs.GetBoolArg("-listen", DEFAULT_LISTEN);
     fDiscover = gArgs.GetBoolArg("-discover", true);
     fRelayTxes = !gArgs.GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY);
 
     for (const std::string &strAddr : gArgs.GetArgs("-externalip")) {
         CService addrLocal;
         if (Lookup(strAddr.c_str(), 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
     // unlimited unless -maxuploadtarget is set
     uint64_t nMaxOutboundLimit = 0;
     uint64_t nMaxOutboundTimeframe = MAX_UPLOAD_TIMEFRAME;
 
     if (gArgs.IsArgSet("-maxuploadtarget")) {
         nMaxOutboundLimit =
             gArgs.GetArg("-maxuploadtarget", DEFAULT_MAX_UPLOAD_TARGET) * 1024 *
             1024;
     }
 
     // Step 6.5 (I guess ?): Initialize Avalanche.
     g_avalanche = std::make_unique<AvalancheProcessor>(g_connman.get());
 
     // Step 7: load block chain
 
     fReindex = gArgs.GetBoolArg("-reindex", false);
     bool fReindexChainState = gArgs.GetBoolArg("-reindex-chainstate", false);
 
     // cache size calculations
     int64_t nTotalCache = (gArgs.GetArg("-dbcache", nDefaultDbCache) << 20);
     // total cache cannot be less than nMinDbCache
     nTotalCache = std::max(nTotalCache, nMinDbCache << 20);
     // total cache cannot be greater than nMaxDbcache
     nTotalCache = std::min(nTotalCache, nMaxDbCache << 20);
     int64_t nBlockTreeDBCache =
         std::min(nTotalCache / 8, nMaxBlockDBCache << 20);
     nTotalCache -= nBlockTreeDBCache;
     int64_t nTxIndexCache =
         std::min(nTotalCache / 8, gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)
                                       ? nMaxTxIndexCache << 20
                                       : 0);
     nTotalCache -= nTxIndexCache;
     // use 25%-50% of the remainder for disk cache
     int64_t nCoinDBCache =
         std::min(nTotalCache / 2, (nTotalCache / 4) + (1 << 23));
     // cap total coins db cache
     nCoinDBCache = std::min(nCoinDBCache, nMaxCoinsDBCache << 20);
     nTotalCache -= nCoinDBCache;
     // the rest goes to in-memory cache
     nCoinCacheUsage = nTotalCache;
     int64_t nMempoolSizeMax =
         gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
     LogPrintf("Cache configuration:\n");
     LogPrintf("* Using %.1fMiB for block index database\n",
               nBlockTreeDBCache * (1.0 / 1024 / 1024));
     if (gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         LogPrintf("* Using %.1fMiB for transaction index database\n",
                   nTxIndexCache * (1.0 / 1024 / 1024));
     }
     LogPrintf("* Using %.1fMiB for chain state database\n",
               nCoinDBCache * (1.0 / 1024 / 1024));
     LogPrintf("* Using %.1fMiB for in-memory UTXO set (plus up to %.1fMiB of "
               "unused mempool space)\n",
               nCoinCacheUsage * (1.0 / 1024 / 1024),
               nMempoolSizeMax * (1.0 / 1024 / 1024));
 
     int64_t nStart = 0;
     bool fLoaded = false;
     while (!fLoaded && !ShutdownRequested()) {
         bool fReset = fReindex;
         std::string strLoadError;
 
         uiInterface.InitMessage(_("Loading block index..."));
         nStart = GetTimeMillis();
         do {
             try {
                 LOCK(cs_main);
                 UnloadBlockIndex();
                 pcoinsTip.reset();
                 pcoinsdbview.reset();
                 pcoinscatcher.reset();
                 pblocktree.reset(
                     new CBlockTreeDB(nBlockTreeDBCache, false, fReset));
 
                 if (fReset) {
                     pblocktree->WriteReindexing(true);
                     // If we're reindexing in prune mode, wipe away unusable
                     // block files and all undo data files
                     if (fPruneMode) {
                         CleanupBlockRevFiles();
                     }
                 }
 
                 if (ShutdownRequested()) {
                     break;
                 }
 
                 // LoadBlockIndex will load fHavePruned if we've ever removed a
                 // block file from disk.
                 // Note that it also sets fReindex based on the disk flag!
                 // From here on out fReindex and fReset mean something
                 // different!
                 if (!LoadBlockIndex(config)) {
                     strLoadError = _("Error loading block database");
                     break;
                 }
 
                 // If the loaded chain has a wrong genesis, bail out immediately
                 // (we're likely using a testnet datadir, or the other way
                 // around).
                 if (!mapBlockIndex.empty() &&
                     !LookupBlockIndex(
                         chainparams.GetConsensus().hashGenesisBlock)) {
                     return InitError(_("Incorrect or no genesis block found. "
                                        "Wrong datadir for network?"));
                 }
 
                 // Check for changed -prune state.  What we are concerned about
                 // is a user who has pruned blocks in the past, but is now
                 // trying to run unpruned.
                 if (fHavePruned && !fPruneMode) {
                     strLoadError =
                         _("You need to rebuild the database using -reindex to "
                           "go back to unpruned mode.  This will redownload the "
                           "entire blockchain");
                     break;
                 }
 
                 // At this point blocktree args are consistent with what's on
                 // disk. If we're not mid-reindex (based on disk + args), add a
                 // genesis block on disk (otherwise we use the one already on
                 // disk).
                 // This is called again in ThreadImport after the reindex
                 // completes.
                 if (!fReindex && !LoadGenesisBlock(chainparams)) {
                     strLoadError = _("Error initializing block database");
                     break;
                 }
 
                 // At this point we're either in reindex or we've loaded a
                 // useful block tree into mapBlockIndex!
 
                 pcoinsdbview.reset(new CCoinsViewDB(
                     nCoinDBCache, false, fReset || fReindexChainState));
                 pcoinscatcher.reset(
                     new CCoinsViewErrorCatcher(pcoinsdbview.get()));
 
                 // If necessary, upgrade from older database format.
                 // This is a no-op if we cleared the coinsviewdb with -reindex
                 // or -reindex-chainstate
                 if (!pcoinsdbview->Upgrade()) {
                     strLoadError = _("Error upgrading chainstate database");
                     break;
                 }
 
                 // ReplayBlocks is a no-op if we cleared the coinsviewdb with
                 // -reindex or -reindex-chainstate
                 if (!ReplayBlocks(chainparams.GetConsensus(),
                                   pcoinsdbview.get())) {
                     strLoadError =
                         _("Unable to replay blocks. You will need to rebuild "
                           "the database using -reindex-chainstate.");
                     break;
                 }
 
                 // The on-disk coinsdb is now in a good state, create the cache
                 pcoinsTip.reset(new CCoinsViewCache(pcoinscatcher.get()));
 
                 bool is_coinsview_empty = fReset || fReindexChainState ||
                                           pcoinsTip->GetBestBlock().IsNull();
                 if (!is_coinsview_empty) {
                     // LoadChainTip sets ::ChainActive() based on pcoinsTip's
                     // best block
                     if (!LoadChainTip(config)) {
                         strLoadError = _("Error initializing block database");
                         break;
                     }
                     assert(::ChainActive().Tip() != nullptr);
 
                     uiInterface.InitMessage(_("Verifying blocks..."));
                     if (fHavePruned &&
                         gArgs.GetArg("-checkblocks", DEFAULT_CHECKBLOCKS) >
                             MIN_BLOCKS_TO_KEEP) {
                         LogPrintf(
                             "Prune: pruned datadir may not have more than %d "
                             "blocks; only checking available blocks\n",
                             MIN_BLOCKS_TO_KEEP);
                     }
 
                     CBlockIndex *tip = ::ChainActive().Tip();
                     RPCNotifyBlockChange(true, tip);
                     if (tip && tip->nTime >
                                    GetAdjustedTime() + MAX_FUTURE_BLOCK_TIME) {
                         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;
                     }
 
                     if (!CVerifyDB().VerifyDB(
                             config, pcoinsdbview.get(),
                             gArgs.GetArg("-checklevel", DEFAULT_CHECKLEVEL),
                             gArgs.GetArg("-checkblocks",
                                          DEFAULT_CHECKBLOCKS))) {
                         strLoadError = _("Corrupted block database detected");
                         break;
                     }
                 }
             } catch (const std::exception &e) {
                 LogPrintf("%s\n", e.what());
                 strLoadError = _("Error opening block database");
                 break;
             }
 
             fLoaded = true;
         } while (false);
 
         if (!fLoaded && !ShutdownRequested()) {
             // first suggest a reindex
             if (!fReset) {
                 bool fRet = uiInterface.ThreadSafeQuestion(
                     strLoadError + ".\n\n" +
                         _("Do you want to rebuild the block database now?"),
                     strLoadError + ".\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;
     }
     if (fLoaded) {
         LogPrintf(" block index %15dms\n", GetTimeMillis() - nStart);
     }
 
     // Encoded addresses using cashaddr instead of base58.
     // We do this by default to avoid confusion with BTC addresses.
     config.SetCashAddrEncoding(gArgs.GetBoolArg("-usecashaddr", true));
 
     // Step 8: load indexers
     if (gArgs.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {
         g_txindex = std::make_unique<TxIndex>(nTxIndexCache, false, fReindex);
         g_txindex->Start();
     }
 
     // Step 9: load wallet
     for (const auto &client : interfaces.chain_clients) {
         if (!client->load(chainparams)) {
             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) {
             uiInterface.InitMessage(_("Pruning blockstore..."));
             PruneAndFlush();
         }
     }
 
     // Step 11: import blocks
     if (!CheckDiskSpace(GetDataDir())) {
         InitError(
             strprintf(_("Error: Disk space is low for %s"), GetDataDir()));
         return false;
     }
     if (!CheckDiskSpace(GetBlocksDir())) {
         InitError(
             strprintf(_("Error: Disk space is low for %s"), GetBlocksDir()));
         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.
     if (::ChainActive().Tip() == nullptr) {
         uiInterface.NotifyBlockTip_connect(BlockNotifyGenesisWait);
     } else {
         fHaveGenesis = true;
     }
 
     if (gArgs.IsArgSet("-blocknotify")) {
         uiInterface.NotifyBlockTip_connect(BlockNotifyCallback);
     }
 
     std::vector<fs::path> vImportFiles;
     for (const std::string &strFile : gArgs.GetArgs("-loadblock")) {
         vImportFiles.push_back(strFile);
     }
 
     threadGroup.create_thread(
         std::bind(&ThreadImport, std::ref(config), vImportFiles));
 
     // 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));
         }
         uiInterface.NotifyBlockTip_disconnect(BlockNotifyGenesisWait);
     }
 
     if (ShutdownRequested()) {
         return false;
     }
 
     // Step 12: start node
 
     int chain_active_height;
 
     //// debug print
     {
         LOCK(cs_main);
         LogPrintf("mapBlockIndex.size() = %u\n", mapBlockIndex.size());
         chain_active_height = ::ChainActive().Height();
     }
     LogPrintf("nBestHeight = %d\n", chain_active_height);
 
     if (gArgs.GetBoolArg("-listenonion", DEFAULT_LISTEN_ONION)) {
         StartTorControl();
     }
 
     Discover();
 
     // Map ports with UPnP
     if (gArgs.GetBoolArg("-upnp", DEFAULT_UPNP)) {
         StartMapPort();
     }
 
     CConnman::Options connOptions;
     connOptions.nLocalServices = nLocalServices;
     connOptions.nMaxConnections = nMaxConnections;
     connOptions.nMaxOutbound =
         std::min(MAX_OUTBOUND_CONNECTIONS, connOptions.nMaxConnections);
     connOptions.nMaxAddnode = MAX_ADDNODE_CONNECTIONS;
     connOptions.nMaxFeeler = 1;
     connOptions.nBestHeight = chain_active_height;
     connOptions.uiInterface = &uiInterface;
     connOptions.m_banman = g_banman.get();
     connOptions.m_msgproc = peerLogic.get();
     connOptions.nSendBufferMaxSize =
         1000 * gArgs.GetArg("-maxsendbuffer", DEFAULT_MAXSENDBUFFER);
     connOptions.nReceiveFloodSize =
         1000 * gArgs.GetArg("-maxreceivebuffer", DEFAULT_MAXRECEIVEBUFFER);
     connOptions.m_added_nodes = gArgs.GetArgs("-addnode");
 
     connOptions.nMaxOutboundTimeframe = nMaxOutboundTimeframe;
     connOptions.nMaxOutboundLimit = nMaxOutboundLimit;
 
     for (const std::string &strBind : gArgs.GetArgs("-bind")) {
         CService addrBind;
         if (!Lookup(strBind.c_str(), addrBind, GetListenPort(), false)) {
             return InitError(ResolveErrMsg("bind", strBind));
         }
         connOptions.vBinds.push_back(addrBind);
     }
 
     for (const std::string &strBind : gArgs.GetArgs("-whitebind")) {
         CService addrBind;
         if (!Lookup(strBind.c_str(), addrBind, 0, false)) {
             return InitError(ResolveErrMsg("whitebind", strBind));
         }
         if (addrBind.GetPort() == 0) {
             return InitError(strprintf(
                 _("Need to specify a port with -whitebind: '%s'"), strBind));
         }
         connOptions.vWhiteBinds.push_back(addrBind);
     }
 
     for (const auto &net : gArgs.GetArgs("-whitelist")) {
         CSubNet subnet;
         LookupSubNet(net.c_str(), subnet);
         if (!subnet.IsValid()) {
             return InitError(strprintf(
                 _("Invalid netmask specified in -whitelist: '%s'"), net));
         }
         connOptions.vWhitelistedRange.push_back(subnet);
     }
 
     connOptions.vSeedNodes = gArgs.GetArgs("-seednode");
 
     // Initiate outbound connections unless connect=0
     connOptions.m_use_addrman_outgoing = !gArgs.IsArgSet("-connect");
     if (!connOptions.m_use_addrman_outgoing) {
         const auto connect = gArgs.GetArgs("-connect");
         if (connect.size() != 1 || connect[0] != "0") {
             connOptions.m_specified_outgoing = connect;
         }
     }
     if (!g_connman->Start(scheduler, connOptions)) {
         return false;
     }
 
     // Step 13: finished
 
     SetRPCWarmupFinished();
     uiInterface.InitMessage(_("Done loading"));
 
     for (const auto &client : interfaces.chain_clients) {
         client->start(scheduler);
     }
 
     scheduler.scheduleEvery(
         [] {
             g_banman->DumpBanlist();
             return true;
         },
         DUMP_BANS_INTERVAL * 1000);
 
     // Start Avalanche's event loop.
     g_avalanche->startEventLoop(scheduler);
 
     return true;
 }
diff --git a/src/net.cpp b/src/net.cpp
index a717a4157..6e14892b8 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -1,2842 +1,2842 @@
 // 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.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <net.h>
 
 #include <banman.h>
 #include <chainparams.h>
 #include <clientversion.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <crypto/common.h>
 #include <crypto/sha256.h>
 #include <hash.h>
 #include <netbase.h>
 #include <primitives/transaction.h>
 #include <scheduler.h>
 #include <ui_interface.h>
 #include <util/strencodings.h>
 
 #ifdef WIN32
 #include <cstring>
 #else
 #include <fcntl.h>
 #endif
 
 #ifdef USE_UPNP
 #include <miniupnpc/miniupnpc.h>
 #include <miniupnpc/miniwget.h>
 #include <miniupnpc/upnpcommands.h>
 #include <miniupnpc/upnperrors.h>
 #endif
 
 #include <cmath>
 
 // Dump addresses to peers.dat every 15 minutes (900s)
 static constexpr int DUMP_PEERS_INTERVAL = 15 * 60;
 
 // We add a random period time (0 to 1 seconds) to feeler connections to prevent
 // synchronization.
 #define FEELER_SLEEP_WINDOW 1
 
 // MSG_NOSIGNAL is not available on some platforms, if it doesn't exist define
 // it as 0
 #if !defined(MSG_NOSIGNAL)
 #define MSG_NOSIGNAL 0
 #endif
 
 // MSG_DONTWAIT is not available on some platforms, if it doesn't exist define
 // it as 0
 #if !defined(MSG_DONTWAIT)
 #define MSG_DONTWAIT 0
 #endif
 
 // Fix for ancient MinGW versions, that don't have defined these in ws2tcpip.h.
 // Todo: Can be removed when our pull-tester is upgraded to a modern MinGW
 // version.
 #ifdef WIN32
 #ifndef PROTECTION_LEVEL_UNRESTRICTED
 #define PROTECTION_LEVEL_UNRESTRICTED 10
 #endif
 #ifndef IPV6_PROTECTION_LEVEL
 #define IPV6_PROTECTION_LEVEL 23
 #endif
 #endif
 
 /** Used to pass flags to the Bind() function */
 enum BindFlags {
     BF_NONE = 0,
     BF_EXPLICIT = (1U << 0),
     BF_REPORT_ERROR = (1U << 1),
     BF_WHITELIST = (1U << 2),
 };
 
 const static 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;
 //
 // Global state variables
 //
 bool fDiscover = true;
 bool fListen = true;
 bool fRelayTxes = true;
 CCriticalSection cs_mapLocalHost;
 std::map<CNetAddr, LocalServiceInfo> mapLocalHost GUARDED_BY(cs_mapLocalHost);
 static bool vfLimited[NET_MAX] GUARDED_BY(cs_mapLocalHost) = {};
 
 void CConnman::AddOneShot(const std::string &strDest) {
     LOCK(cs_vOneShots);
     vOneShots.push_back(strDest);
 }
 
 unsigned short GetListenPort() {
     return (unsigned short)(gArgs.GetArg("-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(cs_mapLocalHost);
         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(cs_mapLocalHost);
     if (mapLocalHost.count(addr) == LOCAL_NONE) {
         return 0;
     }
     return mapLocalHost[addr].nScore;
 }
 
 // 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());
 }
 
 // Pushes our own address to a peer.
 void AdvertiseLocal(CNode *pnode) {
     if (fListen && pnode->fSuccessfullyConnected) {
         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, "AdvertiseLocal: advertising address %s\n",
                      addrLocal.ToString());
             pnode->PushAddress(addrLocal, rng);
         }
     }
 }
 
 // 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(cs_mapLocalHost);
         bool fAlready = mapLocalHost.count(addr) > 0;
         LocalServiceInfo &info = mapLocalHost[addr];
         if (!fAlready || nScore >= info.nScore) {
             info.nScore = nScore + (fAlready ? 1 : 0);
             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(cs_mapLocalHost);
     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(cs_mapLocalHost);
     vfLimited[net] = !reachable;
 }
 
 bool IsReachable(enum Network net) {
     LOCK(cs_mapLocalHost);
     return !vfLimited[net];
 }
 
 bool IsReachable(const CNetAddr &addr) {
     return IsReachable(addr.GetNetwork());
 }
 
 /** vote for a local address */
 bool SeenLocal(const CService &addr) {
     LOCK(cs_mapLocalHost);
     if (mapLocalHost.count(addr) == 0) {
         return false;
     }
     mapLocalHost[addr].nScore++;
     return true;
 }
 
 /** check whether a given address is potentially local */
 bool IsLocal(const CService &addr) {
     LOCK(cs_mapLocalHost);
     return mapLocalHost.count(addr) > 0;
 }
 
 CNode *CConnman::FindNode(const CNetAddr &ip) {
     LOCK(cs_vNodes);
     for (CNode *pnode : vNodes) {
         if (static_cast<CNetAddr>(pnode->addr) == ip) {
             return pnode;
         }
     }
     return nullptr;
 }
 
 CNode *CConnman::FindNode(const CSubNet &subNet) {
     LOCK(cs_vNodes);
     for (CNode *pnode : vNodes) {
         if (subNet.Match(static_cast<CNetAddr>(pnode->addr))) {
             return pnode;
         }
     }
     return nullptr;
 }
 
 CNode *CConnman::FindNode(const std::string &addrName) {
     LOCK(cs_vNodes);
     for (CNode *pnode : vNodes) {
         if (pnode->GetAddrName() == addrName) {
             return pnode;
         }
     }
     return nullptr;
 }
 
 CNode *CConnman::FindNode(const CService &addr) {
     LOCK(cs_vNodes);
     for (CNode *pnode : vNodes) {
         if (static_cast<CService>(pnode->addr) == addr) {
             return pnode;
         }
     }
     return nullptr;
 }
 
 bool CConnman::CheckIncomingNonce(uint64_t nonce) {
     LOCK(cs_vNodes);
     for (const CNode *pnode : vNodes) {
         if (!pnode->fSuccessfullyConnected && !pnode->fInbound &&
             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, bool manual_connection) {
     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 int default_port = 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, and return the existing CNode instead. Also store
             // the name we used to connect in that CNode, so that future
             // FindNode() calls to that name catch this early.
             LOCK(cs_vNodes);
             CNode *pnode = FindNode(static_cast<CService>(addrConnect));
             if (pnode) {
                 pnode->MaybeSetAddrName(std::string(pszDest));
                 LogPrintf("Failed to open new connection, already connected\n");
                 return nullptr;
             }
         }
     }
 
     // Connect
     bool connected = false;
     SOCKET hSocket = INVALID_SOCKET;
     proxyType proxy;
     if (addrConnect.IsValid()) {
         bool proxyConnectionFailed = false;
 
         if (GetProxy(addrConnect.GetNetwork(), proxy)) {
             hSocket = CreateSocket(proxy.proxy);
             if (hSocket == INVALID_SOCKET) {
                 return nullptr;
             }
             connected = ConnectThroughProxy(
                 proxy, addrConnect.ToStringIP(), addrConnect.GetPort(), hSocket,
                 nConnectTimeout, &proxyConnectionFailed);
         } else {
             // no proxy needed (none set for target network)
             hSocket = CreateSocket(addrConnect);
             if (hSocket == INVALID_SOCKET) {
                 return nullptr;
             }
             connected = ConnectSocketDirectly(
                 addrConnect, hSocket, nConnectTimeout, manual_connection);
         }
         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)) {
         hSocket = CreateSocket(proxy.proxy);
         if (hSocket == INVALID_SOCKET) {
             return nullptr;
         }
         std::string host;
         int port = default_port;
         SplitHostPort(std::string(pszDest), port, host);
         connected = ConnectThroughProxy(proxy, host, port, hSocket,
                                         nConnectTimeout, nullptr);
     }
     if (!connected) {
         CloseSocket(hSocket);
         return nullptr;
     }
 
     // Add node
     NodeId id = GetNewNodeId();
     uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE)
                          .Write(id)
                          .Finalize();
     CAddress addr_bind = GetBindAddress(hSocket);
     CNode *pnode = new CNode(id, nLocalServices, GetBestHeight(), hSocket,
                              addrConnect, CalculateKeyedNetGroup(addrConnect),
                              nonce, addr_bind, pszDest ? pszDest : "", false);
     pnode->AddRef();
 
     return pnode;
 }
 
 void CNode::CloseSocketDisconnect() {
     fDisconnect = true;
     LOCK(cs_hSocket);
     if (hSocket != INVALID_SOCKET) {
         LogPrint(BCLog::NET, "disconnecting peer=%d\n", id);
         CloseSocket(hSocket);
     }
 }
 
 bool CConnman::IsWhitelistedRange(const CNetAddr &addr) {
     for (const CSubNet &subnet : vWhitelistedRange) {
         if (subnet.Match(addr)) {
             return true;
         }
     }
     return false;
 }
 
 std::string CNode::GetAddrName() const {
     LOCK(cs_addrName);
     return addrName;
 }
 
 void CNode::MaybeSetAddrName(const std::string &addrNameIn) {
     LOCK(cs_addrName);
     if (addrName.empty()) {
         addrName = addrNameIn;
     }
 }
 
 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;
     }
 }
 
 void CNode::copyStats(CNodeStats &stats) {
     stats.nodeid = this->GetId();
     stats.nServices = nServices;
     stats.addr = addr;
     stats.addrBind = addrBind;
     {
         LOCK(cs_filter);
         stats.fRelayTxes = fRelayTxes;
     }
     stats.nLastSend = nLastSend;
     stats.nLastRecv = nLastRecv;
     stats.nTimeConnected = nTimeConnected;
     stats.nTimeOffset = nTimeOffset;
     stats.addrName = GetAddrName();
     stats.nVersion = nVersion;
     {
         LOCK(cs_SubVer);
         stats.cleanSubVer = cleanSubVer;
     }
     stats.fInbound = fInbound;
     stats.m_manual_connection = m_manual_connection;
     stats.nStartingHeight = nStartingHeight;
     {
         LOCK(cs_vSend);
         stats.mapSendBytesPerMsgCmd = mapSendBytesPerMsgCmd;
         stats.nSendBytes = nSendBytes;
     }
     {
         LOCK(cs_vRecv);
         stats.mapRecvBytesPerMsgCmd = mapRecvBytesPerMsgCmd;
         stats.nRecvBytes = nRecvBytes;
     }
     stats.fWhitelisted = fWhitelisted;
     {
         LOCK(cs_feeFilter);
         stats.minFeeFilter = minFeeFilter;
     }
 
     // It is common for nodes with good ping times to suddenly become lagged,
     // due to a new block arriving or other large transfer. Merely reporting
     // pingtime might fool the caller into thinking the node was still
     // responsive, since pingtime does not update until the ping is complete,
     // which might take a while. So, if a ping is taking an unusually long time
     // in flight, the caller can immediately detect that this is happening.
     int64_t nPingUsecWait = 0;
     if ((0 != nPingNonceSent) && (0 != nPingUsecStart)) {
         nPingUsecWait = GetTimeMicros() - nPingUsecStart;
     }
 
     // Raw ping time is in microseconds, but show it to user as whole seconds
     // (Bitcoin users should be well used to small numbers with many decimal
     // places by now :)
     stats.dPingTime = ((double(nPingUsecTime)) / 1e6);
     stats.dMinPing = ((double(nMinPingUsecTime)) / 1e6);
     stats.dPingWait = ((double(nPingUsecWait)) / 1e6);
 
     // Leave string empty if addrLocal invalid (not filled in yet)
     CService addrLocalUnlocked = GetAddrLocal();
     stats.addrLocal =
         addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToString() : "";
 }
 
 static bool IsOversizedMessage(const Config &config, const CNetMessage &msg) {
     if (!msg.in_data) {
         // Header only, cannot be oversized.
         return false;
     }
 
     return msg.hdr.IsOversized(config);
 }
 
 bool CNode::ReceiveMsgBytes(const Config &config, const char *pch,
                             uint32_t nBytes, bool &complete) {
     complete = false;
     int64_t nTimeMicros = GetTimeMicros();
     LOCK(cs_vRecv);
     nLastRecv = nTimeMicros / 1000000;
     nRecvBytes += nBytes;
     while (nBytes > 0) {
         // Get current incomplete message, or create a new one.
         if (vRecvMsg.empty() || vRecvMsg.back().complete()) {
             vRecvMsg.push_back(CNetMessage(config.GetChainParams().NetMagic(),
                                            SER_NETWORK, INIT_PROTO_VERSION));
         }
 
         CNetMessage &msg = vRecvMsg.back();
 
         // Absorb network data.
         int handled;
         if (!msg.in_data) {
             handled = msg.readHeader(config, pch, nBytes);
         } else {
             handled = msg.readData(pch, nBytes);
         }
 
         if (handled < 0) {
             return false;
         }
 
         if (IsOversizedMessage(config, msg)) {
             LogPrint(BCLog::NET,
                      "Oversized message from peer=%i, disconnecting\n",
                      GetId());
             return false;
         }
 
         pch += handled;
         nBytes -= handled;
 
         if (msg.complete()) {
             // Store received bytes per message command to prevent a memory DOS,
             // only allow valid commands.
             mapMsgCmdSize::iterator i =
                 mapRecvBytesPerMsgCmd.find(msg.hdr.pchCommand.data());
             if (i == mapRecvBytesPerMsgCmd.end()) {
                 i = mapRecvBytesPerMsgCmd.find(NET_MESSAGE_COMMAND_OTHER);
             }
 
             assert(i != mapRecvBytesPerMsgCmd.end());
             i->second += msg.hdr.nMessageSize + CMessageHeader::HEADER_SIZE;
 
             msg.nTime = nTimeMicros;
             complete = true;
         }
     }
 
     return true;
 }
 
 void CNode::SetSendVersion(int nVersionIn) {
     // Send version may only be changed in the version message, and only one
     // version message is allowed per session. We can therefore treat this value
     // as const and even atomic as long as it's only used once a version message
     // has been successfully processed. Any attempt to set this twice is an
     // error.
     if (nSendVersion != 0) {
         error("Send version already set for node: %i. Refusing to change from "
               "%i to %i",
               id, nSendVersion, nVersionIn);
     } else {
         nSendVersion = nVersionIn;
     }
 }
 
 int CNode::GetSendVersion() const {
     // The send version should always be explicitly set to INIT_PROTO_VERSION
     // rather than using this value until SetSendVersion has been called.
     if (nSendVersion == 0) {
         error("Requesting unset send version for node: %i. Using %i", id,
               INIT_PROTO_VERSION);
         return INIT_PROTO_VERSION;
     }
     return nSendVersion;
 }
 
 int CNetMessage::readHeader(const Config &config, const char *pch,
                             uint32_t nBytes) {
     // copy data to temporary parsing buffer
     uint32_t nRemaining = 24 - nHdrPos;
     uint32_t nCopy = std::min(nRemaining, nBytes);
 
     memcpy(&hdrbuf[nHdrPos], pch, nCopy);
     nHdrPos += nCopy;
 
     // if header incomplete, exit
     if (nHdrPos < 24) {
         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 CNetMessage::readData(const char *pch, uint32_t nBytes) {
     unsigned int nRemaining = hdr.nMessageSize - nDataPos;
     unsigned int nCopy = std::min(nRemaining, nBytes);
 
     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((const uint8_t *)pch, nCopy);
     memcpy(&vRecv[nDataPos], pch, nCopy);
     nDataPos += nCopy;
 
     return nCopy;
 }
 
 const uint256 &CNetMessage::GetMessageHash() const {
     assert(complete());
     if (data_hash.IsNull()) {
         hasher.Finalize(data_hash.begin());
     }
     return data_hash;
 }
 
 size_t CConnman::SocketSendData(CNode *pnode) const
     EXCLUSIVE_LOCKS_REQUIRED(pnode->cs_vSend) {
     size_t nSentSize = 0;
     size_t nMsgCount = 0;
 
     for (const auto &data : pnode->vSendMsg) {
         assert(data.size() > pnode->nSendOffset);
         int nBytes = 0;
 
         {
             LOCK(pnode->cs_hSocket);
             if (pnode->hSocket == INVALID_SOCKET) {
                 break;
             }
 
             nBytes = send(pnode->hSocket,
                           reinterpret_cast<const char *>(data.data()) +
                               pnode->nSendOffset,
                           data.size() - pnode->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) {
                 LogPrintf("socket send error %s\n", NetworkErrorString(nErr));
                 pnode->CloseSocketDisconnect();
             }
 
             break;
         }
 
         assert(nBytes > 0);
         pnode->nLastSend = GetSystemTimeInSeconds();
         pnode->nSendBytes += nBytes;
         pnode->nSendOffset += nBytes;
         nSentSize += nBytes;
         if (pnode->nSendOffset != data.size()) {
             // could not send full message; stop sending more
             break;
         }
 
         pnode->nSendOffset = 0;
         pnode->nSendSize -= data.size();
         pnode->fPauseSend = pnode->nSendSize > nSendBufferMaxSize;
         nMsgCount++;
     }
 
     pnode->vSendMsg.erase(pnode->vSendMsg.begin(),
                           pnode->vSendMsg.begin() + nMsgCount);
 
     if (pnode->vSendMsg.empty()) {
         assert(pnode->nSendOffset == 0);
         assert(pnode->nSendSize == 0);
     }
 
     return nSentSize;
 }
 
 struct NodeEvictionCandidate {
     NodeId id;
     int64_t nTimeConnected;
     int64_t nMinPingUsecTime;
     int64_t nLastBlockTime;
     int64_t nLastTXTime;
     bool fRelevantServices;
     bool fRelayTxes;
     bool fBloomFilter;
     CAddress addr;
     uint64_t nKeyedNetGroup;
     bool prefer_evict;
 };
 
 static bool ReverseCompareNodeMinPingTime(const NodeEvictionCandidate &a,
                                           const NodeEvictionCandidate &b) {
     return a.nMinPingUsecTime > b.nMinPingUsecTime;
 }
 
 static bool ReverseCompareNodeTimeConnected(const NodeEvictionCandidate &a,
                                             const NodeEvictionCandidate &b) {
     return a.nTimeConnected > b.nTimeConnected;
 }
 
 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.nLastBlockTime != b.nLastBlockTime) {
         return a.nLastBlockTime < b.nLastBlockTime;
     }
 
     if (a.fRelevantServices != b.fRelevantServices) {
         return b.fRelevantServices;
     }
 
     return a.nTimeConnected > b.nTimeConnected;
 }
 
 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.nLastTXTime != b.nLastTXTime) {
         return a.nLastTXTime < b.nLastTXTime;
     }
 
     if (a.fRelayTxes != b.fRelayTxes) {
         return b.fRelayTxes;
     }
 
     if (a.fBloomFilter != b.fBloomFilter) {
         return a.fBloomFilter;
     }
 
     return a.nTimeConnected > b.nTimeConnected;
 }
 
 //! Sort an array by the specified comparator, then erase the last K elements.
 template <typename T, typename Comparator>
 static void EraseLastKElements(std::vector<T> &elements, Comparator comparator,
                                size_t k) {
     std::sort(elements.begin(), elements.end(), comparator);
     size_t eraseSize = std::min(k, elements.size());
     elements.erase(elements.end() - eraseSize, elements.end());
 }
 
 /**
  * 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(cs_vNodes);
 
         for (CNode *node : vNodes) {
             if (node->fWhitelisted || !node->fInbound || node->fDisconnect) {
                 continue;
             }
             LOCK(node->cs_filter);
             NodeEvictionCandidate candidate = {
                 node->GetId(),
                 node->nTimeConnected,
                 node->nMinPingUsecTime,
                 node->nLastBlockTime,
                 node->nLastTXTime,
                 HasAllDesirableServiceFlags(node->nServices),
                 node->fRelayTxes,
                 node->pfilter != nullptr,
                 node->addr,
                 node->nKeyedNetGroup,
                 node->m_prefer_evict};
             vEvictionCandidates.push_back(candidate);
         }
     }
 
     // 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 transactions.
     // An attacker cannot manipulate this metric without performing useful work.
     EraseLastKElements(vEvictionCandidates, CompareNodeTXTime, 4);
     // Protect 4 nodes that most recently sent us blocks.
     // An attacker cannot manipulate this metric without performing useful work.
     EraseLastKElements(vEvictionCandidates, CompareNodeBlockTime, 4);
     // 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.
     EraseLastKElements(vEvictionCandidates, ReverseCompareNodeTimeConnected,
                        vEvictionCandidates.size() / 2);
 
     if (vEvictionCandidates.empty()) {
         return false;
     }
 
     // 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;
     int64_t 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);
         int64_t grouptime = group[0].nTimeConnected;
         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
     NodeId evicted = vEvictionCandidates.front().id;
     LOCK(cs_vNodes);
     for (CNode *pnode : vNodes) {
         if (pnode->GetId() == evicted) {
             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;
     int nInbound = 0;
     int nMaxInbound = nMaxConnections - (nMaxOutbound + nMaxFeeler);
 
     if (hSocket != INVALID_SOCKET) {
         if (!addr.SetSockAddr((const struct sockaddr *)&sockaddr)) {
             LogPrintf("Warning: Unknown socket family\n");
         }
     }
 
     bool whitelisted = hListenSocket.whitelisted || IsWhitelistedRange(addr);
     {
         LOCK(cs_vNodes);
         for (const CNode *pnode : vNodes) {
             if (pnode->fInbound) {
                 nInbound++;
             }
         }
     }
 
     if (hSocket == INVALID_SOCKET) {
         int nErr = WSAGetLastError();
         if (nErr != WSAEWOULDBLOCK) {
             LogPrintf("socket error accept failed: %s\n",
                       NetworkErrorString(nErr));
         }
         return;
     }
 
     if (!fNetworkActive) {
         LogPrintf("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);
 
     int bannedlevel = m_banman ? m_banman->IsBannedLevel(addr) : 0;
 
     // Don't accept connections from banned peers, but if our inbound slots
     // aren't almost full, accept if the only banning reason was an automatic
     // misbehavior ban.
     if (!whitelisted && bannedlevel > ((nInbound + 1 < nMaxInbound) ? 1 : 0)) {
         LogPrint(BCLog::NET, "connection from %s dropped (banned)\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();
     CAddress addr_bind = GetBindAddress(hSocket);
 
     CNode *pnode =
         new CNode(id, nLocalServices, GetBestHeight(), hSocket, addr,
                   CalculateKeyedNetGroup(addr), nonce, addr_bind, "", true);
     pnode->AddRef();
     pnode->fWhitelisted = whitelisted;
 
     pnode->m_prefer_evict = bannedlevel > 0;
     m_msgproc->InitializeNode(*config, pnode);
 
     LogPrint(BCLog::NET, "connection from %s accepted\n", addr.ToString());
 
     {
         LOCK(cs_vNodes);
         vNodes.push_back(pnode);
     }
 }
 
 void CConnman::DisconnectNodes() {
     {
         LOCK(cs_vNodes);
 
         if (!fNetworkActive) {
             // Disconnect any connected nodes
             for (CNode *pnode : vNodes) {
                 if (!pnode->fDisconnect) {
                     LogPrint(BCLog::NET,
                              "Network not active, dropping peer=%d\n",
                              pnode->GetId());
                     pnode->fDisconnect = true;
                 }
             }
         }
 
         // Disconnect unused nodes
         std::vector<CNode *> vNodesCopy = vNodes;
         for (CNode *pnode : vNodesCopy) {
             if (pnode->fDisconnect) {
                 // remove from vNodes
                 vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode),
                              vNodes.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();
                 vNodesDisconnected.push_back(pnode);
             }
         }
     }
     {
         // Delete disconnected nodes
         std::list<CNode *> vNodesDisconnectedCopy = vNodesDisconnected;
         for (CNode *pnode : vNodesDisconnectedCopy) {
             // wait until threads are done using it
             if (pnode->GetRefCount() <= 0) {
                 bool fDelete = false;
                 {
                     TRY_LOCK(pnode->cs_inventory, lockInv);
                     if (lockInv) {
                         TRY_LOCK(pnode->cs_vSend, lockSend);
                         if (lockSend) {
                             fDelete = true;
                         }
                     }
                 }
                 if (fDelete) {
                     vNodesDisconnected.remove(pnode);
                     DeleteNode(pnode);
                 }
             }
         }
     }
 }
 
 void CConnman::NotifyNumConnectionsChanged() {
     size_t vNodesSize;
     {
         LOCK(cs_vNodes);
         vNodesSize = vNodes.size();
     }
     if (vNodesSize != nPrevNodeCount) {
         nPrevNodeCount = vNodesSize;
         if (clientInterface) {
             clientInterface->NotifyNumConnectionsChanged(vNodesSize);
         }
     }
 }
 
 void CConnman::InactivityCheck(CNode *pnode) {
     int64_t nTime = GetSystemTimeInSeconds();
     if (nTime - pnode->nTimeConnected > 60) {
         if (pnode->nLastRecv == 0 || pnode->nLastSend == 0) {
             LogPrint(BCLog::NET,
                      "socket no message in first 60 seconds, %d %d from %d\n",
                      pnode->nLastRecv != 0, pnode->nLastSend != 0,
                      pnode->GetId());
             pnode->fDisconnect = true;
         } else if (nTime - pnode->nLastSend > TIMEOUT_INTERVAL) {
             LogPrintf("socket sending timeout: %is\n",
                       nTime - pnode->nLastSend);
             pnode->fDisconnect = true;
         } else if (nTime - pnode->nLastRecv > (pnode->nVersion > BIP0031_VERSION
                                                    ? TIMEOUT_INTERVAL
                                                    : 90 * 60)) {
             LogPrintf("socket receive timeout: %is\n",
                       nTime - pnode->nLastRecv);
             pnode->fDisconnect = true;
         } else if (pnode->nPingNonceSent &&
                    pnode->nPingUsecStart + TIMEOUT_INTERVAL * 1000000 <
                        GetTimeMicros()) {
             LogPrintf("ping timeout: %fs\n",
                       0.000001 * (GetTimeMicros() - pnode->nPingUsecStart));
             pnode->fDisconnect = true;
         } else if (!pnode->fSuccessfullyConnected) {
             LogPrint(BCLog::NET, "version handshake timeout from %d\n",
                      pnode->GetId());
             pnode->fDisconnect = true;
         }
     }
 }
 
 void CConnman::SocketHandler() {
     //
     // Find which sockets have data to receive
     //
     struct timeval timeout;
     timeout.tv_sec = 0;
     // Frequency to poll pnode->vSend
     timeout.tv_usec = 50000;
 
     fd_set fdsetRecv;
     fd_set fdsetSend;
     fd_set fdsetError;
     FD_ZERO(&fdsetRecv);
     FD_ZERO(&fdsetSend);
     FD_ZERO(&fdsetError);
     SOCKET hSocketMax = 0;
     bool have_fds = false;
 
     for (const ListenSocket &hListenSocket : vhListenSocket) {
         FD_SET(hListenSocket.socket, &fdsetRecv);
         hSocketMax = std::max(hSocketMax, hListenSocket.socket);
         have_fds = true;
     }
 
     {
         LOCK(cs_vNodes);
         for (CNode *pnode : vNodes) {
             // 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;
             }
 
             FD_SET(pnode->hSocket, &fdsetError);
             hSocketMax = std::max(hSocketMax, pnode->hSocket);
             have_fds = true;
 
             if (select_send) {
                 FD_SET(pnode->hSocket, &fdsetSend);
                 continue;
             }
             if (select_recv) {
                 FD_SET(pnode->hSocket, &fdsetRecv);
             }
         }
     }
 
     int nSelect = select(have_fds ? hSocketMax + 1 : 0, &fdsetRecv, &fdsetSend,
                          &fdsetError, &timeout);
     if (interruptNet) {
         return;
     }
 
     if (nSelect == SOCKET_ERROR) {
         if (have_fds) {
             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(timeout.tv_usec / 1000))) {
             return;
         }
     }
 
     //
     // Accept new connections
     //
     for (const ListenSocket &hListenSocket : vhListenSocket) {
         if (hListenSocket.socket != INVALID_SOCKET &&
             FD_ISSET(hListenSocket.socket, &fdsetRecv)) {
             AcceptConnection(hListenSocket);
         }
     }
 
     //
     // Service each socket
     //
     std::vector<CNode *> vNodesCopy;
     {
         LOCK(cs_vNodes);
         vNodesCopy = vNodes;
         for (CNode *pnode : vNodesCopy) {
             pnode->AddRef();
         }
     }
     for (CNode *pnode : vNodesCopy) {
         if (interruptNet) {
             return;
         }
 
         //
         // Receive
         //
         bool recvSet = false;
         bool sendSet = false;
         bool errorSet = false;
         {
             LOCK(pnode->cs_hSocket);
             if (pnode->hSocket == INVALID_SOCKET) {
                 continue;
             }
             recvSet = FD_ISSET(pnode->hSocket, &fdsetRecv);
             sendSet = FD_ISSET(pnode->hSocket, &fdsetSend);
             errorSet = FD_ISSET(pnode->hSocket, &fdsetError);
         }
         if (recvSet || errorSet) {
             // typical socket buffer is 8K-64K
             char pchBuf[0x10000];
             int32_t nBytes = 0;
             {
                 LOCK(pnode->cs_hSocket);
                 if (pnode->hSocket == INVALID_SOCKET) {
                     continue;
                 }
                 nBytes =
                     recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
             }
             if (nBytes > 0) {
                 bool notify = false;
                 if (!pnode->ReceiveMsgBytes(*config, pchBuf, nBytes, notify)) {
                     pnode->CloseSocketDisconnect();
                 }
                 RecordBytesRecv(nBytes);
                 if (notify) {
                     size_t nSizeAdded = 0;
                     auto it(pnode->vRecvMsg.begin());
                     for (; it != pnode->vRecvMsg.end(); ++it) {
                         if (!it->complete()) {
                             break;
                         }
                         nSizeAdded +=
                             it->vRecv.size() + CMessageHeader::HEADER_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\n");
                 }
                 pnode->CloseSocketDisconnect();
             } else if (nBytes < 0) {
                 // error
                 int nErr = WSAGetLastError();
                 if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE &&
                     nErr != WSAEINTR && nErr != WSAEINPROGRESS) {
                     if (!pnode->fDisconnect) {
                         LogPrintf("socket recv error %s\n",
                                   NetworkErrorString(nErr));
                     }
                     pnode->CloseSocketDisconnect();
                 }
             }
         }
 
         //
         // Send
         //
         if (sendSet) {
             LOCK(pnode->cs_vSend);
             size_t nBytes = SocketSendData(pnode);
             if (nBytes) {
                 RecordBytesSent(nBytes);
             }
         }
 
         InactivityCheck(pnode);
     }
     {
         LOCK(cs_vNodes);
         for (CNode *pnode : vNodesCopy) {
             pnode->Release();
         }
     }
 }
 
 void CConnman::ThreadSocketHandler() {
     while (!interruptNet) {
         DisconnectNodes();
         NotifyNumConnectionsChanged();
         SocketHandler();
     }
 }
 
 void CConnman::WakeMessageHandler() {
     {
         std::lock_guard<std::mutex> lock(mutexMsgProc);
         fMsgProcWake = true;
     }
     condMsgProc.notify_one();
 }
 
 #ifdef USE_UPNP
 static CThreadInterrupt g_upnp_interrupt;
 static std::thread g_upnp_thread;
 static void ThreadMapPort() {
     std::string port = strprintf("%u", GetListenPort());
     const char *multicastif = nullptr;
     const char *minissdpdpath = nullptr;
     struct UPNPDev *devlist = nullptr;
     char lanaddr[64];
 
 #ifndef UPNPDISCOVER_SUCCESS
     /* miniupnpc 1.5 */
     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
 #elif MINIUPNPC_API_VERSION < 14
     /* miniupnpc 1.6 */
     int error = 0;
     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
 #else
     /* miniupnpc 1.9.20150730 */
     int error = 0;
     devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, 2, &error);
 #endif
 
     struct UPNPUrls urls;
     struct IGDdatas data;
     int r;
 
     r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
     if (r == 1) {
         if (fDiscover) {
             char externalIPAddress[40];
             r = UPNP_GetExternalIPAddress(
                 urls.controlURL, data.first.servicetype, externalIPAddress);
             if (r != UPNPCOMMAND_SUCCESS) {
                 LogPrintf("UPnP: GetExternalIPAddress() returned %d\n", r);
             } else {
                 if (externalIPAddress[0]) {
                     CNetAddr resolved;
                     if (LookupHost(externalIPAddress, resolved, false)) {
                         LogPrintf("UPnP: ExternalIPAddress = %s\n",
                                   resolved.ToString().c_str());
                         AddLocal(resolved, LOCAL_UPNP);
                     }
                 } else {
                     LogPrintf("UPnP: GetExternalIPAddress failed.\n");
                 }
             }
         }
 
         std::string strDesc = "Bitcoin " + FormatFullVersion();
 
         do {
 #ifndef UPNPDISCOVER_SUCCESS
             /* miniupnpc 1.5 */
             r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
                                     port.c_str(), port.c_str(), lanaddr,
                                     strDesc.c_str(), "TCP", 0);
 #else
             /* miniupnpc 1.6 */
             r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
                                     port.c_str(), port.c_str(), lanaddr,
                                     strDesc.c_str(), "TCP", 0, "0");
 #endif
 
             if (r != UPNPCOMMAND_SUCCESS) {
                 LogPrintf(
                     "AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
                     port, port, lanaddr, r, strupnperror(r));
             } else {
                 LogPrintf("UPnP Port Mapping successful.\n");
             }
         } while (g_upnp_interrupt.sleep_for(std::chrono::minutes(20)));
 
         r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype,
                                    port.c_str(), "TCP", 0);
         LogPrintf("UPNP_DeletePortMapping() returned: %d\n", r);
         freeUPNPDevlist(devlist);
         devlist = nullptr;
         FreeUPNPUrls(&urls);
     } else {
         LogPrintf("No valid UPnP IGDs found\n");
         freeUPNPDevlist(devlist);
         devlist = nullptr;
         if (r != 0) {
             FreeUPNPUrls(&urls);
         }
     }
 }
 
 void StartMapPort() {
     if (!g_upnp_thread.joinable()) {
         assert(!g_upnp_interrupt);
         g_upnp_thread = std::thread(
             (std::bind(&TraceThread<void (*)()>, "upnp", &ThreadMapPort)));
     }
 }
 
 void InterruptMapPort() {
     if (g_upnp_thread.joinable()) {
         g_upnp_interrupt();
     }
 }
 
 void StopMapPort() {
     if (g_upnp_thread.joinable()) {
         g_upnp_thread.join();
         g_upnp_interrupt.reset();
     }
 }
 
 #else
 void StartMapPort() {
     // Intentionally left blank.
 }
 void InterruptMapPort() {
     // Intentionally left blank.
 }
 void StopMapPort() {
     // Intentionally left blank.
 }
 #endif
 
 void CConnman::ThreadDNSAddressSeed() {
     // goal: only query DNS seeds if address need is acute.
     // Avoiding DNS seeds when we don't need them 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.
     if ((addrman.size() > 0) &&
         (!gArgs.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED))) {
         if (!interruptNet.sleep_for(std::chrono::seconds(11))) {
             return;
         }
 
         LOCK(cs_vNodes);
         int nRelevant = 0;
         for (const CNode *pnode : vNodes) {
             nRelevant += pnode->fSuccessfullyConnected && !pnode->fFeeler &&
                          !pnode->fOneShot && !pnode->m_manual_connection &&
                          !pnode->fInbound;
         }
         if (nRelevant >= 2) {
             LogPrintf("P2P peers available. Skipped DNS seeding.\n");
             return;
         }
     }
 
     const std::vector<std::string> &vSeeds =
         config->GetChainParams().DNSSeeds();
     int found = 0;
 
     LogPrintf("Loading addresses from DNS seeds (could take a while)\n");
 
     for (const std::string &seed : vSeeds) {
         if (interruptNet) {
             return;
         }
         if (HaveNameProxy()) {
             AddOneShot(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.c_str(), 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 - GetRand(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
                 // oneshot to get nodes with our desired service bits.
                 AddOneShot(seed);
             }
         }
     }
 
     LogPrintf("%d addresses found from DNS seeds\n", found);
 }
 
 void CConnman::DumpAddresses() {
     int64_t nStart = GetTimeMillis();
 
     CAddrDB adb(config->GetChainParams());
     adb.Write(addrman);
 
     LogPrint(BCLog::NET, "Flushed %d addresses to peers.dat  %dms\n",
              addrman.size(), GetTimeMillis() - nStart);
 }
 
 void CConnman::ProcessOneShot() {
     std::string strDest;
     {
         LOCK(cs_vOneShots);
         if (vOneShots.empty()) {
             return;
         }
         strDest = vOneShots.front();
         vOneShots.pop_front();
     }
     CAddress addr;
     CSemaphoreGrant grant(*semOutbound, true);
     if (grant) {
         OpenNetworkConnection(addr, false, &grant, strDest.c_str(), true);
     }
 }
 
 bool CConnman::GetTryNewOutboundPeer() {
     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 one-shots and feelers).
 // 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::GetExtraOutboundCount() {
     int nOutbound = 0;
     {
         LOCK(cs_vNodes);
         for (const CNode *pnode : vNodes) {
             if (!pnode->fInbound && !pnode->m_manual_connection &&
                 !pnode->fFeeler && !pnode->fDisconnect && !pnode->fOneShot &&
                 pnode->fSuccessfullyConnected) {
                 ++nOutbound;
             }
         }
     }
     return std::max(nOutbound - nMaxOutbound, 0);
 }
 
 void CConnman::ThreadOpenConnections(const std::vector<std::string> connect) {
     // Connect to specific addresses
     if (!connect.empty()) {
         for (int64_t nLoop = 0;; nLoop++) {
             ProcessOneShot();
             for (const std::string &strAddr : connect) {
                 CAddress addr(CService(), NODE_NONE);
                 OpenNetworkConnection(addr, false, nullptr, strAddr.c_str(),
                                       false, false, true);
                 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
     int64_t nStart = GetTime();
 
     // Minimum time before next feeler connection (in microseconds).
     int64_t nNextFeeler =
         PoissonNextSend(nStart * 1000 * 1000, FEELER_INTERVAL);
     while (!interruptNet) {
         ProcessOneShot();
 
         if (!interruptNet.sleep_for(std::chrono::milliseconds(500))) {
             return;
         }
 
         CSemaphoreGrant grant(*semOutbound);
         if (interruptNet) {
             return;
         }
 
         // Add seed nodes if DNS seeds are all down (an infrastructure attack?).
         if (addrman.size() == 0 && (GetTime() - nStart > 60)) {
             static bool done = false;
             if (!done) {
                 LogPrintf("Adding fixed seed nodes as DNS doesn't seem to be "
                           "available.\n");
                 CNetAddr local;
                 local.SetInternal("fixedseeds");
                 addrman.Add(convertSeed6(config->GetChainParams().FixedSeeds()),
                             local);
                 done = true;
             }
         }
 
         //
         // 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 nOutbound = 0;
         std::set<std::vector<uint8_t>> setConnected;
         {
             LOCK(cs_vNodes);
             for (const CNode *pnode : vNodes) {
                 if (!pnode->fInbound && !pnode->m_manual_connection) {
                     // Netgroups for inbound and addnode 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 addnode peers do not use our outbound slots. Inbound
                     // peers also have the added issue that they're attacker
                     // controlled and could be used to prevent us from
                     // connecting to particular hosts if we used them here.
                     setConnected.insert(pnode->addr.GetGroup());
                     nOutbound++;
                 }
             }
         }
 
         // Feeler Connections
         //
         // Design goals:
         //  * Increase the number of connectable addresses in the tried table.
         //
         // Method:
         //  * Choose a random address from new and attempt to connect to it if
         //    we can connect successfully it is added to tried.
         //  * Start attempting feeler connections only after node finishes
         //    making outbound connections.
         //  * Only make a feeler connection once every few minutes.
         //
         bool fFeeler = false;
 
         if (nOutbound >= nMaxOutbound && !GetTryNewOutboundPeer()) {
             // The current time right now (in microseconds).
             int64_t nTime = GetTimeMicros();
             if (nTime > nNextFeeler) {
                 nNextFeeler = PoissonNextSend(nTime, FEELER_INTERVAL);
                 fFeeler = true;
             } else {
                 continue;
             }
         }
 
         addrman.ResolveCollisions();
 
         int64_t nANow = GetAdjustedTime();
         int nTries = 0;
         while (!interruptNet) {
             CAddrInfo addr = addrman.SelectTriedCollision();
 
             // SelectTriedCollision returns an invalid address if it is empty.
             if (!fFeeler || !addr.IsValid()) {
                 addr = addrman.Select(fFeeler);
             }
 
             // if we selected an invalid address, restart
             if (!addr.IsValid() || setConnected.count(addr.GetGroup()) ||
                 IsLocal(addr)) {
                 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;
             }
 
             if (!IsReachable(addr)) {
                 continue;
             }
 
             // only consider very recently tried nodes after 30 failed attempts
             if (nANow - addr.nLastTry < 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 allow non-default ports, unless after 50 invalid addresses
             // selected already.
             if (addr.GetPort() != config->GetChainParams().GetDefaultPort() &&
                 nTries < 50) {
                 continue;
             }
 
             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());
             }
 
             OpenNetworkConnection(addrConnect,
                                   (int)setConnected.size() >=
                                       std::min(nMaxConnections - 1, 2),
                                   &grant, nullptr, false, fFeeler);
         }
     }
 }
 
 std::vector<AddedNodeInfo> CConnman::GetAddedNodeInfo() {
     std::vector<AddedNodeInfo> ret;
 
     std::list<std::string> lAddresses(0);
     {
         LOCK(cs_vAddedNodes);
         ret.reserve(vAddedNodes.size());
         std::copy(vAddedNodes.cbegin(), vAddedNodes.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(cs_vNodes);
         for (const CNode *pnode : vNodes) {
             if (pnode->addr.IsValid()) {
                 mapConnected[pnode->addr] = pnode->fInbound;
             }
             std::string addrName = pnode->GetAddrName();
             if (!addrName.empty()) {
                 mapConnectedByName[std::move(addrName)] =
                     std::make_pair(pnode->fInbound,
                                    static_cast<const CService &>(pnode->addr));
             }
         }
     }
 
     for (const std::string &strAddNode : lAddresses) {
         CService service(
             LookupNumeric(strAddNode.c_str(), Params().GetDefaultPort()));
         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(), false, false,
                                       true);
                 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, bool fOneShot,
                                      bool fFeeler, bool manual_connection) {
     //
     // Initiate outbound network connection
     //
     if (interruptNet) {
         return;
     }
     if (!fNetworkActive) {
         return;
     }
     if (!pszDest) {
         if (IsLocal(addrConnect) ||
             FindNode(static_cast<CNetAddr>(addrConnect)) ||
             (m_banman && m_banman->IsBanned(addrConnect)) ||
             FindNode(addrConnect.ToStringIPPort())) {
             return;
         }
     } else if (FindNode(std::string(pszDest))) {
         return;
     }
 
     CNode *pnode =
         ConnectNode(addrConnect, pszDest, fCountFailure, manual_connection);
 
     if (!pnode) {
         return;
     }
     if (grantOutbound) {
         grantOutbound->MoveTo(pnode->grantOutbound);
     }
     if (fOneShot) {
         pnode->fOneShot = true;
     }
     if (fFeeler) {
         pnode->fFeeler = true;
     }
     if (manual_connection) {
         pnode->m_manual_connection = true;
     }
 
     m_msgproc->InitializeNode(*config, pnode);
     {
         LOCK(cs_vNodes);
         vNodes.push_back(pnode);
     }
 }
 
 void CConnman::ThreadMessageHandler() {
     while (!flagInterruptMsgProc) {
         std::vector<CNode *> vNodesCopy;
         {
             LOCK(cs_vNodes);
             vNodesCopy = vNodes;
             for (CNode *pnode : vNodesCopy) {
                 pnode->AddRef();
             }
         }
 
         bool fMoreWork = false;
 
         for (CNode *pnode : vNodesCopy) {
             if (pnode->fDisconnect) {
                 continue;
             }
 
             // Receive messages
             bool fMoreNodeWork = m_msgproc->ProcessMessages(
                 *config, pnode, flagInterruptMsgProc);
             fMoreWork |= (fMoreNodeWork && !pnode->fPauseSend);
             if (flagInterruptMsgProc) {
                 return;
             }
 
             // Send messages
             {
                 LOCK(pnode->cs_sendProcessing);
                 m_msgproc->SendMessages(*config, pnode, flagInterruptMsgProc);
             }
 
             if (flagInterruptMsgProc) {
                 return;
             }
         }
 
         {
             LOCK(cs_vNodes);
             for (CNode *pnode : vNodesCopy) {
                 pnode->Release();
             }
         }
 
         WAIT_LOCK(mutexMsgProc, lock);
         if (!fMoreWork) {
             condMsgProc.wait_until(lock,
                                    std::chrono::steady_clock::now() +
                                        std::chrono::milliseconds(100),
                                    [this] { return fMsgProcWake; });
         }
         fMsgProcWake = false;
     }
 }
 
 bool CConnman::BindListenPort(const CService &addrBind, std::string &strError,
                               bool fWhitelisted) {
     strError = "";
     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("Error: Bind address family for %s not supported",
                              addrBind.ToString());
         LogPrintf("%s\n", strError);
         return false;
     }
 
     SOCKET hListenSocket = CreateSocket(addrBind);
     if (hListenSocket == INVALID_SOCKET) {
         strError = strprintf("Error: Couldn't open socket for incoming "
                              "connections (socket returned error %s)",
                              NetworkErrorString(WSAGetLastError()));
         LogPrintf("%s\n", strError);
         return false;
     }
 
     // Allow binding if the port is still in TIME_WAIT state after
     // the program was closed and restarted.
     setsockopt(hListenSocket, 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(hListenSocket, IPPROTO_IPV6, IPV6_V6ONLY,
                    (sockopt_arg_type)&nOne, sizeof(int));
 #endif
 #ifdef WIN32
         int nProtLevel = PROTECTION_LEVEL_UNRESTRICTED;
         setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_PROTECTION_LEVEL,
                    (sockopt_arg_type)&nProtLevel, sizeof(int));
 #endif
     }
 
     if (::bind(hListenSocket, (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));
+                                 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);
         CloseSocket(hListenSocket);
         return false;
     }
     LogPrintf("Bound to %s\n", addrBind.ToString());
 
     // Listen for incoming connections
     if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR) {
         strError = strprintf(_("Error: Listening for incoming connections "
                                "failed (listen returned error %s)"),
                              NetworkErrorString(WSAGetLastError()));
         LogPrintf("%s\n", strError);
         CloseSocket(hListenSocket);
         return false;
     }
 
     vhListenSocket.push_back(ListenSocket(hListenSocket, fWhitelisted));
 
     if (addrBind.IsRoutable() && fDiscover && !fWhitelisted) {
         AddLocal(addrBind, LOCAL_BIND);
     }
 
     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) {
     LogPrint(BCLog::NET, "SetNetworkActive: %s\n", active);
 
     if (fNetworkActive == active) {
         return;
     }
 
     fNetworkActive = active;
     uiInterface.NotifyNetworkActiveChanged(fNetworkActive);
 }
 
 CConnman::CConnman(const Config &configIn, uint64_t nSeed0In, uint64_t nSeed1In)
     : config(&configIn), nSeed0(nSeed0In), nSeed1(nSeed1In) {
     SetTryNewOutboundPeer(false);
 
     Options connOptions;
     Init(connOptions);
 }
 
 NodeId CConnman::GetNewNodeId() {
     return nLastNodeId.fetch_add(1);
 }
 
 bool CConnman::Bind(const CService &addr, unsigned int flags) {
     if (!(flags & BF_EXPLICIT) && !IsReachable(addr)) {
         return false;
     }
     std::string strError;
     if (!BindListenPort(addr, strError, (flags & BF_WHITELIST) != 0)) {
         if ((flags & BF_REPORT_ERROR) && clientInterface) {
             clientInterface->ThreadSafeMessageBox(
                 strError, "", CClientUIInterface::MSG_ERROR);
         }
         return false;
     }
     return true;
 }
 
 bool CConnman::InitBinds(const std::vector<CService> &binds,
                          const std::vector<CService> &whiteBinds) {
     bool fBound = false;
     for (const auto &addrBind : binds) {
         fBound |= Bind(addrBind, (BF_EXPLICIT | BF_REPORT_ERROR));
     }
     for (const auto &addrBind : whiteBinds) {
         fBound |=
             Bind(addrBind, (BF_EXPLICIT | BF_REPORT_ERROR | BF_WHITELIST));
     }
     if (binds.empty() && whiteBinds.empty()) {
         struct in_addr inaddr_any;
         inaddr_any.s_addr = INADDR_ANY;
         struct in6_addr inaddr6_any = IN6ADDR_ANY_INIT;
         fBound |= Bind(CService(inaddr6_any, GetListenPort()), BF_NONE);
         fBound |= Bind(CService(inaddr_any, GetListenPort()),
                        !fBound ? BF_REPORT_ERROR : BF_NONE);
     }
     return fBound;
 }
 
 bool CConnman::Start(CScheduler &scheduler, const Options &connOptions) {
     Init(connOptions);
 
     {
         LOCK(cs_totalBytesRecv);
         nTotalBytesRecv = 0;
     }
     {
         LOCK(cs_totalBytesSent);
         nTotalBytesSent = 0;
         nMaxOutboundTotalBytesSentInCycle = 0;
         nMaxOutboundCycleStartTime = 0;
     }
 
     if (fListen && !InitBinds(connOptions.vBinds, connOptions.vWhiteBinds)) {
         if (clientInterface) {
             clientInterface->ThreadSafeMessageBox(
                 _("Failed to listen on any port. Use -listen=0 if you want "
                   "this."),
                 "", CClientUIInterface::MSG_ERROR);
         }
         return false;
     }
 
     for (const auto &strDest : connOptions.vSeedNodes) {
         AddOneShot(strDest);
     }
 
     if (clientInterface) {
         clientInterface->InitMessage(_("Loading P2P addresses..."));
     }
     // Load addresses from peers.dat
     int64_t nStart = GetTimeMillis();
     {
         CAddrDB adb(config->GetChainParams());
         if (adb.Read(addrman)) {
             LogPrintf("Loaded %i addresses from peers.dat  %dms\n",
                       addrman.size(), GetTimeMillis() - nStart);
         } else {
             // Addrman can be in an inconsistent state after failure, reset it
             addrman.Clear();
             LogPrintf("Invalid or missing peers.dat; recreating\n");
             DumpAddresses();
         }
     }
 
     uiInterface.InitMessage(_("Starting network threads..."));
 
     fAddressesInitialized = true;
 
     if (semOutbound == nullptr) {
         // initialize semaphore
         semOutbound = std::make_unique<CSemaphore>(
             std::min((nMaxOutbound + nMaxFeeler), nMaxConnections));
     }
     if (semAddnode == nullptr) {
         // initialize semaphore
         semAddnode = std::make_unique<CSemaphore>(nMaxAddnode);
     }
 
     //
     // Start threads
     //
     assert(m_msgproc);
     InterruptSocks5(false);
     interruptNet.reset();
     flagInterruptMsgProc = false;
 
     {
         LOCK(mutexMsgProc);
         fMsgProcWake = false;
     }
 
     // Send and receive from sockets, accept connections
     threadSocketHandler = std::thread(
         &TraceThread<std::function<void()>>, "net",
         std::function<void()>(std::bind(&CConnman::ThreadSocketHandler, this)));
 
     if (!gArgs.GetBoolArg("-dnsseed", true)) {
         LogPrintf("DNS seeding disabled\n");
     } else {
         threadDNSAddressSeed =
             std::thread(&TraceThread<std::function<void()>>, "dnsseed",
                         std::function<void()>(
                             std::bind(&CConnman::ThreadDNSAddressSeed, this)));
     }
 
     // Initiate outbound connections from -addnode
     threadOpenAddedConnections =
         std::thread(&TraceThread<std::function<void()>>, "addcon",
                     std::function<void()>(std::bind(
                         &CConnman::ThreadOpenAddedConnections, this)));
 
     if (connOptions.m_use_addrman_outgoing &&
         !connOptions.m_specified_outgoing.empty()) {
         if (clientInterface) {
             clientInterface->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(&TraceThread<std::function<void()>>, "opencon",
                         std::function<void()>(
                             std::bind(&CConnman::ThreadOpenConnections, this,
                                       connOptions.m_specified_outgoing)));
     }
 
     // Process messages
     threadMessageHandler =
         std::thread(&TraceThread<std::function<void()>>, "msghand",
                     std::function<void()>(
                         std::bind(&CConnman::ThreadMessageHandler, this)));
 
     // Dump network addresses
     scheduler.scheduleEvery(
         [this]() {
             this->DumpAddresses();
             return true;
         },
         DUMP_PEERS_INTERVAL * 1000);
 
     return true;
 }
 
 class CNetCleanup {
 public:
     CNetCleanup() {}
 
     ~CNetCleanup() {
 #ifdef WIN32
         // Shutdown Windows Sockets
         WSACleanup();
 #endif
     }
 } instance_of_cnetcleanup;
 
 void CConnman::Interrupt() {
     {
         std::lock_guard<std::mutex> lock(mutexMsgProc);
         flagInterruptMsgProc = true;
     }
     condMsgProc.notify_all();
 
     interruptNet();
     InterruptSocks5(true);
 
     if (semOutbound) {
         for (int i = 0; i < (nMaxOutbound + nMaxFeeler); i++) {
             semOutbound->post();
         }
     }
 
     if (semAddnode) {
         for (int i = 0; i < nMaxAddnode; i++) {
             semAddnode->post();
         }
     }
 }
 
 void CConnman::Stop() {
     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();
     }
 
     if (fAddressesInitialized) {
         DumpAddresses();
         fAddressesInitialized = false;
     }
 
     // Close sockets
     for (CNode *pnode : vNodes) {
         pnode->CloseSocketDisconnect();
     }
     for (ListenSocket &hListenSocket : vhListenSocket) {
         if (hListenSocket.socket != INVALID_SOCKET) {
             if (!CloseSocket(hListenSocket.socket)) {
                 LogPrintf("CloseSocket(hListenSocket) failed with error %s\n",
                           NetworkErrorString(WSAGetLastError()));
             }
         }
     }
 
     // clean up some globals (to help leak detection)
     for (CNode *pnode : vNodes) {
         DeleteNode(pnode);
     }
     for (CNode *pnode : vNodesDisconnected) {
         DeleteNode(pnode);
     }
     vNodes.clear();
     vNodesDisconnected.clear();
     vhListenSocket.clear();
     semOutbound.reset();
     semAddnode.reset();
 }
 
 void CConnman::DeleteNode(CNode *pnode) {
     assert(pnode);
     bool fUpdateConnectionTime = false;
     m_msgproc->FinalizeNode(*config, pnode->GetId(), fUpdateConnectionTime);
     if (fUpdateConnectionTime) {
         addrman.Connected(pnode->addr);
     }
     delete pnode;
 }
 
 CConnman::~CConnman() {
     Interrupt();
     Stop();
 }
 
 size_t CConnman::GetAddressCount() const {
     return addrman.size();
 }
 
 void CConnman::SetServices(const CService &addr, ServiceFlags nServices) {
     addrman.SetServices(addr, nServices);
 }
 
 void CConnman::MarkAddressGood(const CAddress &addr) {
     addrman.Good(addr);
 }
 
 void CConnman::AddNewAddresses(const std::vector<CAddress> &vAddr,
                                const CAddress &addrFrom, int64_t nTimePenalty) {
     addrman.Add(vAddr, addrFrom, nTimePenalty);
 }
 
 std::vector<CAddress> CConnman::GetAddresses() {
     return addrman.GetAddr();
 }
 
 bool CConnman::AddNode(const std::string &strNode) {
     LOCK(cs_vAddedNodes);
     for (const std::string &it : vAddedNodes) {
         if (strNode == it) {
             return false;
         }
     }
 
     vAddedNodes.push_back(strNode);
     return true;
 }
 
 bool CConnman::RemoveAddedNode(const std::string &strNode) {
     LOCK(cs_vAddedNodes);
     for (std::vector<std::string>::iterator it = vAddedNodes.begin();
          it != vAddedNodes.end(); ++it) {
         if (strNode == *it) {
             vAddedNodes.erase(it);
             return true;
         }
     }
     return false;
 }
 
 size_t CConnman::GetNodeCount(NumConnections flags) {
     LOCK(cs_vNodes);
     // Shortcut if we want total
     if (flags == CConnman::CONNECTIONS_ALL) {
         return vNodes.size();
     }
 
     int nNum = 0;
     for (const auto &pnode : vNodes) {
         if (flags & (pnode->fInbound ? CONNECTIONS_IN : CONNECTIONS_OUT)) {
             nNum++;
         }
     }
 
     return nNum;
 }
 
 void CConnman::GetNodeStats(std::vector<CNodeStats> &vstats) {
     vstats.clear();
     LOCK(cs_vNodes);
     vstats.reserve(vNodes.size());
     for (CNode *pnode : vNodes) {
         vstats.emplace_back();
         pnode->copyStats(vstats.back());
     }
 }
 
 bool CConnman::DisconnectNode(const std::string &strNode) {
     LOCK(cs_vNodes);
     if (CNode *pnode = FindNode(strNode)) {
         pnode->fDisconnect = true;
         return true;
     }
     return false;
 }
 
 bool CConnman::DisconnectNode(const CSubNet &subnet) {
     bool disconnected = false;
     LOCK(cs_vNodes);
     for (CNode *pnode : vNodes) {
         if (subnet.Match(pnode->addr)) {
             pnode->fDisconnect = true;
             disconnected = true;
         }
     }
     return disconnected;
 }
 
 bool CConnman::DisconnectNode(const CNetAddr &addr) {
     return DisconnectNode(CSubNet(addr));
 }
 
 bool CConnman::DisconnectNode(NodeId id) {
     LOCK(cs_vNodes);
     for (CNode *pnode : vNodes) {
         if (id == pnode->GetId()) {
             pnode->fDisconnect = true;
             return true;
         }
     }
     return false;
 }
 
 void CConnman::RecordBytesRecv(uint64_t bytes) {
     LOCK(cs_totalBytesRecv);
     nTotalBytesRecv += bytes;
 }
 
 void CConnman::RecordBytesSent(uint64_t bytes) {
     LOCK(cs_totalBytesSent);
     nTotalBytesSent += bytes;
 
     uint64_t now = GetTime();
     if (nMaxOutboundCycleStartTime + nMaxOutboundTimeframe < now) {
         // timeframe expired, reset cycle
         nMaxOutboundCycleStartTime = now;
         nMaxOutboundTotalBytesSentInCycle = 0;
     }
 
     // TODO, exclude whitebind peers
     nMaxOutboundTotalBytesSentInCycle += bytes;
 }
 
 void CConnman::SetMaxOutboundTarget(uint64_t limit) {
     LOCK(cs_totalBytesSent);
     nMaxOutboundLimit = limit;
 }
 
 uint64_t CConnman::GetMaxOutboundTarget() {
     LOCK(cs_totalBytesSent);
     return nMaxOutboundLimit;
 }
 
 uint64_t CConnman::GetMaxOutboundTimeframe() {
     LOCK(cs_totalBytesSent);
     return nMaxOutboundTimeframe;
 }
 
 uint64_t CConnman::GetMaxOutboundTimeLeftInCycle() {
     LOCK(cs_totalBytesSent);
     if (nMaxOutboundLimit == 0) {
         return 0;
     }
 
     if (nMaxOutboundCycleStartTime == 0) {
         return nMaxOutboundTimeframe;
     }
 
     uint64_t cycleEndTime = nMaxOutboundCycleStartTime + nMaxOutboundTimeframe;
     uint64_t now = GetTime();
     return (cycleEndTime < now) ? 0 : cycleEndTime - GetTime();
 }
 
 void CConnman::SetMaxOutboundTimeframe(uint64_t timeframe) {
     LOCK(cs_totalBytesSent);
     if (nMaxOutboundTimeframe != timeframe) {
         // reset measure-cycle in case of changing the timeframe.
         nMaxOutboundCycleStartTime = GetTime();
     }
     nMaxOutboundTimeframe = timeframe;
 }
 
 bool CConnman::OutboundTargetReached(bool historicalBlockServingLimit) {
     LOCK(cs_totalBytesSent);
     if (nMaxOutboundLimit == 0) {
         return false;
     }
 
     if (historicalBlockServingLimit) {
         // keep a large enough buffer to at least relay each block once.
         uint64_t timeLeftInCycle = GetMaxOutboundTimeLeftInCycle();
         uint64_t buffer = timeLeftInCycle / 600 * ONE_MEGABYTE;
         if (buffer >= nMaxOutboundLimit ||
             nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit - buffer) {
             return true;
         }
     } else if (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit) {
         return true;
     }
 
     return false;
 }
 
 uint64_t CConnman::GetOutboundTargetBytesLeft() {
     LOCK(cs_totalBytesSent);
     if (nMaxOutboundLimit == 0) {
         return 0;
     }
 
     return (nMaxOutboundTotalBytesSentInCycle >= nMaxOutboundLimit)
                ? 0
                : nMaxOutboundLimit - nMaxOutboundTotalBytesSentInCycle;
 }
 
 uint64_t CConnman::GetTotalBytesRecv() {
     LOCK(cs_totalBytesRecv);
     return nTotalBytesRecv;
 }
 
 uint64_t CConnman::GetTotalBytesSent() {
     LOCK(cs_totalBytesSent);
     return nTotalBytesSent;
 }
 
 ServiceFlags CConnman::GetLocalServices() const {
     return nLocalServices;
 }
 
 void CConnman::SetBestHeight(int height) {
     nBestHeight.store(height, std::memory_order_release);
 }
 
 int CConnman::GetBestHeight() const {
     return nBestHeight.load(std::memory_order_acquire);
 }
 
 unsigned int CConnman::GetReceiveFloodSize() const {
     return nReceiveFloodSize;
 }
 
 CNode::CNode(NodeId idIn, ServiceFlags nLocalServicesIn,
              int nMyStartingHeightIn, SOCKET hSocketIn, const CAddress &addrIn,
              uint64_t nKeyedNetGroupIn, uint64_t nLocalHostNonceIn,
              const CAddress &addrBindIn, const std::string &addrNameIn,
              bool fInboundIn)
     : nTimeConnected(GetSystemTimeInSeconds()), addr(addrIn),
       addrBind(addrBindIn), fInbound(fInboundIn),
       nKeyedNetGroup(nKeyedNetGroupIn), addrKnown(5000, 0.001),
       filterInventoryKnown(50000, 0.000001), id(idIn),
       nLocalHostNonce(nLocalHostNonceIn), nLocalServices(nLocalServicesIn),
       nMyStartingHeight(nMyStartingHeightIn) {
     hSocket = hSocketIn;
     addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn;
     strSubVer = "";
     hashContinue = BlockHash();
     filterInventoryKnown.reset();
     pfilter = std::make_unique<CBloomFilter>();
 
     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", addrName, id);
     } else {
         LogPrint(BCLog::NET, "Added connection peer=%d\n", id);
     }
 }
 
 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();
     size_t nTotalSize = nMessageSize + CMessageHeader::HEADER_SIZE;
     LogPrint(BCLog::NET, "sending %s (%d bytes) peer=%d\n",
              SanitizeString(msg.command.c_str()), nMessageSize, pnode->GetId());
 
     std::vector<uint8_t> serializedHeader;
     serializedHeader.reserve(CMessageHeader::HEADER_SIZE);
     uint256 hash = Hash(msg.data.data(), msg.data.data() + nMessageSize);
     CMessageHeader hdr(config->GetChainParams().NetMagic(), msg.command.c_str(),
                        nMessageSize);
     memcpy(hdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);
 
     CVectorWriter{SER_NETWORK, INIT_PROTO_VERSION, serializedHeader, 0, hdr};
 
     size_t nBytesSent = 0;
     {
         LOCK(pnode->cs_vSend);
         bool optimisticSend(pnode->vSendMsg.empty());
 
         // log total amount of bytes per command
         pnode->mapSendBytesPerMsgCmd[msg.command] += 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(cs_vNodes);
     for (auto &&pnode : vNodes) {
         if (pnode->GetId() == id) {
             found = pnode;
             break;
         }
     }
     return found != nullptr && NodeFullyConnected(found) && func(found);
 }
 
 int64_t CConnman::PoissonNextSendInbound(int64_t now,
                                          int average_interval_seconds) {
     if (m_next_send_inv_to_incoming < 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_seconds);
     }
     return m_next_send_inv_to_incoming;
 }
 
 int64_t PoissonNextSend(int64_t now, int average_interval_seconds) {
     return now + int64_t(log1p(GetRand(1ULL << 48) *
                                -0.0000000000000035527136788 /* -1/2^48 */) *
                              average_interval_seconds * -1000000.0 +
                          0.5);
 }
 
 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());
 
     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);
     }
 
     // Size compliance is checked at startup, it is safe to not check it again
     std::string subversion =
         FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, uacomments);
 
     return subversion;
 }
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
index 1d9726b6e..083973ccd 100644
--- a/src/qt/bitcoin.cpp
+++ b/src/qt/bitcoin.cpp
@@ -1,751 +1,750 @@
 // 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.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/bitcoin.h>
 
 #include <chainparams.h>
 #include <config.h>
 #include <fs.h>
 #include <httprpc.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <noui.h>
 #include <qt/bitcoingui.h>
 #include <qt/clientmodel.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/intro.h>
 #include <qt/networkstyle.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/splashscreen.h>
 #include <qt/utilitydialog.h>
 #include <qt/winshutdownmonitor.h>
 #include <rpc/server.h>
 #include <ui_interface.h>
 #include <uint256.h>
 #include <util/system.h>
 #include <util/threadnames.h>
 #include <walletinitinterface.h>
 #include <warnings.h>
 
 #ifdef ENABLE_WALLET
 #include <qt/paymentserver.h>
 #include <qt/walletcontroller.h>
 #endif
 
 #include <QApplication>
 #include <QDebug>
 #include <QLibraryInfo>
 #include <QLocale>
 #include <QMessageBox>
 #include <QSettings>
 #include <QStringList>
 #include <QThread>
 #include <QTimer>
 #include <QTranslator>
 
 #if defined(QT_STATICPLUGIN)
 #include <QtPlugin>
 #if defined(QT_QPA_PLATFORM_XCB)
 Q_IMPORT_PLUGIN(QXcbIntegrationPlugin);
 #elif defined(QT_QPA_PLATFORM_WINDOWS)
 Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin);
 #elif defined(QT_QPA_PLATFORM_COCOA)
 Q_IMPORT_PLUGIN(QCocoaIntegrationPlugin);
 #endif
 #endif
 
 #include <cstdint>
 #include <memory>
 
 // Declare meta types used for QMetaObject::invokeMethod
 Q_DECLARE_METATYPE(bool *)
 Q_DECLARE_METATYPE(Amount)
 Q_DECLARE_METATYPE(uint256)
 
 // Config is non-copyable so we can only register pointers to it
 Q_DECLARE_METATYPE(Config *)
 
 static void InitMessage(const std::string &message) {
     noui_InitMessage(message);
 }
 
 static QString GetLangTerritory() {
     QSettings settings;
     // Get desired locale (e.g. "de_DE")
     // 1) System default language
     QString lang_territory = QLocale::system().name();
     // 2) Language from QSettings
     QString lang_territory_qsettings =
         settings.value("language", "").toString();
     if (!lang_territory_qsettings.isEmpty()) {
         lang_territory = lang_territory_qsettings;
     }
     // 3) -lang command line argument
     lang_territory = QString::fromStdString(
         gArgs.GetArg("-lang", lang_territory.toStdString()));
     return lang_territory;
 }
 
 /** Set up translations */
 static void initTranslations(QTranslator &qtTranslatorBase,
                              QTranslator &qtTranslator,
                              QTranslator &translatorBase,
                              QTranslator &translator) {
     // Remove old translators
     QApplication::removeTranslator(&qtTranslatorBase);
     QApplication::removeTranslator(&qtTranslator);
     QApplication::removeTranslator(&translatorBase);
     QApplication::removeTranslator(&translator);
 
     // Get desired locale (e.g. "de_DE")
     // 1) System default language
     QString lang_territory = GetLangTerritory();
 
     // Convert to "de" only by truncating "_DE"
     QString lang = lang_territory;
     lang.truncate(lang_territory.lastIndexOf('_'));
 
     // Load language files for configured locale:
     // - First load the translator for the base language, without territory
     // - Then load the more specific locale translator
 
     // Load e.g. qt_de.qm
     if (qtTranslatorBase.load(
             "qt_" + lang,
             QLibraryInfo::location(QLibraryInfo::TranslationsPath))) {
         QApplication::installTranslator(&qtTranslatorBase);
     }
 
     // Load e.g. qt_de_DE.qm
     if (qtTranslator.load(
             "qt_" + lang_territory,
             QLibraryInfo::location(QLibraryInfo::TranslationsPath))) {
         QApplication::installTranslator(&qtTranslator);
     }
 
     // Load e.g. bitcoin_de.qm (shortcut "de" needs to be defined in
     // bitcoin.qrc)
     if (translatorBase.load(lang, ":/translations/")) {
         QApplication::installTranslator(&translatorBase);
     }
 
     // Load e.g. bitcoin_de_DE.qm (shortcut "de_DE" needs to be defined in
     // bitcoin.qrc)
     if (translator.load(lang_territory, ":/translations/")) {
         QApplication::installTranslator(&translator);
     }
 }
 
 /* qDebug() message handler --> debug.log */
 void DebugMessageHandler(QtMsgType type, const QMessageLogContext &context,
                          const QString &msg) {
     Q_UNUSED(context);
     if (type == QtDebugMsg) {
         LogPrint(BCLog::QT, "GUI: %s\n", msg.toStdString());
     } else {
         LogPrintf("GUI: %s\n", msg.toStdString());
     }
 }
 
 BitcoinABC::BitcoinABC(interfaces::Node &node) : QObject(), m_node(node) {}
 
 void BitcoinABC::handleRunawayException(const std::exception *e) {
     PrintExceptionContinue(e, "Runaway exception");
     Q_EMIT runawayException(QString::fromStdString(m_node.getWarnings("gui")));
 }
 
 void BitcoinABC::initialize(Config *config, RPCServer *rpcServer,
                             HTTPRPCRequestProcessor *httpRPCRequestProcessor) {
     try {
         qDebug() << __func__ << ": Running initialization in thread";
         util::ThreadRename("qt-init");
         bool rv =
             m_node.appInitMain(*config, *rpcServer, *httpRPCRequestProcessor);
         Q_EMIT initializeResult(rv);
     } catch (const std::exception &e) {
         handleRunawayException(&e);
     } catch (...) {
         handleRunawayException(nullptr);
     }
 }
 
 void BitcoinABC::shutdown() {
     try {
         qDebug() << __func__ << ": Running Shutdown in thread";
         m_node.appShutdown();
         qDebug() << __func__ << ": Shutdown finished";
         Q_EMIT shutdownResult();
     } catch (const std::exception &e) {
         handleRunawayException(&e);
     } catch (...) {
         handleRunawayException(nullptr);
     }
 }
 
 BitcoinApplication::BitcoinApplication(interfaces::Node &node, int &argc,
                                        char **argv)
     : QApplication(argc, argv), coreThread(nullptr), m_node(node),
       optionsModel(nullptr), clientModel(nullptr), window(nullptr),
       pollShutdownTimer(nullptr), returnValue(0), platformStyle(nullptr) {
     setQuitOnLastWindowClosed(false);
 }
 
 void BitcoinApplication::setupPlatformStyle() {
     // UI per-platform customization
     // This must be done inside the BitcoinApplication constructor, or after it,
     // because PlatformStyle::instantiate requires a QApplication.
     std::string platformName;
     platformName = gArgs.GetArg("-uiplatform", BitcoinGUI::DEFAULT_UIPLATFORM);
     platformStyle =
         PlatformStyle::instantiate(QString::fromStdString(platformName));
     // Fall back to "other" if specified name not found.
     if (!platformStyle) {
         platformStyle = PlatformStyle::instantiate("other");
     }
     assert(platformStyle);
 }
 
 BitcoinApplication::~BitcoinApplication() {
     if (coreThread) {
         qDebug() << __func__ << ": Stopping thread";
         Q_EMIT stopThread();
         coreThread->wait();
         qDebug() << __func__ << ": Stopped thread";
     }
 
     delete window;
     window = nullptr;
 #ifdef ENABLE_WALLET
     delete paymentServer;
     paymentServer = nullptr;
 #endif
     delete optionsModel;
     optionsModel = nullptr;
     delete platformStyle;
     platformStyle = nullptr;
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinApplication::createPaymentServer() {
     paymentServer = new PaymentServer(this);
 }
 #endif
 
 void BitcoinApplication::createOptionsModel(bool resetSettings) {
     optionsModel = new OptionsModel(m_node, nullptr, resetSettings);
 }
 
 void BitcoinApplication::createWindow(const Config *config,
                                       const NetworkStyle *networkStyle) {
     window =
         new BitcoinGUI(m_node, config, platformStyle, networkStyle, nullptr);
 
     pollShutdownTimer = new QTimer(window);
     connect(pollShutdownTimer, &QTimer::timeout, window,
             &BitcoinGUI::detectShutdown);
 }
 
 void BitcoinApplication::createSplashScreen(const NetworkStyle *networkStyle) {
     SplashScreen *splash = new SplashScreen(m_node, nullptr, networkStyle);
     // We don't hold a direct pointer to the splash screen after creation, but
     // the splash screen will take care of deleting itself when slotFinish
     // happens.
     splash->show();
     connect(this, &BitcoinApplication::splashFinished, splash,
             &SplashScreen::slotFinish);
     connect(this, &BitcoinApplication::requestedShutdown, splash,
             &QWidget::close);
 }
 
 bool BitcoinApplication::baseInitialize(Config &config) {
     return m_node.baseInitialize(config);
 }
 
 void BitcoinApplication::startThread() {
     if (coreThread) {
         return;
     }
     coreThread = new QThread(this);
     BitcoinABC *executor = new BitcoinABC(m_node);
     executor->moveToThread(coreThread);
 
     /*  communication to and from thread */
     connect(executor, &BitcoinABC::initializeResult, this,
             &BitcoinApplication::initializeResult);
     connect(executor, &BitcoinABC::shutdownResult, this,
             &BitcoinApplication::shutdownResult);
     connect(executor, &BitcoinABC::runawayException, this,
             &BitcoinApplication::handleRunawayException);
 
     // Note on how Qt works: it tries to directly invoke methods if the signal
     // is emitted on the same thread that the target object 'lives' on.
     // But if the target object 'lives' on another thread (executor here does)
     // the SLOT will be invoked asynchronously at a later time in the thread
     // of the target object.  So.. we pass a pointer around.  If you pass
     // a reference around (even if it's non-const) you'll get Qt generating
     // code to copy-construct the parameter in question (Q_DECLARE_METATYPE
     // and qRegisterMetaType generate this code).  For the Config class,
     // which is noncopyable, we can't do this.  So.. we have to pass
     // pointers to Config around.  Make sure Config &/Config * isn't a
     // temporary (eg it lives somewhere aside from the stack) or this will
     // crash because initialize() gets executed in another thread at some
     // unspecified time (after) requestedInitialize() is emitted!
     connect(this, &BitcoinApplication::requestedInitialize, executor,
             &BitcoinABC::initialize);
 
     connect(this, &BitcoinApplication::requestedShutdown, executor,
             &BitcoinABC::shutdown);
     /*  make sure executor object is deleted in its own thread */
     connect(this, &BitcoinApplication::stopThread, executor,
             &QObject::deleteLater);
     connect(this, &BitcoinApplication::stopThread, coreThread, &QThread::quit);
 
     coreThread->start();
 }
 
 void BitcoinApplication::parameterSetup() {
     // Default printtoconsole to false for the GUI. GUI programs should not
     // print to the console unnecessarily.
     gArgs.SoftSetBoolArg("-printtoconsole", false);
 
     m_node.initLogging();
     m_node.initParameterInteraction();
 }
 
 void BitcoinApplication::requestInitialize(
     Config &config, RPCServer &rpcServer,
     HTTPRPCRequestProcessor &httpRPCRequestProcessor) {
     qDebug() << __func__ << ": Requesting initialize";
     startThread();
     // IMPORTANT: config must NOT be a reference to a temporary because below
     // signal may be connected to a slot that will be executed as a queued
     // connection in another thread!
     Q_EMIT requestedInitialize(&config, &rpcServer, &httpRPCRequestProcessor);
 }
 
 void BitcoinApplication::requestShutdown(Config &config) {
     // Show a simple window indicating shutdown status. Do this first as some of
     // the steps may take some time below, for example the RPC console may still
     // be executing a command.
     shutdownWindow.reset(ShutdownWindow::showShutdownWindow(window));
 
     qDebug() << __func__ << ": Requesting shutdown";
     startThread();
     window->hide();
     window->setClientModel(nullptr);
     pollShutdownTimer->stop();
 
 #ifdef ENABLE_WALLET
     delete m_wallet_controller;
     m_wallet_controller = nullptr;
 #endif
     delete clientModel;
     clientModel = nullptr;
 
     m_node.startShutdown();
 
     // Request shutdown from core thread
     Q_EMIT requestedShutdown();
 }
 
 void BitcoinApplication::initializeResult(bool success) {
     qDebug() << __func__ << ": Initialization result: " << success;
     returnValue = success ? EXIT_SUCCESS : EXIT_FAILURE;
     if (!success) {
         // Make sure splash screen doesn't stick around during shutdown.
         Q_EMIT splashFinished(window);
         // Exit first main loop invocation.
         quit();
         return;
     }
     // Log this only after AppInitMain finishes, as then logging setup is
     // guaranteed complete.
     qWarning() << "Platform customization:" << platformStyle->getName();
 #ifdef ENABLE_WALLET
     m_wallet_controller =
         new WalletController(m_node, platformStyle, optionsModel, this);
 #ifdef ENABLE_BIP70
     PaymentServer::LoadRootCAs();
 #endif
     if (paymentServer) {
         paymentServer->setOptionsModel(optionsModel);
 #ifdef ENABLE_BIP70
         connect(m_wallet_controller, &WalletController::coinsSent,
                 paymentServer, &PaymentServer::fetchPaymentACK);
 #endif
     }
 #endif
 
     clientModel = new ClientModel(m_node, optionsModel);
     window->setClientModel(clientModel);
 #ifdef ENABLE_WALLET
     window->setWalletController(m_wallet_controller);
 #endif
 
     // If -min option passed, start window minimized.
     if (gArgs.GetBoolArg("-min", false)) {
         window->showMinimized();
     } else {
         window->show();
     }
     Q_EMIT splashFinished(window);
     Q_EMIT windowShown(window);
 
 #ifdef ENABLE_WALLET
     // Now that initialization/startup is done, process any command-line
     // bitcoincash: URIs or payment requests:
     if (paymentServer) {
         connect(paymentServer, &PaymentServer::receivedPaymentRequest, window,
                 &BitcoinGUI::handlePaymentRequest);
         connect(window, &BitcoinGUI::receivedURI, paymentServer,
                 &PaymentServer::handleURIOrFile);
         connect(paymentServer, &PaymentServer::message,
                 [this](const QString &title, const QString &message,
                        unsigned int style) {
                     window->message(title, message, style);
                 });
         QTimer::singleShot(100, paymentServer, &PaymentServer::uiReady);
     }
 #endif
 
     pollShutdownTimer->start(200);
 }
 
 void BitcoinApplication::shutdownResult() {
     // Exit second main loop invocation after shutdown finished.
     quit();
 }
 
 void BitcoinApplication::handleRunawayException(const QString &message) {
     QMessageBox::critical(
         nullptr, "Runaway exception",
         BitcoinGUI::tr("A fatal error occurred. Bitcoin can no longer continue "
                        "safely and will quit.") +
             QString("\n\n") + message);
     ::exit(EXIT_FAILURE);
 }
 
 WId BitcoinApplication::getMainWinId() const {
     if (!window) {
         return 0;
     }
 
     return window->winId();
 }
 
 static void SetupUIArgs() {
 #if defined(ENABLE_WALLET) && defined(ENABLE_BIP70)
     gArgs.AddArg("-allowselfsignedrootcertificates",
                  strprintf("Allow self signed root certificates (default: %d)",
                            DEFAULT_SELFSIGNED_ROOTCERTS),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::GUI);
 #endif
     gArgs.AddArg("-choosedatadir",
                  strprintf("Choose data directory on startup (default: %d)",
                            DEFAULT_CHOOSE_DATADIR),
                  ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
     gArgs.AddArg("-lang=<lang>",
                  "Set language, for example \"de_DE\" (default: system locale)",
                  ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
     gArgs.AddArg("-min", "Start minimized", ArgsManager::ALLOW_ANY,
                  OptionsCategory::GUI);
     gArgs.AddArg(
         "-rootcertificates=<file>",
         "Set SSL root certificates for payment request (default: -system-)",
         ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
     gArgs.AddArg("-splash",
                  strprintf("Show splash screen on startup (default: %d)",
                            DEFAULT_SPLASHSCREEN),
                  ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
     gArgs.AddArg("-resetguisettings", "Reset all settings changed in the GUI",
                  ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
     gArgs.AddArg("-uiplatform",
                  strprintf("Select platform to customize UI for (one of "
                            "windows, macosx, other; default: %s)",
                            BitcoinGUI::DEFAULT_UIPLATFORM),
                  ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY,
                  OptionsCategory::GUI);
 }
 
 #ifndef BITCOIN_QT_TEST
 
 static void MigrateSettings() {
     assert(!QApplication::applicationName().isEmpty());
 
     static const QString legacyAppName("Bitcoin-Qt"),
 #ifdef Q_OS_DARWIN
         // Macs and/or iOS et al use a domain-style name for Settings
         // files. All other platforms use a simple orgname. This
         // difference is documented in the QSettings class documentation.
         legacyOrg("bitcoin.org");
 #else
         legacyOrg("Bitcoin");
 #endif
     QSettings
         // below picks up settings file location based on orgname,appname
         legacy(legacyOrg, legacyAppName),
         // default c'tor below picks up settings file location based on
         // QApplication::applicationName(), et al -- which was already set
         // in main()
         abc;
 #ifdef Q_OS_DARWIN
     // Disable bogus OSX keys from MacOS system-wide prefs that may cloud our
     // judgement ;) (this behavior is also documented in QSettings docs)
     legacy.setFallbacksEnabled(false);
     abc.setFallbacksEnabled(false);
 #endif
     const QStringList legacyKeys(legacy.allKeys());
 
     // We only migrate settings if we have Core settings but no Bitcoin-ABC
     // settings
     if (!legacyKeys.isEmpty() && abc.allKeys().isEmpty()) {
         for (const QString &key : legacyKeys) {
             // now, copy settings over
             abc.setValue(key, legacy.value(key));
         }
     }
 }
 
 int GuiMain(int argc, char *argv[]) {
 #ifdef WIN32
     util::WinCmdLineArgs winArgs;
     std::tie(argc, argv) = winArgs.get();
 #endif
     SetupEnvironment();
     util::ThreadSetInternalName("main");
 
     std::unique_ptr<interfaces::Node> node = interfaces::MakeNode();
 
     // Do not refer to data directory yet, this can be overridden by
     // Intro::pickDataDirectory
 
     /// 1. Basic Qt initialization (not dependent on parameters or
     /// configuration)
     Q_INIT_RESOURCE(bitcoin);
     Q_INIT_RESOURCE(bitcoin_locale);
 
 #if QT_VERSION > 0x050100
     // Generate high-dpi pixmaps
     QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
 #endif
 #if QT_VERSION >= 0x050600
     QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
 #endif
 #ifdef Q_OS_MAC
     QApplication::setAttribute(Qt::AA_DontShowIconsInMenus);
 #endif
 
     BitcoinApplication app(*node, argc, argv);
 
     // Register meta types used for QMetaObject::invokeMethod
     qRegisterMetaType<bool *>();
     //   Need to pass name here as Amount is a typedef (see
     //   http://qt-project.org/doc/qt-5/qmetatype.html#qRegisterMetaType)
     //   IMPORTANT if it is no longer a typedef use the normal variant above
     qRegisterMetaType<Amount>("Amount");
     qRegisterMetaType<std::function<void()>>("std::function<void()>");
 
     // Need to register any types Qt doesn't know about if you intend
     // to use them with the signal/slot mechanism Qt provides. Even pointers.
     // Note that class Config is noncopyable and so we can't register a
     // non-pointer version of it with Qt, because Qt expects to be able to
     // copy-construct non-pointers to objects for invoking slots
     // behind-the-scenes in the 'Queued' connection case.
     qRegisterMetaType<Config *>();
 
     /// 2. Parse command-line options. We do this after qt in order to show an
     /// error if there are problems parsing these
     // Command-line options take precedence:
     node->setupServerArgs();
     SetupUIArgs();
     std::string error;
     if (!node->parseParameters(argc, argv, error)) {
         QMessageBox::critical(
-            nullptr, QObject::tr(PACKAGE_NAME),
+            nullptr, PACKAGE_NAME,
             QObject::tr("Error parsing command line arguments: %1.")
                 .arg(QString::fromStdString(error)));
         return EXIT_FAILURE;
     }
 
     // Now that the QApplication is setup and we have parsed our parameters, we
     // can set the platform style
     app.setupPlatformStyle();
 
     /// 3. Application identification
     // must be set before OptionsModel is initialized or translations are
     // loaded, as it is used to locate QSettings.
     // Note: If you move these calls somewhere else, be sure to bring
     // MigrateSettings() below along for the ride.
     QApplication::setOrganizationName(QAPP_ORG_NAME);
     QApplication::setOrganizationDomain(QAPP_ORG_DOMAIN);
     QApplication::setApplicationName(QAPP_APP_NAME_DEFAULT);
     // Migrate settings from core's/our old GUI settings to Bitcoin ABC
     // only if core's exist but Bitcoin ABC's doesn't.
     // NOTE -- this function needs to be called *after* the above 3 lines
     // that set the app orgname and app name! If you move the above 3 lines
     // to elsewhere, take this call with you!
     MigrateSettings();
 
     /// 4. Initialization of translations, so that intro dialog is in user's
     /// language. Now that QSettings are accessible, initialize translations.
     QTranslator qtTranslatorBase, qtTranslator, translatorBase, translator;
     initTranslations(qtTranslatorBase, qtTranslator, translatorBase,
                      translator);
 
     // Show help message immediately after parsing command-line options (for
     // "-lang") and setting locale, but before showing splash screen.
     if (HelpRequested(gArgs) || gArgs.IsArgSet("-version")) {
         HelpMessageDialog help(*node, nullptr, gArgs.IsArgSet("-version"));
         help.showOrPrint();
         return EXIT_SUCCESS;
     }
 
     /// 5. Now that settings and translations are available, ask user for data
     /// directory. User language is set up: pick a data directory.
     if (!Intro::pickDataDirectory(*node)) {
         return EXIT_SUCCESS;
     }
 
     /// 6. Determine availability of data and blocks directory and parse
     /// bitcoin.conf
     /// - Do not call GetDataDir(true) before this step finishes.
     if (!fs::is_directory(GetDataDir(false))) {
         QMessageBox::critical(
-            nullptr, QObject::tr(PACKAGE_NAME),
+            nullptr, PACKAGE_NAME,
             QObject::tr(
                 "Error: Specified data directory \"%1\" does not exist.")
                 .arg(QString::fromStdString(gArgs.GetArg("-datadir", ""))));
         return EXIT_FAILURE;
     }
     if (!node->readConfigFiles(error)) {
         QMessageBox::critical(
-            nullptr, QObject::tr(PACKAGE_NAME),
+            nullptr, PACKAGE_NAME,
             QObject::tr("Error: Cannot parse configuration file: %1.")
                 .arg(QString::fromStdString(error)));
         return EXIT_FAILURE;
     }
 
     /// 7. Determine network (and switch to network specific options)
     // - Do not call Params() before this step.
     // - Do this after parsing the configuration file, as the network can be
     // switched there.
     // - QSettings() will use the new application name after this, resulting in
     // network-specific settings.
     // - Needs to be done before createOptionsModel.
 
     // Check for -testnet or -regtest parameter (Params() calls are only valid
     // after this clause)
     try {
         node->selectParams(gArgs.GetChainName());
     } catch (std::exception &e) {
-        QMessageBox::critical(nullptr, QObject::tr(PACKAGE_NAME),
+        QMessageBox::critical(nullptr, PACKAGE_NAME,
                               QObject::tr("Error: %1").arg(e.what()));
         return EXIT_FAILURE;
     }
 #ifdef ENABLE_WALLET
     // Parse URIs on command line -- this can affect Params()
     PaymentServer::ipcParseCommandLine(*node, argc, argv);
 #endif
 
     QScopedPointer<const NetworkStyle> networkStyle(NetworkStyle::instantiate(
         QString::fromStdString(Params().NetworkIDString())));
     assert(!networkStyle.isNull());
     // Allow for separate UI settings for testnets
     QApplication::setApplicationName(networkStyle->getAppName());
     // Re-initialize translations after changing application name (language in
     // network-specific settings can be different)
     initTranslations(qtTranslatorBase, qtTranslator, translatorBase,
                      translator);
 
 #ifdef ENABLE_WALLET
     /// 8. URI IPC sending
     // - Do this early as we don't want to bother initializing if we are just
     // calling IPC
     // - Do this *after* setting up the data directory, as the data directory
     // hash is used in the name
     // of the server.
     // - Do this after creating app and setting up translations, so errors are
     // translated properly.
     if (PaymentServer::ipcSendCommandLine()) {
         exit(EXIT_SUCCESS);
     }
 
     // Start up the payment server early, too, so impatient users that click on
     // bitcoincash: links repeatedly have their payment requests routed to this
     // process:
     app.createPaymentServer();
 #endif
 
     /// 9. Main GUI initialization
     // Install global event filter that makes sure that long tooltips can be
     // word-wrapped.
     app.installEventFilter(
         new GUIUtil::ToolTipToRichTextFilter(TOOLTIP_WRAP_THRESHOLD, &app));
 #if defined(Q_OS_WIN)
     // Install global event filter for processing Windows session related
     // Windows messages (WM_QUERYENDSESSION and WM_ENDSESSION)
     qApp->installNativeEventFilter(new WinShutdownMonitor());
 #endif
     // Install qDebug() message handler to route to debug.log
     qInstallMessageHandler(DebugMessageHandler);
     // Allow parameter interaction before we create the options model
     app.parameterSetup();
     // Load GUI settings from QSettings
     app.createOptionsModel(gArgs.GetBoolArg("-resetguisettings", false));
 
     // Subscribe to global signals from core
     std::unique_ptr<interfaces::Handler> handler =
         node->handleInitMessage(InitMessage);
 
     // Get global config
     Config &config = const_cast<Config &>(GetConfig());
 
     if (gArgs.GetBoolArg("-splash", DEFAULT_SPLASHSCREEN) &&
         !gArgs.GetBoolArg("-min", false)) {
         app.createSplashScreen(networkStyle.data());
     }
 
     RPCServer rpcServer;
     HTTPRPCRequestProcessor httpRPCRequestProcessor(config, rpcServer);
 
     try {
         app.createWindow(&config, networkStyle.data());
         // Perform base initialization before spinning up
         // initialization/shutdown thread. This is acceptable because this
         // function only contains steps that are quick to execute, so the GUI
         // thread won't be held up.
         if (!app.baseInitialize(config)) {
             // A dialog with detailed error will have been shown by InitError()
             return EXIT_FAILURE;
         }
         app.requestInitialize(config, rpcServer, httpRPCRequestProcessor);
 #if defined(Q_OS_WIN)
         WinShutdownMonitor::registerShutdownBlockReason(
-            QObject::tr("%1 didn't yet exit safely...")
-                .arg(QObject::tr(PACKAGE_NAME)),
+            QObject::tr("%1 didn't yet exit safely...").arg(PACKAGE_NAME),
             (HWND)app.getMainWinId());
 #endif
         app.exec();
         app.requestShutdown(config);
         app.exec();
         return app.getReturnValue();
     } catch (const std::exception &e) {
         PrintExceptionContinue(&e, "Runaway exception");
         app.handleRunawayException(
             QString::fromStdString(node->getWarnings("gui")));
     } catch (...) {
         PrintExceptionContinue(nullptr, "Runaway exception");
         app.handleRunawayException(
             QString::fromStdString(node->getWarnings("gui")));
     }
     return EXIT_FAILURE;
 }
 #endif // BITCOIN_QT_TEST
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index d94d5265f..946c056bc 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -1,1485 +1,1485 @@
 // 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.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/bitcoingui.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <noui.h>
 #include <qt/bitcoinunits.h>
 #include <qt/clientmodel.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #ifdef Q_OS_MAC
 #include <qt/macdockiconhandler.h>
 #endif
 #include <qt/modaloverlay.h>
 #include <qt/networkstyle.h>
 #include <qt/notificator.h>
 #include <qt/openuridialog.h>
 #include <qt/optionsdialog.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/rpcconsole.h>
 #include <qt/utilitydialog.h>
 #ifdef ENABLE_WALLET
 #include <qt/walletcontroller.h>
 #include <qt/walletframe.h>
 #include <qt/walletmodel.h>
 #include <qt/walletview.h>
 #endif // ENABLE_WALLET
 #include <ui_interface.h>
 #include <util/system.h>
 
 #include <QAction>
 #include <QApplication>
 #include <QComboBox>
 #include <QDateTime>
 #include <QDragEnterEvent>
 #include <QListWidget>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QMimeData>
 #include <QProgressDialog>
 #include <QScreen>
 #include <QSettings>
 #include <QShortcut>
 #include <QStackedWidget>
 #include <QStatusBar>
 #include <QStyle>
 #include <QTimer>
 #include <QToolBar>
 #include <QUrlQuery>
 #include <QVBoxLayout>
 
 const std::string BitcoinGUI::DEFAULT_UIPLATFORM =
 #if defined(Q_OS_MAC)
     "macosx"
 #elif defined(Q_OS_WIN)
     "windows"
 #else
     "other"
 #endif
     ;
 
 BitcoinGUI::BitcoinGUI(interfaces::Node &node, const Config *configIn,
                        const PlatformStyle *_platformStyle,
                        const NetworkStyle *networkStyle, QWidget *parent)
     : QMainWindow(parent), m_node(node), config(configIn),
       platformStyle(_platformStyle), m_network_style(networkStyle) {
     QSettings settings;
     if (!restoreGeometry(settings.value("MainWindowGeometry").toByteArray())) {
         // Restore failed (perhaps missing setting), center the window
         move(QGuiApplication::primaryScreen()->availableGeometry().center() -
              frameGeometry().center());
     }
 
 #ifdef ENABLE_WALLET
     enableWallet = WalletModel::isWalletEnabled();
 #endif // ENABLE_WALLET
     QApplication::setWindowIcon(m_network_style->getTrayAndWindowIcon());
     setWindowIcon(m_network_style->getTrayAndWindowIcon());
     updateWindowTitle();
 
     rpcConsole = new RPCConsole(node, _platformStyle, nullptr);
     helpMessageDialog = new HelpMessageDialog(node, this, false);
 #ifdef ENABLE_WALLET
     if (enableWallet) {
         /** Create wallet frame and make it the central widget */
         walletFrame = new WalletFrame(_platformStyle, this);
         setCentralWidget(walletFrame);
     } else
 #endif // ENABLE_WALLET
     {
         /**
          * When compiled without wallet or -disablewallet is provided,  the
          * central widget is the rpc console.
          */
         setCentralWidget(rpcConsole);
         Q_EMIT consoleShown(rpcConsole);
     }
 
     // Accept D&D of URIs
     setAcceptDrops(true);
 
     // Create actions for the toolbar, menu bar and tray/dock icon
     // Needs walletFrame to be initialized
     createActions();
 
     // Create application menu bar
     createMenuBar();
 
     // Create the toolbars
     createToolBars();
 
     // Create system tray icon and notification
     if (QSystemTrayIcon::isSystemTrayAvailable()) {
         createTrayIcon();
     }
     notificator =
         new Notificator(QApplication::applicationName(), trayIcon, this);
 
     // Create status bar
     statusBar();
 
     // Disable size grip because it looks ugly and nobody needs it
     statusBar()->setSizeGripEnabled(false);
 
     // Status bar notification icons
     QFrame *frameBlocks = new QFrame();
     frameBlocks->setContentsMargins(0, 0, 0, 0);
     frameBlocks->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
     QHBoxLayout *frameBlocksLayout = new QHBoxLayout(frameBlocks);
     frameBlocksLayout->setContentsMargins(3, 0, 3, 0);
     frameBlocksLayout->setSpacing(3);
     unitDisplayControl = new UnitDisplayStatusBarControl(platformStyle);
     labelWalletEncryptionIcon = new QLabel();
     labelWalletHDStatusIcon = new QLabel();
     labelProxyIcon = new GUIUtil::ClickableLabel();
     connectionsControl = new GUIUtil::ClickableLabel();
     labelBlocksIcon = new GUIUtil::ClickableLabel();
     if (enableWallet) {
         frameBlocksLayout->addStretch();
         frameBlocksLayout->addWidget(unitDisplayControl);
         frameBlocksLayout->addStretch();
         frameBlocksLayout->addWidget(labelWalletEncryptionIcon);
         frameBlocksLayout->addWidget(labelWalletHDStatusIcon);
     }
     frameBlocksLayout->addWidget(labelProxyIcon);
     frameBlocksLayout->addStretch();
     frameBlocksLayout->addWidget(connectionsControl);
     frameBlocksLayout->addStretch();
     frameBlocksLayout->addWidget(labelBlocksIcon);
     frameBlocksLayout->addStretch();
 
     // Progress bar and label for blocks download
     progressBarLabel = new QLabel();
     progressBarLabel->setVisible(false);
     progressBar = new GUIUtil::ProgressBar();
     progressBar->setAlignment(Qt::AlignCenter);
     progressBar->setVisible(false);
 
     // Override style sheet for progress bar for styles that have a segmented
     // progress bar, as they make the text unreadable (workaround for issue
     // #1071)
     // See https://doc.qt.io/qt-5/gallery.html
     QString curStyle = QApplication::style()->metaObject()->className();
     if (curStyle == "QWindowsStyle" || curStyle == "QWindowsXPStyle") {
         progressBar->setStyleSheet(
             "QProgressBar { background-color: #e8e8e8; border: 1px solid grey; "
             "border-radius: 7px; padding: 1px; text-align: center; } "
             "QProgressBar::chunk { background: QLinearGradient(x1: 0, y1: 0, "
             "x2: 1, y2: 0, stop: 0 #FF8000, stop: 1 orange); border-radius: "
             "7px; margin: 0px; }");
     }
 
     statusBar()->addWidget(progressBarLabel);
     statusBar()->addWidget(progressBar);
     statusBar()->addPermanentWidget(frameBlocks);
 
     // Install event filter to be able to catch status tip events
     // (QEvent::StatusTip)
     this->installEventFilter(this);
 
     // Initially wallet actions should be disabled
     setWalletActionsEnabled(false);
 
     // Subscribe to notifications from core
     subscribeToCoreSignals();
 
     connect(connectionsControl, &GUIUtil::ClickableLabel::clicked,
             [this] { m_node.setNetworkActive(!m_node.getNetworkActive()); });
     connect(labelProxyIcon, &GUIUtil::ClickableLabel::clicked,
             [this] { openOptionsDialogWithTab(OptionsDialog::TAB_NETWORK); });
 
     modalOverlay = new ModalOverlay(this->centralWidget());
 #ifdef ENABLE_WALLET
     if (enableWallet) {
         connect(walletFrame, &WalletFrame::requestedSyncWarningInfo, this,
                 &BitcoinGUI::showModalOverlay);
         connect(labelBlocksIcon, &GUIUtil::ClickableLabel::clicked, this,
                 &BitcoinGUI::showModalOverlay);
         connect(progressBar, &GUIUtil::ClickableProgressBar::clicked, this,
                 &BitcoinGUI::showModalOverlay);
     }
 #endif
 }
 
 BitcoinGUI::~BitcoinGUI() {
     // Unsubscribe from notifications from core
     unsubscribeFromCoreSignals();
 
     QSettings settings;
     settings.setValue("MainWindowGeometry", saveGeometry());
     // Hide tray icon, as deleting will let it linger until quit (on Ubuntu)
     if (trayIcon) {
         trayIcon->hide();
     }
 #ifdef Q_OS_MAC
     delete appMenuBar;
     MacDockIconHandler::cleanup();
 #endif
 
     delete rpcConsole;
 }
 
 void BitcoinGUI::createActions() {
     QActionGroup *tabGroup = new QActionGroup(this);
 
     overviewAction =
         new QAction(platformStyle->SingleColorIcon(":/icons/overview"),
                     tr("&Overview"), this);
     overviewAction->setStatusTip(tr("Show general overview of wallet"));
     overviewAction->setToolTip(overviewAction->statusTip());
     overviewAction->setCheckable(true);
     overviewAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_1));
     tabGroup->addAction(overviewAction);
 
     sendCoinsAction = new QAction(
         platformStyle->SingleColorIcon(":/icons/send"), tr("&Send"), this);
     sendCoinsAction->setStatusTip(tr("Send coins to a Bitcoin address"));
     sendCoinsAction->setToolTip(sendCoinsAction->statusTip());
     sendCoinsAction->setCheckable(true);
     sendCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_2));
     tabGroup->addAction(sendCoinsAction);
 
     sendCoinsMenuAction =
         new QAction(platformStyle->TextColorIcon(":/icons/send"),
                     sendCoinsAction->text(), this);
     sendCoinsMenuAction->setStatusTip(sendCoinsAction->statusTip());
     sendCoinsMenuAction->setToolTip(sendCoinsMenuAction->statusTip());
 
     receiveCoinsAction = new QAction(
         platformStyle->SingleColorIcon(":/icons/receiving_addresses"),
         tr("&Receive"), this);
     receiveCoinsAction->setStatusTip(
         tr("Request payments (generates QR codes and %1: URIs)")
             .arg(QString::fromStdString(
                 config->GetChainParams().CashAddrPrefix())));
     receiveCoinsAction->setToolTip(receiveCoinsAction->statusTip());
     receiveCoinsAction->setCheckable(true);
     receiveCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_3));
     tabGroup->addAction(receiveCoinsAction);
 
     receiveCoinsMenuAction =
         new QAction(platformStyle->TextColorIcon(":/icons/receiving_addresses"),
                     receiveCoinsAction->text(), this);
     receiveCoinsMenuAction->setStatusTip(receiveCoinsAction->statusTip());
     receiveCoinsMenuAction->setToolTip(receiveCoinsMenuAction->statusTip());
 
     historyAction =
         new QAction(platformStyle->SingleColorIcon(":/icons/history"),
                     tr("&Transactions"), this);
     historyAction->setStatusTip(tr("Browse transaction history"));
     historyAction->setToolTip(historyAction->statusTip());
     historyAction->setCheckable(true);
     historyAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_4));
     tabGroup->addAction(historyAction);
 
 #ifdef ENABLE_WALLET
     // These showNormalIfMinimized are needed because Send Coins and Receive
     // Coins can be triggered from the tray menu, and need to show the GUI to be
     // useful.
     connect(overviewAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(overviewAction, &QAction::triggered, this,
             &BitcoinGUI::gotoOverviewPage);
     connect(sendCoinsAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(sendCoinsAction, &QAction::triggered,
             [this] { gotoSendCoinsPage(); });
     connect(sendCoinsMenuAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(sendCoinsMenuAction, &QAction::triggered,
             [this] { gotoSendCoinsPage(); });
     connect(receiveCoinsAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(receiveCoinsAction, &QAction::triggered, this,
             &BitcoinGUI::gotoReceiveCoinsPage);
     connect(receiveCoinsMenuAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(receiveCoinsMenuAction, &QAction::triggered, this,
             &BitcoinGUI::gotoReceiveCoinsPage);
     connect(historyAction, &QAction::triggered,
             [this] { showNormalIfMinimized(); });
     connect(historyAction, &QAction::triggered, this,
             &BitcoinGUI::gotoHistoryPage);
 #endif // ENABLE_WALLET
 
     quitAction = new QAction(platformStyle->TextColorIcon(":/icons/quit"),
                              tr("E&xit"), this);
     quitAction->setStatusTip(tr("Quit application"));
     quitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
     quitAction->setMenuRole(QAction::QuitRole);
     aboutAction = new QAction(platformStyle->TextColorIcon(":/icons/about"),
-                              tr("&About %1").arg(tr(PACKAGE_NAME)), this);
+                              tr("&About %1").arg(PACKAGE_NAME), this);
     aboutAction->setStatusTip(
-        tr("Show information about %1").arg(tr(PACKAGE_NAME)));
+        tr("Show information about %1").arg(PACKAGE_NAME));
     aboutAction->setMenuRole(QAction::AboutRole);
     aboutAction->setEnabled(false);
     aboutQtAction =
         new QAction(platformStyle->TextColorIcon(":/icons/about_qt"),
                     tr("About &Qt"), this);
     aboutQtAction->setStatusTip(tr("Show information about Qt"));
     aboutQtAction->setMenuRole(QAction::AboutQtRole);
     optionsAction = new QAction(platformStyle->TextColorIcon(":/icons/options"),
                                 tr("&Options..."), this);
     optionsAction->setStatusTip(
-        tr("Modify configuration options for %1").arg(tr(PACKAGE_NAME)));
+        tr("Modify configuration options for %1").arg(PACKAGE_NAME));
     optionsAction->setMenuRole(QAction::PreferencesRole);
     optionsAction->setEnabled(false);
     toggleHideAction =
         new QAction(platformStyle->TextColorIcon(":/icons/about"),
                     tr("&Show / Hide"), this);
     toggleHideAction->setStatusTip(tr("Show or hide the main Window"));
 
     encryptWalletAction =
         new QAction(platformStyle->TextColorIcon(":/icons/lock_closed"),
                     tr("&Encrypt Wallet..."), this);
     encryptWalletAction->setStatusTip(
         tr("Encrypt the private keys that belong to your wallet"));
     encryptWalletAction->setCheckable(true);
     backupWalletAction =
         new QAction(platformStyle->TextColorIcon(":/icons/filesave"),
                     tr("&Backup Wallet..."), this);
     backupWalletAction->setStatusTip(tr("Backup wallet to another location"));
     changePassphraseAction =
         new QAction(platformStyle->TextColorIcon(":/icons/key"),
                     tr("&Change Passphrase..."), this);
     changePassphraseAction->setStatusTip(
         tr("Change the passphrase used for wallet encryption"));
     signMessageAction =
         new QAction(platformStyle->TextColorIcon(":/icons/edit"),
                     tr("Sign &message..."), this);
     signMessageAction->setStatusTip(
         tr("Sign messages with your Bitcoin addresses to prove you own them"));
     verifyMessageAction =
         new QAction(platformStyle->TextColorIcon(":/icons/verify"),
                     tr("&Verify message..."), this);
     verifyMessageAction->setStatusTip(
         tr("Verify messages to ensure they were signed with specified Bitcoin "
            "addresses"));
 
     openRPCConsoleAction =
         new QAction(platformStyle->TextColorIcon(":/icons/debugwindow"),
                     tr("&Debug window"), this);
     openRPCConsoleAction->setStatusTip(
         tr("Open debugging and diagnostic console"));
     // initially disable the debug window menu item
     openRPCConsoleAction->setEnabled(false);
     openRPCConsoleAction->setObjectName("openRPCConsoleAction");
 
     usedSendingAddressesAction =
         new QAction(platformStyle->TextColorIcon(":/icons/address-book"),
                     tr("&Sending addresses..."), this);
     usedSendingAddressesAction->setStatusTip(
         tr("Show the list of used sending addresses and labels"));
     usedReceivingAddressesAction =
         new QAction(platformStyle->TextColorIcon(":/icons/address-book"),
                     tr("&Receiving addresses..."), this);
     usedReceivingAddressesAction->setStatusTip(
         tr("Show the list of used receiving addresses and labels"));
 
     openAction = new QAction(platformStyle->TextColorIcon(":/icons/open"),
                              tr("Open &URI..."), this);
     openAction->setStatusTip(
         tr("Open a %1: URI or payment request")
             .arg(QString::fromStdString(
                 config->GetChainParams().CashAddrPrefix())));
 
     showHelpMessageAction =
         new QAction(platformStyle->TextColorIcon(":/icons/info"),
                     tr("&Command-line options"), this);
     showHelpMessageAction->setMenuRole(QAction::NoRole);
     showHelpMessageAction->setStatusTip(
         tr("Show the %1 help message to get a list with possible Bitcoin "
            "command-line options")
-            .arg(tr(PACKAGE_NAME)));
+            .arg(PACKAGE_NAME));
 
     connect(quitAction, &QAction::triggered, qApp, QApplication::quit);
     connect(aboutAction, &QAction::triggered, this, &BitcoinGUI::aboutClicked);
     connect(aboutQtAction, &QAction::triggered, qApp, QApplication::aboutQt);
     connect(optionsAction, &QAction::triggered, this,
             &BitcoinGUI::optionsClicked);
     connect(toggleHideAction, &QAction::triggered, this,
             &BitcoinGUI::toggleHidden);
     connect(showHelpMessageAction, &QAction::triggered, this,
             &BitcoinGUI::showHelpMessageClicked);
     connect(openRPCConsoleAction, &QAction::triggered, this,
             &BitcoinGUI::showDebugWindow);
     // prevents an open debug window from becoming stuck/unusable on client
     // shutdown
     connect(quitAction, &QAction::triggered, rpcConsole, &QWidget::hide);
 
 #ifdef ENABLE_WALLET
     if (walletFrame) {
         connect(encryptWalletAction, &QAction::triggered, walletFrame,
                 &WalletFrame::encryptWallet);
         connect(backupWalletAction, &QAction::triggered, walletFrame,
                 &WalletFrame::backupWallet);
         connect(changePassphraseAction, &QAction::triggered, walletFrame,
                 &WalletFrame::changePassphrase);
         connect(signMessageAction, &QAction::triggered,
                 [this] { showNormalIfMinimized(); });
         connect(signMessageAction, &QAction::triggered,
                 [this] { gotoSignMessageTab(); });
         connect(verifyMessageAction, &QAction::triggered,
                 [this] { showNormalIfMinimized(); });
         connect(verifyMessageAction, &QAction::triggered,
                 [this] { gotoVerifyMessageTab(); });
         connect(usedSendingAddressesAction, &QAction::triggered, walletFrame,
                 &WalletFrame::usedSendingAddresses);
         connect(usedReceivingAddressesAction, &QAction::triggered, walletFrame,
                 &WalletFrame::usedReceivingAddresses);
         connect(openAction, &QAction::triggered, this,
                 &BitcoinGUI::openClicked);
     }
 #endif // ENABLE_WALLET
 
     connect(new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_C), this),
             &QShortcut::activated, this,
             &BitcoinGUI::showDebugWindowActivateConsole);
     connect(new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_D), this),
             &QShortcut::activated, this, &BitcoinGUI::showDebugWindow);
 }
 
 void BitcoinGUI::createMenuBar() {
 #ifdef Q_OS_MAC
     // Create a decoupled menu bar on Mac which stays even if the window is
     // closed
     appMenuBar = new QMenuBar();
 #else
     // Get the main window's menu bar on other platforms
     appMenuBar = menuBar();
 #endif
 
     // Configure the menus
     QMenu *file = appMenuBar->addMenu(tr("&File"));
     if (walletFrame) {
         file->addAction(openAction);
         file->addAction(backupWalletAction);
         file->addAction(signMessageAction);
         file->addAction(verifyMessageAction);
         file->addSeparator();
         file->addAction(usedSendingAddressesAction);
         file->addAction(usedReceivingAddressesAction);
         file->addSeparator();
     }
     file->addAction(quitAction);
 
     QMenu *settings = appMenuBar->addMenu(tr("&Settings"));
     if (walletFrame) {
         settings->addAction(encryptWalletAction);
         settings->addAction(changePassphraseAction);
         settings->addSeparator();
     }
     settings->addAction(optionsAction);
 
     QMenu *help = appMenuBar->addMenu(tr("&Help"));
     if (walletFrame) {
         help->addAction(openRPCConsoleAction);
     }
     help->addAction(showHelpMessageAction);
     help->addSeparator();
     help->addAction(aboutAction);
     help->addAction(aboutQtAction);
 }
 
 void BitcoinGUI::createToolBars() {
     if (walletFrame) {
         QToolBar *toolbar = addToolBar(tr("Tabs toolbar"));
         appToolBar = toolbar;
         toolbar->setContextMenuPolicy(Qt::PreventContextMenu);
         toolbar->setMovable(false);
         toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
         toolbar->addAction(overviewAction);
         toolbar->addAction(sendCoinsAction);
         toolbar->addAction(receiveCoinsAction);
         toolbar->addAction(historyAction);
         overviewAction->setChecked(true);
 
 #ifdef ENABLE_WALLET
         QWidget *spacer = new QWidget();
         spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         toolbar->addWidget(spacer);
 
         m_wallet_selector = new QComboBox();
         connect(m_wallet_selector,
                 static_cast<void (QComboBox::*)(int)>(
                     &QComboBox::currentIndexChanged),
                 this, &BitcoinGUI::setCurrentWalletBySelectorIndex);
 
         m_wallet_selector_label = new QLabel();
         m_wallet_selector_label->setText(tr("Wallet:") + " ");
         m_wallet_selector_label->setBuddy(m_wallet_selector);
 
         m_wallet_selector_label_action =
             appToolBar->addWidget(m_wallet_selector_label);
         m_wallet_selector_action = appToolBar->addWidget(m_wallet_selector);
 
         m_wallet_selector_label_action->setVisible(false);
         m_wallet_selector_action->setVisible(false);
 #endif
     }
 }
 
 void BitcoinGUI::setClientModel(ClientModel *_clientModel) {
     this->clientModel = _clientModel;
     if (_clientModel) {
         // Create system tray menu (or setup the dock menu) that late to prevent
         // users from calling actions, while the client has not yet fully loaded
         createTrayIconMenu();
 
         // Keep up to date with client
         updateNetworkState();
         connect(_clientModel, &ClientModel::numConnectionsChanged, this,
                 &BitcoinGUI::setNumConnections);
         connect(_clientModel, &ClientModel::networkActiveChanged, this,
                 &BitcoinGUI::setNetworkActive);
 
         modalOverlay->setKnownBestHeight(
             _clientModel->getHeaderTipHeight(),
             QDateTime::fromTime_t(_clientModel->getHeaderTipTime()));
         setNumBlocks(m_node.getNumBlocks(),
                      QDateTime::fromTime_t(m_node.getLastBlockTime()),
                      m_node.getVerificationProgress(), false);
         connect(_clientModel, &ClientModel::numBlocksChanged, this,
                 &BitcoinGUI::setNumBlocks);
 
         // Receive and report messages from client model
         connect(_clientModel, &ClientModel::message,
                 [this](const QString &title, const QString &message,
                        unsigned int style) {
                     this->message(title, message, style);
                 });
 
         // Show progress dialog
         connect(_clientModel, &ClientModel::showProgress, this,
                 &BitcoinGUI::showProgress);
 
         rpcConsole->setClientModel(_clientModel);
 
         updateProxyIcon();
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->setClientModel(_clientModel);
         }
 #endif // ENABLE_WALLET
         unitDisplayControl->setOptionsModel(_clientModel->getOptionsModel());
 
         OptionsModel *optionsModel = _clientModel->getOptionsModel();
         if (optionsModel && trayIcon) {
             // be aware of the tray icon disable state change reported by the
             // OptionsModel object.
             connect(optionsModel, &OptionsModel::hideTrayIconChanged, this,
                     &BitcoinGUI::setTrayIconVisible);
 
             // initialize the disable state of the tray icon with the current
             // value in the model.
             setTrayIconVisible(optionsModel->getHideTrayIcon());
         }
     } else {
         // Disable possibility to show main window via action
         toggleHideAction->setEnabled(false);
         if (trayIconMenu) {
             // Disable context menu on tray icon
             trayIconMenu->clear();
         }
         // Propagate cleared model to child objects
         rpcConsole->setClientModel(nullptr);
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->setClientModel(nullptr);
         }
 #endif // ENABLE_WALLET
         unitDisplayControl->setOptionsModel(nullptr);
     }
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::setWalletController(WalletController *wallet_controller) {
     assert(!m_wallet_controller);
     assert(wallet_controller);
 
     m_wallet_controller = wallet_controller;
 
     connect(wallet_controller, &WalletController::walletAdded, this,
             &BitcoinGUI::addWallet);
     connect(wallet_controller, &WalletController::walletRemoved, this,
             &BitcoinGUI::removeWallet);
 
     for (WalletModel *wallet_model : m_wallet_controller->getWallets()) {
         addWallet(wallet_model);
     }
 }
 
 void BitcoinGUI::addWallet(WalletModel *walletModel) {
     if (!walletFrame) {
         return;
     }
     const QString display_name = walletModel->getDisplayName();
     setWalletActionsEnabled(true);
     rpcConsole->addWallet(walletModel);
     walletFrame->addWallet(walletModel);
     m_wallet_selector->addItem(display_name, QVariant::fromValue(walletModel));
     if (m_wallet_selector->count() == 2) {
         m_wallet_selector_label_action->setVisible(true);
         m_wallet_selector_action->setVisible(true);
     }
 }
 
 void BitcoinGUI::removeWallet(WalletModel *walletModel) {
     if (!walletFrame) {
         return;
     }
     int index = m_wallet_selector->findData(QVariant::fromValue(walletModel));
     m_wallet_selector->removeItem(index);
     if (m_wallet_selector->count() == 0) {
         setWalletActionsEnabled(false);
     } else if (m_wallet_selector->count() == 1) {
         m_wallet_selector_label_action->setVisible(false);
         m_wallet_selector_action->setVisible(false);
     }
     rpcConsole->removeWallet(walletModel);
     walletFrame->removeWallet(walletModel);
     updateWindowTitle();
 }
 
 void BitcoinGUI::setCurrentWallet(WalletModel *wallet_model) {
     if (!walletFrame) {
         return;
     }
     walletFrame->setCurrentWallet(wallet_model);
     for (int index = 0; index < m_wallet_selector->count(); ++index) {
         if (m_wallet_selector->itemData(index).value<WalletModel *>() ==
             wallet_model) {
             m_wallet_selector->setCurrentIndex(index);
             break;
         }
     }
     updateWindowTitle();
 }
 
 void BitcoinGUI::setCurrentWalletBySelectorIndex(int index) {
     WalletModel *wallet_model =
         m_wallet_selector->itemData(index).value<WalletModel *>();
     if (wallet_model) {
         setCurrentWallet(wallet_model);
     }
 }
 
 void BitcoinGUI::removeAllWallets() {
     if (!walletFrame) {
         return;
     }
     setWalletActionsEnabled(false);
     walletFrame->removeAllWallets();
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::setWalletActionsEnabled(bool enabled) {
     overviewAction->setEnabled(enabled);
     sendCoinsAction->setEnabled(enabled);
     sendCoinsMenuAction->setEnabled(enabled);
     receiveCoinsAction->setEnabled(enabled);
     receiveCoinsMenuAction->setEnabled(enabled);
     historyAction->setEnabled(enabled);
     encryptWalletAction->setEnabled(enabled);
     backupWalletAction->setEnabled(enabled);
     changePassphraseAction->setEnabled(enabled);
     signMessageAction->setEnabled(enabled);
     verifyMessageAction->setEnabled(enabled);
     usedSendingAddressesAction->setEnabled(enabled);
     usedReceivingAddressesAction->setEnabled(enabled);
     openAction->setEnabled(enabled);
 }
 
 void BitcoinGUI::createTrayIcon() {
     assert(QSystemTrayIcon::isSystemTrayAvailable());
 
 #ifndef Q_OS_MAC
     if (QSystemTrayIcon::isSystemTrayAvailable()) {
         trayIcon =
             new QSystemTrayIcon(m_network_style->getTrayAndWindowIcon(), this);
-        QString toolTip = tr("%1 client").arg(tr(PACKAGE_NAME)) + " " +
+        QString toolTip = tr("%1 client").arg(PACKAGE_NAME) + " " +
                           m_network_style->getTitleAddText();
         trayIcon->setToolTip(toolTip);
     }
 #endif
 }
 
 void BitcoinGUI::createTrayIconMenu() {
 #ifndef Q_OS_MAC
     // Return if trayIcon is unset (only on non-macOSes)
     if (!trayIcon) {
         return;
     }
 
     trayIconMenu = new QMenu(this);
     trayIcon->setContextMenu(trayIconMenu);
 
     connect(trayIcon, &QSystemTrayIcon::activated, this,
             &BitcoinGUI::trayIconActivated);
 #else
     // Note: On macOS, the Dock icon is used to provide the tray's
     // functionality.
     MacDockIconHandler *dockIconHandler = MacDockIconHandler::instance();
     connect(dockIconHandler, &MacDockIconHandler::dockIconClicked, this,
             &BitcoinGUI::macosDockIconActivated);
     trayIconMenu = new QMenu(this);
     trayIconMenu->setAsDockMenu();
 #endif
 
     // Configuration of the tray icon (or Dock icon) menu
 #ifndef Q_OS_MAC
     // Note: On macOS, the Dock icon's menu already has Show / Hide action.
     trayIconMenu->addAction(toggleHideAction);
     trayIconMenu->addSeparator();
 #endif
     trayIconMenu->addAction(sendCoinsMenuAction);
     trayIconMenu->addAction(receiveCoinsMenuAction);
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(signMessageAction);
     trayIconMenu->addAction(verifyMessageAction);
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(optionsAction);
     trayIconMenu->addAction(openRPCConsoleAction);
 #ifndef Q_OS_MAC
     // This is built-in on macOS
     trayIconMenu->addSeparator();
     trayIconMenu->addAction(quitAction);
 #endif
 }
 
 #ifndef Q_OS_MAC
 void BitcoinGUI::trayIconActivated(QSystemTrayIcon::ActivationReason reason) {
     if (reason == QSystemTrayIcon::Trigger) {
         // Click on system tray icon triggers show/hide of the main window
         toggleHidden();
     }
 }
 #else
 void BitcoinGUI::macosDockIconActivated() {
     show();
     activateWindow();
 }
 #endif
 
 void BitcoinGUI::optionsClicked() {
     openOptionsDialogWithTab(OptionsDialog::TAB_MAIN);
 }
 
 void BitcoinGUI::aboutClicked() {
     if (!clientModel) {
         return;
     }
 
     HelpMessageDialog dlg(m_node, this, true);
     dlg.exec();
 }
 
 void BitcoinGUI::showDebugWindow() {
     GUIUtil::bringToFront(rpcConsole);
     Q_EMIT consoleShown(rpcConsole);
 }
 
 void BitcoinGUI::showDebugWindowActivateConsole() {
     rpcConsole->setTabFocus(RPCConsole::TAB_CONSOLE);
     showDebugWindow();
 }
 
 void BitcoinGUI::showHelpMessageClicked() {
     helpMessageDialog->show();
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::openClicked() {
     OpenURIDialog dlg(config->GetChainParams(), this);
     if (dlg.exec()) {
         Q_EMIT receivedURI(dlg.getURI());
     }
 }
 
 void BitcoinGUI::gotoOverviewPage() {
     overviewAction->setChecked(true);
     if (walletFrame) {
         walletFrame->gotoOverviewPage();
     }
 }
 
 void BitcoinGUI::gotoHistoryPage() {
     historyAction->setChecked(true);
     if (walletFrame) {
         walletFrame->gotoHistoryPage();
     }
 }
 
 void BitcoinGUI::gotoReceiveCoinsPage() {
     receiveCoinsAction->setChecked(true);
     if (walletFrame) {
         walletFrame->gotoReceiveCoinsPage();
     }
 }
 
 void BitcoinGUI::gotoSendCoinsPage(QString addr) {
     sendCoinsAction->setChecked(true);
     if (walletFrame) {
         walletFrame->gotoSendCoinsPage(addr);
     }
 }
 
 void BitcoinGUI::gotoSignMessageTab(QString addr) {
     if (walletFrame) {
         walletFrame->gotoSignMessageTab(addr);
     }
 }
 
 void BitcoinGUI::gotoVerifyMessageTab(QString addr) {
     if (walletFrame) {
         walletFrame->gotoVerifyMessageTab(addr);
     }
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::updateNetworkState() {
     int count = clientModel->getNumConnections();
     QString icon;
     switch (count) {
         case 0:
             icon = ":/icons/connect_0";
             break;
         case 1:
         case 2:
         case 3:
             icon = ":/icons/connect_1";
             break;
         case 4:
         case 5:
         case 6:
             icon = ":/icons/connect_2";
             break;
         case 7:
         case 8:
         case 9:
             icon = ":/icons/connect_3";
             break;
         default:
             icon = ":/icons/connect_4";
             break;
     }
 
     QString tooltip;
 
     if (m_node.getNetworkActive()) {
         tooltip = tr("%n active connection(s) to Bitcoin network", "", count) +
                   QString(".<br>") + tr("Click to disable network activity.");
     } else {
         tooltip = tr("Network activity disabled.") + QString("<br>") +
                   tr("Click to enable network activity again.");
         icon = ":/icons/network_disabled";
     }
 
     // Don't word-wrap this (fixed-width) tooltip
     tooltip = QString("<nobr>") + tooltip + QString("</nobr>");
     connectionsControl->setToolTip(tooltip);
 
     connectionsControl->setPixmap(platformStyle->SingleColorIcon(icon).pixmap(
         STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
 }
 
 void BitcoinGUI::setNumConnections(int count) {
     updateNetworkState();
 }
 
 void BitcoinGUI::setNetworkActive(bool networkActive) {
     updateNetworkState();
 }
 
 void BitcoinGUI::updateHeadersSyncProgressLabel() {
     int64_t headersTipTime = clientModel->getHeaderTipTime();
     int headersTipHeight = clientModel->getHeaderTipHeight();
     int estHeadersLeft =
         (GetTime() - headersTipTime) /
         config->GetChainParams().GetConsensus().nPowTargetSpacing;
     if (estHeadersLeft > HEADER_HEIGHT_DELTA_SYNC) {
         progressBarLabel->setText(
             tr("Syncing Headers (%1%)...")
                 .arg(QString::number(100.0 /
                                          (headersTipHeight + estHeadersLeft) *
                                          headersTipHeight,
                                      'f', 1)));
     }
 }
 
 void BitcoinGUI::openOptionsDialogWithTab(OptionsDialog::Tab tab) {
     if (!clientModel || !clientModel->getOptionsModel()) {
         return;
     }
 
     OptionsDialog dlg(this, enableWallet);
     dlg.setCurrentTab(tab);
     dlg.setModel(clientModel->getOptionsModel());
     dlg.exec();
 }
 
 void BitcoinGUI::setNumBlocks(int count, const QDateTime &blockDate,
                               double nVerificationProgress, bool header) {
     if (modalOverlay) {
         if (header) {
             modalOverlay->setKnownBestHeight(count, blockDate);
         } else {
             modalOverlay->tipUpdate(count, blockDate, nVerificationProgress);
         }
     }
     if (!clientModel) {
         return;
     }
 
     // Prevent orphan statusbar messages (e.g. hover Quit in main menu, wait
     // until chain-sync starts -> garbled text)
     statusBar()->clearMessage();
 
     // Acquire current block source
     enum BlockSource blockSource = clientModel->getBlockSource();
     switch (blockSource) {
         case BlockSource::NETWORK:
             if (header) {
                 updateHeadersSyncProgressLabel();
                 return;
             }
             progressBarLabel->setText(tr("Synchronizing with network..."));
             updateHeadersSyncProgressLabel();
             break;
         case BlockSource::DISK:
             if (header) {
                 progressBarLabel->setText(tr("Indexing blocks on disk..."));
             } else {
                 progressBarLabel->setText(tr("Processing blocks on disk..."));
             }
             break;
         case BlockSource::REINDEX:
             progressBarLabel->setText(tr("Reindexing blocks on disk..."));
             break;
         case BlockSource::NONE:
             if (header) {
                 return;
             }
             progressBarLabel->setText(tr("Connecting to peers..."));
             break;
     }
 
     QString tooltip;
 
     QDateTime currentDate = QDateTime::currentDateTime();
     qint64 secs = blockDate.secsTo(currentDate);
 
     tooltip = tr("Processed %n block(s) of transaction history.", "", count);
 
     // Set icon state: spinning if catching up, tick otherwise
     if (secs < MAX_BLOCK_TIME_GAP) {
         tooltip = tr("Up to date") + QString(".<br>") + tooltip;
         labelBlocksIcon->setPixmap(
             platformStyle->SingleColorIcon(":/icons/synced")
                 .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->showOutOfSyncWarning(false);
             modalOverlay->showHide(true, true);
         }
 #endif // ENABLE_WALLET
 
         progressBarLabel->setVisible(false);
         progressBar->setVisible(false);
     } else {
         QString timeBehindText = GUIUtil::formatNiceTimeOffset(secs);
 
         progressBarLabel->setVisible(true);
         progressBar->setFormat(tr("%1 behind").arg(timeBehindText));
         progressBar->setMaximum(1000000000);
         progressBar->setValue(nVerificationProgress * 1000000000.0 + 0.5);
         progressBar->setVisible(true);
 
         tooltip = tr("Catching up...") + QString("<br>") + tooltip;
         if (count != prevBlocks) {
             labelBlocksIcon->setPixmap(
                 platformStyle
                     ->SingleColorIcon(QString(":/movies/spinner-%1")
                                           .arg(spinnerFrame, 3, 10, QChar('0')))
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES;
         }
         prevBlocks = count;
 
 #ifdef ENABLE_WALLET
         if (walletFrame) {
             walletFrame->showOutOfSyncWarning(true);
             modalOverlay->showHide();
         }
 #endif // ENABLE_WALLET
 
         tooltip += QString("<br>");
         tooltip +=
             tr("Last received block was generated %1 ago.").arg(timeBehindText);
         tooltip += QString("<br>");
         tooltip += tr("Transactions after this will not yet be visible.");
     }
 
     // Don't word-wrap this (fixed-width) tooltip
     tooltip = QString("<nobr>") + tooltip + QString("</nobr>");
 
     labelBlocksIcon->setToolTip(tooltip);
     progressBarLabel->setToolTip(tooltip);
     progressBar->setToolTip(tooltip);
 }
 
 void BitcoinGUI::message(const QString &title, const QString &message,
                          unsigned int style, bool *ret) {
     // default title
     QString strTitle = tr("Bitcoin");
     // Default to information icon
     int nMBoxIcon = QMessageBox::Information;
     int nNotifyIcon = Notificator::Information;
 
     QString msgType;
 
     // Prefer supplied title over style based title
     if (!title.isEmpty()) {
         msgType = title;
     } else {
         switch (style) {
             case CClientUIInterface::MSG_ERROR:
                 msgType = tr("Error");
                 break;
             case CClientUIInterface::MSG_WARNING:
                 msgType = tr("Warning");
                 break;
             case CClientUIInterface::MSG_INFORMATION:
                 msgType = tr("Information");
                 break;
             default:
                 break;
         }
     }
     // Append title to "Bitcoin - "
     if (!msgType.isEmpty()) {
         strTitle += " - " + msgType;
     }
 
     // Check for error/warning icon
     if (style & CClientUIInterface::ICON_ERROR) {
         nMBoxIcon = QMessageBox::Critical;
         nNotifyIcon = Notificator::Critical;
     } else if (style & CClientUIInterface::ICON_WARNING) {
         nMBoxIcon = QMessageBox::Warning;
         nNotifyIcon = Notificator::Warning;
     }
 
     // Display message
     if (style & CClientUIInterface::MODAL) {
         // Check for buttons, use OK as default, if none was supplied
         QMessageBox::StandardButton buttons;
         if (!(buttons = (QMessageBox::StandardButton)(
                   style & CClientUIInterface::BTN_MASK))) {
             buttons = QMessageBox::Ok;
         }
 
         showNormalIfMinimized();
         QMessageBox mBox(static_cast<QMessageBox::Icon>(nMBoxIcon), strTitle,
                          message, buttons, this);
         mBox.setTextFormat(Qt::PlainText);
         int r = mBox.exec();
         if (ret != nullptr) {
             *ret = r == QMessageBox::Ok;
         }
     } else {
         notificator->notify(static_cast<Notificator::Class>(nNotifyIcon),
                             strTitle, message);
     }
 }
 
 void BitcoinGUI::changeEvent(QEvent *e) {
     QMainWindow::changeEvent(e);
 #ifndef Q_OS_MAC // Ignored on Mac
     if (e->type() == QEvent::WindowStateChange) {
         if (clientModel && clientModel->getOptionsModel() &&
             clientModel->getOptionsModel()->getMinimizeToTray()) {
             QWindowStateChangeEvent *wsevt =
                 static_cast<QWindowStateChangeEvent *>(e);
             if (!(wsevt->oldState() & Qt::WindowMinimized) && isMinimized()) {
                 QTimer::singleShot(0, this, &BitcoinGUI::hide);
                 e->ignore();
             } else if ((wsevt->oldState() & Qt::WindowMinimized) &&
                        !isMinimized()) {
                 QTimer::singleShot(0, this, &BitcoinGUI::show);
                 e->ignore();
             }
         }
     }
 #endif
 }
 
 void BitcoinGUI::closeEvent(QCloseEvent *event) {
 #ifndef Q_OS_MAC // Ignored on Mac
     if (clientModel && clientModel->getOptionsModel()) {
         if (!clientModel->getOptionsModel()->getMinimizeOnClose()) {
             // close rpcConsole in case it was open to make some space for the
             // shutdown window
             rpcConsole->close();
 
             QApplication::quit();
         } else {
             QMainWindow::showMinimized();
             event->ignore();
         }
     }
 #else
     QMainWindow::closeEvent(event);
 #endif
 }
 
 void BitcoinGUI::showEvent(QShowEvent *event) {
     // enable the debug window when the main window shows up
     openRPCConsoleAction->setEnabled(true);
     aboutAction->setEnabled(true);
     optionsAction->setEnabled(true);
 }
 
 #ifdef ENABLE_WALLET
 void BitcoinGUI::incomingTransaction(const QString &date, int unit,
                                      const Amount amount, const QString &type,
                                      const QString &address,
                                      const QString &label,
                                      const QString &walletName) {
     // On new transaction, make an info balloon
     QString msg = tr("Date: %1\n").arg(date) +
                   tr("Amount: %1\n")
                       .arg(BitcoinUnits::formatWithUnit(unit, amount, true));
     if (m_node.getWallets().size() > 1 && !walletName.isEmpty()) {
         msg += tr("Wallet: %1\n").arg(walletName);
     }
     msg += tr("Type: %1\n").arg(type);
     if (!label.isEmpty()) {
         msg += tr("Label: %1\n").arg(label);
     } else if (!address.isEmpty()) {
         msg += tr("Address: %1\n").arg(address);
     }
     message(amount < Amount::zero() ? tr("Sent transaction")
                                     : tr("Incoming transaction"),
             msg, CClientUIInterface::MSG_INFORMATION);
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::dragEnterEvent(QDragEnterEvent *event) {
     // Accept only URIs
     if (event->mimeData()->hasUrls()) {
         event->acceptProposedAction();
     }
 }
 
 void BitcoinGUI::dropEvent(QDropEvent *event) {
     if (event->mimeData()->hasUrls()) {
         for (const QUrl &uri : event->mimeData()->urls()) {
             Q_EMIT receivedURI(uri.toString());
         }
     }
     event->acceptProposedAction();
 }
 
 bool BitcoinGUI::eventFilter(QObject *object, QEvent *event) {
     // Catch status tip events
     if (event->type() == QEvent::StatusTip) {
         // Prevent adding text from setStatusTip(), if we currently use the
         // status bar for displaying other stuff
         if (progressBarLabel->isVisible() || progressBar->isVisible()) {
             return true;
         }
     }
     return QMainWindow::eventFilter(object, event);
 }
 
 #ifdef ENABLE_WALLET
 bool BitcoinGUI::handlePaymentRequest(const SendCoinsRecipient &recipient) {
     // URI has to be valid
     if (walletFrame && walletFrame->handlePaymentRequest(recipient)) {
         showNormalIfMinimized();
         gotoSendCoinsPage();
         return true;
     }
     return false;
 }
 
 void BitcoinGUI::setHDStatus(int hdEnabled) {
     labelWalletHDStatusIcon->setPixmap(
         platformStyle
             ->SingleColorIcon(hdEnabled ? ":/icons/hd_enabled"
                                         : ":/icons/hd_disabled")
             .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
     labelWalletHDStatusIcon->setToolTip(
         hdEnabled ? tr("HD key generation is <b>enabled</b>")
                   : tr("HD key generation is <b>disabled</b>"));
 
     // eventually disable the QLabel to set its opacity to 50%
     labelWalletHDStatusIcon->setEnabled(hdEnabled);
 }
 
 void BitcoinGUI::setEncryptionStatus(int status) {
     switch (status) {
         case WalletModel::Unencrypted:
             labelWalletEncryptionIcon->hide();
             encryptWalletAction->setChecked(false);
             changePassphraseAction->setEnabled(false);
             encryptWalletAction->setEnabled(true);
             break;
         case WalletModel::Unlocked:
             labelWalletEncryptionIcon->show();
             labelWalletEncryptionIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/lock_open")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelWalletEncryptionIcon->setToolTip(
                 tr("Wallet is <b>encrypted</b> and currently <b>unlocked</b>"));
             encryptWalletAction->setChecked(true);
             changePassphraseAction->setEnabled(true);
             encryptWalletAction->setEnabled(
                 false); // TODO: decrypt currently not supported
             break;
         case WalletModel::Locked:
             labelWalletEncryptionIcon->show();
             labelWalletEncryptionIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/lock_closed")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelWalletEncryptionIcon->setToolTip(
                 tr("Wallet is <b>encrypted</b> and currently <b>locked</b>"));
             encryptWalletAction->setChecked(true);
             changePassphraseAction->setEnabled(true);
             encryptWalletAction->setEnabled(
                 false); // TODO: decrypt currently not supported
             break;
     }
 }
 
 void BitcoinGUI::updateWalletStatus() {
     if (!walletFrame) {
         return;
     }
     WalletView *const walletView = walletFrame->currentWalletView();
     if (!walletView) {
         return;
     }
     WalletModel *const walletModel = walletView->getWalletModel();
     setEncryptionStatus(walletModel->getEncryptionStatus());
     setHDStatus(walletModel->wallet().hdEnabled());
 }
 #endif // ENABLE_WALLET
 
 void BitcoinGUI::updateProxyIcon() {
     std::string ip_port;
     bool proxy_enabled = clientModel->getProxyInfo(ip_port);
 
     if (proxy_enabled) {
         if (labelProxyIcon->pixmap() == nullptr) {
             QString ip_port_q = QString::fromStdString(ip_port);
             labelProxyIcon->setPixmap(
                 platformStyle->SingleColorIcon(":/icons/proxy")
                     .pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
             labelProxyIcon->setToolTip(
                 tr("Proxy is <b>enabled</b>: %1").arg(ip_port_q));
         } else {
             labelProxyIcon->show();
         }
     } else {
         labelProxyIcon->hide();
     }
 }
 
 void BitcoinGUI::updateWindowTitle() {
-    QString window_title = tr(PACKAGE_NAME);
+    QString window_title = PACKAGE_NAME;
 #ifdef ENABLE_WALLET
     if (walletFrame) {
         WalletModel *const wallet_model = walletFrame->currentWalletModel();
         if (wallet_model && !wallet_model->getWalletName().isEmpty()) {
             window_title += " - " + wallet_model->getDisplayName();
         }
     }
 #endif
     if (!m_network_style->getTitleAddText().isEmpty()) {
         window_title += " - " + m_network_style->getTitleAddText();
     }
     setWindowTitle(window_title);
 }
 
 void BitcoinGUI::showNormalIfMinimized(bool fToggleHidden) {
     if (!clientModel) {
         return;
     }
 
     if (!isHidden() && !isMinimized() && !GUIUtil::isObscured(this) &&
         fToggleHidden) {
         hide();
     } else {
         GUIUtil::bringToFront(this);
     }
 }
 
 void BitcoinGUI::toggleHidden() {
     showNormalIfMinimized(true);
 }
 
 void BitcoinGUI::detectShutdown() {
     if (m_node.shutdownRequested()) {
         if (rpcConsole) {
             rpcConsole->hide();
         }
         qApp->quit();
     }
 }
 
 void BitcoinGUI::showProgress(const QString &title, int nProgress) {
     if (nProgress == 0) {
         progressDialog = new QProgressDialog(title, "", 0, 100);
         progressDialog->setWindowModality(Qt::ApplicationModal);
         progressDialog->setMinimumDuration(0);
         progressDialog->setCancelButton(nullptr);
         progressDialog->setAutoClose(false);
         progressDialog->setValue(0);
     } else if (progressDialog) {
         if (nProgress == 100) {
             progressDialog->close();
             progressDialog->deleteLater();
         } else {
             progressDialog->setValue(nProgress);
         }
     }
 }
 
 void BitcoinGUI::setTrayIconVisible(bool fHideTrayIcon) {
     if (trayIcon) {
         trayIcon->setVisible(!fHideTrayIcon);
     }
 }
 
 void BitcoinGUI::showModalOverlay() {
     if (modalOverlay &&
         (progressBar->isVisible() || modalOverlay->isLayerVisible())) {
         modalOverlay->toggleVisibility();
     }
 }
 
 static bool ThreadSafeMessageBox(BitcoinGUI *gui, const std::string &message,
                                  const std::string &caption,
                                  unsigned int style) {
     // Redundantly log and print message in non-gui fashion
     noui_ThreadSafeMessageBox(message, caption, style);
 
     bool modal = (style & CClientUIInterface::MODAL);
     // The SECURE flag has no effect in the Qt GUI.
     // bool secure = (style & CClientUIInterface::SECURE);
     style &= ~CClientUIInterface::SECURE;
     bool ret = false;
     // In case of modal message, use blocking connection to wait for user to
     // click a button
     QMetaObject::invokeMethod(gui, "message",
                               modal ? GUIUtil::blockingGUIThreadConnection()
                                     : Qt::QueuedConnection,
                               Q_ARG(QString, QString::fromStdString(caption)),
                               Q_ARG(QString, QString::fromStdString(message)),
                               Q_ARG(unsigned int, style), Q_ARG(bool *, &ret));
     return ret;
 }
 
 void BitcoinGUI::subscribeToCoreSignals() {
     // Connect signals to client
     m_handler_message_box = m_node.handleMessageBox(
         std::bind(ThreadSafeMessageBox, this, std::placeholders::_1,
                   std::placeholders::_2, std::placeholders::_3));
     m_handler_question = m_node.handleQuestion(
         std::bind(ThreadSafeMessageBox, this, std::placeholders::_1,
                   std::placeholders::_3, std::placeholders::_4));
 }
 
 void BitcoinGUI::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
     m_handler_message_box->disconnect();
     m_handler_question->disconnect();
 }
 
 UnitDisplayStatusBarControl::UnitDisplayStatusBarControl(
     const PlatformStyle *platformStyle)
     : optionsModel(nullptr), menu(nullptr) {
     createContextMenu();
     setToolTip(tr("Unit to show amounts in. Click to select another unit."));
     QList<BitcoinUnits::Unit> units = BitcoinUnits::availableUnits();
     int max_width = 0;
     const QFontMetrics fm(font());
     for (const BitcoinUnits::Unit unit : units) {
         max_width = qMax(max_width,
                          GUIUtil::TextWidth(fm, BitcoinUnits::longName(unit)));
     }
     setMinimumSize(max_width, 0);
     setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     setStyleSheet(QString("QLabel { color : %1 }")
                       .arg(platformStyle->SingleColor().name()));
 }
 
 /** So that it responds to button clicks */
 void UnitDisplayStatusBarControl::mousePressEvent(QMouseEvent *event) {
     onDisplayUnitsClicked(event->pos());
 }
 
 /** Creates context menu, its actions, and wires up all the relevant signals for
  * mouse events. */
 void UnitDisplayStatusBarControl::createContextMenu() {
     menu = new QMenu(this);
     for (const BitcoinUnits::Unit u : BitcoinUnits::availableUnits()) {
         QAction *menuAction =
             new QAction(QString(BitcoinUnits::longName(u)), this);
         menuAction->setData(QVariant(u));
         menu->addAction(menuAction);
     }
     connect(menu, &QMenu::triggered, this,
             &UnitDisplayStatusBarControl::onMenuSelection);
 }
 
 /** Lets the control know about the Options Model (and its signals) */
 void UnitDisplayStatusBarControl::setOptionsModel(OptionsModel *_optionsModel) {
     if (_optionsModel) {
         this->optionsModel = _optionsModel;
 
         // be aware of a display unit change reported by the OptionsModel
         // object.
         connect(_optionsModel, &OptionsModel::displayUnitChanged, this,
                 &UnitDisplayStatusBarControl::updateDisplayUnit);
 
         // initialize the display units label with the current value in the
         // model.
         updateDisplayUnit(_optionsModel->getDisplayUnit());
     }
 }
 
 /** When Display Units are changed on OptionsModel it will refresh the display
  * text of the control on the status bar */
 void UnitDisplayStatusBarControl::updateDisplayUnit(int newUnits) {
     setText(BitcoinUnits::longName(newUnits));
 }
 
 /** Shows context menu with Display Unit options by the mouse coordinates */
 void UnitDisplayStatusBarControl::onDisplayUnitsClicked(const QPoint &point) {
     QPoint globalPos = mapToGlobal(point);
     menu->exec(globalPos);
 }
 
 /** Tells underlying optionsModel to update its current display unit. */
 void UnitDisplayStatusBarControl::onMenuSelection(QAction *action) {
     if (action) {
         optionsModel->setDisplayUnit(action->data());
     }
 }
diff --git a/src/qt/bitcoinstrings.cpp b/src/qt/bitcoinstrings.cpp
index bafa1659e..651e0f147 100644
--- a/src/qt/bitcoinstrings.cpp
+++ b/src/qt/bitcoinstrings.cpp
@@ -1,191 +1,182 @@
 #include <QtGlobal>
 // Automatically @generated by extract_strings_qt.py
 
 #ifdef __GNUC__
 #define UNUSED __attribute__((unused))
 #else
 #define UNUSED
 #endif
 static const char UNUSED *bitcoin_strings[] = {
-QT_TRANSLATE_NOOP("bitcoin-abc", "Bitcoin ABC"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "The %s developers"),
-QT_TRANSLATE_NOOP("bitcoin-abc", "Bitcoin"),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "-maxtxfee is set very high! Fees this large could be paid on a single "
 "transaction."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
-"Accept relayed transactions received from whitelisted peers even when not "
-"relaying transactions (default: %d)"),
-QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Can't generate a change-address key. Private keys are disabled for this "
 "wallet."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Cannot obtain a lock on data directory %s. %s is probably already running."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Cannot provide specific connections and have addrman find outgoing "
 "connections at the same."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Cannot upgrade a non HD split wallet without upgrading to support pre split "
 "keypool. Please use -upgradewallet=200300 or -upgradewallet with no version "
 "specified."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Distributed under the MIT software license, see the accompanying file %s or "
 "%s"),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Error reading %s! All keys read correctly, but transaction data or address "
 "book entries might be missing or incorrect."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Error: Listening for incoming connections failed (listen returned error %s)"),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Invalid amount for -maxtxfee=<amount>: '%s' (must be at least the minrelay "
 "fee of %s to prevent stuck transactions)"),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Max generated block size (blockmaxsize) cannot exceed the excessive block "
 "size (excessiveblocksize)"),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Please check that your computer's date and time are correct! If your clock "
 "is wrong, %s will not work properly."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Please contribute if you find %s useful. Visit %s for further information "
 "about the software."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Prune configured below the minimum of %d MiB.  Please use a higher number."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Prune: last wallet synchronisation goes beyond pruned data. You need to -"
 "reindex (download the whole blockchain again in case of pruned node)"),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Rescans are not possible in pruned mode. You will need to use -reindex which "
 "will download the whole blockchain again."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "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"),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "The transaction amount is too small to send after the fee has been deducted"),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "This is a pre-release test build - use at your own risk - do not use for "
 "mining or merchant applications"),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "This is the transaction fee you may pay when fee estimates are not available."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "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."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Total length of network version string (%i) exceeds maximum length (%i). "
 "Reduce the number or size of uacomments."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Unable to replay blocks. You will need to rebuild the database using -"
 "reindex-chainstate."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Warning: Private keys detected in wallet {%s} with disabled private keys"),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Warning: The network does not appear to fully agree! Some miners appear to "
 "be experiencing issues."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Warning: Wallet file corrupt, data salvaged! Original %s saved as %s in %s; "
 "if your balance or transactions are incorrect you should restore from a "
 "backup."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "Warning: We do not appear to fully agree with our peers! You may need to "
 "upgrade, or other nodes may need to upgrade."),
 QT_TRANSLATE_NOOP("bitcoin-abc", ""
 "You need to rebuild the database using -reindex to go back to unpruned "
 "mode.  This will redownload the entire blockchain"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "%s corrupt, salvage failed"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "%s is set very high!"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "-maxmempool must be at least %d MB"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Cannot downgrade wallet"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Cannot resolve -%s address: '%s'"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Cannot write to data directory '%s'; check permissions."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Change index out of range"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Config setting for %s only applied on %s network when in [%s] section."),
-QT_TRANSLATE_NOOP("bitcoin-abc", "Connect through SOCKS5 proxy"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Copyright (C) %i-%i"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Corrupted block database detected"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Do you want to rebuild the block database now?"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Done loading"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error initializing block database"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error initializing wallet database environment %s!"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error loading %s"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error loading %s: Private keys can only be disabled during creation"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error loading %s: Wallet corrupted"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error loading %s: Wallet requires newer version of %s"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error loading block database"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error loading wallet %s. Duplicate -wallet filename specified."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error opening block database"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error reading from database, shutting down."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error upgrading chainstate database"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error: A fatal internal error occurred, see debug.log for details"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error: Disk space is low for %s"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Error: Disk space is low!"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Excessive block size must be > 1,000,000 bytes (1MB)"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Failed to listen on any port. Use -listen=0 if you want this."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Failed to rescan the wallet during initialization"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Importing..."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Incorrect or no genesis block found. Wrong datadir for network?"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Information"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Initialization sanity check failed. %s is shutting down."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Insufficient funds"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Invalid -onion address or hostname: '%s'"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Invalid -proxy address or hostname: '%s'"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Invalid amount for -%s=<amount>: '%s'"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Invalid amount for -fallbackfee=<amount>: '%s'"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Invalid amount for -paytxfee=<amount>: '%s' (must be at least %s)"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Invalid netmask specified in -whitelist: '%s'"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Keypool ran out, please call keypoolrefill first"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Loading P2P addresses..."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Loading banlist..."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Loading block index..."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Loading wallet..."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Need to specify a port with -whitebind: '%s'"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Not enough file descriptors available."),
-QT_TRANSLATE_NOOP("bitcoin-abc", "Password for JSON-RPC connections"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Prune cannot be configured with a negative value."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Prune mode is incompatible with -txindex."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Pruning blockstore..."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Reducing -maxconnections from %d to %d, because of system limitations."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Replaying blocks..."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Rescanning..."),
-QT_TRANSLATE_NOOP("bitcoin-abc", "Run in the background as a daemon and accept commands"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Section [%s] is not recognized."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Signing transaction failed"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Specified -walletdir \"%s\" does not exist"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Specified -walletdir \"%s\" is a relative path"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Specified -walletdir \"%s\" is not a directory"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Specified blocks directory \"%s\" does not exist."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Starting network threads..."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "The source code is available from %s."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "The transaction amount is too small to pay the fee"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "The wallet will avoid paying less than the minimum relay fee."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "This is experimental software."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "This is the minimum transaction fee you pay on every transaction."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "This is the transaction fee you will pay if you send a transaction."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Transaction amount too small"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Transaction amounts must not be negative"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Transaction fee and change calculation failed"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Transaction has too long of a mempool chain"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Transaction must have at least one recipient"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Transaction too large for fee policy"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Transaction too large"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Unable to bind to %s on this computer (bind returned error %s)"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Unable to bind to %s on this computer. %s is probably already running."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Unable to create the PID file '%s': %s"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Unable to generate initial keys"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Unable to generate keys"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Unable to start HTTP server. See debug log for details."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Unknown network specified in -onlynet: '%s'"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Unsupported logging category %s=%s."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Upgrading UTXO database"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Upgrading txindex database"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "User Agent comment (%s) contains unsafe characters."),
-QT_TRANSLATE_NOOP("bitcoin-abc", "Username for JSON-RPC connections"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Verifying blocks..."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Verifying wallet(s)..."),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Wallet %s resides outside wallet directory %s"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Wallet needed to be rewritten: restart %s to complete"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Warning"),
 QT_TRANSLATE_NOOP("bitcoin-abc", "Zapping all transactions from wallet..."),
 };
diff --git a/src/qt/intro.cpp b/src/qt/intro.cpp
index c66e24ba4..c975756c4 100644
--- a/src/qt/intro.cpp
+++ b/src/qt/intro.cpp
@@ -1,340 +1,339 @@
 // 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 <fs.h>
 #include <interfaces/node.h>
 #include <qt/forms/ui_intro.h>
 #include <qt/guiutil.h>
 #include <qt/intro.h>
 #include <util/system.h>
 
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QSettings>
 
 #include <cmath>
 
 static const uint64_t GB_BYTES = 1000000000LL;
 /**
  * Total required space (in GB) depending on user choice (prune, not prune).
  */
 static uint64_t requiredSpace;
 
 /* Check free space asynchronously to prevent hanging the UI thread.
 
    Up to one request to check a path is in flight to this thread; when the
    check()
    function runs, the current path is requested from the associated Intro
    object.
    The reply is sent back through a signal.
 
    This ensures that no queue of checking requests is built up while the user is
    still entering the path, and that always the most recently entered path is
    checked as
    soon as the thread becomes available.
 */
 class FreespaceChecker : public QObject {
     Q_OBJECT
 
 public:
     explicit FreespaceChecker(Intro *intro);
 
     enum Status { ST_OK, ST_ERROR };
 
 public Q_SLOTS:
     void check();
 
 Q_SIGNALS:
     void reply(int status, const QString &message, quint64 available);
 
 private:
     Intro *intro;
 };
 
 #include <qt/intro.moc>
 
 FreespaceChecker::FreespaceChecker(Intro *_intro) {
     this->intro = _intro;
 }
 
 void FreespaceChecker::check() {
     QString dataDirStr = intro->getPathToCheck();
     fs::path dataDir = GUIUtil::qstringToBoostPath(dataDirStr);
     uint64_t freeBytesAvailable = 0;
     int replyStatus = ST_OK;
     QString replyMessage = tr("A new data directory will be created.");
 
     /* Find first parent that exists, so that fs::space does not fail */
     fs::path parentDir = dataDir;
     fs::path parentDirOld = fs::path();
     while (parentDir.has_parent_path() && !fs::exists(parentDir)) {
         parentDir = parentDir.parent_path();
 
         /* Check if we make any progress, break if not to prevent an infinite
          * loop here */
         if (parentDirOld == parentDir) {
             break;
         }
 
         parentDirOld = parentDir;
     }
 
     try {
         freeBytesAvailable = fs::space(parentDir).available;
         if (fs::exists(dataDir)) {
             if (fs::is_directory(dataDir)) {
                 QString separator = "<code>" + QDir::toNativeSeparators("/") +
                                     tr("name") + "</code>";
                 replyStatus = ST_OK;
                 replyMessage = tr("Directory already exists. Add %1 if you "
                                   "intend to create a new directory here.")
                                    .arg(separator);
             } else {
                 replyStatus = ST_ERROR;
                 replyMessage =
                     tr("Path already exists, and is not a directory.");
             }
         }
     } catch (const fs::filesystem_error &) {
         /* Parent directory does not exist or is not accessible */
         replyStatus = ST_ERROR;
         replyMessage = tr("Cannot create data directory here.");
     }
     Q_EMIT reply(replyStatus, replyMessage, freeBytesAvailable);
 }
 
 Intro::Intro(QWidget *parent, uint64_t blockchain_size,
              uint64_t chain_state_size)
     : QDialog(parent), ui(new Ui::Intro), thread(nullptr), signalled(false),
       m_blockchain_size(blockchain_size), m_chain_state_size(chain_state_size) {
     ui->setupUi(this);
-    ui->welcomeLabel->setText(ui->welcomeLabel->text().arg(tr(PACKAGE_NAME)));
-    ui->storageLabel->setText(ui->storageLabel->text().arg(tr(PACKAGE_NAME)));
+    ui->welcomeLabel->setText(ui->welcomeLabel->text().arg(PACKAGE_NAME));
+    ui->storageLabel->setText(ui->storageLabel->text().arg(PACKAGE_NAME));
 
     ui->lblExplanation1->setText(ui->lblExplanation1->text()
-                                     .arg(tr(PACKAGE_NAME))
+                                     .arg(PACKAGE_NAME)
                                      .arg(m_blockchain_size)
                                      .arg(2009)
                                      .arg(tr("Bitcoin")));
-    ui->lblExplanation2->setText(
-        ui->lblExplanation2->text().arg(tr(PACKAGE_NAME)));
+    ui->lblExplanation2->setText(ui->lblExplanation2->text().arg(PACKAGE_NAME));
 
     uint64_t pruneTarget = std::max<int64_t>(0, gArgs.GetArg("-prune", 0));
     requiredSpace = m_blockchain_size;
     QString storageRequiresMsg =
         tr("At least %1 GB of data will be stored in this directory, and it "
            "will grow over time.");
     if (pruneTarget) {
         uint64_t prunedGBs = std::ceil(pruneTarget * 1024 * 1024.0 / GB_BYTES);
         if (prunedGBs <= requiredSpace) {
             requiredSpace = prunedGBs;
             storageRequiresMsg = tr("Approximately %1 GB of data will be "
                                     "stored in this directory.");
         }
         ui->lblExplanation3->setVisible(true);
     } else {
         ui->lblExplanation3->setVisible(false);
     }
     requiredSpace += m_chain_state_size;
     ui->sizeWarningLabel->setText(
         tr("%1 will download and store a copy of the Bitcoin block chain.")
-            .arg(tr(PACKAGE_NAME)) +
+            .arg(PACKAGE_NAME) +
         " " + storageRequiresMsg.arg(requiredSpace) + " " +
         tr("The wallet will also be stored in this directory."));
     startThread();
 }
 
 Intro::~Intro() {
     delete ui;
     /* Ensure thread is finished before it is deleted */
     Q_EMIT stopThread();
     thread->wait();
 }
 
 QString Intro::getDataDirectory() {
     return ui->dataDirectory->text();
 }
 
 void Intro::setDataDirectory(const QString &dataDir) {
     ui->dataDirectory->setText(dataDir);
     if (dataDir == getDefaultDataDirectory()) {
         ui->dataDirDefault->setChecked(true);
         ui->dataDirectory->setEnabled(false);
         ui->ellipsisButton->setEnabled(false);
     } else {
         ui->dataDirCustom->setChecked(true);
         ui->dataDirectory->setEnabled(true);
         ui->ellipsisButton->setEnabled(true);
     }
 }
 
 QString Intro::getDefaultDataDirectory() {
     return GUIUtil::boostPathToQString(GetDefaultDataDir());
 }
 
 bool Intro::pickDataDirectory(interfaces::Node &node) {
     QSettings settings;
     /* If data directory provided on command line, no need to look at settings
        or show a picking dialog */
     if (!gArgs.GetArg("-datadir", "").empty()) {
         return true;
     }
     /* 1) Default data directory for operating system */
     QString dataDir = getDefaultDataDirectory();
     /* 2) Allow QSettings to override default dir */
     dataDir = settings.value("strDataDir", dataDir).toString();
 
     if (!fs::exists(GUIUtil::qstringToBoostPath(dataDir)) ||
         gArgs.GetBoolArg("-choosedatadir", DEFAULT_CHOOSE_DATADIR) ||
         settings.value("fReset", false).toBool() ||
         gArgs.GetBoolArg("-resetguisettings", false)) {
         /**
          * Use selectParams here to guarantee Params() can be used by node
          * interface.
          */
         try {
             node.selectParams(gArgs.GetChainName());
         } catch (const std::exception &) {
             return false;
         }
 
         /**
          * If current default data directory does not exist, let the user choose
          * one.
          */
         Intro intro(nullptr, node.getAssumedBlockchainSize(),
                     node.getAssumedChainStateSize());
         intro.setDataDirectory(dataDir);
         intro.setWindowIcon(QIcon(":icons/bitcoin"));
 
         while (true) {
             if (!intro.exec()) {
                 /* Cancel clicked */
                 return false;
             }
             dataDir = intro.getDataDirectory();
             try {
                 if (TryCreateDirectories(
                         GUIUtil::qstringToBoostPath(dataDir))) {
                     // If a new data directory has been created, make wallets
                     // subdirectory too
                     TryCreateDirectories(GUIUtil::qstringToBoostPath(dataDir) /
                                          "wallets");
                 }
                 break;
             } catch (const fs::filesystem_error &) {
-                QMessageBox::critical(nullptr, tr(PACKAGE_NAME),
+                QMessageBox::critical(nullptr, PACKAGE_NAME,
                                       tr("Error: Specified data directory "
                                          "\"%1\" cannot be created.")
                                           .arg(dataDir));
                 /* fall through, back to choosing screen */
             }
         }
 
         settings.setValue("strDataDir", dataDir);
         settings.setValue("fReset", false);
     }
     /* Only override -datadir if different from the default, to make it possible
      * to
      * override -datadir in the bitcoin.conf file in the default data directory
      * (to be consistent with bitcoind behavior)
      */
     if (dataDir != getDefaultDataDirectory()) {
         // use OS locale for path setting
         node.softSetArg("-datadir",
                         GUIUtil::qstringToBoostPath(dataDir).string());
     }
     return true;
 }
 
 void Intro::setStatus(int status, const QString &message,
                       quint64 bytesAvailable) {
     switch (status) {
         case FreespaceChecker::ST_OK:
             ui->errorMessage->setText(message);
             ui->errorMessage->setStyleSheet("");
             break;
         case FreespaceChecker::ST_ERROR:
             ui->errorMessage->setText(tr("Error") + ": " + message);
             ui->errorMessage->setStyleSheet("QLabel { color: #800000 }");
             break;
     }
     /* Indicate number of bytes available */
     if (status == FreespaceChecker::ST_ERROR) {
         ui->freeSpace->setText("");
     } else {
         QString freeString =
             tr("%n GB of free space available", "", bytesAvailable / GB_BYTES);
         if (bytesAvailable < requiredSpace * GB_BYTES) {
             freeString += " " + tr("(of %n GB needed)", "", requiredSpace);
             ui->freeSpace->setStyleSheet("QLabel { color: #800000 }");
         } else {
             ui->freeSpace->setStyleSheet("");
         }
         ui->freeSpace->setText(freeString + ".");
     }
     /* Don't allow confirm in ERROR state */
     ui->buttonBox->button(QDialogButtonBox::Ok)
         ->setEnabled(status != FreespaceChecker::ST_ERROR);
 }
 
 void Intro::on_dataDirectory_textChanged(const QString &dataDirStr) {
     /* Disable OK button until check result comes in */
     ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
     checkPath(dataDirStr);
 }
 
 void Intro::on_ellipsisButton_clicked() {
     QString dir = QDir::toNativeSeparators(QFileDialog::getExistingDirectory(
         nullptr, "Choose data directory", ui->dataDirectory->text()));
     if (!dir.isEmpty()) {
         ui->dataDirectory->setText(dir);
     }
 }
 
 void Intro::on_dataDirDefault_clicked() {
     setDataDirectory(getDefaultDataDirectory());
 }
 
 void Intro::on_dataDirCustom_clicked() {
     ui->dataDirectory->setEnabled(true);
     ui->ellipsisButton->setEnabled(true);
 }
 
 void Intro::startThread() {
     thread = new QThread(this);
     FreespaceChecker *executor = new FreespaceChecker(this);
     executor->moveToThread(thread);
 
     connect(executor, &FreespaceChecker::reply, this, &Intro::setStatus);
     connect(this, &Intro::requestCheck, executor, &FreespaceChecker::check);
     /*  make sure executor object is deleted in its own thread */
     connect(this, &Intro::stopThread, executor, &QObject::deleteLater);
     connect(this, &Intro::stopThread, thread, &QThread::quit);
 
     thread->start();
 }
 
 void Intro::checkPath(const QString &dataDir) {
     mutex.lock();
     pathToCheck = dataDir;
     if (!signalled) {
         signalled = true;
         Q_EMIT requestCheck();
     }
     mutex.unlock();
 }
 
 QString Intro::getPathToCheck() {
     QString retval;
     mutex.lock();
     retval = pathToCheck;
     signalled = false; /* new request can be queued now */
     mutex.unlock();
     return retval;
 }
diff --git a/src/qt/locale/bitcoin_en.ts b/src/qt/locale/bitcoin_en.ts
index 0eac7512e..9df9873cd 100644
--- a/src/qt/locale/bitcoin_en.ts
+++ b/src/qt/locale/bitcoin_en.ts
@@ -1,4585 +1,4547 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE TS>
 <TS version="2.1" language="en">
 <context>
     <name>AddressBookPage</name>
     <message>
         <location filename="../forms/addressbookpage.ui" line="+37"/>
         <source>Right-click to edit address or label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+27"/>
         <source>Create a new address</source>
         <translation>Create a new address</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>&amp;New</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+14"/>
         <source>Copy the currently selected address to the system clipboard</source>
         <translation>Copy the currently selected address to the system clipboard</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>&amp;Copy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+67"/>
         <source>C&amp;lose</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-53"/>
         <source>Delete the currently selected address from the list</source>
         <translation>Delete the currently selected address from the list</translation>
     </message>
     <message>
         <location line="-71"/>
         <source>Enter address or label to search</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+101"/>
         <source>Export the data in the current tab to a file</source>
         <translation>Export the data in the current tab to a file</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>&amp;Export</source>
         <translation>&amp;Export</translation>
     </message>
     <message>
         <location line="-30"/>
         <source>&amp;Delete</source>
         <translation>&amp;Delete</translation>
     </message>
     <message>
         <location filename="../addressbookpage.cpp" line="+81"/>
         <source>Choose the address to send coins to</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Choose the address to receive coins with</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>C&amp;hoose</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Sending addresses</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Receiving addresses</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+8"/>
         <source>These are your Bitcoin addresses for sending payments. Always check the amount and the receiving address before sending coins.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+8"/>
         <source>These are your Bitcoin addresses for receiving payments. It is recommended to use a new receiving address for each transaction.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+9"/>
         <source>&amp;Copy Address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy &amp;Label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>&amp;Edit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+181"/>
         <source>Export Address List</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Comma separated file (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+14"/>
         <source>Exporting Failed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>There was an error trying to save the address list to %1. Please try again.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>AddressTableModel</name>
     <message>
         <location filename="../addresstablemodel.cpp" line="+162"/>
         <source>Label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+0"/>
         <source>Address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+31"/>
         <source>(no label)</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>AskPassphraseDialog</name>
     <message>
         <location filename="../forms/askpassphrasedialog.ui" line="+26"/>
         <source>Passphrase Dialog</source>
         <translation>Passphrase Dialog</translation>
     </message>
     <message>
         <location line="+30"/>
         <source>Enter passphrase</source>
         <translation>Enter passphrase</translation>
     </message>
     <message>
         <location line="+14"/>
         <source>New passphrase</source>
         <translation>New passphrase</translation>
     </message>
     <message>
         <location line="+14"/>
         <source>Repeat new passphrase</source>
         <translation>Repeat new passphrase</translation>
     </message>
     <message>
         <location line="+14"/>
         <source>Show password</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../askpassphrasedialog.cpp" line="+41"/>
         <source>Enter the new passphrase to the wallet.&lt;br/&gt;Please use a passphrase of &lt;b&gt;ten or more random characters&lt;/b&gt;, or &lt;b&gt;eight or more words&lt;/b&gt;.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Encrypt wallet</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>This operation needs your wallet passphrase to unlock the wallet.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Unlock wallet</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>This operation needs your wallet passphrase to decrypt the wallet.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Decrypt wallet</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Change passphrase</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Enter the old passphrase and new passphrase to the wallet.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+48"/>
         <source>Confirm wallet encryption</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Warning: If you encrypt your wallet and lose your passphrase, you will &lt;b&gt;LOSE ALL OF YOUR BITCOINS&lt;/b&gt;!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Are you sure you wish to encrypt your wallet?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <location line="+55"/>
         <source>Wallet encrypted</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-53"/>
         <source>Your wallet is now encrypted. Remember that encrypting your wallet cannot fully protect your bitcoins from being stolen by malware infecting your computer.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>IMPORTANT: Any previous backups you have made of your wallet file should be replaced with the newly generated, encrypted wallet file. For security reasons, previous backups of the unencrypted wallet file will become useless as soon as you start using the new, encrypted wallet.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+11"/>
         <location line="+7"/>
         <location line="+34"/>
         <location line="+6"/>
         <source>Wallet encryption failed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-46"/>
         <source>Wallet encryption failed due to an internal error. Your wallet was not encrypted.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <location line="+40"/>
         <source>The supplied passphrases do not match.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-32"/>
         <source>Wallet unlock failed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <location line="+9"/>
         <location line="+16"/>
         <source>The passphrase entered for the wallet decryption was incorrect.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-17"/>
         <source>Wallet decryption failed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+12"/>
         <source>Wallet passphrase was successfully changed.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+46"/>
         <location line="+32"/>
         <source>Warning: The Caps Lock key is on!</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>BanTableModel</name>
     <message>
         <location filename="../bantablemodel.cpp" line="+85"/>
         <source>IP/Netmask</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+0"/>
         <source>Banned Until</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>BitcoinGUI</name>
     <message>
         <location filename="../bitcoingui.cpp" line="+361"/>
         <source>Sign &amp;message...</source>
         <translation>Sign &amp;message...</translation>
     </message>
     <message>
         <location line="+598"/>
         <source>Synchronizing with network...</source>
         <translation>Synchronizing with network...</translation>
     </message>
     <message>
         <location line="-720"/>
         <source>&amp;Overview</source>
         <translation>&amp;Overview</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Show general overview of wallet</source>
         <translation>Show general overview of wallet</translation>
     </message>
     <message>
         <location line="+24"/>
         <source>Request payments (generates QR codes and %1: URIs)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+16"/>
         <source>&amp;Transactions</source>
         <translation>&amp;Transactions</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Browse transaction history</source>
         <translation>Browse transaction history</translation>
     </message>
     <message>
         <location line="+37"/>
         <source>E&amp;xit</source>
         <translation>E&amp;xit</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Quit application</source>
         <translation>Quit application</translation>
     </message>
     <message>
         <location line="+4"/>
         <source>&amp;About %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Show information about %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>About &amp;Qt</source>
         <translation>About &amp;Qt</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Show information about Qt</source>
         <translation>Show information about Qt</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>&amp;Options...</source>
         <translation>&amp;Options...</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Modify configuration options for %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>&amp;Encrypt Wallet...</source>
         <translation>&amp;Encrypt Wallet...</translation>
     </message>
     <message>
         <location line="+6"/>
         <source>&amp;Backup Wallet...</source>
         <translation>&amp;Backup Wallet...</translation>
     </message>
     <message>
         <location line="+4"/>
         <source>&amp;Change Passphrase...</source>
         <translation>&amp;Change Passphrase...</translation>
     </message>
     <message>
         <location line="+26"/>
         <source>&amp;Sending addresses...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>&amp;Receiving addresses...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Open &amp;URI...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Open a %1: URI or payment request</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+127"/>
         <source>Wallet:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+363"/>
         <source>Click to disable network activity.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Network activity disabled.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Click to enable network activity again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+28"/>
         <source>Syncing Headers (%1%)...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+55"/>
         <source>Reindexing blocks on disk...</source>
         <translation>Reindexing blocks on disk...</translation>
     </message>
     <message>
         <location line="+325"/>
         <source>Proxy is &lt;b&gt;enabled&lt;/b&gt;: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-1047"/>
         <source>Send coins to a Bitcoin address</source>
         <translation>Send coins to a Bitcoin address</translation>
     </message>
     <message>
         <location line="+105"/>
         <source>Backup wallet to another location</source>
         <translation>Backup wallet to another location</translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Change the passphrase used for wallet encryption</source>
         <translation>Change the passphrase used for wallet encryption</translation>
     </message>
     <message>
         <location line="+15"/>
         <source>&amp;Debug window</source>
         <translation>&amp;Debug window</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Open debugging and diagnostic console</source>
         <translation>Open debugging and diagnostic console</translation>
     </message>
     <message>
         <location line="-9"/>
         <source>&amp;Verify message...</source>
         <translation>&amp;Verify message...</translation>
     </message>
     <message>
         <location line="+682"/>
         <source>Bitcoin</source>
         <translation>Bitcoin</translation>
     </message>
     <message>
         <location line="-801"/>
         <source>&amp;Send</source>
         <translation>&amp;Send</translation>
     </message>
     <message>
         <location line="+15"/>
         <source>&amp;Receive</source>
         <translation>&amp;Receive</translation>
     </message>
     <message>
         <location line="+79"/>
         <source>&amp;Show / Hide</source>
         <translation>&amp;Show / Hide</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Show or hide the main Window</source>
         <translation>Show or hide the main Window</translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Encrypt the private keys that belong to your wallet</source>
         <translation>Encrypt the private keys that belong to your wallet</translation>
     </message>
     <message>
         <location line="+15"/>
         <source>Sign messages with your Bitcoin addresses to prove you own them</source>
         <translation>Sign messages with your Bitcoin addresses to prove you own them</translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Verify messages to ensure they were signed with specified Bitcoin addresses</source>
         <translation>Verify messages to ensure they were signed with specified Bitcoin addresses</translation>
     </message>
     <message>
         <location line="+97"/>
         <source>&amp;File</source>
         <translation>&amp;File</translation>
     </message>
     <message>
         <location line="+13"/>
         <source>&amp;Settings</source>
         <translation>&amp;Settings</translation>
     </message>
     <message>
         <location line="+8"/>
         <source>&amp;Help</source>
         <translation>&amp;Help</translation>
     </message>
     <message>
         <location line="+12"/>
         <source>Tabs toolbar</source>
         <translation>Tabs toolbar</translation>
     </message>
     <message>
         <location line="-114"/>
         <source>Show the list of used sending addresses and labels</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Show the list of used receiving addresses and labels</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+11"/>
         <source>&amp;Command-line options</source>
         <translation type="unfinished"></translation>
     </message>
     <message numerus="yes">
         <location line="+483"/>
         <source>%n active connection(s) to Bitcoin network</source>
         <translation>
             <numerusform>%n active connection to Bitcoin network</numerusform>
             <numerusform>%n active connections to Bitcoin network</numerusform>
         </translation>
     </message>
     <message>
         <location line="+81"/>
         <source>Indexing blocks on disk...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Processing blocks on disk...</source>
         <translation type="unfinished"></translation>
     </message>
     <message numerus="yes">
         <location line="+19"/>
         <source>Processed %n block(s) of transaction history.</source>
         <translation>
             <numerusform>Processed %n block of transaction history.</numerusform>
             <numerusform>Processed %n blocks of transaction history.</numerusform>
         </translation>
     </message>
     <message>
         <location line="+22"/>
         <source>%1 behind</source>
         <translation>%1 behind</translation>
     </message>
     <message>
         <location line="+25"/>
         <source>Last received block was generated %1 ago.</source>
         <translation>Last received block was generated %1 ago.</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Transactions after this will not yet be visible.</source>
         <translation>Transactions after this will not yet be visible.</translation>
     </message>
     <message>
         <location line="+27"/>
         <source>Error</source>
         <translation>Error</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Warning</source>
         <translation>Warning</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Information</source>
         <translation>Information</translation>
     </message>
     <message>
         <location line="-78"/>
         <source>Up to date</source>
         <translation>Up to date</translation>
     </message>
     <message>
         <location line="-586"/>
         <source>Show the %1 help message to get a list with possible Bitcoin command-line options</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+310"/>
         <source>%1 client</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+263"/>
         <source>Connecting to peers...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+36"/>
         <source>Catching up...</source>
         <translation>Catching up...</translation>
     </message>
     <message>
         <location line="+152"/>
         <source>Date: %1
 </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Amount: %1
 </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Wallet: %1
 </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Type: %1
 </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Label: %1
 </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Address: %1
 </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Sent transaction</source>
         <translation>Sent transaction</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Incoming transaction</source>
         <translation>Incoming transaction</translation>
     </message>
     <message>
         <location line="+51"/>
         <source>HD key generation is &lt;b&gt;enabled&lt;/b&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>HD key generation is &lt;b&gt;disabled&lt;/b&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+20"/>
         <source>Wallet is &lt;b&gt;encrypted&lt;/b&gt; and currently &lt;b&gt;unlocked&lt;/b&gt;</source>
         <translation>Wallet is &lt;b&gt;encrypted&lt;/b&gt; and currently &lt;b&gt;unlocked&lt;/b&gt;</translation>
     </message>
     <message>
         <location line="+12"/>
         <source>Wallet is &lt;b&gt;encrypted&lt;/b&gt; and currently &lt;b&gt;locked&lt;/b&gt;</source>
         <translation>Wallet is &lt;b&gt;encrypted&lt;/b&gt; and currently &lt;b&gt;locked&lt;/b&gt;</translation>
     </message>
     <message>
         <location filename="../bitcoin.cpp" line="+429"/>
         <source>A fatal error occurred. Bitcoin can no longer continue safely and will quit.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>CoinControlDialog</name>
     <message>
         <location filename="../forms/coincontroldialog.ui" line="+14"/>
         <source>Coin Selection</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+34"/>
         <source>Quantity:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+29"/>
         <source>Bytes:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+45"/>
         <source>Amount:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+80"/>
         <source>Fee:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-48"/>
         <source>Dust:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+93"/>
         <source>After Fee:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+32"/>
         <source>Change:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+56"/>
         <source>(un)select all</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+16"/>
         <source>Tree mode</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+13"/>
         <source>List mode</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+56"/>
         <source>Amount</source>
         <translation type="unfinished">Amount</translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Received with label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Received with address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Date</source>
         <translation type="unfinished">Date</translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Confirmations</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Confirmed</source>
         <translation type="unfinished">Confirmed</translation>
     </message>
     <message>
         <location filename="../coincontroldialog.cpp" line="+59"/>
         <source>Copy address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <location line="+36"/>
         <source>Copy amount</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-34"/>
         <source>Copy transaction ID</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Lock unspent</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Unlock unspent</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+29"/>
         <source>Copy quantity</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Copy fee</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy after fee</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy bytes</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy dust</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy change</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+349"/>
         <source>(%1 locked)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+164"/>
         <source>yes</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+0"/>
         <source>no</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+17"/>
         <source>This label turns red if any recipient receives an amount smaller than the current dust threshold.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Can vary +/- %1 satoshi(s) per input.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+64"/>
         <location line="+59"/>
         <source>(no label)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-8"/>
         <source>change from %1 (%2)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>(change)</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>EditAddressDialog</name>
     <message>
         <location filename="../forms/editaddressdialog.ui" line="+14"/>
         <source>Edit Address</source>
         <translation>Edit Address</translation>
     </message>
     <message>
         <location line="+11"/>
         <source>&amp;Label</source>
         <translation>&amp;Label</translation>
     </message>
     <message>
         <location line="+10"/>
         <source>The label associated with this address list entry</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+17"/>
         <source>The address associated with this address list entry. This can only be modified for sending addresses.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-10"/>
         <source>&amp;Address</source>
         <translation>&amp;Address</translation>
     </message>
     <message>
         <location filename="../editaddressdialog.cpp" line="+23"/>
         <source>New sending address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Edit receiving address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Edit sending address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+68"/>
         <source>The entered address &quot;%1&quot; is not a valid Bitcoin address.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+33"/>
         <source>Address &quot;%1&quot; already exists as a receiving address with label &quot;%2&quot; and so cannot be added as a sending address.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>The entered address &quot;%1&quot; is already in the address book with label &quot;%2&quot;.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-27"/>
         <source>Could not unlock wallet.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>New key generation failed.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>FreespaceChecker</name>
     <message>
         <location filename="../intro.cpp" line="+70"/>
         <source>A new data directory will be created.</source>
         <translation>A new data directory will be created.</translation>
     </message>
     <message>
         <location line="+22"/>
         <source>name</source>
         <translation>name</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Directory already exists. Add %1 if you intend to create a new directory here.</source>
         <translation>Directory already exists. Add %1 if you intend to create a new directory here.</translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Path already exists, and is not a directory.</source>
         <translation>Path already exists, and is not a directory.</translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Cannot create data directory here.</source>
         <translation>Cannot create data directory here.</translation>
     </message>
 </context>
 <context>
     <name>HelpMessageDialog</name>
     <message>
         <location filename="../utilitydialog.cpp" line="+40"/>
         <source>version</source>
         <translation type="unfinished">version</translation>
     </message>
     <message>
         <location line="+8"/>
         <location line="+2"/>
         <source>(%1-bit)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>About %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+19"/>
         <source>Command-line options</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>Intro</name>
     <message>
         <location filename="../forms/intro.ui" line="+14"/>
         <source>Welcome</source>
         <translation>Welcome</translation>
     </message>
     <message>
         <location line="+9"/>
         <source>Welcome to %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+26"/>
         <source>As this is the first time the program is launched, you can choose where %1 will store its data.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+157"/>
         <source>When you click OK, %1 will begin to download and process the full %4 block chain (%2GB) starting with the earliest transactions in %3 when %4 initially launched.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>This initial synchronisation is very demanding, and may expose hardware problems with your computer that had previously gone unnoticed. Each time you run %1, it will continue downloading where it left off.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>If you have chosen to limit block chain storage (pruning), the historical data must still be downloaded and processed, but will be deleted afterward to keep your disk usage low.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-160"/>
         <source>Use the default data directory</source>
         <translation>Use the default data directory</translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Use a custom data directory:</source>
         <translation>Use a custom data directory:</translation>
     </message>
     <message>
         <location filename="../intro.cpp" line="+17"/>
         <source>Bitcoin</source>
         <translation type="unfinished">Bitcoin</translation>
     </message>
     <message>
-        <location line="+7"/>
+        <location line="+6"/>
         <source>At least %1 GB of data will be stored in this directory, and it will grow over time.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Approximately %1 GB of data will be stored in this directory.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+9"/>
         <source>%1 will download and store a copy of the Bitcoin block chain.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>The wallet will also be stored in this directory.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+84"/>
         <source>Error: Specified data directory &quot;%1&quot; cannot be created.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+31"/>
         <source>Error</source>
         <translation>Error</translation>
     </message>
     <message numerus="yes">
         <location line="+9"/>
         <source>%n GB of free space available</source>
         <translation>
             <numerusform>%n GB of free space available</numerusform>
             <numerusform>%n GB of free space available</numerusform>
         </translation>
     </message>
     <message numerus="yes">
         <location line="+2"/>
         <source>(of %n GB needed)</source>
         <translation>
             <numerusform>(of %n GB needed)</numerusform>
             <numerusform>(of %n GB needed)</numerusform>
         </translation>
     </message>
 </context>
 <context>
     <name>ModalOverlay</name>
     <message>
         <location filename="../forms/modaloverlay.ui" line="+14"/>
         <source>Form</source>
         <translation type="unfinished">Form</translation>
     </message>
     <message>
         <location line="+119"/>
         <source>Recent transactions may not yet be visible, and therefore your wallet&apos;s balance might be incorrect. This information will be correct once your wallet has finished synchronizing with the bitcoin network, as detailed below.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+19"/>
         <source>Attempting to spend bitcoins that are affected by not-yet-displayed transactions will not be accepted by the network.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+63"/>
         <source>Number of blocks left</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <location line="+26"/>
         <location filename="../modaloverlay.cpp" line="+148"/>
         <source>Unknown...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-13"/>
         <source>Last block time</source>
         <translation type="unfinished">Last block time</translation>
     </message>
     <message>
         <location line="+26"/>
         <source>Progress</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+34"/>
         <source>Progress increase per hour</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <location line="+20"/>
         <source>calculating...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-7"/>
         <source>Estimated time left until synced</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+37"/>
         <source>Hide</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../modaloverlay.cpp" line="-1"/>
         <source>Unknown. Syncing Headers (%1)...</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>OpenURIDialog</name>
     <message>
         <location filename="../forms/openuridialog.ui" line="+14"/>
         <source>Open URI</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Open payment request from URI or file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+9"/>
         <source>URI:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>Select payment request file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../openuridialog.cpp" line="+41"/>
         <source>Select payment request file to open</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>OptionsDialog</name>
     <message>
         <location filename="../forms/optionsdialog.ui" line="+14"/>
         <source>Options</source>
         <translation>Options</translation>
     </message>
     <message>
         <location line="+13"/>
         <source>&amp;Main</source>
         <translation>&amp;Main</translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Automatically start %1 after logging in to the system.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>&amp;Start %1 on system login</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+72"/>
         <source>Size of &amp;database cache</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+16"/>
         <source>MB</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+27"/>
         <source>Number of script &amp;verification threads</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+161"/>
         <location line="+187"/>
         <source>IP address of the proxy (e.g. IPv4: 127.0.0.1 / IPv6: ::1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-118"/>
         <location line="+23"/>
         <location line="+23"/>
         <source>Shows if the supplied default SOCKS5 proxy is used to reach peers via this network type.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+38"/>
         <source>Use separate SOCKS&amp;5 proxy to reach peers via Tor hidden services:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+108"/>
         <source>Hide the icon from the system tray.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>&amp;Hide tray icon</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+17"/>
         <source>Minimize instead of exit the application when the window is closed. When this option is enabled, the application will be closed only after selecting Exit in the menu.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+80"/>
         <location line="+13"/>
         <source>Third party URLs (e.g. a block explorer) that appear in the transactions tab as context menu items. %s in the URL is replaced by transaction hash. Multiple URLs are separated by vertical bar |.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+31"/>
         <source>Active command-line options that override above options:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+58"/>
         <source>Reset all client options to default.</source>
         <translation>Reset all client options to default.</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>&amp;Reset Options</source>
         <translation>&amp;Reset Options</translation>
     </message>
     <message>
         <location line="-529"/>
         <source>&amp;Network</source>
         <translation>&amp;Network</translation>
     </message>
     <message>
         <location line="-191"/>
         <source>Disables some advanced features but all blocks will still be fully validated. Reverting this setting requires re-downloading the entire blockchain. Actual disk usage may be somewhat higher.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Prune &amp;block storage to</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>GB</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+25"/>
         <source>Reverting this setting requires re-downloading the entire blockchain.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+68"/>
         <source>(0 = auto, &lt;0 = leave that many cores free)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+36"/>
         <source>W&amp;allet</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Expert</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+9"/>
         <source>Enable coin &amp;control features</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>If you disable the spending of unconfirmed change, the change from a transaction cannot be used until that transaction has at least one confirmation. This also affects how your balance is computed.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>&amp;Spend unconfirmed change</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+30"/>
         <source>Automatically open the Bitcoin client port on the router. This only works when your router supports UPnP and it is enabled.</source>
         <translation>Automatically open the Bitcoin client port on the router. This only works when your router supports UPnP and it is enabled.</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Map port using &amp;UPnP</source>
         <translation>Map port using &amp;UPnP</translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Accept connections from outside.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Allow incomin&amp;g connections</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Connect to the Bitcoin network through a SOCKS5 proxy.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>&amp;Connect through SOCKS5 proxy (default proxy):</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+9"/>
         <location line="+187"/>
         <source>Proxy &amp;IP:</source>
         <translation>Proxy &amp;IP:</translation>
     </message>
     <message>
         <location line="-155"/>
         <location line="+187"/>
         <source>&amp;Port:</source>
         <translation>&amp;Port:</translation>
     </message>
     <message>
         <location line="-162"/>
         <location line="+187"/>
         <source>Port of the proxy (e.g. 9050)</source>
         <translation>Port of the proxy (e.g. 9050)</translation>
     </message>
     <message>
         <location line="-163"/>
         <source>Used for reaching peers via:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>IPv4</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>IPv6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Tor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+25"/>
         <source>Connect to the Bitcoin network through a separate SOCKS5 proxy for Tor hidden services.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+105"/>
         <source>&amp;Window</source>
         <translation>&amp;Window</translation>
     </message>
     <message>
         <location line="+16"/>
         <source>Show only a tray icon after minimizing the window.</source>
         <translation>Show only a tray icon after minimizing the window.</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>&amp;Minimize to the tray instead of the taskbar</source>
         <translation>&amp;Minimize to the tray instead of the taskbar</translation>
     </message>
     <message>
         <location line="+10"/>
         <source>M&amp;inimize on close</source>
         <translation>M&amp;inimize on close</translation>
     </message>
     <message>
         <location line="+21"/>
         <source>&amp;Display</source>
         <translation>&amp;Display</translation>
     </message>
     <message>
         <location line="+8"/>
         <source>User Interface &amp;language:</source>
         <translation>User Interface &amp;language:</translation>
     </message>
     <message>
         <location line="+13"/>
         <source>The user interface language can be set here. This setting will take effect after restarting %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+11"/>
         <source>&amp;Unit to show amounts in:</source>
         <translation>&amp;Unit to show amounts in:</translation>
     </message>
     <message>
         <location line="+13"/>
         <source>Choose the default subdivision unit to show in the interface and when sending coins.</source>
         <translation>Choose the default subdivision unit to show in the interface and when sending coins.</translation>
     </message>
     <message>
         <location line="-450"/>
         <source>Whether to show coin control features or not.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+464"/>
         <source>&amp;Third party transaction URLs</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+86"/>
         <source>Open the %1 configuration file from the working directory.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Open Configuration File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+93"/>
         <source>&amp;OK</source>
         <translation>&amp;OK</translation>
     </message>
     <message>
         <location line="+13"/>
         <source>&amp;Cancel</source>
         <translation>&amp;Cancel</translation>
     </message>
     <message>
         <location filename="../optionsdialog.cpp" line="+102"/>
         <source>default</source>
         <translation>default</translation>
     </message>
     <message>
         <location line="+70"/>
         <source>none</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+110"/>
         <source>Confirm options reset</source>
         <translation>Confirm options reset</translation>
     </message>
     <message>
         <location line="+1"/>
         <location line="+58"/>
         <source>Client restart required to activate changes.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-57"/>
         <source>Client will be shut down. Do you want to proceed?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+16"/>
         <source>Configuration options</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>The configuration file is used to specify advanced user options which override GUI settings. Additionally, any command-line options will override this configuration file.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Error</source>
         <translation type="unfinished">Error</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>The configuration file could not be opened.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+35"/>
         <source>This change would require a client restart.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+29"/>
         <source>The supplied proxy address is invalid.</source>
         <translation>The supplied proxy address is invalid.</translation>
     </message>
 </context>
 <context>
     <name>OverviewPage</name>
     <message>
         <location filename="../forms/overviewpage.ui" line="+14"/>
         <source>Form</source>
         <translation>Form</translation>
     </message>
     <message>
         <location line="+62"/>
         <location line="+386"/>
         <source>The displayed information may be out of date. Your wallet automatically synchronizes with the Bitcoin network after a connection is established, but this process has not completed yet.</source>
         <translation>The displayed information may be out of date. Your wallet automatically synchronizes with the Bitcoin network after a connection is established, but this process has not completed yet.</translation>
     </message>
     <message>
         <location line="-139"/>
         <source>Watch-only:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>Available:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+16"/>
         <source>Your current spendable balance</source>
         <translation>Your current spendable balance</translation>
     </message>
     <message>
         <location line="+41"/>
         <source>Pending:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-236"/>
         <source>Total of transactions that have yet to be confirmed, and do not yet count toward the spendable balance</source>
         <translation>Total of transactions that have yet to be confirmed, and do not yet count toward the spendable balance</translation>
     </message>
     <message>
         <location line="+112"/>
         <source>Immature:</source>
         <translation>Immature:</translation>
     </message>
     <message>
         <location line="-29"/>
         <source>Mined balance that has not yet matured</source>
         <translation>Mined balance that has not yet matured</translation>
     </message>
     <message>
         <location line="-177"/>
         <source>Balances</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+161"/>
         <source>Total:</source>
         <translation>Total:</translation>
     </message>
     <message>
         <location line="+61"/>
         <source>Your current total balance</source>
         <translation>Your current total balance</translation>
     </message>
     <message>
         <location line="+92"/>
         <source>Your current balance in watch-only addresses</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Spendable:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+49"/>
         <source>Recent transactions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-317"/>
         <source>Unconfirmed transactions to watch-only addresses</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+50"/>
         <source>Mined balance in watch-only addresses that has not yet matured</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+128"/>
         <source>Current total balance in watch-only addresses</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>PaymentServer</name>
     <message>
         <location filename="../paymentserver.cpp" line="+261"/>
         <location line="+362"/>
         <location line="+48"/>
         <location line="+132"/>
         <location line="+15"/>
         <location line="+15"/>
         <source>Payment request error</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-571"/>
         <source>Cannot start click-to-pay handler</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+72"/>
         <location line="+7"/>
         <location line="+14"/>
         <location line="+8"/>
         <source>URI handling</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-28"/>
         <source>Payment request fetch URL is invalid: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Cannot process payment request because BIP70 support was not compiled in.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+14"/>
         <source>Invalid payment address %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+8"/>
         <source>URI cannot be parsed! This can be caused by an invalid Bitcoin address or malformed URI parameters.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+25"/>
         <source>Payment request file handling</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Payment request file cannot be read! This can be caused by an invalid payment request file.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+215"/>
         <location line="+11"/>
         <location line="+33"/>
         <location line="+12"/>
         <location line="+24"/>
         <location line="+103"/>
         <source>Payment request rejected</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-182"/>
         <source>Payment request network doesn&apos;t match client network.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+11"/>
         <source>Payment request expired.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Payment request is not initialized.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+26"/>
         <source>Unverified payment requests to custom payment scripts are unsupported.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+12"/>
         <location line="+24"/>
         <source>Invalid payment request.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-14"/>
         <source>Requested payment amount of %1 is too small (considered dust).</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+82"/>
         <source>Refund from %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+35"/>
         <source>Payment request %1 is too large (%2 bytes, allowed %3 bytes).</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+9"/>
         <source>Error communicating with %1: %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+21"/>
         <source>Payment request cannot be parsed!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>Bad response from server %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+21"/>
         <source>Network request error</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Payment acknowledged</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>PeerTableModel</name>
     <message>
         <location filename="../peertablemodel.cpp" line="+108"/>
         <source>User Agent</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-1"/>
         <source>Node/Service</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+0"/>
         <source>NodeId</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+0"/>
         <source>Ping</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+0"/>
         <source>Sent</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Received</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
         <location filename="../bitcoinunits.cpp" line="+209"/>
         <source>Amount</source>
         <translation type="unfinished">Amount</translation>
     </message>
     <message>
         <location filename="../guiutil.cpp" line="+140"/>
         <source>Enter a Bitcoin address (e.g. %1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+715"/>
         <source>%1 d</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>%1 h</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>%1 m</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <location line="+54"/>
         <source>%1 s</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-13"/>
         <source>None</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>N/A</source>
         <translation type="unfinished">N/A</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>%1 ms</source>
         <translation type="unfinished"></translation>
     </message>
     <message numerus="yes">
         <location line="+18"/>
         <source>%n second(s)</source>
         <translation>
             <numerusform>%n second</numerusform>
             <numerusform>%n seconds</numerusform>
         </translation>
     </message>
     <message numerus="yes">
         <location line="+2"/>
         <source>%n minute(s)</source>
         <translation>
             <numerusform>%n minute</numerusform>
             <numerusform>%n minutes</numerusform>
         </translation>
     </message>
     <message numerus="yes">
         <location line="+2"/>
         <source>%n hour(s)</source>
         <translation type="unfinished">
             <numerusform>%n hour</numerusform>
             <numerusform>%n hours</numerusform>
         </translation>
     </message>
     <message numerus="yes">
         <location line="+2"/>
         <source>%n day(s)</source>
         <translation type="unfinished">
             <numerusform>%n day</numerusform>
             <numerusform>%n days</numerusform>
         </translation>
     </message>
     <message numerus="yes">
         <location line="+2"/>
         <location line="+6"/>
         <source>%n week(s)</source>
         <translation type="unfinished">
             <numerusform>%n week</numerusform>
             <numerusform>%n weeks</numerusform>
         </translation>
     </message>
     <message>
         <location line="-2"/>
         <source>%1 and %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message numerus="yes">
         <location line="+1"/>
         <source>%n year(s)</source>
         <translation type="unfinished">
             <numerusform>%n year</numerusform>
             <numerusform>%n years</numerusform>
         </translation>
     </message>
     <message>
         <location line="+9"/>
         <source>%1 B</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>%1 KB</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>%1 MB</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>%1 GB</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../bitcoin.cpp" line="+303"/>
-        <source>%1 didn&apos;t yet exit safely...</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="../modaloverlay.cpp" line="-35"/>
-        <source>unknown</source>
-        <translation type="unfinished"></translation>
-    </message>
-</context>
-<context>
-    <name>QObject::QObject</name>
-    <message>
-        <location filename="../bitcoin.cpp" line="-159"/>
+        <location filename="../bitcoin.cpp" line="+144"/>
         <source>Error parsing command line arguments: %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+50"/>
         <source>Error: Specified data directory &quot;%1&quot; does not exist.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+8"/>
         <source>Error: Cannot parse configuration file: %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+19"/>
         <source>Error: %1</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location line="+82"/>
+        <source>%1 didn&apos;t yet exit safely...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../modaloverlay.cpp" line="-35"/>
+        <source>unknown</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QRImageWidget</name>
     <message>
         <location filename="../receiverequestdialog.cpp" line="+33"/>
         <source>&amp;Save Image...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>&amp;Copy Image</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+31"/>
         <source>Save QR Code</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>PNG Image (*.png)</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>RPCConsole</name>
     <message>
         <location filename="../forms/debugwindow.ui" line="+56"/>
         <location line="+26"/>
         <location line="+26"/>
         <location line="+26"/>
         <location line="+29"/>
         <location line="+26"/>
         <location line="+36"/>
         <location line="+23"/>
         <location line="+36"/>
         <location line="+23"/>
         <location line="+36"/>
         <location line="+23"/>
         <location line="+679"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+23"/>
         <location line="+26"/>
         <location line="+23"/>
         <location line="+23"/>
         <source>N/A</source>
         <translation>N/A</translation>
     </message>
     <message>
         <location line="-1393"/>
         <source>Client version</source>
         <translation>Client version</translation>
     </message>
     <message>
         <location line="-22"/>
         <source>&amp;Information</source>
         <translation>&amp;Information</translation>
     </message>
     <message>
         <location line="-10"/>
         <source>Debug window</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+25"/>
         <source>General</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+56"/>
         <source>Using BerkeleyDB version</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+26"/>
         <source>Datadir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>To specify a non-default location of the data directory use the &apos;%1&apos; option.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+19"/>
         <source>Blocksdir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>To specify a non-default location of the blocks directory use the &apos;%1&apos; option.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+19"/>
         <source>Startup time</source>
         <translation>Startup time</translation>
     </message>
     <message>
         <location line="+29"/>
         <source>Network</source>
         <translation>Network</translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Name</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Number of connections</source>
         <translation>Number of connections</translation>
     </message>
     <message>
         <location line="+29"/>
         <source>Block chain</source>
         <translation>Block chain</translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Current number of blocks</source>
         <translation>Current number of blocks</translation>
     </message>
     <message>
         <location line="+52"/>
         <source>Memory Pool</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Current number of transactions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Memory usage</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+94"/>
         <source>Wallet: </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+8"/>
         <source>(none)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+238"/>
         <source>&amp;Reset</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+80"/>
         <location line="+558"/>
         <source>Received</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-478"/>
         <location line="+455"/>
         <source>Sent</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-414"/>
         <source>&amp;Peers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+53"/>
         <source>Banned peers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+60"/>
         <location filename="../rpcconsole.cpp" line="+577"/>
-        <location line="+876"/>
+        <location line="+875"/>
         <source>Select a peer to view detailed information.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+25"/>
         <source>Whitelisted</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Direction</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Version</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+69"/>
         <source>Starting Block</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Synced Headers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Synced Blocks</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-1127"/>
         <location line="+1035"/>
         <source>User Agent</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-700"/>
         <source>Open the %1 debug log file from the current data directory. This can take a few seconds for large log files.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+84"/>
         <source>Decrease font size</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+29"/>
         <source>Increase font size</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+610"/>
         <source>Services</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+92"/>
         <source>Ban Score</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Connection Time</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Last Send</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Last Receive</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+69"/>
         <source>Ping Time</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>The duration of a currently outstanding ping.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Ping Wait</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Min Ping</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Time Offset</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-1132"/>
         <source>Last block time</source>
         <translation>Last block time</translation>
     </message>
     <message>
         <location line="+110"/>
         <source>&amp;Open</source>
         <translation>&amp;Open</translation>
     </message>
     <message>
         <location line="+26"/>
         <source>&amp;Console</source>
         <translation>&amp;Console</translation>
     </message>
     <message>
         <location line="+211"/>
         <source>&amp;Network Traffic</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+68"/>
         <source>Totals</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../rpcconsole.cpp" line="-464"/>
         <source>In:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Out:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../forms/debugwindow.ui" line="-315"/>
         <source>Debug log file</source>
         <translation>Debug log file</translation>
     </message>
     <message>
         <location line="+152"/>
         <source>Clear console</source>
         <translation>Clear console</translation>
     </message>
     <message>
-        <location filename="../rpcconsole.cpp" line="-300"/>
+        <location filename="../rpcconsole.cpp" line="-299"/>
         <source>1 &amp;hour</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>1 &amp;day</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>1 &amp;week</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>1 &amp;year</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-8"/>
         <source>&amp;Disconnect</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <location line="+2"/>
         <location line="+2"/>
         <location line="+2"/>
         <source>Ban for</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+66"/>
         <source>&amp;Unban</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+177"/>
         <source>Welcome to the %1 RPC console.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+2"/>
+        <location line="+1"/>
         <source>Use up and down arrows to navigate history, and %1 to clear screen.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Type %1 for an overview of available commands.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>For more information on using this console type %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+48"/>
         <source>Network activity disabled</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+76"/>
         <source>Executing command without any wallet</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-4"/>
         <source>Executing command using &quot;%1&quot; wallet</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-117"/>
         <source>WARNING: Scammers have been active, telling users to type commands here, stealing their wallet contents. Do not use this console without fully understanding the ramifications of a command.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+320"/>
         <source>(node id: %1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>via %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <location line="+5"/>
         <source>never</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+19"/>
         <source>Inbound</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Outbound</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Yes</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>No</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+14"/>
         <location line="+8"/>
         <source>Unknown</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ReceiveCoinsDialog</name>
     <message>
         <location filename="../forms/receivecoinsdialog.ui" line="+90"/>
         <source>&amp;Amount:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-16"/>
         <source>&amp;Label:</source>
         <translation type="unfinished">&amp;Label:</translation>
     </message>
     <message>
         <location line="-37"/>
         <source>&amp;Message:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-3"/>
         <location line="+23"/>
         <source>An optional message to attach to the payment request, which will be displayed when the request is opened. Note: The message will not be sent with the payment over the Bitcoin network.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-7"/>
         <location line="+21"/>
         <source>An optional label to associate with the new receiving address.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-7"/>
         <source>Use this form to request payments. All fields are &lt;b&gt;optional&lt;/b&gt;.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <location line="+22"/>
         <source>An optional amount to request. Leave this empty or zero to not request a specific amount.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+32"/>
         <source>Clear all fields of the form.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Clear</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+75"/>
         <source>Requested payments history</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-95"/>
         <source>&amp;Request payment</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+120"/>
         <source>Show the selected request (does the same as double clicking an entry)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Show</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+17"/>
         <source>Remove the selected entries from the list</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Remove</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../receivecoinsdialog.cpp" line="+51"/>
         <source>Copy URI</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy message</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy amount</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ReceiveRequestDialog</name>
     <message>
         <location filename="../forms/receiverequestdialog.ui" line="+29"/>
         <source>QR Code</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+46"/>
         <source>Copy &amp;URI</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>Copy &amp;Address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>&amp;Save Image...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../receiverequestdialog.cpp" line="+62"/>
         <source>Request payment to %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Payment information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>URI</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Amount</source>
         <translation type="unfinished">Amount</translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Message</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Wallet</source>
         <translation type="unfinished">Wallet</translation>
     </message>
     <message>
         <location line="+12"/>
         <source>Resulting URI too long, try to reduce the text for label / message.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Error encoding URI into QR Code.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>RecentRequestsTableModel</name>
     <message>
         <location filename="../recentrequeststablemodel.cpp" line="+25"/>
         <source>Date</source>
         <translation type="unfinished">Date</translation>
     </message>
     <message>
         <location line="+0"/>
         <source>Label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+0"/>
         <source>Message</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+35"/>
         <source>(no label)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>(no message)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>(no amount requested)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+47"/>
         <source>Requested</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>SendCoinsDialog</name>
     <message>
         <location filename="../forms/sendcoinsdialog.ui" line="+14"/>
         <location filename="../sendcoinsdialog.cpp" line="+621"/>
         <source>Send Coins</source>
         <translation>Send Coins</translation>
     </message>
     <message>
         <location line="+76"/>
         <source>Coin Control Features</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+20"/>
         <source>Inputs...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>automatically selected</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+19"/>
         <source>Insufficient funds!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+89"/>
         <source>Quantity:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+35"/>
         <source>Bytes:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+48"/>
         <source>Amount:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+80"/>
         <source>Fee:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+51"/>
         <source>After Fee:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+32"/>
         <source>Change:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+44"/>
         <source>If this is activated, but the change address is empty or invalid, change will be sent to a newly generated address.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Custom change address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+206"/>
         <source>Transaction Fee:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+14"/>
         <source>Choose...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+37"/>
         <source>collapse fee-settings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+56"/>
         <source>per kilobyte</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-53"/>
         <source>Hide</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+48"/>
         <source>Specify a custom fee per kB (1,000 bytes) of the transaction&apos;s size.
 
 Note:  Since the fee is calculated on a per-byte basis, a fee of &quot;100 satoshis per kB&quot; for a transaction size of 500 bytes (half of 1 kB) would ultimately yield a fee of only 50 satoshis.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+38"/>
         <location line="+13"/>
         <source>Paying only the minimum fee is just fine as long as there is less transaction volume than space in the blocks. But be aware that this can end up in a never confirming transaction once there is more demand for bitcoin transactions than the network can process.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>(read the tooltip)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+29"/>
         <source>Recommended:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+30"/>
         <source>Custom:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+52"/>
         <source>(Smart fee not initialized yet. This usually takes a few blocks...)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+114"/>
         <source>Send to multiple recipients at once</source>
         <translation>Send to multiple recipients at once</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Add &amp;Recipient</source>
         <translation>Add &amp;Recipient</translation>
     </message>
     <message>
         <location line="-20"/>
         <source>Clear all fields of the form.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-748"/>
         <source>Dust:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+751"/>
         <source>Clear &amp;All</source>
         <translation>Clear &amp;All</translation>
     </message>
     <message>
         <location line="+55"/>
         <source>Balance:</source>
         <translation>Balance:</translation>
     </message>
     <message>
         <location filename="../sendcoinsdialog.cpp" line="-272"/>
         <source>Please, review your transaction.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Transaction fee</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+30"/>
         <source>Total Amount</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../forms/sendcoinsdialog.ui" line="-84"/>
         <source>Confirm the send action</source>
         <translation>Confirm the send action</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>S&amp;end</source>
         <translation>S&amp;end</translation>
     </message>
     <message>
         <location filename="../sendcoinsdialog.cpp" line="-313"/>
         <source>Copy quantity</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy amount</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy fee</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy after fee</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy bytes</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy dust</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy change</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+225"/>
         <source>from wallet %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+21"/>
         <location line="+4"/>
         <location line="+7"/>
         <location line="+5"/>
         <source>%1 to %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Are you sure you want to send?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+44"/>
         <source>or</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Confirm send coins</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+183"/>
         <source>The recipient address is not valid. Please recheck.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>The amount to pay must be larger than 0.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>The amount exceeds your balance.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>The total exceeds your balance when the %1 transaction fee is included.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Duplicate address found: addresses should only be used once each.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Transaction creation failed!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>The transaction was rejected with the following reason: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>A fee higher than %1 is considered an absurdly high fee.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Payment request expired.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+132"/>
         <source>Estimated to begin confirmation by next block.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-39"/>
         <source>Pay only the required fee of %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+140"/>
         <source>Warning: Invalid Bitcoin address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Warning: Unknown change address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Confirm custom change address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>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?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+25"/>
         <source>(no label)</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>SendCoinsEntry</name>
     <message>
         <location filename="../forms/sendcoinsentry.ui" line="+155"/>
         <location line="+546"/>
         <location line="+533"/>
         <source>A&amp;mount:</source>
         <translation>A&amp;mount:</translation>
     </message>
     <message>
         <location line="-1192"/>
         <source>Pay &amp;To:</source>
         <translation>Pay &amp;To:</translation>
     </message>
     <message>
         <location line="+93"/>
         <source>&amp;Label:</source>
         <translation>&amp;Label:</translation>
     </message>
     <message>
         <location line="-68"/>
         <source>Choose previously used address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-46"/>
         <source>This is a normal payment.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+39"/>
         <source>The Bitcoin address to send the payment to</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+23"/>
         <source>Alt+A</source>
         <translation>Alt+A</translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Paste address from clipboard</source>
         <translation>Paste address from clipboard</translation>
     </message>
     <message>
         <location line="+16"/>
         <source>Alt+P</source>
         <translation>Alt+P</translation>
     </message>
     <message>
         <location line="+7"/>
         <location line="+555"/>
         <location line="+533"/>
         <source>Remove this entry</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-1028"/>
         <source>The fee will be deducted from the amount being sent. The recipient will receive less bitcoins than you enter in the amount field. If multiple recipients are selected, the fee is split equally.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>S&amp;ubtract fee from amount</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Use available balance</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+9"/>
         <source>Message:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+443"/>
         <source>This is an unauthenticated payment request.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+529"/>
         <source>This is an authenticated payment request.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-1016"/>
         <source>Enter a label for this address to add it to the list of used addresses</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../sendcoinsentry.cpp" line="+101"/>
         <source>A message that was attached to the %1 URI which will be stored with the transaction for your reference. Note: This message will not be sent over the Bitcoin network.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../forms/sendcoinsentry.ui" line="+502"/>
         <location line="+529"/>
         <source>Pay To:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-495"/>
         <location line="+533"/>
         <source>Memo:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../sendcoinsentry.cpp" line="-56"/>
         <source>Enter a label for this address to add it to your address book</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>SendConfirmationDialog</name>
     <message>
         <location filename="../sendcoinsdialog.cpp" line="+78"/>
         <location line="+3"/>
         <source>Yes</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ShutdownWindow</name>
     <message>
         <location filename="../utilitydialog.cpp" line="+80"/>
         <source>%1 is shutting down...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Do not shut down the computer until this window disappears.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>SignVerifyMessageDialog</name>
     <message>
         <location filename="../forms/signverifymessagedialog.ui" line="+14"/>
         <source>Signatures - Sign / Verify a Message</source>
         <translation>Signatures - Sign / Verify a Message</translation>
     </message>
     <message>
         <location line="+13"/>
         <source>&amp;Sign Message</source>
         <translation>&amp;Sign Message</translation>
     </message>
     <message>
         <location line="+6"/>
         <source>You can sign messages/agreements with your addresses to prove you can receive bitcoins sent to them. Be careful not to sign anything vague or random, as phishing attacks may try to trick you into signing your identity over to them. Only sign fully-detailed statements you agree to.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+18"/>
         <source>The Bitcoin address to sign the message with</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <location line="+210"/>
         <source>Choose previously used address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-200"/>
         <location line="+210"/>
         <source>Alt+A</source>
         <translation>Alt+A</translation>
     </message>
     <message>
         <location line="-200"/>
         <source>Paste address from clipboard</source>
         <translation>Paste address from clipboard</translation>
     </message>
     <message>
         <location line="+10"/>
         <source>Alt+P</source>
         <translation>Alt+P</translation>
     </message>
     <message>
         <location line="+12"/>
         <source>Enter the message you want to sign here</source>
         <translation>Enter the message you want to sign here</translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Signature</source>
         <translation>Signature</translation>
     </message>
     <message>
         <location line="+27"/>
         <source>Copy the current signature to the system clipboard</source>
         <translation>Copy the current signature to the system clipboard</translation>
     </message>
     <message>
         <location line="+21"/>
         <source>Sign the message to prove you own this Bitcoin address</source>
         <translation>Sign the message to prove you own this Bitcoin address</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Sign &amp;Message</source>
         <translation>Sign &amp;Message</translation>
     </message>
     <message>
         <location line="+14"/>
         <source>Reset all sign message fields</source>
         <translation>Reset all sign message fields</translation>
     </message>
     <message>
         <location line="+3"/>
         <location line="+143"/>
         <source>Clear &amp;All</source>
         <translation>Clear &amp;All</translation>
     </message>
     <message>
         <location line="-84"/>
         <source>&amp;Verify Message</source>
         <translation>&amp;Verify Message</translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Enter the receiver&apos;s address, message (ensure you copy line breaks, spaces, tabs, etc. exactly) and signature below to verify the message. Be careful not to read more into the signature than what is in the signed message itself, to avoid being tricked by a man-in-the-middle attack. Note that this only proves the signing party receives with the address, it cannot prove sendership of any transaction!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+21"/>
         <source>The Bitcoin address the message was signed with</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+37"/>
         <source>Verify the message to ensure it was signed with the specified Bitcoin address</source>
         <translation>Verify the message to ensure it was signed with the specified Bitcoin address</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Verify &amp;Message</source>
         <translation>Verify &amp;Message</translation>
     </message>
     <message>
         <location line="+14"/>
         <source>Reset all verify message fields</source>
         <translation>Reset all verify message fields</translation>
     </message>
     <message>
         <location filename="../signverifymessagedialog.cpp" line="+45"/>
         <source>Click &quot;Sign Message&quot; to generate signature</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+77"/>
         <location line="+80"/>
         <source>The entered address is invalid.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-79"/>
         <location line="+9"/>
         <location line="+71"/>
         <location line="+8"/>
         <source>Please check the address and try again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-80"/>
         <location line="+79"/>
         <source>The entered address does not refer to a key.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-71"/>
         <source>Wallet unlock was cancelled.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+8"/>
         <source>Private key for the entered address is not available.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+12"/>
         <source>Message signing failed.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Message signed.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+58"/>
         <source>The signature could not be decoded.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <location line="+14"/>
         <source>Please check the signature and try again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-1"/>
         <source>The signature did not match the message digest.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+8"/>
         <source>Message verification failed.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Message verified.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>SplashScreen</name>
     <message>
         <location filename="../networkstyle.cpp" line="+19"/>
         <source>[testnet]</source>
         <translation>[testnet]</translation>
     </message>
 </context>
 <context>
     <name>TrafficGraphWidget</name>
     <message>
         <location filename="../trafficgraphwidget.cpp" line="+72"/>
         <source>KB/s</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>TransactionDesc</name>
     <message numerus="yes">
         <location filename="../transactiondesc.cpp" line="+38"/>
         <source>Open for %n more block(s)</source>
         <translation>
             <numerusform>Open for %n more block</numerusform>
             <numerusform>Open for %n more blocks</numerusform>
         </translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Open until %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>conflicted with a transaction with %1 confirmations</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>0/unconfirmed, %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>in memory pool</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>not in memory pool</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>abandoned</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>%1/unconfirmed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>%1 confirmations</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+25"/>
         <source>Status</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Date</source>
         <translation type="unfinished">Date</translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Source</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+0"/>
         <source>Generated</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <location line="+14"/>
         <location line="+82"/>
         <source>From</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-82"/>
         <source>unknown</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <location line="+23"/>
         <location line="+77"/>
         <source>To</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-97"/>
         <source>own address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <location line="+77"/>
         <source>watch-only</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-75"/>
         <source>label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+40"/>
         <location line="+15"/>
         <location line="+64"/>
         <location line="+40"/>
         <location line="+86"/>
         <source>Credit</source>
         <translation type="unfinished"></translation>
     </message>
     <message numerus="yes">
         <location line="-201"/>
         <source>matures in %n more block(s)</source>
         <translation>
             <numerusform>matures in %n more block</numerusform>
             <numerusform>matures in %n more blocks</numerusform>
         </translation>
     </message>
     <message>
         <location line="+4"/>
         <source>not accepted</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+66"/>
         <location line="+36"/>
         <location line="+87"/>
         <source>Debit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-108"/>
         <source>Total debit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Total credit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Transaction fee</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+29"/>
         <source>Net amount</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <location line="+18"/>
         <source>Message</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-14"/>
         <source>Comment</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Transaction ID</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Transaction total size</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Output index</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+22"/>
         <source>Merchant</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+11"/>
         <source>Generated coins must mature %1 blocks before they can be spent. When you generated this block, it was broadcast to the network to be added to the block chain. If it fails to get into the chain, its state will change to &quot;not accepted&quot; and it won&apos;t be spendable. This may occasionally happen if another node generates a block within a few seconds of yours.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+14"/>
         <source>Debug information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+18"/>
         <source>Transaction</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Inputs</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+22"/>
         <source>Amount</source>
         <translation type="unfinished">Amount</translation>
     </message>
     <message>
         <location line="+4"/>
         <location line="+5"/>
         <source>true</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-4"/>
         <location line="+5"/>
         <source>false</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>TransactionDescDialog</name>
     <message>
         <location filename="../forms/transactiondescdialog.ui" line="+20"/>
         <source>This pane shows a detailed description of the transaction</source>
         <translation>This pane shows a detailed description of the transaction</translation>
     </message>
     <message>
         <location filename="../transactiondescdialog.cpp" line="+17"/>
         <source>Details for %1</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>TransactionTableModel</name>
     <message>
         <location filename="../transactiontablemodel.cpp" line="+219"/>
         <source>Date</source>
         <translation type="unfinished">Date</translation>
     </message>
     <message>
         <location line="+0"/>
         <source>Type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+0"/>
         <source>Label</source>
         <translation type="unfinished"></translation>
     </message>
     <message numerus="yes">
         <location line="+57"/>
         <source>Open for %n more block(s)</source>
         <translation>
             <numerusform>Open for %n more block</numerusform>
             <numerusform>Open for %n more blocks</numerusform>
         </translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Open until %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Unconfirmed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Abandoned</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Confirming (%1 of %2 recommended confirmations)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Confirmed (%1 confirmations)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Conflicted</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Immature (%1 confirmations, will be available after %2)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Generated but not accepted</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+38"/>
         <source>Received with</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Received from</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Sent to</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Payment to yourself</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Mined</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+29"/>
         <source>watch-only</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+15"/>
         <source>(n/a)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+218"/>
         <source>(no label)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+35"/>
         <source>Transaction status. Hover over this field to show number of confirmations.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Date and time that the transaction was received.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Type of transaction.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Whether or not a watch-only address is involved in this transaction.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>User-defined intent/purpose of the transaction.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Amount removed from or added to balance.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>TransactionView</name>
     <message>
         <location filename="../transactionview.cpp" line="+73"/>
         <location line="+16"/>
         <source>All</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="-15"/>
         <source>Today</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>This week</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>This month</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Last month</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>This year</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Range...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+12"/>
         <source>Received with</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Sent to</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>To yourself</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Mined</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Other</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Enter address, transaction id, or label to search</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Min amount</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+46"/>
         <source>Abandon transaction</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy amount</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy transaction ID</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Copy raw transaction</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Copy full transaction details</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Edit label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Show transaction details</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+234"/>
         <source>Export Transaction History</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Comma separated file (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>Confirmed</source>
         <translation type="unfinished">Confirmed</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Watch-only</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Date</source>
         <translation type="unfinished">Date</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Label</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Address</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>ID</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Exporting Failed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>There was an error trying to save the transaction history to %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Exporting Successful</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>The transaction history was successfully saved to %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+162"/>
         <source>Range:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+8"/>
         <source>to</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>UnitDisplayStatusBarControl</name>
     <message>
-        <location filename="../bitcoingui.cpp" line="+156"/>
+        <location filename="../bitcoingui.cpp" line="+158"/>
         <source>Unit to show amounts in. Click to select another unit.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>WalletFrame</name>
     <message>
         <location filename="../walletframe.cpp" line="+26"/>
         <source>No wallet has been loaded.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>WalletModel</name>
     <message>
         <location filename="../walletmodel.cpp" line="+218"/>
         <source>Send Coins</source>
         <translation type="unfinished">Send Coins</translation>
     </message>
     <message>
         <location line="+300"/>
         <source>default wallet</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>WalletView</name>
     <message>
         <location filename="../walletview.cpp" line="+44"/>
         <source>&amp;Export</source>
         <translation type="unfinished">&amp;Export</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Export the data in the current tab to a file</source>
         <translation type="unfinished">Export the data in the current tab to a file</translation>
     </message>
     <message>
         <location line="+242"/>
         <source>Backup Wallet</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Wallet Data (*.dat)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+8"/>
         <source>Backup Failed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>There was an error trying to save the wallet data to %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Backup Successful</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>The wallet data was successfully saved to %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+47"/>
         <source>Cancel</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>bitcoin-abc</name>
     <message>
-        <location filename="../bitcoinstrings.cpp" line="+31"/>
+        <location filename="../bitcoinstrings.cpp" line="+26"/>
         <source>Distributed under the MIT software license, see the accompanying file %s or %s</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+20"/>
         <source>Prune configured below the minimum of %d MiB.  Please use a higher number.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Prune: last wallet synchronisation goes beyond pruned data. You need to -reindex (download the whole blockchain again in case of pruned node)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Rescans are not possible in pruned mode. You will need to use -reindex which will download the whole blockchain again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+65"/>
+        <location line="+64"/>
         <source>Error: A fatal internal error occurred, see debug.log for details</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+27"/>
+        <location line="+26"/>
         <source>Pruning blockstore...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Replaying blocks...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
-        <source>Run in the background as a daemon and accept commands</source>
-        <translation>Run in the background as a daemon and accept commands</translation>
-    </message>
-    <message>
-        <location line="+1"/>
         <source>Section [%s] is not recognized.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Specified -walletdir &quot;%s&quot; does not exist</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Specified -walletdir &quot;%s&quot; is a relative path</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Specified -walletdir &quot;%s&quot; is not a directory</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Specified blocks directory &quot;%s&quot; does not exist.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+10"/>
         <source>Transaction fee and change calculation failed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Unable to create the PID file &apos;%s&apos;: %s</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Unable to generate initial keys</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Unable to generate keys</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Unable to start HTTP server. See debug log for details.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="-168"/>
-        <source>Bitcoin ABC</source>
-        <translation type="unfinished">Bitcoin ABC</translation>
-    </message>
-    <message>
-        <location line="+1"/>
+        <location line="-160"/>
         <source>The %s developers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+5"/>
-        <source>Accept relayed transactions received from whitelisted peers even when not relaying transactions (default: %d)</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location line="+6"/>
+        <location line="+7"/>
         <source>Cannot obtain a lock on data directory %s. %s is probably already running.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+12"/>
         <source>Error reading %s! All keys read correctly, but transaction data or address book entries might be missing or incorrect.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+11"/>
         <source>Please check that your computer&apos;s date and time are correct! If your clock is wrong, %s will not work properly.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Please contribute if you find %s useful. Visit %s for further information about the software.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+11"/>
         <source>The block database contains a block which appears to be from the future. This may be due to your computer&apos;s date and time being set incorrectly. Only rebuild the block database if you are sure that your computer&apos;s date and time are correct</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>This is a pre-release test build - use at your own risk - do not use for mining or merchant applications</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+17"/>
         <source>Warning: The network does not appear to fully agree! Some miners appear to be experiencing issues.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Warning: We do not appear to fully agree with our peers! You may need to upgrade, or other nodes may need to upgrade.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>%s corrupt, salvage failed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>-maxmempool must be at least %d MB</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Cannot resolve -%s address: &apos;%s&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Change index out of range</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+3"/>
+        <location line="+2"/>
         <source>Copyright (C) %i-%i</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Corrupted block database detected</source>
         <translation>Corrupted block database detected</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Do you want to rebuild the block database now?</source>
         <translation>Do you want to rebuild the block database now?</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Error initializing block database</source>
         <translation>Error initializing block database</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Error initializing wallet database environment %s!</source>
         <translation>Error initializing wallet database environment %s!</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Error loading %s</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Error loading %s: Wallet corrupted</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Error loading %s: Wallet requires newer version of %s</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Error loading block database</source>
         <translation>Error loading block database</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Error opening block database</source>
         <translation>Error opening block database</translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Error: Disk space is low!</source>
         <translation>Error: Disk space is low!</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Failed to listen on any port. Use -listen=0 if you want this.</source>
         <translation>Failed to listen on any port. Use -listen=0 if you want this.</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Importing...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Incorrect or no genesis block found. Wrong datadir for network?</source>
         <translation>Incorrect or no genesis block found. Wrong datadir for network?</translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Initialization sanity check failed. %s is shutting down.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Invalid amount for -%s=&lt;amount&gt;: &apos;%s&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Invalid amount for -fallbackfee=&lt;amount&gt;: &apos;%s&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Loading banlist...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Not enough file descriptors available.</source>
         <translation>Not enough file descriptors available.</translation>
     </message>
     <message>
-        <location line="+2"/>
+        <location line="+1"/>
         <source>Prune cannot be configured with a negative value.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Prune mode is incompatible with -txindex.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+13"/>
+        <location line="+12"/>
         <source>The source code is available from %s.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+14"/>
         <source>Unable to bind to %s on this computer. %s is probably already running.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+9"/>
         <source>User Agent comment (%s) contains unsafe characters.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+2"/>
+        <location line="+1"/>
         <source>Verifying blocks...</source>
         <translation>Verifying blocks...</translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Wallet needed to be rewritten: restart %s to complete</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="-151"/>
+        <location line="-147"/>
         <source>Error: Listening for incoming connections failed (listen returned error %s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Invalid amount for -maxtxfee=&lt;amount&gt;: &apos;%s&apos; (must be at least the minrelay fee of %s to prevent stuck transactions)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+25"/>
         <source>The transaction amount is too small to send after the fee has been deducted</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+29"/>
         <source>You need to rebuild the database using -reindex to go back to unpruned mode.  This will redownload the entire blockchain</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+11"/>
-        <source>Connect through SOCKS5 proxy</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location line="+14"/>
+        <location line="+24"/>
         <source>Error reading from database, shutting down.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+11"/>
         <source>Information</source>
         <translation>Information</translation>
     </message>
     <message>
         <location line="+7"/>
         <source>Invalid amount for -paytxfee=&lt;amount&gt;: &apos;%s&apos; (must be at least %s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Invalid netmask specified in -whitelist: &apos;%s&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Need to specify a port with -whitebind: &apos;%s&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+6"/>
+        <location line="+5"/>
         <source>Reducing -maxconnections from %d to %d, because of system limitations.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+5"/>
+        <location line="+4"/>
         <source>Signing transaction failed</source>
         <translation>Signing transaction failed</translation>
     </message>
     <message>
         <location line="+7"/>
         <source>The transaction amount is too small to pay the fee</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>This is experimental software.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Transaction amount too small</source>
         <translation>Transaction amount too small</translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Transaction too large for fee policy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Transaction too large</source>
         <translation>Transaction too large</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Unable to bind to %s on this computer (bind returned error %s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+11"/>
-        <source>Username for JSON-RPC connections</source>
-        <translation>Username for JSON-RPC connections</translation>
-    </message>
-    <message>
-        <location line="+2"/>
+        <location line="+12"/>
         <source>Verifying wallet(s)...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Wallet %s resides outside wallet directory %s</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Warning</source>
         <translation>Warning</translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Zapping all transactions from wallet...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="-45"/>
-        <source>Password for JSON-RPC connections</source>
-        <translation>Password for JSON-RPC connections</translation>
-    </message>
-    <message>
-        <location line="-132"/>
+        <location line="-170"/>
         <source>-maxtxfee is set very high! Fees this large could be paid on a single transaction.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+56"/>
+        <location line="+53"/>
         <source>This is the transaction fee you may pay when fee estimates are not available.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>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.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Total length of network version string (%i) exceeds maximum length (%i). Reduce the number or size of uacomments.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+11"/>
         <source>Warning: Wallet file corrupt, data salvaged! Original %s saved as %s in %s; if your balance or transactions are incorrect you should restore from a backup.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+11"/>
         <source>%s is set very high!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+41"/>
+        <location line="+40"/>
         <source>Keypool ran out, please call keypoolrefill first</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+21"/>
+        <location line="+19"/>
         <source>Starting network threads...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>The wallet will avoid paying less than the minimum relay fee.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>This is the minimum transaction fee you pay on every transaction.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>This is the transaction fee you will pay if you send a transaction.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Transaction amounts must not be negative</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Transaction has too long of a mempool chain</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Transaction must have at least one recipient</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+9"/>
         <source>Unknown network specified in -onlynet: &apos;%s&apos;</source>
         <translation>Unknown network specified in -onlynet: &apos;%s&apos;</translation>
     </message>
     <message>
-        <location line="-48"/>
+        <location line="-46"/>
         <source>Insufficient funds</source>
         <translation>Insufficient funds</translation>
     </message>
     <message>
-        <location line="-119"/>
-        <source>Bitcoin</source>
-        <translation type="unfinished">Bitcoin</translation>
-    </message>
-    <message>
-        <location line="+7"/>
+        <location line="-111"/>
         <source>Can&apos;t generate a change-address key. Private keys are disabled for this wallet.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+5"/>
         <source>Cannot provide specific connections and have addrman find outgoing connections at the same.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Cannot upgrade a non HD split wallet without upgrading to support pre split keypool. Please use -upgradewallet=200300 or -upgradewallet with no version specified.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+15"/>
         <source>Max generated block size (blockmaxsize) cannot exceed the excessive block size (excessiveblocksize)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+36"/>
         <source>Unable to replay blocks. You will need to rebuild the database using -reindex-chainstate.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Warning: Private keys detected in wallet {%s} with disabled private keys</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+20"/>
         <source>Cannot write to data directory &apos;%s&apos;; check permissions.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Config setting for %s only applied on %s network when in [%s] section.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+9"/>
+        <location line="+8"/>
         <source>Error loading %s: Private keys can only be disabled during creation</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+4"/>
         <source>Error loading wallet %s. Duplicate -wallet filename specified.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Error upgrading chainstate database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+3"/>
         <source>Error: Disk space is low for %s</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Excessive block size must be &gt; 1,000,000 bytes (1MB)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Failed to rescan the wallet during initialization</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Invalid -onion address or hostname: &apos;%s&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Invalid -proxy address or hostname: &apos;%s&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+6"/>
         <source>Loading P2P addresses...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+2"/>
         <source>Loading block index...</source>
         <translation>Loading block index...</translation>
     </message>
     <message>
-        <location line="+39"/>
+        <location line="+37"/>
         <source>Unsupported logging category %s=%s.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Upgrading UTXO database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+1"/>
         <source>Upgrading txindex database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="-40"/>
+        <location line="-38"/>
         <source>Loading wallet...</source>
         <translation>Loading wallet...</translation>
     </message>
     <message>
-        <location line="-43"/>
+        <location line="-42"/>
         <source>Cannot downgrade wallet</source>
         <translation>Cannot downgrade wallet</translation>
     </message>
     <message>
-        <location line="+52"/>
+        <location line="+50"/>
         <source>Rescanning...</source>
         <translation>Rescanning...</translation>
     </message>
     <message>
-        <location line="-43"/>
+        <location line="-42"/>
         <source>Done loading</source>
         <translation>Done loading</translation>
     </message>
     <message>
         <location line="+12"/>
         <source>Error</source>
         <translation>Error</translation>
     </message>
 </context>
 </TS>
diff --git a/src/qt/optionsdialog.cpp b/src/qt/optionsdialog.cpp
index 1ead83235..298cf9851 100644
--- a/src/qt/optionsdialog.cpp
+++ b/src/qt/optionsdialog.cpp
@@ -1,419 +1,419 @@
 // 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_optionsdialog.h>
 #include <qt/optionsdialog.h>
 
 #include <interfaces/node.h>
 #include <netbase.h>
 #include <qt/bitcoinunits.h>
 #include <qt/guiutil.h>
 #include <qt/optionsmodel.h>
 #include <txdb.h>       // for -dbcache defaults
 #include <validation.h> // for DEFAULT_SCRIPTCHECK_THREADS and MAX_SCRIPTCHECK_THREADS
 
 #include <QDataWidgetMapper>
 #include <QDir>
 #include <QIntValidator>
 #include <QLocale>
 #include <QMessageBox>
 #include <QSystemTrayIcon>
 #include <QTimer>
 
 OptionsDialog::OptionsDialog(QWidget *parent, bool enableWallet)
     : QDialog(parent), ui(new Ui::OptionsDialog), model(nullptr),
       mapper(nullptr) {
     ui->setupUi(this);
 
     /* Main elements init */
     ui->databaseCache->setMinimum(nMinDbCache);
     ui->databaseCache->setMaximum(nMaxDbCache);
     static const uint64_t GiB = 1024 * 1024 * 1024;
     static const uint64_t nMinDiskSpace =
         MIN_DISK_SPACE_FOR_BLOCK_FILES / GiB +
                 (MIN_DISK_SPACE_FOR_BLOCK_FILES % GiB)
             ? 1
             : 0;
     ui->pruneSize->setMinimum(nMinDiskSpace);
     ui->threadsScriptVerif->setMinimum(-GetNumCores());
     ui->threadsScriptVerif->setMaximum(MAX_SCRIPTCHECK_THREADS);
     ui->pruneWarning->setVisible(false);
     ui->pruneWarning->setStyleSheet("QLabel { color: red; }");
 
     ui->pruneSize->setEnabled(false);
     connect(ui->prune, &QPushButton::toggled, ui->pruneSize,
             &QWidget::setEnabled);
 
 /* Network elements init */
 #ifndef USE_UPNP
     ui->mapPortUpnp->setEnabled(false);
 #endif
 
     ui->proxyIp->setEnabled(false);
     ui->proxyPort->setEnabled(false);
     ui->proxyPort->setValidator(new QIntValidator(1, 65535, this));
 
     ui->proxyIpTor->setEnabled(false);
     ui->proxyPortTor->setEnabled(false);
     ui->proxyPortTor->setValidator(new QIntValidator(1, 65535, this));
 
     connect(ui->connectSocks, &QPushButton::toggled, ui->proxyIp,
             &QWidget::setEnabled);
     connect(ui->connectSocks, &QPushButton::toggled, ui->proxyPort,
             &QWidget::setEnabled);
     connect(ui->connectSocks, &QPushButton::toggled, this,
             &OptionsDialog::updateProxyValidationState);
 
     connect(ui->connectSocksTor, &QPushButton::toggled, ui->proxyIpTor,
             &QWidget::setEnabled);
     connect(ui->connectSocksTor, &QPushButton::toggled, ui->proxyPortTor,
             &QWidget::setEnabled);
     connect(ui->connectSocksTor, &QPushButton::toggled, this,
             &OptionsDialog::updateProxyValidationState);
 
     /* Window elements init */
 #ifdef Q_OS_MAC
     /* remove Window tab on Mac */
     ui->tabWidget->removeTab(ui->tabWidget->indexOf(ui->tabWindow));
 #endif
 
     /* remove Wallet tab in case of -disablewallet */
     if (!enableWallet) {
         ui->tabWidget->removeTab(ui->tabWidget->indexOf(ui->tabWallet));
     }
 
     /* Display elements init */
     QDir translations(":translations");
 
     ui->bitcoinAtStartup->setToolTip(
-        ui->bitcoinAtStartup->toolTip().arg(tr(PACKAGE_NAME)));
+        ui->bitcoinAtStartup->toolTip().arg(PACKAGE_NAME));
     ui->bitcoinAtStartup->setText(
-        ui->bitcoinAtStartup->text().arg(tr(PACKAGE_NAME)));
+        ui->bitcoinAtStartup->text().arg(PACKAGE_NAME));
 
     ui->openBitcoinConfButton->setToolTip(
-        ui->openBitcoinConfButton->toolTip().arg(tr(PACKAGE_NAME)));
+        ui->openBitcoinConfButton->toolTip().arg(PACKAGE_NAME));
 
-    ui->lang->setToolTip(ui->lang->toolTip().arg(tr(PACKAGE_NAME)));
+    ui->lang->setToolTip(ui->lang->toolTip().arg(PACKAGE_NAME));
     ui->lang->addItem(QString("(") + tr("default") + QString(")"),
                       QVariant(""));
     for (const QString &langStr : translations.entryList()) {
         QLocale locale(langStr);
 
         /** check if the locale name consists of 2 parts (language_country) */
         if (langStr.contains("_")) {
             /** display language strings as "native language - native country
              * (locale name)", e.g. "Deutsch - Deutschland (de)" */
             ui->lang->addItem(locale.nativeLanguageName() + QString(" - ") +
                                   locale.nativeCountryName() + QString(" (") +
                                   langStr + QString(")"),
                               QVariant(langStr));
         } else {
             /** display language strings as "native language (locale name)",
              * e.g. "Deutsch (de)" */
             ui->lang->addItem(locale.nativeLanguageName() + QString(" (") +
                                   langStr + QString(")"),
                               QVariant(langStr));
         }
     }
     ui->thirdPartyTxUrls->setPlaceholderText("https://example.com/tx/%s");
 
     ui->unit->setModel(new BitcoinUnits(this));
 
     /* Widget-to-option mapper */
     mapper = new QDataWidgetMapper(this);
     mapper->setSubmitPolicy(QDataWidgetMapper::ManualSubmit);
     mapper->setOrientation(Qt::Vertical);
 
     GUIUtil::ItemDelegate *delegate = new GUIUtil::ItemDelegate(mapper);
     connect(delegate, &GUIUtil::ItemDelegate::keyEscapePressed, this,
             &OptionsDialog::reject);
     mapper->setItemDelegate(delegate);
 
     /* setup/change UI elements when proxy IPs are invalid/valid */
     ui->proxyIp->setCheckValidator(new ProxyAddressValidator(parent));
     ui->proxyIpTor->setCheckValidator(new ProxyAddressValidator(parent));
     connect(ui->proxyIp, &QValidatedLineEdit::validationDidChange, this,
             &OptionsDialog::updateProxyValidationState);
     connect(ui->proxyIpTor, &QValidatedLineEdit::validationDidChange, this,
             &OptionsDialog::updateProxyValidationState);
     connect(ui->proxyPort, &QLineEdit::textChanged, this,
             &OptionsDialog::updateProxyValidationState);
     connect(ui->proxyPortTor, &QLineEdit::textChanged, this,
             &OptionsDialog::updateProxyValidationState);
 
     if (!QSystemTrayIcon::isSystemTrayAvailable()) {
         ui->hideTrayIcon->setChecked(true);
         ui->hideTrayIcon->setEnabled(false);
         ui->minimizeToTray->setChecked(false);
         ui->minimizeToTray->setEnabled(false);
     }
 }
 
 OptionsDialog::~OptionsDialog() {
     delete ui;
 }
 
 void OptionsDialog::setModel(OptionsModel *_model) {
     this->model = _model;
 
     if (_model) {
         /* check if client restart is needed and show persistent message */
         if (_model->isRestartRequired()) {
             showRestartWarning(true);
         }
 
         QString strLabel = _model->getOverriddenByCommandLine();
         if (strLabel.isEmpty()) {
             strLabel = tr("none");
         }
         ui->overriddenByCommandLineLabel->setText(strLabel);
 
         mapper->setModel(_model);
         setMapper();
         mapper->toFirst();
 
         updateDefaultProxyNets();
     }
 
     /* warn when one of the following settings changes by user action (placed
      * here so init via mapper doesn't trigger them) */
 
     /* Main */
     connect(ui->prune, &QCheckBox::clicked, this,
             &OptionsDialog::showRestartWarning);
     connect(ui->prune, &QCheckBox::clicked, this,
             &OptionsDialog::togglePruneWarning);
     connect(ui->pruneSize,
             static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this,
             &OptionsDialog::showRestartWarning);
     connect(ui->databaseCache,
             static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this,
             &OptionsDialog::showRestartWarning);
     connect(ui->threadsScriptVerif,
             static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this,
             &OptionsDialog::showRestartWarning);
     /* Wallet */
     connect(ui->spendZeroConfChange, &QCheckBox::clicked, this,
             &OptionsDialog::showRestartWarning);
     /* Network */
     connect(ui->allowIncoming, &QCheckBox::clicked, this,
             &OptionsDialog::showRestartWarning);
     connect(ui->connectSocks, &QCheckBox::clicked, this,
             &OptionsDialog::showRestartWarning);
     connect(ui->connectSocksTor, &QCheckBox::clicked, this,
             &OptionsDialog::showRestartWarning);
     /* Display */
     connect(
         ui->lang,
         static_cast<void (QValueComboBox::*)()>(&QValueComboBox::valueChanged),
         [this] { showRestartWarning(); });
     connect(ui->thirdPartyTxUrls, &QLineEdit::textChanged,
             [this] { showRestartWarning(); });
 }
 
 void OptionsDialog::setCurrentTab(OptionsDialog::Tab tab) {
     QWidget *tab_widget = nullptr;
     if (tab == OptionsDialog::Tab::TAB_NETWORK) {
         tab_widget = ui->tabNetwork;
     }
     if (tab == OptionsDialog::Tab::TAB_MAIN) {
         tab_widget = ui->tabMain;
     }
     if (tab_widget && ui->tabWidget->currentWidget() != tab_widget) {
         ui->tabWidget->setCurrentWidget(tab_widget);
     }
 }
 
 void OptionsDialog::setMapper() {
     /* Main */
     mapper->addMapping(ui->bitcoinAtStartup, OptionsModel::StartAtStartup);
     mapper->addMapping(ui->threadsScriptVerif,
                        OptionsModel::ThreadsScriptVerif);
     mapper->addMapping(ui->databaseCache, OptionsModel::DatabaseCache);
     mapper->addMapping(ui->prune, OptionsModel::Prune);
     mapper->addMapping(ui->pruneSize, OptionsModel::PruneSize);
 
     /* Wallet */
     mapper->addMapping(ui->spendZeroConfChange,
                        OptionsModel::SpendZeroConfChange);
     mapper->addMapping(ui->coinControlFeatures,
                        OptionsModel::CoinControlFeatures);
 
     /* Network */
     mapper->addMapping(ui->mapPortUpnp, OptionsModel::MapPortUPnP);
     mapper->addMapping(ui->allowIncoming, OptionsModel::Listen);
 
     mapper->addMapping(ui->connectSocks, OptionsModel::ProxyUse);
     mapper->addMapping(ui->proxyIp, OptionsModel::ProxyIP);
     mapper->addMapping(ui->proxyPort, OptionsModel::ProxyPort);
 
     mapper->addMapping(ui->connectSocksTor, OptionsModel::ProxyUseTor);
     mapper->addMapping(ui->proxyIpTor, OptionsModel::ProxyIPTor);
     mapper->addMapping(ui->proxyPortTor, OptionsModel::ProxyPortTor);
 
 /* Window */
 #ifndef Q_OS_MAC
     if (QSystemTrayIcon::isSystemTrayAvailable()) {
         mapper->addMapping(ui->hideTrayIcon, OptionsModel::HideTrayIcon);
         mapper->addMapping(ui->minimizeToTray, OptionsModel::MinimizeToTray);
     }
     mapper->addMapping(ui->minimizeOnClose, OptionsModel::MinimizeOnClose);
 #endif
 
     /* Display */
     mapper->addMapping(ui->lang, OptionsModel::Language);
     mapper->addMapping(ui->unit, OptionsModel::DisplayUnit);
     mapper->addMapping(ui->thirdPartyTxUrls, OptionsModel::ThirdPartyTxUrls);
 }
 
 void OptionsDialog::setOkButtonState(bool fState) {
     ui->okButton->setEnabled(fState);
 }
 
 void OptionsDialog::on_resetButton_clicked() {
     if (model) {
         // confirmation dialog
         QMessageBox::StandardButton btnRetVal = QMessageBox::question(
             this, tr("Confirm options reset"),
             tr("Client restart required to activate changes.") + "<br><br>" +
                 tr("Client will be shut down. Do you want to proceed?"),
             QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Cancel);
 
         if (btnRetVal == QMessageBox::Cancel) {
             return;
         }
 
         /* reset all options and close GUI */
         model->Reset();
         QApplication::quit();
     }
 }
 
 void OptionsDialog::on_openBitcoinConfButton_clicked() {
     /* explain the purpose of the config file */
     QMessageBox::information(
         this, tr("Configuration options"),
         tr("The configuration file is used to specify advanced user options "
            "which override GUI settings. Additionally, any command-line "
            "options will override this configuration file."));
 
     /* show an error if there was some problem opening the file */
     if (!GUIUtil::openBitcoinConf()) {
         QMessageBox::critical(
             this, tr("Error"),
             tr("The configuration file could not be opened."));
     }
 }
 
 void OptionsDialog::on_okButton_clicked() {
     mapper->submit();
     accept();
     updateDefaultProxyNets();
 }
 
 void OptionsDialog::on_cancelButton_clicked() {
     reject();
 }
 
 void OptionsDialog::on_hideTrayIcon_stateChanged(int fState) {
     if (fState) {
         ui->minimizeToTray->setChecked(false);
         ui->minimizeToTray->setEnabled(false);
     } else {
         ui->minimizeToTray->setEnabled(true);
     }
 }
 
 void OptionsDialog::togglePruneWarning(bool enabled) {
     ui->pruneWarning->setVisible(!ui->pruneWarning->isVisible());
 }
 
 void OptionsDialog::showRestartWarning(bool fPersistent) {
     ui->statusLabel->setStyleSheet("QLabel { color: red; }");
 
     if (fPersistent) {
         ui->statusLabel->setText(
             tr("Client restart required to activate changes."));
     } else {
         ui->statusLabel->setText(
             tr("This change would require a client restart."));
         // clear non-persistent status label after 10 seconds
         // TODO: should perhaps be a class attribute, if we extend the use of
         // statusLabel
         QTimer::singleShot(10000, this, &OptionsDialog::clearStatusLabel);
     }
 }
 
 void OptionsDialog::clearStatusLabel() {
     ui->statusLabel->clear();
     if (model && model->isRestartRequired()) {
         showRestartWarning(true);
     }
 }
 
 void OptionsDialog::updateProxyValidationState() {
     QValidatedLineEdit *pUiProxyIp = ui->proxyIp;
     QValidatedLineEdit *otherProxyWidget =
         (pUiProxyIp == ui->proxyIpTor) ? ui->proxyIp : ui->proxyIpTor;
     if (pUiProxyIp->isValid() &&
         (!ui->proxyPort->isEnabled() || ui->proxyPort->text().toInt() > 0) &&
         (!ui->proxyPortTor->isEnabled() ||
          ui->proxyPortTor->text().toInt() > 0)) {
         // Only enable ok button if both proxys are valid
         setOkButtonState(otherProxyWidget->isValid());
         clearStatusLabel();
     } else {
         setOkButtonState(false);
         ui->statusLabel->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel->setText(tr("The supplied proxy address is invalid."));
     }
 }
 
 void OptionsDialog::updateDefaultProxyNets() {
     proxyType proxy;
     std::string strProxy;
     QString strDefaultProxyGUI;
 
     model->node().getProxy(NET_IPV4, proxy);
     strProxy = proxy.proxy.ToStringIP() + ":" + proxy.proxy.ToStringPort();
     strDefaultProxyGUI = ui->proxyIp->text() + ":" + ui->proxyPort->text();
     (strProxy == strDefaultProxyGUI.toStdString())
         ? ui->proxyReachIPv4->setChecked(true)
         : ui->proxyReachIPv4->setChecked(false);
 
     model->node().getProxy(NET_IPV6, proxy);
     strProxy = proxy.proxy.ToStringIP() + ":" + proxy.proxy.ToStringPort();
     strDefaultProxyGUI = ui->proxyIp->text() + ":" + ui->proxyPort->text();
     (strProxy == strDefaultProxyGUI.toStdString())
         ? ui->proxyReachIPv6->setChecked(true)
         : ui->proxyReachIPv6->setChecked(false);
 
     model->node().getProxy(NET_ONION, proxy);
     strProxy = proxy.proxy.ToStringIP() + ":" + proxy.proxy.ToStringPort();
     strDefaultProxyGUI = ui->proxyIp->text() + ":" + ui->proxyPort->text();
     (strProxy == strDefaultProxyGUI.toStdString())
         ? ui->proxyReachTor->setChecked(true)
         : ui->proxyReachTor->setChecked(false);
 }
 
 ProxyAddressValidator::ProxyAddressValidator(QObject *parent)
     : QValidator(parent) {}
 
 QValidator::State ProxyAddressValidator::validate(QString &input,
                                                   int &pos) const {
     Q_UNUSED(pos);
     // Validate the proxy
     CService serv(
         LookupNumeric(input.toStdString().c_str(), DEFAULT_GUI_PROXY_PORT));
     proxyType addrProxy = proxyType(serv, true);
     if (addrProxy.IsValid()) {
         return QValidator::Acceptable;
     }
 
     return QValidator::Invalid;
 }
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index 56f984861..d77954f48 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -1,1468 +1,1467 @@
 // 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.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/rpcconsole.h>
 
 #include <chainparams.h>
 #include <config.h>
 #include <interfaces/node.h>
 #include <netbase.h>
 #include <qt/bantablemodel.h>
 #include <qt/clientmodel.h>
 #include <qt/forms/ui_debugwindow.h>
 #include <qt/guiutil.h>
 #include <qt/platformstyle.h>
 #include <qt/walletmodel.h>
 #include <rpc/client.h>
 #include <rpc/server.h>
 #include <util/system.h>
 
 #ifdef ENABLE_WALLET
 #include <wallet/wallet.h>
 
 #include <db_cxx.h>
 #endif
 
 #include <QKeyEvent>
 #include <QMenu>
 #include <QMessageBox>
 #include <QScreen>
 #include <QScrollBar>
 #include <QSettings>
 #include <QSignalMapper>
 #include <QStringList>
 #include <QThread>
 #include <QTime>
 #include <QTimer>
 
 #include <univalue.h>
 
 // TODO: add a scrollback limit, as there is currently none
 // TODO: make it possible to filter out categories (esp debug messages when
 // implemented)
 // TODO: receive errors and debug messages through ClientModel
 
 const int CONSOLE_HISTORY = 50;
 const int INITIAL_TRAFFIC_GRAPH_MINS = 30;
 const QSize FONT_RANGE(4, 40);
 const char fontSizeSettingsKey[] = "consoleFontSize";
 
 const struct {
     const char *url;
     const char *source;
 } ICON_MAPPING[] = {{"cmd-request", ":/icons/tx_input"},
                     {"cmd-reply", ":/icons/tx_output"},
                     {"cmd-error", ":/icons/tx_output"},
                     {"misc", ":/icons/tx_inout"},
                     {nullptr, nullptr}};
 
 namespace {
 
 // don't add private key handling cmd's to the history
 const QStringList historyFilter = QStringList() << "importprivkey"
                                                 << "importmulti"
                                                 << "sethdseed"
                                                 << "signmessagewithprivkey"
                                                 << "signrawtransactionwithkey"
                                                 << "walletpassphrase"
                                                 << "walletpassphrasechange"
                                                 << "encryptwallet";
 } // namespace
 
 /* Object for executing console RPC commands in a separate thread.
  */
 class RPCExecutor : public QObject {
     Q_OBJECT
 public:
     RPCExecutor(interfaces::Node &node) : m_node(node) {}
 
 public Q_SLOTS:
     void request(const QString &command, const WalletModel *wallet_model);
 
 Q_SIGNALS:
     void reply(int category, const QString &command);
 
 private:
     interfaces::Node &m_node;
 };
 
 /** Class for handling RPC timers
  * (used for e.g. re-locking the wallet after a timeout)
  */
 class QtRPCTimerBase : public QObject, public RPCTimerBase {
     Q_OBJECT
 public:
     QtRPCTimerBase(std::function<void()> &_func, int64_t millis) : func(_func) {
         timer.setSingleShot(true);
         connect(&timer, &QTimer::timeout, [this] { func(); });
         timer.start(millis);
     }
     ~QtRPCTimerBase() {}
 
 private:
     QTimer timer;
     std::function<void()> func;
 };
 
 class QtRPCTimerInterface : public RPCTimerInterface {
 public:
     ~QtRPCTimerInterface() {}
     const char *Name() override { return "Qt"; }
     RPCTimerBase *NewTimer(std::function<void()> &func,
                            int64_t millis) override {
         return new QtRPCTimerBase(func, millis);
     }
 };
 
 #include <qt/rpcconsole.moc>
 
 /**
  * Split shell command line into a list of arguments and optionally execute the
  * command(s).
  * Aims to emulate \c bash and friends.
  *
  * - Command nesting is possible with parenthesis; for example:
  * validateaddress(getnewaddress())
  * - Arguments are delimited with whitespace or comma
  * - Extra whitespace at the beginning and end and between arguments will be
  * ignored
  * - Text can be "double" or 'single' quoted
  * - The backslash \c \ is used as escape character
  *   - Outside quotes, any character can be escaped
  *   - Within double quotes, only escape \c " and backslashes before a \c " or
  * another backslash
  *   - Within single quotes, no escaping is possible and no special
  * interpretation takes place
  *
  * @param[in]    node    optional node to execute command on
  * @param[out]   result      stringified Result from the executed command(chain)
  * @param[in]    strCommand  Command line to split
  * @param[in]    fExecute    set true if you want the command to be executed
  * @param[out]   pstrFilteredOut  Command line, filtered to remove any sensitive
  * data
  */
 
 bool RPCConsole::RPCParseCommandLine(interfaces::Node *node,
                                      std::string &strResult,
                                      const std::string &strCommand,
                                      const bool fExecute,
                                      std::string *const pstrFilteredOut,
                                      const WalletModel *wallet_model) {
     std::vector<std::vector<std::string>> stack;
     stack.push_back(std::vector<std::string>());
 
     enum CmdParseState {
         STATE_EATING_SPACES,
         STATE_EATING_SPACES_IN_ARG,
         STATE_EATING_SPACES_IN_BRACKETS,
         STATE_ARGUMENT,
         STATE_SINGLEQUOTED,
         STATE_DOUBLEQUOTED,
         STATE_ESCAPE_OUTER,
         STATE_ESCAPE_DOUBLEQUOTED,
         STATE_COMMAND_EXECUTED,
         STATE_COMMAND_EXECUTED_INNER
     } state = STATE_EATING_SPACES;
     std::string curarg;
     UniValue lastResult;
     unsigned nDepthInsideSensitive = 0;
     size_t filter_begin_pos = 0, chpos;
     std::vector<std::pair<size_t, size_t>> filter_ranges;
 
     auto add_to_current_stack = [&](const std::string &strArg) {
         if (stack.back().empty() && (!nDepthInsideSensitive) &&
             historyFilter.contains(QString::fromStdString(strArg),
                                    Qt::CaseInsensitive)) {
             nDepthInsideSensitive = 1;
             filter_begin_pos = chpos;
         }
         // Make sure stack is not empty before adding something
         if (stack.empty()) {
             stack.push_back(std::vector<std::string>());
         }
         stack.back().push_back(strArg);
     };
 
     auto close_out_params = [&]() {
         if (nDepthInsideSensitive) {
             if (!--nDepthInsideSensitive) {
                 assert(filter_begin_pos);
                 filter_ranges.push_back(
                     std::make_pair(filter_begin_pos, chpos));
                 filter_begin_pos = 0;
             }
         }
         stack.pop_back();
     };
 
     std::string strCommandTerminated = strCommand;
     if (strCommandTerminated.back() != '\n') {
         strCommandTerminated += "\n";
     }
     for (chpos = 0; chpos < strCommandTerminated.size(); ++chpos) {
         char ch = strCommandTerminated[chpos];
         switch (state) {
             case STATE_COMMAND_EXECUTED_INNER:
             case STATE_COMMAND_EXECUTED: {
                 bool breakParsing = true;
                 switch (ch) {
                     case '[':
                         curarg.clear();
                         state = STATE_COMMAND_EXECUTED_INNER;
                         break;
                     default:
                         if (state == STATE_COMMAND_EXECUTED_INNER) {
                             if (ch != ']') {
                                 // append char to the current argument (which is
                                 // also used for the query command)
                                 curarg += ch;
                                 break;
                             }
                             if (curarg.size() && fExecute) {
                                 // if we have a value query, query arrays with
                                 // index and objects with a string key
                                 UniValue subelement;
                                 if (lastResult.isArray()) {
                                     for (char argch : curarg) {
                                         if (!std::isdigit(argch)) {
                                             throw std::runtime_error(
                                                 "Invalid result query");
                                         }
                                     }
                                     subelement =
                                         lastResult[atoi(curarg.c_str())];
                                 } else if (lastResult.isObject()) {
                                     subelement = find_value(lastResult, curarg);
                                 } else {
                                     // no array or object: abort
                                     throw std::runtime_error(
                                         "Invalid result query");
                                 }
                                 lastResult = subelement;
                             }
 
                             state = STATE_COMMAND_EXECUTED;
                             break;
                         }
                         // don't break parsing when the char is required for the
                         // next argument
                         breakParsing = false;
 
                         // pop the stack and return the result to the current
                         // command arguments
                         close_out_params();
 
                         // don't stringify the json in case of a string to avoid
                         // doublequotes
                         if (lastResult.isStr()) {
                             curarg = lastResult.get_str();
                         } else {
                             curarg = lastResult.write(2);
                         }
 
                         // if we have a non empty result, use it as stack
                         // argument otherwise as general result
                         if (curarg.size()) {
                             if (stack.size()) {
                                 add_to_current_stack(curarg);
                             } else {
                                 strResult = curarg;
                             }
                         }
                         curarg.clear();
                         // assume eating space state
                         state = STATE_EATING_SPACES;
                 }
 
                 if (breakParsing) {
                     break;
                 }
             }
             // FALLTHROUGH
             case STATE_ARGUMENT: // In or after argument
             case STATE_EATING_SPACES_IN_ARG:
             case STATE_EATING_SPACES_IN_BRACKETS:
             case STATE_EATING_SPACES: // Handle runs of whitespace
                 switch (ch) {
                     case '"':
                         state = STATE_DOUBLEQUOTED;
                         break;
                     case '\'':
                         state = STATE_SINGLEQUOTED;
                         break;
                     case '\\':
                         state = STATE_ESCAPE_OUTER;
                         break;
                     case '(':
                     case ')':
                     case '\n':
                         if (state == STATE_EATING_SPACES_IN_ARG) {
                             throw std::runtime_error("Invalid Syntax");
                         }
                         if (state == STATE_ARGUMENT) {
                             if (ch == '(' && stack.size() &&
                                 stack.back().size() > 0) {
                                 if (nDepthInsideSensitive) {
                                     ++nDepthInsideSensitive;
                                 }
                                 stack.push_back(std::vector<std::string>());
                             }
 
                             // don't allow commands after executed commands on
                             // baselevel
                             if (!stack.size()) {
                                 throw std::runtime_error("Invalid Syntax");
                             }
 
                             add_to_current_stack(curarg);
                             curarg.clear();
                             state = STATE_EATING_SPACES_IN_BRACKETS;
                         }
                         if ((ch == ')' || ch == '\n') && stack.size() > 0) {
                             if (fExecute) {
                                 // Convert argument list to JSON objects in
                                 // method-dependent way, and pass it along with
                                 // the method name to the dispatcher.
                                 UniValue params = RPCConvertValues(
                                     stack.back()[0],
                                     std::vector<std::string>(
                                         stack.back().begin() + 1,
                                         stack.back().end()));
                                 std::string method = stack.back()[0];
                                 std::string uri;
 
 #ifdef ENABLE_WALLET
                                 if (wallet_model) {
                                     QByteArray encodedName =
                                         QUrl::toPercentEncoding(
                                             wallet_model->getWalletName());
                                     uri = "/wallet/" +
                                           std::string(encodedName.constData(),
                                                       encodedName.length());
                                 }
 #endif
 
                                 GlobalConfig config;
                                 assert(node);
                                 lastResult = node->executeRpc(config, method,
                                                               params, uri);
                             }
 
                             state = STATE_COMMAND_EXECUTED;
                             curarg.clear();
                         }
                         break;
                     case ' ':
                     case ',':
                     case '\t':
                         if (state == STATE_EATING_SPACES_IN_ARG &&
                             curarg.empty() && ch == ',') {
                             throw std::runtime_error("Invalid Syntax");
                         } else if (state == STATE_ARGUMENT) {
                             // Space ends argument
                             add_to_current_stack(curarg);
                             curarg.clear();
                         }
                         if ((state == STATE_EATING_SPACES_IN_BRACKETS ||
                              state == STATE_ARGUMENT) &&
                             ch == ',') {
                             state = STATE_EATING_SPACES_IN_ARG;
                             break;
                         }
                         state = STATE_EATING_SPACES;
                         break;
                     default:
                         curarg += ch;
                         state = STATE_ARGUMENT;
                 }
                 break;
             case STATE_SINGLEQUOTED: // Single-quoted string
                 switch (ch) {
                     case '\'':
                         state = STATE_ARGUMENT;
                         break;
                     default:
                         curarg += ch;
                 }
                 break;
             case STATE_DOUBLEQUOTED: // Double-quoted string
                 switch (ch) {
                     case '"':
                         state = STATE_ARGUMENT;
                         break;
                     case '\\':
                         state = STATE_ESCAPE_DOUBLEQUOTED;
                         break;
                     default:
                         curarg += ch;
                 }
                 break;
             case STATE_ESCAPE_OUTER: // '\' outside quotes
                 curarg += ch;
                 state = STATE_ARGUMENT;
                 break;
             case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
                 if (ch != '"' && ch != '\\') {
                     // keep '\' for everything but the quote and '\' itself
                     curarg += '\\';
                 }
                 curarg += ch;
                 state = STATE_DOUBLEQUOTED;
                 break;
         }
     }
     if (pstrFilteredOut) {
         if (STATE_COMMAND_EXECUTED == state) {
             assert(!stack.empty());
             close_out_params();
         }
         *pstrFilteredOut = strCommand;
         for (auto i = filter_ranges.rbegin(); i != filter_ranges.rend(); ++i) {
             pstrFilteredOut->replace(i->first, i->second - i->first, "(…)");
         }
     }
 
     // final state
     switch (state) {
         case STATE_COMMAND_EXECUTED:
             if (lastResult.isStr()) {
                 strResult = lastResult.get_str();
             } else {
                 strResult = lastResult.write(2);
             }
         // FALLTHROUGH
         case STATE_ARGUMENT:
         case STATE_EATING_SPACES:
             return true;
         default: // ERROR to end in one of the other states
             return false;
     }
 }
 
 void RPCExecutor::request(const QString &command,
                           const WalletModel *wallet_model) {
     try {
         std::string result;
         std::string executableCommand = command.toStdString() + "\n";
 
         // Catch the console-only-help command before RPC call is executed and
         // reply with help text as-if a RPC reply.
         if (executableCommand == "help-console\n") {
             Q_EMIT reply(
                 RPCConsole::CMD_REPLY,
                 QString(("\n"
                          "This console accepts RPC commands using the standard "
                          "syntax.\n"
                          "   example:    getblockhash 0\n\n"
 
                          "This console can also accept RPC commands using "
                          "parenthesized syntax.\n"
                          "   example:    getblockhash(0)\n\n"
 
                          "Commands may be nested when specified with the "
                          "parenthesized syntax.\n"
                          "   example:    getblock(getblockhash(0) 1)\n\n"
 
                          "A space or a comma can be used to delimit arguments "
                          "for either syntax.\n"
                          "   example:    getblockhash 0\n"
                          "               getblockhash,0\n\n"
 
                          "Named results can be queried with a non-quoted key "
                          "string in brackets.\n"
                          "   example:    getblock(getblockhash(0) true)[tx]\n\n"
 
                          "Results without keys can be queried using an integer "
                          "in brackets.\n"
                          "   example:    "
                          "getblock(getblockhash(0),true)[tx][0]\n\n")));
             return;
         }
         if (!RPCConsole::RPCExecuteCommandLine(
                 m_node, result, executableCommand, nullptr, wallet_model)) {
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString("Parse error: unbalanced ' or \""));
             return;
         }
 
         Q_EMIT reply(RPCConsole::CMD_REPLY, QString::fromStdString(result));
     } catch (UniValue &objError) {
         // Nice formatting for standard-format error
         try {
             int code = find_value(objError, "code").get_int();
             std::string message = find_value(objError, "message").get_str();
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString::fromStdString(message) + " (code " +
                              QString::number(code) + ")");
         } catch (const std::runtime_error &) {
             // raised when converting to invalid type, i.e. missing code or
             // message. Show raw JSON object.
             Q_EMIT reply(RPCConsole::CMD_ERROR,
                          QString::fromStdString(objError.write()));
         }
     } catch (const std::exception &e) {
         Q_EMIT reply(RPCConsole::CMD_ERROR,
                      QString("Error: ") + QString::fromStdString(e.what()));
     }
 }
 
 RPCConsole::RPCConsole(interfaces::Node &node,
                        const PlatformStyle *_platformStyle, QWidget *parent)
     : QWidget(parent), m_node(node), ui(new Ui::RPCConsole),
       platformStyle(_platformStyle) {
     ui->setupUi(this);
     QSettings settings;
     if (!restoreGeometry(
             settings.value("RPCConsoleWindowGeometry").toByteArray())) {
         // Restore failed (perhaps missing setting), center the window
         move(QGuiApplication::primaryScreen()->availableGeometry().center() -
              frameGeometry().center());
     }
 
     QChar nonbreaking_hyphen(8209);
     ui->dataDir->setToolTip(
         ui->dataDir->toolTip().arg(QString(nonbreaking_hyphen) + "datadir"));
     ui->blocksDir->setToolTip(ui->blocksDir->toolTip().arg(
         QString(nonbreaking_hyphen) + "blocksdir"));
     ui->openDebugLogfileButton->setToolTip(
-        ui->openDebugLogfileButton->toolTip().arg(tr(PACKAGE_NAME)));
+        ui->openDebugLogfileButton->toolTip().arg(PACKAGE_NAME));
 
     if (platformStyle->getImagesOnButtons()) {
         ui->openDebugLogfileButton->setIcon(
             platformStyle->SingleColorIcon(":/icons/export"));
     }
     ui->clearButton->setIcon(platformStyle->SingleColorIcon(":/icons/remove"));
     ui->fontBiggerButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/fontbigger"));
     ui->fontSmallerButton->setIcon(
         platformStyle->SingleColorIcon(":/icons/fontsmaller"));
 
     // Install event filter for up and down arrow
     ui->lineEdit->installEventFilter(this);
     ui->messagesWidget->installEventFilter(this);
 
     connect(ui->clearButton, &QPushButton::clicked, this, &RPCConsole::clear);
     connect(ui->fontBiggerButton, &QPushButton::clicked, this,
             &RPCConsole::fontBigger);
     connect(ui->fontSmallerButton, &QPushButton::clicked, this,
             &RPCConsole::fontSmaller);
     connect(ui->btnClearTrafficGraph, &QPushButton::clicked, ui->trafficGraph,
             &TrafficGraphWidget::clear);
 
     // disable the wallet selector by default
     ui->WalletSelector->setVisible(false);
     ui->WalletSelectorLabel->setVisible(false);
 
 // set library version labels
 #ifdef ENABLE_WALLET
     ui->berkeleyDBVersion->setText(DbEnv::version(nullptr, nullptr, nullptr));
 #else
     ui->label_berkeleyDBVersion->hide();
     ui->berkeleyDBVersion->hide();
 #endif
     // Register RPC timer interface
     rpcTimerInterface = new QtRPCTimerInterface();
     // avoid accidentally overwriting an existing, non QTThread
     // based timer interface
     m_node.rpcSetTimerInterfaceIfUnset(rpcTimerInterface);
 
     setTrafficGraphRange(INITIAL_TRAFFIC_GRAPH_MINS);
 
     ui->detailWidget->hide();
     ui->peerHeading->setText(tr("Select a peer to view detailed information."));
 
     consoleFontSize =
         settings.value(fontSizeSettingsKey, QFontInfo(QFont()).pointSize())
             .toInt();
     clear();
 }
 
 RPCConsole::~RPCConsole() {
     QSettings settings;
     settings.setValue("RPCConsoleWindowGeometry", saveGeometry());
     m_node.rpcUnsetTimerInterface(rpcTimerInterface);
     delete rpcTimerInterface;
     delete ui;
 }
 
 bool RPCConsole::eventFilter(QObject *obj, QEvent *event) {
     // Special key handling
     if (event->type() == QEvent::KeyPress) {
         QKeyEvent *keyevt = static_cast<QKeyEvent *>(event);
         int key = keyevt->key();
         Qt::KeyboardModifiers mod = keyevt->modifiers();
         switch (key) {
             case Qt::Key_Up:
                 if (obj == ui->lineEdit) {
                     browseHistory(-1);
                     return true;
                 }
                 break;
             case Qt::Key_Down:
                 if (obj == ui->lineEdit) {
                     browseHistory(1);
                     return true;
                 }
                 break;
             case Qt::Key_PageUp: /* pass paging keys to messages widget */
             case Qt::Key_PageDown:
                 if (obj == ui->lineEdit) {
                     QApplication::postEvent(ui->messagesWidget,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
                 break;
             case Qt::Key_Return:
             case Qt::Key_Enter:
                 // forward these events to lineEdit
                 if (obj == autoCompleter->popup()) {
                     QApplication::postEvent(ui->lineEdit,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
                 break;
             default:
                 // Typing in messages widget brings focus to line edit, and
                 // redirects key there. Exclude most combinations and keys that
                 // emit no text, except paste shortcuts.
                 if (obj == ui->messagesWidget &&
                     ((!mod && !keyevt->text().isEmpty() &&
                       key != Qt::Key_Tab) ||
                      ((mod & Qt::ControlModifier) && key == Qt::Key_V) ||
                      ((mod & Qt::ShiftModifier) && key == Qt::Key_Insert))) {
                     ui->lineEdit->setFocus();
                     QApplication::postEvent(ui->lineEdit,
                                             new QKeyEvent(*keyevt));
                     return true;
                 }
         }
     }
     return QWidget::eventFilter(obj, event);
 }
 
 void RPCConsole::setClientModel(ClientModel *model) {
     clientModel = model;
     ui->trafficGraph->setClientModel(model);
     if (model && clientModel->getPeerTableModel() &&
         clientModel->getBanTableModel()) {
         // Keep up to date with client
         setNumConnections(model->getNumConnections());
         connect(model, &ClientModel::numConnectionsChanged, this,
                 &RPCConsole::setNumConnections);
 
         interfaces::Node &node = clientModel->node();
         setNumBlocks(node.getNumBlocks(),
                      QDateTime::fromTime_t(node.getLastBlockTime()),
                      node.getVerificationProgress(), false);
         connect(model, &ClientModel::numBlocksChanged, this,
                 &RPCConsole::setNumBlocks);
 
         updateNetworkState();
         connect(model, &ClientModel::networkActiveChanged, this,
                 &RPCConsole::setNetworkActive);
 
         updateTrafficStats(node.getTotalBytesRecv(), node.getTotalBytesSent());
         connect(model, &ClientModel::bytesChanged, this,
                 &RPCConsole::updateTrafficStats);
 
         connect(model, &ClientModel::mempoolSizeChanged, this,
                 &RPCConsole::setMempoolSize);
 
         // set up peer table
         ui->peerWidget->setModel(model->getPeerTableModel());
         ui->peerWidget->verticalHeader()->hide();
         ui->peerWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
         ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
         ui->peerWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
         ui->peerWidget->setContextMenuPolicy(Qt::CustomContextMenu);
         ui->peerWidget->setColumnWidth(PeerTableModel::Address,
                                        ADDRESS_COLUMN_WIDTH);
         ui->peerWidget->setColumnWidth(PeerTableModel::Subversion,
                                        SUBVERSION_COLUMN_WIDTH);
         ui->peerWidget->setColumnWidth(PeerTableModel::Ping, PING_COLUMN_WIDTH);
         ui->peerWidget->horizontalHeader()->setStretchLastSection(true);
 
         // create peer table context menu actions
         QAction *disconnectAction = new QAction(tr("&Disconnect"), this);
         QAction *banAction1h =
             new QAction(tr("Ban for") + " " + tr("1 &hour"), this);
         QAction *banAction24h =
             new QAction(tr("Ban for") + " " + tr("1 &day"), this);
         QAction *banAction7d =
             new QAction(tr("Ban for") + " " + tr("1 &week"), this);
         QAction *banAction365d =
             new QAction(tr("Ban for") + " " + tr("1 &year"), this);
 
         // create peer table context menu
         peersTableContextMenu = new QMenu(this);
         peersTableContextMenu->addAction(disconnectAction);
         peersTableContextMenu->addAction(banAction1h);
         peersTableContextMenu->addAction(banAction24h);
         peersTableContextMenu->addAction(banAction7d);
         peersTableContextMenu->addAction(banAction365d);
 
         // Add a signal mapping to allow dynamic context menu arguments. We need
         // to use int (instead of int64_t), because signal mapper only supports
         // int or objects, which is okay because max bantime (1 year) is <
         // int_max.
         QSignalMapper *signalMapper = new QSignalMapper(this);
         signalMapper->setMapping(banAction1h, 60 * 60);
         signalMapper->setMapping(banAction24h, 60 * 60 * 24);
         signalMapper->setMapping(banAction7d, 60 * 60 * 24 * 7);
         signalMapper->setMapping(banAction365d, 60 * 60 * 24 * 365);
         connect(banAction1h, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(banAction24h, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(banAction7d, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(banAction365d, &QAction::triggered, signalMapper,
                 static_cast<void (QSignalMapper::*)()>(&QSignalMapper::map));
         connect(
             signalMapper,
             static_cast<void (QSignalMapper::*)(int)>(&QSignalMapper::mapped),
             this, &RPCConsole::banSelectedNode);
 
         // peer table context menu signals
         connect(ui->peerWidget, &QTableView::customContextMenuRequested, this,
                 &RPCConsole::showPeersTableContextMenu);
         connect(disconnectAction, &QAction::triggered, this,
                 &RPCConsole::disconnectSelectedNode);
 
         // peer table signal handling - update peer details when selecting new
         // node
         connect(ui->peerWidget->selectionModel(),
                 &QItemSelectionModel::selectionChanged, this,
                 &RPCConsole::peerSelected);
         // peer table signal handling - update peer details when new nodes are
         // added to the model
         connect(model->getPeerTableModel(), &PeerTableModel::layoutChanged,
                 this, &RPCConsole::peerLayoutChanged);
         // peer table signal handling - cache selected node ids
         connect(model->getPeerTableModel(),
                 &PeerTableModel::layoutAboutToBeChanged, this,
                 &RPCConsole::peerLayoutAboutToChange);
 
         // set up ban table
         ui->banlistWidget->setModel(model->getBanTableModel());
         ui->banlistWidget->verticalHeader()->hide();
         ui->banlistWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
         ui->banlistWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
         ui->banlistWidget->setSelectionMode(QAbstractItemView::SingleSelection);
         ui->banlistWidget->setContextMenuPolicy(Qt::CustomContextMenu);
         ui->banlistWidget->setColumnWidth(BanTableModel::Address,
                                           BANSUBNET_COLUMN_WIDTH);
         ui->banlistWidget->setColumnWidth(BanTableModel::Bantime,
                                           BANTIME_COLUMN_WIDTH);
         ui->banlistWidget->horizontalHeader()->setStretchLastSection(true);
 
         // create ban table context menu action
         QAction *unbanAction = new QAction(tr("&Unban"), this);
 
         // create ban table context menu
         banTableContextMenu = new QMenu(this);
         banTableContextMenu->addAction(unbanAction);
 
         // ban table context menu signals
         connect(ui->banlistWidget, &QTableView::customContextMenuRequested,
                 this, &RPCConsole::showBanTableContextMenu);
         connect(unbanAction, &QAction::triggered, this,
                 &RPCConsole::unbanSelectedNode);
 
         // ban table signal handling - clear peer details when clicking a peer
         // in the ban table
         connect(ui->banlistWidget, &QTableView::clicked, this,
                 &RPCConsole::clearSelectedNode);
         // ban table signal handling - ensure ban table is shown or hidden (if
         // empty)
         connect(model->getBanTableModel(), &BanTableModel::layoutChanged, this,
                 &RPCConsole::showOrHideBanTableIfRequired);
         showOrHideBanTableIfRequired();
 
         // Provide initial values
         ui->clientVersion->setText(model->formatFullVersion());
         ui->clientUserAgent->setText(model->formatSubVersion());
         ui->dataDir->setText(model->dataDir());
         ui->blocksDir->setText(model->blocksDir());
         ui->startupTime->setText(model->formatClientStartupTime());
         ui->networkName->setText(
             QString::fromStdString(Params().NetworkIDString()));
 
         // Setup autocomplete and attach it
         QStringList wordList;
         std::vector<std::string> commandList = m_node.listRpcCommands();
         for (size_t i = 0; i < commandList.size(); ++i) {
             wordList << commandList[i].c_str();
             wordList << ("help " + commandList[i]).c_str();
         }
 
         wordList << "help-console";
         wordList.sort();
         autoCompleter = new QCompleter(wordList, this);
         autoCompleter->setModelSorting(QCompleter::CaseSensitivelySortedModel);
         ui->lineEdit->setCompleter(autoCompleter);
         autoCompleter->popup()->installEventFilter(this);
         // Start thread to execute RPC commands.
         startExecutor();
     }
     if (!model) {
         // Client model is being set to 0, this means shutdown() is about to be
         // called. Make sure we clean up the executor thread
         Q_EMIT stopExecutor();
         thread.wait();
     }
 }
 
 #ifdef ENABLE_WALLET
 void RPCConsole::addWallet(WalletModel *const walletModel) {
     // use name for text and wallet model for internal data object (to allow to
     // move to a wallet id later)
     ui->WalletSelector->addItem(walletModel->getDisplayName(),
                                 QVariant::fromValue(walletModel));
     if (ui->WalletSelector->count() == 2 && !isVisible()) {
         // First wallet added, set to default so long as the window isn't
         // presently visible (and potentially in use)
         ui->WalletSelector->setCurrentIndex(1);
     }
     if (ui->WalletSelector->count() > 2) {
         ui->WalletSelector->setVisible(true);
         ui->WalletSelectorLabel->setVisible(true);
     }
 }
 
 void RPCConsole::removeWallet(WalletModel *const walletModel) {
     ui->WalletSelector->removeItem(
         ui->WalletSelector->findData(QVariant::fromValue(walletModel)));
     if (ui->WalletSelector->count() == 2) {
         ui->WalletSelector->setVisible(false);
         ui->WalletSelectorLabel->setVisible(false);
     }
 }
 #endif
 
 static QString categoryClass(int category) {
     switch (category) {
         case RPCConsole::CMD_REQUEST:
             return "cmd-request";
             break;
         case RPCConsole::CMD_REPLY:
             return "cmd-reply";
             break;
         case RPCConsole::CMD_ERROR:
             return "cmd-error";
             break;
         default:
             return "misc";
     }
 }
 
 void RPCConsole::fontBigger() {
     setFontSize(consoleFontSize + 1);
 }
 
 void RPCConsole::fontSmaller() {
     setFontSize(consoleFontSize - 1);
 }
 
 void RPCConsole::setFontSize(int newSize) {
     QSettings settings;
 
     // don't allow an insane font size
     if (newSize < FONT_RANGE.width() || newSize > FONT_RANGE.height()) {
         return;
     }
 
     // temp. store the console content
     QString str = ui->messagesWidget->toHtml();
 
     // replace font tags size in current content
     str.replace(QString("font-size:%1pt").arg(consoleFontSize),
                 QString("font-size:%1pt").arg(newSize));
 
     // store the new font size
     consoleFontSize = newSize;
     settings.setValue(fontSizeSettingsKey, consoleFontSize);
 
     // clear console (reset icon sizes, default stylesheet) and re-add the
     // content
     float oldPosFactor = 1.0 /
                          ui->messagesWidget->verticalScrollBar()->maximum() *
                          ui->messagesWidget->verticalScrollBar()->value();
     clear(false);
     ui->messagesWidget->setHtml(str);
     ui->messagesWidget->verticalScrollBar()->setValue(
         oldPosFactor * ui->messagesWidget->verticalScrollBar()->maximum());
 }
 
 void RPCConsole::clear(bool clearHistory) {
     ui->messagesWidget->clear();
     if (clearHistory) {
         history.clear();
         historyPtr = 0;
     }
     ui->lineEdit->clear();
     ui->lineEdit->setFocus();
 
     // Add smoothly scaled icon images.
     // (when using width/height on an img, Qt uses nearest instead of linear
     // interpolation)
     for (int i = 0; ICON_MAPPING[i].url; ++i) {
         ui->messagesWidget->document()->addResource(
             QTextDocument::ImageResource, QUrl(ICON_MAPPING[i].url),
             platformStyle->SingleColorImage(ICON_MAPPING[i].source)
                 .scaled(QSize(consoleFontSize * 2, consoleFontSize * 2),
                         Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
     }
 
     // Set default style sheet
     QFontInfo fixedFontInfo(GUIUtil::fixedPitchFont());
     ui->messagesWidget->document()->setDefaultStyleSheet(
         QString("table { }"
                 "td.time { color: #808080; font-size: %2; padding-top: 3px; } "
                 "td.message { font-family: %1; font-size: %2; "
                 "white-space:pre-wrap; } "
                 "td.cmd-request { color: #006060; } "
                 "td.cmd-error { color: red; } "
                 ".secwarning { color: red; }"
                 "b { color: #006060; } ")
             .arg(fixedFontInfo.family(), QString("%1pt").arg(consoleFontSize)));
 
 #ifdef Q_OS_MAC
     QString clsKey = "(⌘)-L";
 #else
     QString clsKey = "Ctrl-L";
 #endif
 
     message(CMD_REPLY,
-            (tr("Welcome to the %1 RPC console.").arg(tr(PACKAGE_NAME)) +
-             "<br>" +
+            (tr("Welcome to the %1 RPC console.").arg(PACKAGE_NAME) + "<br>" +
              tr("Use up and down arrows to navigate history, and "
                 "%1 to clear screen.")
                  .arg("<b>" + clsKey + "</b>") +
              "<br>" +
              tr("Type %1 for an overview of available commands.")
                  .arg("<b>help</b>") +
              "<br>" +
              tr("For more information on using this console type %1.")
                  .arg("<b>help-console</b>") +
              "<br><span class=\"secwarning\"><br>" +
              tr("WARNING: Scammers have been active, telling users to type "
                 "commands here, stealing their wallet contents. Do not use "
                 "this console without fully understanding the ramifications "
                 "of a command.") +
              "</span>"),
             true);
 }
 
 void RPCConsole::keyPressEvent(QKeyEvent *event) {
     if (windowType() != Qt::Widget && event->key() == Qt::Key_Escape) {
         close();
     }
 }
 
 void RPCConsole::message(int category, const QString &message, bool html) {
     QTime time = QTime::currentTime();
     QString timeString = time.toString();
     QString out;
     out += "<table><tr><td class=\"time\" width=\"65\">" + timeString + "</td>";
     out += "<td class=\"icon\" width=\"32\"><img src=\"" +
            categoryClass(category) + "\"></td>";
     out += "<td class=\"message " + categoryClass(category) +
            "\" valign=\"middle\">";
     if (html) {
         out += message;
     } else {
         out += GUIUtil::HtmlEscape(message, false);
     }
     out += "</td></tr></table>";
     ui->messagesWidget->append(out);
 }
 
 void RPCConsole::updateNetworkState() {
     QString connections =
         QString::number(clientModel->getNumConnections()) + " (";
     connections += tr("In:") + " " +
                    QString::number(clientModel->getNumConnections(
                        ClientModel::CONNECTIONS_IN)) +
                    " / ";
     connections += tr("Out:") + " " +
                    QString::number(clientModel->getNumConnections(
                        ClientModel::CONNECTIONS_OUT)) +
                    ")";
 
     if (!clientModel->node().getNetworkActive()) {
         connections += " (" + tr("Network activity disabled") + ")";
     }
 
     ui->numberOfConnections->setText(connections);
 }
 
 void RPCConsole::setNumConnections(int count) {
     if (!clientModel) {
         return;
     }
 
     updateNetworkState();
 }
 
 void RPCConsole::setNetworkActive(bool networkActive) {
     updateNetworkState();
 }
 
 void RPCConsole::setNumBlocks(int count, const QDateTime &blockDate,
                               double nVerificationProgress, bool headers) {
     if (!headers) {
         ui->numberOfBlocks->setText(QString::number(count));
         ui->lastBlockTime->setText(blockDate.toString());
     }
 }
 
 void RPCConsole::setMempoolSize(long numberOfTxs, size_t dynUsage) {
     ui->mempoolNumberTxs->setText(QString::number(numberOfTxs));
 
     if (dynUsage < 1000000) {
         ui->mempoolSize->setText(QString::number(dynUsage / 1000.0, 'f', 2) +
                                  " KB");
     } else {
         ui->mempoolSize->setText(QString::number(dynUsage / 1000000.0, 'f', 2) +
                                  " MB");
     }
 }
 
 void RPCConsole::on_lineEdit_returnPressed() {
     QString cmd = ui->lineEdit->text();
 
     if (!cmd.isEmpty()) {
         std::string strFilteredCmd;
         try {
             std::string dummy;
             if (!RPCParseCommandLine(nullptr, dummy, cmd.toStdString(), false,
                                      &strFilteredCmd)) {
                 // Failed to parse command, so we cannot even filter it for the
                 // history
                 throw std::runtime_error("Invalid command line");
             }
         } catch (const std::exception &e) {
             QMessageBox::critical(this, "Error",
                                   QString("Error: ") +
                                       QString::fromStdString(e.what()));
             return;
         }
 
         ui->lineEdit->clear();
 
         cmdBeforeBrowsing = QString();
 
 #ifdef ENABLE_WALLET
         WalletModel *wallet_model{nullptr};
         const int wallet_index = ui->WalletSelector->currentIndex();
         if (wallet_index > 0) {
             wallet_model = ui->WalletSelector->itemData(wallet_index)
                                .value<WalletModel *>();
         }
 
         if (m_last_wallet_model != wallet_model) {
             if (wallet_model) {
                 message(CMD_REQUEST, tr("Executing command using \"%1\" wallet")
                                          .arg(wallet_model->getWalletName()));
             } else {
                 message(CMD_REQUEST,
                         tr("Executing command without any wallet"));
             }
             m_last_wallet_model = wallet_model;
         }
 #endif
 
         message(CMD_REQUEST, QString::fromStdString(strFilteredCmd));
         Q_EMIT cmdRequest(cmd, m_last_wallet_model);
 
         cmd = QString::fromStdString(strFilteredCmd);
 
         // Remove command, if already in history
         history.removeOne(cmd);
         // Append command to history
         history.append(cmd);
         // Enforce maximum history size
         while (history.size() > CONSOLE_HISTORY) {
             history.removeFirst();
         }
         // Set pointer to end of history
         historyPtr = history.size();
 
         // Scroll console view to end
         scrollToEnd();
     }
 }
 
 void RPCConsole::browseHistory(int offset) {
     // store current text when start browsing through the history
     if (historyPtr == history.size()) {
         cmdBeforeBrowsing = ui->lineEdit->text();
     }
 
     historyPtr += offset;
     if (historyPtr < 0) {
         historyPtr = 0;
     }
     if (historyPtr > history.size()) {
         historyPtr = history.size();
     }
     QString cmd;
     if (historyPtr < history.size()) {
         cmd = history.at(historyPtr);
     } else if (!cmdBeforeBrowsing.isNull()) {
         cmd = cmdBeforeBrowsing;
     }
     ui->lineEdit->setText(cmd);
 }
 
 void RPCConsole::startExecutor() {
     RPCExecutor *executor = new RPCExecutor(m_node);
     executor->moveToThread(&thread);
 
     // Replies from executor object must go to this object
     connect(executor, &RPCExecutor::reply, this,
             static_cast<void (RPCConsole::*)(int, const QString &)>(
                 &RPCConsole::message));
 
     // Requests from this object must go to executor
     connect(this, &RPCConsole::cmdRequest, executor, &RPCExecutor::request);
 
     // On stopExecutor signal
     // - quit the Qt event loop in the execution thread
     connect(this, &RPCConsole::stopExecutor, &thread, &QThread::quit);
     // - queue executor for deletion (in execution thread)
     connect(&thread, &QThread::finished, executor, &RPCExecutor::deleteLater,
             Qt::DirectConnection);
 
     // Default implementation of QThread::run() simply spins up an event loop in
     // the thread, which is what we want.
     thread.start();
 }
 
 void RPCConsole::on_tabWidget_currentChanged(int index) {
     if (ui->tabWidget->widget(index) == ui->tab_console) {
         ui->lineEdit->setFocus();
     } else if (ui->tabWidget->widget(index) != ui->tab_peers) {
         clearSelectedNode();
     }
 }
 
 void RPCConsole::on_openDebugLogfileButton_clicked() {
     GUIUtil::openDebugLogfile();
 }
 
 void RPCConsole::scrollToEnd() {
     QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
     scrollbar->setValue(scrollbar->maximum());
 }
 
 void RPCConsole::on_sldGraphRange_valueChanged(int value) {
     const int multiplier = 5; // each position on the slider represents 5 min
     int mins = value * multiplier;
     setTrafficGraphRange(mins);
 }
 
 void RPCConsole::setTrafficGraphRange(int mins) {
     ui->trafficGraph->setGraphRangeMins(mins);
     ui->lblGraphRange->setText(GUIUtil::formatDurationStr(mins * 60));
 }
 
 void RPCConsole::updateTrafficStats(quint64 totalBytesIn,
                                     quint64 totalBytesOut) {
     ui->lblBytesIn->setText(GUIUtil::formatBytes(totalBytesIn));
     ui->lblBytesOut->setText(GUIUtil::formatBytes(totalBytesOut));
 }
 
 void RPCConsole::peerSelected(const QItemSelection &selected,
                               const QItemSelection &deselected) {
     Q_UNUSED(deselected);
 
     if (!clientModel || !clientModel->getPeerTableModel() ||
         selected.indexes().isEmpty()) {
         return;
     }
 
     const CNodeCombinedStats *stats =
         clientModel->getPeerTableModel()->getNodeStats(
             selected.indexes().first().row());
     if (stats) {
         updateNodeDetail(stats);
     }
 }
 
 void RPCConsole::peerLayoutAboutToChange() {
     QModelIndexList selected =
         ui->peerWidget->selectionModel()->selectedIndexes();
     cachedNodeids.clear();
     for (int i = 0; i < selected.size(); i++) {
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(
                 selected.at(i).row());
         cachedNodeids.append(stats->nodeStats.nodeid);
     }
 }
 
 void RPCConsole::peerLayoutChanged() {
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     const CNodeCombinedStats *stats = nullptr;
     bool fUnselect = false;
     bool fReselect = false;
 
     // no node selected yet
     if (cachedNodeids.empty()) {
         return;
     }
 
     // find the currently selected row
     int selectedRow = -1;
     QModelIndexList selectedModelIndex =
         ui->peerWidget->selectionModel()->selectedIndexes();
     if (!selectedModelIndex.isEmpty()) {
         selectedRow = selectedModelIndex.first().row();
     }
 
     // check if our detail node has a row in the table (it may not necessarily
     // be at selectedRow since its position can change after a layout change)
     int detailNodeRow =
         clientModel->getPeerTableModel()->getRowByNodeId(cachedNodeids.first());
 
     if (detailNodeRow < 0) {
         // detail node disappeared from table (node disconnected)
         fUnselect = true;
     } else {
         if (detailNodeRow != selectedRow) {
             // detail node moved position
             fUnselect = true;
             fReselect = true;
         }
 
         // get fresh stats on the detail node.
         stats = clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
     }
 
     if (fUnselect && selectedRow >= 0) {
         clearSelectedNode();
     }
 
     if (fReselect) {
         for (int i = 0; i < cachedNodeids.size(); i++) {
             ui->peerWidget->selectRow(
                 clientModel->getPeerTableModel()->getRowByNodeId(
                     cachedNodeids.at(i)));
         }
     }
 
     if (stats) {
         updateNodeDetail(stats);
     }
 }
 
 void RPCConsole::updateNodeDetail(const CNodeCombinedStats *stats) {
     // update the detail ui with latest node information
     QString peerAddrDetails(QString::fromStdString(stats->nodeStats.addrName) +
                             " ");
     peerAddrDetails +=
         tr("(node id: %1)").arg(QString::number(stats->nodeStats.nodeid));
     if (!stats->nodeStats.addrLocal.empty()) {
         peerAddrDetails += "<br />" + tr("via %1").arg(QString::fromStdString(
                                           stats->nodeStats.addrLocal));
     }
     ui->peerHeading->setText(peerAddrDetails);
     ui->peerServices->setText(
         GUIUtil::formatServicesStr(stats->nodeStats.nServices));
     ui->peerLastSend->setText(
         stats->nodeStats.nLastSend
             ? GUIUtil::formatDurationStr(GetSystemTimeInSeconds() -
                                          stats->nodeStats.nLastSend)
             : tr("never"));
     ui->peerLastRecv->setText(
         stats->nodeStats.nLastRecv
             ? GUIUtil::formatDurationStr(GetSystemTimeInSeconds() -
                                          stats->nodeStats.nLastRecv)
             : tr("never"));
     ui->peerBytesSent->setText(
         GUIUtil::formatBytes(stats->nodeStats.nSendBytes));
     ui->peerBytesRecv->setText(
         GUIUtil::formatBytes(stats->nodeStats.nRecvBytes));
     ui->peerConnTime->setText(GUIUtil::formatDurationStr(
         GetSystemTimeInSeconds() - stats->nodeStats.nTimeConnected));
     ui->peerPingTime->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dPingTime));
     ui->peerPingWait->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dPingWait));
     ui->peerMinPing->setText(
         GUIUtil::formatPingTime(stats->nodeStats.dMinPing));
     ui->timeoffset->setText(
         GUIUtil::formatTimeOffset(stats->nodeStats.nTimeOffset));
     ui->peerVersion->setText(
         QString("%1").arg(QString::number(stats->nodeStats.nVersion)));
     ui->peerSubversion->setText(
         QString::fromStdString(stats->nodeStats.cleanSubVer));
     ui->peerDirection->setText(stats->nodeStats.fInbound ? tr("Inbound")
                                                          : tr("Outbound"));
     ui->peerHeight->setText(
         QString("%1").arg(QString::number(stats->nodeStats.nStartingHeight)));
     ui->peerWhitelisted->setText(stats->nodeStats.fWhitelisted ? tr("Yes")
                                                                : tr("No"));
 
     // This check fails for example if the lock was busy and
     // nodeStateStats couldn't be fetched.
     if (stats->fNodeStateStatsAvailable) {
         // Ban score is init to 0
         ui->peerBanScore->setText(
             QString("%1").arg(stats->nodeStateStats.nMisbehavior));
 
         // Sync height is init to -1
         if (stats->nodeStateStats.nSyncHeight > -1) {
             ui->peerSyncHeight->setText(
                 QString("%1").arg(stats->nodeStateStats.nSyncHeight));
         } else {
             ui->peerSyncHeight->setText(tr("Unknown"));
         }
 
         // Common height is init to -1
         if (stats->nodeStateStats.nCommonHeight > -1) {
             ui->peerCommonHeight->setText(
                 QString("%1").arg(stats->nodeStateStats.nCommonHeight));
         } else {
             ui->peerCommonHeight->setText(tr("Unknown"));
         }
     }
 
     ui->detailWidget->show();
 }
 
 void RPCConsole::resizeEvent(QResizeEvent *event) {
     QWidget::resizeEvent(event);
 }
 
 void RPCConsole::showEvent(QShowEvent *event) {
     QWidget::showEvent(event);
 
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     // start PeerTableModel auto refresh
     clientModel->getPeerTableModel()->startAutoRefresh();
 }
 
 void RPCConsole::hideEvent(QHideEvent *event) {
     QWidget::hideEvent(event);
 
     if (!clientModel || !clientModel->getPeerTableModel()) {
         return;
     }
 
     // stop PeerTableModel auto refresh
     clientModel->getPeerTableModel()->stopAutoRefresh();
 }
 
 void RPCConsole::showPeersTableContextMenu(const QPoint &point) {
     QModelIndex index = ui->peerWidget->indexAt(point);
     if (index.isValid()) {
         peersTableContextMenu->exec(QCursor::pos());
     }
 }
 
 void RPCConsole::showBanTableContextMenu(const QPoint &point) {
     QModelIndex index = ui->banlistWidget->indexAt(point);
     if (index.isValid()) {
         banTableContextMenu->exec(QCursor::pos());
     }
 }
 
 void RPCConsole::disconnectSelectedNode() {
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
         // Find the node, disconnect it and clear the selected node
         if (m_node.disconnect(id)) {
             clearSelectedNode();
         }
     }
 }
 
 void RPCConsole::banSelectedNode(int bantime) {
     if (!clientModel) {
         return;
     }
 
     // Get selected peer addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected peer address
         NodeId id = nodes.at(i).data().toLongLong();
 
         // Get currently selected peer address
         int detailNodeRow =
             clientModel->getPeerTableModel()->getRowByNodeId(id);
         if (detailNodeRow < 0) {
             return;
         }
 
         // Find possible nodes, ban it and clear the selected node
         const CNodeCombinedStats *stats =
             clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
         if (stats) {
             m_node.ban(stats->nodeStats.addr, BanReasonManuallyAdded, bantime);
             m_node.disconnect(stats->nodeStats.addr);
         }
     }
     clearSelectedNode();
     clientModel->getBanTableModel()->refresh();
 }
 
 void RPCConsole::unbanSelectedNode() {
     if (!clientModel) {
         return;
     }
 
     // Get selected ban addresses
     QList<QModelIndex> nodes =
         GUIUtil::getEntryData(ui->banlistWidget, BanTableModel::Address);
     for (int i = 0; i < nodes.count(); i++) {
         // Get currently selected ban address
         QString strNode = nodes.at(i).data().toString();
         CSubNet possibleSubnet;
 
         LookupSubNet(strNode.toStdString().c_str(), possibleSubnet);
         if (possibleSubnet.IsValid() && m_node.unban(possibleSubnet)) {
             clientModel->getBanTableModel()->refresh();
         }
     }
 }
 
 void RPCConsole::clearSelectedNode() {
     ui->peerWidget->selectionModel()->clearSelection();
     cachedNodeids.clear();
     ui->detailWidget->hide();
     ui->peerHeading->setText(tr("Select a peer to view detailed information."));
 }
 
 void RPCConsole::showOrHideBanTableIfRequired() {
     if (!clientModel) {
         return;
     }
 
     bool visible = clientModel->getBanTableModel()->shouldShow();
     ui->banlistWidget->setVisible(visible);
     ui->banHeading->setVisible(visible);
 }
 
 void RPCConsole::setTabFocus(enum TabTypes tabType) {
     ui->tabWidget->setCurrentIndex(tabType);
 }
diff --git a/src/qt/splashscreen.cpp b/src/qt/splashscreen.cpp
index 56aafb612..36c85b230 100644
--- a/src/qt/splashscreen.cpp
+++ b/src/qt/splashscreen.cpp
@@ -1,251 +1,251 @@
 // 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/splashscreen.h>
 
 #include <clientversion.h>
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <interfaces/wallet.h>
 #include <qt/guiutil.h>
 #include <qt/networkstyle.h>
 #include <ui_interface.h>
 #include <util/system.h>
 #include <version.h>
 
 #include <QApplication>
 #include <QCloseEvent>
 #include <QPainter>
 #include <QRadialGradient>
 #include <QScreen>
 
 #include <memory>
 
 SplashScreen::SplashScreen(interfaces::Node &node, Qt::WindowFlags f,
                            const NetworkStyle *networkStyle)
     : QWidget(nullptr, f), curAlignment(0), m_node(node) {
     // set reference point, paddings
     int paddingRight = 50;
     int paddingTop = 50;
     int titleVersionVSpace = 17;
     int titleCopyrightVSpace = 40;
 
     float fontFactor = 1.0;
     float devicePixelRatio = 1.0;
 #if QT_VERSION > 0x050100
     devicePixelRatio =
         static_cast<QGuiApplication *>(QCoreApplication::instance())
             ->devicePixelRatio();
 #endif
 
     // define text to place
-    QString titleText = tr(PACKAGE_NAME);
+    QString titleText = PACKAGE_NAME;
     QString versionText =
         QString("Version %1").arg(QString::fromStdString(FormatFullVersion()));
     QString copyrightText = QString::fromUtf8(
         CopyrightHolders(strprintf("\xc2\xA9 %u-%u ", 2009, COPYRIGHT_YEAR))
             .c_str());
     QString titleAddText = networkStyle->getTitleAddText();
 
     QString font = QApplication::font().toString();
 
     // create a bitmap according to device pixelratio
     QSize splashSize(634 * devicePixelRatio, 320 * devicePixelRatio);
     pixmap = QPixmap(splashSize);
 
 #if QT_VERSION > 0x050100
     // change to HiDPI if it makes sense
     pixmap.setDevicePixelRatio(devicePixelRatio);
 #endif
 
     QPainter pixPaint(&pixmap);
     pixPaint.setPen(QColor(100, 100, 100));
 
     // draw a slightly radial gradient
     QRadialGradient gradient(QPoint(0, 0),
                              splashSize.width() / devicePixelRatio);
     gradient.setColorAt(0, Qt::white);
     gradient.setColorAt(1, QColor(247, 247, 247));
     QRect rGradient(QPoint(0, 0), splashSize);
     pixPaint.fillRect(rGradient, gradient);
 
     // draw the bitcoin icon, expected size of PNG: 1024x1024
     QRect rectIcon(QPoint(-10, -100), QSize(430, 430));
 
     const QSize requiredSize(1024, 1024);
     QPixmap icon(networkStyle->getAppIcon().pixmap(requiredSize));
 
     pixPaint.drawPixmap(rectIcon, icon);
 
     // check font size and drawing with
     pixPaint.setFont(QFont(font, 33 * fontFactor));
     QFontMetrics fm = pixPaint.fontMetrics();
     int titleTextWidth = GUIUtil::TextWidth(fm, titleText);
     if (titleTextWidth > 176) {
         fontFactor = fontFactor * 176 / titleTextWidth;
     }
 
     pixPaint.setFont(QFont(font, 33 * fontFactor));
     fm = pixPaint.fontMetrics();
     titleTextWidth = GUIUtil::TextWidth(fm, titleText);
     pixPaint.drawText(pixmap.width() / devicePixelRatio - titleTextWidth -
                           paddingRight,
                       paddingTop, titleText);
 
     pixPaint.setFont(QFont(font, 15 * fontFactor));
 
     // if the version string is too long, reduce size
     fm = pixPaint.fontMetrics();
     int versionTextWidth = GUIUtil::TextWidth(fm, titleText);
     if (versionTextWidth > titleTextWidth + paddingRight - 10) {
         pixPaint.setFont(QFont(font, 10 * fontFactor));
         titleVersionVSpace -= 5;
     }
     pixPaint.drawText(pixmap.width() / devicePixelRatio - titleTextWidth -
                           paddingRight + 2,
                       paddingTop + titleVersionVSpace, versionText);
 
     // draw copyright stuff
     {
         pixPaint.setFont(QFont(font, 10 * fontFactor));
         const int x =
             pixmap.width() / devicePixelRatio - titleTextWidth - paddingRight;
         const int y = paddingTop + titleCopyrightVSpace;
         QRect copyrightRect(x, y, pixmap.width() - x - paddingRight,
                             pixmap.height() - y);
         pixPaint.drawText(copyrightRect,
                           Qt::AlignLeft | Qt::AlignTop | Qt::TextWordWrap,
                           copyrightText);
     }
 
     // draw additional text if special network
     if (!titleAddText.isEmpty()) {
         QFont boldFont = QFont(font, 10 * fontFactor);
         boldFont.setWeight(QFont::Bold);
         pixPaint.setFont(boldFont);
         fm = pixPaint.fontMetrics();
         int titleAddTextWidth = GUIUtil::TextWidth(fm, titleAddText);
         pixPaint.drawText(pixmap.width() / devicePixelRatio -
                               titleAddTextWidth - 10,
                           15, titleAddText);
     }
 
     pixPaint.end();
 
     // Set window title
     setWindowTitle(titleText + " " + titleAddText);
 
     // Resize window and move to center of desktop, disallow resizing
     QRect r(QPoint(), QSize(pixmap.size().width() / devicePixelRatio,
                             pixmap.size().height() / devicePixelRatio));
     resize(r.size());
     setFixedSize(r.size());
     move(QGuiApplication::primaryScreen()->geometry().center() - r.center());
 
     subscribeToCoreSignals();
     installEventFilter(this);
 }
 
 SplashScreen::~SplashScreen() {
     unsubscribeFromCoreSignals();
 }
 
 bool SplashScreen::eventFilter(QObject *obj, QEvent *ev) {
     if (ev->type() == QEvent::KeyPress) {
         QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
         if (keyEvent->text()[0] == 'q') {
             m_node.startShutdown();
         }
     }
     return QObject::eventFilter(obj, ev);
 }
 
 void SplashScreen::slotFinish(QWidget *mainWin) {
     Q_UNUSED(mainWin);
 
     /* If the window is minimized, hide() will be ignored. */
     /* Make sure we de-minimize the splashscreen window before hiding */
     if (isMinimized()) {
         showNormal();
     }
     hide();
     // No more need for this
     deleteLater();
 }
 
 static void InitMessage(SplashScreen *splash, const std::string &message) {
     QMetaObject::invokeMethod(splash, "showMessage", Qt::QueuedConnection,
                               Q_ARG(QString, QString::fromStdString(message)),
                               Q_ARG(int, Qt::AlignBottom | Qt::AlignHCenter),
                               Q_ARG(QColor, QColor(55, 55, 55)));
 }
 
 static void ShowProgress(SplashScreen *splash, const std::string &title,
                          int nProgress, bool resume_possible) {
     InitMessage(splash, title + std::string("\n") +
                             (resume_possible
                                  ? _("(press q to shutdown and continue later)")
                                  : _("press q to shutdown")) +
                             strprintf("\n%d", nProgress) + "%");
 }
 #ifdef ENABLE_WALLET
 void SplashScreen::ConnectWallet(std::unique_ptr<interfaces::Wallet> wallet) {
     m_connected_wallet_handlers.emplace_back(wallet->handleShowProgress(
         std::bind(ShowProgress, this, std::placeholders::_1,
                   std::placeholders::_2, false)));
     m_connected_wallets.emplace_back(std::move(wallet));
 }
 #endif
 
 void SplashScreen::subscribeToCoreSignals() {
     // Connect signals to client
     m_handler_init_message = m_node.handleInitMessage(
         std::bind(InitMessage, this, std::placeholders::_1));
     m_handler_show_progress = m_node.handleShowProgress(
         std::bind(ShowProgress, this, std::placeholders::_1,
                   std::placeholders::_2, std::placeholders::_3));
 #ifdef ENABLE_WALLET
     m_handler_load_wallet = m_node.handleLoadWallet(
         [this](std::unique_ptr<interfaces::Wallet> wallet) {
             ConnectWallet(std::move(wallet));
         });
 #endif
 }
 
 void SplashScreen::unsubscribeFromCoreSignals() {
     // Disconnect signals from client
     m_handler_init_message->disconnect();
     m_handler_show_progress->disconnect();
     for (const auto &handler : m_connected_wallet_handlers) {
         handler->disconnect();
     }
     m_connected_wallet_handlers.clear();
     m_connected_wallets.clear();
 }
 
 void SplashScreen::showMessage(const QString &message, int alignment,
                                const QColor &color) {
     curMessage = message;
     curAlignment = alignment;
     curColor = color;
     update();
 }
 
 void SplashScreen::paintEvent(QPaintEvent *event) {
     QPainter painter(this);
     painter.drawPixmap(0, 0, pixmap);
     QRect r = rect().adjusted(5, 5, -5, -5);
     painter.setPen(curColor);
     painter.drawText(r, curAlignment, curMessage);
 }
 
 void SplashScreen::closeEvent(QCloseEvent *event) {
     // allows an "emergency" shutdown during startup
     m_node.startShutdown();
     event->ignore();
 }
diff --git a/src/qt/utilitydialog.cpp b/src/qt/utilitydialog.cpp
index 7dabc23e4..8957d0af7 100644
--- a/src/qt/utilitydialog.cpp
+++ b/src/qt/utilitydialog.cpp
@@ -1,177 +1,177 @@
 // 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/utilitydialog.h>
 
 #include <clientversion.h>
 #include <init.h>
 #include <interfaces/node.h>
 #include <qt/bitcoingui.h>
 #include <qt/clientmodel.h>
 #include <qt/forms/ui_helpmessagedialog.h>
 #include <qt/guiconstants.h>
 #include <qt/guiutil.h>
 #include <qt/intro.h>
 #ifdef ENABLE_BIP70
 #include <qt/paymentrequestplus.h>
 #endif
 #include <util/system.h>
 
 #include <QCloseEvent>
 #include <QLabel>
 #include <QRegExp>
 #include <QTextCursor>
 #include <QTextTable>
 #include <QVBoxLayout>
 
 #include <cstdio>
 
 /** "Help message" or "About" dialog box */
 HelpMessageDialog::HelpMessageDialog(interfaces::Node &node, QWidget *parent,
                                      bool about)
     : QDialog(parent), ui(new Ui::HelpMessageDialog) {
     ui->setupUi(this);
 
-    QString version = tr(PACKAGE_NAME) + " " + tr("version") + " " +
+    QString version = QString{PACKAGE_NAME} + " " + tr("version") + " " +
                       QString::fromStdString(FormatFullVersion());
 /**
  * On x86 add a bit specifier to the version so that users can distinguish
  * between 32 and 64 bit builds. On other architectures, 32/64 bit may be more
  * ambiguous.
  */
 #if defined(__x86_64__)
     version += " " + tr("(%1-bit)").arg(64);
 #elif defined(__i386__)
     version += " " + tr("(%1-bit)").arg(32);
 #endif
 
     if (about) {
-        setWindowTitle(tr("About %1").arg(tr(PACKAGE_NAME)));
+        setWindowTitle(tr("About %1").arg(PACKAGE_NAME));
 
         /// HTML-format the license message from the core
         QString licenseInfo = QString::fromStdString(LicenseInfo());
         QString licenseInfoHTML = licenseInfo;
         // Make URLs clickable
         QRegExp uri("<(.*)>", Qt::CaseSensitive, QRegExp::RegExp2);
         uri.setMinimal(true); // use non-greedy matching
         licenseInfoHTML.replace(uri, "<a href=\"\\1\">\\1</a>");
         // Replace newlines with HTML breaks
         licenseInfoHTML.replace("\n", "<br>");
 
         ui->aboutMessage->setTextFormat(Qt::RichText);
         ui->scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
         text = version + "\n" + licenseInfo;
         ui->aboutMessage->setText(version + "<br><br>" + licenseInfoHTML);
         ui->aboutMessage->setWordWrap(true);
         ui->helpMessage->setVisible(false);
     } else {
         setWindowTitle(tr("Command-line options"));
         QString header =
             "Usage:  bitcoin-qt [command-line options]                     \n";
         QTextCursor cursor(ui->helpMessage->document());
         cursor.insertText(version);
         cursor.insertBlock();
         cursor.insertText(header);
         cursor.insertBlock();
 
         std::string strUsage = gArgs.GetHelpMessage();
         QString coreOptions = QString::fromStdString(strUsage);
         text = version + "\n\n" + header + "\n" + coreOptions;
 
         QTextTableFormat tf;
         tf.setBorderStyle(QTextFrameFormat::BorderStyle_None);
         tf.setCellPadding(2);
         QVector<QTextLength> widths;
         widths << QTextLength(QTextLength::PercentageLength, 35);
         widths << QTextLength(QTextLength::PercentageLength, 65);
         tf.setColumnWidthConstraints(widths);
 
         QTextCharFormat bold;
         bold.setFontWeight(QFont::Bold);
 
         for (const QString &line : coreOptions.split("\n")) {
             if (line.startsWith("  -")) {
                 cursor.currentTable()->appendRows(1);
                 cursor.movePosition(QTextCursor::PreviousCell);
                 cursor.movePosition(QTextCursor::NextRow);
                 cursor.insertText(line.trimmed());
                 cursor.movePosition(QTextCursor::NextCell);
             } else if (line.startsWith("   ")) {
                 cursor.insertText(line.trimmed() + ' ');
             } else if (line.size() > 0) {
                 // Title of a group
                 if (cursor.currentTable()) {
                     cursor.currentTable()->appendRows(1);
                 }
                 cursor.movePosition(QTextCursor::Down);
                 cursor.insertText(line.trimmed(), bold);
                 cursor.insertTable(1, 2, tf);
             }
         }
 
         ui->helpMessage->moveCursor(QTextCursor::Start);
         ui->scrollArea->setVisible(false);
         ui->aboutLogo->setVisible(false);
     }
 }
 
 HelpMessageDialog::~HelpMessageDialog() {
     delete ui;
 }
 
 void HelpMessageDialog::printToConsole() {
     // On other operating systems, the expected action is to print the message
     // to the console.
     tfm::format(std::cout, "%s\n", qPrintable(text));
 }
 
 void HelpMessageDialog::showOrPrint() {
 #if defined(WIN32)
     // On Windows, show a message box, as there is no stderr/stdout in windowed
     // applications
     exec();
 #else
     // On other operating systems, print help text to console
     printToConsole();
 #endif
 }
 
 void HelpMessageDialog::on_okButton_accepted() {
     close();
 }
 
 /** "Shutdown" window */
 ShutdownWindow::ShutdownWindow(QWidget *parent, Qt::WindowFlags f)
     : QWidget(parent, f) {
     QVBoxLayout *layout = new QVBoxLayout();
     layout->addWidget(new QLabel(
-        tr("%1 is shutting down...").arg(tr(PACKAGE_NAME)) + "<br /><br />" +
+        tr("%1 is shutting down...").arg(PACKAGE_NAME) + "<br /><br />" +
         tr("Do not shut down the computer until this window disappears.")));
     setLayout(layout);
 }
 
 QWidget *ShutdownWindow::showShutdownWindow(BitcoinGUI *window) {
     if (!window) {
         return nullptr;
     }
 
     // Show a simple window indicating shutdown status
     QWidget *shutdownWindow = new ShutdownWindow();
     shutdownWindow->setWindowTitle(window->windowTitle());
 
     // Center shutdown window at where main window was
     const QPoint global = window->mapToGlobal(window->rect().center());
     shutdownWindow->move(global.x() - shutdownWindow->width() / 2,
                          global.y() - shutdownWindow->height() / 2);
     shutdownWindow->show();
     return shutdownWindow;
 }
 
 void ShutdownWindow::closeEvent(QCloseEvent *event) {
     event->ignore();
 }
diff --git a/src/timedata.cpp b/src/timedata.cpp
index 2a78fcaa6..d340dccc5 100644
--- a/src/timedata.cpp
+++ b/src/timedata.cpp
@@ -1,125 +1,125 @@
 // Copyright (c) 2014-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 <timedata.h>
 
 #include <netaddress.h>
 #include <sync.h>
 #include <ui_interface.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <warnings.h>
 
 static CCriticalSection cs_nTimeOffset;
 static int64_t nTimeOffset = 0;
 
 /**
  * "Never go to sea with two chronometers; take one or three."
  * Our three time sources are:
  *  - System clock
  *  - Median of other nodes clocks
  *  - The user (asking the user to fix the system clock if the first two
  * disagree)
  */
 int64_t GetTimeOffset() {
     LOCK(cs_nTimeOffset);
     return nTimeOffset;
 }
 
 int64_t GetAdjustedTime() {
     return GetTime() + GetTimeOffset();
 }
 
 static int64_t abs64(int64_t n) {
     return (n >= 0 ? n : -n);
 }
 
 #define BITCOIN_TIMEDATA_MAX_SAMPLES 200
 
 void AddTimeData(const CNetAddr &ip, int64_t nOffsetSample) {
     LOCK(cs_nTimeOffset);
     // Ignore duplicates
     static std::set<CNetAddr> setKnown;
     if (setKnown.size() == BITCOIN_TIMEDATA_MAX_SAMPLES) {
         return;
     }
     if (!setKnown.insert(ip).second) {
         return;
     }
 
     // Add data
     static CMedianFilter<int64_t> vTimeOffsets(BITCOIN_TIMEDATA_MAX_SAMPLES, 0);
     vTimeOffsets.input(nOffsetSample);
     LogPrint(BCLog::NET,
              "added time data, samples %d, offset %+d (%+d minutes)\n",
              vTimeOffsets.size(), nOffsetSample, nOffsetSample / 60);
 
     // There is a known issue here (see issue #4521):
     //
     // - The structure vTimeOffsets contains up to 200 elements, after which any
     // new element added to it will not increase its size, replacing the oldest
     // element.
     //
     // - The condition to update nTimeOffset includes checking whether the
     // number of elements in vTimeOffsets is odd, which will never happen after
     // there are 200 elements.
     //
     // But in this case the 'bug' is protective against some attacks, and may
     // actually explain why we've never seen attacks which manipulate the clock
     // offset.
     //
     // So we should hold off on fixing this and clean it up as part of a timing
     // cleanup that strengthens it in a number of other ways.
     //
     if (vTimeOffsets.size() >= 5 && vTimeOffsets.size() % 2 == 1) {
         int64_t nMedian = vTimeOffsets.median();
         std::vector<int64_t> vSorted = vTimeOffsets.sorted();
         // Only let other nodes change our time by so much
         if (abs64(nMedian) <=
             std::max<int64_t>(0, gArgs.GetArg("-maxtimeadjustment",
                                               DEFAULT_MAX_TIME_ADJUSTMENT))) {
             nTimeOffset = nMedian;
         } else {
             nTimeOffset = 0;
 
             static bool fDone;
             if (!fDone) {
                 // If nobody has a time different than ours but within 5 minutes
                 // of ours, give a warning
                 bool fMatch = false;
                 for (const int64_t nOffset : vSorted) {
                     if (nOffset != 0 && abs64(nOffset) < 5 * 60) {
                         fMatch = true;
                     }
                 }
 
                 if (!fMatch) {
                     fDone = true;
                     std::string strMessage =
                         strprintf(_("Please check that your computer's date "
                                     "and time are correct! If your clock is "
                                     "wrong, %s will not work properly."),
-                                  _(PACKAGE_NAME));
+                                  PACKAGE_NAME);
                     SetMiscWarning(strMessage);
                     uiInterface.ThreadSafeMessageBox(
                         strMessage, "", CClientUIInterface::MSG_WARNING);
                 }
             }
         }
 
         if (LogAcceptCategory(BCLog::NET)) {
             for (const int64_t n : vSorted) {
                 LogPrintToBeContinued(BCLog::NET, "%+d  ", n);
             }
 
             LogPrintToBeContinued(BCLog::NET, "|  ");
             LogPrint(BCLog::NET, "nTimeOffset = %+d  (%+d minutes)\n",
                      nTimeOffset, nTimeOffset / 60);
         }
     }
 }
diff --git a/src/util/system.cpp b/src/util/system.cpp
index c670051ce..321e85045 100644
--- a/src/util/system.cpp
+++ b/src/util/system.cpp
@@ -1,1399 +1,1399 @@
 // 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 <fs.h>
 #include <util/system.h>
 
 #include <chainparamsbase.h>
 #include <fs.h>
 #include <random.h>
 #include <serialize.h>
 #include <util/strencodings.h>
 #include <util/time.h>
 
 #include <boost/thread.hpp>
 
 #include <cstdarg>
 #include <memory>
 
 #if (defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__))
 #include <pthread.h>
 #include <pthread_np.h>
 #endif
 
 #ifndef WIN32
 // for posix_fallocate
 #ifdef __linux__
 
 #ifdef _POSIX_C_SOURCE
 #undef _POSIX_C_SOURCE
 #endif
 
 #define _POSIX_C_SOURCE 200112L
 
 #endif // __linux__
 
 #include <algorithm>
 #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
 
 #ifdef _WIN32_WINNT
 #undef _WIN32_WINNT
 #endif
 #define _WIN32_WINNT 0x0501
 
 #ifdef _WIN32_IE
 #undef _WIN32_IE
 #endif
 #define _WIN32_IE 0x0501
 
 #define WIN32_LEAN_AND_MEAN 1
 #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";
 
 ArgsManager gArgs;
 
 /**
  * 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;
 /** Mutex to protect dir_locks. */
 static std::mutex cs_dir_locks;
 
 bool LockDirectory(const fs::path &directory, const std::string lockfile_name,
                    bool probe_only) {
     std::lock_guard<std::mutex> ulock(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(pathLockFile.string())) {
         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",
                      directory.string(), lock->GetReason());
     }
     if (!probe_only) {
         // Lock successful and we're not just probing, put it into the map
         dir_locks.emplace(pathLockFile.string(), std::move(lock));
     }
     return true;
 }
 
 void UnlockDirectory(const fs::path &directory,
                      const std::string &lockfile_name) {
     std::lock_guard<std::mutex> lock(cs_dir_locks);
     dir_locks.erase((directory / lockfile_name).string());
 }
 
 void ReleaseDirectoryLocks() {
     std::lock_guard<std::mutex> ulock(cs_dir_locks);
     dir_locks.clear();
 }
 
 bool DirIsWritable(const fs::path &directory) {
     fs::path tmpFile = directory / fs::unique_path();
 
     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;
 }
 
 /**
  * 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);
 }
 
 /** Internal helper functions for ArgsManager */
 class ArgsManagerHelper {
 public:
     typedef std::map<std::string, std::vector<std::string>> MapArgs;
 
     /** Determine whether to use config settings in the default section,
      *  See also comments around ArgsManager::ArgsManager() below. */
     static inline bool UseDefaultSection(const ArgsManager &am,
                                          const std::string &arg)
         EXCLUSIVE_LOCKS_REQUIRED(am.cs_args) {
         return (am.m_network == CBaseChainParams::MAIN ||
                 am.m_network_only_args.count(arg) == 0);
     }
 
     /** Convert regular argument into the network-specific setting */
     static inline std::string NetworkArg(const ArgsManager &am,
                                          const std::string &arg) {
         assert(arg.length() > 1 && arg[0] == '-');
         return "-" + am.m_network + "." + arg.substr(1);
     }
 
     /** Find arguments in a map and add them to a vector */
     static inline void AddArgs(std::vector<std::string> &res,
                                const MapArgs &map_args,
                                const std::string &arg) {
         auto it = map_args.find(arg);
         if (it != map_args.end()) {
             res.insert(res.end(), it->second.begin(), it->second.end());
         }
     }
 
     /**
      * Return true/false if an argument is set in a map, and also
      * return the first (or last) of the possibly multiple values it has
      */
     static inline std::pair<bool, std::string>
     GetArgHelper(const MapArgs &map_args, const std::string &arg,
                  bool getLast = false) {
         auto it = map_args.find(arg);
 
         if (it == map_args.end() || it->second.empty()) {
             return std::make_pair(false, std::string());
         }
 
         if (getLast) {
             return std::make_pair(true, it->second.back());
         } else {
             return std::make_pair(true, it->second.front());
         }
     }
 
     /**
      * Get the string value of an argument, returning a pair of a boolean
      * indicating the argument was found, and the value for the argument
      * if it was found (or the empty string if not found).
      */
     static inline std::pair<bool, std::string> GetArg(const ArgsManager &am,
                                                       const std::string &arg) {
         LOCK(am.cs_args);
         std::pair<bool, std::string> found_result(false, std::string());
 
         // We pass "true" to GetArgHelper in order to return the last
         // argument value seen from the command line (so "bitcoind -foo=bar
         // -foo=baz" gives GetArg(am,"foo")=={true,"baz"}
         found_result = GetArgHelper(am.m_override_args, arg, true);
         if (found_result.first) {
             return found_result;
         }
 
         // But in contrast we return the first argument seen in a config file,
         // so "foo=bar \n foo=baz" in the config file gives
         // GetArg(am,"foo")={true,"bar"}
         if (!am.m_network.empty()) {
             found_result = GetArgHelper(am.m_config_args, NetworkArg(am, arg));
             if (found_result.first) {
                 return found_result;
             }
         }
 
         if (UseDefaultSection(am, arg)) {
             found_result = GetArgHelper(am.m_config_args, arg);
             if (found_result.first) {
                 return found_result;
             }
         }
 
         return found_result;
     }
 
     /* Special test for -testnet and -regtest args, because we don't want to be
      * confused by craziness like "[regtest] testnet=1"
      */
     static inline bool GetNetBoolArg(const ArgsManager &am,
                                      const std::string &net_arg)
         EXCLUSIVE_LOCKS_REQUIRED(am.cs_args) {
         std::pair<bool, std::string> found_result(false, std::string());
         found_result = GetArgHelper(am.m_override_args, net_arg, true);
         if (!found_result.first) {
             found_result = GetArgHelper(am.m_config_args, net_arg, true);
             if (!found_result.first) {
                 // not set
                 return false;
             }
         }
         // is set, so evaluate
         return InterpretBool(found_result.second);
     }
 };
 
 /**
  * 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 clears the args vector to indicate a negated option.
  *
  * If there was a double negative, it removes "no" from the key, sets the
  * value to "1" and pushes the key and the updated value to the args vector.
  *
  * If there was no "no", it leaves key and value untouched and pushes them
  * to the args vector.
  *
  * 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).
  */
 
 NODISCARD static bool
 InterpretOption(std::string key, std::string val, unsigned int flags,
                 std::map<std::string, std::vector<std::string>> &args,
                 std::string &error) {
     assert(key[0] == '-');
 
     size_t option_index = key.find('.');
     if (option_index == std::string::npos) {
         option_index = 1;
     } else {
         ++option_index;
     }
     if (key.substr(option_index, 2) == "no") {
         key.erase(option_index, 2);
         if (flags & ArgsManager::ALLOW_BOOL) {
             if (InterpretBool(val)) {
                 args[key].clear();
                 return true;
             }
             // Double negatives like -nofoo=0 are supported (but discouraged)
             LogPrintf(
                 "Warning: parsed potentially confusing double-negative %s=%s\n",
                 key, val);
             val = "1";
         } else {
             error = strprintf(
                 "Negating of %s is meaningless and therefore forbidden",
                 key.c_str());
             return false;
         }
     }
     args[key].push_back(val);
     return true;
 }
 
 ArgsManager::ArgsManager() {
     // nothing to do
 }
 
 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) {
         std::pair<bool, std::string> found_result;
 
         // if this option is overridden it's fine
         found_result = ArgsManagerHelper::GetArgHelper(m_override_args, arg);
         if (found_result.first) {
             continue;
         }
 
         // if there's a network-specific value for this option, it's fine
         found_result = ArgsManagerHelper::GetArgHelper(
             m_config_args, ArgsManagerHelper::NetworkArg(*this, arg));
         if (found_result.first) {
             continue;
         }
 
         // if there isn't a default value for this option, it's fine
         found_result = ArgsManagerHelper::GetArgHelper(m_config_args, arg);
         if (!found_result.first) {
             continue;
         }
 
         // otherwise, issue a warning
         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
     std::transform(key.begin(), key.end(), key.begin(), ::tolower);
     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_override_args.clear();
 
     for (int i = 1; i < argc; i++) {
         std::string key(argv[i]);
         if (key == "-") {
             // bitcoin-tx using stdin
             break;
         }
         std::string val;
         if (!ParseKeyValue(key, val)) {
             break;
         }
 
         const unsigned int flags = FlagsOfKnownArg(key);
         if (flags) {
             if (!InterpretOption(key, val, flags, m_override_args, error)) {
                 return false;
             }
         } else {
             error = strprintf("Invalid parameter %s", key.c_str());
             return false;
         }
     }
 
     // we do not allow -includeconf from command line, so we clear it here
     auto it = m_override_args.find("-includeconf");
     if (it != m_override_args.end()) {
         if (it->second.size() > 0) {
             for (const auto &ic : it->second) {
                 error += "-includeconf cannot be used from commandline; "
                          "-includeconf=" +
                          ic + "\n";
             }
             return false;
         }
     }
     return true;
 }
 
 unsigned int ArgsManager::FlagsOfKnownArg(const std::string &key) const {
     assert(key[0] == '-');
 
     size_t option_index = key.find('.');
     if (option_index == std::string::npos) {
         option_index = 1;
     } else {
         ++option_index;
     }
     if (key.substr(option_index, 2) == "no") {
         option_index += 2;
     }
 
     const std::string base_arg_name = '-' + key.substr(option_index);
 
     LOCK(cs_args);
     for (const auto &arg_map : m_available_args) {
         const auto search = arg_map.second.find(base_arg_name);
         if (search != arg_map.second.end()) {
             return search->second.m_flags;
         }
     }
     return ArgsManager::NONE;
 }
 
 std::vector<std::string> ArgsManager::GetArgs(const std::string &strArg) const {
     std::vector<std::string> result = {};
     // special case
     if (IsArgNegated(strArg)) {
         return result;
     }
 
     LOCK(cs_args);
 
     ArgsManagerHelper::AddArgs(result, m_override_args, strArg);
     if (!m_network.empty()) {
         ArgsManagerHelper::AddArgs(
             result, m_config_args,
             ArgsManagerHelper::NetworkArg(*this, strArg));
     }
 
     if (ArgsManagerHelper::UseDefaultSection(*this, strArg)) {
         ArgsManagerHelper::AddArgs(result, m_config_args, strArg);
     }
 
     return result;
 }
 
 bool ArgsManager::IsArgSet(const std::string &strArg) const {
     // special case
     if (IsArgNegated(strArg)) {
         return true;
     }
     return ArgsManagerHelper::GetArg(*this, strArg).first;
 }
 
 bool ArgsManager::IsArgNegated(const std::string &strArg) const {
     LOCK(cs_args);
 
     const auto &ov = m_override_args.find(strArg);
     if (ov != m_override_args.end()) {
         return ov->second.empty();
     }
 
     if (!m_network.empty()) {
         const auto &cfs =
             m_config_args.find(ArgsManagerHelper::NetworkArg(*this, strArg));
         if (cfs != m_config_args.end()) {
             return cfs->second.empty();
         }
     }
 
     const auto &cf = m_config_args.find(strArg);
     if (cf != m_config_args.end()) {
         return cf->second.empty();
     }
 
     return false;
 }
 
 std::string ArgsManager::GetArg(const std::string &strArg,
                                 const std::string &strDefault) const {
     if (IsArgNegated(strArg)) {
         return "0";
     }
     std::pair<bool, std::string> found_res =
         ArgsManagerHelper::GetArg(*this, strArg);
     if (found_res.first) {
         return found_res.second;
     }
     return strDefault;
 }
 
 int64_t ArgsManager::GetArg(const std::string &strArg, int64_t nDefault) const {
     if (IsArgNegated(strArg)) {
         return 0;
     }
     std::pair<bool, std::string> found_res =
         ArgsManagerHelper::GetArg(*this, strArg);
     if (found_res.first) {
         return atoi64(found_res.second);
     }
     return nDefault;
 }
 
 bool ArgsManager::GetBoolArg(const std::string &strArg, bool fDefault) const {
     if (IsArgNegated(strArg)) {
         return false;
     }
     std::pair<bool, std::string> found_res =
         ArgsManagerHelper::GetArg(*this, strArg);
     if (found_res.first) {
         return InterpretBool(found_res.second);
     }
     return fDefault;
 }
 
 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_override_args[strArg] = {strValue};
 }
 
 /**
  * This function is only used for testing purpose so
  * so we should not worry about element uniqueness and
  * integrity of mapMultiArgs data structure
  */
 void ArgsManager::ForceSetMultiArg(const std::string &strArg,
                                    const std::string &strValue) {
     LOCK(cs_args);
     m_override_args[strArg].push_back(strValue);
 }
 
 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::ClearArg(const std::string &strArg) {
     LOCK(cs_args);
     m_override_args.erase(strArg);
     m_config_args.erase(strArg);
 }
 
 std::string ArgsManager::GetHelpMessage() const {
     const bool show_debug = gArgs.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;
             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");
 }
 
 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.c_str());
 }
 
 fs::path GetDefaultDataDir() {
 // Windows < Vista: C:\Documents and Settings\Username\Application Data\Bitcoin
 // Windows >= Vista: C:\Users\Username\AppData\Roaming\Bitcoin
 // Mac: ~/Library/Application Support/Bitcoin
 // Unix: ~/.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
     // Mac
     return pathRet / "Library/Application Support/Bitcoin";
 #else
     // Unix
     return pathRet / ".bitcoin";
 #endif
 #endif
 }
 
 static fs::path g_blocks_path_cache_net_specific;
 static fs::path pathCached;
 static fs::path pathCachedNetSpecific;
 static RecursiveMutex csPathCached;
 
 const fs::path &GetBlocksDir() {
     LOCK(csPathCached);
     fs::path &path = g_blocks_path_cache_net_specific;
 
     // Cache the path to avoid calling fs::create_directories on every call of
     // this function
     if (!path.empty()) {
         return path;
     }
 
     if (gArgs.IsArgSet("-blocksdir")) {
         path = fs::system_complete(gArgs.GetArg("-blocksdir", ""));
         if (!fs::is_directory(path)) {
             path = "";
             return path;
         }
     } else {
         path = GetDataDir(false);
     }
 
     path /= BaseParams().DataDir();
     path /= "blocks";
     fs::create_directories(path);
     return path;
 }
 
 const fs::path &GetDataDir(bool fNetSpecific) {
     LOCK(csPathCached);
     fs::path &path = fNetSpecific ? pathCachedNetSpecific : pathCached;
 
     // Cache the path to avoid calling fs::create_directories on every call of
     // this function
     if (!path.empty()) {
         return path;
     }
 
     if (gArgs.IsArgSet("-datadir")) {
         path = fs::system_complete(gArgs.GetArg("-datadir", ""));
         if (!fs::is_directory(path)) {
             path = "";
             return path;
         }
     } else {
         path = GetDefaultDataDir();
     }
 
     if (fNetSpecific) {
         path /= BaseParams().DataDir();
     }
 
     if (fs::create_directories(path)) {
         // This is the first run, create wallets subdirectory too
         //
         // TODO: this is an ugly way to create the wallets/ directory and
         // really shouldn't be done here. Once this is fixed, please
         // also remove the corresponding line in bitcoind.cpp AppInit.
         // See more info at:
         // https://reviews.bitcoinabc.org/D3312
         fs::create_directories(path / "wallets");
     }
 
     return path;
 }
 
 void ClearDatadirCache() {
     LOCK(csPathCached);
 
     pathCached = fs::path();
     pathCachedNetSpecific = fs::path();
     g_blocks_path_cache_net_specific = fs::path();
 }
 
 fs::path GetConfigFile(const std::string &confPath) {
     return AbsPathForConfigVal(fs::path(confPath), false);
 }
 
 static std::string TrimString(const std::string &str,
                               const std::string &pattern) {
     std::string::size_type front = str.find_first_not_of(pattern);
     if (front == std::string::npos) {
         return std::string();
     }
     std::string::size_type end = str.find_last_not_of(pattern);
     return str.substr(front, end - front + 1);
 }
 
 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) {
         const std::string strKey = std::string("-") + option.first;
         const unsigned int flags = FlagsOfKnownArg(strKey);
         if (flags) {
             if (!InterpretOption(strKey, option.second, flags, m_config_args,
                                  error)) {
                 return false;
             }
         } 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_config_args.clear();
         m_config_sections.clear();
     }
 
     const std::string confPath = GetArg("-conf", BITCOIN_CONF_FILENAME);
     fsbridge::ifstream stream(GetConfigFile(confPath));
 
     // ok to not have a config file
     if (stream.good()) {
         if (!ReadConfigStream(stream, confPath, error, ignore_invalid_keys)) {
             return false;
         }
         // if there is an -includeconf in the override args, but it is empty,
         // that means the user passed '-noincludeconf' on the command line, in
         // which case we should not include anything
         bool emptyIncludeConf;
         {
             LOCK(cs_args);
             emptyIncludeConf = m_override_args.count("-includeconf") == 0;
         }
         if (emptyIncludeConf) {
             std::string chain_id = GetChainName();
             std::vector<std::string> includeconf(GetArgs("-includeconf"));
             {
                 // We haven't set m_network yet (that happens in
                 // SelectParams()), so manually check for network.includeconf
                 // args.
                 std::vector<std::string> includeconf_net(
                     GetArgs(std::string("-") + chain_id + ".includeconf"));
                 includeconf.insert(includeconf.end(), includeconf_net.begin(),
                                    includeconf_net.end());
             }
 
             // Remove -includeconf from configuration, so we can warn about
             // recursion later
             {
                 LOCK(cs_args);
                 m_config_args.erase("-includeconf");
                 m_config_args.erase(std::string("-") + chain_id +
                                     ".includeconf");
             }
 
             for (const std::string &to_include : includeconf) {
                 fsbridge::ifstream include_config(GetConfigFile(to_include));
                 if (include_config.good()) {
                     if (!ReadConfigStream(include_config, to_include, error,
                                           ignore_invalid_keys)) {
                         return false;
                     }
                     LogPrintf("Included configuration file %s\n",
                               to_include.c_str());
                 } else {
                     error =
                         "Failed to include configuration file " + to_include;
                     return false;
                 }
             }
 
             // Warn about recursive -includeconf
             includeconf = GetArgs("-includeconf");
             {
                 std::vector<std::string> includeconf_net(
                     GetArgs(std::string("-") + chain_id + ".includeconf"));
                 includeconf.insert(includeconf.end(), includeconf_net.begin(),
                                    includeconf_net.end());
                 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
                     includeconf_net = GetArgs(std::string("-") +
                                               chain_id_final + ".includeconf");
                     includeconf.insert(includeconf.end(),
                                        includeconf_net.begin(),
                                        includeconf_net.end());
                 }
             }
             for (const std::string &to_include : includeconf) {
                 tfm::format(
                     std::cerr,
                     "warning: -includeconf cannot be used from included "
                     "files; ignoring -includeconf=%s\n",
                     to_include.c_str());
             }
         }
     }
 
     // If datadir is changed in .conf file:
     ClearDatadirCache();
     if (!fs::is_directory(GetDataDir(false))) {
         error = strprintf("specified data directory \"%s\" does not exist.",
                           gArgs.GetArg("-datadir", "").c_str());
         return false;
     }
     return true;
 }
 
 std::string ArgsManager::GetChainName() const {
     LOCK(cs_args);
     bool fRegTest = ArgsManagerHelper::GetNetBoolArg(*this, "-regtest");
     bool fTestNet = ArgsManagerHelper::GetNetBoolArg(*this, "-testnet");
 
     if (fTestNet && fRegTest) {
         throw std::runtime_error(
             "Invalid combination of -regtest and -testnet.");
     }
     if (fRegTest) {
         return CBaseChainParams::REGTEST;
     }
     if (fTestNet) {
         return CBaseChainParams::TESTNET;
     }
     return CBaseChainParams::MAIN;
 }
 
 bool RenameOver(fs::path src, fs::path dest) {
 #ifdef WIN32
     return MoveFileExA(src.string().c_str(), dest.string().c_str(),
                        MOVEFILE_REPLACE_EXISTING) != 0;
 #else
     int rc = std::rename(src.string().c_str(), dest.string().c_str());
     return (rc == 0);
 #endif /* WIN32 */
 }
 
 /**
  * Ignores exceptions thrown by Boost's 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(__linux__) || defined(__NetBSD__)
     // 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 2048;
 #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.
     fstore_t fst;
     fst.fst_flags = F_ALLOCATECONTIG;
     fst.fst_posmode = F_PEOFPOSMODE;
     fst.fst_offset = 0;
     fst.fst_length = (off_t)offset + 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), fst.fst_length);
 #elif defined(__linux__)
     // 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) {
     char pszPath[MAX_PATH] = "";
 
     if (SHGetSpecialFolderPathA(nullptr, pszPath, nFolder, fCreate)) {
         return fs::path(pszPath);
     }
 
     LogPrintf(
         "SHGetSpecialFolderPathA() failed, could not obtain requested path.\n");
     return fs::path("");
 }
 #endif
 
 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);
     }
 }
 
 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" 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", 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 boost::thread::physical_concurrency();
 }
 
 std::string CopyrightHolders(const std::string &strPrefix) {
     return strPrefix +
-           strprintf(_(COPYRIGHT_HOLDERS), _(COPYRIGHT_HOLDERS_SUBSTITUTION));
+           strprintf(_(COPYRIGHT_HOLDERS), 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) {
     return fs::absolute(path, GetDataDir(net_specific));
 }
 
 int ScheduleBatchPriority() {
 #ifdef SCHED_BATCH
     const static sched_param param{};
     if (int ret = pthread_setschedparam(pthread_self(), SCHED_BATCH, &param)) {
         LogPrintf("Failed to pthread_setschedparam: %s\n", strerror(errno));
         return ret;
     }
     return 0;
 #else
     return 1;
 #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/wallet.cpp b/src/wallet/wallet.cpp
index 3f0d9fa76..2233da7be 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1,4967 +1,4967 @@
 // 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 <wallet/wallet.h>
 
 #include <chain.h>
 #include <checkpoints.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <fs.h>
 #include <interfaces/chain.h>
 #include <key.h>
 #include <key_io.h>
 #include <keystore.h>
 #include <net.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/script.h>
 #include <script/sighashtype.h>
 #include <script/sign.h>
 #include <shutdown.h>
 #include <timedata.h>
 #include <txmempool.h>
 #include <ui_interface.h>
 #include <util/moneystr.h>
 #include <util/system.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/coinselection.h>
 #include <wallet/fees.h>
 #include <wallet/finaltx.h>
 
 #include <boost/algorithm/string/replace.hpp>
 
 #include <algorithm>
 #include <cassert>
 #include <future>
 
 static CCriticalSection cs_wallets;
 static std::vector<std::shared_ptr<CWallet>> vpwallets GUARDED_BY(cs_wallets);
 
 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);
     return true;
 }
 
 bool RemoveWallet(const std::shared_ptr<CWallet> &wallet) {
     LOCK(cs_wallets);
     assert(wallet);
     std::vector<std::shared_ptr<CWallet>>::iterator i =
         std::find(vpwallets.begin(), vpwallets.end(), wallet);
     if (i == vpwallets.end()) {
         return false;
     }
     vpwallets.erase(i);
     return true;
 }
 
 bool HasWallets() {
     LOCK(cs_wallets);
     return !vpwallets.empty();
 }
 
 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;
 }
 
 static Mutex g_wallet_release_mutex;
 static std::condition_variable g_wallet_release_cv;
 static std::set<std::string> g_unloading_wallet_set;
 
 // Custom deleter for shared_ptr<CWallet>.
 static void ReleaseWallet(CWallet *wallet) {
     // Unregister and delete the wallet right after
     // BlockUntilSyncedToCurrentChain so that it's in sync with the current
     // chainstate.
     const std::string name = wallet->GetName();
     wallet->WalletLogPrintf("Releasing wallet\n");
     wallet->BlockUntilSyncedToCurrentChain();
     wallet->Flush();
     UnregisterValidationInterface(wallet);
     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);
         }
     }
 }
 
 static const size_t OUTPUT_GROUP_MAX_ENTRIES = 10;
 
 const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
 
 const BlockHash CMerkleTx::ABANDON_HASH(uint256S(
     "0000000000000000000000000000000000000000000000000000000000000001"));
 
 /** @defgroup mapWallet
  *
  * @{
  */
 
 std::string COutput::ToString() const {
     return strprintf("COutput(%s, %d, %d) [%s]", tx->GetId().ToString(), i,
                      nDepth, FormatMoney(tx->tx->vout[i].nValue));
 }
 
 class CAffectedKeysVisitor : public boost::static_visitor<void> {
 private:
     const CKeyStore &keystore;
     std::vector<CKeyID> &vKeys;
 
 public:
     CAffectedKeysVisitor(const CKeyStore &keystoreIn,
                          std::vector<CKeyID> &vKeysIn)
         : keystore(keystoreIn), vKeys(vKeysIn) {}
 
     void Process(const CScript &script) {
         txnouttype type;
         std::vector<CTxDestination> vDest;
         int nRequired;
         if (ExtractDestinations(script, type, vDest, nRequired)) {
             for (const CTxDestination &dest : vDest) {
                 boost::apply_visitor(*this, dest);
             }
         }
     }
 
     void operator()(const CKeyID &keyId) {
         if (keystore.HaveKey(keyId)) {
             vKeys.push_back(keyId);
         }
     }
 
     void operator()(const CScriptID &scriptId) {
         CScript script;
         if (keystore.GetCScript(scriptId, script)) {
             Process(script);
         }
     }
 
     void operator()(const CNoDestination &none) {}
 };
 
 const CWalletTx *CWallet::GetWalletTx(const TxId &txid) const {
     LOCK(cs_wallet);
     std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
     if (it == mapWallet.end()) {
         return nullptr;
     }
 
     return &(it->second);
 }
 
 CPubKey CWallet::GenerateNewKey(WalletBatch &batch, bool internal) {
     assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     assert(!IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET));
     // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     // default to compressed public keys if we want 0.6.0 wallets
     bool fCompressed = CanSupportFeature(FEATURE_COMPRPUBKEY);
 
     CKey secret;
 
     // Create new metadata
     int64_t nCreationTime = GetTime();
     CKeyMetadata metadata(nCreationTime);
 
     // use HD key derivation if HD was enabled during wallet creation and a seed
     // is present
     if (IsHDEnabled()) {
         DeriveNewChildKey(
             batch, metadata, secret,
             (CanSupportFeature(FEATURE_HD_SPLIT) ? internal : false));
     } else {
         secret.MakeNewKey(fCompressed);
     }
 
     // Compressed public keys were introduced in version 0.6.0
     if (fCompressed) {
         SetMinVersion(FEATURE_COMPRPUBKEY);
     }
 
     CPubKey pubkey = secret.GetPubKey();
     assert(secret.VerifyPubKey(pubkey));
 
     mapKeyMetadata[pubkey.GetID()] = metadata;
     UpdateTimeFirstKey(nCreationTime);
 
     if (!AddKeyPubKeyWithDB(batch, secret, pubkey)) {
         throw std::runtime_error(std::string(__func__) + ": AddKey failed");
     }
 
     return pubkey;
 }
 
 void CWallet::DeriveNewChildKey(WalletBatch &batch, CKeyMetadata &metadata,
                                 CKey &secret, bool internal) {
     // for now we use a fixed keypath scheme of m/0'/0'/k
     // seed (256bit)
     CKey seed;
     // hd master key
     CExtKey masterKey;
     // key at m/0'
     CExtKey accountKey;
     // key at m/0'/0' (external) or m/0'/1' (internal)
     CExtKey chainChildKey;
     // key at m/0'/0'/<n>'
     CExtKey childKey;
 
     // try to get the seed
     if (!GetKey(hdChain.seed_id, seed)) {
         throw std::runtime_error(std::string(__func__) + ": seed not found");
     }
 
     masterKey.SetSeed(seed.begin(), seed.size());
 
     // derive m/0'
     // use hardened derivation (child keys >= 0x80000000 are hardened after
     // bip32)
     masterKey.Derive(accountKey, BIP32_HARDENED_KEY_LIMIT);
 
     // derive m/0'/0' (external chain) OR m/0'/1' (internal chain)
     assert(internal ? CanSupportFeature(FEATURE_HD_SPLIT) : true);
     accountKey.Derive(chainChildKey,
                       BIP32_HARDENED_KEY_LIMIT + (internal ? 1 : 0));
 
     // derive child key at next index, skip keys already known to the wallet
     do {
         // always derive hardened keys
         // childIndex | BIP32_HARDENED_KEY_LIMIT = derive childIndex in hardened
         // child-index-range
         // example: 1 | BIP32_HARDENED_KEY_LIMIT == 0x80000001 == 2147483649
         if (internal) {
             chainChildKey.Derive(childKey, hdChain.nInternalChainCounter |
                                                BIP32_HARDENED_KEY_LIMIT);
             metadata.hdKeypath = "m/0'/1'/" +
                                  std::to_string(hdChain.nInternalChainCounter) +
                                  "'";
             hdChain.nInternalChainCounter++;
         } else {
             chainChildKey.Derive(childKey, hdChain.nExternalChainCounter |
                                                BIP32_HARDENED_KEY_LIMIT);
             metadata.hdKeypath = "m/0'/0'/" +
                                  std::to_string(hdChain.nExternalChainCounter) +
                                  "'";
             hdChain.nExternalChainCounter++;
         }
     } while (HaveKey(childKey.key.GetPubKey().GetID()));
     secret = childKey.key;
     metadata.hd_seed_id = hdChain.seed_id;
     // update the chain model in the database
     if (!batch.WriteHDChain(hdChain)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": Writing HD chain model failed");
     }
 }
 
 bool CWallet::AddKeyPubKeyWithDB(WalletBatch &batch, const CKey &secret,
                                  const CPubKey &pubkey) {
     // mapKeyMetadata
     AssertLockHeld(cs_wallet);
 
     // Make sure we aren't adding private keys to private key disabled wallets
     assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
 
     // CCryptoKeyStore has no concept of wallet databases, but calls
     // AddCryptedKey which is overridden below. To avoid flushes, the database
     // handle is tunneled through to it.
     bool needsDB = !encrypted_batch;
     if (needsDB) {
         encrypted_batch = &batch;
     }
     if (!CCryptoKeyStore::AddKeyPubKey(secret, pubkey)) {
         if (needsDB) {
             encrypted_batch = nullptr;
         }
         return false;
     }
 
     if (needsDB) {
         encrypted_batch = nullptr;
     }
 
     // Check if we need to remove from watch-only.
     CScript script;
     script = GetScriptForDestination(pubkey.GetID());
     if (HaveWatchOnly(script)) {
         RemoveWatchOnly(script);
     }
 
     script = GetScriptForRawPubKey(pubkey);
     if (HaveWatchOnly(script)) {
         RemoveWatchOnly(script);
     }
 
     if (!IsCrypted()) {
         return batch.WriteKey(pubkey, secret.GetPrivKey(),
                               mapKeyMetadata[pubkey.GetID()]);
     }
 
     UnsetWalletFlag(WALLET_FLAG_BLANK_WALLET);
     return true;
 }
 
 bool CWallet::AddKeyPubKey(const CKey &secret, const CPubKey &pubkey) {
     WalletBatch batch(*database);
     return CWallet::AddKeyPubKeyWithDB(batch, secret, pubkey);
 }
 
 bool CWallet::AddCryptedKey(const CPubKey &vchPubKey,
                             const std::vector<uint8_t> &vchCryptedSecret) {
     if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret)) {
         return false;
     }
 
     LOCK(cs_wallet);
     if (encrypted_batch) {
         return encrypted_batch->WriteCryptedKey(
             vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
     }
 
     return WalletBatch(*database).WriteCryptedKey(
         vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
 }
 
 void CWallet::LoadKeyMetadata(const CKeyID &keyID, const CKeyMetadata &meta) {
     // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     UpdateTimeFirstKey(meta.nCreateTime);
     mapKeyMetadata[keyID] = meta;
 }
 
 void CWallet::LoadScriptMetadata(const CScriptID &script_id,
                                  const CKeyMetadata &meta) {
     // m_script_metadata
     AssertLockHeld(cs_wallet);
     UpdateTimeFirstKey(meta.nCreateTime);
     m_script_metadata[script_id] = meta;
 }
 
 bool CWallet::LoadCryptedKey(const CPubKey &vchPubKey,
                              const std::vector<uint8_t> &vchCryptedSecret) {
     return CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret);
 }
 
 /**
  * Update wallet first key creation time. This should be called whenever keys
  * are added to the wallet, with the oldest key creation time.
  */
 void CWallet::UpdateTimeFirstKey(int64_t nCreateTime) {
     AssertLockHeld(cs_wallet);
     if (nCreateTime <= 1) {
         // Cannot determine birthday information, so set the wallet birthday to
         // the beginning of time.
         nTimeFirstKey = 1;
     } else if (!nTimeFirstKey || nCreateTime < nTimeFirstKey) {
         nTimeFirstKey = nCreateTime;
     }
 }
 
 bool CWallet::AddCScript(const CScript &redeemScript) {
     if (!CCryptoKeyStore::AddCScript(redeemScript)) {
         return false;
     }
     if (WalletBatch(*database).WriteCScript(Hash160(redeemScript),
                                             redeemScript)) {
         UnsetWalletFlag(WALLET_FLAG_BLANK_WALLET);
         return true;
     }
     return false;
 }
 
 bool CWallet::LoadCScript(const CScript &redeemScript) {
     /**
      * A sanity check was added in pull #3843 to avoid adding redeemScripts that
      * never can be redeemed. However, old wallets may still contain these. Do
      * not add them to the wallet and warn.
      */
     if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) {
         std::string strAddr =
             EncodeDestination(CScriptID(redeemScript), GetConfig());
         WalletLogPrintf("%s: Warning: This wallet contains a redeemScript "
                         "of size %i which exceeds maximum size %i thus can "
                         "never be redeemed. Do not use address %s.\n",
                         __func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE,
                         strAddr);
         return true;
     }
 
     return CCryptoKeyStore::AddCScript(redeemScript);
 }
 
 bool CWallet::AddWatchOnly(const CScript &dest) {
     if (!CCryptoKeyStore::AddWatchOnly(dest)) {
         return false;
     }
 
     const CKeyMetadata &meta = m_script_metadata[CScriptID(dest)];
     UpdateTimeFirstKey(meta.nCreateTime);
     NotifyWatchonlyChanged(true);
     if (WalletBatch(*database).WriteWatchOnly(dest, meta)) {
         UnsetWalletFlag(WALLET_FLAG_BLANK_WALLET);
         return true;
     }
     return false;
 }
 
 bool CWallet::AddWatchOnly(const CScript &dest, int64_t nCreateTime) {
     m_script_metadata[CScriptID(dest)].nCreateTime = nCreateTime;
     return AddWatchOnly(dest);
 }
 
 bool CWallet::RemoveWatchOnly(const CScript &dest) {
     AssertLockHeld(cs_wallet);
     if (!CCryptoKeyStore::RemoveWatchOnly(dest)) {
         return false;
     }
 
     if (!HaveWatchOnly()) {
         NotifyWatchonlyChanged(false);
     }
 
     return WalletBatch(*database).EraseWatchOnly(dest);
 }
 
 bool CWallet::LoadWatchOnly(const CScript &dest) {
     return CCryptoKeyStore::AddWatchOnly(dest);
 }
 
 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 (CCryptoKeyStore::Unlock(_vMasterKey, accept_no_keys)) {
                 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 (CCryptoKeyStore::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) {
     // nWalletVersion
     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) {
     // nWalletVersion, nWalletMaxVersion
     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(bool shutdown) {
     database->Flush(shutdown);
 }
 
 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(interfaces::Chain::Lock &locked_chain,
                       const COutPoint &outpoint) const {
     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 = mit->second.GetDepthInMainChain(locked_chain);
             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));
 
     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());
     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;
         assert(!encrypted_batch);
         encrypted_batch = new WalletBatch(*database);
         if (!encrypted_batch->TxnBegin()) {
             delete encrypted_batch;
             encrypted_batch = nullptr;
             return false;
         }
         encrypted_batch->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
 
         if (!EncryptKeys(_vMasterKey)) {
             encrypted_batch->TxnAbort();
             delete encrypted_batch;
             // 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;
             // 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 HD, replace the HD seed with a new one
         if (IsHDEnabled()) {
             SetHDSeed(GenerateNewSeed());
         }
 
         NewKeyPool();
         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) {
     // nOrderPosNext
     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();
     }
 }
 
 bool CWallet::AddToWallet(const CWalletTx &wtxIn, bool fFlushOnClose) {
     LOCK(cs_wallet);
 
     WalletBatch batch(*database, "r+", fFlushOnClose);
 
     const TxId &txid = wtxIn.GetId();
 
     // Inserts only if not already there, returns tx inserted or tx found.
     std::pair<std::map<TxId, CWalletTx>::iterator, bool> ret =
         mapWallet.insert(std::make_pair(txid, wtxIn));
     CWalletTx &wtx = (*ret.first).second;
     wtx.BindWallet(this);
     bool fInsertedNew = ret.second;
     if (fInsertedNew) {
         wtx.nTimeReceived = GetAdjustedTime();
         wtx.nOrderPos = IncOrderPosNext(&batch);
         wtx.m_it_wtxOrdered =
             wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
         wtx.nTimeSmart = ComputeTimeSmart(wtx);
         AddToSpends(txid);
     }
 
     bool fUpdated = false;
     if (!fInsertedNew) {
         // Merge
         if (!wtxIn.hashUnset() && wtxIn.hashBlock != wtx.hashBlock) {
             wtx.hashBlock = wtxIn.hashBlock;
             fUpdated = true;
         }
 
         // If no longer abandoned, update
         if (wtxIn.hashBlock.IsNull() && wtx.isAbandoned()) {
             wtx.hashBlock = wtxIn.hashBlock;
             fUpdated = true;
         }
 
         if (wtxIn.nIndex != -1 && (wtxIn.nIndex != wtx.nIndex)) {
             wtx.nIndex = wtxIn.nIndex;
             fUpdated = true;
         }
 
         if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe) {
             wtx.fFromMe = wtxIn.fFromMe;
             fUpdated = true;
         }
     }
 
     //// debug print
     WalletLogPrintf("AddToWallet %s  %s%s\n", wtxIn.GetId().ToString(),
                     (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
 
     // Write to disk
     if ((fInsertedNew || fUpdated) && !batch.WriteTx(wtx)) {
         return false;
     }
 
     // Break debit/credit balance caches:
     wtx.MarkDirty();
 
     // Notify UI of new or updated transaction.
     NotifyTransactionChanged(this, txid, fInsertedNew ? CT_NEW : CT_UPDATED);
 
     // Notify an external script when a wallet transaction comes in or is
     // updated.
     std::string strCmd = gArgs.GetArg("-walletnotify", "");
 
     if (!strCmd.empty()) {
         boost::replace_all(strCmd, "%s", wtxIn.GetId().GetHex());
         std::thread t(runCommand, strCmd);
         // Thread runs free.
         t.detach();
     }
 
     return true;
 }
 
 void CWallet::LoadToWallet(const CWalletTx &wtxIn) {
     const TxId &txid = wtxIn.GetId();
     const auto &ins = mapWallet.emplace(txid, wtxIn);
     CWalletTx &wtx = ins.first->second;
     wtx.BindWallet(this);
     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.nIndex == -1 && !prevtx.hashUnset()) {
                 MarkConflicted(prevtx.hashBlock, wtx.GetId());
             }
         }
     }
 }
 
 bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef &ptx,
                                        const BlockHash &block_hash,
                                        int posInBlock, bool fUpdate) {
     const CTransaction &tx = *ptx;
     AssertLockHeld(cs_wallet);
 
     if (!block_hash.IsNull()) {
         for (const CTxIn &txin : tx.vin) {
             std::pair<TxSpends::const_iterator, TxSpends::const_iterator>
                 range = mapTxSpends.equal_range(txin.prevout);
             while (range.first != range.second) {
                 if (range.first->second != tx.GetId()) {
                     WalletLogPrintf(
                         "Transaction %s (in block %s) conflicts with wallet "
                         "transaction %s (both spend %s:%i)\n",
                         tx.GetId().ToString(), block_hash.ToString(),
                         range.first->second.ToString(),
                         range.first->first.GetTxId().ToString(),
                         range.first->first.GetN());
                     MarkConflicted(block_hash, range.first->second);
                 }
                 range.first++;
             }
         }
     }
 
     bool fExisted = mapWallet.count(tx.GetId()) != 0;
     if (fExisted && !fUpdate) {
         return false;
     }
     if (fExisted || IsMine(tx) || IsFromMe(tx)) {
         /**
          * 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 : tx.vout) {
             // extract addresses and check if they match with an unused keypool
             // key
             std::vector<CKeyID> vAffected;
             CAffectedKeysVisitor(*this, vAffected).Process(txout.scriptPubKey);
             for (const CKeyID &keyid : vAffected) {
                 std::map<CKeyID, int64_t>::const_iterator mi =
                     m_pool_key_to_index.find(keyid);
                 if (mi != m_pool_key_to_index.end()) {
                     WalletLogPrintf("%s: Detected a used keypool key, mark all "
                                     "keypool key up to this key as used\n",
                                     __func__);
                     MarkReserveKeysAsUsed(mi->second);
 
                     if (!TopUpKeyPool()) {
                         WalletLogPrintf(
                             "%s: Topping up keypool failed (locked wallet)\n",
                             __func__);
                     }
                 }
             }
         }
 
         CWalletTx wtx(this, ptx);
 
         // Get merkle branch if transaction was found in a block
         if (!block_hash.IsNull()) {
             wtx.SetMerkleBranch(block_hash, posInBlock);
         }
 
         return AddToWallet(wtx, false);
     }
 
     return false;
 }
 
 bool CWallet::TransactionCanBeAbandoned(const TxId &txid) const {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
     const CWalletTx *wtx = GetWalletTx(txid);
     return wtx && !wtx->isAbandoned() &&
            wtx->GetDepthInMainChain(*locked_chain) == 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(interfaces::Chain::Lock &locked_chain,
                                  const TxId &txid) {
     // Temporary. Removed in upcoming lock cleanup
     auto locked_chain_recursive = chain().lock();
     LOCK(cs_wallet);
 
     WalletBatch batch(*database, "r+");
 
     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());
     CWalletTx &origtx = it->second;
     if (origtx.GetDepthInMainChain(locked_chain) != 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 = wtx.GetDepthInMainChain(locked_chain);
         // 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.nIndex = -1;
             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, const TxId &txid) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     int conflictconfirms = -locked_chain->getBlockDepth(hashBlock);
 
     // 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, "r+", 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 = wtx.GetDepthInMainChain(*locked_chain);
         if (conflictconfirms < currentconfirm) {
             // Block is 'more conflicted' than current confirm; update.
             // Mark transaction as conflicted with this block.
             wtx.nIndex = -1;
             wtx.hashBlock = hashBlock;
             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,
                               const BlockHash &block_hash, int posInBlock,
                               bool update_tx) {
     if (!AddToWalletIfInvolvingMe(ptx, block_hash, posInBlock, 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 &ptx) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
     SyncTransaction(ptx, BlockHash(), 0 /* position in block */);
 
     auto it = mapWallet.find(ptx->GetId());
     if (it != mapWallet.end()) {
         it->second.fInMempool = true;
     }
 }
 
 void CWallet::TransactionRemovedFromMempool(const CTransactionRef &ptx) {
     LOCK(cs_wallet);
     auto it = mapWallet.find(ptx->GetId());
     if (it != mapWallet.end()) {
         it->second.fInMempool = false;
     }
 }
 
 void CWallet::BlockConnected(
     const std::shared_ptr<const CBlock> &pblock, const CBlockIndex *pindex,
     const std::vector<CTransactionRef> &vtxConflicted) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     // TODO: Temporarily ensure that mempool removals are notified before
     // connected transactions. This shouldn't matter, but the abandoned state of
     // transactions in our wallet is currently cleared when we receive another
     // notification and there is a race condition where notification of a
     // connected conflict might cause an outside process to abandon a
     // transaction and then have it inadvertently cleared by the notification
     // that the conflicted transaction was evicted.
     for (const CTransactionRef &ptx : vtxConflicted) {
         SyncTransaction(ptx, BlockHash(), 0 /* position in block */);
         TransactionRemovedFromMempool(ptx);
     }
 
     for (size_t i = 0; i < pblock->vtx.size(); i++) {
         SyncTransaction(pblock->vtx[i], pindex->GetBlockHash(), i);
         TransactionRemovedFromMempool(pblock->vtx[i]);
     }
 
     m_last_block_processed = pindex->GetBlockHash();
 }
 
 void CWallet::BlockDisconnected(const std::shared_ptr<const CBlock> &pblock) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     for (const CTransactionRef &ptx : pblock->vtx) {
         SyncTransaction(ptx, BlockHash(), 0 /* position in block */);
     }
 }
 
 void CWallet::BlockUntilSyncedToCurrentChain() {
     AssertLockNotHeld(cs_main);
     AssertLockNotHeld(cs_wallet);
 
     {
         // Skip the queue-draining stuff if we know we're caught up with
         // ::ChainActive().Tip()...
         // We could also take cs_wallet here, and call m_last_block_processed
         // protected by cs_wallet instead of cs_main, but as long as we need
         // cs_main here anyway, it's easier to just call it cs_main-protected.
         auto locked_chain = chain().lock();
         if (!m_last_block_processed.IsNull() &&
             locked_chain->isPotentialTip(m_last_block_processed)) {
             return;
         }
     }
 
     // ...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).
     SyncWithValidationInterfaceQueue();
 }
 
 isminetype CWallet::IsMine(const CTxIn &txin) 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()) {
             return IsMine(prev.tx->vout[txin.prevout.GetN()]);
         }
     }
 
     return ISMINE_NO;
 }
 
 // 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 {
     return ::IsMine(*this, txout.scriptPubKey);
 }
 
 Amount CWallet::GetCredit(const CTxOut &txout,
                           const isminefilter &filter) const {
     if (!MoneyRange(txout.nValue)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": value out of range");
     }
 
     return (IsMine(txout) & filter) ? txout.nValue : Amount::zero();
 }
 
 bool CWallet::IsChange(const CTxOut &txout) const {
     return IsChange(txout.scriptPubKey);
 }
 
 bool CWallet::IsChange(const CScript &script) const {
     // TODO: fix handling of 'change' outputs. The assumption is that any
     // payment to a script that is ours, but is not in the address book is
     // change. That assumption is likely to break when we implement
     // multisignature wallets that return change back into a
     // multi-signature-protected address; a better way of identifying which
     // outputs are 'the send' and which are 'the change' will need to be
     // implemented (maybe extend CWalletTx to remember which output, if any, was
     // change).
     if (::IsMine(*this, script)) {
         CTxDestination address;
         if (!ExtractDestination(script, address)) {
             return true;
         }
 
         LOCK(cs_wallet);
         if (!mapAddressBook.count(address)) {
             return true;
         }
     }
 
     return false;
 }
 
 Amount CWallet::GetChange(const CTxOut &txout) const {
     if (!MoneyRange(txout.nValue)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": value out of range");
     }
 
     return (IsChange(txout) ? txout.nValue : Amount::zero());
 }
 
 bool CWallet::IsMine(const CTransaction &tx) const {
     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::IsAllFromMe(const CTransaction &tx,
                           const isminefilter &filter) const {
     LOCK(cs_wallet);
 
     for (const CTxIn &txin : tx.vin) {
         auto mi = mapWallet.find(txin.prevout.GetTxId());
         if (mi == mapWallet.end()) {
             // Any unknown inputs can't be from us.
             return false;
         }
 
         const CWalletTx &prev = (*mi).second;
 
         if (txin.prevout.GetN() >= prev.tx->vout.size()) {
             // Invalid input!
             return false;
         }
 
         if (!(IsMine(prev.tx->vout[txin.prevout.GetN()]) & filter)) {
             return false;
         }
     }
 
     return true;
 }
 
 Amount CWallet::GetCredit(const CTransaction &tx,
                           const isminefilter &filter) const {
     Amount nCredit = Amount::zero();
     for (const CTxOut &txout : tx.vout) {
         nCredit += GetCredit(txout, filter);
         if (!MoneyRange(nCredit)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nCredit;
 }
 
 Amount CWallet::GetChange(const CTransaction &tx) const {
     Amount nChange = Amount::zero();
     for (const CTxOut &txout : tx.vout) {
         nChange += GetChange(txout);
         if (!MoneyRange(nChange)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": value out of range");
         }
     }
 
     return nChange;
 }
 
 CPubKey CWallet::GenerateNewSeed() {
     assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
     CKey key;
     key.MakeNewKey(true);
     return DeriveNewSeed(key);
 }
 
 CPubKey CWallet::DeriveNewSeed(const CKey &key) {
     int64_t nCreationTime = GetTime();
     CKeyMetadata metadata(nCreationTime);
 
     // Calculate the seed
     CPubKey seed = key.GetPubKey();
     assert(key.VerifyPubKey(seed));
 
     // Set the hd keypath to "s" -> Seed, refers the seed to itself
     metadata.hdKeypath = "s";
     metadata.hd_seed_id = seed.GetID();
 
     LOCK(cs_wallet);
 
     // mem store the metadata
     mapKeyMetadata[seed.GetID()] = metadata;
 
     // Write the key&metadata to the database
     if (!AddKeyPubKey(key, seed)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": AddKeyPubKey failed");
     }
 
     return seed;
 }
 
 void CWallet::SetHDSeed(const CPubKey &seed) {
     LOCK(cs_wallet);
 
     // Store the keyid (hash160) together with the child index counter in the
     // database as a hdchain object.
     CHDChain newHdChain;
     newHdChain.nVersion = CanSupportFeature(FEATURE_HD_SPLIT)
                               ? CHDChain::VERSION_HD_CHAIN_SPLIT
                               : CHDChain::VERSION_HD_BASE;
     newHdChain.seed_id = seed.GetID();
     SetHDChain(newHdChain, false);
     NotifyCanGetAddressesChanged();
     UnsetWalletFlag(WALLET_FLAG_BLANK_WALLET);
 }
 
 void CWallet::SetHDChain(const CHDChain &chain, bool memonly) {
     LOCK(cs_wallet);
     if (!memonly && !WalletBatch(*database).WriteHDChain(chain)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing chain failed");
     }
 
     hdChain = chain;
 }
 
 bool CWallet::IsHDEnabled() const {
     return !hdChain.seed_id.IsNull();
 }
 
 bool CWallet::CanGenerateKeys() {
     // A wallet can generate keys if it has an HD seed (IsHDEnabled) or it is a
     // non-HD wallet (pre FEATURE_HD)
     LOCK(cs_wallet);
     return IsHDEnabled() || !CanSupportFeature(FEATURE_HD);
 }
 
 bool CWallet::CanGetAddresses(bool internal) {
     LOCK(cs_wallet);
     // Check if the keypool has keys
     bool keypool_has_keys;
     if (internal && CanSupportFeature(FEATURE_HD_SPLIT)) {
         keypool_has_keys = setInternalKeyPool.size() > 0;
     } else {
         keypool_has_keys = KeypoolCountExternalKeys() > 0;
     }
     // If the keypool doesn't have keys, check if we can generate them
     if (!keypool_has_keys) {
         return CanGenerateKeys();
     }
     return keypool_has_keys;
 }
 
 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) {
     LOCK(cs_wallet);
     m_wallet_flags &= ~flag;
     if (!WalletBatch(*database).WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 }
 
 bool CWallet::IsWalletFlagSet(uint64_t flag) {
     return (m_wallet_flags & flag);
 }
 
 bool CWallet::SetWalletFlags(uint64_t overwriteFlags, bool memonly) {
     LOCK(cs_wallet);
     m_wallet_flags = overwriteFlags;
     if (((overwriteFlags & g_known_wallet_flags) >> 32) ^
         (overwriteFlags >> 32)) {
         // contains unknown non-tolerable wallet flags
         return false;
     }
     if (!memonly && !WalletBatch(*database).WriteWalletFlags(m_wallet_flags)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": writing wallet flags failed");
     }
 
     return true;
 }
 
 int64_t CWalletTx::GetTxTime() const {
     int64_t n = nTimeSmart;
     return n ? n : nTimeReceived;
 }
 
 // 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;
 
     if (!ProduceSignature(*this,
                           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;
 }
 
 int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                      const CWallet *wallet, bool use_max_sig) {
     std::vector<CTxOut> txouts;
     // Look up the inputs.  We should have already checked that this transaction
     // IsAllFromMe(ISMINE_SPENDABLE), so every input should already be in our
     // wallet, with a valid index into the vout array, and the ability to sign.
     for (auto &input : tx.vin) {
         const auto mi = wallet->mapWallet.find(input.prevout.GetTxId());
         if (mi == wallet->mapWallet.end()) {
             return -1;
         }
         assert(input.prevout.GetN() < mi->second.tx->vout.size());
         txouts.emplace_back(mi->second.tx->vout[input.prevout.GetN()]);
     }
     return CalculateMaximumSignedTxSize(tx, wallet, txouts, use_max_sig);
 }
 
 // txouts needs to be in the order of tx.vin
 int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                      const CWallet *wallet,
                                      const std::vector<CTxOut> &txouts,
                                      bool use_max_sig) {
     CMutableTransaction txNew(tx);
     if (!wallet->DummySignTx(txNew, txouts, use_max_sig)) {
         // This should never happen, because IsAllFromMe(ISMINE_SPENDABLE)
         // implies that we can sign for every input.
         return -1;
     }
     return GetSerializeSize(txNew, PROTOCOL_VERSION);
 }
 
 int CalculateMaximumSignedInputSize(const CTxOut &txout, const CWallet *wallet,
                                     bool use_max_sig) {
     CMutableTransaction txn;
     txn.vin.push_back(CTxIn(COutPoint()));
     if (!wallet->DummySignInput(txn.vin[0], txout, use_max_sig)) {
         // This should never happen, because IsAllFromMe(ISMINE_SPENDABLE)
         // implies that we can sign for every input.
         return -1;
     }
     return GetSerializeSize(txn.vin[0], PROTOCOL_VERSION);
 }
 
 void CWalletTx::GetAmounts(std::list<COutputEntry> &listReceived,
                            std::list<COutputEntry> &listSent, Amount &nFee,
                            const isminefilter &filter) const {
     nFee = Amount::zero();
     listReceived.clear();
     listSent.clear();
 
     // Compute fee:
     Amount nDebit = GetDebit(filter);
     // debit>0 means we signed/sent this transaction.
     if (nDebit > Amount::zero()) {
         Amount nValueOut = tx->GetValueOut();
         nFee = (nDebit - nValueOut);
     }
 
     // Sent/received.
     for (unsigned int i = 0; i < tx->vout.size(); ++i) {
         const CTxOut &txout = tx->vout[i];
         isminetype fIsMine = pwallet->IsMine(txout);
         // Only need to handle txouts if AT LEAST one of these is true:
         //   1) they debit from us (sent)
         //   2) the output is to us (received)
         if (nDebit > Amount::zero()) {
             // Don't report 'change' txouts
             if (pwallet->IsChange(txout)) {
                 continue;
             }
         } else if (!(fIsMine & filter)) {
             continue;
         }
 
         // In either case, we need to get the destination address.
         CTxDestination address;
 
         if (!ExtractDestination(txout.scriptPubKey, address) &&
             !txout.scriptPubKey.IsUnspendable()) {
             pwallet->WalletLogPrintf("CWalletTx::GetAmounts: Unknown "
                                      "transaction type found, txid %s\n",
                                      this->GetId().ToString());
             address = CNoDestination();
         }
 
         COutputEntry output = {address, txout.nValue, (int)i};
 
         // If we are debited by the transaction, add the output as a "sent"
         // entry.
         if (nDebit > Amount::zero()) {
             listSent.push_back(output);
         }
 
         // If we are receiving the output, add it as a "received" entry.
         if (fIsMine & filter) {
             listReceived.push_back(output);
         }
     }
 }
 
 /**
  * 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.
     BlockHash start_block;
     {
         auto locked_chain = chain().lock();
         const Optional<int> start_height = locked_chain->findFirstBlockWithTime(
             startTime - TIMESTAMP_WINDOW, &start_block);
         const Optional<int> tip_height = locked_chain->getHeight();
         WalletLogPrintf(
             "%s: Rescanning last %i blocks\n", __func__,
             tip_height && start_height ? *tip_height - *start_height + 1 : 0);
     }
 
     if (!start_block.IsNull()) {
         // TODO: this should take into account failure by ScanResult::USER_ABORT
         ScanResult result = ScanForWalletTransactions(start_block, BlockHash(),
                                                       reserver, update);
         if (result.status == ScanResult::FAILURE) {
             int64_t time_max;
             if (!chain().findBlock(result.failed_block, nullptr /* block */,
                                    nullptr /* time */, &time_max)) {
                 throw std::logic_error(
                     "ScanForWalletTransactions returned invalid block hash");
             }
             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 if not null, the scan will start at this block instead
  *            of the genesis block
  * @param[in] stop_block if not null, the scan will stop at this block instead
  *            of the chain tip
  *
  * @return ScanResult indicating success or failure of the scan. 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, const BlockHash &stop_block,
     const WalletRescanReserver &reserver, bool fUpdate) {
     int64_t nNow = GetTime();
 
     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..."), GetDisplayName()),
                      0);
         BlockHash tip_hash;
         // The way the 'block_height' is initialized is just a workaround for
         // the gcc bug #47679 since version 4.6.0.
         Optional<int> block_height = MakeOptional(false, int());
         double progress_begin;
         double progress_end;
         {
             auto locked_chain = chain().lock();
             if (Optional<int> tip_height = locked_chain->getHeight()) {
                 tip_hash = locked_chain->getBlockHash(*tip_height);
             }
             block_height = locked_chain->getBlockHeight(block_hash);
             progress_begin = chain().guessVerificationProgress(block_hash);
             progress_end = chain().guessVerificationProgress(
                 stop_block.IsNull() ? tip_hash : stop_block);
         }
         double progress_current = progress_begin;
         while (block_height && !fAbortRescan && !ShutdownRequested()) {
             if (*block_height % 100 == 0 &&
                 progress_end - progress_begin > 0.0) {
                 ShowProgress(
                     strprintf("%s " + _("Rescanning..."), GetDisplayName()),
                     std::max(
                         1,
                         std::min(99, (int)((progress_current - progress_begin) /
                                            (progress_end - progress_begin) *
                                            100))));
             }
             if (GetTime() >= nNow + 60) {
                 nNow = GetTime();
                 WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n",
                                 *block_height, progress_current);
             }
 
             CBlock block;
             if (chain().findBlock(block_hash, &block) && !block.IsNull()) {
                 auto locked_chain = chain().lock();
                 LOCK(cs_wallet);
                 if (!locked_chain->getBlockHeight(block_hash)) {
                     // Abort scan if current block is no longer active, to
                     // prevent marking transactions as coming from the wrong
                     // block.
                     // TODO: This should return success instead of failure, see
                     // https://github.com/bitcoin/bitcoin/pull/14711#issuecomment-458342518
                     result.failed_block = block_hash;
                     result.status = ScanResult::FAILURE;
                     break;
                 }
                 for (size_t posInBlock = 0; posInBlock < block.vtx.size();
                      ++posInBlock) {
                     SyncTransaction(block.vtx[posInBlock], block_hash,
                                     posInBlock, fUpdate);
                 }
                 // scan succeeded, record block as most recent successfully
                 // scanned
                 result.stop_block = block_hash;
                 result.stop_height = *block_height;
             } else {
                 // could not scan block, keep scanning but record this block as
                 // the most recent failure
                 result.failed_block = block_hash;
                 result.status = ScanResult::FAILURE;
             }
             if (block_hash == stop_block) {
                 break;
             }
             {
                 auto locked_chain = chain().lock();
                 Optional<int> tip_height = locked_chain->getHeight();
                 if (!tip_height || *tip_height <= block_height ||
                     !locked_chain->getBlockHeight(block_hash)) {
                     // 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 = locked_chain->getBlockHash(++*block_height);
                 progress_current =
                     chain().guessVerificationProgress(block_hash);
 
                 // handle updated tip hash
                 const BlockHash prev_tip_hash = tip_hash;
                 tip_hash = locked_chain->getBlockHash(*tip_height);
                 if (stop_block.IsNull() && 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..."), GetDisplayName()),
                      100);
         if (block_height && fAbortRescan) {
             WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n",
                             block_height.value_or(0), progress_current);
             result.status = ScanResult::USER_ABORT;
         } else if (block_height && ShutdownRequested()) {
             WalletLogPrintf("Rescan interrupted by shutdown request at block "
                             "%d. Progress=%f\n",
                             block_height.value_or(0), progress_current);
             result.status = ScanResult::USER_ABORT;
         }
     }
 
     return result;
 }
 
 void CWallet::ReacceptWalletTransactions() {
     // If transactions aren't being broadcasted, don't let them into local
     // mempool either.
     if (!fBroadcastTransactions) {
         return;
     }
 
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
     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 = wtx.GetDepthInMainChain(*locked_chain);
 
         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);
         CValidationState state;
         wtx.AcceptToMemoryPool(*locked_chain, maxTxFee, state);
     }
 }
 
 bool CWalletTx::RelayWalletTransaction(interfaces::Chain::Lock &locked_chain,
                                        CConnman *connman) {
     assert(pwallet->GetBroadcastTransactions());
     if (IsCoinBase() || isAbandoned() ||
         GetDepthInMainChain(locked_chain) != 0) {
         return false;
     }
 
     CValidationState state;
     // GetDepthInMainChain already catches known conflicts.
     if (InMempool() || AcceptToMemoryPool(locked_chain, maxTxFee, state)) {
         pwallet->WalletLogPrintf("Relaying wtx %s\n", GetId().ToString());
         if (connman) {
             CInv inv(MSG_TX, GetId());
             connman->ForEachNode(
                 [&inv](CNode *pnode) { pnode->PushInventory(inv); });
             return true;
         }
     }
 
     return false;
 }
 
 std::set<TxId> CWalletTx::GetConflicts() const {
     std::set<TxId> result;
     if (pwallet != nullptr) {
         const TxId &txid = GetId();
         result = pwallet->GetConflicts(txid);
         result.erase(txid);
     }
 
     return result;
 }
 
 Amount CWalletTx::GetDebit(const isminefilter &filter) const {
     if (tx->vin.empty()) {
         return Amount::zero();
     }
 
     Amount debit = Amount::zero();
     if (filter & ISMINE_SPENDABLE) {
         if (fDebitCached) {
             debit += nDebitCached;
         } else {
             nDebitCached = pwallet->GetDebit(*tx, ISMINE_SPENDABLE);
             fDebitCached = true;
             debit += nDebitCached;
         }
     }
 
     if (filter & ISMINE_WATCH_ONLY) {
         if (fWatchDebitCached) {
             debit += nWatchDebitCached;
         } else {
             nWatchDebitCached = pwallet->GetDebit(*tx, ISMINE_WATCH_ONLY);
             fWatchDebitCached = true;
             debit += Amount(nWatchDebitCached);
         }
     }
 
     return debit;
 }
 
 Amount CWalletTx::GetCredit(interfaces::Chain::Lock &locked_chain,
                             const isminefilter &filter) const {
     // Must wait until coinbase is safely deep enough in the chain before
     // valuing it.
     if (IsImmatureCoinBase(locked_chain)) {
         return Amount::zero();
     }
 
     Amount credit = Amount::zero();
     if (filter & ISMINE_SPENDABLE) {
         // GetBalance can assume transactions in mapWallet won't change.
         if (fCreditCached) {
             credit += nCreditCached;
         } else {
             nCreditCached = pwallet->GetCredit(*tx, ISMINE_SPENDABLE);
             fCreditCached = true;
             credit += nCreditCached;
         }
     }
 
     if (filter & ISMINE_WATCH_ONLY) {
         if (fWatchCreditCached) {
             credit += nWatchCreditCached;
         } else {
             nWatchCreditCached = pwallet->GetCredit(*tx, ISMINE_WATCH_ONLY);
             fWatchCreditCached = true;
             credit += nWatchCreditCached;
         }
     }
 
     return credit;
 }
 
 Amount CWalletTx::GetImmatureCredit(interfaces::Chain::Lock &locked_chain,
                                     bool fUseCache) const {
     if (IsImmatureCoinBase(locked_chain) && IsInMainChain(locked_chain)) {
         if (fUseCache && fImmatureCreditCached) {
             return nImmatureCreditCached;
         }
 
         nImmatureCreditCached = pwallet->GetCredit(*tx, ISMINE_SPENDABLE);
         fImmatureCreditCached = true;
         return nImmatureCreditCached;
     }
 
     return Amount::zero();
 }
 
 Amount CWalletTx::GetAvailableCredit(interfaces::Chain::Lock &locked_chain,
                                      bool fUseCache,
                                      const isminefilter &filter) const {
     if (pwallet == nullptr) {
         return Amount::zero();
     }
 
     // Must wait until coinbase is safely deep enough in the chain before
     // valuing it.
     if (IsImmatureCoinBase(locked_chain)) {
         return Amount::zero();
     }
 
     Amount *cache = nullptr;
     bool *cache_used = nullptr;
 
     if (filter == ISMINE_SPENDABLE) {
         cache = &nAvailableCreditCached;
         cache_used = &fAvailableCreditCached;
     } else if (filter == ISMINE_WATCH_ONLY) {
         cache = &nAvailableWatchCreditCached;
         cache_used = &fAvailableWatchCreditCached;
     }
 
     if (fUseCache && cache_used && *cache_used) {
         return *cache;
     }
 
     Amount nCredit = Amount::zero();
     const TxId &txid = GetId();
     for (uint32_t i = 0; i < tx->vout.size(); i++) {
         if (!pwallet->IsSpent(locked_chain, COutPoint(txid, i))) {
             const CTxOut &txout = tx->vout[i];
             nCredit += pwallet->GetCredit(txout, filter);
             if (!MoneyRange(nCredit)) {
                 throw std::runtime_error(std::string(__func__) +
                                          " : value out of range");
             }
         }
     }
 
     if (cache) {
         *cache = nCredit;
         *cache_used = true;
     }
     return nCredit;
 }
 
 Amount
 CWalletTx::GetImmatureWatchOnlyCredit(interfaces::Chain::Lock &locked_chain,
                                       const bool fUseCache) const {
     if (IsImmatureCoinBase(locked_chain) && IsInMainChain(locked_chain)) {
         if (fUseCache && fImmatureWatchCreditCached) {
             return nImmatureWatchCreditCached;
         }
 
         nImmatureWatchCreditCached = pwallet->GetCredit(*tx, ISMINE_WATCH_ONLY);
         fImmatureWatchCreditCached = true;
         return nImmatureWatchCreditCached;
     }
 
     return Amount::zero();
 }
 
 Amount CWalletTx::GetChange() const {
     if (fChangeCached) {
         return nChangeCached;
     }
 
     nChangeCached = pwallet->GetChange(*tx);
     fChangeCached = true;
     return nChangeCached;
 }
 
 bool CWalletTx::InMempool() const {
     return fInMempool;
 }
 
 bool CWalletTx::IsTrusted(interfaces::Chain::Lock &locked_chain) const {
     // Temporary, for CheckFinalTx below. Removed in upcoming commit.
     LockAnnotation lock(::cs_main);
 
     // Quick answer in most cases
     if (!CheckFinalTx(*tx)) {
         return false;
     }
 
     int nDepth = GetDepthInMainChain(locked_chain);
     if (nDepth >= 1) {
         return true;
     }
 
     if (nDepth < 0) {
         return false;
     }
 
     // using wtx's cached debit
     if (!pwallet->m_spend_zero_conf_change || !IsFromMe(ISMINE_ALL)) {
         return false;
     }
 
     // Don't trust unconfirmed transactions from us unless they are in the
     // mempool.
     if (!InMempool()) {
         return false;
     }
 
     // Trusted if all inputs are from us and are in the mempool:
     for (const CTxIn &txin : tx->vin) {
         // Transactions not sent by us: not trusted
         const CWalletTx *parent = pwallet->GetWalletTx(txin.prevout.GetTxId());
         if (parent == nullptr) {
             return false;
         }
 
         const CTxOut &parentOut = parent->tx->vout[txin.prevout.GetN()];
         if (pwallet->IsMine(parentOut) != ISMINE_SPENDABLE) {
             return false;
         }
     }
 
     return true;
 }
 
 bool CWalletTx::IsEquivalentTo(const CWalletTx &_tx) const {
     CMutableTransaction tx1{*this->tx};
     CMutableTransaction tx2{*_tx.tx};
     for (auto &txin : tx1.vin) {
         txin.scriptSig = CScript();
     }
 
     for (auto &txin : tx2.vin) {
         txin.scriptSig = CScript();
     }
 
     return CTransaction(tx1) == CTransaction(tx2);
 }
 
 std::vector<uint256>
 CWallet::ResendWalletTransactionsBefore(interfaces::Chain::Lock &locked_chain,
                                         int64_t nTime, CConnman *connman) {
     std::vector<uint256> result;
 
     LOCK(cs_wallet);
 
     // Sort them in chronological order
     std::multimap<unsigned int, CWalletTx *> mapSorted;
     for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
         CWalletTx &wtx = item.second;
         // Don't rebroadcast if newer than nTime:
         if (wtx.nTimeReceived > nTime) {
             continue;
         }
 
         mapSorted.insert(std::make_pair(wtx.nTimeReceived, &wtx));
     }
 
     for (const std::pair<const unsigned int, CWalletTx *> &item : mapSorted) {
         CWalletTx &wtx = *item.second;
         if (wtx.RelayWalletTransaction(locked_chain, connman)) {
             result.push_back(wtx.GetId());
         }
     }
 
     return result;
 }
 
 void CWallet::ResendWalletTransactions(int64_t nBestBlockTime,
                                        CConnman *connman) {
     // Do this infrequently and randomly to avoid giving away that these are our
     // transactions.
     if (GetTime() < nNextResend || !fBroadcastTransactions) {
         return;
     }
 
     bool fFirst = (nNextResend == 0);
     nNextResend = GetTime() + GetRand(30 * 60);
     if (fFirst) {
         return;
     }
 
     // Only do it if there's been a new block since last time
     if (nBestBlockTime < nLastResend) {
         return;
     }
 
     nLastResend = GetTime();
 
     // Temporary. Removed in upcoming lock cleanup
     auto locked_chain = chain().assumeLocked();
     // Rebroadcast unconfirmed txes older than 5 minutes before the last block
     // was found:
     std::vector<uint256> relayed = ResendWalletTransactionsBefore(
         *locked_chain, nBestBlockTime - 5 * 60, connman);
     if (!relayed.empty()) {
         WalletLogPrintf("%s: rebroadcast %u unconfirmed transactions\n",
                         __func__, relayed.size());
     }
 }
 
 /** @} */ // end of mapWallet
 
 /**
  * @defgroup Actions
  *
  * @{
  */
 Amount CWallet::GetBalance(const isminefilter &filter,
                            const int min_depth) const {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     Amount nTotal = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx *pcoin = &entry.second;
         if (pcoin->IsTrusted(*locked_chain) &&
             pcoin->GetDepthInMainChain(*locked_chain) >= min_depth) {
             nTotal += pcoin->GetAvailableCredit(*locked_chain, true, filter);
         }
     }
 
     return nTotal;
 }
 
 Amount CWallet::GetUnconfirmedBalance() const {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     Amount nTotal = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx *pcoin = &entry.second;
         if (!pcoin->IsTrusted(*locked_chain) &&
             pcoin->GetDepthInMainChain(*locked_chain) == 0 &&
             pcoin->InMempool()) {
             nTotal += pcoin->GetAvailableCredit(*locked_chain);
         }
     }
 
     return nTotal;
 }
 
 Amount CWallet::GetImmatureBalance() const {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     Amount nTotal = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx *pcoin = &entry.second;
         nTotal += pcoin->GetImmatureCredit(*locked_chain);
     }
 
     return nTotal;
 }
 
 Amount CWallet::GetUnconfirmedWatchOnlyBalance() const {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     Amount nTotal = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx *pcoin = &entry.second;
         if (!pcoin->IsTrusted(*locked_chain) &&
             pcoin->GetDepthInMainChain(*locked_chain) == 0 &&
             pcoin->InMempool()) {
             nTotal += pcoin->GetAvailableCredit(*locked_chain, true,
                                                 ISMINE_WATCH_ONLY);
         }
     }
 
     return nTotal;
 }
 
 Amount CWallet::GetImmatureWatchOnlyBalance() const {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     Amount nTotal = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx *pcoin = &entry.second;
         nTotal += pcoin->GetImmatureWatchOnlyCredit(*locked_chain);
     }
 
     return nTotal;
 }
 
 // Calculate total balance in a different way from GetBalance. The biggest
 // difference is that GetBalance sums up all unspent TxOuts paying to the
 // wallet, while this sums up both spent and unspent TxOuts paying to the
 // wallet, and then subtracts the values of TxIns spending from the wallet. This
 // also has fewer restrictions on which unconfirmed transactions are considered
 // trusted.
 Amount CWallet::GetLegacyBalance(const isminefilter &filter,
                                  int minDepth) const {
     // Temporary, for CheckFinalTx below. Removed in upcoming commit.
     LockAnnotation lock(::cs_main);
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     Amount balance = Amount::zero();
     for (const auto &entry : mapWallet) {
         const CWalletTx &wtx = entry.second;
         const int depth = wtx.GetDepthInMainChain(*locked_chain);
         if (depth < 0 || !CheckFinalTx(*wtx.tx) ||
             wtx.IsImmatureCoinBase(*locked_chain)) {
             continue;
         }
 
         // Loop through tx outputs and add incoming payments. For outgoing txs,
         // treat change outputs specially, as part of the amount debited.
         Amount debit = wtx.GetDebit(filter);
         const bool outgoing = debit > Amount::zero();
         for (const CTxOut &out : wtx.tx->vout) {
             if (outgoing && IsChange(out)) {
                 debit -= out.nValue;
             } else if (IsMine(out) & filter && depth >= minDepth) {
                 balance += out.nValue;
             }
         }
 
         // For outgoing txs, subtract amount debited.
         if (outgoing) {
             balance -= debit;
         }
     }
 
     return balance;
 }
 
 Amount CWallet::GetAvailableBalance(const CCoinControl *coinControl) const {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     Amount balance = Amount::zero();
     std::vector<COutput> vCoins;
     AvailableCoins(*locked_chain, vCoins, true, coinControl);
     for (const COutput &out : vCoins) {
         if (out.fSpendable) {
             balance += out.tx->tx->vout[out.i].nValue;
         }
     }
     return balance;
 }
 
 void CWallet::AvailableCoins(interfaces::Chain::Lock &locked_chain,
                              std::vector<COutput> &vCoins, bool fOnlySafe,
                              const CCoinControl *coinControl,
                              const Amount nMinimumAmount,
                              const Amount nMaximumAmount,
                              const Amount nMinimumSumAmount,
                              const uint64_t nMaximumCount, const int nMinDepth,
                              const int nMaxDepth) const {
     AssertLockHeld(cs_main);
     AssertLockHeld(cs_wallet);
 
     vCoins.clear();
     Amount nTotal = Amount::zero();
 
     for (const auto &entry : mapWallet) {
         const TxId &wtxid = entry.first;
         const CWalletTx *pcoin = &entry.second;
 
         if (!CheckFinalTx(*pcoin->tx)) {
             continue;
         }
 
         if (pcoin->IsImmatureCoinBase(locked_chain)) {
             continue;
         }
 
         int nDepth = pcoin->GetDepthInMainChain(locked_chain);
         if (nDepth < 0) {
             continue;
         }
 
         // We should not consider coins which aren't at least in our mempool.
         // It's possible for these to be conflicted via ancestors which we may
         // never be able to detect.
         if (nDepth == 0 && !pcoin->InMempool()) {
             continue;
         }
 
         bool safeTx = pcoin->IsTrusted(locked_chain);
 
         // Bitcoin-ABC: Removed check that prevents consideration of coins from
         // transactions that are replacing other transactions. This check based
         // on pcoin->mapValue.count("replaces_txid") which was not being set
         // anywhere.
 
         // Similarly, we should not consider coins from transactions that have
         // been replaced. In the example above, we would want to prevent
         // creation of a transaction A' spending an output of A, because if
         // transaction B were initially confirmed, conflicting with A and A', we
         // wouldn't want to the user to create a transaction D intending to
         // replace A', but potentially resulting in a scenario where A, A', and
         // D could all be accepted (instead of just B and D, or just A and A'
         // like the user would want).
 
         // Bitcoin-ABC: retained this check as 'replaced_by_txid' is still set
         // in the wallet code.
         if (nDepth == 0 && pcoin->mapValue.count("replaced_by_txid")) {
             safeTx = false;
         }
 
         if (fOnlySafe && !safeTx) {
             continue;
         }
 
         if (nDepth < nMinDepth || nDepth > nMaxDepth) {
             continue;
         }
 
         for (uint32_t i = 0; i < pcoin->tx->vout.size(); i++) {
             if (pcoin->tx->vout[i].nValue < nMinimumAmount ||
                 pcoin->tx->vout[i].nValue > nMaximumAmount) {
                 continue;
             }
 
             const COutPoint outpoint(wtxid, i);
 
             if (coinControl && coinControl->HasSelected() &&
                 !coinControl->fAllowOtherInputs &&
                 !coinControl->IsSelected(outpoint)) {
                 continue;
             }
 
             if (IsLockedCoin(outpoint)) {
                 continue;
             }
 
             if (IsSpent(locked_chain, outpoint)) {
                 continue;
             }
 
             isminetype mine = IsMine(pcoin->tx->vout[i]);
 
             if (mine == ISMINE_NO) {
                 continue;
             }
 
             bool solvable = IsSolvable(*this, pcoin->tx->vout[i].scriptPubKey);
             bool spendable =
                 ((mine & ISMINE_SPENDABLE) != ISMINE_NO) ||
                 (((mine & ISMINE_WATCH_ONLY) != ISMINE_NO) &&
                  (coinControl && coinControl->fAllowWatchOnly && solvable));
 
             vCoins.push_back(
                 COutput(pcoin, i, nDepth, spendable, solvable, safeTx,
                         (coinControl && coinControl->fAllowWatchOnly)));
 
             // Checks the sum amount of all UTXO's.
             if (nMinimumSumAmount != MAX_MONEY) {
                 nTotal += pcoin->tx->vout[i].nValue;
 
                 if (nTotal >= nMinimumSumAmount) {
                     return;
                 }
             }
 
             // Checks the maximum number of UTXO's.
             if (nMaximumCount > 0 && vCoins.size() >= nMaximumCount) {
                 return;
             }
         }
     }
 }
 
 std::map<CTxDestination, std::vector<COutput>>
 CWallet::ListCoins(interfaces::Chain::Lock &locked_chain) const {
     AssertLockHeld(cs_main);
     AssertLockHeld(cs_wallet);
 
     std::map<CTxDestination, std::vector<COutput>> result;
     std::vector<COutput> availableCoins;
 
     AvailableCoins(locked_chain, availableCoins);
 
     for (const auto &coin : availableCoins) {
         CTxDestination address;
         if (coin.fSpendable &&
             ExtractDestination(
                 FindNonChangeParentOutput(*coin.tx->tx, coin.i).scriptPubKey,
                 address)) {
             result[address].emplace_back(std::move(coin));
         }
     }
 
     std::vector<COutPoint> lockedCoins;
     ListLockedCoins(lockedCoins);
     for (const auto &output : lockedCoins) {
         auto it = mapWallet.find(output.GetTxId());
         if (it != mapWallet.end()) {
             int depth = it->second.GetDepthInMainChain(locked_chain);
             if (depth >= 0 && output.GetN() < it->second.tx->vout.size() &&
                 IsMine(it->second.tx->vout[output.GetN()]) ==
                     ISMINE_SPENDABLE) {
                 CTxDestination address;
                 if (ExtractDestination(
                         FindNonChangeParentOutput(*it->second.tx, output.GetN())
                             .scriptPubKey,
                         address)) {
                     result[address].emplace_back(
                         &it->second, output.GetN(), depth, true /* spendable */,
                         true /* solvable */, false /* safe */);
                 }
             }
         }
     }
 
     return result;
 }
 
 const CTxOut &CWallet::FindNonChangeParentOutput(const CTransaction &tx,
                                                  int output) const {
     const CTransaction *ptx = &tx;
     int n = output;
     while (IsChange(ptx->vout[n]) && ptx->vin.size() > 0) {
         const COutPoint &prevout = ptx->vin[0].prevout;
         auto it = mapWallet.find(prevout.GetTxId());
         if (it == mapWallet.end() ||
             it->second.tx->vout.size() <= prevout.GetN() ||
             !IsMine(it->second.tx->vout[prevout.GetN()])) {
             break;
         }
         ptx = it->second.tx.get();
         n = prevout.GetN();
     }
     return ptx->vout[n];
 }
 
 bool CWallet::SelectCoinsMinConf(
     const Amount nTargetValue, const CoinEligibilityFilter &eligibility_filter,
     std::vector<OutputGroup> groups, std::set<CInputCoin> &setCoinsRet,
     Amount &nValueRet, const CoinSelectionParams &coin_selection_params,
     bool &bnb_used) const {
     setCoinsRet.clear();
     nValueRet = Amount::zero();
 
     std::vector<OutputGroup> utxo_pool;
     if (coin_selection_params.use_bnb) {
         // Get long term estimate
         CCoinControl temp;
         temp.m_confirm_target = 1008;
         CFeeRate long_term_feerate = GetMinimumFeeRate(*this, temp, g_mempool);
 
         // Calculate cost of change
         Amount cost_of_change =
             dustRelayFee.GetFee(coin_selection_params.change_spend_size) +
             coin_selection_params.effective_fee.GetFee(
                 coin_selection_params.change_output_size);
 
         // Filter by the min conf specs and add to utxo_pool and calculate
         // effective value
         for (OutputGroup &group : groups) {
             if (!group.EligibleForSpending(eligibility_filter)) {
                 continue;
             }
 
             group.fee = Amount::zero();
             group.long_term_fee = Amount::zero();
             group.effective_value = Amount::zero();
             for (auto it = group.m_outputs.begin();
                  it != group.m_outputs.end();) {
                 const CInputCoin &coin = *it;
                 Amount effective_value =
                     coin.txout.nValue -
                     (coin.m_input_bytes < 0
                          ? Amount::zero()
                          : coin_selection_params.effective_fee.GetFee(
                                coin.m_input_bytes));
                 // Only include outputs that are positive effective value (i.e.
                 // not dust)
                 if (effective_value > Amount::zero()) {
                     group.fee +=
                         coin.m_input_bytes < 0
                             ? Amount::zero()
                             : coin_selection_params.effective_fee.GetFee(
                                   coin.m_input_bytes);
                     group.long_term_fee +=
                         coin.m_input_bytes < 0
                             ? Amount::zero()
                             : long_term_feerate.GetFee(coin.m_input_bytes);
                     group.effective_value += effective_value;
                     ++it;
                 } else {
                     it = group.Discard(coin);
                 }
             }
             if (group.effective_value > Amount::zero()) {
                 utxo_pool.push_back(group);
             }
         }
         // Calculate the fees for things that aren't inputs
         Amount not_input_fees = coin_selection_params.effective_fee.GetFee(
             coin_selection_params.tx_noinputs_size);
         bnb_used = true;
         return SelectCoinsBnB(utxo_pool, nTargetValue, cost_of_change,
                               setCoinsRet, nValueRet, not_input_fees);
     } else {
         // Filter by the min conf specs and add to utxo_pool
         for (const OutputGroup &group : groups) {
             if (!group.EligibleForSpending(eligibility_filter)) {
                 continue;
             }
             utxo_pool.push_back(group);
         }
         bnb_used = false;
         return KnapsackSolver(nTargetValue, utxo_pool, setCoinsRet, nValueRet);
     }
 }
 
 bool CWallet::SelectCoins(const std::vector<COutput> &vAvailableCoins,
                           const Amount nTargetValue,
                           std::set<CInputCoin> &setCoinsRet, Amount &nValueRet,
                           const CCoinControl &coin_control,
                           CoinSelectionParams &coin_selection_params,
                           bool &bnb_used) const {
     std::vector<COutput> vCoins(vAvailableCoins);
 
     // coin control -> return all selected outputs (we want all selected to go
     // into the transaction for sure)
     if (coin_control.HasSelected() && !coin_control.fAllowOtherInputs) {
         // We didn't use BnB here, so set it to false.
         bnb_used = false;
 
         for (const COutput &out : vCoins) {
             if (!out.fSpendable) {
                 continue;
             }
 
             nValueRet += out.tx->tx->vout[out.i].nValue;
             setCoinsRet.insert(out.GetInputCoin());
         }
 
         return (nValueRet >= nTargetValue);
     }
 
     // Calculate value from preset inputs and store them.
     std::set<CInputCoin> setPresetCoins;
     Amount nValueFromPresetInputs = Amount::zero();
 
     std::vector<COutPoint> vPresetInputs;
     coin_control.ListSelected(vPresetInputs);
 
     for (const COutPoint &outpoint : vPresetInputs) {
         // For now, don't use BnB if preset inputs are selected. TODO: Enable
         // this later
         bnb_used = false;
         coin_selection_params.use_bnb = false;
 
         std::map<TxId, CWalletTx>::const_iterator it =
             mapWallet.find(outpoint.GetTxId());
         if (it == mapWallet.end()) {
             // TODO: Allow non-wallet inputs
             return false;
         }
 
         const CWalletTx *pcoin = &it->second;
         // Clearly invalid input, fail.
         if (pcoin->tx->vout.size() <= outpoint.GetN()) {
             return false;
         }
 
         // Just to calculate the marginal byte size
         nValueFromPresetInputs += pcoin->tx->vout[outpoint.GetN()].nValue;
         setPresetCoins.insert(CInputCoin(pcoin->tx, outpoint.GetN()));
     }
 
     // Remove preset inputs from vCoins
     for (std::vector<COutput>::iterator it = vCoins.begin();
          it != vCoins.end() && coin_control.HasSelected();) {
         if (setPresetCoins.count(it->GetInputCoin())) {
             it = vCoins.erase(it);
         } else {
             ++it;
         }
     }
 
     // form groups from remaining coins; note that preset coins will not
     // automatically have their associated (same address) coins included
     if (coin_control.m_avoid_partial_spends &&
         vCoins.size() > OUTPUT_GROUP_MAX_ENTRIES) {
         // Cases where we have 11+ outputs all pointing to the same destination
         // may result in privacy leaks as they will potentially be
         // deterministically sorted. We solve that by explicitly shuffling the
         // outputs before processing
         Shuffle(vCoins.begin(), vCoins.end(), FastRandomContext());
     }
     std::vector<OutputGroup> groups =
         GroupOutputs(vCoins, !coin_control.m_avoid_partial_spends);
 
     size_t max_ancestors = std::max<size_t>(
         1, gArgs.GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT));
     size_t max_descendants = std::max<size_t>(
         1, gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT));
     bool fRejectLongChains = gArgs.GetBoolArg(
         "-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS);
 
     bool res =
         nTargetValue <= nValueFromPresetInputs ||
         SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                            CoinEligibilityFilter(1, 6, 0), groups, setCoinsRet,
                            nValueRet, coin_selection_params, bnb_used) ||
         SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                            CoinEligibilityFilter(1, 1, 0), groups, setCoinsRet,
                            nValueRet, coin_selection_params, bnb_used) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                             CoinEligibilityFilter(0, 1, 2), groups, setCoinsRet,
                             nValueRet, coin_selection_params, bnb_used)) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(
              nTargetValue - nValueFromPresetInputs,
              CoinEligibilityFilter(0, 1, std::min<size_t>(4, max_ancestors / 3),
                                    std::min<size_t>(4, max_descendants / 3)),
              groups, setCoinsRet, nValueRet, coin_selection_params,
              bnb_used)) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                             CoinEligibilityFilter(0, 1, max_ancestors / 2,
                                                   max_descendants / 2),
                             groups, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
         (m_spend_zero_conf_change &&
          SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs,
                             CoinEligibilityFilter(0, 1, max_ancestors - 1,
                                                   max_descendants - 1),
                             groups, setCoinsRet, nValueRet,
                             coin_selection_params, bnb_used)) ||
         (m_spend_zero_conf_change && !fRejectLongChains &&
          SelectCoinsMinConf(
              nTargetValue - nValueFromPresetInputs,
              CoinEligibilityFilter(0, 1, std::numeric_limits<uint64_t>::max()),
              groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
     // Because SelectCoinsMinConf clears the setCoinsRet, we now add the
     // possible inputs to the coinset.
     util::insert(setCoinsRet, setPresetCoins);
 
     // Add preset inputs to the total value selected.
     nValueRet += nValueFromPresetInputs;
 
     return res;
 }
 
 bool CWallet::SignTransaction(CMutableTransaction &tx) {
     // sign the new tx
     int nIn = 0;
     for (CTxIn &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 CScript &scriptPubKey =
             mi->second.tx->vout[input.prevout.GetN()].scriptPubKey;
         const Amount amount = mi->second.tx->vout[input.prevout.GetN()].nValue;
         SignatureData sigdata;
         SigHashType sigHashType = SigHashType().withForkId();
         if (!ProduceSignature(*this,
                               MutableTransactionSignatureCreator(
                                   &tx, nIn, amount, sigHashType),
                               scriptPubKey, sigdata)) {
             return false;
         }
         UpdateInput(input, sigdata);
         nIn++;
     }
     return true;
 }
 
 bool CWallet::FundTransaction(CMutableTransaction &tx, Amount &nFeeRet,
                               int &nChangePosInOut, std::string &strFailReason,
                               bool lockUnspents,
                               const std::set<int> &setSubtractFeeFromOutputs,
                               CCoinControl coinControl) {
     std::vector<CRecipient> vecSend;
 
     // Turn the txout set into a CRecipient vector.
     for (size_t idx = 0; idx < tx.vout.size(); idx++) {
         const CTxOut &txOut = tx.vout[idx];
         CRecipient recipient = {txOut.scriptPubKey, txOut.nValue,
                                 setSubtractFeeFromOutputs.count(idx) == 1};
         vecSend.push_back(recipient);
     }
 
     coinControl.fAllowOtherInputs = true;
 
     for (const CTxIn &txin : tx.vin) {
         coinControl.Select(txin.prevout);
     }
 
     // Acquire the locks to prevent races to the new locked unspents between the
     // CreateTransaction call and LockCoin calls (when lockUnspents is true).
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     CReserveKey reservekey(this);
     CTransactionRef tx_new;
     if (!CreateTransaction(*locked_chain, vecSend, tx_new, reservekey, nFeeRet,
                            nChangePosInOut, strFailReason, coinControl,
                            false)) {
         return false;
     }
 
     if (nChangePosInOut != -1) {
         tx.vout.insert(tx.vout.begin() + nChangePosInOut,
                        tx_new->vout[nChangePosInOut]);
         // We don't have the normal Create/Commit cycle, and don't want to
         // risk reusing change, so just remove the key from the keypool
         // here.
         reservekey.KeepKey();
     }
 
     // Copy output sizes from new transaction; they may have had the fee
     // subtracted from them.
     for (size_t idx = 0; idx < tx.vout.size(); idx++) {
         tx.vout[idx].nValue = tx_new->vout[idx].nValue;
     }
 
     // Add new txins (keeping original txin scriptSig/order)
     for (const CTxIn &txin : tx_new->vin) {
         if (!coinControl.IsSelected(txin.prevout)) {
             tx.vin.push_back(txin);
 
             if (lockUnspents) {
                 LockCoin(txin.prevout);
             }
         }
     }
 
     return true;
 }
 
 static bool IsCurrentForAntiFeeSniping(interfaces::Chain::Lock &locked_chain) {
     if (IsInitialBlockDownload()) {
         return false;
     }
 
     // in seconds
     constexpr int64_t MAX_ANTI_FEE_SNIPING_TIP_AGE = 8 * 60 * 60;
     if (ChainActive().Tip()->GetBlockTime() <
         (GetTime() - MAX_ANTI_FEE_SNIPING_TIP_AGE)) {
         return false;
     }
     return true;
 }
 
 /**
  * Return a height-based locktime for new transactions (uses the height of the
  * current chain tip unless we are not synced with the current chain
  */
 static uint32_t
 GetLocktimeForNewTransaction(interfaces::Chain::Lock &locked_chain) {
     uint32_t const height = locked_chain.getHeight().value_or(-1);
     uint32_t locktime;
     // Discourage fee sniping.
     //
     // For a large miner the value of the transactions in the best block and
     // the mempool can exceed the cost of deliberately attempting to mine two
     // blocks to orphan the current best block. By setting nLockTime such that
     // only the next block can include the transaction, we discourage this
     // practice as the height restricted and limited blocksize gives miners
     // considering fee sniping fewer options for pulling off this attack.
     //
     // A simple way to think about this is from the wallet's point of view we
     // always want the blockchain to move forward. By setting nLockTime this
     // way we're basically making the statement that we only want this
     // transaction to appear in the next block; we don't want to potentially
     // encourage reorgs by allowing transactions to appear at lower heights
     // than the next block in forks of the best chain.
     //
     // Of course, the subsidy is high enough, and transaction volume low
     // enough, that fee sniping isn't a problem yet, but by implementing a fix
     // now we ensure code won't be written that makes assumptions about
     // nLockTime that preclude a fix later.
     if (IsCurrentForAntiFeeSniping(locked_chain)) {
         locktime = height;
 
         // Secondly occasionally randomly pick a nLockTime even further back, so
         // that transactions that are delayed after signing for whatever reason,
         // e.g. high-latency mix networks and some CoinJoin implementations,
         // have better privacy.
         if (GetRandInt(10) == 0) {
             locktime = std::max(0, int(locktime) - GetRandInt(100));
         }
     } else {
         // If our chain is lagging behind, we can't discourage fee sniping nor
         // help the privacy of high-latency transactions. To avoid leaking a
         // potentially unique "nLockTime fingerprint", set nLockTime to a
         // constant.
         locktime = 0;
     }
     assert(locktime <= height);
     assert(locktime < LOCKTIME_THRESHOLD);
     return locktime;
 }
 
 OutputType
 CWallet::TransactionChangeType(OutputType change_type,
                                const std::vector<CRecipient> &vecSend) {
     // If -changetype is specified, always use that change type.
     if (change_type != OutputType::CHANGE_AUTO) {
         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;
 }
 
 bool CWallet::CreateTransaction(interfaces::Chain::Lock &locked_chainIn,
                                 const std::vector<CRecipient> &vecSend,
                                 CTransactionRef &tx, CReserveKey &reservekey,
                                 Amount &nFeeRet, int &nChangePosInOut,
                                 std::string &strFailReason,
                                 const CCoinControl &coinControl, bool sign) {
     Amount nValue = Amount::zero();
     int nChangePosRequest = nChangePosInOut;
     unsigned int nSubtractFeeFromAmount = 0;
     for (const auto &recipient : vecSend) {
         if (nValue < Amount::zero() || recipient.nAmount < Amount::zero()) {
             strFailReason = _("Transaction amounts must not be negative");
             return false;
         }
 
         nValue += recipient.nAmount;
 
         if (recipient.fSubtractFeeFromAmount) {
             nSubtractFeeFromAmount++;
         }
     }
 
     if (vecSend.empty()) {
         strFailReason = _("Transaction must have at least one recipient");
         return false;
     }
 
     CMutableTransaction txNew;
 
     txNew.nLockTime = GetLocktimeForNewTransaction(locked_chainIn);
 
     {
         std::set<CInputCoin> setCoins;
         auto locked_chain = chain().lock();
         LOCK(cs_wallet);
 
         std::vector<COutput> vAvailableCoins;
         AvailableCoins(*locked_chain, vAvailableCoins, true, &coinControl);
         // Parameters for coin selection, init with dummy
         CoinSelectionParams coin_selection_params;
 
         // Create change script that will be used if we need change
         // TODO: pass in scriptChange instead of reservekey so
         // change transaction isn't always pay-to-bitcoin-address
         CScript scriptChange;
 
         // coin control: send change to custom address
         if (!boost::get<CNoDestination>(&coinControl.destChange)) {
             scriptChange = GetScriptForDestination(coinControl.destChange);
 
             // no coin control: send change to newly generated address
         } else {
             // Note: We use a new key here to keep it from being obvious
             // which side is the change.
             //  The drawback is that by not reusing a previous key, the
             //  change may be lost if a backup is restored, if the backup
             //  doesn't have the new private key for the change. If we
             //  reused the old key, it would be possible to add code to look
             //  for and rediscover unknown transactions that were written
             //  with keys of ours to recover post-backup change.
 
             // Reserve a new key pair from key pool
             if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
                 strFailReason =
                     _("Can't generate a change-address key. Private keys "
                       "are disabled for this wallet.");
                 return false;
             }
             CPubKey vchPubKey;
             bool ret;
             ret = reservekey.GetReservedKey(vchPubKey, true);
             if (!ret) {
                 strFailReason =
                     _("Keypool ran out, please call keypoolrefill first");
                 return false;
             }
 
             const OutputType change_type = TransactionChangeType(
                 coinControl.m_change_type ? *coinControl.m_change_type
                                           : m_default_change_type,
                 vecSend);
 
             LearnRelatedScripts(vchPubKey, change_type);
             scriptChange = GetScriptForDestination(
                 GetDestinationForKey(vchPubKey, change_type));
         }
         CTxOut change_prototype_txout(Amount::zero(), scriptChange);
         coin_selection_params.change_output_size =
             GetSerializeSize(change_prototype_txout);
 
         // Get the fee rate to use effective values in coin selection
         CFeeRate nFeeRateNeeded =
             GetMinimumFeeRate(*this, coinControl, g_mempool);
 
         nFeeRet = Amount::zero();
         bool pick_new_inputs = true;
         Amount nValueIn = Amount::zero();
 
         // BnB selector is the only selector used when this is true.
         // That should only happen on the first pass through the loop.
         // If we are doing subtract fee from recipient, then don't use BnB
         coin_selection_params.use_bnb = nSubtractFeeFromAmount == 0;
         // Start with no fee and loop until there is enough fee
         while (true) {
             nChangePosInOut = nChangePosRequest;
             txNew.vin.clear();
             txNew.vout.clear();
             bool fFirst = true;
 
             Amount nValueToSelect = nValue;
             if (nSubtractFeeFromAmount == 0) {
                 nValueToSelect += nFeeRet;
             }
 
             // Static size overhead + outputs vsize. 4 nVersion, 4 nLocktime, 1
             // input count, 1 output count
             coin_selection_params.tx_noinputs_size = 10;
             // vouts to the payees
             for (const auto &recipient : vecSend) {
                 CTxOut txout(recipient.nAmount, recipient.scriptPubKey);
 
                 if (recipient.fSubtractFeeFromAmount) {
                     assert(nSubtractFeeFromAmount != 0);
                     // Subtract fee equally from each selected recipient.
                     txout.nValue -= nFeeRet / int(nSubtractFeeFromAmount);
 
                     // First receiver pays the remainder not divisible by output
                     // count.
                     if (fFirst) {
                         fFirst = false;
                         txout.nValue -= nFeeRet % int(nSubtractFeeFromAmount);
                     }
                 }
 
                 // Include the fee cost for outputs. Note this is only used for
                 // BnB right now
                 coin_selection_params.tx_noinputs_size +=
                     ::GetSerializeSize(txout, PROTOCOL_VERSION);
 
                 if (IsDust(txout, dustRelayFee)) {
                     if (recipient.fSubtractFeeFromAmount &&
                         nFeeRet > Amount::zero()) {
                         if (txout.nValue < Amount::zero()) {
                             strFailReason = _("The transaction amount is "
                                               "too small to pay the fee");
                         } else {
                             strFailReason =
                                 _("The transaction amount is too small to "
                                   "send after the fee has been deducted");
                         }
                     } else {
                         strFailReason = _("Transaction amount too small");
                     }
 
                     return false;
                 }
 
                 txNew.vout.push_back(txout);
             }
 
             // Choose coins to use
             bool bnb_used;
             if (pick_new_inputs) {
                 nValueIn = Amount::zero();
                 setCoins.clear();
                 coin_selection_params.change_spend_size =
                     CalculateMaximumSignedInputSize(change_prototype_txout,
                                                     this);
                 coin_selection_params.effective_fee = nFeeRateNeeded;
                 if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins,
                                  nValueIn, coinControl, coin_selection_params,
                                  bnb_used)) {
                     // If BnB was used, it was the first pass. No longer the
                     // first pass and continue loop with knapsack.
                     if (bnb_used) {
                         coin_selection_params.use_bnb = false;
                         continue;
                     } else {
                         strFailReason = _("Insufficient funds");
                         return false;
                     }
                 }
             }
 
             const Amount nChange = nValueIn - nValueToSelect;
             if (nChange > Amount::zero()) {
                 // Fill a vout to ourself.
                 CTxOut newTxOut(nChange, scriptChange);
 
                 // Never create dust outputs; if we would, just add the dust to
                 // the fee.
                 // The nChange when BnB is used is always going to go to fees.
                 if (IsDust(newTxOut, dustRelayFee) || bnb_used) {
                     nChangePosInOut = -1;
                     nFeeRet += nChange;
                 } else {
                     if (nChangePosInOut == -1) {
                         // Insert change txn at random position:
                         nChangePosInOut = GetRandInt(txNew.vout.size() + 1);
                     } else if ((unsigned int)nChangePosInOut >
                                txNew.vout.size()) {
                         strFailReason = _("Change index out of range");
                         return false;
                     }
 
                     std::vector<CTxOut>::iterator position =
                         txNew.vout.begin() + nChangePosInOut;
                     txNew.vout.insert(position, newTxOut);
                 }
             } else {
                 nChangePosInOut = -1;
             }
 
             // Dummy fill vin for maximum size estimation
             //
             for (const auto &coin : setCoins) {
                 txNew.vin.push_back(CTxIn(coin.outpoint, CScript()));
             }
 
             CTransaction txNewConst(txNew);
             int nBytes = CalculateMaximumSignedTxSize(
                 txNewConst, this, coinControl.fAllowWatchOnly);
             if (nBytes < 0) {
                 strFailReason = _("Signing transaction failed");
                 return false;
             }
 
             Amount nFeeNeeded =
                 GetMinimumFee(*this, nBytes, coinControl, g_mempool);
 
             // If we made it here and we aren't even able to meet the relay fee
             // on the next pass, give up because we must be at the maximum
             // allowed fee.
             if (nFeeNeeded < ::minRelayTxFee.GetFee(nBytes)) {
                 strFailReason = _("Transaction too large for fee policy");
                 return false;
             }
 
             if (nFeeRet >= nFeeNeeded) {
                 // Reduce fee to only the needed amount if possible. This
                 // prevents potential overpayment in fees if the coins selected
                 // to meet nFeeNeeded result in a transaction that requires less
                 // fee than the prior iteration.
 
                 // If we have no change and a big enough excess fee, then try to
                 // construct transaction again only without picking new inputs.
                 // We now know we only need the smaller fee (because of reduced
                 // tx size) and so we should add a change output. Only try this
                 // once.
                 if (nChangePosInOut == -1 && nSubtractFeeFromAmount == 0 &&
                     pick_new_inputs) {
                     // Add 2 as a buffer in case increasing # of outputs changes
                     // compact size
                     unsigned int tx_size_with_change =
                         nBytes + coin_selection_params.change_output_size + 2;
                     Amount fee_needed_with_change = GetMinimumFee(
                         *this, tx_size_with_change, coinControl, g_mempool);
                     Amount minimum_value_for_change =
                         GetDustThreshold(change_prototype_txout, dustRelayFee);
                     if (nFeeRet >=
                         fee_needed_with_change + minimum_value_for_change) {
                         pick_new_inputs = false;
                         nFeeRet = fee_needed_with_change;
                         continue;
                     }
                 }
 
                 // If we have change output already, just increase it
                 if (nFeeRet > nFeeNeeded && nChangePosInOut != -1 &&
                     nSubtractFeeFromAmount == 0) {
                     Amount extraFeePaid = nFeeRet - nFeeNeeded;
                     std::vector<CTxOut>::iterator change_position =
                         txNew.vout.begin() + nChangePosInOut;
                     change_position->nValue += extraFeePaid;
                     nFeeRet -= extraFeePaid;
                 }
 
                 // Done, enough fee included.
                 break;
             } else if (!pick_new_inputs) {
                 // This shouldn't happen, we should have had enough excess fee
                 // to pay for the new output and still meet nFeeNeeded.
                 // Or we should have just subtracted fee from recipients and
                 // nFeeNeeded should not have changed.
                 strFailReason =
                     _("Transaction fee and change calculation failed");
                 return false;
             }
 
             // Try to reduce change to include necessary fee.
             if (nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) {
                 Amount additionalFeeNeeded = nFeeNeeded - nFeeRet;
                 std::vector<CTxOut>::iterator change_position =
                     txNew.vout.begin() + nChangePosInOut;
                 // Only reduce change if remaining amount is still a large
                 // enough output.
                 if (change_position->nValue >=
                     MIN_FINAL_CHANGE + additionalFeeNeeded) {
                     change_position->nValue -= additionalFeeNeeded;
                     nFeeRet += additionalFeeNeeded;
                     // Done, able to increase fee from change.
                     break;
                 }
             }
 
             // If subtracting fee from recipients, we now know what fee we
             // need to subtract, we have no reason to reselect inputs.
             if (nSubtractFeeFromAmount > 0) {
                 pick_new_inputs = false;
             }
 
             // Include more fee and try again.
             nFeeRet = nFeeNeeded;
             coin_selection_params.use_bnb = false;
             continue;
         }
 
         if (nChangePosInOut == -1) {
             // Return any reserved key if we don't have change
             reservekey.ReturnKey();
         }
 
         // Shuffle selected coins and fill in final vin
         txNew.vin.clear();
         std::vector<CInputCoin> selected_coins(setCoins.begin(),
                                                setCoins.end());
         Shuffle(selected_coins.begin(), selected_coins.end(),
                 FastRandomContext());
 
         // Note how the sequence number is set to non-maxint so that
         // the nLockTime set above actually works.
         for (const auto &coin : selected_coins) {
             txNew.vin.push_back(
                 CTxIn(coin.outpoint, CScript(),
                       std::numeric_limits<uint32_t>::max() - 1));
         }
 
         if (sign) {
             SigHashType sigHashType = SigHashType().withForkId();
 
             int nIn = 0;
             for (const auto &coin : selected_coins) {
                 const CScript &scriptPubKey = coin.txout.scriptPubKey;
                 SignatureData sigdata;
 
                 if (!ProduceSignature(
                         *this,
                         MutableTransactionSignatureCreator(
                             &txNew, nIn, coin.txout.nValue, sigHashType),
                         scriptPubKey, sigdata)) {
                     strFailReason = _("Signing transaction failed");
                     return false;
                 }
 
                 UpdateInput(txNew.vin.at(nIn), sigdata);
                 nIn++;
             }
         }
 
         // Return the constructed transaction data.
         tx = MakeTransactionRef(std::move(txNew));
 
         // Limit size.
         if (tx->GetTotalSize() >= MAX_STANDARD_TX_SIZE) {
             strFailReason = _("Transaction too large");
             return false;
         }
     }
 
     if (gArgs.GetBoolArg("-walletrejectlongchains",
                          DEFAULT_WALLET_REJECT_LONG_CHAINS)) {
         // Lastly, ensure this tx will pass the mempool's chain limits.
         LockPoints lp;
         CTxMemPoolEntry entry(tx, Amount::zero(), 0, 0, false, 0, lp);
         CTxMemPool::setEntries setAncestors;
         size_t nLimitAncestors =
             gArgs.GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT);
         size_t nLimitAncestorSize =
             gArgs.GetArg("-limitancestorsize", DEFAULT_ANCESTOR_SIZE_LIMIT) *
             1000;
         size_t nLimitDescendants =
             gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT);
         size_t nLimitDescendantSize =
             gArgs.GetArg("-limitdescendantsize",
                          DEFAULT_DESCENDANT_SIZE_LIMIT) *
             1000;
         std::string errString;
         LOCK(::g_mempool.cs);
         if (!g_mempool.CalculateMemPoolAncestors(
                 entry, setAncestors, nLimitAncestors, nLimitAncestorSize,
                 nLimitDescendants, nLimitDescendantSize, errString)) {
             strFailReason = _("Transaction has too long of a mempool chain");
             return false;
         }
     }
 
     return true;
 }
 
 /**
  * Call after CreateTransaction unless you want to abort
  */
 bool CWallet::CommitTransaction(
     CTransactionRef tx, mapValue_t mapValue,
     std::vector<std::pair<std::string, std::string>> orderForm,
     CReserveKey &reservekey, CConnman *connman, CValidationState &state) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     CWalletTx wtxNew(this, std::move(tx));
     wtxNew.mapValue = std::move(mapValue);
     wtxNew.vOrderForm = std::move(orderForm);
     wtxNew.fTimeReceivedIsTxTime = true;
     wtxNew.fFromMe = true;
 
     WalletLogPrintfToBeContinued("CommitTransaction:\n%s",
                                  wtxNew.tx->ToString());
 
     // Take key pair from key pool so it won't be used again.
     reservekey.KeepKey();
 
     // Add tx to wallet, because if it has change it's also ours, otherwise just
     // for transaction history.
     AddToWallet(wtxNew);
 
     // Notify that old coins are spent.
     for (const CTxIn &txin : wtxNew.tx->vin) {
         CWalletTx &coin = mapWallet.at(txin.prevout.GetTxId());
         coin.BindWallet(this);
         NotifyTransactionChanged(this, coin.GetId(), CT_UPDATED);
     }
 
     // Get the inserted-CWalletTx from mapWallet so that the
     // fInMempool flag is cached properly
     CWalletTx &wtx = mapWallet.at(wtxNew.GetId());
 
     if (fBroadcastTransactions) {
         // Broadcast
         if (!wtx.AcceptToMemoryPool(*locked_chain, maxTxFee, state)) {
             WalletLogPrintf("CommitTransaction(): Transaction cannot be "
                             "broadcast immediately, %s\n",
                             FormatStateMessage(state));
             // TODO: if we expect the failure to be long term or permanent,
             // instead delete wtx from the wallet and return failure.
         } else {
             wtx.RelayWalletTransaction(*locked_chain, connman);
         }
     }
 
     return true;
 }
 
 DBErrors CWallet::LoadWallet(bool &fFirstRunRet) {
     auto locked_chain = chain().lock();
     LOCK(cs_wallet);
 
     fFirstRunRet = false;
     DBErrors nLoadWalletRet = WalletBatch(*database, "cr+").LoadWallet(this);
     if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             setInternalKeyPool.clear();
             setExternalKeyPool.clear();
             m_pool_key_to_index.clear();
             // Note: can't top-up keypool here, because wallet is locked.
             // User will be prompted to unlock wallet the next operation
             // that requires a new key.
         }
     }
 
     {
         LOCK(cs_KeyStore);
         // This wallet is in its first run if all of these are empty
         fFirstRunRet = mapKeys.empty() && mapCryptedKeys.empty() &&
                        mapWatchKeys.empty() && setWatchOnly.empty() &&
                        mapScripts.empty() &&
                        !IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
                        !IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET);
     }
 
     if (nLoadWalletRet != DBErrors::LOAD_OK) {
         return nLoadWalletRet;
     }
 
     return DBErrors::LOAD_OK;
 }
 
 DBErrors CWallet::ZapSelectTx(std::vector<TxId> &txIdsIn,
                               std::vector<TxId> &txIdsOut) {
     // mapWallet
     AssertLockHeld(cs_wallet);
     DBErrors nZapSelectTxRet =
         WalletBatch(*database, "cr+").ZapSelectTx(txIdsIn, txIdsOut);
     for (const TxId &txid : txIdsOut) {
         const auto &it = mapWallet.find(txid);
         wtxOrdered.erase(it->second.m_it_wtxOrdered);
         mapWallet.erase(it);
     }
 
     if (nZapSelectTxRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             setInternalKeyPool.clear();
             setExternalKeyPool.clear();
             m_pool_key_to_index.clear();
             // Note: can't top-up keypool here, because wallet is locked.
             // User will be prompted to unlock wallet the next operation
             // that requires a new key.
         }
     }
 
     if (nZapSelectTxRet != DBErrors::LOAD_OK) {
         return nZapSelectTxRet;
     }
 
     MarkDirty();
 
     return DBErrors::LOAD_OK;
 }
 
 DBErrors CWallet::ZapWalletTx(std::vector<CWalletTx> &vWtx) {
     DBErrors nZapWalletTxRet = WalletBatch(*database, "cr+").ZapWalletTx(vWtx);
     if (nZapWalletTxRet == DBErrors::NEED_REWRITE) {
         if (database->Rewrite("\x04pool")) {
             LOCK(cs_wallet);
             setInternalKeyPool.clear();
             setExternalKeyPool.clear();
             m_pool_key_to_index.clear();
             // Note: can't top-up keypool here, because wallet is locked.
             // User will be prompted to unlock wallet the next operation
             // that requires a new key.
         }
     }
 
     if (nZapWalletTxRet != DBErrors::LOAD_OK) {
         return nZapWalletTxRet;
     }
 
     return DBErrors::LOAD_OK;
 }
 
 bool CWallet::SetAddressBook(const CTxDestination &address,
                              const std::string &strName,
                              const std::string &strPurpose) {
     bool fUpdated = false;
     {
         // mapAddressBook
         LOCK(cs_wallet);
         std::map<CTxDestination, CAddressBookData>::iterator mi =
             mapAddressBook.find(address);
         fUpdated = mi != mapAddressBook.end();
         mapAddressBook[address].name = strName;
         // Update purpose only if requested.
         if (!strPurpose.empty()) {
             mapAddressBook[address].purpose = strPurpose;
         }
     }
 
     NotifyAddressBookChanged(this, address, strName,
                              ::IsMine(*this, address) != ISMINE_NO, strPurpose,
                              (fUpdated ? CT_UPDATED : CT_NEW));
     if (!strPurpose.empty() &&
         !WalletBatch(*database).WritePurpose(address, strPurpose)) {
         return false;
     }
     return WalletBatch(*database).WriteName(address, strName);
 }
 
 bool CWallet::DelAddressBook(const CTxDestination &address) {
     {
         // mapAddressBook
         LOCK(cs_wallet);
 
         // Delete destdata tuples associated with address.
         for (const std::pair<const std::string, std::string> &item :
              mapAddressBook[address].destdata) {
             WalletBatch(*database).EraseDestData(address, item.first);
         }
 
         mapAddressBook.erase(address);
     }
 
     NotifyAddressBookChanged(this, address, "",
                              ::IsMine(*this, address) != ISMINE_NO, "",
                              CT_DELETED);
 
     WalletBatch(*database).ErasePurpose(address);
     return WalletBatch(*database).EraseName(address);
 }
 
 const std::string &CWallet::GetLabelName(const CScript &scriptPubKey) const {
     CTxDestination address;
     if (ExtractDestination(scriptPubKey, address) &&
         !scriptPubKey.IsUnspendable()) {
         auto mi = mapAddressBook.find(address);
         if (mi != mapAddressBook.end()) {
             return mi->second.name;
         }
     }
     // A scriptPubKey that doesn't have an entry in the address book is
     // associated with the default label ("").
     const static std::string DEFAULT_LABEL_NAME;
     return DEFAULT_LABEL_NAME;
 }
 
 /**
  * Mark old keypool keys as used, and generate all new keys.
  */
 bool CWallet::NewKeyPool() {
     if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         return false;
     }
     LOCK(cs_wallet);
     WalletBatch batch(*database);
 
     for (const int64_t nIndex : setInternalKeyPool) {
         batch.ErasePool(nIndex);
     }
     setInternalKeyPool.clear();
 
     for (const int64_t nIndex : setExternalKeyPool) {
         batch.ErasePool(nIndex);
     }
     setExternalKeyPool.clear();
 
     for (int64_t nIndex : set_pre_split_keypool) {
         batch.ErasePool(nIndex);
     }
     set_pre_split_keypool.clear();
 
     m_pool_key_to_index.clear();
 
     if (!TopUpKeyPool()) {
         return false;
     }
 
     WalletLogPrintf("CWallet::NewKeyPool rewrote keypool\n");
     return true;
 }
 
 size_t CWallet::KeypoolCountExternalKeys() {
     // setExternalKeyPool
     AssertLockHeld(cs_wallet);
     return setExternalKeyPool.size() + set_pre_split_keypool.size();
 }
 
 void CWallet::LoadKeyPool(int64_t nIndex, const CKeyPool &keypool) {
     AssertLockHeld(cs_wallet);
     if (keypool.m_pre_split) {
         set_pre_split_keypool.insert(nIndex);
     } else if (keypool.fInternal) {
         setInternalKeyPool.insert(nIndex);
     } else {
         setExternalKeyPool.insert(nIndex);
     }
     m_max_keypool_index = std::max(m_max_keypool_index, nIndex);
     m_pool_key_to_index[keypool.vchPubKey.GetID()] = nIndex;
 
     // If no metadata exists yet, create a default with the pool key's
     // creation time. Note that this may be overwritten by actually
     // stored metadata for that key later, which is fine.
     CKeyID keyid = keypool.vchPubKey.GetID();
     if (mapKeyMetadata.count(keyid) == 0) {
         mapKeyMetadata[keyid] = CKeyMetadata(keypool.nTime);
     }
 }
 
 bool CWallet::TopUpKeyPool(unsigned int kpSize) {
     if (!CanGenerateKeys()) {
         return false;
     }
     {
         LOCK(cs_wallet);
 
         if (IsLocked()) {
             return false;
         }
 
         // Top up key pool
         unsigned int nTargetSize;
         if (kpSize > 0) {
             nTargetSize = kpSize;
         } else {
             nTargetSize = std::max<int64_t>(
                 gArgs.GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), 0);
         }
 
         // count amount of available keys (internal, external)
         // make sure the keypool of external and internal keys fits the user
         // selected target (-keypool)
         int64_t missingExternal = std::max<int64_t>(
             std::max<int64_t>(nTargetSize, 1) - setExternalKeyPool.size(), 0);
         int64_t missingInternal = std::max<int64_t>(
             std::max<int64_t>(nTargetSize, 1) - setInternalKeyPool.size(), 0);
 
         if (!IsHDEnabled() || !CanSupportFeature(FEATURE_HD_SPLIT)) {
             // don't create extra internal keys
             missingInternal = 0;
         }
         bool internal = false;
         WalletBatch batch(*database);
         for (int64_t i = missingInternal + missingExternal; i--;) {
             if (i < missingInternal) {
                 internal = true;
             }
 
             // How in the hell did you use so many keys?
             assert(m_max_keypool_index < std::numeric_limits<int64_t>::max());
             int64_t index = ++m_max_keypool_index;
 
             CPubKey pubkey(GenerateNewKey(batch, internal));
             if (!batch.WritePool(index, CKeyPool(pubkey, internal))) {
                 throw std::runtime_error(std::string(__func__) +
                                          ": writing generated key failed");
             }
 
             if (internal) {
                 setInternalKeyPool.insert(index);
             } else {
                 setExternalKeyPool.insert(index);
             }
             m_pool_key_to_index[pubkey.GetID()] = index;
         }
         if (missingInternal + missingExternal > 0) {
             WalletLogPrintf(
                 "keypool added %d keys (%d internal), size=%u (%u internal)\n",
                 missingInternal + missingExternal, missingInternal,
                 setInternalKeyPool.size() + setExternalKeyPool.size() +
                     set_pre_split_keypool.size(),
                 setInternalKeyPool.size());
         }
     }
     NotifyCanGetAddressesChanged();
     return true;
 }
 
 bool CWallet::ReserveKeyFromKeyPool(int64_t &nIndex, CKeyPool &keypool,
                                     bool fRequestedInternal) {
     nIndex = -1;
     keypool.vchPubKey = CPubKey();
     {
         LOCK(cs_wallet);
 
         if (!IsLocked()) {
             TopUpKeyPool();
         }
 
         bool fReturningInternal = IsHDEnabled() &&
                                   CanSupportFeature(FEATURE_HD_SPLIT) &&
                                   fRequestedInternal;
         bool use_split_keypool = set_pre_split_keypool.empty();
         std::set<int64_t> &setKeyPool =
             use_split_keypool
                 ? (fReturningInternal ? setInternalKeyPool : setExternalKeyPool)
                 : set_pre_split_keypool;
 
         // Get the oldest key
         if (setKeyPool.empty()) {
             return false;
         }
 
         WalletBatch batch(*database);
 
         auto it = setKeyPool.begin();
         nIndex = *it;
         setKeyPool.erase(it);
         if (!batch.ReadPool(nIndex, keypool)) {
             throw std::runtime_error(std::string(__func__) + ": read failed");
         }
         if (!HaveKey(keypool.vchPubKey.GetID())) {
             throw std::runtime_error(std::string(__func__) +
                                      ": unknown key in key pool");
         }
         // If the key was pre-split keypool, we don't care about what type it is
         if (use_split_keypool && keypool.fInternal != fReturningInternal) {
             throw std::runtime_error(std::string(__func__) +
                                      ": keypool entry misclassified");
         }
         if (!keypool.vchPubKey.IsValid()) {
             throw std::runtime_error(std::string(__func__) +
                                      ": keypool entry invalid");
         }
 
         m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
         WalletLogPrintf("keypool reserve %d\n", nIndex);
     }
     NotifyCanGetAddressesChanged();
     return true;
 }
 
 void CWallet::KeepKey(int64_t nIndex) {
     // Remove from key pool.
     WalletBatch batch(*database);
     batch.ErasePool(nIndex);
     WalletLogPrintf("keypool keep %d\n", nIndex);
 }
 
 void CWallet::ReturnKey(int64_t nIndex, bool fInternal, const CPubKey &pubkey) {
     // Return to key pool
     {
         LOCK(cs_wallet);
         if (fInternal) {
             setInternalKeyPool.insert(nIndex);
         } else if (!set_pre_split_keypool.empty()) {
             set_pre_split_keypool.insert(nIndex);
         } else {
             setExternalKeyPool.insert(nIndex);
         }
         m_pool_key_to_index[pubkey.GetID()] = nIndex;
         NotifyCanGetAddressesChanged();
     }
 
     WalletLogPrintf("keypool return %d\n", nIndex);
 }
 
 bool CWallet::GetKeyFromPool(CPubKey &result, bool internal) {
     if (!CanGetAddresses(internal)) {
         return false;
     }
 
     CKeyPool keypool;
     LOCK(cs_wallet);
     int64_t nIndex;
     if (!ReserveKeyFromKeyPool(nIndex, keypool, internal)) {
         if (IsLocked()) {
             return false;
         }
         WalletBatch batch(*database);
         result = GenerateNewKey(batch, internal);
         return true;
     }
 
     KeepKey(nIndex);
     result = keypool.vchPubKey;
 
     return true;
 }
 
 static int64_t GetOldestKeyTimeInPool(const std::set<int64_t> &setKeyPool,
                                       WalletBatch &batch) {
     if (setKeyPool.empty()) {
         return GetTime();
     }
 
     CKeyPool keypool;
     int64_t nIndex = *(setKeyPool.begin());
     if (!batch.ReadPool(nIndex, keypool)) {
         throw std::runtime_error(std::string(__func__) +
                                  ": read oldest key in keypool failed");
     }
 
     assert(keypool.vchPubKey.IsValid());
     return keypool.nTime;
 }
 
 int64_t CWallet::GetOldestKeyPoolTime() {
     LOCK(cs_wallet);
 
     WalletBatch batch(*database);
 
     // load oldest key from keypool, get time and return
     int64_t oldestKey = GetOldestKeyTimeInPool(setExternalKeyPool, batch);
     if (IsHDEnabled() && CanSupportFeature(FEATURE_HD_SPLIT)) {
         oldestKey = std::max(GetOldestKeyTimeInPool(setInternalKeyPool, batch),
                              oldestKey);
         if (!set_pre_split_keypool.empty()) {
             oldestKey =
                 std::max(GetOldestKeyTimeInPool(set_pre_split_keypool, batch),
                          oldestKey);
         }
     }
 
     return oldestKey;
 }
 
 std::map<CTxDestination, Amount>
 CWallet::GetAddressBalances(interfaces::Chain::Lock &locked_chain) {
     std::map<CTxDestination, Amount> balances;
 
     LOCK(cs_wallet);
     for (const auto &walletEntry : mapWallet) {
         const CWalletTx *pcoin = &walletEntry.second;
 
         if (!pcoin->IsTrusted(locked_chain)) {
             continue;
         }
 
         if (pcoin->IsImmatureCoinBase(locked_chain)) {
             continue;
         }
 
         int nDepth = pcoin->GetDepthInMainChain(locked_chain);
         if (nDepth < (pcoin->IsFromMe(ISMINE_ALL) ? 0 : 1)) {
             continue;
         }
 
         for (uint32_t i = 0; i < pcoin->tx->vout.size(); i++) {
             CTxDestination addr;
             if (!IsMine(pcoin->tx->vout[i])) {
                 continue;
             }
 
             if (!ExtractDestination(pcoin->tx->vout[i].scriptPubKey, addr)) {
                 continue;
             }
 
             Amount n = IsSpent(locked_chain, COutPoint(walletEntry.first, i))
                            ? Amount::zero()
                            : pcoin->tx->vout[i].nValue;
 
             if (!balances.count(addr)) {
                 balances[addr] = Amount::zero();
             }
             balances[addr] += n;
         }
     }
 
     return balances;
 }
 
 std::set<std::set<CTxDestination>> CWallet::GetAddressGroupings() {
     // mapWallet
     AssertLockHeld(cs_wallet);
     std::set<std::set<CTxDestination>> groupings;
     std::set<CTxDestination> grouping;
 
     for (const auto &walletEntry : mapWallet) {
         const CWalletTx *pcoin = &walletEntry.second;
 
         if (pcoin->tx->vin.size() > 0) {
             bool any_mine = false;
             // Group all input addresses with each other.
             for (const auto &txin : pcoin->tx->vin) {
                 CTxDestination address;
                 // If this input isn't mine, ignore it.
                 if (!IsMine(txin)) {
                     continue;
                 }
 
                 if (!ExtractDestination(mapWallet.at(txin.prevout.GetTxId())
                                             .tx->vout[txin.prevout.GetN()]
                                             .scriptPubKey,
                                         address)) {
                     continue;
                 }
 
                 grouping.insert(address);
                 any_mine = true;
             }
 
             // Group change with input addresses.
             if (any_mine) {
                 for (const auto &txout : pcoin->tx->vout) {
                     if (IsChange(txout)) {
                         CTxDestination txoutAddr;
                         if (!ExtractDestination(txout.scriptPubKey,
                                                 txoutAddr)) {
                             continue;
                         }
 
                         grouping.insert(txoutAddr);
                     }
                 }
             }
 
             if (grouping.size() > 0) {
                 groupings.insert(grouping);
                 grouping.clear();
             }
         }
 
         // Group lone addrs by themselves.
         for (const auto &txout : pcoin->tx->vout) {
             if (IsMine(txout)) {
                 CTxDestination address;
                 if (!ExtractDestination(txout.scriptPubKey, address)) {
                     continue;
                 }
 
                 grouping.insert(address);
                 groupings.insert(grouping);
                 grouping.clear();
             }
         }
     }
 
     // A set of pointers to groups of addresses.
     std::set<std::set<CTxDestination> *> uniqueGroupings;
     // Map addresses to the unique group containing it.
     std::map<CTxDestination, std::set<CTxDestination> *> setmap;
     for (std::set<CTxDestination> _grouping : groupings) {
         // Make a set of all the groups hit by this new group.
         std::set<std::set<CTxDestination> *> hits;
         std::map<CTxDestination, std::set<CTxDestination> *>::iterator it;
         for (const CTxDestination &address : _grouping) {
             if ((it = setmap.find(address)) != setmap.end()) {
                 hits.insert((*it).second);
             }
         }
 
         // Merge all hit groups into a new single group and delete old groups.
         std::set<CTxDestination> *merged =
             new std::set<CTxDestination>(_grouping);
         for (std::set<CTxDestination> *hit : hits) {
             merged->insert(hit->begin(), hit->end());
             uniqueGroupings.erase(hit);
             delete hit;
         }
         uniqueGroupings.insert(merged);
 
         // Update setmap.
         for (const CTxDestination &element : *merged) {
             setmap[element] = merged;
         }
     }
 
     std::set<std::set<CTxDestination>> ret;
     for (const std::set<CTxDestination> *uniqueGrouping : uniqueGroupings) {
         ret.insert(*uniqueGrouping);
         delete uniqueGrouping;
     }
 
     return ret;
 }
 
 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 :
          mapAddressBook) {
         const CTxDestination &address = item.first;
         const std::string &strName = item.second.name;
         if (strName == label) {
             result.insert(address);
         }
     }
 
     return result;
 }
 
 bool CReserveKey::GetReservedKey(CPubKey &pubkey, bool internal) {
     if (!pwallet->CanGetAddresses(internal)) {
         return false;
     }
 
     if (nIndex == -1) {
         CKeyPool keypool;
         if (!pwallet->ReserveKeyFromKeyPool(nIndex, keypool, internal)) {
             return false;
         }
 
         vchPubKey = keypool.vchPubKey;
         fInternal = keypool.fInternal;
     }
 
     assert(vchPubKey.IsValid());
     pubkey = vchPubKey;
     return true;
 }
 
 void CReserveKey::KeepKey() {
     if (nIndex != -1) {
         pwallet->KeepKey(nIndex);
     }
 
     nIndex = -1;
     vchPubKey = CPubKey();
 }
 
 void CReserveKey::ReturnKey() {
     if (nIndex != -1) {
         pwallet->ReturnKey(nIndex, fInternal, vchPubKey);
     }
     nIndex = -1;
     vchPubKey = CPubKey();
 }
 
 void CWallet::MarkReserveKeysAsUsed(int64_t keypool_id) {
     AssertLockHeld(cs_wallet);
     bool internal = setInternalKeyPool.count(keypool_id);
     if (!internal) {
         assert(setExternalKeyPool.count(keypool_id) ||
                set_pre_split_keypool.count(keypool_id));
     }
 
     std::set<int64_t> *setKeyPool =
         internal ? &setInternalKeyPool
                  : (set_pre_split_keypool.empty() ? &setExternalKeyPool
                                                   : &set_pre_split_keypool);
     auto it = setKeyPool->begin();
 
     WalletBatch batch(*database);
     while (it != std::end(*setKeyPool)) {
         const int64_t &index = *(it);
         if (index > keypool_id) {
             // set*KeyPool is ordered
             break;
         }
 
         CKeyPool keypool;
         if (batch.ReadPool(index, keypool)) {
             // TODO: This should be unnecessary
             m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
         }
         LearnAllRelatedScripts(keypool.vchPubKey);
         batch.ErasePool(index);
         WalletLogPrintf("keypool index %d removed\n", index);
         it = setKeyPool->erase(it);
     }
 }
 
 void CWallet::GetScriptForMining(std::shared_ptr<CReserveScript> &script) {
     std::shared_ptr<CReserveKey> rKey = std::make_shared<CReserveKey>(this);
     CPubKey pubkey;
     if (!rKey->GetReservedKey(pubkey)) {
         return;
     }
 
     script = rKey;
     script->reserveScript = CScript() << ToByteVector(pubkey) << OP_CHECKSIG;
 }
 
 void CWallet::LockCoin(const COutPoint &output) {
     // setLockedCoins
     AssertLockHeld(cs_wallet);
     setLockedCoins.insert(output);
 }
 
 void CWallet::UnlockCoin(const COutPoint &output) {
     // setLockedCoins
     AssertLockHeld(cs_wallet);
     setLockedCoins.erase(output);
 }
 
 void CWallet::UnlockAllCoins() {
     // setLockedCoins
     AssertLockHeld(cs_wallet);
     setLockedCoins.clear();
 }
 
 bool CWallet::IsLockedCoin(const COutPoint &outpoint) const {
     // setLockedCoins
     AssertLockHeld(cs_wallet);
 
     return setLockedCoins.count(outpoint) > 0;
 }
 
 void CWallet::ListLockedCoins(std::vector<COutPoint> &vOutpts) const {
     // setLockedCoins
     AssertLockHeld(cs_wallet);
     for (COutPoint outpoint : setLockedCoins) {
         vOutpts.push_back(outpoint);
     }
 }
 
 /** @} */ // end of Actions
 
 void CWallet::GetKeyBirthTimes(
     interfaces::Chain::Lock &locked_chain,
     std::map<CTxDestination, int64_t> &mapKeyBirth) const {
     // mapKeyMetadata
     AssertLockHeld(cs_wallet);
     mapKeyBirth.clear();
 
     // Get birth times for keys with metadata.
     for (const auto &entry : mapKeyMetadata) {
         if (entry.second.nCreateTime) {
             mapKeyBirth[entry.first] = entry.second.nCreateTime;
         }
     }
 
     // Map in which we'll infer heights of other keys
     const Optional<int> tip_height = locked_chain.getHeight();
     // the tip can be reorganized; use a 144-block safety margin
     const int max_height =
         tip_height && *tip_height > 144 ? *tip_height - 144 : 0;
     std::map<CKeyID, int> mapKeyFirstBlock;
     for (const CKeyID &keyid : GetKeys()) {
         if (mapKeyBirth.count(keyid) == 0) {
             mapKeyFirstBlock[keyid] = max_height;
         }
     }
 
     // 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.
     std::vector<CKeyID> vAffected;
     for (const auto &entry : mapWallet) {
         // iterate over all wallet transactions...
         const CWalletTx &wtx = entry.second;
         if (Optional<int> height = locked_chain.getBlockHeight(wtx.hashBlock)) {
             // ... which are already in a block
             for (const CTxOut &txout : wtx.tx->vout) {
                 // Iterate over all their outputs...
                 CAffectedKeysVisitor(*this, vAffected)
                     .Process(txout.scriptPubKey);
                 for (const CKeyID &keyid : vAffected) {
                     // ... and all their affected keys.
                     std::map<CKeyID, int>::iterator rit =
                         mapKeyFirstBlock.find(keyid);
                     if (rit != mapKeyFirstBlock.end() &&
                         *height < rit->second) {
                         rit->second = *height;
                     }
                 }
                 vAffected.clear();
             }
         }
     }
 
     // Extract block timestamps for those keys.
     for (const auto &entry : mapKeyFirstBlock) {
         // block times can be 2h off
         mapKeyBirth[entry.first] =
             locked_chain.getBlockTime(entry.second) - 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.hashUnset()) {
         int64_t blocktime;
         if (chain().findBlock(wtx.hashBlock, nullptr /* block */, &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.hashBlock.ToString());
         }
     }
     return nTimeSmart;
 }
 
 bool CWallet::AddDestData(const CTxDestination &dest, const std::string &key,
                           const std::string &value) {
     if (boost::get<CNoDestination>(&dest)) {
         return false;
     }
 
     mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
     return WalletBatch(*database).WriteDestData(dest, key, value);
 }
 
 bool CWallet::EraseDestData(const CTxDestination &dest,
                             const std::string &key) {
     if (!mapAddressBook[dest].destdata.erase(key)) {
         return false;
     }
 
     return WalletBatch(*database).EraseDestData(dest, key);
 }
 
 void CWallet::LoadDestData(const CTxDestination &dest, const std::string &key,
                            const std::string &value) {
     mapAddressBook[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 =
         mapAddressBook.find(dest);
     if (i != mapAddressBook.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 {
     LOCK(cs_wallet);
     std::vector<std::string> values;
     for (const auto &address : mapAddressBook) {
         for (const auto &data : address.second.destdata) {
             if (!data.first.compare(0, prefix.size(), prefix)) {
                 values.emplace_back(data.second);
             }
         }
     }
     return values;
 }
 
 bool CWallet::Verify(const CChainParams &chainParams, interfaces::Chain &chain,
                      const WalletLocation &location, bool salvage_wallet,
                      std::string &error_string, std::string &warning_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.
     LOCK(cs_wallets);
     const fs::path &wallet_path = location.GetPath();
     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 &&
            fs::path(location.GetName()).filename() == location.GetName()))) {
         error_string =
             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)",
                       location.GetName(), GetWalletDir());
         return false;
     }
 
     // Make sure that the wallet path doesn't clash with an existing wallet path
     if (IsWalletLoaded(wallet_path)) {
         error_string = strprintf(
             "Error loading wallet %s. Duplicate -wallet filename specified.",
             location.GetName());
         return false;
     }
 
     // Keep same database environment instance across Verify/Recover calls
     // below.
     std::unique_ptr<WalletDatabase> database =
         WalletDatabase::Create(wallet_path);
 
     try {
         if (!WalletBatch::VerifyEnvironment(wallet_path, error_string)) {
             return false;
         }
     } catch (const fs::filesystem_error &e) {
         error_string =
             strprintf("Error loading wallet %s. %s", location.GetName(),
                       fsbridge::get_filesystem_error_message(e));
         return false;
     }
 
     if (salvage_wallet) {
         // Recover readable keypairs:
         CWallet dummyWallet(chainParams, chain, WalletLocation(),
                             WalletDatabase::CreateDummy());
         std::string backup_filename;
         if (!WalletBatch::Recover(
                 wallet_path, static_cast<void *>(&dummyWallet),
                 WalletBatch::RecoverKeysOnlyFilter, backup_filename)) {
             return false;
         }
     }
 
     return WalletBatch::VerifyDatabaseFile(wallet_path, warning_string,
                                            error_string);
 }
 
 void CWallet::MarkPreSplitKeys() {
     WalletBatch batch(*database);
     for (auto it = setExternalKeyPool.begin();
          it != setExternalKeyPool.end();) {
         int64_t index = *it;
         CKeyPool keypool;
         if (!batch.ReadPool(index, keypool)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": read keypool entry failed");
         }
         keypool.m_pre_split = true;
         if (!batch.WritePool(index, keypool)) {
             throw std::runtime_error(std::string(__func__) +
                                      ": writing modified keypool entry failed");
         }
         set_pre_split_keypool.insert(index);
         it = setExternalKeyPool.erase(it);
     }
 }
 
 std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(
     const CChainParams &chainParams, interfaces::Chain &chain,
     const WalletLocation &location, uint64_t wallet_creation_flags) {
     const std::string &walletFile = location.GetName();
 
     // Needed to restore wallet transaction meta data after -zapwallettxes
     std::vector<CWalletTx> vWtx;
 
     if (gArgs.GetBoolArg("-zapwallettxes", false)) {
         uiInterface.InitMessage(_("Zapping all transactions from wallet..."));
 
         std::unique_ptr<CWallet> tempWallet = std::make_unique<CWallet>(
             chainParams, chain, location,
             WalletDatabase::Create(location.GetPath()));
         DBErrors nZapWalletRet = tempWallet->ZapWalletTx(vWtx);
         if (nZapWalletRet != DBErrors::LOAD_OK) {
             InitError(
                 strprintf(_("Error loading %s: Wallet corrupted"), walletFile));
             return nullptr;
         }
     }
 
     uiInterface.InitMessage(_("Loading wallet..."));
 
     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(chainParams, chain, location,
                     WalletDatabase::Create(location.GetPath())),
         ReleaseWallet);
     DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun);
     if (nLoadWalletRet != DBErrors::LOAD_OK) {
         if (nLoadWalletRet == DBErrors::CORRUPT) {
             InitError(
                 strprintf(_("Error loading %s: Wallet corrupted"), walletFile));
             return nullptr;
         }
 
         if (nLoadWalletRet == DBErrors::NONCRITICAL_ERROR) {
             InitWarning(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) {
             InitError(strprintf(
                 _("Error loading %s: Wallet requires newer version of %s"),
-                walletFile, _(PACKAGE_NAME)));
+                walletFile, PACKAGE_NAME));
             return nullptr;
         } else if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
             InitError(strprintf(
                 _("Wallet needed to be rewritten: restart %s to complete"),
-                _(PACKAGE_NAME)));
+                PACKAGE_NAME));
             return nullptr;
         } else {
             InitError(strprintf(_("Error loading %s"), walletFile));
             return nullptr;
         }
     }
 
     int prev_version = walletInstance->nWalletVersion;
     if (gArgs.GetBoolArg("-upgradewallet", fFirstRun)) {
         int nMaxVersion = gArgs.GetArg("-upgradewallet", 0);
         // The -upgradewallet without argument case
         if (nMaxVersion == 0) {
             walletInstance->WalletLogPrintf("Performing wallet upgrade to %i\n",
                                             FEATURE_LATEST);
             nMaxVersion = FEATURE_LATEST;
             // permanently upgrade the wallet immediately
             walletInstance->SetMinVersion(FEATURE_LATEST);
         } else {
             walletInstance->WalletLogPrintf(
                 "Allowing wallet upgrade up to %i\n", nMaxVersion);
         }
 
         if (nMaxVersion < walletInstance->GetVersion()) {
             InitError(_("Cannot downgrade wallet"));
             return nullptr;
         }
 
         walletInstance->SetMaxVersion(nMaxVersion);
     }
 
     // Upgrade to HD if explicit upgrade
     if (gArgs.GetBoolArg("-upgradewallet", false)) {
         LOCK(walletInstance->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 = walletInstance->nWalletVersion;
         if (!walletInstance->CanSupportFeature(FEATURE_HD_SPLIT) &&
             max_version >= FEATURE_HD_SPLIT &&
             max_version < FEATURE_PRE_SPLIT_KEYPOOL) {
             InitError(
                 _("Cannot upgrade a non HD split wallet without upgrading to "
                   "support pre split keypool. Please use -upgradewallet=200300 "
                   "or -upgradewallet with no version specified."));
             return nullptr;
         }
 
         bool hd_upgrade = false;
         bool split_upgrade = false;
         if (walletInstance->CanSupportFeature(FEATURE_HD) &&
             !walletInstance->IsHDEnabled()) {
             walletInstance->WalletLogPrintf("Upgrading wallet to HD\n");
             walletInstance->SetMinVersion(FEATURE_HD);
 
             // generate a new master key
             CPubKey masterPubKey = walletInstance->GenerateNewSeed();
             walletInstance->SetHDSeed(masterPubKey);
             hd_upgrade = true;
         }
         // Upgrade to HD chain split if necessary
         if (walletInstance->CanSupportFeature(FEATURE_HD_SPLIT)) {
             walletInstance->WalletLogPrintf(
                 "Upgrading wallet to use HD chain split\n");
             walletInstance->SetMinVersion(FEATURE_PRE_SPLIT_KEYPOOL);
             split_upgrade = FEATURE_HD_SPLIT > prev_version;
         }
         // Mark all keys currently in the keypool as pre-split
         if (split_upgrade) {
             walletInstance->MarkPreSplitKeys();
         }
         // Regenerate the keypool if upgraded to HD
         if (hd_upgrade) {
             if (!walletInstance->TopUpKeyPool()) {
                 InitError(_("Unable to generate keys"));
                 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);
 
         if ((wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
             // selective allow to set flags
             walletInstance->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
         } else if (wallet_creation_flags & WALLET_FLAG_BLANK_WALLET) {
             walletInstance->SetWalletFlag(WALLET_FLAG_BLANK_WALLET);
         } else {
             // generate a new seed
             CPubKey seed = walletInstance->GenerateNewSeed();
             walletInstance->SetHDSeed(seed);
         } // Otherwise, do not generate a new seed
 
         // Top up the keypool
         if (walletInstance->CanGenerateKeys() &&
             !walletInstance->TopUpKeyPool()) {
             InitError(_("Unable to generate initial keys"));
             return nullptr;
         }
 
         // Temporary. Removed in upcoming lock cleanup
         auto locked_chain = chain.assumeLocked();
         walletInstance->ChainStateFlushed(locked_chain->getLocator());
     } else if (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS) {
         // Make it impossible to disable private keys after creation
         InitError(strprintf(_("Error loading %s: Private keys can only be "
                               "disabled during creation"),
                             walletFile));
         return nullptr;
     } else if (walletInstance->IsWalletFlagSet(
                    WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         LOCK(walletInstance->cs_KeyStore);
         if (!walletInstance->mapKeys.empty() ||
             !walletInstance->mapCryptedKeys.empty()) {
             InitWarning(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()) {
             InitError(AmountErrMsg("mintxfee", gArgs.GetArg("-mintxfee", "")));
             return nullptr;
         }
         if (n > HIGH_TX_FEE_PER_KB) {
             InitWarning(AmountHighWarn("-mintxfee") + " " +
                         _("This is the minimum transaction fee you pay on "
                           "every transaction."));
         }
         walletInstance->m_min_fee = CFeeRate(n);
     }
 
     if (gArgs.IsArgSet("-fallbackfee")) {
         Amount nFeePerK = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-fallbackfee", ""), nFeePerK)) {
             InitError(
                 strprintf(_("Invalid amount for -fallbackfee=<amount>: '%s'"),
                           gArgs.GetArg("-fallbackfee", "")));
             return nullptr;
         }
         if (nFeePerK > HIGH_TX_FEE_PER_KB) {
             InitWarning(AmountHighWarn("-fallbackfee") + " " +
                         _("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 = (nFeePerK != Amount::zero());
     }
     if (gArgs.IsArgSet("-paytxfee")) {
         Amount nFeePerK = Amount::zero();
         if (!ParseMoney(gArgs.GetArg("-paytxfee", ""), nFeePerK)) {
             InitError(AmountErrMsg("paytxfee", gArgs.GetArg("-paytxfee", "")));
             return nullptr;
         }
         if (nFeePerK > HIGH_TX_FEE_PER_KB) {
             InitWarning(AmountHighWarn("-paytxfee") + " " +
                         _("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 < ::minRelayTxFee) {
             InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s' "
                                   "(must be at least %s)"),
                                 gArgs.GetArg("-paytxfee", ""),
                                 ::minRelayTxFee.ToString()));
             return nullptr;
         }
     }
     walletInstance->m_spend_zero_conf_change =
         gArgs.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
 
     walletInstance->m_default_address_type = DEFAULT_ADDRESS_TYPE;
     walletInstance->m_default_change_type = DEFAULT_CHANGE_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();
 
     auto locked_chain = chain.lock();
     LOCK(walletInstance->cs_wallet);
 
     int rescan_height = 0;
     if (!gArgs.GetBoolArg("-rescan", false)) {
         WalletBatch batch(*walletInstance->database);
         CBlockLocator locator;
         if (batch.ReadBestBlock(locator)) {
             if (const Optional<int> fork_height =
                     locked_chain->findLocatorFork(locator)) {
                 rescan_height = *fork_height;
             }
         }
     }
 
     const Optional<int> tip_height = locked_chain->getHeight();
     if (tip_height) {
         walletInstance->m_last_block_processed =
             locked_chain->getBlockHash(*tip_height);
     } else {
         walletInstance->m_last_block_processed.SetNull();
     }
 
     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 he ran -disablewallet for a longer time, then decided to
         // re-enable.
         if (fPruneMode) {
             int block_height = *tip_height;
             while (block_height > 0 &&
                    locked_chain->haveBlockOnDisk(block_height - 1) &&
                    rescan_height != block_height) {
                 --block_height;
             }
 
             if (rescan_height != block_height) {
                 InitError(_("Prune: last wallet synchronisation goes beyond "
                             "pruned data. You need to -reindex (download the "
                             "whole blockchain again in case of pruned node)"));
                 return nullptr;
             }
         }
 
         uiInterface.InitMessage(_("Rescanning..."));
         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)
         if (walletInstance->nTimeFirstKey) {
             if (Optional<int> first_block =
                     locked_chain->findFirstBlockWithTimeAndHeight(
                         walletInstance->nTimeFirstKey - TIMESTAMP_WINDOW,
                         rescan_height)) {
                 rescan_height = *first_block;
             }
         }
 
         nStart = GetTimeMillis();
         {
             WalletRescanReserver reserver(walletInstance.get());
             if (!reserver.reserve() ||
                 (ScanResult::SUCCESS !=
                  walletInstance
                      ->ScanForWalletTransactions(
                          locked_chain->getBlockHash(rescan_height), BlockHash(),
                          reserver, true /* update */)
                      .status)) {
                 InitError(
                     _("Failed to rescan the wallet during initialization"));
                 return nullptr;
             }
         }
         walletInstance->WalletLogPrintf("Rescan completed in %15dms\n",
                                         GetTimeMillis() - nStart);
         walletInstance->ChainStateFlushed(locked_chain->getLocator());
         walletInstance->database->IncrementUpdateCounter();
 
         // Restore wallet transaction metadata after -zapwallettxes=1
         if (gArgs.GetBoolArg("-zapwallettxes", false) &&
             gArgs.GetArg("-zapwallettxes", "1") != "2") {
             WalletBatch batch(*walletInstance->database);
 
             for (const CWalletTx &wtxOld : vWtx) {
                 const TxId txid = wtxOld.GetId();
                 std::map<TxId, CWalletTx>::iterator mi =
                     walletInstance->mapWallet.find(txid);
                 if (mi != walletInstance->mapWallet.end()) {
                     const CWalletTx *copyFrom = &wtxOld;
                     CWalletTx *copyTo = &mi->second;
                     copyTo->mapValue = copyFrom->mapValue;
                     copyTo->vOrderForm = copyFrom->vOrderForm;
                     copyTo->nTimeReceived = copyFrom->nTimeReceived;
                     copyTo->nTimeSmart = copyFrom->nTimeSmart;
                     copyTo->fFromMe = copyFrom->fFromMe;
                     copyTo->nOrderPos = copyFrom->nOrderPos;
                     batch.WriteTx(*copyTo);
                 }
             }
         }
     }
 
     uiInterface.LoadWallet(walletInstance);
 
     // Register with the validation interface. It's ok to do this after rescan
     // since we're still holding cs_main.
     RegisterValidationInterface(walletInstance.get());
 
     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("mapAddressBook.size() = %u\n",
                                     walletInstance->mapAddressBook.size());
 
     return walletInstance;
 }
 
 void CWallet::postInitProcess() {
     // Add wallet transactions that aren't already in a block to mempool.
     // Do this here as mempool requires genesis block to be loaded.
     ReacceptWalletTransactions();
 }
 
 bool CWallet::BackupWallet(const std::string &strDest) {
     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;
 }
 
 CWalletKey::CWalletKey(int64_t nExpires) {
     nTimeCreated = (nExpires ? GetTime() : 0);
     nTimeExpires = nExpires;
 }
 
 void CMerkleTx::SetMerkleBranch(const BlockHash &block_hash, int posInBlock) {
     // Update the tx's hashBlock
     hashBlock = block_hash;
 
     // Set the position of the transaction in the block.
     nIndex = posInBlock;
 }
 
 int CMerkleTx::GetDepthInMainChain(
     interfaces::Chain::Lock &locked_chain) const {
     if (hashUnset()) {
         return 0;
     }
 
     AssertLockHeld(cs_main);
 
     return locked_chain.getBlockDepth(hashBlock) * (nIndex == -1 ? -1 : 1);
 }
 
 int CMerkleTx::GetBlocksToMaturity(
     interfaces::Chain::Lock &locked_chain) const {
     if (!IsCoinBase()) {
         return 0;
     }
 
     return std::max(0, (COINBASE_MATURITY + 1) -
                            GetDepthInMainChain(locked_chain));
 }
 
 bool CMerkleTx::IsImmatureCoinBase(
     interfaces::Chain::Lock &locked_chain) const {
     // note GetBlocksToMaturity is 0 for non-coinbase tx
     return GetBlocksToMaturity(locked_chain) > 0;
 }
 
 bool CWalletTx::AcceptToMemoryPool(interfaces::Chain::Lock &locked_chain,
                                    const Amount nAbsurdFee,
                                    CValidationState &state) {
     // Temporary, for AcceptToMemoryPool below. Removed in upcoming commit.
     LockAnnotation lock(::cs_main);
 
     // 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.
     bool ret = ::AcceptToMemoryPool(GetConfig(), g_mempool, state, tx,
                                     nullptr /* pfMissingInputs */,
                                     false /* bypass_limits */, nAbsurdFee);
     fInMempool |= ret;
     return ret;
 }
 
 void CWallet::LearnRelatedScripts(const CPubKey &key, OutputType type) {
     // Nothing to do...
 }
 
 void CWallet::LearnAllRelatedScripts(const CPubKey &key) {
     // Nothing to do...
 }
 
 std::vector<OutputGroup>
 CWallet::GroupOutputs(const std::vector<COutput> &outputs,
                       bool single_coin) const {
     std::vector<OutputGroup> groups;
     std::map<CTxDestination, OutputGroup> gmap;
     CTxDestination dst;
     for (const auto &output : outputs) {
         if (output.fSpendable) {
             CInputCoin input_coin = output.GetInputCoin();
 
             size_t ancestors, descendants;
             g_mempool.GetTransactionAncestry(output.tx->GetId(), ancestors,
                                              descendants);
             if (!single_coin &&
                 ExtractDestination(output.tx->tx->vout[output.i].scriptPubKey,
                                    dst)) {
                 // Limit output groups to no more than 10 entries, to protect
                 // against inadvertently creating a too-large transaction
                 // when using -avoidpartialspends
                 if (gmap[dst].m_outputs.size() >= OUTPUT_GROUP_MAX_ENTRIES) {
                     groups.push_back(gmap[dst]);
                     gmap.erase(dst);
                 }
                 gmap[dst].Insert(input_coin, output.nDepth,
                                  output.tx->IsFromMe(ISMINE_ALL), ancestors,
                                  descendants);
             } else {
                 groups.emplace_back(input_coin, output.nDepth,
                                     output.tx->IsFromMe(ISMINE_ALL), ancestors,
                                     descendants);
             }
         }
     }
     if (!single_coin) {
         for (const auto &it : gmap) {
             groups.push_back(it.second);
         }
     }
     return groups;
 }
 
 bool CWallet::GetKeyOrigin(const CKeyID &keyID, KeyOriginInfo &info) const {
     CKeyMetadata meta;
     {
         LOCK(cs_wallet);
         auto it = mapKeyMetadata.find(keyID);
         if (it != mapKeyMetadata.end()) {
             meta = it->second;
         }
     }
     if (!meta.hdKeypath.empty()) {
         if (!ParseHDKeypath(meta.hdKeypath, info.path)) {
             return false;
         }
         // Get the proper master key id
         CKey key;
         GetKey(meta.hd_seed_id, key);
         CExtKey masterKey;
         masterKey.SetSeed(key.begin(), key.size());
         // Compute identifier
         CKeyID masterid = masterKey.key.GetPubKey().GetID();
         std::copy(masterid.begin(), masterid.begin() + 4, info.fingerprint);
     } else {
         // Single pubkeys get the master fingerprint of themselves
         std::copy(keyID.begin(), keyID.begin() + 4, info.fingerprint);
     }
     return true;
 }
diff --git a/test/lint/lint-format-strings.py b/test/lint/lint-format-strings.py
index 56e40b4bd..2fb092238 100755
--- a/test/lint/lint-format-strings.py
+++ b/test/lint/lint-format-strings.py
@@ -1,296 +1,296 @@
 #!/usr/bin/env python3
 #
 # Copyright (c) 2018-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.
 #
 # Lint format strings: This program checks that the number of arguments passed
 # to a variadic format string function matches the number of format specifiers
 # in the format string.
 
 import argparse
 import doctest
 import re
 import sys
 
 FALSE_POSITIVES = [
     ("src/dbwrapper.cpp", "vsnprintf(p, limit - p, format, backup_ap)"),
     ("src/index/base.cpp", "FatalError(const char *fmt, const Args &... args)"),
     ("src/netbase.cpp", "LogConnectFailure(bool manual_connection, const char *fmt, const Args &... args)"),
     ("src/util/system.cpp",
-     "strprintf(_(COPYRIGHT_HOLDERS), _(COPYRIGHT_HOLDERS_SUBSTITUTION))"),
+     "strprintf(_(COPYRIGHT_HOLDERS), COPYRIGHT_HOLDERS_SUBSTITUTION)"),
     ("src/tinyformat.h", "printf(const char *fmt, const Args &... args)"),
     ("src/tinyformat.h", "printf(const char *fmt, TINYFORMAT_VARARGS(n))"),
     ("src/wallet/wallet.h",
      "LogPrintf((\"%s \" + fmt).c_str(), GetDisplayName(), parameters...)"),
     ("src/logging.h", "LogPrintf(const char *fmt, const Args &... args)"),
 ]
 
 FUNCTION_NAMES_AND_NUMBER_OF_LEADING_ARGUMENTS = [
     ("FatalError", 0),
     ("fprintf", 1),
     ("LogConnectFailure", 1),
     ("LogPrint", 1),
     ("LogPrintf", 0),
     ("printf", 0),
     ("snprintf", 2),
     ("sprintf", 1),
     ("strprintf", 0),
     ("tfm::format", 1),  # Assuming tfm::::format(std::ostream&, ...
     ("vfprintf", 1),
     ("vprintf", 1),
     ("vsnprintf", 1),
     ("vsprintf", 1),
 ]
 
 
 def parse_function_calls(function_name, source_code):
     """Return an array with all calls to function function_name in string source_code.
     Preprocessor directives and C++ style comments ("//") in source_code are removed.
 
     >>> len(parse_function_calls("foo", "foo();bar();foo();bar();"))
     2
     >>> parse_function_calls("foo", "foo(1);bar(1);foo(2);bar(2);")[0].startswith("foo(1);")
     True
     >>> parse_function_calls("foo", "foo(1);bar(1);foo(2);bar(2);")[1].startswith("foo(2);")
     True
     >>> len(parse_function_calls("foo", "foo();bar();// foo();bar();"))
     1
     >>> len(parse_function_calls("foo", "#define FOO foo();"))
     0
     """
     assert isinstance(function_name, str) and isinstance(
         source_code, str) and function_name
     lines = [re.sub("// .*", " ", line).strip()
              for line in source_code.split("\n")
              if not line.strip().startswith("#")]
     return re.findall(
         r"[^a-zA-Z_](?=({}\(.*).*)".format(function_name), " " + " ".join(lines))
 
 
 def normalize(s):
     """Return a normalized version of string s with newlines, tabs and C style comments ("/* ... */")
     replaced with spaces. Multiple spaces are replaced with a single space.
 
     >>> normalize("  /* nothing */   foo\tfoo  /* bar */  foo     ")
     'foo foo foo'
     """
     assert isinstance(s, str)
     s = s.replace("\n", " ")
     s = s.replace("\t", " ")
     s = re.sub(r"/\*.*?\*/", " ", s)
     s = re.sub(" {2,}", " ", s)
     return s.strip()
 
 
 ESCAPE_MAP = {
     r"\n": "[escaped-newline]",
     r"\t": "[escaped-tab]",
     r'\"': "[escaped-quote]",
 }
 
 
 def escape(s):
     """Return the escaped version of string s with "\\\"", "\\n" and "\\t" escaped as
     "[escaped-backslash]", "[escaped-newline]" and "[escaped-tab]".
 
     >>> unescape(escape("foo")) == "foo"
     True
     >>> escape(r'foo \\t foo \\n foo \\\\ foo \\ foo \\"bar\\"')
     'foo [escaped-tab] foo [escaped-newline] foo \\\\\\\\ foo \\\\ foo [escaped-quote]bar[escaped-quote]'
     """
     assert isinstance(s, str)
     for raw_value, escaped_value in ESCAPE_MAP.items():
         s = s.replace(raw_value, escaped_value)
     return s
 
 
 def unescape(s):
     """Return the unescaped version of escaped string s.
     Reverses the replacements made in function escape(s).
 
     >>> unescape(escape("bar"))
     'bar'
     >>> unescape("foo [escaped-tab] foo [escaped-newline] foo \\\\\\\\ foo \\\\ foo [escaped-quote]bar[escaped-quote]")
     'foo \\\\t foo \\\\n foo \\\\\\\\ foo \\\\ foo \\\\"bar\\\\"'
     """
     assert isinstance(s, str)
     for raw_value, escaped_value in ESCAPE_MAP.items():
         s = s.replace(escaped_value, raw_value)
     return s
 
 
 def parse_function_call_and_arguments(function_name, function_call):
     """Split string function_call into an array of strings consisting of:
     * the string function_call followed by "("
     * the function call argument #1
     * ...
     * the function call argument #n
     * a trailing ");"
 
     The strings returned are in escaped form. See escape(...).
 
     >>> parse_function_call_and_arguments("foo", 'foo("%s", "foo");')
     ['foo(', '"%s",', ' "foo"', ')']
     >>> parse_function_call_and_arguments("foo", 'foo("%s", "foo");')
     ['foo(', '"%s",', ' "foo"', ')']
     >>> parse_function_call_and_arguments("foo", 'foo("%s %s", "foo", "bar");')
     ['foo(', '"%s %s",', ' "foo",', ' "bar"', ')']
     >>> parse_function_call_and_arguments("fooprintf", 'fooprintf("%050d", i);')
     ['fooprintf(', '"%050d",', ' i', ')']
     >>> parse_function_call_and_arguments("foo", 'foo(bar(foobar(barfoo("foo"))), foobar); barfoo')
     ['foo(', 'bar(foobar(barfoo("foo"))),', ' foobar', ')']
     >>> parse_function_call_and_arguments("foo", "foo()")
     ['foo(', '', ')']
     >>> parse_function_call_and_arguments("foo", "foo(123)")
     ['foo(', '123', ')']
     >>> parse_function_call_and_arguments("foo", 'foo("foo")')
     ['foo(', '"foo"', ')']
     """
     assert isinstance(function_name, str) and isinstance(
         function_call, str) and function_name
     remaining = normalize(escape(function_call))
     expected_function_call = "{}(".format(function_name)
     assert remaining.startswith(expected_function_call)
     parts = [expected_function_call]
     remaining = remaining[len(expected_function_call):]
     open_parentheses = 1
     in_string = False
     parts.append("")
     for char in remaining:
         parts.append(parts.pop() + char)
         if char == "\"":
             in_string = not in_string
             continue
         if in_string:
             continue
         if char == "(":
             open_parentheses += 1
             continue
         if char == ")":
             open_parentheses -= 1
         if open_parentheses > 1:
             continue
         if open_parentheses == 0:
             parts.append(parts.pop()[:-1])
             parts.append(char)
             break
         if char == ",":
             parts.append("")
     return parts
 
 
 def parse_string_content(argument):
     """Return the text within quotes in string argument.
 
     >>> parse_string_content('1 "foo %d bar" 2')
     'foo %d bar'
     >>> parse_string_content('1 foobar 2')
     ''
     >>> parse_string_content('1 "bar" 2')
     'bar'
     >>> parse_string_content('1 "foo" 2 "bar" 3')
     'foobar'
     >>> parse_string_content('1 "foo" 2 " " "bar" 3')
     'foo bar'
     >>> parse_string_content('""')
     ''
     >>> parse_string_content('')
     ''
     >>> parse_string_content('1 2 3')
     ''
     """
     assert isinstance(argument, str)
     string_content = ""
     in_string = False
     for char in normalize(escape(argument)):
         if char == "\"":
             in_string = not in_string
         elif in_string:
             string_content += char
     return string_content
 
 
 def count_format_specifiers(format_string):
     """Return the number of format specifiers in string format_string.
 
     >>> count_format_specifiers("foo bar foo")
     0
     >>> count_format_specifiers("foo %d bar foo")
     1
     >>> count_format_specifiers("foo %d bar %i foo")
     2
     >>> count_format_specifiers("foo %d bar %i foo %% foo")
     2
     >>> count_format_specifiers("foo %d bar %i foo %% foo %d foo")
     3
     >>> count_format_specifiers("foo %d bar %i foo %% foo %*d foo")
     4
     """
     assert isinstance(format_string, str)
     n = 0
     in_specifier = False
     for i, char in enumerate(format_string):
         if format_string[i - 1:i +
                          1] == "%%" or format_string[i:i + 2] == "%%":
             pass
         elif char == "%":
             in_specifier = True
             n += 1
         elif char in "aAcdeEfFgGinopsuxX":
             in_specifier = False
         elif in_specifier and char == "*":
             n += 1
     return n
 
 
 def main(args_in):
     """ Return a string output with information on string format errors
 
     >>> main(["test/lint/lint-format-strings-tests.txt"])
     test/lint/lint-format-strings-tests.txt: Expected 1 argument(s) after format string but found 2 argument(s): printf("%d", 1, 2)
     test/lint/lint-format-strings-tests.txt: Expected 2 argument(s) after format string but found 3 argument(s): printf("%a %b", 1, 2, "anything")
     test/lint/lint-format-strings-tests.txt: Expected 1 argument(s) after format string but found 0 argument(s): printf("%d")
     test/lint/lint-format-strings-tests.txt: Expected 3 argument(s) after format string but found 2 argument(s): printf("%a%b%z", 1, "anything")
 
     >>> main(["test/lint/lint-format-strings-tests-skip-arguments.txt"])
     test/lint/lint-format-strings-tests-skip-arguments.txt: Expected 1 argument(s) after format string but found 2 argument(s): fprintf(skipped, "%d", 1, 2)
     test/lint/lint-format-strings-tests-skip-arguments.txt: Expected 1 argument(s) after format string but found 0 argument(s): fprintf(skipped, "%d")
     test/lint/lint-format-strings-tests-skip-arguments.txt: Expected 1 argument(s) after format string but found 2 argument(s): snprintf(skip1, skip2, "%d", 1, 2)
     test/lint/lint-format-strings-tests-skip-arguments.txt: Expected 1 argument(s) after format string but found 0 argument(s): snprintf(skip1, skip2, "%d")
     test/lint/lint-format-strings-tests-skip-arguments.txt: Could not parse function call string "snprintf(...)": snprintf(skip1, "%d")
     """
     parser = argparse.ArgumentParser(description="This program checks that the number of arguments passed "
                                      "to a variadic format string function matches the number of format "
                                      "specifiers in the format string.")
     parser.add_argument("file", type=argparse.FileType(
         "r", encoding="utf-8"), nargs="*", help="C++ source code file (e.g. foo.cpp)")
     args = parser.parse_args(args_in)
 
     for f in args.file:
         file_content = f.read()
         for (function_name,
              skip_arguments) in FUNCTION_NAMES_AND_NUMBER_OF_LEADING_ARGUMENTS:
             for function_call_str in parse_function_calls(
                     function_name, file_content):
                 parts = parse_function_call_and_arguments(
                     function_name, function_call_str)
                 relevant_function_call_str = unescape("".join(parts))[:512]
                 if (f.name, relevant_function_call_str) in FALSE_POSITIVES:
                     continue
                 if len(parts) < 3 + skip_arguments:
                     print("{}: Could not parse function call string \"{}(...)\": {}".format(
                         f.name, function_name, relevant_function_call_str))
                     continue
                 argument_count = len(parts) - 3 - skip_arguments
                 format_str = parse_string_content(parts[1 + skip_arguments])
                 format_specifier_count = count_format_specifiers(format_str)
                 if format_specifier_count != argument_count:
                     print("{}: Expected {} argument(s) after format string but found {} argument(s): {}".format(
                         f.name, format_specifier_count, argument_count, relevant_function_call_str))
                     continue
 
 
 if __name__ == "__main__":
     doctest.testmod()
     main(sys.argv[1:])