feat: remove middle spend from offline transfers

sn_client/src/audit/tests/setup.rs

@@ -114,7 +114,6 @@ impl MockNetwork {
             recipient,
             from_wallet.sk.main_pubkey(),
             SpendReason::default(),
-            None,
         )
         .map_err(|e| eyre!("failed to create transfer: {}", e))?;
         let spends = transfer.all_spend_requests;

sn_node/tests/double_spend.rs

@@ -54,15 +54,9 @@ async fn cash_note_transfer_double_spend_fail() -> Result<()> {
     let to2_unique_key = (amount, to2, DerivationIndex::random(&mut rng));
     let to3_unique_key = (amount, to3, DerivationIndex::random(&mut rng));
 
-    let transfer_to_2 = OfflineTransfer::new(
-        some_cash_notes,
-        vec![to2_unique_key],
-        to1,
-        reason.clone(),
-        None,
-    )?;
-    let transfer_to_3 =
-        OfflineTransfer::new(same_cash_notes, vec![to3_unique_key], to1, reason, None)?;
+    let transfer_to_2 =
+        OfflineTransfer::new(some_cash_notes, vec![to2_unique_key], to1, reason.clone())?;
+    let transfer_to_3 = OfflineTransfer::new(same_cash_notes, vec![to3_unique_key], to1, reason)?;
 
     // send both transfers to the network
     // upload won't error out, only error out during verification.
@@ -127,8 +121,7 @@ async fn genesis_double_spend_fail() -> Result<()> {
     );
     let change_addr = second_wallet_addr;
     let reason = SpendReason::default();
-    let transfer =
-        OfflineTransfer::new(genesis_cashnote, vec![recipient], change_addr, reason, None)?;
+    let transfer = OfflineTransfer::new(genesis_cashnote, vec![recipient], change_addr, reason)?;
 
     // send the transfer to the network which will mark genesis as a double spent
     // making its direct descendants unspendable
@@ -160,7 +153,6 @@ async fn genesis_double_spend_fail() -> Result<()> {
         vec![recipient],
         change_addr,
         reason,
-        None,
     )?;
 
     // send the transfer to the network which should reject it
@@ -199,7 +191,6 @@ async fn poisoning_old_spend_should_not_affect_descendant() -> Result<()> {
         vec![to_2_unique_key],
         to1,
         reason.clone(),
-        None,
     )?;
 
     info!("Sending 1->2 to the network...");
@@ -224,13 +215,8 @@ async fn poisoning_old_spend_should_not_affect_descendant() -> Result<()> {
         wallet_22.address(),
         DerivationIndex::random(&mut rng),
     );
-    let transfer_to_22 = OfflineTransfer::new(
-        cash_notes_2,
-        vec![to_22_unique_key],
-        to2,
-        reason.clone(),
-        None,
-    )?;
+    let transfer_to_22 =
+        OfflineTransfer::new(cash_notes_2, vec![to_22_unique_key], to2, reason.clone())?;
 
     client
         .send_spends(transfer_to_22.all_spend_requests.iter(), false)
@@ -251,13 +237,8 @@ async fn poisoning_old_spend_should_not_affect_descendant() -> Result<()> {
         wallet_3.address(),
         DerivationIndex::random(&mut rng),
     );
-    let transfer_to_3 = OfflineTransfer::new(
-        cash_notes_1,
-        vec![to_3_unique_key],
-        to1,
-        reason.clone(),
-        None,
-    )?; // reuse the old cash notes
+    let transfer_to_3 =
+        OfflineTransfer::new(cash_notes_1, vec![to_3_unique_key], to1, reason.clone())?; // reuse the old cash notes
     client
         .send_spends(transfer_to_3.all_spend_requests.iter(), false)
         .await?;
@@ -290,7 +271,6 @@ async fn poisoning_old_spend_should_not_affect_descendant() -> Result<()> {
         vec![to_222_unique_key],
         wallet_22.address(),
         reason,
-        None,
     )?;
     client
         .send_spends(transfer_to_222.all_spend_requests.iter(), false)
@@ -358,7 +338,6 @@ async fn parent_and_child_double_spends_should_lead_to_cashnote_being_invalid()
         vec![to_b_unique_key],
         wallet_a.address(),
         reason.clone(),
-        None,
     )?;
 
     info!("Sending A->B to the network...");
@@ -388,7 +367,6 @@ async fn parent_and_child_double_spends_should_lead_to_cashnote_being_invalid()
         vec![to_c_unique_key],
         wallet_b.address(),
         reason.clone(),
-        None,
     )?;
 
     info!("spend B to C: {:?}", transfer_to_c.all_spend_requests);
@@ -416,7 +394,6 @@ async fn parent_and_child_double_spends_should_lead_to_cashnote_being_invalid()
         vec![to_x_unique_key],
         wallet_a.address(),
         reason.clone(),
-        None,
     )?; // reuse the old cash notes
     client
         .send_spends(transfer_to_x.all_spend_requests.iter(), false)
@@ -447,7 +424,6 @@ async fn parent_and_child_double_spends_should_lead_to_cashnote_being_invalid()
         vec![to_y_unique_key],
         wallet_b.address(),
         reason.clone(),
