Merge pull request #601

664dc42 rpc: fix missing target information in RPC call (moneromooo-monero)
eaf4dcd daemon: fix status command when run from command line (moneromooo-monero)
67bbb56 wallet2: decide at runtime which upper tx size to use (moneromooo-monero)
a44d94d rpc: is_key_image_spent now checks the tx pool too (moneromooo-monero)

src/daemon/rpc_command_executor.cpp

@@ -277,7 +277,7 @@ bool t_rpc_command_executor::show_status() {
     {
       return true;
     }
-    if (!m_rpc_client->rpc_request(mreq, mres, "mining_status", fail_message.c_str()))
+    if (!m_rpc_client->rpc_request(mreq, mres, "/mining_status", fail_message.c_str()))
     {
       return true;
     }

src/rpc/core_rpc_server.cpp

@@ -304,7 +304,37 @@ namespace cryptonote
     }
     res.spent_status.clear();
     for (size_t n = 0; n < spent_status.size(); ++n)
-      res.spent_status.push_back(spent_status[n]);
+      res.spent_status.push_back(spent_status[n] ? COMMAND_RPC_IS_KEY_IMAGE_SPENT::SPENT_IN_BLOCKCHAIN : COMMAND_RPC_IS_KEY_IMAGE_SPENT::UNSPENT);
+
+    // check the pool too
+    std::vector<cryptonote::tx_info> txs;
+    std::vector<cryptonote::spent_key_image_info> ki;
+    r = m_core.get_pool_transactions_and_spent_keys_info(txs, ki);
+    if(!r)
+    {
+      res.status = "Failed";
+      return true;
+    }
+    for (std::vector<cryptonote::spent_key_image_info>::const_iterator i = ki.begin(); i != ki.end(); ++i)
+    {
+      crypto::hash hash;
+      crypto::key_image spent_key_image;
+      if (parse_hash256(i->id_hash, hash))
+      {
+        memcpy(&spent_key_image, &hash, sizeof(hash)); // a bit dodgy, should be other parse functions somewhere
+        for (size_t n = 0; n < res.spent_status.size(); ++n)
+        {
+          if (res.spent_status[n] == COMMAND_RPC_IS_KEY_IMAGE_SPENT::UNSPENT)
+          {
+            if (key_images[n] == spent_key_image)
+            {
+              res.spent_status[n] = COMMAND_RPC_IS_KEY_IMAGE_SPENT::SPENT_IN_POOL;
+              break;
+            }
+          }
+        }
+      }
+    }
 
     res.status = CORE_RPC_STATUS_OK;
     return true;
@@ -872,6 +902,7 @@ namespace cryptonote
     res.height = m_core.get_current_blockchain_height();
     res.target_height = m_core.get_target_blockchain_height();
     res.difficulty = m_core.get_blockchain_storage().get_difficulty_for_next_block();
+    res.target = m_core.get_blockchain_storage().get_current_hard_fork_version() < 2 ? DIFFICULTY_TARGET_V1 : DIFFICULTY_TARGET;
     res.tx_count = m_core.get_blockchain_storage().get_total_transactions() - res.height; //without coinbase
     res.tx_pool_size = m_core.get_pool_transactions_count();
     res.alt_blocks_count = m_core.get_blockchain_storage().get_alternative_blocks_count();
@@ -880,6 +911,7 @@ namespace cryptonote
     res.incoming_connections_count = total_conn - res.outgoing_connections_count;
     res.white_peerlist_size = m_p2p.get_peerlist_manager().get_white_peers_count();
     res.grey_peerlist_size = m_p2p.get_peerlist_manager().get_gray_peers_count();
+    res.testnet = m_testnet;
     res.status = CORE_RPC_STATUS_OK;
     return true;
   }

src/rpc/core_rpc_server_commands_defs.h

