carrot+fcmp: fix libwallet hot/cold compile errors

Author: jeffro256

src/wallet/api/pending_transaction.cpp

@@ -113,9 +113,12 @@ bool PendingTransactionImpl::commit(const std::string &filename, bool overwrite)
 
         const bool tx_cold_signed = m_wallet.m_wallet->get_account().get_device().has_tx_cold_sign();
         if (tx_cold_signed){
+          wallet2_basic::transfer_container transfers;
+          m_wallet.m_wallet->get_transfers(transfers);
+
           std::unordered_set<size_t> selected_transfers;
           for(const tools::wallet2::pending_tx & ptx : m_pending_tx){
-            for(size_t s : ptx.selected_transfers){
+            for(size_t s : tools::wallet::collect_selected_transfer_indices(ptx.construction_data, transfers)){
               selected_transfers.insert(s);
             }
           }

src/wallet/api/unsigned_transaction.cpp

@@ -175,7 +175,7 @@ bool UnsignedTransactionImpl::checkLoadedTx(const std::string &extra_message)
                 m_errorString = tr("Claimed change is larger than payment to the change address");
                 return  false;
             }
-            if (!first_known_non_zero_change_dst == -1)
+            if (!first_known_non_zero_change_dst)
                 first_known_non_zero_change_dst = change_dst;
             if (change_dst.addr != first_known_non_zero_change_dst->addr)
             {

src/wallet/hot_cold.cpp

@@ -431,16 +431,16 @@ std::size_t num_unsigned_txs_ref(const UnsignedTransactionSetVariant &v)
     return std::visit(num_unsigned_txs_ref_visitor{}, v);
 }
 //-------------------------------------------------------------------------------------------------------------------
-std::size_t num_new_outputs(const UnsignedTransactionSetVariant &v)
+std::size_t num_new_outputs_ref(const UnsignedTransactionSetVariant &v)
 {
-    struct num_new_outputs_visitor
+    struct num_new_outputs_ref_visitor
     {
         std::size_t operator()(const UnsignedPreCarrotTransactionSet &x) const {
             return std::get<2>(x.transfers).size() + std::get<2>(x.new_transfers).size(); }
         std::size_t operator()(const UnsignedCarrotTransactionSetV1 &x) const { return x.new_transfers.size(); }
     };
 
-    return std::visit(num_new_outputs_visitor{}, v);
+    return std::visit(num_new_outputs_ref_visitor{}, v);
 }
 //-------------------------------------------------------------------------------------------------------------------
 exported_pre_carrot_transfer_details export_cold_pre_carrot_output(const wallet2_basic::transfer_details &td)

src/wallet/hot_cold.h

@@ -206,7 +206,7 @@ using UnsignedTransactionSetVariant = std::variant<
         UnsignedCarrotTransactionSetV1
     >;
 std::size_t num_unsigned_txs_ref(const UnsignedTransactionSetVariant&);
-std::size_t num_new_outputs(const UnsignedTransactionSetVariant&);
+std::size_t num_new_outputs_ref(const UnsignedTransactionSetVariant&);
 
 struct SignedFullTransactionSet
 {

src/wallet/wallet2.cpp

@@ -14220,10 +14220,8 @@ size_t wallet2::import_outputs(const std::tuple<uint64_t, uint64_t, std::vector<
   return m_transfers.size();
 }
 //----------------------------------------------------------------------------------------------------
-size_t wallet2::import_outputs_from_str(const std::string &outputs_st)
+size_t wallet2::import_outputs(const std::tuple<uint64_t, uint64_t, std::vector<wallet::cold::exported_transfer_details_variant>> &outputs)
 {
-  PERF_TIMER(import_outputs_from_str);
-
   // devices
   const auto addr_dev = get_cryptonote_address_device();
   const carrot::hybrid_hierarchy_address_device_composed hybrid_addr_dev(&*addr_dev, nullptr);
@@ -14233,27 +14231,35 @@ size_t wallet2::import_outputs_from_str(const std::string &outputs_st)
     nullptr,
     &*addr_dev);
 
+  // expand cold outputs
+  wallet2_basic::transfer_container expanded_outputs;
+  expanded_outputs.reserve(std::get<2>(outputs).size());
+  for (const wallet::cold::exported_transfer_details_variant &cold_output : std::get<2>(outputs))
+    expanded_outputs.push_back(wallet::cold::import_cold_output(cold_output, *addr_dev, key_image_dev));
+
+  // import in `wallet2_basic::transfer_details` form
+  return import_outputs({std::get<0>(outputs), std::get<1>(outputs), std::move(expanded_outputs)});
+}
+//----------------------------------------------------------------------------------------------------
+size_t wallet2::import_outputs_from_str(const std::string &outputs_st)
+{
+  PERF_TIMER(import_outputs_from_str);
+
   size_t imported_outputs = 0;
   try
   {
     // decrypt payload
-    std::tuple<std::uint64_t, std::uint64_t, std::vector<transfer_details>> expanded_outputs;
-    std::vector<wallet::cold::exported_transfer_details_variant> cold_outputs;
+    std::tuple<uint64_t, uint64_t, std::vector<wallet::cold::exported_transfer_details_variant>> cold_outputs;
     wallet::cold::decrypt_exported_outputs(outputs_st,
       m_account.get_keys().m_account_address.m_spend_public_key,
       m_account.get_keys().m_view_secret_key,
       m_kdf_rounds,
-      std::get<0>(expanded_outputs),
-      std::get<1>(expanded_outputs),
-      cold_outputs);
-
-    // expand cold outputs into transfer_details
-    std::get<2>(expanded_outputs).reserve(cold_outputs.size());
-    for (const wallet::cold::exported_transfer_details_variant &etd : cold_outputs)
-      std::get<2>(expanded_outputs).push_back(wallet::cold::import_cold_output(etd, *addr_dev, key_image_dev));
+      std::get<0>(cold_outputs),
+      std::get<1>(cold_outputs),
+      std::get<2>(cold_outputs));
 
     // import
-    imported_outputs = import_outputs(expanded_outputs);
+    imported_outputs = import_outputs(cold_outputs);
   }
   catch (const std::exception &e)
   {

src/wallet/wallet2.h

@@ -1167,6 +1167,7 @@ namespace tools
     std::tuple<uint64_t, uint64_t, std::vector<wallet::cold::exported_transfer_details_variant>> export_outputs(bool all = false, uint32_t start = 0, uint32_t count = 0xffffffff) const;
     std::string export_outputs_to_str(bool all = false, uint32_t start = 0, uint32_t count = 0xffffffff) const;
     size_t import_outputs(const std::tuple<uint64_t, uint64_t, std::vector<wallet::cold::exported_pre_carrot_transfer_details>> &outputs);
+    size_t import_outputs(const std::tuple<uint64_t, uint64_t, std::vector<wallet::cold::exported_transfer_details_variant>> &outputs);
     size_t import_outputs(const std::tuple<uint64_t, uint64_t, std::vector<tools::wallet2::transfer_details>> &outputs);
     size_t import_outputs_from_str(const std::string &outputs_st);
     payment_container export_payments() const;