clippy

Author: dvush

crates/rbuilder/benches/benchmarks/txpool_fetcher.rs

@@ -32,7 +32,7 @@ async fn txpool_receive_util(count: u32) {
 
     let provider = ProviderBuilder::new()
         .wallet(wallet)
-        .on_http(anvil.endpoint().parse().unwrap());
+        .connect_http(anvil.endpoint().parse().unwrap());
 
     let alice = anvil.addresses()[0];
     let eip1559_est = provider.estimate_eip1559_fees().await.unwrap();

crates/rbuilder/src/backtest/restore_landed_orders/find_landed_orders.rs

@@ -460,7 +460,7 @@ mod tests {
         ];
         for (idx, (chunk_idx, chunk_txs_block_idx, expected)) in cases.into_iter().enumerate() {
             let got = find_allowed_range(block_len, chunk_idx, &chunk_txs_block_idx);
-            assert_eq!(expected, got, "Test index: {}", idx);
+            assert_eq!(expected, got, "Test index: {idx}");
         }
     }
 
@@ -474,7 +474,7 @@ mod tests {
         for expected_result in expected {
             let got_result = got
                 .get(&expected_result.order)
-                .unwrap_or_else(|| panic!("Order not found: {:?}", expected_result));
+                .unwrap_or_else(|| panic!("Order not found: {expected_result:?}"));
             assert_eq!(expected_result, *got_result);
         }
     }

crates/rbuilder/src/beacon_api_client/mod.rs

@@ -85,6 +85,6 @@ mod tests {
         // validate that the stream is not empty
         // TODO: add timeout
         let event = stream.next().await.unwrap().unwrap();
-        print!("{:?}", event);
+        print!("{event:?}");
     }
 }

crates/rbuilder/src/building/testing/bundle_tests/mod.rs

@@ -856,10 +856,7 @@ fn test_subbundle_skip() -> eyre::Result<()> {
         if let OrderErr::Bundle(BundleErr::TransactionReverted(hash)) = err {
             assert_eq!(hash, revert_hash);
         } else {
-            panic!(
-                "got {} while expecting OrderErr::Bundle(BundleErr::TransactionReverted)",
-                err
-            );
+            panic!("got {err} while expecting OrderErr::Bundle(BundleErr::TransactionReverted)");
         }
     });
 

crates/rbuilder/src/building/testing/bundle_tests/setup.rs

@@ -274,14 +274,14 @@ impl TestSetup {
     pub fn commit_order_err_check_text(&mut self, expected_error: &str) {
         let res = self.try_commit_order().expect("Failed to commit order");
         match res {
-            Ok(_) => panic!("expected error, result: {:#?}", res),
+            Ok(_) => panic!("expected error, result: {res:#?}"),
             Err(err) => {
                 if !err
                     .to_string()
                     .to_lowercase()
                     .contains(&expected_error.to_lowercase())
                 {
-                    panic!("unexpected error: {}, expected: {}", err, expected_error);
+                    panic!("unexpected error: {err}, expected: {expected_error}");
                 }
             }
         }
@@ -291,12 +291,12 @@ impl TestSetup {
     pub fn commit_order_err_check<F: FnOnce(OrderErr)>(&mut self, err_check: F) {
         let res = self.try_commit_order().expect("Failed to commit order");
         match res {
-            Ok(_) => panic!("expected error,got ok result: {:#?}", res),
+            Ok(_) => panic!("expected error,got ok result: {res:#?}"),
             Err(err) => {
                 if let ExecutionError::OrderError(order_error) = err {
                     err_check(order_error);
                 } else {
-                    panic!("unexpected non OrderErr error: {}", err);
+                    panic!("unexpected non OrderErr error: {err}");
                 }
             }
         }

crates/rbuilder/src/live_builder/base_config.rs

@@ -725,7 +725,7 @@ mod test {
         // Setup and initialize a temp reth db (with static files)
         let tempdir = TempDir::with_prefix_in("rbuilder-", "/tmp").unwrap();
 
-        let data_dir = MaybePlatformPath::<DataDirPath>::from(tempdir.into_path());
+        let data_dir = MaybePlatformPath::<DataDirPath>::from(tempdir.keep());
         let data_dir = data_dir.unwrap_or_chain_default(Chain::mainnet(), DatadirArgs::default());
 
         let db = Arc::new(init_db(data_dir.data_dir(), Default::default()).unwrap());

crates/rbuilder/src/live_builder/block_list_provider.rs

@@ -274,20 +274,20 @@ pub mod test {
 
         fn run(&self, port: u64) {
             // Create the address string once
-            let addr = format!("127.0.0.1:{}", port);
+            let addr = format!("127.0.0.1:{port}");
 
             // Create a TCP listener bound to the specified port
             let listener = TcpListener::bind(&addr).unwrap();
-            println!("Server running at http://{}", addr);
+            println!("Server running at http://{addr}");
 
             // Listen for incoming connections
             for stream in listener.incoming() {
                 match stream {
                     Ok(stream) => {
                         self.handle_connection(stream);
                     }
-                    Err(e) => {
-                        eprintln!("Connection failed: {}", e);
+                    Err(err) => {
+                        eprintln!("Connection failed: {err}");
                     }
                 }
             }
@@ -337,7 +337,7 @@ pub mod test {
         // ugly wait for BlocklistHttpServer
         tokio::time::sleep(Duration::from_millis(200)).await;
         let provider = HttpBlockListProvider::new(
-            Url::parse(&format!("http://127.0.0.1:{}", PORT)).unwrap(),
+            Url::parse(&format!("http://127.0.0.1:{PORT}")).unwrap(),
             Duration::from_secs(AGE_SECS),
             true,
             cancellation.clone(),

crates/rbuilder/src/live_builder/block_output/unfinished_block_processing.rs

@@ -104,8 +104,8 @@ impl FinalizeWorker {
                 payout_tx_val,
                 seen_competition_bid,
             } = finalize_task;
-            trace!(payout_tx_val = ?payout_tx_val.map(|v| format_ether(v)),
-		   seen_competition_bid = ?seen_competition_bid.map(|v| format_ether(v)),
+            trace!(payout_tx_val = ?payout_tx_val.map(format_ether),
+		   seen_competition_bid = ?seen_competition_bid.map(format_ether),
 		   "Started block finalization");
             match block.finalize_block(&mut local_ctx, payout_tx_val, seen_competition_bid) {
                 Ok(result) => {
@@ -308,7 +308,7 @@ impl UnfinishedBlocksSlotWorker {
                     self.pending_blocks
                         .push_back((new_block_id, last_best_block.block.box_clone()));
                     let block_descriptor =
-                        BuiltBlockDescriptorForSlotBidder::new(new_block_id, &last_best_block);
+                        BuiltBlockDescriptorForSlotBidder::new(new_block_id, last_best_block);
                     self.slot_bidder.notify_new_built_block(block_descriptor);
                 }
                 BlockSealSlotWorkerCommands::SealBid(slot_bidder_seal_bid_command) => {

crates/rbuilder/src/mev_boost/mod.rs

@@ -1038,7 +1038,7 @@ mod tests {
             entry: ValidatorRegistration {
                 message: ValidatorRegistrationMessage {
                     timestamp: 0,
-                    gas_limit: 30_000_00,
+                    gas_limit: 30_000_000,
                     fee_recipient: Address::random(),
                     pubkey: H384::random(),
                 },