bootstrap mode: ensure we bootstrap with compatible daemon

Author: j-berman

src/hardforks/hardforks.cpp

@@ -130,3 +130,59 @@ const hardfork_t stagenet_hard_forks[] = {
   { 16, 1151720, 0, 1656629118 },
 };
 const size_t num_stagenet_hard_forks = sizeof(stagenet_hard_forks) / sizeof(stagenet_hard_forks[0]);
+
+bool check_fork_version_compatibility(
+    const cryptonote::network_type &nettype,
+    const std::vector<std::pair<uint8_t, uint64_t>> &daemon_hard_forks,
+    const uint64_t height,
+    const uint64_t target_height,
+    bool *client_is_outdated,
+    bool *daemon_is_outdated)
+{
+  const size_t client_num_hard_forks = nettype == cryptonote::network_type::TESTNET ? num_testnet_hard_forks
+    : nettype == cryptonote::network_type::STAGENET ? num_stagenet_hard_forks : num_mainnet_hard_forks;
+  const hardfork_t *client_hard_forks = cryptonote::network_type::TESTNET ? testnet_hard_forks
+    : nettype == cryptonote::network_type::STAGENET ? stagenet_hard_forks : mainnet_hard_forks;
+
+  // Make sure we're pointing to an FCMP++ compatible daemon in order for client
+  // to sync the FCMP++ tree.
+  if (daemon_hard_forks.size() < HF_VERSION_FCMP_PLUS_PLUS)
+  {
+    if (daemon_is_outdated)
+      *daemon_is_outdated = true;
+    return false;
+  }
+
+  // Check if client or daemon is outdated (whether either are unaware of a hard
+  // fork). Then check if fork has passed rendering versions incompatible.
+  const bool daemon_outdated = daemon_hard_forks.size() < client_num_hard_forks;
+  const bool client_outdated = daemon_hard_forks.size() > client_num_hard_forks;
+
+  if (daemon_is_outdated)
+    *daemon_is_outdated = daemon_outdated;
+  if (client_is_outdated)
+    *client_is_outdated = client_outdated;
+
+  if (daemon_outdated)
+  {
+    uint64_t daemon_missed_fork_height = client_hard_forks[daemon_hard_forks.size()].height;
+
+    // If the daemon missed the fork, then technically it is no longer part of
+    // the Monero network. Don't connect.
+    bool daemon_missed_fork = height >= daemon_missed_fork_height || target_height >= daemon_missed_fork_height;
+    if (daemon_missed_fork)
+      return false;
+  }
+  else if (client_outdated)
+  {
+    uint64_t client_missed_fork_height = daemon_hard_forks[client_num_hard_forks].second;
+
+    // If the client missed the fork, then technically it is no longer able
+    // to communicate with the Monero network. Don't connect.
+    bool client_missed_fork = height >= client_missed_fork_height || target_height >= client_missed_fork_height;
+    if (client_missed_fork)
+      return false;
+  }
+
+  return true;
+}

src/hardforks/hardforks.h

@@ -28,8 +28,12 @@
 
 #pragma once
 
+#include "cryptonote_config.h"
+
 #include <stdint.h>
 #include <time.h>