@@ -123,6 +123,12 @@ namespace cryptonote
   //-----------------------------------------------
   struct COMMAND_RPC_IS_KEY_IMAGE_SPENT
   {
+    enum STATUS {
+      UNSPENT = 0,
+      SPENT_IN_BLOCKCHAIN = 1,
+      SPENT_IN_POOL = 2,
+    };
+
     struct request
     {
       std::vector<std::string> key_images;
@@ -289,6 +295,7 @@ namespace cryptonote
         KV_SERIALIZE(height)
         KV_SERIALIZE(target_height)
         KV_SERIALIZE(difficulty)
+        KV_SERIALIZE(target)
         KV_SERIALIZE(tx_count)
         KV_SERIALIZE(tx_pool_size)
         KV_SERIALIZE(alt_blocks_count)

src/wallet/wallet2.cpp

@@ -1419,15 +1419,15 @@ void wallet2::rescan_spent()
   for (size_t i = 0; i < m_transfers.size(); ++i)
   {
     transfer_details& td = m_transfers[i];
-    if (td.m_spent != daemon_resp.spent_status[i])
+    if (td.m_spent != (daemon_resp.spent_status[i] != COMMAND_RPC_IS_KEY_IMAGE_SPENT::UNSPENT))
     {
       if (td.m_spent)
       {
-        LOG_PRINT_L1("Marking output " << i << " as unspent, it was marked as spent");
+        LOG_PRINT_L0("Marking output " << i << "(" << td.m_key_image << ") as unspent, it was marked as spent");
       }
       else
       {
-        LOG_PRINT_L1("Marking output " << i << " as spent, it was marked as unspent");
+        LOG_PRINT_L0("Marking output " << i << "(" << td.m_key_image << ") as spent, it was marked as unspent");
       }
       td.m_spent = daemon_resp.spent_status[i];
     }
@@ -1880,6 +1880,7 @@ void wallet2::transfer_selected(const std::vector<cryptonote::tx_destination_ent
   // throw if attempting a transaction with no destinations
   THROW_WALLET_EXCEPTION_IF(dsts.empty(), error::zero_destination);
 
+  uint64_t upper_transaction_size_limit = get_upper_tranaction_size_limit();
   uint64_t needed_money = fee;
   LOG_PRINT_L2("transfer: starting with fee " << print_money (needed_money));
 
@@ -2005,7 +2006,7 @@ void wallet2::transfer_selected(const std::vector<cryptonote::tx_destination_ent
   crypto::secret_key tx_key;
   bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), sources, splitted_dsts, extra, tx, unlock_time, tx_key);
   THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sources, splitted_dsts, unlock_time, m_testnet);
-  THROW_WALLET_EXCEPTION_IF(m_upper_transaction_size_limit <= get_object_blobsize(tx), error::tx_too_big, tx, m_upper_transaction_size_limit);
+  THROW_WALLET_EXCEPTION_IF(upper_transaction_size_limit <= get_object_blobsize(tx), error::tx_too_big, tx, upper_transaction_size_limit);
 
   std::string key_images;
   bool all_are_txin_to_key = std::all_of(tx.vin.begin(), tx.vin.end(), [&](const txin_v& s_e) -> bool
@@ -2066,6 +2067,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
   std::vector<TX> txes;
   bool adding_fee; // true if new outputs go towards fee, rather than destinations
   uint64_t needed_fee, available_for_fee = 0;
+  uint64_t upper_transaction_size_limit = get_upper_tranaction_size_limit();
 
   // throw if attempting a transaction with no destinations
   THROW_WALLET_EXCEPTION_IF(dsts.empty(), error::zero_destination);
@@ -2158,7 +2160,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
 
     // here, check if we need to sent tx and start a new one
     LOG_PRINT_L2("Considering whether to create a tx now, " << tx.selected_transfers.size() << " inputs, tx limit "
-      << m_upper_transaction_size_limit);
+      << upper_transaction_size_limit);
     bool try_tx;
     if (adding_fee)
     {
@@ -2167,7 +2169,7 @@ std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryp
     }
     else
     {
-      try_tx = dsts.empty() || (tx.selected_transfers.size() * (fake_outs_count+1) * APPROXIMATE_INPUT_BYTES >= TX_SIZE_TARGET(m_upper_transaction_size_limit));
+      try_tx = dsts.empty() || (tx.selected_transfers.size() * (fake_outs_count+1) * APPROXIMATE_INPUT_BYTES >= TX_SIZE_TARGET(upper_transaction_size_limit));
     }
 
     if (try_tx) {
@@ -2290,6 +2292,8 @@ void wallet2::transfer_dust(size_t num_outputs, uint64_t unlock_time, uint64_t n
 {
   using namespace cryptonote;
 
+  uint64_t upper_transaction_size_limit = get_upper_tranaction_size_limit();
+
   // select all dust inputs for transaction
   // throw if there are none
   uint64_t money = 0;
@@ -2354,7 +2358,7 @@ void wallet2::transfer_dust(size_t num_outputs, uint64_t unlock_time, uint64_t n
   crypto::secret_key tx_key;
   bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), sources, splitted_dsts, extra, tx, unlock_time, tx_key);
   THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sources, splitted_dsts, unlock_time, m_testnet);
-  THROW_WALLET_EXCEPTION_IF(m_upper_transaction_size_limit <= get_object_blobsize(tx), error::tx_too_big, tx, m_upper_transaction_size_limit);
+  THROW_WALLET_EXCEPTION_IF(upper_transaction_size_limit <= get_object_blobsize(tx), error::tx_too_big, tx, upper_transaction_size_limit);
 
   std::string key_images;
   bool all_are_txin_to_key = std::all_of(tx.vin.begin(), tx.vin.end(), [&](const txin_v& s_e) -> bool
@@ -2409,6 +2413,14 @@ bool wallet2::use_fork_rules(uint8_t version)
   return close_enough;
 }
 //----------------------------------------------------------------------------------------------------
+uint64_t wallet2::get_upper_tranaction_size_limit()
+{
+  if (m_upper_transaction_size_limit > 0)
+    return m_upper_transaction_size_limit;
+  uint64_t full_reward_zone = use_fork_rules(2) ? CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE : CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V1;
+  return ((full_reward_zone * 125) / 100) - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
+}
+//----------------------------------------------------------------------------------------------------
 std::vector<wallet2::pending_tx> wallet2::create_dust_sweep_transactions()
 {
   // From hard fork 1, we don't consider small amounts to be dust anymore

src/wallet/wallet2.h

@@ -214,7 +214,7 @@ namespace tools
     // free block size. TODO: fix this so that it actually takes
     // into account the current median block size rather than
     // the minimum block size.
-    void init(const std::string& daemon_address = "http://localhost:8080", uint64_t upper_transaction_size_limit = ((CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE * 125) / 100) - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE);
+    void init(const std::string& daemon_address = "http://localhost:8080", uint64_t upper_transaction_size_limit = 0);
     bool deinit();
 
     void stop() { m_run.store(false, std::memory_order_relaxed); }
@@ -374,6 +374,7 @@ namespace tools
     void check_acc_out(const cryptonote::account_keys &acc, const cryptonote::tx_out &o, const crypto::public_key &tx_pub_key, size_t i, uint64_t &money_transfered, bool &error) const;
     void parse_block_round(const cryptonote::blobdata &blob, cryptonote::block &bl, crypto::hash &bl_id, bool &error) const;
     bool use_fork_rules(uint8_t version);
+    uint64_t get_upper_tranaction_size_limit();
 
     cryptonote::account_base m_account;
     std::string m_daemon_address;
@@ -543,6 +544,7 @@ namespace tools
     // throw if attempting a transaction with no destinations
     THROW_WALLET_EXCEPTION_IF(dsts.empty(), error::zero_destination);
 
+    uint64_t upper_transaction_size_limit = get_upper_tranaction_size_limit();
     uint64_t needed_money = fee;
 
     // calculate total amount being sent to all destinations
@@ -664,7 +666,7 @@ namespace tools
     crypto::secret_key tx_key;
     bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), sources, splitted_dsts, extra, tx, unlock_time, tx_key);
     THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sources, splitted_dsts, unlock_time, m_testnet);
-    THROW_WALLET_EXCEPTION_IF(m_upper_transaction_size_limit <= get_object_blobsize(tx), error::tx_too_big, tx, m_upper_transaction_size_limit);
+    THROW_WALLET_EXCEPTION_IF(upper_transaction_size_limit <= get_object_blobsize(tx), error::tx_too_big, tx, upper_transaction_size_limit);
 
     std::string key_images;
     bool all_are_txin_to_key = std::all_of(tx.vin.begin(), tx.vin.end(), [&](const txin_v& s_e) -> bool