carrot+fcmp: send to integrated address [WIP]

Author: jeffro256

src/carrot_impl/tx_proposal_utils.cpp

@@ -258,7 +258,7 @@ void make_carrot_transaction_proposal_v1_transfer(
         // shadow subtractable_selfsend_payment_proposals and adjust for default case (no subtractable provided)
         const auto &subtractable_selfsend_payment_proposals_ref = subtractable_selfsend_payment_proposals;
         std::set<std::size_t> subtractable_selfsend_payment_proposals = subtractable_selfsend_payment_proposals_ref;
-        if (subtractable_selfsend_payment_proposals.empty())
+        if (subtractable_normal_payment_proposals.empty() && subtractable_selfsend_payment_proposals.empty())
             subtractable_selfsend_payment_proposals.insert(selfsend_payment_proposals.size() - 1);
 
         const bool has_subbable_normal = !subtractable_normal_payment_proposals.empty();

src/simplewallet/simplewallet.cpp

@@ -6492,8 +6492,7 @@ bool simple_wallet::transfer_main(const std::vector<std::string> &args_, bool ca
      return false;
   }
 
-  std::vector<uint8_t> extra;
-  bool payment_id_seen = false;
+  // Fail on parsed long payment ID
   if (!local_args.empty())
   {
     std::string payment_id_str = local_args.back();
@@ -6533,6 +6532,7 @@ bool simple_wallet::transfer_main(const std::vector<std::string> &args_, bool ca
 
   vector<cryptonote::address_parse_info> dsts_info;
   vector<cryptonote::tx_destination_entry> dsts;
+  std::pair<crypto::hash8, std::size_t> payment_id{crypto::null_hash8, 0};
   for (size_t i = 0; i < local_args.size(); )
   {
     dsts_info.emplace_back();
@@ -6594,19 +6594,18 @@ bool simple_wallet::transfer_main(const std::vector<std::string> &args_, bool ca
 
     if (info.has_payment_id || !payment_id_uri.empty())
     {
-      if (payment_id_seen)
+      if (payment_id.first != crypto::null_hash8) // other pid seen before
       {
         fail_msg_writer() << tr("a single transaction cannot use more than one payment id");
         return false;
       }
 
-      crypto::hash payment_id;
-      std::string extra_nonce;
+      crypto::hash ignored_long_pid;
       if (info.has_payment_id)
       {
-        set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, info.payment_id);
+        payment_id = {info.payment_id, dsts.size()};
       }
-      else if (tools::wallet2::parse_payment_id(payment_id_uri, payment_id))
+      else if (tools::wallet2::parse_payment_id(payment_id_uri, ignored_long_pid))
       {
         LONG_PAYMENT_ID_SUPPORT_CHECK();
       }
@@ -6615,13 +6614,6 @@ bool simple_wallet::transfer_main(const std::vector<std::string> &args_, bool ca
         fail_msg_writer() << tr("failed to parse payment id, though it was detected");
         return false;
       }
-      bool r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
-      if(!r)
-      {
-        fail_msg_writer() << tr("failed to set up payment id, though it was decoded correctly");
-        return false;
-      }
-      payment_id_seen = true;
     }
 
     dsts.push_back(de);
@@ -6639,7 +6631,7 @@ bool simple_wallet::transfer_main(const std::vector<std::string> &args_, bool ca
   try
   {
     // figure out what tx will be necessary
-    auto ptx_vector = m_wallet->create_transactions_2(dsts, fake_outs_count, priority, extra,
+    auto ptx_vector = m_wallet->create_transactions_2(dsts, payment_id, fake_outs_count, priority, /*extra=*/{},
       m_current_subaddress_account, subaddr_indices, subtract_fee_from_outputs);
 
     if (ptx_vector.empty())
@@ -7075,14 +7067,13 @@ bool simple_wallet::sweep_main(uint32_t account, uint64_t below, const std::vect
     }
   }
 
-  std::vector<uint8_t> extra;
-  bool payment_id_seen = false;
+  // Fail on parsed long payment ID
   if (local_args.size() >= 2)
   {
     std::string payment_id_str = local_args.back();
 
-    crypto::hash payment_id;
-    bool r = tools::wallet2::parse_long_payment_id(payment_id_str, payment_id);
+    crypto::hash ignored_long_pid;
+    bool r = tools::wallet2::parse_long_payment_id(payment_id_str, ignored_long_pid);
     if(r)
     {
       LONG_PAYMENT_ID_SUPPORT_CHECK();
@@ -7094,8 +7085,6 @@ bool simple_wallet::sweep_main(uint32_t account, uint64_t below, const std::vect
       print_usage();
       return true;
     }
-    if (payment_id_seen)
-      local_args.pop_back();
   }
 
   cryptonote::address_parse_info info;
@@ -7106,31 +7095,12 @@ bool simple_wallet::sweep_main(uint32_t account, uint64_t below, const std::vect
     return true;
   }
 
-  if (info.has_payment_id)
-  {
-    if (payment_id_seen)
-    {
-      fail_msg_writer() << tr("a single transaction cannot use more than one payment id: ") << local_args[0];
-      return true;
-    }
-
-    std::string extra_nonce;
-    set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, info.payment_id);
-    bool r = add_extra_nonce_to_tx_extra(extra, extra_nonce);
-    if(!r)
-    {
-      fail_msg_writer() << tr("failed to set up payment id, though it was decoded correctly");
-      return true;
-    }
-    payment_id_seen = true;
-  }
-
   SCOPED_WALLET_UNLOCK();
 
   try
   {
     // figure out what tx will be necessary
-    auto ptx_vector = m_wallet->create_transactions_all(below, info.address, info.is_subaddress, outputs, fake_outs_count, priority, extra, account, subaddr_indices);
+    auto ptx_vector = m_wallet->create_transactions_all(below, info.address, info.is_subaddress, outputs, info.payment_id, fake_outs_count, priority, /*extra=*/{}, account, subaddr_indices);
 
     if (ptx_vector.empty())
     {
@@ -7325,13 +7295,11 @@ bool simple_wallet::sweep_single(const std::vector<std::string> &args_)
     }
   }
 
-  std::vector<uint8_t> extra;
-  bool payment_id_seen = false;
+  // Fail on parsed long payment ID
   if (local_args.size() == 3)
   {
-    crypto::hash payment_id;
-    std::string extra_nonce;
-    if (tools::wallet2::parse_long_payment_id(local_args.back(), payment_id))
+    crypto::hash ignored_long_pid;
+    if (tools::wallet2::parse_long_payment_id(local_args.back(), ignored_long_pid))
     {
       LONG_PAYMENT_ID_SUPPORT_CHECK();
     }
@@ -7340,15 +7308,6 @@ bool simple_wallet::sweep_single(const std::vector<std::string> &args_)
       fail_msg_writer() << tr("failed to parse Payment ID");
       return true;
     }
-
-    if (!add_extra_nonce_to_tx_extra(extra, extra_nonce))
-    {
-      fail_msg_writer() << tr("failed to set up payment id, though it was decoded correctly");
-      return true;
-    }
-
-    local_args.pop_back();
-    payment_id_seen = true;
   }
 
   if (local_args.size() != 2)
@@ -7371,30 +7330,12 @@ bool simple_wallet::sweep_single(const std::vector<std::string> &args_)
     return true;
   }
 
-  if (info.has_payment_id)
-  {
-    if (payment_id_seen)
-    {
-      fail_msg_writer() << tr("a single transaction cannot use more than one payment id: ") << local_args[0];
-      return true;
-    }
-
-    std::string extra_nonce;
-    set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, info.payment_id);
-    if (!add_extra_nonce_to_tx_extra(extra, extra_nonce))
-    {
-      fail_msg_writer() << tr("failed to set up payment id, though it was decoded correctly");
-      return true;
-    }
-    payment_id_seen = true;
-  }
-
   SCOPED_WALLET_UNLOCK();
 
   try
   {
     // figure out what tx will be necessary
-    auto ptx_vector = m_wallet->create_transactions_single(ki, info.address, info.is_subaddress, outputs, fake_outs_count, priority, extra);
+    auto ptx_vector = m_wallet->create_transactions_single(ki, info.address, info.is_subaddress, outputs, info.payment_id, fake_outs_count, priority, /*extra=*/{});
 
     if (ptx_vector.empty())
     {
@@ -7561,14 +7502,18 @@ bool simple_wallet::donate(const std::vector<std::string> &args_)
   std::string amount_str;
   std::string payment_id_str;
   // get payment id and pop
-  crypto::hash payment_id;
-  crypto::hash8 payment_id8;
+  crypto::hash payment_id = crypto::null_hash;
+  crypto::hash8 payment_id8 = crypto::null_hash8;
   if (tools::wallet2::parse_long_payment_id (local_args.back(), payment_id ) ||
       tools::wallet2::parse_short_payment_id(local_args.back(), payment_id8))
   {
     payment_id_str = local_args.back();
     local_args.pop_back();
   }
+  if (payment_id != crypto::null_hash)
+  {
+    LONG_PAYMENT_ID_SUPPORT_CHECK();
+  }
   // get amount and pop
   uint64_t amount;
   bool ok = cryptonote::parse_amount(amount, local_args.back());

src/wallet/api/wallet.cpp

@@ -1631,8 +1631,6 @@ PendingTransaction *WalletImpl::createTransactionMultDest(const std::vector<stri
         if (checkBackgroundSync("cannot create transactions"))
             break;
 
-        std::vector<uint8_t> extra;
-        std::string extra_nonce;
         vector<cryptonote::tx_destination_entry> dsts;
         if (!amount && dst_addr.size() > 1) {
             setStatusError(tr("Sending all requires one destination address"));
@@ -1643,15 +1641,11 @@ PendingTransaction *WalletImpl::createTransactionMultDest(const std::vector<stri
             break;
         }
         if (!payment_id.empty()) {
-            crypto::hash payment_id_long;
-            if (tools::wallet2::parse_long_payment_id(payment_id, payment_id_long)) {
-                cryptonote::set_payment_id_to_tx_extra_nonce(extra_nonce, payment_id_long);
-            } else {
-                setStatusError(tr("payment id has invalid format, expected 64 character hex string: ") + payment_id);
-                break;
-            }
+            setStatusError(tr("Long payment IDs are obsolete and no longer supported"));
+            break;
         }
         bool error = false;
+        std::pair<crypto::hash8, std::size_t> payment_id{crypto::null_hash8, 0};
         for (size_t i = 0; i < dst_addr.size() && !error; i++) {
             if(!cryptonote::get_account_address_from_str(info, m_wallet->nettype(), dst_addr[i])) {
                 // TODO: copy-paste 'if treating as an address fails, try as url' from simplewallet.cpp:1982
@@ -1660,12 +1654,12 @@ PendingTransaction *WalletImpl::createTransactionMultDest(const std::vector<stri
                 break;
             }
             if (info.has_payment_id) {
-                if (!extra_nonce.empty()) {
+                if (payment_id.first != crypto::null_hash8) {
                     setStatusError(tr("a single transaction cannot use more than one payment id"));
                     error = true;
                     break;
                 }
-                set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, info.payment_id);
+                payment_id = {info.payment_id, dsts.size()};
             }
 
             if (amount) {
@@ -1686,22 +1680,21 @@ PendingTransaction *WalletImpl::createTransactionMultDest(const std::vector<stri
         if (error) {
             break;
         }
-        if (!extra_nonce.empty() && !add_extra_nonce_to_tx_extra(extra, extra_nonce)) {
-            setStatusError(tr("failed to set up payment id, though it was decoded correctly"));
-            break;
-        }
         try {
             size_t fake_outs_count = mixin_count > 0 ? mixin_count : m_wallet->default_mixin();
             fake_outs_count = m_wallet->adjust_mixin(mixin_count);
 
             if (amount) {
-                transaction->m_pending_tx = m_wallet->create_transactions_2(dsts, fake_outs_count,
+                transaction->m_pending_tx = m_wallet->create_transactions_2(dsts, payment_id, fake_outs_count,
                                                                             adjusted_priority,
-                                                                            extra, subaddr_account, subaddr_indices);
+                                                                            /*extra=*/{},
+                                                                            subaddr_account, subaddr_indices);
             } else {
-                transaction->m_pending_tx = m_wallet->create_transactions_all(0, info.address, info.is_subaddress, 1, fake_outs_count,
+                transaction->m_pending_tx = m_wallet->create_transactions_all(0, info.address, info.is_subaddress, 1,
+                                                                              payment_id.first, fake_outs_count,
                                                                               adjusted_priority,
-                                                                              extra, subaddr_account, subaddr_indices);
+                                                                              /*extra=*/{}, subaddr_account,
+                                                                              subaddr_indices);
             }
             pendingTxPostProcess(transaction);