+#include <utility>
+#include <vector>
 
 struct hardfork_t
 {
@@ -50,3 +54,11 @@ extern const size_t num_testnet_hard_forks;
 
 extern const hardfork_t stagenet_hard_forks[];
 extern const size_t num_stagenet_hard_forks;
+
+bool check_fork_version_compatibility(
+    const cryptonote::network_type &nettype,
+    const std::vector<std::pair<uint8_t, uint64_t>> &daemon_hard_forks,
+    const uint64_t height,
+    const uint64_t target_height,
+    bool *client_is_outdated,
+    bool *daemon_is_outdated);

src/rpc/CMakeLists.txt

@@ -164,6 +164,7 @@ target_link_libraries(daemon_rpc_server
     rpc_pub
     cryptonote_core
     cryptonote_protocol
+    hardforks
     version
     daemon_messages
     serialization

src/rpc/bootstrap_daemon.cpp

@@ -6,6 +6,7 @@
 
 #include "crypto/crypto.h"
 #include "cryptonote_core/cryptonote_core.h"
+#include "hardforks/hardforks.h"
 #include "misc_log_ex.h"
 #include "net/parse.h"
 
@@ -16,21 +17,25 @@ namespace cryptonote
 {
 
   bootstrap_daemon::bootstrap_daemon(
+    const cryptonote::network_type &nettype,
     std::function<std::map<std::string, bool>()> get_public_nodes,
     bool rpc_payment_enabled,
     const std::string &proxy)
-    : m_selector(new bootstrap_node::selector_auto(std::move(get_public_nodes)))
+    : m_nettype(nettype)
+    , m_selector(new bootstrap_node::selector_auto(std::move(get_public_nodes)))
     , m_rpc_payment_enabled(rpc_payment_enabled)
   {
     set_proxy(proxy);
   }
 
   bootstrap_daemon::bootstrap_daemon(
+    const cryptonote::network_type &nettype,
     const std::string &address,
     boost::optional<epee::net_utils::http::login> credentials,
     bool rpc_payment_enabled,
     const std::string &proxy)
-    : m_selector(nullptr)
+    : m_nettype(nettype)
+    , m_selector(nullptr)
     , m_rpc_payment_enabled(rpc_payment_enabled)
   {
     set_proxy(proxy);
@@ -68,6 +73,25 @@ namespace cryptonote
     return {{res.height, res.target_height}};
   }
 
+  boost::optional<cryptonote::COMMAND_RPC_GET_VERSION::response> bootstrap_daemon::get_version()
+  {
+    cryptonote::COMMAND_RPC_GET_VERSION::request req;
+    cryptonote::COMMAND_RPC_GET_VERSION::response res;
+
+    const bool r = epee::net_utils::invoke_http_json_rpc("/json_rpc", "get_version", req, res, m_http_client, std::chrono::seconds(10));
+    if (!handle_result(r, res.status))
+    {
+      return boost::none;
+    }
+
+    if (res.status != CORE_RPC_STATUS_OK)
+    {
+      return boost::none;
+    }
+
+    return boost::optional<cryptonote::COMMAND_RPC_GET_VERSION::response>(res);
+  }
+
   bool bootstrap_daemon::handle_result(bool success, const std::string &status)
   {
     const bool failed = !success || (!m_rpc_payment_enabled && status == CORE_RPC_STATUS_PAYMENT_REQUIRED);
@@ -115,15 +139,50 @@ namespace cryptonote
       return true;
     }
 
-    boost::optional<bootstrap_node::node_info> node;
+    // We want to make sure we connect to a compatible bootstrap daemon
+    MINFO("Attempting to switch bootstrap daemon address");
+    std::size_t n_attempts = 0;
+    while (n_attempts++ < 5)
     {
-      const boost::unique_lock<boost::mutex> lock(m_selector_mutex);
-      node = m_selector->next_node();
-    }
-    if (node) {
-      return set_server(node->address, node->credentials);
+      MDEBUG("Bootstrap daemon switch attempt " << n_attempts);
+      std::string address;
+      {
+        boost::unique_lock<boost::mutex> lock(m_selector_mutex);
+        const auto node = m_selector->next_node();
+        if (!node)
+          continue;
+        if (!this->set_server(node->address, node->credentials))
+          continue;
+        address = node->address;
+      }
+
+      const auto res = this->get_version();
+      if (!res)
+        continue;
+      std::vector<std::pair<uint8_t, uint64_t>> bootstrap_daemon_hfs;
+      bootstrap_daemon_hfs.reserve(res->hard_forks.size());
+      for (const auto &hf : res->hard_forks)
+        bootstrap_daemon_hfs.push_back({hf.hf_version, hf.height});
+
+      // Only connect to a compatible bootstrap daemon
+      bool client_is_outdated = false, daemon_is_outdated = false;
+      if (!check_fork_version_compatibility(m_nettype, bootstrap_daemon_hfs, res->current_height, res->target_height, &client_is_outdated, &daemon_is_outdated))
+      {
+        MWARNING("Bootstrap daemon " << address << " is incompatible with our daemon");
+        this->handle_result(false, "");
+        continue;
+      }
+
+      if (client_is_outdated)
+        MWARNING("We are connected to a bootstrap daemon that knows of a future hard fork(s) that we do not");
+      else if (daemon_is_outdated)
+        MWARNING("We are connected to a bootstrap daemon that has not yet updated for the upcoming fork");
+
+      MGINFO("Successfully switched bootstrap daemon to " << address);
+      return true;
     }
 
+    MERROR("Could not find compatible bootstrap daemon");
     return false;
   }
 

src/rpc/bootstrap_daemon.h

@@ -9,6 +9,7 @@
 #include <boost/utility/string_ref.hpp>
 
 #include "net/http.h"
+#include "core_rpc_server_commands_defs.h"
 #include "storages/http_abstract_invoke.h"
 
 #include "bootstrap_node_selector.h"
@@ -20,10 +21,12 @@ namespace cryptonote
   {
   public:
     bootstrap_daemon(
+      const cryptonote::network_type &nettype,
       std::function<std::map<std::string, bool>()> get_public_nodes,
       bool rpc_payment_enabled,
       const std::string &proxy);
     bootstrap_daemon(
+      const cryptonote::network_type &nettype,
       const std::string &address,
       boost::optional<epee::net_utils::http::login> credentials,
       bool rpc_payment_enabled,
@@ -78,9 +81,11 @@ namespace cryptonote
 
   private:
     bool set_server(const std::string &address, const boost::optional<epee::net_utils::http::login> &credentials = boost::none);
+    boost::optional<cryptonote::COMMAND_RPC_GET_VERSION::response> get_version();
     bool switch_server_if_needed();
 
   private:
+    const cryptonote::network_type m_nettype;
     net::http::client m_http_client;
     const bool m_rpc_payment_enabled;
     const std::unique_ptr<bootstrap_node::selector> m_selector;

src/rpc/core_rpc_server.cpp

@@ -250,11 +250,11 @@ namespace cryptonote
       auto get_nodes = [this]() {
         return get_public_nodes(credits_per_hash_threshold);
       };
-      m_bootstrap_daemon.reset(new bootstrap_daemon(std::move(get_nodes), rpc_payment_enabled, m_bootstrap_daemon_proxy.empty() ? proxy : m_bootstrap_daemon_proxy));
+      m_bootstrap_daemon.reset(new bootstrap_daemon(nettype(), std::move(get_nodes), rpc_payment_enabled, m_bootstrap_daemon_proxy.empty() ? proxy : m_bootstrap_daemon_proxy));
     }
     else
     {
-      m_bootstrap_daemon.reset(new bootstrap_daemon(address, credentials, rpc_payment_enabled, m_bootstrap_daemon_proxy.empty() ? proxy : m_bootstrap_daemon_proxy));
+      m_bootstrap_daemon.reset(new bootstrap_daemon(nettype(), address, credentials, rpc_payment_enabled, m_bootstrap_daemon_proxy.empty() ? proxy : m_bootstrap_daemon_proxy));
     }
 
     m_should_use_bootstrap_daemon = m_bootstrap_daemon.get() != nullptr;

src/wallet/wallet2.cpp

@@ -3437,23 +3437,23 @@ bool wallet2::bump_refresh_start_height(const uint64_t init_start_height, const
   // Get the corresponding hash from the daemon
   crypto::hash granularized_init_hash;
   {
-    cryptonote::COMMAND_RPC_GETBLOCKHASH::request req = AUTO_VAL_INIT(req);
-    cryptonote::COMMAND_RPC_GETBLOCKHASH::response res = AUTO_VAL_INIT(res);
+    cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::request req = AUTO_VAL_INIT(req);
+    cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::response res = AUTO_VAL_INIT(res);
     epee::json_rpc::error error;
     error.code = 0;
-    req.push_back(granularized_init_block_idx);
+    req.height = granularized_init_block_idx;
 
     const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
-    bool r = net_utils::invoke_http_json_rpc("/json_rpc", "on_get_block_hash", req, res, error, *m_http_client, rpc_timeout);
+    bool r = net_utils::invoke_http_json_rpc("/json_rpc", "getblockheaderbyheight", req, res, error, *m_http_client, rpc_timeout);
     if (error.code == CORE_RPC_ERROR_CODE_TOO_BIG_HEIGHT) {
       // We don't need to sync if start height is higher than the daemon height
       MWARNING("Refresh start height is higher than the current chain tip, not syncing");
       return false;
     }
-    THROW_WALLET_EXCEPTION_IF(!r || error.code != 0, error::get_block_hash_error, error.message);
-    THROW_WALLET_EXCEPTION_IF(res.size() != 64, error::get_block_hash_error, "Hash is not 32 bytes as expected");
-    r = epee::string_tools::hex_to_pod(res, granularized_init_hash);
-    THROW_WALLET_EXCEPTION_IF(!r, error::get_block_hash_error, "Failed to parse getblockhash hash");
+    THROW_WALLET_EXCEPTION_IF(!r || error.code != 0, error::block_header_by_height, error.message);
+    THROW_WALLET_EXCEPTION_IF(res.block_header.hash.size() != 64, error::block_header_by_height, "Hash is not 32 bytes as expected");
+    r = epee::string_tools::hex_to_pod(res.block_header.hash, granularized_init_hash);
+    THROW_WALLET_EXCEPTION_IF(!r, error::block_header_by_height, "Failed to parse getblockheaderbyheight hash");
   }
 
   MINFO("Starting scanner on top of block " << granularized_init_block_idx << " , hash " << granularized_init_hash);
@@ -6660,90 +6660,14 @@ bool wallet2::check_version(uint32_t *version, bool *wallet_is_outdated, bool *d
   // check wallet compatibility with daemon's hard fork version
   if (!m_allow_mismatched_daemon_version)
   {
-    if (rpc_version < MAKE_CORE_RPC_VERSION(3, 17))
-    {
-      // Wallet cannot init FCMP++ tree while syncing if pointing to an older daemon
-      if (daemon_is_outdated)
-        *daemon_is_outdated = true;
-      return false;
-    }
-
-    // check wallet compatibility with daemon's hard fork version
-    if (!check_hard_fork_version(m_nettype, daemon_hard_forks, height, target_height, wallet_is_outdated, daemon_is_outdated))
+    if (!check_fork_version_compatibility(m_nettype, daemon_hard_forks, height, target_height, wallet_is_outdated, daemon_is_outdated))
       return false;
   }
 
   m_rpc_version = rpc_version;
   return true;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::check_hard_fork_version(cryptonote::network_type nettype, const std::vector<std::pair<uint8_t, uint64_t>> &daemon_hard_forks, const uint64_t height, const uint64_t target_height, bool *wallet_is_outdated, bool *daemon_is_outdated)
-{
-  const size_t wallet_num_hard_forks = nettype == TESTNET ? num_testnet_hard_forks
-    : nettype == STAGENET ? num_stagenet_hard_forks : num_mainnet_hard_forks;
-  const hardfork_t *wallet_hard_forks = nettype == TESTNET ? testnet_hard_forks
-    : nettype == STAGENET ? stagenet_hard_forks : mainnet_hard_forks;
-
-  // First check if wallet or daemon is outdated (whether either are unaware of
-  // a hard fork). Then check if fork has passed rendering versions incompatible
-  if (daemon_hard_forks.size() > 0)
-  {
-    bool daemon_outdated = daemon_hard_forks.size() < wallet_num_hard_forks;
-    bool wallet_outdated = daemon_hard_forks.size() > wallet_num_hard_forks;
-
-    if (daemon_is_outdated)
-      *daemon_is_outdated = daemon_outdated;
-    if (wallet_is_outdated)
-      *wallet_is_outdated = wallet_outdated;
-
-    if (daemon_outdated)
-    {
-      uint64_t daemon_missed_fork_height = wallet_hard_forks[daemon_hard_forks.size()].height;
-
-      // If the daemon missed the fork, then technically it is no longer part of
-      // the Monero network. Don't connect.
-      bool daemon_missed_fork = height >= daemon_missed_fork_height || target_height >= daemon_missed_fork_height;
-      if (daemon_missed_fork)
-        return false;
-    }
-    else if (wallet_outdated)
-    {
-      uint64_t wallet_missed_fork_height = daemon_hard_forks[wallet_num_hard_forks].second;
-
-      // If the wallet missed the fork, then technically it is no longer able
-      // to communicate with the Monero network. Don't connect.
-      bool wallet_missed_fork = height >= wallet_missed_fork_height || target_height >= wallet_missed_fork_height;
-      if (wallet_missed_fork)
-        return false;
-    }
-  }
-  else
-  {
-    // Non-updated daemons won't return daemon_hard_forks in response to
-    // get_version. Fall back to extra call to get_hard_fork_info by version.
-    uint64_t daemon_fork_height;
-    get_hard_fork_info(wallet_num_hard_forks-1/* wallet expects "double fork" pattern */, daemon_fork_height);
-    bool daemon_outdated = daemon_fork_height == std::numeric_limits<uint64_t>::max();
-
-    if (daemon_is_outdated)
-      *daemon_is_outdated = daemon_outdated;
-
-    if (daemon_outdated)
-    {
-      uint64_t daemon_missed_fork_height = wallet_hard_forks[wallet_num_hard_forks-2].height;
-      bool daemon_missed_fork = height >= daemon_missed_fork_height || target_height >= daemon_missed_fork_height;
-      if (daemon_missed_fork)
-        return false;
-    }
-
-    // Don't need to check if wallet is outdated here because the daemons updated
-    // for a future hard fork will serve daemon_hard_forks above. The check for
-    // an outdated wallet is done above using daemon_hard_forks.
-  }
-
-  return true;
-}
-//----------------------------------------------------------------------------------------------------
 void wallet2::set_offline(bool offline)
 {
   m_offline = offline;

src/wallet/wallet2.h

@@ -772,7 +772,6 @@ namespace tools
     void discard_unmixable_outputs();
     bool check_connection(uint32_t *version = NULL, bool *ssl = NULL, uint32_t timeout = 200000, bool *wallet_is_outdated = NULL, bool *daemon_is_outdated = NULL);
     bool check_version(uint32_t *version, bool *wallet_is_outdated, bool *daemon_is_outdated);
-    bool check_hard_fork_version(cryptonote::network_type nettype, const std::vector<std::pair<uint8_t, uint64_t>> &daemon_hard_forks, const uint64_t height, const uint64_t target_height, bool *wallet_is_outdated, bool *daemon_is_outdated);
     void get_transfers(wallet2::transfer_container& incoming_transfers, const bool include_all = true) const;
     void get_payments(const crypto::hash& payment_id, std::list<wallet2::payment_details>& payments, uint64_t min_height = 0, const boost::optional<uint32_t>& subaddr_account = boost::none, const std::set<uint32_t>& subaddr_indices = {}) const;
     void get_payments(std::list<std::pair<crypto::hash,wallet2::payment_details>>& payments, uint64_t min_height, uint64_t max_height = (uint64_t)-1, const boost::optional<uint32_t>& subaddr_account = boost::none, const std::set<uint32_t>& subaddr_indices = {}) const;