-        None,
     )?; // reuse the old cash notes
 
     info!("spend B to Y: {:?}", transfer_to_y.all_spend_requests);

sn_node/tests/spend_simulation.rs

@@ -357,18 +357,11 @@ async fn inner_handle_action(
                 "{our_id} Available CashNotes for local send: {:?}",
                 available_cash_notes
             );
-            let mut rng = &mut rand::rngs::OsRng;
-            let derivation_index = DerivationIndex::random(&mut rng);
             let transfer = OfflineTransfer::new(
                 available_cash_notes,
                 recipients,
                 wallet.address(),
                 SpendReason::default(),
-                Some((
-                    wallet.key().main_pubkey(),
-                    derivation_index,
-                    wallet.key().derive_key(&derivation_index),
-                )),
             )?;
             let recipient_cash_notes = transfer.cash_notes_for_recipient.clone();
             let change = transfer.change_cash_note.clone();
@@ -414,7 +407,6 @@ async fn inner_handle_action(
                 vec![to],
                 wallet.address(),
                 SpendReason::default(),
-                None,
             )?;
             info!("{our_id} double spending transfer: {transfer:?}");
 
@@ -703,7 +695,6 @@ async fn init_state(count: usize) -> Result<(Client, State)> {
         recipients,
         first_wallet.address(),
         reason.clone(),
-        None,
     )?;
 
     info!("Sending transfer for all wallets and verifying them");

sn_transfers/benches/reissue.rs

@@ -41,7 +41,6 @@ fn bench_reissue_1_to_100(c: &mut Criterion) {
         recipients,
         starting_main_key.main_pubkey(),
         SpendReason::default(),
-        None,
     )
     .expect("transfer to succeed");
 
@@ -98,7 +97,6 @@ fn bench_reissue_100_to_1(c: &mut Criterion) {
         recipients,
         starting_main_key.main_pubkey(),
         SpendReason::default(),
-        None,
     )
     .expect("transfer to succeed");
 
@@ -136,18 +134,12 @@ fn bench_reissue_100_to_1(c: &mut Criterion) {
         DerivationIndex::random(&mut rng),
     )];
 
-    let derivation_index = DerivationIndex::random(&mut rng);
     // create transfer to merge all of the cashnotes into one
     let many_to_one_transfer = OfflineTransfer::new(
         many_cashnotes,
         one_single_recipient,
         starting_main_key.main_pubkey(),
         SpendReason::default(),
-        Some((
-            starting_main_key.main_pubkey(),
-            derivation_index,
-            starting_main_key.derive_key(&derivation_index),
-        )),
     )
     .expect("transfer to succeed");
 

sn_transfers/src/transfers/offline_transfer.rs

