Merge pull request #8724

d2a591d wallet, simplewallet: Drop support for mine-to-use RPC system (Jeffrey Ryan)

1 files changed, 1 insertions, 95 deletions

diff --git a/src/wallet/node_rpc_proxy.cpp b/src/wallet/node_rpc_proxy.cpp
index 62a525a4b..dd0f6eb0c 100644
--- a/src/wallet/node_rpc_proxy.cpp
+++ b/src/wallet/node_rpc_proxy.cpp
@@ -28,8 +28,6 @@
 
 #include "node_rpc_proxy.h"
 #include "rpc/core_rpc_server_commands_defs.h"
-#include "rpc/rpc_payment_signature.h"
-#include "rpc/rpc_payment_costs.h"
 #include "storages/http_abstract_invoke.h"
 
 #include <boost/thread.hpp>
@@ -37,7 +35,6 @@
 #define RETURN_ON_RPC_RESPONSE_ERROR(r, error, res, method) \
   do { \
     CHECK_AND_ASSERT_MES(error.code == 0, error.message, error.message); \
-    handle_payment_changes(res, std::integral_constant<bool, HasCredits<decltype(res)>::Has>()); \
     CHECK_AND_ASSERT_MES(r, std::string("Failed to connect to daemon"), "Failed to connect to daemon"); \
     /* empty string -> not connection */ \
     CHECK_AND_ASSERT_MES(!res.status.empty(), res.status, "No connection to daemon"); \
@@ -53,9 +50,8 @@ namespace tools
 
 static const std::chrono::seconds rpc_timeout = std::chrono::minutes(3) + std::chrono::seconds(30);
 
-NodeRPCProxy::NodeRPCProxy(epee::net_utils::http::abstract_http_client &http_client, rpc_payment_state_t &rpc_payment_state, boost::recursive_mutex &mutex)
+NodeRPCProxy::NodeRPCProxy(epee::net_utils::http::abstract_http_client &http_client, boost::recursive_mutex &mutex)
   : m_http_client(http_client)
-  , m_rpc_payment_state(rpc_payment_state)
   , m_daemon_rpc_mutex(mutex)
   , m_offline(false)
 {
@@ -77,16 +73,8 @@ void NodeRPCProxy::invalidate()
   m_block_weight_limit = 0;
   m_adjusted_time = 0;
   m_get_info_time = 0;
-  m_rpc_payment_info_time = 0;
-  m_rpc_payment_seed_height = 0;
-  m_rpc_payment_seed_hash = crypto::null_hash;
-  m_rpc_payment_next_seed_hash = crypto::null_hash;
   m_height_time = 0;
   m_target_height_time = 0;
-  m_rpc_payment_diff = 0;
-  m_rpc_payment_credits_per_hash_found = 0;
-  m_rpc_payment_height = 0;
-  m_rpc_payment_cookie = 0;
   m_daemon_hard_forks.clear();
 }
 
@@ -147,11 +135,8 @@ boost::optional<std::string> NodeRPCProxy::get_info()
 
     {
       const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
-      uint64_t pre_call_credits = m_rpc_payment_state.credits;
-      req_t.client = cryptonote::make_rpc_payment_signature(m_client_id_secret_key);
       bool r = net_utils::invoke_http_json_rpc("/json_rpc", "get_info", req_t, resp_t, m_http_client, rpc_timeout);
       RETURN_ON_RPC_RESPONSE_ERROR(r, epee::json_rpc::error{}, resp_t, "get_info");
-      check_rpc_cost(m_rpc_payment_state, "get_info", resp_t.credits, pre_call_credits, COST_PER_GET_INFO);
     }
 
     m_height = resp_t.height;
@@ -227,11 +212,8 @@ boost::optional<std::string> NodeRPCProxy::get_earliest_height(uint8_t version,
 
     {
       const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
-      uint64_t pre_call_credits = m_rpc_payment_state.credits;
-      req_t.client = cryptonote::make_rpc_payment_signature(m_client_id_secret_key);
       bool r = net_utils::invoke_http_json_rpc("/json_rpc", "hard_fork_info", req_t, resp_t, m_http_client, rpc_timeout);
       RETURN_ON_RPC_RESPONSE_ERROR(r, epee::json_rpc::error{}, resp_t, "hard_fork_info");
-      check_rpc_cost(m_rpc_payment_state, "hard_fork_info", resp_t.credits, pre_call_credits, COST_PER_HARD_FORK_INFO);
     }
 
     m_earliest_height[version] = resp_t.earliest_height;
@@ -259,11 +241,8 @@ boost::optional<std::string> NodeRPCProxy::get_dynamic_base_fee_estimate_2021_sc
 
     {
       const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
-      uint64_t pre_call_credits = m_rpc_payment_state.credits;
-      req_t.client = cryptonote::make_rpc_payment_signature(m_client_id_secret_key);
       bool r = net_utils::invoke_http_json_rpc("/json_rpc", "get_fee_estimate", req_t, resp_t, m_http_client, rpc_timeout);
       RETURN_ON_RPC_RESPONSE_ERROR(r, epee::json_rpc::error{}, resp_t, "get_fee_estimate");
-      check_rpc_cost(m_rpc_payment_state, "get_fee_estimate", resp_t.credits, pre_call_credits, COST_PER_FEE_ESTIMATE);
     }
 
     m_dynamic_base_fee_estimate = resp_t.fee;
@@ -305,11 +284,8 @@ boost::optional<std::string> NodeRPCProxy::get_fee_quantization_mask(uint64_t &f
 
     {
       const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
-      uint64_t pre_call_credits = m_rpc_payment_state.credits;
-      req_t.client = cryptonote::make_rpc_payment_signature(m_client_id_secret_key);
       bool r = net_utils::invoke_http_json_rpc("/json_rpc", "get_fee_estimate", req_t, resp_t, m_http_client, rpc_timeout);
       RETURN_ON_RPC_RESPONSE_ERROR(r, epee::json_rpc::error{}, resp_t, "get_fee_estimate");
-      check_rpc_cost(m_rpc_payment_state, "get_fee_estimate", resp_t.credits, pre_call_credits, COST_PER_FEE_ESTIMATE);
     }
 
     m_dynamic_base_fee_estimate = resp_t.fee;
@@ -326,72 +302,6 @@ boost::optional<std::string> NodeRPCProxy::get_fee_quantization_mask(uint64_t &f
   return boost::optional<std::string>();
 }
 
-boost::optional<std::string> NodeRPCProxy::get_rpc_payment_info(bool mining, bool &payment_required, uint64_t &credits, uint64_t &diff, uint64_t &credits_per_hash_found, cryptonote::blobdata &blob, uint64_t &height, uint64_t &seed_height, crypto::hash &seed_hash, crypto::hash &next_seed_hash, uint32_t &cookie)
-{
-  const time_t now = time(NULL);
-  if (m_rpc_payment_state.stale || now >= m_rpc_payment_info_time + 5*60 || (mining && now >= m_rpc_payment_info_time + 10)) // re-cache every 10 seconds if mining, 5 minutes otherwise
-  {
-    cryptonote::COMMAND_RPC_ACCESS_INFO::request req_t = AUTO_VAL_INIT(req_t);
-    cryptonote::COMMAND_RPC_ACCESS_INFO::response resp_t = AUTO_VAL_INIT(resp_t);
-
-    {
-      const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
-      req_t.client = cryptonote::make_rpc_payment_signature(m_client_id_secret_key);
-      bool r = net_utils::invoke_http_json_rpc("/json_rpc", "rpc_access_info", req_t, resp_t, m_http_client, rpc_timeout);
-      RETURN_ON_RPC_RESPONSE_ERROR(r, epee::json_rpc::error{}, resp_t, "rpc_access_info");
-      m_rpc_payment_state.stale = false;
-    }
-
-    m_rpc_payment_diff = resp_t.diff;
-    m_rpc_payment_credits_per_hash_found = resp_t.credits_per_hash_found;
-    m_rpc_payment_height = resp_t.height;
-    m_rpc_payment_seed_height = resp_t.seed_height;
-    m_rpc_payment_cookie = resp_t.cookie;
-
-    if (m_rpc_payment_diff == 0)
-    {
-      // If no payment required daemon doesn't give us back a hashing blob
-      m_rpc_payment_blob.clear();
-    }
-    else if (!epee::string_tools::parse_hexstr_to_binbuff(resp_t.hashing_blob, m_rpc_payment_blob) || m_rpc_payment_blob.size() < 43)
-    {
-      MERROR("Invalid hashing blob: " << resp_t.hashing_blob);
-      return std::string("Invalid hashing blob");
-    }
-    if (resp_t.seed_hash.empty())
-    {
-      m_rpc_payment_seed_hash = crypto::null_hash;
-    }
-    else if (!epee::string_tools::hex_to_pod(resp_t.seed_hash, m_rpc_payment_seed_hash))
-    {
-      MERROR("Invalid seed_hash: " << resp_t.seed_hash);
-      return std::string("Invalid seed hash");
-    }
-    if (resp_t.next_seed_hash.empty())
-    {
-      m_rpc_payment_next_seed_hash = crypto::null_hash;
-    }
-    else if (!epee::string_tools::hex_to_pod(resp_t.next_seed_hash, m_rpc_payment_next_seed_hash))
-    {
-      MERROR("Invalid next_seed_hash: " << resp_t.next_seed_hash);
-      return std::string("Invalid next seed hash");
-    }
-    m_rpc_payment_info_time = now;
-  }
-
-  payment_required = m_rpc_payment_diff > 0;
-  credits = m_rpc_payment_state.credits;
-  diff = m_rpc_payment_diff;
-  credits_per_hash_found = m_rpc_payment_credits_per_hash_found;
-  blob = m_rpc_payment_blob;
-  height = m_rpc_payment_height;
-  seed_height = m_rpc_payment_seed_height;
-  seed_hash = m_rpc_payment_seed_hash;
-  next_seed_hash = m_rpc_payment_next_seed_hash;
-  cookie = m_rpc_payment_cookie;
-  return boost::none;
-}
-
 boost::optional<std::string> NodeRPCProxy::get_transactions(const std::vector<crypto::hash> &txids, const std::function<void(const cryptonote::COMMAND_RPC_GET_TRANSACTIONS::request&, const cryptonote::COMMAND_RPC_GET_TRANSACTIONS::response&, bool)> &f)
 {
   const size_t SLICE_SIZE = 100; // RESTRICTED_TRANSACTIONS_COUNT as defined in rpc/core_rpc_server.cpp
@@ -410,11 +320,7 @@ boost::optional<std::string> NodeRPCProxy::get_transactions(const std::vector<cr
     bool r = false;
     {
       const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
-      uint64_t pre_call_credits = m_rpc_payment_state.credits;
-      req_t.client = cryptonote::make_rpc_payment_signature(m_client_id_secret_key);
       r = net_utils::invoke_http_json("/gettransactions", req_t, resp_t, m_http_client, rpc_timeout);
-      if (r && resp_t.status == CORE_RPC_STATUS_OK)
-        check_rpc_cost(m_rpc_payment_state, "/gettransactions", resp_t.credits, pre_call_credits, resp_t.txs.size() * COST_PER_TX);
     }
 
     f(req_t, resp_t, r);