daemon: add more chain specific info in alt_chain_info

src/common/util.cpp

@@ -1068,6 +1068,23 @@ std::string get_nix_version_display_string()
     return std::string(buffer);
   }
 
+  std::string get_human_readable_timespan(uint64_t seconds)
+  {
+    if (seconds < 60)
+      return std::to_string(seconds) + " seconds";
+    if (seconds < 3600)
+      return std::to_string((uint64_t)(seconds / 60)) + " minutes";
+    if (seconds < 3600 * 24)
+      return std::to_string((uint64_t)(seconds / 3600)) + " hours";
+    if (seconds < 3600 * 24 * 30.5)
+      return std::to_string((uint64_t)(seconds / (3600 * 24))) + " days";
+    if (seconds < 3600 * 24 * 365.25)
+      return std::to_string((uint64_t)(seconds / (3600 * 24 * 30.5))) + " months";
+    if (seconds < 3600 * 24 * 365.25 * 100)
+      return std::to_string((uint64_t)(seconds / (3600 * 24 * 30.5 * 365.25))) + " years";
+    return "a long time";
+  }
+
   std::string get_human_readable_bytes(uint64_t bytes)
   {
     // Use 1024 for "kilo", 1024*1024 for "mega" and so on instead of the more modern and standard-conforming

src/common/util.h

@@ -245,5 +245,7 @@ namespace tools
 
   std::string get_human_readable_timestamp(uint64_t ts);
 
+  std::string get_human_readable_timespan(uint64_t seconds);
+
   std::string get_human_readable_bytes(uint64_t bytes);
 }

src/daemon/rpc_command_executor.cpp

@@ -1884,6 +1884,7 @@ bool t_rpc_command_executor::alt_chain_info(const std::string &tip, size_t above
   }
   else
   {
+    const uint64_t now = time(NULL);
     const auto i = std::find_if(res.chains.begin(), res.chains.end(), [&tip](cryptonote::COMMAND_RPC_GET_ALTERNATE_CHAINS::chain_info &info){ return info.block_hash == tip; });
     if (i != res.chains.end())
     {
@@ -1895,6 +1896,49 @@ bool t_rpc_command_executor::alt_chain_info(const std::string &tip, size_t above
       for (const std::string &block_id: chain.block_hashes)
         tools::msg_writer() << "  " << block_id;
       tools::msg_writer() << "Chain parent on main chain: " << chain.main_chain_parent_block;
+      cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::request bhreq;
+      cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH::response bhres;
+      bhreq.hashes = chain.block_hashes;
+      bhreq.hashes.push_back(chain.main_chain_parent_block);
+      bhreq.fill_pow_hash = false;
+      if (m_is_rpc)
+      {
+        if (!m_rpc_client->json_rpc_request(bhreq, bhres, "getblockheaderbyhash", fail_message.c_str()))
+        {
+          return true;
+        }
+      }
+      else
+      {
+        if (!m_rpc_server->on_get_block_header_by_hash(bhreq, bhres, error_resp))
+        {
+          tools::fail_msg_writer() << make_error(fail_message, res.status);
+          return true;
+        }
+      }
+      if (bhres.block_headers.size() != chain.length + 1)
+      {
+        tools::fail_msg_writer() << "Failed to get block header info for alt chain";
+        return true;
+      }
+      uint64_t t0 = bhres.block_headers.front().timestamp, t1 = t0;
+      for (const cryptonote::block_header_response &block_header: bhres.block_headers)
+      {
+        t0 = std::min<uint64_t>(t0, block_header.timestamp);
+        t1 = std::max<uint64_t>(t1, block_header.timestamp);
+      }
+      const uint64_t dt = t1 - t0;
+      const uint64_t age = std::max(dt, t0 < now ? now - t0 : 0);
+      tools::msg_writer() << "Age: " << tools::get_human_readable_timespan(age);
+      if (chain.length > 1)
+      {
+        tools::msg_writer() << "Time span: " << tools::get_human_readable_timespan(dt);
+        cryptonote::difficulty_type start_difficulty = bhres.block_headers.back().difficulty;
+        if (start_difficulty > 0)
+          tools::msg_writer() << "Approximated " << 100.f * DIFFICULTY_TARGET_V2 * chain.length / dt << "% of network hash rate";
+        else
+          tools::fail_msg_writer() << "Bad cmumulative difficulty reported by dameon";
+      }
     }
     else
       tools::fail_msg_writer() << "Block hash " << tip << " is not the tip of any known alternate chain";

src/rpc/core_rpc_server.cpp

@@ -1593,12 +1593,13 @@ namespace cryptonote
     if (use_bootstrap_daemon_if_necessary<COMMAND_RPC_GET_BLOCK_HEADER_BY_HASH>(invoke_http_mode::JON_RPC, "getblockheaderbyhash", req, res, r))
       return r;
 
+    auto get = [this](const std::string &hash, bool fill_pow_hash, block_header_response &block_header, bool restricted, epee::json_rpc::error& error_resp) -> bool {
       crypto::hash block_hash;
-    bool hash_parsed = parse_hash256(req.hash, block_hash);
+      bool hash_parsed = parse_hash256(hash, block_hash);
       if(!hash_parsed)
       {
         error_resp.code = CORE_RPC_ERROR_CODE_WRONG_PARAM;
-      error_resp.message = "Failed to parse hex representation of block hash. Hex = " + req.hash + '.';
+        error_resp.message = "Failed to parse hex representation of block hash. Hex = " + hash + '.';
         return false;
       }
       block blk;
@@ -1607,7 +1608,7 @@ namespace cryptonote
       if (!have_block)
       {
         error_resp.code = CORE_RPC_ERROR_CODE_INTERNAL_ERROR;
-      error_resp.message = "Internal error: can't get block by hash. Hash = " + req.hash + '.';
+        error_resp.message = "Internal error: can't get block by hash. Hash = " + hash + '.';
         return false;
       }
       if (blk.miner_tx.vin.size() != 1 || blk.miner_tx.vin.front().type() != typeid(txin_gen))
@@ -1617,14 +1618,30 @@ namespace cryptonote
         return false;
       }
       uint64_t block_height = boost::get<txin_gen>(blk.miner_tx.vin.front()).height;
-    const bool restricted = m_restricted && ctx;
-    bool response_filled = fill_block_header_response(blk, orphan, block_height, block_hash, res.block_header, req.fill_pow_hash && !restricted);
+      bool response_filled = fill_block_header_response(blk, orphan, block_height, block_hash, block_header, fill_pow_hash && !restricted);
       if (!response_filled)
       {
         error_resp.code = CORE_RPC_ERROR_CODE_INTERNAL_ERROR;
         error_resp.message = "Internal error: can't produce valid response.";
         return false;
       }
+      return true;
+    };
+
+    const bool restricted = m_restricted && ctx;
+    if (!req.hash.empty())
+    {
+      if (!get(req.hash, req.fill_pow_hash, res.block_header, restricted, error_resp))
+        return false;
+    }
+    res.block_headers.reserve(req.hashes.size());
+    for (const std::string &hash: req.hashes)
+    {
+      res.block_headers.push_back({});
+      if (!get(hash, req.fill_pow_hash, res.block_headers.back(), restricted, error_resp))
+        return false;
+    }
+
     res.status = CORE_RPC_STATUS_OK;
     return true;
   }

