fix chaingen tests

- fix tx create from sources, input locking. Originally, creating a synthetic transactions with chaingen could create a transaction with outputs that are still locked in the current block, thus failing chain validation by the daemon. Simple unlock check was added. Some buggy tests were fixed as well as new unlock-checking version of tx creation rejected those, fixes are simple - mostly using correct block after a rewind to construct a transaction

1 files changed, 39 insertions, 20 deletions

diff --git a/tests/core_tests/chaingen.cpp b/tests/core_tests/chaingen.cpp
index b66aa7924..9aa0de8e5 100644
--- a/tests/core_tests/chaingen.cpp
+++ b/tests/core_tests/chaingen.cpp
@@ -504,7 +504,7 @@ bool init_spent_output_indices(map_output_idx_t& outs, map_output_t& outs_mine,
     return true;
 }
 
-bool fill_output_entries(std::vector<output_index>& out_indices, size_t sender_out, size_t nmix, size_t& real_entry_idx, std::vector<tx_source_entry::output_entry>& output_entries)
+bool fill_output_entries(std::vector<output_index>& out_indices, size_t sender_out, size_t nmix, size_t& real_entry_idx, std::vector<tx_source_entry::output_entry>& output_entries, uint64_t cur_height, const boost::optional<fnc_accept_output_t>& fnc_accept = boost::none)
 {
   if (out_indices.size() <= nmix)
     return false;
@@ -516,6 +516,10 @@ bool fill_output_entries(std::vector<output_index>& out_indices, size_t sender_o
     const output_index& oi = out_indices[i];
     if (oi.spent)
       continue;
+    if (oi.unlock_time < CRYPTONOTE_MAX_BLOCK_NUMBER && oi.unlock_time > cur_height + 1)
+      continue;
+    if (fnc_accept && !(fnc_accept.get())({.oi=oi, .cur_height=cur_height}))
+      continue;
 
     bool append = false;
     if (i == sender_out)
@@ -542,7 +546,8 @@ bool fill_output_entries(std::vector<output_index>& out_indices, size_t sender_o
 }
 
 bool fill_tx_sources(std::vector<tx_source_entry>& sources, const std::vector<test_event_entry>& events,
-                     const block& blk_head, const cryptonote::account_base& from, uint64_t amount, size_t nmix)
+                     const block& blk_head, const cryptonote::account_base& from, uint64_t amount, size_t nmix,
+                     bool check_unlock_time, const boost::optional<fnc_accept_output_t>& fnc_accept)
 {
     map_output_idx_t outs;
     map_output_t outs_mine;
@@ -559,6 +564,7 @@ bool fill_tx_sources(std::vector<tx_source_entry>& sources, const std::vector<te
         return false;
 
     // Iterate in reverse is more efficiency
+    uint64_t head_height = check_unlock_time ? get_block_height(blk_head) : std::numeric_limits<uint64_t>::max() - 1;
     uint64_t sources_amount = 0;
     bool sources_found = false;
     BOOST_REVERSE_FOREACH(const map_output_t::value_type o, outs_mine)
@@ -571,13 +577,17 @@ bool fill_tx_sources(std::vector<tx_source_entry>& sources, const std::vector<te
                 continue;
             if (oi.rct)
                 continue;
+            if (oi.unlock_time < CRYPTONOTE_MAX_BLOCK_NUMBER && oi.unlock_time > head_height + 1)
+                continue;
+            if (fnc_accept && !(fnc_accept.get())({.oi=oi, .cur_height=head_height}))
+                continue;
 
             cryptonote::tx_source_entry ts;
             ts.amount = oi.amount;
             ts.real_output_in_tx_index = oi.out_no;
             ts.real_out_tx_key = get_tx_pub_key_from_extra(*oi.p_tx); // incoming tx public key
             size_t realOutput;
-            if (!fill_output_entries(outs[o.first], sender_out, nmix, realOutput, ts.outputs))
+            if (!fill_output_entries(outs[o.first], sender_out, nmix, realOutput, ts.outputs, head_height, fnc_accept))
               continue;
 
             ts.real_output = realOutput;
@@ -692,7 +702,7 @@ void block_tracker::global_indices(const cryptonote::transaction *tx, std::vecto
   }
 }
 
-void block_tracker::get_fake_outs(size_t num_outs, uint64_t amount, uint64_t global_index, uint64_t cur_height, std::vector<get_outs_entry> &outs){
+void block_tracker::get_fake_outs(size_t num_outs, uint64_t amount, uint64_t global_index, uint64_t cur_height, std::vector<get_outs_entry> &outs, const boost::optional<fnc_accept_output_t>& fnc_accept){
   auto & vct = m_outs[amount];
   const size_t n_outs = vct.size();
   CHECK_AND_ASSERT_THROW_MES(n_outs > 0, "n_outs is 0");
@@ -717,15 +727,16 @@ void block_tracker::get_fake_outs(size_t num_outs, uint64_t amount, uint64_t glo
       continue;
     if (oi.out.type() != typeid(cryptonote::txout_to_key))
       continue;
-    if (oi.unlock_time > cur_height)
+    if (oi.unlock_time < CRYPTONOTE_MAX_BLOCK_NUMBER && oi.unlock_time > cur_height + 1)
       continue;
     if (used.find(oi_idx) != used.end())
       continue;
+    if (fnc_accept && !(fnc_accept.get())({.oi=oi, .cur_height=cur_height}))
+      continue;
 
     rct::key comm = oi.commitment();
     auto out = boost::get<txout_to_key>(oi.out);
-    auto item = std::make_tuple(oi.idx, out.key, comm);
-    outs.push_back(item);
+    outs.emplace_back(oi.idx, out.key, comm);
     used.insert(oi_idx);
   }
 }
@@ -924,13 +935,14 @@ void fill_tx_destinations(const var_addr_t& from, const cryptonote::account_publ
 void fill_tx_sources_and_destinations(const std::vector<test_event_entry>& events, const block& blk_head,
                                       const cryptonote::account_base& from, const cryptonote::account_public_address& to,
                                       uint64_t amount, uint64_t fee, size_t nmix, std::vector<tx_source_entry>& sources,
-                                      std::vector<tx_destination_entry>& destinations)
+                                      std::vector<tx_destination_entry>& destinations, bool check_unlock_time,
+                                      const boost::optional<fnc_accept_output_t>& fnc_tx_in_accept)
 {
   sources.clear();
   destinations.clear();
 
-  if (!fill_tx_sources(sources, events, blk_head, from, amount + fee, nmix))
-    throw std::runtime_error("couldn't fill transaction sources");
+  if (!fill_tx_sources(sources, events, blk_head, from, amount + fee, nmix, check_unlock_time, fnc_tx_in_accept))
+    throw tx_construct_tx_fill_error();
 
   fill_tx_destinations(from, to, amount, fee, sources, destinations, false);
 }
@@ -938,9 +950,10 @@ void fill_tx_sources_and_destinations(const std::vector<test_event_entry>& event
 void fill_tx_sources_and_destinations(const std::vector<test_event_entry>& events, const block& blk_head,
                                       const cryptonote::account_base& from, const cryptonote::account_base& to,
                                       uint64_t amount, uint64_t fee, size_t nmix, std::vector<tx_source_entry>& sources,
-                                      std::vector<tx_destination_entry>& destinations)
+                                      std::vector<tx_destination_entry>& destinations, bool check_unlock_time,
+                                      const boost::optional<fnc_accept_output_t>& fnc_tx_in_accept)
 {
-  fill_tx_sources_and_destinations(events, blk_head, from, to.get_keys().m_account_address, amount, fee, nmix, sources, destinations);
+  fill_tx_sources_and_destinations(events, blk_head, from, to.get_keys().m_account_address, amount, fee, nmix, sources, destinations, check_unlock_time, fnc_tx_in_accept);
 }
 
 cryptonote::tx_destination_entry build_dst(const var_addr_t& to, bool is_subaddr, uint64_t amount)
@@ -952,10 +965,14 @@ cryptonote::tx_destination_entry build_dst(const var_addr_t& to, bool is_subaddr
   return de;
 }
 
-std::vector<cryptonote::tx_destination_entry> build_dsts(const var_addr_t& to1, bool sub1, uint64_t am1)
+std::vector<cryptonote::tx_destination_entry> build_dsts(const var_addr_t& to1, bool sub1, uint64_t am1, size_t repeat)
 {
   std::vector<cryptonote::tx_destination_entry> res;
-  res.push_back(build_dst(to1, sub1, am1));
+  res.reserve(repeat);
+  for(size_t i = 0; i < repeat; ++i)
+  {
+    res.emplace_back(build_dst(to1, sub1, am1));
+  }
   return res;
 }
 
@@ -1019,25 +1036,27 @@ bool construct_miner_tx_manually(size_t height, uint64_t already_generated_coins
 
 bool construct_tx_to_key(const std::vector<test_event_entry>& events, cryptonote::transaction& tx, const cryptonote::block& blk_head,
                          const cryptonote::account_base& from, const var_addr_t& to, uint64_t amount,
-                         uint64_t fee, size_t nmix, bool rct, rct::RangeProofType range_proof_type, int bp_version)
+                         uint64_t fee, size_t nmix, bool rct, rct::RangeProofType range_proof_type, int bp_version,
+                         bool check_unlock_time, const boost::optional<fnc_accept_output_t>& fnc_tx_in_accept)
 {
   vector<tx_source_entry> sources;
   vector<tx_destination_entry> destinations;
-  fill_tx_sources_and_destinations(events, blk_head, from, get_address(to), amount, fee, nmix, sources, destinations);
+  fill_tx_sources_and_destinations(events, blk_head, from, get_address(to), amount, fee, nmix, sources, destinations, check_unlock_time, fnc_tx_in_accept);
 
   return construct_tx_rct(from.get_keys(), sources, destinations, from.get_keys().m_account_address, std::vector<uint8_t>(), tx, 0, rct, range_proof_type, bp_version);
 }
 
 bool construct_tx_to_key(const std::vector<test_event_entry>& events, cryptonote::transaction& tx, const cryptonote::block& blk_head,
-                         const cryptonote::account_base& from, std::vector<cryptonote::tx_destination_entry> destinations,
-                         uint64_t fee, size_t nmix, bool rct, rct::RangeProofType range_proof_type, int bp_version)
+                         const cryptonote::account_base& from, const std::vector<cryptonote::tx_destination_entry>& destinations,
+                         uint64_t fee, size_t nmix, bool rct, rct::RangeProofType range_proof_type, int bp_version,
+                         bool check_unlock_time, const boost::optional<fnc_accept_output_t>& fnc_tx_in_accept)
 {
   vector<tx_source_entry> sources;
   vector<tx_destination_entry> destinations_all;
   uint64_t amount = sum_amount(destinations);
 
-  if (!fill_tx_sources(sources, events, blk_head, from, amount + fee, nmix))
-    throw std::runtime_error("couldn't fill transaction sources");
+  if (!fill_tx_sources(sources, events, blk_head, from, amount + fee, nmix, check_unlock_time, fnc_tx_in_accept))
+    throw tx_construct_tx_fill_error();
 
   fill_tx_destinations(from, destinations, fee, sources, destinations_all, false);