@@ -108,16 +108,11 @@ impl OfflineTransfer {
     /// The peers will validate each signed spend they receive, before accepting it.
     /// Once enough peers have accepted all the spends of the transaction, and serve
     /// them upon request, the transaction will be completed.
-    ///
-    /// When there are multiple inputs from different unique_pubkeys,
-    /// they shall all be paid into a `middle_addr` first, then from that `middle_addr` pay out
-    /// to recipients as normal.
     pub fn new(
         available_cash_notes: CashNotesAndSecretKey,
         recipients: Vec<(NanoTokens, MainPubkey, DerivationIndex)>,
         change_to: MainPubkey,
         input_reason_hash: SpendReason,
-        middle_addr: Option<(MainPubkey, DerivationIndex, DerivedSecretKey)>,
     ) -> Result<Self> {
         let total_output_amount = recipients
             .iter()
@@ -140,7 +135,7 @@ impl OfflineTransfer {
             change: (change_amount, change_to),
         };
 
-        create_offline_transfer_with(selected_inputs, input_reason_hash, middle_addr)
+        create_offline_transfer_with(selected_inputs, input_reason_hash)
     }
 
     pub fn verify(&self, main_key: &MainSecretKey) -> Result<()> {
@@ -315,103 +310,9 @@ fn create_transaction_builder_with(
 /// to the network. When those same signed spends can be retrieved from
 /// enough peers in the network, the transaction will be completed.
 fn create_offline_transfer_with(
-    mut selected_inputs: TransferInputs,
+    selected_inputs: TransferInputs,
     input_reason: SpendReason,
-    middle_addr: Option<(MainPubkey, DerivationIndex, DerivedSecretKey)>,
 ) -> Result<OfflineTransfer> {
-    let mut all_spend_requests = vec![];
-
-    let input_keys: BTreeSet<_> = selected_inputs
-        .cash_notes_to_spend
-        .iter()
-        .map(|(cn, _)| cn.unique_pubkey)
-        .collect();
-    if input_keys.len() > 1 {
-        info!(
-            "Multiple input_keys vs multiple outputs detected {:?}",
-            input_keys
-        );
-        if let Some((main_pubkey, derivation_index, middle_derived_sk)) = middle_addr {
-            let mut middle_cash_notes = vec![];
-            for input_key in input_keys {
-                let mut amount: u64 = 0;
-                let cash_notes_to_spend = selected_inputs
-                    .cash_notes_to_spend
-                    .iter()
-                    .filter_map(|(cn, derived_sk)| {
-                        if cn.unique_pubkey == input_key {
-                            if let Ok(value) = cn.value() {
-                                amount += value.as_nano();
-                                Some((cn.clone(), derived_sk.clone()))
-                            } else {
-                                None
-                            }
-                        } else {
-                            None
-                        }
-                    })
-                    .collect();
-
-                let recipients = vec![(NanoTokens::from(amount), main_pubkey, derivation_index)];
-
-                let middle_inputs = TransferInputs {
-                    cash_notes_to_spend,
-                    recipients,
-                    change: (NanoTokens::zero(), selected_inputs.change.1),
-                };
-
-                let (tx_builder, _change_id) = create_transaction_builder_with(middle_inputs)?;
-                let cash_note_builder = tx_builder.build(input_reason.clone());
-                let signed_spends: BTreeMap<_, _> = cash_note_builder
-                    .signed_spends()
-                    .into_iter()
-                    .map(|spend| (spend.unique_pubkey(), spend))
-                    .collect();
-
-                for (_, signed_spend) in signed_spends.into_iter() {
-                    all_spend_requests.push(signed_spend.to_owned());
-                }
-                middle_cash_notes.extend(
-                    cash_note_builder
-                        .build()?
-                        .into_iter()
-                        .map(|(cash_note, _)| cash_note)
-                        .collect::<Vec<_>>(),
-                );
-            }
-
-            info!("We now have middle cash notes: {middle_cash_notes:?}");
-
-            let mut parent_spends = BTreeSet::new();
-            for cn in middle_cash_notes.iter() {
-                for parent_spend in cn.parent_spends.iter() {
-                    let _ = parent_spends.insert(parent_spend.clone());
-                }
-            }
-
-            let cash_notes_to_spend = if let Some(cn) = middle_cash_notes.first() {
-                let merged_cn = CashNote {
-                    unique_pubkey: cn.unique_pubkey,
-                    parent_spends,
-                    main_pubkey: cn.main_pubkey,
-                    derivation_index: cn.derivation_index,
-                };
-                info!("We now have a merged cash note: {merged_cn:?}");
-                vec![(merged_cn, Some(middle_derived_sk.clone()))]
-            } else {
-                return Err(TransferError::MultipleInputsWithoutMiddlePayment);
-            };
-
-            selected_inputs = TransferInputs {
-                cash_notes_to_spend,
-                recipients: selected_inputs.recipients,
-                change: selected_inputs.change,
-            };
-        } else {
-            return Err(TransferError::MultipleInputsWithoutMiddleAddr);
-        }
-    }
-
     let (tx_builder, change_id) = create_transaction_builder_with(selected_inputs)?;
 
     // Finalize the tx builder to get the cash_note builder.
@@ -423,6 +324,7 @@ fn create_offline_transfer_with(
         .map(|spend| (spend.unique_pubkey(), spend))
         .collect();
 
+    let mut all_spend_requests = vec![];
     for (_, signed_spend) in signed_spends.into_iter() {
         all_spend_requests.push(signed_spend.to_owned());
     }

sn_transfers/src/wallet/hot_wallet.rs

@@ -424,18 +424,8 @@ impl HotWallet {
 
         let reason = reason.unwrap_or_default();
 
-        let derivation_index = DerivationIndex::random(&mut rng);
-        let transfer = OfflineTransfer::new(
-            available_cash_notes,
-            to_unique_keys,
-            self.address(),
-            reason,
-            Some((
-                self.key.main_pubkey(),
-                derivation_index,
-                self.key.derive_key(&derivation_index),
-            )),
-        )?;
+        let transfer =
+            OfflineTransfer::new(available_cash_notes, to_unique_keys, self.address(), reason)?;
 
         let created_cash_notes = transfer.cash_notes_for_recipient.clone();
 
@@ -498,18 +488,12 @@ impl HotWallet {
             .into_iter()
             .map(|(amount, address)| (amount, address, DerivationIndex::random(&mut rng)))
             .collect();
-        let derivation_index = DerivationIndex::random(&mut rng);
 
         let transfer = OfflineTransfer::new(
             available_cash_notes,
             to_unique_keys,
             self.address(),
             spend_reason,
-            Some((
-                self.key.main_pubkey(),
-                derivation_index,
-                self.key.derive_key(&derivation_index),
-            )),
         )?;
 
         let signed_spends = transfer.all_spend_requests.clone();
@@ -588,17 +572,11 @@ impl HotWallet {
 
         let spend_reason = Default::default();
         let start = Instant::now();
-        let derivation_index = DerivationIndex::random(&mut rng);
         let offline_transfer = OfflineTransfer::new(
             available_cash_notes,
             recipients,
             self.address(),
             spend_reason,
-            Some((
-                self.key.main_pubkey(),
-                derivation_index,
-                self.key.derive_key(&derivation_index),
-            )),
         )?;
         trace!(
             "local_send_storage_payment created offline_transfer with {} cashnotes in {:?}",