src/rpc/core_rpc_server_commands_defs.h

@@ -84,7 +84,7 @@ namespace cryptonote
 // advance which version they will stop working with
 // Don't go over 32767 for any of these
 #define CORE_RPC_VERSION_MAJOR 2
-#define CORE_RPC_VERSION_MINOR 6
+#define CORE_RPC_VERSION_MINOR 7
 #define MAKE_CORE_RPC_VERSION(major,minor) (((major)<<16)|(minor))
 #define CORE_RPC_VERSION MAKE_CORE_RPC_VERSION(CORE_RPC_VERSION_MAJOR, CORE_RPC_VERSION_MINOR)
 
@@ -1091,10 +1091,12 @@ namespace cryptonote
     struct request_t
     {
       std::string hash;
+      std::vector<std::string> hashes;
       bool fill_pow_hash;
 
       BEGIN_KV_SERIALIZE_MAP()
         KV_SERIALIZE(hash)
+        KV_SERIALIZE(hashes)
         KV_SERIALIZE_OPT(fill_pow_hash, false);
       END_KV_SERIALIZE_MAP()
     };
@@ -1104,10 +1106,12 @@ namespace cryptonote
     {
       std::string status;
       block_header_response block_header;
+      std::vector<block_header_response> block_headers;
       bool untrusted;
       
       BEGIN_KV_SERIALIZE_MAP()
         KV_SERIALIZE(block_header)
+        KV_SERIALIZE(block_headers)
         KV_SERIALIZE(status)
         KV_SERIALIZE(untrusted)
       END_KV_SERIALIZE_MAP()

utils/python-rpc/framework/daemon.py

@@ -88,11 +88,12 @@ class Daemon(object):
         }
         return self.rpc.send_json_rpc_request(getlastblockheader)
 
-    def getblockheaderbyhash(self, hash):
+    def getblockheaderbyhash(self, hash = "", hashes = []):
         getblockheaderbyhash = {
             'method': 'getblockheaderbyhash',
             'params': {
                 'hash': hash,
+                'hashes': hashes,
             },
             'jsonrpc': '2.0', 
             'id': '0'