fix: store multiple double spend attempts

sn_client/src/audit/dag_crawling.rs

@@ -24,7 +24,7 @@ const SPENDS_PROCESSING_BUFFER_SIZE: usize = 4096;
 
 enum InternalGetNetworkSpend {
     Spend(Box<SignedSpend>),
-    DoubleSpend(Box<SignedSpend>, Box<SignedSpend>),
+    DoubleSpend(Vec<SignedSpend>),
     NotFound,
     Error(Error),
 }
@@ -33,17 +33,18 @@ impl Client {
     pub async fn new_dag_with_genesis_only(&self) -> WalletResult<SpendDag> {
         let genesis_addr = SpendAddress::from_unique_pubkey(&GENESIS_SPEND_UNIQUE_KEY);
         let mut dag = SpendDag::new(genesis_addr);
-        let genesis_spend = match self.get_spend_from_network(genesis_addr).await {
-            Ok(s) => s,
-            Err(Error::Network(NetworkError::DoubleSpendAttempt(spend1, spend2))) => {
-                let addr = spend1.address();
-                println!("Double spend detected at Genesis: {addr:?}");
-                dag.insert(genesis_addr, *spend2);
-                *spend1
+        match self.get_spend_from_network(genesis_addr).await {
+            Ok(spend) => {
+                dag.insert(genesis_addr, spend);
+            }
+            Err(Error::Network(NetworkError::DoubleSpendAttempt(spends))) => {
+                println!("Double spend detected at Genesis: {genesis_addr:?}");
+                for spend in spends.into_iter() {
+                    dag.insert(genesis_addr, spend);
+                }
             }
             Err(e) => return Err(WalletError::FailedToGetSpend(e.to_string())),
         };
-        dag.insert(genesis_addr, genesis_spend);
 
         Ok(dag)
     }
@@ -163,7 +164,7 @@ impl Client {
                             .map_err(|e| WalletError::SpendProcessing(e.to_string()));
                         addrs_to_get.extend(for_further_track);
                     }
-                    InternalGetNetworkSpend::DoubleSpend(_s1, _s2) => {
+                    InternalGetNetworkSpend::DoubleSpend(_spends) => {
                         warn!("Detected double spend regarding {address:?}");
                     }
                     InternalGetNetworkSpend::NotFound => {
@@ -193,14 +194,27 @@ impl Client {
         let mut utxos = BTreeSet::new();
 
         // get first spend
-        let first_spend = match self.crawl_spend(spend_addr).await {
-            InternalGetNetworkSpend::Spend(s) => *s,
-            InternalGetNetworkSpend::DoubleSpend(s1, s2) => {
+        let mut txs_to_follow = match self.crawl_spend(spend_addr).await {
+            InternalGetNetworkSpend::Spend(spend) => {
+                let spend = *spend;
+                let txs = BTreeSet::from_iter([spend.spend.spent_tx.clone()]);
+
                 spend_processing
-                    .send(*s2)
+                    .send(spend)
                     .await
                     .map_err(|e| WalletError::SpendProcessing(e.to_string()))?;
-                *s1
+                txs
+            }
+            InternalGetNetworkSpend::DoubleSpend(spends) => {
+                let mut txs = BTreeSet::new();
+                for spend in spends.into_iter() {
+                    txs.insert(spend.spend.spent_tx.clone());
+                    spend_processing
+                        .send(spend)
+                        .await
+                        .map_err(|e| WalletError::SpendProcessing(e.to_string()))?;
+                }
+                txs
             }
             InternalGetNetworkSpend::NotFound => {
                 // the cashnote was not spent yet, so it's an UTXO
@@ -212,13 +226,8 @@ impl Client {
                 return Err(WalletError::FailedToGetSpend(e.to_string()));
             }
         };
-        spend_processing
-            .send(first_spend.clone())
-            .await
-            .map_err(|e| WalletError::SpendProcessing(e.to_string()))?;
 
         // use iteration instead of recursion to avoid stack overflow
-        let mut txs_to_follow = BTreeSet::from_iter([first_spend.spend.spent_tx]);
         let mut known_tx = BTreeSet::new();
         let mut gen: u32 = 0;
         let start = std::time::Instant::now();
@@ -260,18 +269,15 @@ impl Client {
                             .await
                             .map_err(|e| WalletError::SpendProcessing(e.to_string()))?;
                     }
-                    InternalGetNetworkSpend::DoubleSpend(s1, s2) => {
-                        info!("Fetched double spend at {addr:?} from network, following both...");
-                        next_gen_tx.insert(s1.spend.spent_tx.clone());
-                        next_gen_tx.insert(s2.spend.spent_tx.clone());
-                        spend_processing
-                            .send(*s1.clone())
-                            .await
-                            .map_err(|e| WalletError::SpendProcessing(e.to_string()))?;
-                        spend_processing
-                            .send(*s2.clone())
-                            .await
-                            .map_err(|e| WalletError::SpendProcessing(e.to_string()))?;
+                    InternalGetNetworkSpend::DoubleSpend(spends) => {
+                        info!("Fetched double spend(s) of len {} at {addr:?} from network, following all of them.", spends.len());
+                        for s in spends.into_iter() {
+                            next_gen_tx.insert(s.spend.spent_tx.clone());
+                            spend_processing
+                                .send(s.clone())
+                                .await
+                                .map_err(|e| WalletError::SpendProcessing(e.to_string()))?;
+                        }
                     }
                     InternalGetNetworkSpend::NotFound => {
                         info!("Reached UTXO at {addr:?}");
@@ -360,8 +366,8 @@ impl Client {
                         InternalGetNetworkSpend::Spend(s) => {
                             spends.insert(*s);
                         }
-                        InternalGetNetworkSpend::DoubleSpend(s1, s2) => {
-                            spends.extend([*s1, *s2]);
+                        InternalGetNetworkSpend::DoubleSpend(s) => {
+                            spends.extend(s.into_iter());
                         }
                         InternalGetNetworkSpend::NotFound => {
                             return Err(WalletError::FailedToGetSpend(format!(
@@ -498,9 +504,9 @@ impl Client {
                 debug!("DAG crawling: spend at {spend_addr:?} not found on the network");
                 InternalGetNetworkSpend::NotFound
             }
-            Err(Error::Network(NetworkError::DoubleSpendAttempt(s1, s2))) => {
-                debug!("DAG crawling: got a double spend at {spend_addr:?} on the network");
-                InternalGetNetworkSpend::DoubleSpend(s1, s2)
+            Err(Error::Network(NetworkError::DoubleSpendAttempt(spends))) => {
+                debug!("DAG crawling: got a double spend(s) of len {} at {spend_addr:?} on the network", spends.len());
+                InternalGetNetworkSpend::DoubleSpend(spends)
             }
             Err(e) => {
                 debug!(

sn_networking/src/driver.rs

@@ -102,7 +102,7 @@ pub(crate) type BadNodes = BTreeMap<PeerId, (Vec<(NodeIssue, Instant)>, bool)>;
 /// What is the largest packet to send over the network.
 /// Records larger than this will be rejected.
 // TODO: revisit once cashnote_redemption is in
-const MAX_PACKET_SIZE: usize = 1024 * 1024 * 5; // the chunk size is 1mb, so should be higher than that to prevent failures, 5mb here to allow for CashNote storage
+pub const MAX_PACKET_SIZE: usize = 1024 * 1024 * 5; // the chunk size is 1mb, so should be higher than that to prevent failures, 5mb here to allow for CashNote storage
 
 // Timeout for requests sent/received through the request_response behaviour.
 const REQUEST_TIMEOUT_DEFAULT_S: Duration = Duration::from_secs(30);

sn_networking/src/error.rs

@@ -138,8 +138,8 @@ pub enum NetworkError {
     // ---------- Spend Errors
     #[error("Spend not found: {0:?}")]
     NoSpendFoundInsideRecord(SpendAddress),
-    #[error("A double spend was detected. Two diverging signed spends: {0:?}, {1:?}")]
-    DoubleSpendAttempt(Box<SignedSpend>, Box<SignedSpend>),
+    #[error("Double spend(s) was detected. The signed spends are: {0:?}")]
+    DoubleSpendAttempt(Vec<SignedSpend>),
 
     // ---------- Store Error
     #[error("No Store Cost Responses")]

sn_networking/src/event/kad.rs

@@ -412,10 +412,8 @@ impl SwarmDriver {
                     }
                     if !accumulated_spends.is_empty() {
                         info!("For record {pretty_key:?} task {query_id:?}, found split record for a spend, accumulated and sending them as a single record");
-                        let accumulated_spends = accumulated_spends
-                            .into_iter()
-                            .take(2)
-                            .collect::<Vec<SignedSpend>>();
+                        let accumulated_spends =
+                            accumulated_spends.into_iter().collect::<Vec<SignedSpend>>();
 
                         let bytes = try_serialize_record(&accumulated_spends, RecordKind::Spend)?;
 

sn_networking/src/lib.rs

@@ -36,7 +36,9 @@ pub use target_arch::{interval, sleep, spawn, Instant, Interval};
 
 pub use self::{
     cmd::{NodeIssue, SwarmLocalState},
-    driver::{GetRecordCfg, NetworkBuilder, PutRecordCfg, SwarmDriver, VerificationKind},
+    driver::{
+        GetRecordCfg, NetworkBuilder, PutRecordCfg, SwarmDriver, VerificationKind, MAX_PACKET_SIZE,
+    },
     error::{GetRecordError, NetworkError},
     event::{MsgResponder, NetworkEvent},
     record_store::{calculate_cost_for_records, NodeRecordStore},

sn_networking/src/record_store.rs

@@ -7,6 +7,7 @@
 // permissions and limitations relating to use of the SAFE Network Software.
 #![allow(clippy::mutable_key_type)] // for the Bytes in NetworkAddress
 
+use crate::driver::MAX_PACKET_SIZE;
 use crate::target_arch::{spawn, Instant};
 use crate::CLOSE_GROUP_SIZE;
 use crate::{cmd::SwarmCmd, event::NetworkEvent, log_markers::Marker, send_swarm_cmd};
@@ -109,7 +110,7 @@ impl Default for NodeRecordStoreConfig {
             storage_dir: historic_quote_dir.clone(),
             historic_quote_dir,
             max_records: MAX_RECORDS_COUNT,
-            max_value_bytes: 65 * 1024,
+            max_value_bytes: MAX_PACKET_SIZE,
         }
     }
 }

sn_networking/src/transfers.rs

@@ -236,21 +236,22 @@ pub fn get_signed_spend_from_record(
     address: &SpendAddress,
     record: &Record,
 ) -> Result<SignedSpend> {
-    match get_raw_signed_spends_from_record(record)?.as_slice() {
-        [one, two, ..] => {
-            warn!("Found double spend for {address:?}");
-            Err(NetworkError::DoubleSpendAttempt(
-                Box::new(one.to_owned()),
-                Box::new(two.to_owned()),
-            ))
+    let spends = get_raw_signed_spends_from_record(record)?;
+    match spends.as_slice() {
+        [] => {
+            error!("Found no spend for {address:?}");
+            Err(NetworkError::NoSpendFoundInsideRecord(*address))
         }
         [one] => {
             trace!("Spend get for address: {address:?} successful");
             Ok(one.clone())
         }
-        _ => {
-            trace!("Found no spend for {address:?}");
-            Err(NetworkError::NoSpendFoundInsideRecord(*address))
+        _double_spends => {
+            warn!(
+                "Found double spend(s) of len {} for {address:?}",
+                spends.len()
+            );
+            Err(NetworkError::DoubleSpendAttempt(spends))
         }
     }
 }