Clean up clippy warnings.

src/main.rs

@@ -157,7 +157,7 @@ async fn run(error_sender: Sender<anyhow::Error>) -> Result<()> {
 		db: db.clone(),
 		cfg: cfg.clone(),
 		counter: counter.clone(),
-		version: format!("v{}", clap::crate_version!().to_string()),
+		version: format!("v{}", clap::crate_version!()),
 		network_version: EXPECTED_NETWORK_VERSION.to_string(),
 	};
 

src/network/client.rs

@@ -189,7 +189,7 @@ impl Client {
 
 	// Since callers ignores DHT errors, debug logs are used to observe DHT behavior.
 	// Return type assumes that cell is not found in case when error is present.
-	async fn fetch_cell_from_dht(&self, block_number: u32, position: &Position) -> Option<Cell> {
+	async fn fetch_cell_from_dht(&self, block_number: u32, position: Position) -> Option<Cell> {
 		let reference = position.reference(block_number);
 		let record_key = Key::from(reference.as_bytes().to_vec());
 
@@ -207,7 +207,6 @@ impl Client {
 				    return None;
 				};
 
-				let position = position.clone();
 				Some(Cell { position, content })
 			},
 			Err(error) => {
@@ -252,7 +251,7 @@ impl Client {
 		let mut cells = Vec::<Option<Cell>>::with_capacity(positions.len());
 
 		for positions in positions.chunks(self.dht_parallelization_limit) {
-			let fetch = |position| self.fetch_cell_from_dht(block_number, position);
+			let fetch = |&position| self.fetch_cell_from_dht(block_number, position);
 			let results = join_all(positions.iter().map(fetch)).await;
 			cells.extend(results.into_iter().collect::<Vec<_>>());
 		}
@@ -261,7 +260,7 @@ impl Client {
 			.iter()
 			.zip(positions)
 			.filter(|(cell, _)| cell.is_none())
-			.map(|(_, position)| position.clone())
+			.map(|(_, &position)| position)
 			.collect::<Vec<_>>();
 
 		let fetched = cells.into_iter().flatten().collect();

src/network/mod.rs

@@ -98,7 +98,7 @@ pub fn init(
 		let upgraded_relay_transport = relay_client_transport
 			.upgrade(Version::V1Lazy)
 			.authenticate(NoiseConfig::xx(noise_keys).into_authenticated())
-			.multiplex(libp2p::yamux::YamuxConfig::default());
+			.multiplex(libp2p::yamux::Config::default());
 		// relay transport only handles listening and dialing on relayed [`Multiaddr`]
 		// and depends on other transport to do the actual transmission of data, we have to combine the two
 		let transport =

src/rpc.rs

@@ -104,11 +104,11 @@ pub async fn get_header_by_block_number(
 /// Generates random cell positions for sampling
 pub fn generate_random_cells(dimensions: Dimensions, cell_count: u32) -> Vec<Position> {
 	let max_cells = dimensions.extended_size();
-	let count = if max_cells < cell_count.into() {
+	let count = if max_cells < cell_count {
 		debug!("Max cells count {max_cells} is lesser than cell_count {cell_count}");
 		max_cells
 	} else {
-		cell_count.into()
+		cell_count
 	};
 	let mut rng = thread_rng();
 	let mut indices = HashSet::new();
@@ -157,10 +157,7 @@ pub async fn get_kate_proof(
 	Ok(positions
 		.iter()
 		.zip(i)
-		.map(|(position, &content)| Cell {
-			position: position.clone(),
-			content,
-		})
+		.map(|(&position, &content)| Cell { position, content })
 		.collect::<Vec<_>>())
 }
 
@@ -209,7 +206,7 @@ impl ExpectedVersion<'_> {
 	/// Since runtime `spec_version` can be changed with runtime upgrade, `spec_version` is removed.
 	/// NOTE: Runtime compatiblity check is currently not implemented.
 	pub fn matches(&self, node_version: String, spec_name: String) -> bool {
-		node_version.starts_with(&self.version) && self.spec_name == spec_name
+		node_version.starts_with(self.version) && self.spec_name == spec_name
 	}
 }
 

src/types.rs

@@ -333,7 +333,7 @@ impl From<&RuntimeConfig> for LightClientConfig {
 			dht_parallelization_limit: val.dht_parallelization_limit,
 			query_proof_rpc_parallel_tasks: val.query_proof_rpc_parallel_tasks,
 			block_processing_delay: Delay(block_processing_delay),
-			block_matrix_partition: val.block_matrix_partition.clone(),
+			block_matrix_partition: val.block_matrix_partition,
 			disable_proof_verification: val.disable_proof_verification,
 			max_cells_per_rpc: val.max_cells_per_rpc.unwrap_or(30),
 			ttl: val.kad_record_ttl,