GetRange for requests

.github/workflows/merge.yml

@@ -77,6 +77,9 @@ jobs:
         shell: bash
         run: if [[ ! $(cargo metadata --no-deps --format-version 1 | jq -r '.packages[].features.default[]? | select(. == "local-discovery")') ]]; then echo "local-discovery is not a default feature in any package."; else echo "local-discovery is a default feature in at least one package." && exit 1; fi
 
+      - name: Clean out the target directory
+        run: cargo clean
+
       # In a cargo workspace, feature unification can occur, allowing a crate to be built successfully even if it
       # doesn't explicitly specify a feature it uses, provided another crate in the workspace enables that feature.
       # To detect such cases, we must build each crate using `--package` flag, building all packages at once does not work.
@@ -737,6 +740,10 @@ jobs:
             echo "SAFE_PEERS has been set to $SAFE_PEERS"
           fi
 
+      - name: Wait from network to stabilise
+        shell: bash
+        run: sleep 30
+
       - name: Verify the routing tables of the nodes
         run: cargo test --release -p sn_node --features="local-discovery" --test verify_routing_table -- --nocapture
         env:
@@ -762,7 +769,7 @@ jobs:
         uses: maidsafe/sn-local-testnet-action@main
         with:
           action: stop
-          log_file_prefix: safe_test_logs_data_location
+          log_file_prefix: safe_test_logs_data_location_routing_table
           platform: ${{ matrix.os }}
 
       - name: Verify restart of nodes using rg

Cargo.toml

@@ -45,6 +45,9 @@ clone_on_ref_ptr = "warn"
 debug = 0
 strip = "debuginfo"
 
+[profile.dev]
+debug = 0
+strip = "debuginfo"
 
 [workspace.metadata.release]
 pre-release-commit-message = "chore(release): release commit, tags, deps and changelog updates"

README.md

@@ -210,22 +210,27 @@ cargo run --bin safe --features local-discovery -- folders download <target dir
 
 Use your local wallet to demonstrate sending tokens and receiving transfers.
 
-First, get your wallet address:
+First, get your wallet address, this address can be safely shared publicly
 
 ```
 cargo run --bin safe -- wallet address
 ```
 
-Now send some tokens to that address:
+You can also get your balance with:
 
 ```
-cargo run --bin safe --features local-discovery -- wallet send 2 [address]
+cargo run --bin safe -- wallet balance
 ```
 
-This will output a transfer as a hex string, which should be sent to the recipient out-of-band.
+Now to send some tokens to an address:
+
+```
+cargo run --bin safe --features local-discovery -- wallet send 2 [address]
+```
 
