From 99471fd308ee222f71908ae1f829167969baf02a Mon Sep 17 00:00:00 2001
From: Naviabheeman <45412531+Naviabheeman@users.noreply.github.com>
Date: Tue, 20 Jun 2023 13:01:39 +0530
Subject: [PATCH] Change boost classes to std classes (#268)

* replace boost::bind with td::bind and fix validation interface compilation

* remove boost::chrono

* change boost::variant to std::variant

* Revert "remove boost::chrono"

This reverts commit 434d8d77b8fc8d11c69dca0b3ba4c7e6618e1ef6.
---
 src/bench/block_assemble.cpp       |  2 +-
 src/federationparams.cpp           |  2 +-
 src/init.cpp                       |  7 ++--
 src/key_io.cpp                     |  7 ++--
 src/keystore.cpp                   |  2 +-
 src/primitives/xfield.cpp          | 13 +++---
 src/primitives/xfield.h            | 12 +++---
 src/qt/addresstablemodel.cpp       |  2 +-
 src/qt/clientmodel.cpp             | 14 +++----
 src/qt/coincontroldialog.cpp       |  4 +-
 src/qt/signverifymessagedialog.cpp |  5 ++-
 src/qt/splashscreen.cpp            |  6 +--
 src/qt/tapyrusgui.cpp              |  4 +-
 src/qt/transactionrecord.cpp       |  2 +-
 src/qt/transactiontablemodel.cpp   |  4 +-
 src/qt/walletmodel.cpp             | 12 +++---
 src/rpc/mining.cpp                 |  2 +-
 src/rpc/misc.cpp                   |  2 +-
 src/rpc/rawtransaction.cpp         |  8 ++--
 src/rpc/server.cpp                 |  7 ++--
 src/rpc/util.cpp                   |  4 +-
 src/rpc/util.h                     |  3 +-
 src/scheduler.cpp                  |  5 +--
 src/scheduler.h                    |  2 +-
 src/script/standard.cpp            |  6 +--
 src/script/standard.h              |  4 +-
 src/test/block_tests.cpp           |  8 ++--
 src/test/key_tests.cpp             | 10 ++---
 src/test/scheduler_tests.cpp       | 17 ++++----
 src/test/script_standard_tests.cpp | 24 ++++-------
 src/test/test_tapyrus.cpp          |  2 +-
 src/test/xfield_tests.cpp          |  4 +-
 src/torcontrol.cpp                 | 23 +++++------
 src/validation.cpp                 |  8 ++--
 src/validationinterface.cpp        | 60 ++++++++++++++-------------
 src/wallet/rpcdump.cpp             |  2 +-
 src/wallet/rpcwallet.cpp           | 66 +++++++++++++++---------------
 src/wallet/test/wallet_tests.cpp   |  6 +--
 src/wallet/wallet.cpp              |  8 ++--
 src/xfieldhistory.cpp              |  2 +-
 src/xfieldhistory.h                | 10 ++---
 test/lint/pending-lint-includes.sh |  4 --
 42 files changed, 189 insertions(+), 206 deletions(-)

diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index 1a0e84c66d..43cc919ad1 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -93,7 +93,7 @@ static void AssembleBlock(benchmark::State& state)
         ::pcoinsdbview.reset(new CCoinsViewDB(1 << 23, true));
         ::pcoinsTip.reset(new CCoinsViewCache(pcoinsdbview.get()));
 
-        thread_group.create_thread(boost::bind(&CScheduler::serviceQueue, &scheduler));
+        thread_group.create_thread(std::bind(&CScheduler::serviceQueue, &scheduler));
         GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
         LoadGenesisBlock();
         CValidationState state;
diff --git a/src/federationparams.cpp b/src/federationparams.cpp
index 27a6a9be88..9eb1fb8348 100644
--- a/src/federationparams.cpp
+++ b/src/federationparams.cpp
@@ -156,7 +156,7 @@ bool CFederationParams::ReadGenesisBlock(std::string genesisHex)
     switch(genesis.xfield.xfieldType)
     {
         case TAPYRUS_XFIELDTYPES::AGGPUBKEY: {
-            std::vector<unsigned char>* pubkey = &boost::get<XFieldAggPubKey>(genesis.xfield.xfieldValue).data;
+            std::vector<unsigned char>* pubkey = &std::get<XFieldAggPubKey>(genesis.xfield.xfieldValue).data;
             if(!pubkey->size())
                 throw std::runtime_error("Aggregate Public Key for Signed Block is empty");
 
diff --git a/src/init.cpp b/src/init.cpp
index 02a49f3d75..d26047e64a 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -59,7 +59,6 @@
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/split.hpp>
-#include <boost/bind.hpp>
 #include <boost/interprocess/sync/file_lock.hpp>
 #include <boost/thread.hpp>
 
@@ -1236,8 +1235,8 @@ bool AppInitMain()
     }
 
     // Start the lightweight task scheduler thread
-    CScheduler::Function serviceLoop = boost::bind(&CScheduler::serviceQueue, &scheduler);
-    threadGroup.create_thread(boost::bind(&TraceThread<CScheduler::Function>, "scheduler", serviceLoop));
+    CScheduler::Function serviceLoop = std::bind(&CScheduler::serviceQueue, &scheduler);
+    threadGroup.create_thread(std::bind(&TraceThread<CScheduler::Function>, "scheduler", serviceLoop));
 
     // Gather some entropy once per minute.
     scheduler.scheduleEvery([]{
@@ -1635,7 +1634,7 @@ bool AppInitMain()
         vImportFiles.push_back(strFile);
     }
 
-    threadGroup.create_thread(boost::bind(&ThreadImport, vImportFiles, fReloadxfield));
+    threadGroup.create_thread(std::bind(&ThreadImport, vImportFiles, fReloadxfield));
 
     // Wait for genesis block to be processed
     {
diff --git a/src/key_io.cpp b/src/key_io.cpp
index 2f4b76d6bc..7f82501096 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -10,8 +10,7 @@
 #include <script/script.h>
 #include <utilstrencodings.h>
 
-#include <boost/variant/apply_visitor.hpp>
-#include <boost/variant/static_visitor.hpp>
+#include <variant>
 
 #include <assert.h>
 #include <string.h>
@@ -20,7 +19,7 @@
 
 namespace
 {
-class DestinationEncoder : public boost::static_visitor<std::string>
+class DestinationEncoder
 {
 private:
     const CChainParams& m_params;
@@ -196,7 +195,7 @@ std::string EncodeExtKey(const CExtKey& key)
 
 std::string EncodeDestination(const CTxDestination& dest)
 {
-    return boost::apply_visitor(DestinationEncoder(Params()), dest);
+    return std::visit(DestinationEncoder(Params()), dest);
 }
 
 CTxDestination DecodeDestination(const std::string& str)
diff --git a/src/keystore.cpp b/src/keystore.cpp
index d53889820b..775eb0e3af 100644
--- a/src/keystore.cpp
+++ b/src/keystore.cpp
@@ -210,7 +210,7 @@ CKeyID GetKeyForDestination(const CKeyStore& store, const CTxDestination& dest)
 {
     // Only supports destinations which map to single public keys, i.e. P2PKH,
     // P2WPKH, and P2SH-P2WPKH.
-    if (auto id = boost::get<CKeyID>(&dest)) {
+    if (auto id = std::get_if<CKeyID>(&dest)) {
         return *id;
     }
     return CKeyID();
diff --git a/src/primitives/xfield.cpp b/src/primitives/xfield.cpp
index ebb815933e..c2dbbfd5ee 100644
--- a/src/primitives/xfield.cpp
+++ b/src/primitives/xfield.cpp
@@ -5,6 +5,7 @@
 #include <primitives/xfield.h>
 #include <tinyformat.h>
 #include <utilstrencodings.h>
+#include <variant>
 
 inline std::string XFieldAggPubKey::ToString() const {
     return HexStr(data);
@@ -16,7 +17,7 @@ inline std::string XFieldMaxBlockSize::ToString() const {
 
 template <typename T>
 bool GetXFieldValueFrom(XFieldData& xfieldValue, T& value) {
-    value = boost::get<T>(xfieldValue);
+    value = std::get<T>(xfieldValue);
     return std::atoi(value.BLOCKTREE_DB_KEY) == GetXFieldTypeFrom(xfieldValue);
 }
 
@@ -29,7 +30,7 @@ std::string CXField::ToString() const {
 
 bool CXField::IsValid() const {
     return ::IsValid(this->xfieldType)
-        && boost::apply_visitor(XFieldValidityVisitor(), this->xfieldValue)
+        && std::visit(XFieldValidityVisitor(), this->xfieldValue)
         && GetXFieldTypeFrom(this->xfieldValue) == this->xfieldType;
 }
 
@@ -37,9 +38,9 @@ std::string XFieldDataToString(const XFieldData &xfieldValue) {
     switch(GetXFieldTypeFrom(xfieldValue))
     {
         case TAPYRUS_XFIELDTYPES::AGGPUBKEY:
-            return boost::get<XFieldAggPubKey>(xfieldValue).ToString();
+            return std::get<XFieldAggPubKey>(xfieldValue).ToString();
         case TAPYRUS_XFIELDTYPES::MAXBLOCKSIZE:
-            return boost::get<XFieldMaxBlockSize>(xfieldValue).ToString();
+            return std::get<XFieldMaxBlockSize>(xfieldValue).ToString();
         case TAPYRUS_XFIELDTYPES::NONE:
         default:
             return "";
@@ -51,9 +52,9 @@ char GetXFieldDBKey(const XFieldData& xfieldValue) {
     switch(GetXFieldTypeFrom(xfieldValue))
     {
         case TAPYRUS_XFIELDTYPES::AGGPUBKEY:
-            return boost::get<XFieldAggPubKey>(xfieldValue).BLOCKTREE_DB_KEY;
+            return std::get<XFieldAggPubKey>(xfieldValue).BLOCKTREE_DB_KEY;
         case TAPYRUS_XFIELDTYPES::MAXBLOCKSIZE:
-            return boost::get<XFieldMaxBlockSize>(xfieldValue).BLOCKTREE_DB_KEY;
+            return std::get<XFieldMaxBlockSize>(xfieldValue).BLOCKTREE_DB_KEY;
         case TAPYRUS_XFIELDTYPES::NONE:
         default:
             return '\0';
diff --git a/src/primitives/xfield.h b/src/primitives/xfield.h
index 6568913290..ed86a9bbc9 100644
--- a/src/primitives/xfield.h
+++ b/src/primitives/xfield.h
@@ -10,7 +10,7 @@
 #include <uint256.h>
 #include <key.h>
 
-#include <boost/variant.hpp>
+#include <variant>
 #include <type_traits>
 #include <typeinfo>
 
@@ -122,7 +122,7 @@ class XFieldMaxBlockSize {
 /*
  * union of above classes to represent xfieldValue.
  */
-typedef boost::variant<
+typedef std::variant<
     XFieldEmpty,
     XFieldAggPubKey,
     XFieldMaxBlockSize> XFieldData;
@@ -131,7 +131,7 @@ typedef boost::variant<
  * This method defines the association between XFieldData and TAPYRUS_XFIELDTYPES
  */
 inline TAPYRUS_XFIELDTYPES GetXFieldTypeFrom(XFieldData xfieldDataIn) {
-    return TAPYRUS_XFIELDTYPES(xfieldDataIn.which());
+    return TAPYRUS_XFIELDTYPES(xfieldDataIn.index());
 }
 
 //Exception to identify xfield composition problems
@@ -223,9 +223,9 @@ struct CXField {
         switch(xfieldType)
         {
             case TAPYRUS_XFIELDTYPES::AGGPUBKEY:
-                ::Serialize(s, boost::get<XFieldAggPubKey>(xfieldValue)); break;
+                ::Serialize(s, std::get<XFieldAggPubKey>(xfieldValue)); break;
             case TAPYRUS_XFIELDTYPES::MAXBLOCKSIZE:
-                ::Serialize(s, boost::get<XFieldMaxBlockSize>(xfieldValue)); break;
+                ::Serialize(s, std::get<XFieldMaxBlockSize>(xfieldValue)); break;
             case TAPYRUS_XFIELDTYPES::NONE:
             default:
                 break;
@@ -269,7 +269,7 @@ struct CXField {
 };
 
 
-class XFieldValidityVisitor : public boost::static_visitor< bool >
+class XFieldValidityVisitor
 {
 public:
 
diff --git a/src/qt/addresstablemodel.cpp b/src/qt/addresstablemodel.cpp
index ac500bd5ad..c25a9b8eab 100644
--- a/src/qt/addresstablemodel.cpp
+++ b/src/qt/addresstablemodel.cpp
@@ -253,7 +253,7 @@ bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,
         } else if(index.column() == Address) {
             CTxDestination newAddress = DecodeDestination(value.toString().toStdString());
             // Refuse to set invalid address, set error status and return false
-            if(boost::get<CNoDestination>(&newAddress))
+            if(std::get_if<CNoDestination>(&newAddress))
             {
                 editStatus = INVALID_ADDRESS;
                 return false;
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
index c40a6703a7..baf6c8110b 100644
--- a/src/qt/clientmodel.cpp
+++ b/src/qt/clientmodel.cpp
@@ -247,13 +247,13 @@ static void BlockTipChanged(ClientModel *clientmodel, bool initialSync, int heig
 void ClientModel::subscribeToCoreSignals()
 {
     // Connect signals to client
-    m_handler_show_progress = m_node.handleShowProgress(boost::bind(ShowProgress, this, boost::placeholders::_1, boost::placeholders::_2));
-    m_handler_notify_num_connections_changed = m_node.handleNotifyNumConnectionsChanged(boost::bind(NotifyNumConnectionsChanged, this, boost::placeholders::_1));
-    m_handler_notify_network_active_changed = m_node.handleNotifyNetworkActiveChanged(boost::bind(NotifyNetworkActiveChanged, this, boost::placeholders::_1));
-    m_handler_notify_alert_changed = m_node.handleNotifyAlertChanged(boost::bind(NotifyAlertChanged, this));
-    m_handler_banned_list_changed = m_node.handleBannedListChanged(boost::bind(BannedListChanged, this));
-    m_handler_notify_block_tip = m_node.handleNotifyBlockTip(boost::bind(BlockTipChanged, this, boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3, boost::placeholders::_4, false));
-    m_handler_notify_header_tip = m_node.handleNotifyHeaderTip(boost::bind(BlockTipChanged, this, boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3, boost::placeholders::_4, true));
+    m_handler_show_progress = m_node.handleShowProgress(std::bind(ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
+    m_handler_notify_num_connections_changed = m_node.handleNotifyNumConnectionsChanged(std::bind(NotifyNumConnectionsChanged, this, std::placeholders::_1));
+    m_handler_notify_network_active_changed = m_node.handleNotifyNetworkActiveChanged(std::bind(NotifyNetworkActiveChanged, this, std::placeholders::_1));
+    m_handler_notify_alert_changed = m_node.handleNotifyAlertChanged(std::bind(NotifyAlertChanged, this));
+    m_handler_banned_list_changed = m_node.handleBannedListChanged(std::bind(BannedListChanged, this));
+    m_handler_notify_block_tip = m_node.handleNotifyBlockTip(std::bind(BlockTipChanged, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, false));
+    m_handler_notify_header_tip = m_node.handleNotifyHeaderTip(std::bind(BlockTipChanged, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, true));
 }
 
 void ClientModel::unsubscribeFromCoreSignals()
diff --git a/src/qt/coincontroldialog.cpp b/src/qt/coincontroldialog.cpp
index 178e58f2d5..4ed6132ea3 100644
--- a/src/qt/coincontroldialog.cpp
+++ b/src/qt/coincontroldialog.cpp
@@ -466,8 +466,8 @@ void CoinControlDialog::updateLabels(WalletModel *model, QDialog* dialog)
         if(ExtractDestination(out.txout.scriptPubKey, address))
         {
             CPubKey pubkey;
-            CKeyID *keyid = boost::get<CKeyID>(&address);
-            if (keyid && model->wallet().getPubKey(*keyid, pubkey))
+            CKeyID &keyid = std::get<CKeyID>(address);
+            if (model->wallet().getPubKey(keyid, pubkey))
             {
                 nBytesInputs += (pubkey.IsCompressed() ? 148 : 180);
             }
diff --git a/src/qt/signverifymessagedialog.cpp b/src/qt/signverifymessagedialog.cpp
index 487fc9ee1e..49d3af1ffa 100644
--- a/src/qt/signverifymessagedialog.cpp
+++ b/src/qt/signverifymessagedialog.cpp
@@ -120,7 +120,7 @@ void SignVerifyMessageDialog::on_signMessageButton_SM_clicked()
         ui->statusLabel_SM->setText(tr("The entered address is invalid.") + QString(" ") + tr("Please check the address and try again."));
         return;
     }
-    const CKeyID* keyID = boost::get<CKeyID>(&destination);
+    const CKeyID* keyID = std::get_if<CKeyID>(&destination);
     if (!keyID) {
         ui->addressIn_SM->setValid(false);
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
@@ -198,7 +198,8 @@ void SignVerifyMessageDialog::on_verifyMessageButton_VM_clicked()
         ui->statusLabel_VM->setText(tr("The entered address is invalid.") + QString(" ") + tr("Please check the address and try again."));
         return;
     }
-    if (!boost::get<CKeyID>(&destination)) {
+    CKeyID* pdest = std::get_if<CKeyID>(&destination);
+    if (!pdest) {
         ui->addressIn_VM->setValid(false);
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(tr("The entered address does not refer to a key.") + QString(" ") + tr("Please check the address and try again."));
diff --git a/src/qt/splashscreen.cpp b/src/qt/splashscreen.cpp
index 3620186f7b..6edd710eee 100644
--- a/src/qt/splashscreen.cpp
+++ b/src/qt/splashscreen.cpp
@@ -178,7 +178,7 @@ static void ShowProgress(SplashScreen *splash, const std::string &title, int nPr
 #ifdef ENABLE_WALLET
 void SplashScreen::ConnectWallet(std::unique_ptr<interfaces::Wallet> wallet)
 {
-    m_connected_wallet_handlers.emplace_back(wallet->handleShowProgress(boost::bind(ShowProgress, this, boost::placeholders::_1, boost::placeholders::_2, false)));
+    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
@@ -186,8 +186,8 @@ void SplashScreen::ConnectWallet(std::unique_ptr<interfaces::Wallet> wallet)
 void SplashScreen::subscribeToCoreSignals()
 {
     // Connect signals to client
-    m_handler_init_message = m_node.handleInitMessage(boost::bind(InitMessage, this, boost::placeholders::_1));
-    m_handler_show_progress = m_node.handleShowProgress(boost::bind(ShowProgress, this, boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3));
+    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
diff --git a/src/qt/tapyrusgui.cpp b/src/qt/tapyrusgui.cpp
index 24a221cede..a54dfb26a6 100644
--- a/src/qt/tapyrusgui.cpp
+++ b/src/qt/tapyrusgui.cpp
@@ -1221,8 +1221,8 @@ static bool ThreadSafeMessageBox(TapyrusGUI *gui, const std::string& message, co
 void TapyrusGUI::subscribeToCoreSignals()
 {
     // Connect signals to client
-    m_handler_message_box = m_node.handleMessageBox(boost::bind(ThreadSafeMessageBox, this, boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3));
-    m_handler_question = m_node.handleQuestion(boost::bind(ThreadSafeMessageBox, this, boost::placeholders::_1, boost::placeholders::_3, boost::placeholders::_4));
+    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 TapyrusGUI::unsubscribeFromCoreSignals()
diff --git a/src/qt/transactionrecord.cpp b/src/qt/transactionrecord.cpp
index a6d91b9802..73cad256cd 100644
--- a/src/qt/transactionrecord.cpp
+++ b/src/qt/transactionrecord.cpp
@@ -120,7 +120,7 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(const interface
                     continue;
                 }
 
-                if (!boost::get<CNoDestination>(&wtx.txout_address[nOut]))
+                if (!std::get_if<CNoDestination>(&wtx.txout_address[nOut]))
                 {
                     // Sent to Bitcoin Address
                     sub.type = TransactionRecord::SendToAddress;
diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
index e787de0302..95b4238246 100644
--- a/src/qt/transactiontablemodel.cpp
+++ b/src/qt/transactiontablemodel.cpp
@@ -736,8 +736,8 @@ static void ShowProgress(TransactionTableModel *ttm, const std::string &title, i
 void TransactionTableModel::subscribeToCoreSignals()
 {
     // Connect signals to wallet
-    m_handler_transaction_changed = walletModel->wallet().handleTransactionChanged(boost::bind(NotifyTransactionChanged, this, boost::placeholders::_1, boost::placeholders::_2));
-    m_handler_show_progress = walletModel->wallet().handleShowProgress(boost::bind(ShowProgress, this, boost::placeholders::_1, boost::placeholders::_2));
+    m_handler_transaction_changed = walletModel->wallet().handleTransactionChanged(std::bind(NotifyTransactionChanged, this, std::placeholders::_1, std::placeholders::_2));
+    m_handler_show_progress = walletModel->wallet().handleShowProgress(std::bind(ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
 }
 
 void TransactionTableModel::unsubscribeFromCoreSignals()
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
index bb013ab7b3..64f53671e4 100644
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -387,12 +387,12 @@ static void NotifyWatchonlyChanged(WalletModel *walletmodel, bool fHaveWatchonly
 void WalletModel::subscribeToCoreSignals()
 {
     // Connect signals to wallet
-    m_handler_unload = m_wallet->handleUnload(boost::bind(&NotifyUnload, this));
-    m_handler_status_changed = m_wallet->handleStatusChanged(boost::bind(&NotifyKeyStoreStatusChanged, this));
-    m_handler_address_book_changed = m_wallet->handleAddressBookChanged(boost::bind(NotifyAddressBookChanged, this, boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3, boost::placeholders::_4, boost::placeholders::_5));
-    m_handler_transaction_changed = m_wallet->handleTransactionChanged(boost::bind(NotifyTransactionChanged, this, boost::placeholders::_1, boost::placeholders::_2));
-    m_handler_show_progress = m_wallet->handleShowProgress(boost::bind(ShowProgress, this, boost::placeholders::_1, boost::placeholders::_2));
-    m_handler_watch_only_changed = m_wallet->handleWatchOnlyChanged(boost::bind(NotifyWatchonlyChanged, this, boost::placeholders::_1));
+    m_handler_unload = m_wallet->handleUnload(std::bind(&NotifyUnload, this));
+    m_handler_status_changed = m_wallet->handleStatusChanged(std::bind(&NotifyKeyStoreStatusChanged, this));
+    m_handler_address_book_changed = m_wallet->handleAddressBookChanged(std::bind(NotifyAddressBookChanged, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5));
+    m_handler_transaction_changed = m_wallet->handleTransactionChanged(std::bind(NotifyTransactionChanged, this, std::placeholders::_1, std::placeholders::_2));
+    m_handler_show_progress = m_wallet->handleShowProgress(std::bind(ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
+    m_handler_watch_only_changed = m_wallet->handleWatchOnlyChanged(std::bind(NotifyWatchonlyChanged, this, std::placeholders::_1));
 }
 
 void WalletModel::unsubscribeFromCoreSignals()
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index c4617878d1..b6afacc71e 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -201,7 +201,7 @@ UniValue getnewblock(const JSONRPCRequest& request)
                 if(!xfieldString.size() || !ParseUInt32(xfieldString, &val))
                     throw JSONRPCError(RPC_INVALID_PARAMS, "xfield max block size was invalid. It is expected to be <xfield_type:new_xfield_value>.");
                 xfield.xfieldValue = XFieldMaxBlockSize(val);
-                if(!boost::apply_visitor(XFieldValidityVisitor(), xfield.xfieldValue))
+                if(!std::visit(XFieldValidityVisitor(), xfield.xfieldValue))
                     throw JSONRPCError(RPC_INVALID_PARAMS, "xfield max block size was invalid. It is expected to be a positive quantity between 1000 and 4294967295.");
                 xfield.xfieldType = TAPYRUS_XFIELDTYPES::MAXBLOCKSIZE;
             }
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 5dc9771206..da6b815e2e 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -179,7 +179,7 @@ static UniValue verifymessage(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
-    const CKeyID *keyID = boost::get<CKeyID>(&destination);
+    const CKeyID *keyID = std::get_if<CKeyID>(&destination);
     if (!keyID) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 01a797c39f..a9d182d0ad 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -427,10 +427,10 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
                 throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + name_);
             }
             ColorIdentifier colorId;
-            if(destination.which() == 3)
-                colorId = boost::get<CColorKeyID>(destination).color;
-            else if(destination.which() == 4)
-                colorId = boost::get<CColorScriptID>(destination).color;
+            if(destination.index() == 3)
+                colorId = std::get<CColorKeyID>(destination).color;
+            else if(destination.index() == 4)
+                colorId = std::get<CColorScriptID>(destination).color;
 
             CScript scriptPubKey = GetScriptForDestination(destination);
             CAmount nAmount = (colorId.type == TokenTypes::NONE ? AmountFromValue(outputs[name_]) : TokenAmountFromValue(outputs[name_]));
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
index c95c78a2e9..80c7bf81d7 100644
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -15,7 +15,6 @@
 #include <util.h>
 #include <utilstrencodings.h>
 
-#include <boost/bind.hpp>
 #include <boost/signals2/signal.hpp>
 #include <boost/algorithm/string/case_conv.hpp> // for to_upper()
 #include <boost/algorithm/string/classification.hpp>
@@ -520,9 +519,9 @@ std::vector<std::string> CRPCTable::listCommands() const
     std::vector<std::string> commandList;
     typedef std::map<std::string, const CRPCCommand*> commandMap;
 
-    std::transform( mapCommands.begin(), mapCommands.end(),
-                   std::back_inserter(commandList),
-                   boost::bind(&commandMap::value_type::first, boost::placeholders::_1) );
+    for (const auto& i : mapCommands)
+        commandList.emplace_back(i.first);
+
     return commandList;
 }
 
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 51561d653b..ab4dc5a933 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -66,7 +66,7 @@ CScript CreateMultisigRedeemscript(const int required, const std::vector<CPubKey
     return result;
 }
 
-class DescribeAddressVisitor : public boost::static_visitor<UniValue>
+class DescribeAddressVisitor
 {
 public:
     explicit DescribeAddressVisitor() {}
@@ -113,5 +113,5 @@ class DescribeAddressVisitor : public boost::static_visitor<UniValue>
 
 UniValue DescribeAddress(const CTxDestination& dest)
 {
-    return boost::apply_visitor(DescribeAddressVisitor(), dest);
+    return std::visit(DescribeAddressVisitor(), dest);
 }
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 0a3a156e45..fdc5c1451b 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -9,8 +9,7 @@
 #include <script/standard.h>
 #include <univalue.h>
 
-#include <boost/variant/static_visitor.hpp>
-
+#include <variant>
 #include <string>
 #include <vector>
 
diff --git a/src/scheduler.cpp b/src/scheduler.cpp
index 1dde16162e..d2b882d842 100644
--- a/src/scheduler.cpp
+++ b/src/scheduler.cpp
@@ -8,7 +8,6 @@
 #include <reverselock.h>
 
 #include <assert.h>
-#include <boost/bind.hpp>
 #include <utility>
 
 CScheduler::CScheduler() : nThreadsServicingQueue(0), stopRequested(false), stopWhenEmpty(false)
@@ -118,12 +117,12 @@ void CScheduler::scheduleFromNow(CScheduler::Function f, int64_t deltaMilliSecon
 static void Repeat(CScheduler* s, CScheduler::Function f, int64_t deltaMilliSeconds)
 {
     f();
-    s->scheduleFromNow(boost::bind(&Repeat, s, f, deltaMilliSeconds), deltaMilliSeconds);
+    s->scheduleFromNow(std::bind(&Repeat, s, f, deltaMilliSeconds), deltaMilliSeconds);
 }
 
 void CScheduler::scheduleEvery(CScheduler::Function f, int64_t deltaMilliSeconds)
 {
-    scheduleFromNow(boost::bind(&Repeat, this, f, deltaMilliSeconds), deltaMilliSeconds);
+    scheduleFromNow(std::bind(&Repeat, this, f, deltaMilliSeconds), deltaMilliSeconds);
 }
 
 size_t CScheduler::getQueueInfo(boost::chrono::system_clock::time_point &first,
diff --git a/src/scheduler.h b/src/scheduler.h
index 0c2551cf4f..a1c064ef1e 100644
--- a/src/scheduler.h
+++ b/src/scheduler.h
@@ -25,7 +25,7 @@
 // CScheduler* s = new CScheduler();
 // s->scheduleFromNow(doSomething, 11); // Assuming a: void doSomething() { }
 // s->scheduleFromNow(std::bind(Class::func, this, argument), 3);
-// boost::thread* t = new boost::thread(boost::bind(CScheduler::serviceQueue, s));
+// boost::thread* t = new boost::thread(std::bind(CScheduler::serviceQueue, s));
 //
 // ... then at program shutdown, clean up the thread running serviceQueue:
 // t->interrupt();
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index db103feeb7..01c0e03187 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -319,7 +319,7 @@ bool ExtractDestinations(const CScript& scriptPubKey, txnouttype& typeRet, std::
 
 namespace
 {
-class CScriptVisitor : public boost::static_visitor<bool>
+class CScriptVisitor
 {
 private:
     CScript *script;
@@ -363,7 +363,7 @@ CScript GetScriptForDestination(const CTxDestination& dest)
 {
     CScript script;
 
-    boost::apply_visitor(CScriptVisitor(&script), dest);
+    std::visit(CScriptVisitor(&script), dest);
     return script;
 }
 
@@ -384,5 +384,5 @@ CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys)
 }
 
 bool IsValidDestination(const CTxDestination& dest) {
-    return dest.which() != 0;
+    return dest.index() != 0;
 }
\ No newline at end of file
diff --git a/src/script/standard.h b/src/script/standard.h
index c4c6a77410..4ef3fcb8b1 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -10,7 +10,7 @@
 #include <script/interpreter.h>
 #include <uint256.h>
 
-#include <boost/variant.hpp>
+#include <variant>
 
 #include <stdint.h>
 
@@ -81,7 +81,7 @@ class CNoDestination {
  *  A CTxDestination is the internal data type encoded in a bitcoin address
  */
 
-typedef boost::variant<
+typedef std::variant<
     CNoDestination,
     CKeyID,
     CScriptID,
diff --git a/src/test/block_tests.cpp b/src/test/block_tests.cpp
index 8c4dffcd4f..9e853c1e91 100644
--- a/src/test/block_tests.cpp
+++ b/src/test/block_tests.cpp
@@ -218,7 +218,7 @@ BOOST_AUTO_TEST_CASE(blockHeaderWithxfieldType2_xfield365)
 
     BOOST_CHECK(blockHeader.xfield.IsValid());
     BOOST_CHECK(blockHeader.xfield.xfieldType == TAPYRUS_XFIELDTYPES::MAXBLOCKSIZE);
-    int32_t size = boost::get<XFieldMaxBlockSize>(blockHeader.xfield.xfieldValue).data;
+    int32_t size = std::get<XFieldMaxBlockSize>(blockHeader.xfield.xfieldValue).data;
     BOOST_CHECK_EQUAL(size, 1090612733);
     BOOST_CHECK_EQUAL(blockHeader.proof.size(), 71);//interpreted incorrectly
 }
@@ -231,7 +231,7 @@ BOOST_AUTO_TEST_CASE(blockHeaderWithxfieldType2_xfield0)
 
     BOOST_CHECK(blockHeader.xfield.IsValid());
     BOOST_CHECK(blockHeader.xfield.xfieldType == TAPYRUS_XFIELDTYPES::MAXBLOCKSIZE);
-    int32_t size = boost::get<XFieldMaxBlockSize>(blockHeader.xfield.xfieldValue).data;
+    int32_t size = std::get<XFieldMaxBlockSize>(blockHeader.xfield.xfieldValue).data;
     BOOST_CHECK_EQUAL(size, 809976064);
     BOOST_CHECK_EQUAL(blockHeader.proof.size(), 69);//interpreted incorrectly
 }
@@ -245,7 +245,7 @@ BOOST_AUTO_TEST_CASE(blockHeaderWithxfieldType2_maxblocksize)
 
     BOOST_CHECK(blockHeader.xfield.IsValid());
     BOOST_CHECK(blockHeader.xfield.xfieldType == TAPYRUS_XFIELDTYPES::MAXBLOCKSIZE);
-    int32_t size = boost::get<XFieldMaxBlockSize>(blockHeader.xfield.xfieldValue).data;
+    int32_t size = std::get<XFieldMaxBlockSize>(blockHeader.xfield.xfieldValue).data;
     BOOST_CHECK_EQUAL(size, 400000);
     BOOST_CHECK_EQUAL(blockHeader.proof.size(), 65);
 }
@@ -258,7 +258,7 @@ BOOST_AUTO_TEST_CASE(blockHeaderWithxfieldType2_maxblocksize2)
 
     BOOST_CHECK(blockHeader.xfield.IsValid());
     BOOST_CHECK(blockHeader.xfield.xfieldType == TAPYRUS_XFIELDTYPES::MAXBLOCKSIZE);
-    int32_t size = boost::get<XFieldMaxBlockSize>(blockHeader.xfield.xfieldValue).data;
+    int32_t size = std::get<XFieldMaxBlockSize>(blockHeader.xfield.xfieldValue).data;
     BOOST_CHECK_EQUAL(size, -2147483648);
     BOOST_CHECK_EQUAL(blockHeader.proof.size(), 65);
 }
diff --git a/src/test/key_tests.cpp b/src/test/key_tests.cpp
index 08774b747a..342c229e6d 100644
--- a/src/test/key_tests.cpp
+++ b/src/test/key_tests.cpp
@@ -79,13 +79,13 @@ BOOST_AUTO_TEST_CASE(key_test1)
     BOOST_CHECK(DecodeDestination(addr2C) == CTxDestination(pubkey2C.GetID()));
     //valid color address
     CTxDestination dest = DecodeDestination(caddr1);
-    BOOST_CHECK(dest != CTxDestination(pubkey1.GetID()));
-    BOOST_CHECK(dest.which() ==  3);
-    BOOST_CHECK(boost::get<CColorKeyID>(dest).color.type == TokenTypes::REISSUABLE);
-    BOOST_CHECK(boost::get<CColorKeyID>(dest).color.toVector().size() == 33);
+    BOOST_CHECK(dest.index() != CTxDestination(pubkey1.GetID()).index());
+    BOOST_CHECK(dest.index() ==  3);
+    BOOST_CHECK(std::get<CColorKeyID>(dest).color.type == TokenTypes::REISSUABLE);
+    BOOST_CHECK(std::get<CColorKeyID>(dest).color.toVector().size() == 33);
     //invalid color address
     dest = DecodeDestination(caddr2);
-    BOOST_CHECK(dest.which() ==  0);
+    BOOST_CHECK(dest.index() ==  0);
 
     for (int n=0; n<16; n++)
     {
diff --git a/src/test/scheduler_tests.cpp b/src/test/scheduler_tests.cpp
index f4f26b5588..edc43dd870 100644
--- a/src/test/scheduler_tests.cpp
+++ b/src/test/scheduler_tests.cpp
@@ -8,7 +8,6 @@
 
 #include <test/test_tapyrus.h>
 
-#include <boost/bind.hpp>
 #include <boost/thread.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -22,7 +21,7 @@ static void microTask(CScheduler& s, boost::mutex& mutex, int& counter, int delt
     }
     boost::chrono::system_clock::time_point noTime = boost::chrono::system_clock::time_point::min();
     if (rescheduleTime != noTime) {
-        CScheduler::Function f = boost::bind(&microTask, boost::ref(s), boost::ref(mutex), boost::ref(counter), -delta + 1, noTime);
+        CScheduler::Function f = std::bind(&microTask, std::ref(s), std::ref(mutex), std::ref(counter), -delta + 1, noTime);
         s.schedule(f, rescheduleTime);
     }
 }
@@ -63,8 +62,8 @@ BOOST_AUTO_TEST_CASE(manythreads)
         boost::chrono::system_clock::time_point t = now + boost::chrono::microseconds(randomMsec(rng));
         boost::chrono::system_clock::time_point tReschedule = now + boost::chrono::microseconds(500 + randomMsec(rng));
         int whichCounter = zeroToNine(rng);
-        CScheduler::Function f = boost::bind(&microTask, boost::ref(microTasks),
-                                             boost::ref(counterMutex[whichCounter]), boost::ref(counter[whichCounter]),
+        CScheduler::Function f = std::bind(&microTask, std::ref(microTasks),
+                                             std::ref(counterMutex[whichCounter]), std::ref(counter[whichCounter]),
                                              randomDelta(rng), tReschedule);
         microTasks.schedule(f, t);
     }
@@ -76,20 +75,20 @@ BOOST_AUTO_TEST_CASE(manythreads)
     // As soon as these are created they will start running and servicing the queue
     boost::thread_group microThreads;
     for (int i = 0; i < 5; i++)
-        microThreads.create_thread(boost::bind(&CScheduler::serviceQueue, &microTasks));
+        microThreads.create_thread(std::bind(&CScheduler::serviceQueue, &microTasks));
 
     MicroSleep(600);
     now = boost::chrono::system_clock::now();
 
     // More threads and more tasks:
     for (int i = 0; i < 5; i++)
-        microThreads.create_thread(boost::bind(&CScheduler::serviceQueue, &microTasks));
+        microThreads.create_thread(std::bind(&CScheduler::serviceQueue, &microTasks));
     for (int i = 0; i < 100; i++) {
         boost::chrono::system_clock::time_point t = now + boost::chrono::microseconds(randomMsec(rng));
         boost::chrono::system_clock::time_point tReschedule = now + boost::chrono::microseconds(500 + randomMsec(rng));
         int whichCounter = zeroToNine(rng);
-        CScheduler::Function f = boost::bind(&microTask, boost::ref(microTasks),
-                                             boost::ref(counterMutex[whichCounter]), boost::ref(counter[whichCounter]),
+        CScheduler::Function f = std::bind(&microTask, std::ref(microTasks),
+                                             std::ref(counterMutex[whichCounter]), std::ref(counter[whichCounter]),
                                              randomDelta(rng), tReschedule);
         microTasks.schedule(f, t);
     }
@@ -120,7 +119,7 @@ BOOST_AUTO_TEST_CASE(singlethreadedscheduler_ordered)
     // if they don't we'll get out of order behaviour
     boost::thread_group threads;
     for (int i = 0; i < 5; ++i) {
-        threads.create_thread(boost::bind(&CScheduler::serviceQueue, &scheduler));
+        threads.create_thread(std::bind(&CScheduler::serviceQueue, &scheduler));
     }
 
     // these are not atomic, if SinglethreadedSchedulerClient prevents
diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
index 60bee92a0c..53a11c3c91 100644
--- a/src/test/script_standard_tests.cpp
+++ b/src/test/script_standard_tests.cpp
@@ -209,23 +209,20 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
     s.clear();
     s << ToByteVector(pubkey) << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<CKeyID>(&address) &&
-                *boost::get<CKeyID>(&address) == pubkey.GetID());
+    BOOST_CHECK(std::get<CKeyID>(address) == pubkey.GetID());
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<CKeyID>(&address) &&
-                *boost::get<CKeyID>(&address) == pubkey.GetID());
+    BOOST_CHECK(std::get<CKeyID>(address) == pubkey.GetID());
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<CScriptID>(&address) &&
-                *boost::get<CScriptID>(&address) == CScriptID(redeemScript));
+    BOOST_CHECK(std::get<CScriptID>(address) == CScriptID(redeemScript));
 
     // TX_MULTISIG
     s.clear();
@@ -260,8 +257,7 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEY);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
-    BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
-                *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
+    BOOST_CHECK(std::get<CKeyID>(addresses[0]) == pubkeys[0].GetID());
 
     // TX_PUBKEYHASH
     s.clear();
@@ -270,8 +266,7 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
-    BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
-                *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
+    BOOST_CHECK(std::get<CKeyID>(addresses[0]) == pubkeys[0].GetID());
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
@@ -281,8 +276,7 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
-    BOOST_CHECK(boost::get<CScriptID>(&addresses[0]) &&
-                *boost::get<CScriptID>(&addresses[0]) == CScriptID(redeemScript));
+    BOOST_CHECK(std::get<CScriptID>(addresses[0]) == CScriptID(redeemScript));
 
     // TX_MULTISIG
     s.clear();
@@ -294,10 +288,8 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
     BOOST_CHECK_EQUAL(addresses.size(), 2U);
     BOOST_CHECK_EQUAL(nRequired, 2);
-    BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
-                *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
-    BOOST_CHECK(boost::get<CKeyID>(&addresses[1]) &&
-                *boost::get<CKeyID>(&addresses[1]) == pubkeys[1].GetID());
+    BOOST_CHECK(std::get<CKeyID>(addresses[0]) == pubkeys[0].GetID());
+    BOOST_CHECK(std::get<CKeyID>(addresses[1]) == pubkeys[1].GetID());
 
     // TX_NULL_DATA
     s.clear();
diff --git a/src/test/test_tapyrus.cpp b/src/test/test_tapyrus.cpp
index 378cfb52c5..0b4c89f3a7 100644
--- a/src/test/test_tapyrus.cpp
+++ b/src/test/test_tapyrus.cpp
@@ -98,7 +98,7 @@ TestingSetup::TestingSetup(const std::string& chainName) : BasicTestingSetup(cha
 
         // We have to run a scheduler thread to prevent ActivateBestChain
         // from blocking due to queue overrun.
-        threadGroup.create_thread(boost::bind(&CScheduler::serviceQueue, &scheduler));
+        threadGroup.create_thread(std::bind(&CScheduler::serviceQueue, &scheduler));
         GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
 
         mempool.setSanityCheck(1.0);
diff --git a/src/test/xfield_tests.cpp b/src/test/xfield_tests.cpp
index 85b596536f..33b5c2b5d0 100644
--- a/src/test/xfield_tests.cpp
+++ b/src/test/xfield_tests.cpp
@@ -27,7 +27,7 @@ BOOST_AUTO_TEST_CASE(XFieldChange_deserialize)
 
     BOOST_CHECK(xfieldList.xfieldChanges.size() == 1);
 
-    CPubKey pubkey(boost::get<XFieldAggPubKey>(xfieldList.xfieldChanges[0].xfieldValue).data),
+    CPubKey pubkey(std::get<XFieldAggPubKey>(xfieldList.xfieldChanges[0].xfieldValue).data),
     pubkeyActual(ParseHex("02473757a955a23f75379820f3071abf5b3343b78eb54e52373d06259ffa6c550b"));
     BOOST_CHECK(std::equal(pubkey.begin(), pubkey.end(), pubkeyActual.begin()));
     BOOST_CHECK(xfieldList.xfieldChanges[0].height == 0);
@@ -38,7 +38,7 @@ BOOST_AUTO_TEST_CASE(XFieldChange_deserialize)
     stream2 >> xfieldList2;
 
     BOOST_CHECK(xfieldList2.xfieldChanges.size() == 1);
-    uint32_t maxblocksize = boost::get<XFieldMaxBlockSize>(xfieldList2.xfieldChanges[0].xfieldValue).data;
+    uint32_t maxblocksize = std::get<XFieldMaxBlockSize>(xfieldList2.xfieldChanges[0].xfieldValue).data;
 
     BOOST_CHECK(maxblocksize == 0xffffffff);
     BOOST_CHECK(xfieldList2.xfieldChanges[0].height == 0);
diff --git a/src/torcontrol.cpp b/src/torcontrol.cpp
index c88f61f1ec..8683dfbb72 100644
--- a/src/torcontrol.cpp
+++ b/src/torcontrol.cpp
@@ -15,7 +15,6 @@
 #include <set>
 #include <stdlib.h>
 
-#include <boost/bind.hpp>
 #include <boost/signals2/signal.hpp>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
@@ -459,8 +458,8 @@ TorController::TorController(struct event_base* _base, const std::string& _targe
     if (!reconnect_ev)
         LogPrintf("tor: Failed to create event for reconnection: out of memory?\n");
     // Start connection attempts immediately
-    if (!conn.Connect(_target, boost::bind(&TorController::connected_cb, this, _1),
-         boost::bind(&TorController::disconnected_cb, this, _1) )) {
+    if (!conn.Connect(_target, std::bind(&TorController::connected_cb, this, std::placeholders::_1),
+         std::bind(&TorController::disconnected_cb, this, std::placeholders::_1) )) {
         LogPrintf("tor: Initiating connection to Tor control port %s failed\n", _target);
     }
     // Read service private key if cached
@@ -538,7 +537,7 @@ void TorController::auth_cb(TorControlConnection& _conn, const TorControlReply&
         // Note that the 'virtual' port doesn't have to be the same as our internal port, but this is just a convenient
         // choice.  TODO; refactor the shutdown sequence some day.
         _conn.Command(strprintf("ADD_ONION %s Port=%i,127.0.0.1:%i", private_key, GetListenPort(), GetListenPort()),
-            boost::bind(&TorController::add_onion_cb, this, _1, _2));
+            std::bind(&TorController::add_onion_cb, this, std::placeholders::_1, std::placeholders::_2));
     } else {
         LogPrintf("tor: Authentication failed\n");
     }
@@ -597,7 +596,7 @@ void TorController::authchallenge_cb(TorControlConnection& _conn, const TorContr
             }
 
             std::vector<uint8_t> computedClientHash = ComputeResponse(TOR_SAFE_CLIENTKEY, cookie, clientNonce, serverNonce);
-            _conn.Command("AUTHENTICATE " + HexStr(computedClientHash), boost::bind(&TorController::auth_cb, this, _1, _2));
+            _conn.Command("AUTHENTICATE " + HexStr(computedClientHash), std::bind(&TorController::auth_cb, this, std::placeholders::_1, std::placeholders::_2));
         } else {
             LogPrintf("tor: Invalid reply to AUTHCHALLENGE\n");
         }
@@ -646,23 +645,23 @@ void TorController::protocolinfo_cb(TorControlConnection& _conn, const TorContro
             if (methods.count("HASHEDPASSWORD")) {
                 LogPrint(BCLog::TOR, "tor: Using HASHEDPASSWORD authentication\n");
                 boost::replace_all(torpassword, "\"", "\\\"");
-                _conn.Command("AUTHENTICATE \"" + torpassword + "\"", boost::bind(&TorController::auth_cb, this, _1, _2));
+                _conn.Command("AUTHENTICATE \"" + torpassword + "\"", std::bind(&TorController::auth_cb, this, std::placeholders::_1, std::placeholders::_2));
             } else {
                 LogPrintf("tor: Password provided with -torpassword, but HASHEDPASSWORD authentication is not available\n");
             }
         } else if (methods.count("NULL")) {
             LogPrint(BCLog::TOR, "tor: Using NULL authentication\n");
-            _conn.Command("AUTHENTICATE", boost::bind(&TorController::auth_cb, this, _1, _2));
+            _conn.Command("AUTHENTICATE", std::bind(&TorController::auth_cb, this, std::placeholders::_1, std::placeholders::_2));
         } else if (methods.count("SAFECOOKIE")) {
             // Cookie: hexdump -e '32/1 "%02x""\n"'  ~/.tor/control_auth_cookie
             LogPrint(BCLog::TOR, "tor: Using SAFECOOKIE authentication, reading cookie authentication from %s\n", cookiefile);
             std::pair<bool,std::string> status_cookie = ReadBinaryFile(cookiefile, TOR_COOKIE_SIZE);
             if (status_cookie.first && status_cookie.second.size() == TOR_COOKIE_SIZE) {
-                // _conn.Command("AUTHENTICATE " + HexStr(status_cookie.second), boost::bind(&TorController::auth_cb, this, _1, _2));
+                // _conn.Command("AUTHENTICATE " + HexStr(status_cookie.second), std::bind(&TorController::auth_cb, this, std::placeholders::_1, std::placeholders::_2));
                 cookie = std::vector<uint8_t>(status_cookie.second.begin(), status_cookie.second.end());
                 clientNonce = std::vector<uint8_t>(TOR_NONCE_SIZE, 0);
                 GetRandBytes(clientNonce.data(), TOR_NONCE_SIZE);
-                _conn.Command("AUTHCHALLENGE SAFECOOKIE " + HexStr(clientNonce), boost::bind(&TorController::authchallenge_cb, this, _1, _2));
+                _conn.Command("AUTHCHALLENGE SAFECOOKIE " + HexStr(clientNonce), std::bind(&TorController::authchallenge_cb, this, std::placeholders::_1, std::placeholders::_2));
             } else {
                 if (status_cookie.first) {
                     LogPrintf("tor: Authentication cookie %s is not exactly %i bytes, as is required by the spec\n", cookiefile, TOR_COOKIE_SIZE);
@@ -684,7 +683,7 @@ void TorController::connected_cb(TorControlConnection& _conn)
 {
     reconnect_timeout = RECONNECT_TIMEOUT_START;
     // First send a PROTOCOLINFO command to figure out what authentication is expected
-    if (!_conn.Command("PROTOCOLINFO 1", boost::bind(&TorController::protocolinfo_cb, this, _1, _2)))
+    if (!_conn.Command("PROTOCOLINFO 1", std::bind(&TorController::protocolinfo_cb, this, std::placeholders::_1, std::placeholders::_2)))
         LogPrintf("tor: Error sending initial protocolinfo command\n");
 }
 
@@ -711,8 +710,8 @@ void TorController::Reconnect()
     /* Try to reconnect and reestablish if we get booted - for example, Tor
      * may be restarting.
      */
-    if (!conn.Connect(target, boost::bind(&TorController::connected_cb, this, _1),
-         boost::bind(&TorController::disconnected_cb, this, _1) )) {
+    if (!conn.Connect(target, std::bind(&TorController::connected_cb, this, std::placeholders::_1),
+         std::bind(&TorController::disconnected_cb, this, std::placeholders::_1) )) {
         LogPrintf("tor: Re-initiating connection to Tor control port %s failed\n", target);
     }
 }
diff --git a/src/validation.cpp b/src/validation.cpp
index 943258a73a..eb6b7fcd98 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -2293,15 +2293,13 @@ class ConnectTrace {
 private:
     std::vector<PerBlockConnectTrace> blocksConnected;
     CTxMemPool &pool;
+    boost::signals2::scoped_connection m_connNotifyEntryRemoved;
 
 public:
     explicit ConnectTrace(CTxMemPool &_pool) : blocksConnected(1), pool(_pool) {
-        pool.NotifyEntryRemoved.connect(boost::bind(&ConnectTrace::NotifyEntryRemoved, this, boost::placeholders::_1, boost::placeholders::_2));
+        m_connNotifyEntryRemoved = pool.NotifyEntryRemoved.connect(std::bind(&ConnectTrace::NotifyEntryRemoved, this, std::placeholders::_1, std::placeholders::_2));
     }
 
-    ~ConnectTrace() {
-        pool.NotifyEntryRemoved.disconnect(boost::bind(&ConnectTrace::NotifyEntryRemoved, this, boost::placeholders::_1, boost::placeholders::_2));
-    }
 
     void BlockConnected(CBlockIndex* pindex, std::shared_ptr<const CBlock> pblock) {
         assert(!blocksConnected.back().pindex);
@@ -3027,7 +3025,7 @@ static bool CheckBlockHeader(const CBlockHeader& block, CValidationState& state,
         pxfieldHistory->GetLatest(TAPYRUS_XFIELDTYPES::AGGPUBKEY, aggregatePubkeyObj);
     }
     else
-        aggregatePubkeyObj = boost::get<const XFieldAggPubKey>(CXFieldHistory().Get(TAPYRUS_XFIELDTYPES::AGGPUBKEY, nHeight).xfieldValue);
+        aggregatePubkeyObj = std::get<XFieldAggPubKey>(CXFieldHistory().Get(TAPYRUS_XFIELDTYPES::AGGPUBKEY, nHeight).xfieldValue);
     CPubKey aggregatePubkey(aggregatePubkeyObj.getPubKey());
 
     const uint256 blockHash = block.GetHashForSign();
diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp
index bf8dd0ccd0..6e045826f3 100644
--- a/src/validationinterface.cpp
+++ b/src/validationinterface.cpp
@@ -19,6 +19,18 @@
 
 #include <boost/signals2/signal.hpp>
 
+struct ValidationInterfaceConnections {
+    boost::signals2::scoped_connection UpdatedBlockTip;
+    boost::signals2::scoped_connection TransactionAddedToMempool;
+    boost::signals2::scoped_connection BlockConnected;
+    boost::signals2::scoped_connection BlockDisconnected;
+    boost::signals2::scoped_connection TransactionRemovedFromMempool;
+    boost::signals2::scoped_connection ChainStateFlushed;
+    boost::signals2::scoped_connection Broadcast;
+    boost::signals2::scoped_connection BlockChecked;
+    boost::signals2::scoped_connection NewPoWValidBlock;
+};
+
 struct MainSignalsInstance {
     boost::signals2::signal<void (const CBlockIndex *, const CBlockIndex *, bool fInitialDownload)> UpdatedBlockTip;
     boost::signals2::signal<void (const CTransactionRef &)> TransactionAddedToMempool;
@@ -34,11 +46,16 @@ struct MainSignalsInstance {
     // but must ensure all callbacks happen in-order, so we end up creating
     // our own queue here :(
     SingleThreadedSchedulerClient m_schedulerClient;
+    std::unordered_map<CValidationInterface*, ValidationInterfaceConnections> m_connMainSignals;
 
     explicit MainSignalsInstance(CScheduler *pscheduler) : m_schedulerClient(pscheduler) {}
 };
 
 static CMainSignals g_signals;
+// This map has to a separate global instead of a member of MainSignalsInstance,
+// because RegisterWithMempoolSignals is currently called before RegisterBackgroundSignalScheduler,
+// so MainSignalsInstance hasn't been created yet.
+static std::unordered_map<CTxMemPool*, boost::signals2::scoped_connection> g_connNotifyEntryRemoved;
 
 void CMainSignals::RegisterBackgroundSignalScheduler(CScheduler& scheduler) {
     assert(!m_internals);
@@ -61,11 +78,11 @@ size_t CMainSignals::CallbacksPending() {
 }
 
 void CMainSignals::RegisterWithMempoolSignals(CTxMemPool& pool) {
-    pool.NotifyEntryRemoved.connect(boost::bind(&CMainSignals::MempoolEntryRemoved, this, boost::placeholders::_1, boost::placeholders::_2));
+    g_connNotifyEntryRemoved.emplace(&pool, pool.NotifyEntryRemoved.connect(std::bind(&CMainSignals::MempoolEntryRemoved, this, std::placeholders::_1, std::placeholders::_2)));
 }
 
 void CMainSignals::UnregisterWithMempoolSignals(CTxMemPool& pool) {
-    pool.NotifyEntryRemoved.disconnect(boost::bind(&CMainSignals::MempoolEntryRemoved, this, boost::placeholders::_1, boost::placeholders::_2));
+    g_connNotifyEntryRemoved.erase(&pool);
 }
 
 CMainSignals& GetMainSignals()
@@ -74,42 +91,27 @@ CMainSignals& GetMainSignals()
 }
 
 void RegisterValidationInterface(CValidationInterface* pwalletIn) {
-    g_signals.m_internals->UpdatedBlockTip.connect(boost::bind(&CValidationInterface::UpdatedBlockTip, pwalletIn, boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3));
-    g_signals.m_internals->TransactionAddedToMempool.connect(boost::bind(&CValidationInterface::TransactionAddedToMempool, pwalletIn, boost::placeholders::_1));
-    g_signals.m_internals->BlockConnected.connect(boost::bind(&CValidationInterface::BlockConnected, pwalletIn, boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3));
-    g_signals.m_internals->BlockDisconnected.connect(boost::bind(&CValidationInterface::BlockDisconnected, pwalletIn, boost::placeholders::_1));
-    g_signals.m_internals->TransactionRemovedFromMempool.connect(boost::bind(&CValidationInterface::TransactionRemovedFromMempool, pwalletIn, boost::placeholders::_1));
-    g_signals.m_internals->ChainStateFlushed.connect(boost::bind(&CValidationInterface::ChainStateFlushed, pwalletIn, boost::placeholders::_1));
-    g_signals.m_internals->Broadcast.connect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn, boost::placeholders::_1, boost::placeholders::_2));
-    g_signals.m_internals->BlockChecked.connect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, boost::placeholders::_1, boost::placeholders::_2));
-    g_signals.m_internals->NewValidBlock.connect(boost::bind(&CValidationInterface::NewValidBlock, pwalletIn, boost::placeholders::_1, boost::placeholders::_2));
+    ValidationInterfaceConnections& conns = g_signals.m_internals->m_connMainSignals[pwalletIn];
+    conns.UpdatedBlockTip = g_signals.m_internals->UpdatedBlockTip.connect(std::bind(&CValidationInterface::UpdatedBlockTip, pwalletIn, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+    conns.TransactionAddedToMempool = g_signals.m_internals->TransactionAddedToMempool.connect(std::bind(&CValidationInterface::TransactionAddedToMempool, pwalletIn, std::placeholders::_1));
+    conns.BlockConnected = g_signals.m_internals->BlockConnected.connect(std::bind(&CValidationInterface::BlockConnected, pwalletIn, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+    conns.BlockDisconnected = g_signals.m_internals->BlockDisconnected.connect(std::bind(&CValidationInterface::BlockDisconnected, pwalletIn, std::placeholders::_1));
+    conns.TransactionRemovedFromMempool = g_signals.m_internals->TransactionRemovedFromMempool.connect(std::bind(&CValidationInterface::TransactionRemovedFromMempool, pwalletIn, std::placeholders::_1));
+    conns.ChainStateFlushed = g_signals.m_internals->ChainStateFlushed.connect(std::bind(&CValidationInterface::ChainStateFlushed, pwalletIn, std::placeholders::_1));
+    conns.Broadcast = g_signals.m_internals->Broadcast.connect(std::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn, std::placeholders::_1, std::placeholders::_2));
+    conns.BlockChecked = g_signals.m_internals->BlockChecked.connect(std::bind(&CValidationInterface::BlockChecked, pwalletIn, std::placeholders::_1, std::placeholders::_2));
+    conns.NewPoWValidBlock = g_signals.m_internals->NewValidBlock.connect(std::bind(&CValidationInterface::NewValidBlock, pwalletIn, std::placeholders::_1, std::placeholders::_2));
 }
 
 void UnregisterValidationInterface(CValidationInterface* pwalletIn) {
-    g_signals.m_internals->BlockChecked.disconnect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, boost::placeholders::_1, boost::placeholders::_2));
-    g_signals.m_internals->Broadcast.disconnect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn, boost::placeholders::_1, boost::placeholders::_2));
-    g_signals.m_internals->ChainStateFlushed.disconnect(boost::bind(&CValidationInterface::ChainStateFlushed, pwalletIn, boost::placeholders::_1));
-    g_signals.m_internals->TransactionAddedToMempool.disconnect(boost::bind(&CValidationInterface::TransactionAddedToMempool, pwalletIn, boost::placeholders::_1));
-    g_signals.m_internals->BlockConnected.disconnect(boost::bind(&CValidationInterface::BlockConnected, pwalletIn, boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3));
-    g_signals.m_internals->BlockDisconnected.disconnect(boost::bind(&CValidationInterface::BlockDisconnected, pwalletIn, boost::placeholders::_1));
-    g_signals.m_internals->TransactionRemovedFromMempool.disconnect(boost::bind(&CValidationInterface::TransactionRemovedFromMempool, pwalletIn, boost::placeholders::_1));
-    g_signals.m_internals->UpdatedBlockTip.disconnect(boost::bind(&CValidationInterface::UpdatedBlockTip, pwalletIn, boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3));
-    g_signals.m_internals->NewValidBlock.disconnect(boost::bind(&CValidationInterface::NewValidBlock, pwalletIn, boost::placeholders::_1, boost::placeholders::_2));
+   g_signals.m_internals->m_connMainSignals.erase(pwalletIn);
 }
 
 void UnregisterAllValidationInterfaces() {
     if (!g_signals.m_internals) {
         return;
     }
-    g_signals.m_internals->BlockChecked.disconnect_all_slots();
-    g_signals.m_internals->Broadcast.disconnect_all_slots();
-    g_signals.m_internals->ChainStateFlushed.disconnect_all_slots();
-    g_signals.m_internals->TransactionAddedToMempool.disconnect_all_slots();
-    g_signals.m_internals->BlockConnected.disconnect_all_slots();
-    g_signals.m_internals->BlockDisconnected.disconnect_all_slots();
-    g_signals.m_internals->TransactionRemovedFromMempool.disconnect_all_slots();
-    g_signals.m_internals->UpdatedBlockTip.disconnect_all_slots();
-    g_signals.m_internals->NewValidBlock.disconnect_all_slots();
+    g_signals.m_internals->m_connMainSignals.clear();
 }
 
 void CallFunctionInValidationInterfaceQueue(std::function<void ()> func) {
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 29ce064967..ca2e35a756 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -732,7 +732,7 @@ UniValue dumpwallet(const JSONRPCRequest& request)
     // sort time/key pairs
     std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
     for (const auto& entry : mapKeyBirth) {
-        if (const CKeyID* keyID = boost::get<CKeyID>(&entry.first)) { // set and test
+        if (const CKeyID* keyID = std::get_if<CKeyID>(&entry.first)) { // set and test
             vKeyBirth.push_back(std::make_pair(entry.second, *keyID));
         }
     }
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 4feff251f1..4156954459 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -141,10 +141,10 @@ static std::string LabelFromValue(const UniValue& value)
 static void addTokenKV(const CTxDestination& address, const CAmount nAmount, UniValue& entry)
 {
     ColorIdentifier colorId;
-    if(address.which() == 3)
-        colorId = boost::get<CColorKeyID>(address).color;
-    else if(address.which() == 4)
-        colorId = boost::get<CColorScriptID>(address).color;
+    if(address.index() == 3)
+        colorId = std::get<CColorKeyID>(address).color;
+    else if(address.index() == 4)
+        colorId = std::get<CColorScriptID>(address).color;
 
     entry.pushKV("token", colorId.toHexString());
 
@@ -441,10 +441,10 @@ static UniValue sendtoaddress(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
     }
     ColorIdentifier colorId;
-    if(dest.which() == 3)
-        colorId = boost::get<CColorKeyID>(dest).color;
-    else if(dest.which() == 4)
-        colorId = boost::get<CColorScriptID>(dest).color;
+    if(dest.index() == 3)
+        colorId = std::get<CColorKeyID>(dest).color;
+    else if(dest.index() == 4)
+        colorId = std::get<CColorScriptID>(dest).color;
 
     if (colorId.type != TokenTypes::NONE
       && pwallet->GetBalance()[colorId] == 0 ) {
@@ -543,10 +543,10 @@ static UniValue listaddressgroupings(const JSONRPCRequest& request)
         for (const CTxDestination& address : grouping)
         {
             ColorIdentifier colorId;
-            if(address.which() == 3)
-                colorId = boost::get<CColorKeyID>(address).color;
-            else if(address.which() == 4)
-                colorId = boost::get<CColorScriptID>(address).color;
+            if(address.index() == 3)
+                colorId = std::get<CColorKeyID>(address).color;
+            else if(address.index() == 4)
+                colorId = std::get<CColorScriptID>(address).color;
             UniValue addressInfo(UniValue::VARR);
             addressInfo.push_back(EncodeDestination(address));
             addressInfo.push_back(colorId.type == TokenTypes::NONE ? ValueFromAmount(balances[address]) : balances[address]);
@@ -604,7 +604,7 @@ static UniValue signmessage(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
-    const CKeyID *keyID = boost::get<CKeyID>(&dest);
+    const CKeyID *keyID = std::get_if<CKeyID>(&dest);
     if (!keyID) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
@@ -686,10 +686,10 @@ static UniValue getreceivedbyaddress(const JSONRPCRequest& request)
     }
 
     ColorIdentifier colorId;
-    if(dest.which() == 3)
-        colorId = boost::get<CColorKeyID>(dest).color;
-    else if(dest.which() == 4)
-        colorId = boost::get<CColorScriptID>(dest).color;
+    if(dest.index() == 3)
+        colorId = std::get<CColorKeyID>(dest).color;
+    else if(dest.index() == 4)
+        colorId = std::get<CColorScriptID>(dest).color;
 
     return colorId.type == TokenTypes::NONE ? ValueFromAmount(nAmount) : nAmount;
 }
@@ -750,10 +750,10 @@ static UniValue getreceivedbylabel(const JSONRPCRequest& request)
             CTxDestination address;
             if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*pwallet, address) && setAddress.count(address)) {
                 ColorIdentifier colorId;
-                if(address.which() == 3)
-                    colorId = boost::get<CColorKeyID>(address).color;
-                else if(address.which() == 4)
-                    colorId = boost::get<CColorScriptID>(address).color;
+                if(address.index() == 3)
+                    colorId = std::get<CColorKeyID>(address).color;
+                else if(address.index() == 4)
+                    colorId = std::get<CColorScriptID>(address).color;
 
                 if (wtx.GetDepthInMainChain() >= nMinDepth)
                     lable_balance[colorId] += txout.nValue;
@@ -1159,10 +1159,10 @@ static UniValue ListReceived(CWallet * const pwallet, const UniValue& params, bo
             continue;
 
         ColorIdentifier colorId;
-        if(address.which() == 3)
-            colorId = boost::get<CColorKeyID>(address).color;
-        else if(address.which() == 4)
-            colorId = boost::get<CColorScriptID>(address).color;
+        if(address.index() == 3)
+            colorId = std::get<CColorKeyID>(address).color;
+        else if(address.index() == 4)
+            colorId = std::get<CColorScriptID>(address).color;
 
         CAmount nAmount = 0;
         int nConf = std::numeric_limits<int>::max();
@@ -2838,7 +2838,7 @@ static UniValue listunspent(const JSONRPCRequest& request)
             }
 
             if (scriptPubKey.IsPayToScriptHash()) {
-                const CScriptID& hash = boost::get<CScriptID>(address);
+                const CScriptID& hash = std::get<CScriptID>(address);
                 CScript redeemScript;
                 if (pwallet->GetCScript(hash, redeemScript)) {
                     entry.pushKV("redeemScript", HexStr(redeemScript.begin(), redeemScript.end()));
@@ -3430,7 +3430,7 @@ UniValue rescanblockchain(const JSONRPCRequest& request)
     return response;
 }
 
-class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue>
+class DescribeWalletAddressVisitor
 {
 public:
     CWallet * const pwallet;
@@ -3451,7 +3451,7 @@ class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue>
             UniValue subobj(UniValue::VOBJ);
             UniValue detail = DescribeAddress(embedded);
             subobj.pushKVs(detail);
-            UniValue wallet_detail = boost::apply_visitor(*this, embedded);
+            UniValue wallet_detail = std::visit(*this, embedded);
             subobj.pushKVs(wallet_detail);
             subobj.pushKV("address", EncodeDestination(embedded));
             subobj.pushKV("scriptPubKey", HexStr(subscript.begin(), subscript.end()));
@@ -3510,7 +3510,7 @@ static UniValue DescribeWalletAddress(CWallet* pwallet, const CTxDestination& de
     UniValue ret(UniValue::VOBJ);
     UniValue detail = DescribeAddress(dest);
     ret.pushKVs(detail);
-    ret.pushKVs(boost::apply_visitor(DescribeWalletAddressVisitor(pwallet), dest));
+    ret.pushKVs(std::visit(DescribeWalletAddressVisitor(pwallet), dest));
     return ret;
 }
 
@@ -3591,10 +3591,10 @@ UniValue getaddressinfo(const JSONRPCRequest& request)
     ret.pushKV("address", currentAddress);
 
     ColorIdentifier colorId;
-    if(dest.which() == 3)
-        colorId = boost::get<CColorKeyID>(dest).color;
-    else if(dest.which() == 4)
-        colorId = boost::get<CColorScriptID>(dest).color;
+    if(dest.index() == 3)
+        colorId = std::get<CColorKeyID>(dest).color;
+    else if(dest.index() == 4)
+        colorId = std::get<CColorScriptID>(dest).color;
 
     ret.pushKV("token", colorId.toHexString());
 
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 225a15241c..69718497b5 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -315,7 +315,7 @@ BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
     // address.
     auto list = wallet->ListCoins();
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
+    BOOST_CHECK_EQUAL(std::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 6U);
 
     // Check initial balance from 6 coinbase transaction.
@@ -328,7 +328,7 @@ BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
     AddTx(CRecipient{GetScriptForRawPubKey({}), 1 * COIN, false /* subtract fee */});
     list = wallet->ListCoins();
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
+    BOOST_CHECK_EQUAL(std::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 6U);
 
     // Lock both coins. Confirm number of available coins drops to 0.
@@ -354,7 +354,7 @@ BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
     // being locked.
     list = wallet->ListCoins();
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
+    BOOST_CHECK_EQUAL(std::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 6U);
 }
 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 1a7179a7f8..dacd0457ec 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -107,7 +107,7 @@ std::string COutput::ToString() const
 }
 
 /** A class to identify which pubkeys a script and a keystore have in common. */
-class CAffectedKeysVisitor : public boost::static_visitor<void> {
+class CAffectedKeysVisitor {
 private:
     const CKeyStore &keystore;
     std::vector<CKeyID> &vKeys;
@@ -131,7 +131,7 @@ class CAffectedKeysVisitor : public boost::static_visitor<void> {
         int nRequired;
         if (ExtractDestinations(script, type, vDest, nRequired)) {
             for (const CTxDestination &dest : vDest)
-                boost::apply_visitor(*this, dest);
+                std::visit(*this, dest);
         }
     }
 
@@ -2704,7 +2704,7 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
             CScript scriptChange;
 
             // coin control: send change to custom address
-            if (!boost::get<CNoDestination>(&coin_control.destChange)) {
+            if (!std::get_if<CNoDestination>(&coin_control.destChange)) {
                 scriptChange = GetScriptForDestination(coin_control.destChange);
             } else { // no coin control: send change to newly generated address
                 // Note: We use a new key here to keep it from being obvious which side is the change.
@@ -3937,7 +3937,7 @@ unsigned int CWallet::ComputeTimeSmart(const CWalletTx& wtx) const
 
 bool CWallet::AddDestData(const CTxDestination &dest, const std::string &key, const std::string &value)
 {
-    if (boost::get<CNoDestination>(&dest))
+    if (std::get_if<CNoDestination>(&dest))
         return false;
 
     mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
diff --git a/src/xfieldhistory.cpp b/src/xfieldhistory.cpp
index 59f938d838..8f49de2414 100644
--- a/src/xfieldhistory.cpp
+++ b/src/xfieldhistory.cpp
@@ -81,7 +81,7 @@ bool IsXFieldNew(const CXField& xfield, CXFieldHistoryMap* pxfieldHistory)
     IsXFieldLastInHistoryVisitor checkVisitor(pxfieldHistory);
     return xfield.IsValid()
           && std::find(XFIELDTYPES_INIT_LIST.begin(), XFIELDTYPES_INIT_LIST.end(), xfield.xfieldType) != XFIELDTYPES_INIT_LIST.end()
-          && !boost::apply_visitor(checkVisitor, xfield.xfieldValue);
+          && !std::visit(checkVisitor, xfield.xfieldValue);
 }
 
 uint32_t GetCurrentMaxBlockSize() {
diff --git a/src/xfieldhistory.h b/src/xfieldhistory.h
index 2ee39e99e5..3171c701f8 100644
--- a/src/xfieldhistory.h
+++ b/src/xfieldhistory.h
@@ -33,9 +33,9 @@ struct XFieldChange {
         switch(GetXFieldTypeFrom(xfieldValue))
         {
             case TAPYRUS_XFIELDTYPES::AGGPUBKEY:
-                ::Serialize(s, boost::get<XFieldAggPubKey>(xfieldValue)); break;
+                ::Serialize(s, std::get<XFieldAggPubKey>(xfieldValue)); break;
             case TAPYRUS_XFIELDTYPES::MAXBLOCKSIZE:
-                ::Serialize(s, boost::get<XFieldMaxBlockSize>(xfieldValue)); break;
+                ::Serialize(s, std::get<XFieldMaxBlockSize>(xfieldValue)); break;
             case TAPYRUS_XFIELDTYPES::NONE:
             default:
                 break;
@@ -139,7 +139,7 @@ class CXFieldHistoryMap{
     template <typename T>
     void GetLatest(TAPYRUS_XFIELDTYPES type, T & xfieldval) const {
         auto& listofXfieldChanges = (isTemp ? this->getXFieldHistoryMap() : xfieldHistory).find(type)->second;
-        xfieldval = boost::get<T>(listofXfieldChanges.rbegin()->xfieldValue);
+        xfieldval = std::get<T>(listofXfieldChanges.rbegin()->xfieldValue);
     }
 
     virtual XFieldChangeListWrapper& operator[](TAPYRUS_XFIELDTYPES type) const {
@@ -219,7 +219,7 @@ class CTempXFieldHistory : public CXFieldHistoryMap{
 
 };
 
-class IsXFieldLastInHistoryVisitor : public boost::static_visitor< bool >
+class IsXFieldLastInHistoryVisitor
 {
     CXFieldHistoryMap* history;
 public:
@@ -229,7 +229,7 @@ class IsXFieldLastInHistoryVisitor : public boost::static_visitor< bool >
     bool operator()(const T &xField) const {
         assert(history);
         TAPYRUS_XFIELDTYPES X = GetXFieldTypeFrom(xField);
-        return boost::get<T>((*history)[X].rbegin()->xfieldValue).operator==(T(xField));
+        return std::get<T>((*history)[X].rbegin()->xfieldValue).operator==(T(xField));
     }
 
 };
diff --git a/test/lint/pending-lint-includes.sh b/test/lint/pending-lint-includes.sh
index 8f7a1fd76b..40a3c11006 100755
--- a/test/lint/pending-lint-includes.sh
+++ b/test/lint/pending-lint-includes.sh
@@ -51,7 +51,6 @@ EXPECTED_BOOST_INCLUDES=(
     boost/algorithm/string/classification.hpp
     boost/algorithm/string/replace.hpp
     boost/algorithm/string/split.hpp
-    boost/bind.hpp
     boost/chrono/chrono.hpp
     boost/date_time/posix_time/posix_time.hpp
     boost/filesystem.hpp
@@ -74,9 +73,6 @@ EXPECTED_BOOST_INCLUDES=(
     boost/thread/condition_variable.hpp
     boost/thread/mutex.hpp
     boost/thread/thread.hpp
-    boost/variant.hpp
-    boost/variant/apply_visitor.hpp
-    boost/variant/static_visitor.hpp
 )
 
 for BOOST_INCLUDE in $(git grep '^#include <boost/' -- "*.cpp" "*.h" | cut -f2 -d: | cut -f2 -d'<' | cut -f1 -d'>' | sort -u); do