-For demonstration purposes, copy the transfer string and use it to receive the transfer in your own
-wallet:
+This will output a transfer as a hex string, which should be sent to the recipient.
+This transfer is encrypted to the recipient so only the recipient can read and redeem it. 
+To receive a transfer, simply paste it after the wallet receive command:
 
 ```
 cargo run --bin safe --features local-discovery -- wallet receive [transfer]

node-launchpad/src/components/home.rs

@@ -31,7 +31,6 @@ use std::{
 };
 use tokio::sync::mpsc::UnboundedSender;
 
-const NODE_START_INTERVAL: usize = 10;
 const NODE_STAT_UPDATE_INTERVAL: Duration = Duration::from_secs(5);
 /// If nat detection fails for more than 3 times, we don't want to waste time running during every node start.
 const MAX_ERRORS_WHILE_RUNNING_NAT_DETECTION: usize = 3;
@@ -660,6 +659,7 @@ fn maintain_n_running_nodes(
         if let Err(err) = sn_node_manager::cmd::node::maintain_n_running_nodes(
             false,
             true,
+            120,
             count,
             None,
             true,
@@ -680,7 +680,7 @@ fn maintain_n_running_nodes(
             None,
             None,
             VerbosityLevel::Minimal,
-            NODE_START_INTERVAL as u64,
+            None,
         )
         .await
         {

sn_cli/src/files/download.rs

@@ -20,6 +20,7 @@ use indicatif::ProgressBar;
 use walkdir::WalkDir;
 use xor_name::XorName;
 
+use crate::utils::duration_to_minute_seconds_miliseconds_string;
 use sn_client::{
     protocol::storage::{Chunk, ChunkAddress, RetryStrategy},
     FilesApi, FilesDownload, FilesDownloadEvent,
@@ -97,6 +98,8 @@ pub async fn download_file(
     batch_size: usize,
     retry_strategy: RetryStrategy,
 ) {
+    let start_time = std::time::Instant::now();
+
     let mut files_download = FilesDownload::new(files_api.clone())
         .set_batch_size(batch_size)
         .set_show_holders(show_holders)
@@ -110,6 +113,7 @@ pub async fn download_file(
 
     let progress_handler = tokio::spawn(async move {
         let mut progress_bar: Option<ProgressBar> = None;
+
         // The loop is guaranteed to end, as the channel will be closed when the download completes or errors out.
         while let Some(event) = download_events_rx.recv().await {
             match event {
@@ -145,6 +149,7 @@ pub async fn download_file(
                 }
             }
         }
+
         if let Some(progress_bar) = progress_bar {
             progress_bar.finish_and_clear();
         }
@@ -158,6 +163,8 @@ pub async fn download_file(
         )
         .await;
 
+    let duration = start_time.elapsed();
+
     // await on the progress handler first as we want to clear the progress bar before printing things.
     let _ = progress_handler.await;
     match download_result {
@@ -170,6 +177,8 @@ pub async fn download_file(
                 "Saved {file_name:?} at {}",
                 downloaded_file_path.to_string_lossy()
             );
+            let elapsed_time = duration_to_minute_seconds_miliseconds_string(duration);
+            println!("File downloaded in {elapsed_time}");
         }
         Err(error) => {
             error!("Error downloading {file_name:?}: {error}");

sn_cli/src/files/files_uploader.rs

@@ -7,6 +7,7 @@
 // permissions and limitations relating to use of the SAFE Network Software.
 
 use super::get_progress_bar;
+use crate::utils::duration_to_minute_seconds_string;
 use crate::ChunkManager;
 use bytes::Bytes;
 use color_eyre::{eyre::eyre, Report, Result};
@@ -424,13 +425,7 @@ impl FilesUploadStatusNotifier for StdOutPrinter {
         elapsed_time: Duration,
         chunks_to_upload_len: usize,
     ) {
-        let elapsed_minutes = elapsed_time.as_secs() / 60;
-        let elapsed_seconds = elapsed_time.as_secs() % 60;
-        let elapsed = if elapsed_minutes > 0 {
-            format!("{elapsed_minutes} minutes {elapsed_seconds} seconds")
-        } else {
-            format!("{elapsed_seconds} seconds")
-        };
+        let elapsed = duration_to_minute_seconds_string(elapsed_time);
 
         println!(
             "Among {chunks_to_upload_len} chunks, found {} already existed in network, uploaded \
@@ -462,10 +457,10 @@ impl StdOutPrinter {
         for (_, file_name, addr) in completed_files {
             let hex_addr = addr.to_hex();
             if let Some(file_name) = file_name.to_str() {
-                println!("\"{file_name}\" {hex_addr}");
+                println!("Uploaded \"{file_name}\" to address {hex_addr}");
                 info!("Uploaded {file_name} to {hex_addr}");
             } else {
-                println!("\"{file_name:?}\" {hex_addr}");
+                println!("Uploaded \"{file_name:?}\" to address {hex_addr}");
                 info!("Uploaded {file_name:?} to {hex_addr}");
             }
         }

sn_cli/src/utils.rs

@@ -6,7 +6,32 @@
 // KIND, either express or implied. Please review the Licences for the specific language governing
 // permissions and limitations relating to use of the SAFE Network Software.
 
+use std::time::Duration;
+
 /// Returns whether a hex string is a valid secret key in hex format.
 pub fn is_valid_key_hex(hex: &str) -> bool {
     hex.len() == 64 && hex.chars().all(|c| c.is_ascii_hexdigit())
 }
+
+pub fn duration_to_minute_seconds_string(duration: Duration) -> String {
+    let elapsed_minutes = duration.as_secs() / 60;
+    let elapsed_seconds = duration.as_secs() % 60;
+    if elapsed_minutes > 0 {
+        format!("{elapsed_minutes} minutes {elapsed_seconds} seconds")
+    } else {
+        format!("{elapsed_seconds} seconds")
+    }
+}
+
+pub fn duration_to_minute_seconds_miliseconds_string(duration: Duration) -> String {
+    let elapsed_minutes = duration.as_secs() / 60;
+    let elapsed_seconds = duration.as_secs() % 60;
+    let elapsed_millis = duration.subsec_millis();
+    if elapsed_minutes > 0 {
+        format!("{elapsed_minutes} minutes {elapsed_seconds} seconds {elapsed_millis} milliseconds")
+    } else if elapsed_seconds > 0 {
+        format!("{elapsed_seconds} seconds {elapsed_millis} milliseconds")
+    } else {
+        format!("{elapsed_millis} milliseconds")
+    }
+}

sn_client/src/api.rs

@@ -14,7 +14,7 @@ use super::{
 use bls::{PublicKey, SecretKey, Signature};
 use libp2p::{
     identity::Keypair,
-    kad::{Quorum, Record},
+    kad::{KBucketDistance, Quorum, Record},
     Multiaddr, PeerId,
 };
 #[cfg(feature = "open-metrics")]
@@ -24,7 +24,7 @@ use sn_networking::{
     get_signed_spend_from_record, multiaddr_is_global,
     target_arch::{interval, spawn, timeout, Instant},
     GetRecordCfg, GetRecordError, NetworkBuilder, NetworkError, NetworkEvent, PutRecordCfg,
-    VerificationKind, CLOSE_GROUP_SIZE,
+    VerificationKind,
 };
 use sn_protocol::{
     error::Error as ProtocolError,
@@ -33,7 +33,7 @@ use sn_protocol::{
         try_deserialize_record, try_serialize_record, Chunk, ChunkAddress, RecordHeader,
         RecordKind, RegisterAddress, RetryStrategy, SpendAddress,
     },
-    NetworkAddress, PrettyPrintRecordKey,
+    NetworkAddress, PrettyPrintRecordKey, CLOSE_GROUP_SIZE,
 };
 use sn_registers::{Permissions, SignedRegister};
 use sn_transfers::{
@@ -307,6 +307,11 @@ impl Client {
         self.events_broadcaster.subscribe()
     }
 
+    /// Return the underlying network GetRange
+    pub async fn get_range(&self) -> Result<KBucketDistance> {
+        self.network.get_range().await.map_err(Error::from)
+    }
+
     /// Sign the given data.
     ///
     /// # Arguments
@@ -450,9 +455,9 @@ impl Client {
     ) -> Result<SignedRegister> {
         let key = NetworkAddress::from_register_address(address).to_record_key();
         let get_quorum = if is_verifying {
-            Quorum::Majority
+            Quorum::All
         } else {
-            Quorum::One
+            Quorum::Majority
         };
         let retry_strategy = if is_verifying {
             Some(RetryStrategy::Balanced)
@@ -889,17 +894,25 @@ impl Client {
 
         // When there is retry on Put side, no need to have a retry on Get
         let verification_cfg = GetRecordCfg {
-            get_quorum: Quorum::Majority,
+            get_quorum: Quorum::All,
             retry_strategy: None,
             target_record: record_to_verify,
             expected_holders,
         };
+
+        let verification = if verify_store {
+            Some((VerificationKind::Network, verification_cfg))
+        } else {
+            None
+        };
+
         let put_cfg = PutRecordCfg {
-            put_quorum: Quorum::Majority,
+            put_quorum: Quorum::All,
             retry_strategy: Some(RetryStrategy::Persistent),
             use_put_record_to: None,
-            verification: Some((VerificationKind::Network, verification_cfg)),
+            verification,
         };
+
         Ok(self.network.put_record(record, &put_cfg).await?)
     }
 
@@ -936,7 +949,7 @@ impl Client {
         self.try_fetch_spend_from_network(
             address,
             GetRecordCfg {
-                get_quorum: Quorum::Majority,
+                get_quorum: Quorum::All,
                 retry_strategy: Some(RetryStrategy::Balanced),
                 target_record: None,
                 expected_holders: Default::default(),
@@ -967,7 +980,7 @@ impl Client {
         self.try_fetch_spend_from_network(
             address,
             GetRecordCfg {
-                get_quorum: Quorum::Majority,
+                get_quorum: Quorum::All,
                 retry_strategy: None,
                 target_record: None,
                 expected_holders: Default::default(),
@@ -1023,9 +1036,7 @@ impl Client {
             }
             Err(err) => {
                 warn!("Invalid signed spend got from network for {address:?}: {err:?}.");
-                Err(Error::CouldNotVerifyTransfer(format!(
-                    "Verification failed for spent at {address:?} with error {err:?}"
-                )))
+                Err(Error::from(err))
             }
         }
     }

sn_client/src/error.rs

@@ -13,6 +13,7 @@ use crate::UploadSummary;
 use super::ClientEvent;
 use sn_protocol::NetworkAddress;
 use sn_registers::{Entry, EntryHash};
+use sn_transfers::SpendAddress;
 use std::collections::BTreeSet;
 use thiserror::Error;
 use tokio::time::Duration;
@@ -46,6 +47,9 @@ pub enum Error {
     #[error("Chunks error {0}.")]
     Chunks(#[from] super::chunks::Error),
 
+    #[error("No cashnote found at {0:?}.")]
+    NoCashNoteFound(SpendAddress),
+
     #[error("Decrypting a Folder's item failed: {0}")]
     FolderEntryDecryption(EntryHash),
 
@@ -64,9 +68,6 @@ pub enum Error {
     #[error(transparent)]
     JoinError(#[from] tokio::task::JoinError),
 
-    /// A general error when verifying a transfer validity in the network.
-    #[error("Failed to verify transfer validity in the network {0}")]
-    CouldNotVerifyTransfer(String),
     #[error("Invalid DAG")]
     InvalidDag,
     #[error("Serialization error: {0:?}")]

sn_client/src/test_utils.rs

@@ -29,7 +29,7 @@ use tracing::{info, warn};
 pub const AMOUNT_TO_FUND_WALLETS: u64 = 100 * 1_000_000_000;
 
 // The number of times to try to load the faucet wallet
-const LOAD_FAUCET_WALLET_RETRIES: usize = 6;
+const LOAD_FAUCET_WALLET_RETRIES: usize = 10;
 
 // mutex to restrict access to faucet wallet from concurrent tests
 static FAUCET_WALLET_MUTEX: Mutex<()> = Mutex::const_new(());