Clippy expects

Author: SozinM

Diff for: crates/eth-sparse-mpt/src/reth_sparse_trie/hash.rs

@@ -54,6 +54,7 @@ pub enum RootHashError {
     HashingAccountsTrie { err: ErrSparseNodeNotFound },
 }
 
+#[expect(clippy::result_large_err)]
 impl EthSparseTries {
     pub fn calculate_root_hash(
         &mut self,
@@ -172,6 +173,7 @@ impl EthSparseTries {
     }
 }
 
+#[expect(clippy::result_large_err)]
 fn hash_storage_trie(
     storage_trie: &mut DiffTrie,
     account: &Bytes,

Diff for: crates/eth-sparse-mpt/src/reth_sparse_trie/mod.rs

@@ -77,6 +77,7 @@ impl ChangedAccountData {
     }
 }
 
+#[expect(clippy::result_large_err)]
 /// Prefetches data
 pub fn prefetch_tries_for_accounts<'a, Provider>(
     consistent_db_view: ConsistentDbView<Provider>,

Diff for: crates/rbuilder/src/building/block_orders/prioritized_order_store.rs

@@ -16,11 +16,11 @@ use super::{OrderPriority, SimulatedOrderSink};
 /// Order must implement BlockOrdersOrder which has priority(). This priority is used to sort the simulated orders.
 /// Usage:
 /// - Add new order (a little bit complex):
-///     ALWAYS BE SURE THAT YOU CALLED update_onchain_nonces and updated the current state of all the needed nonces by the order
-///     call insert_order
+///   ALWAYS BE SURE THAT YOU CALLED update_onchain_nonces and updated the current state of all the needed nonces by the order
+///   call insert_order
 /// - Get best order to execute
-///     call pop_order to get the best order
-///     if the order is executed call update_onchain_nonces to update all the changed nonces.
+///   call pop_order to get the best order
+///   if the order is executed call update_onchain_nonces to update all the changed nonces.
 /// - Remove orders: remove_orders. This is useful if we think this orders are no really good (failed to execute to often)
 #[derive(Debug, Clone)]
 pub struct PrioritizedOrderStore<OrderPriorityType> {

Diff for: crates/rbuilder/src/building/builders/block_building_helper.rs

@@ -55,11 +55,13 @@ pub trait BlockBuildingHelper: Send + Sync {
     /// This is the maximum profit that can reach the final fee recipient (max bid!).
     /// Maximum payout_tx_value value to pass to finalize_block.
     /// The main reason to get an error is if profit is so low that we can't pay the payout tx (that would mean negative block value!).
+    #[expect(clippy::result_large_err)]
     fn true_block_value(&self) -> Result<U256, BlockBuildingHelperError>;
 
     /// Eats the BlockBuildingHelper since once it's finished you should not use it anymore.
     /// payout_tx_value: If Some, added at the end of the block from coinbase to the final fee recipient.
     ///     This only works if can_add_payout_tx.
+    #[expect(clippy::result_large_err)]
     fn finalize_block(
         self: Box<Self>,
         local_ctx: &mut ThreadBlockBuildingContext,
@@ -94,6 +96,7 @@ impl Clone for BiddableUnfinishedBlock {
 }
 
 impl BiddableUnfinishedBlock {
+    #[expect(clippy::result_large_err)]
     pub fn new(block: Box<dyn BlockBuildingHelper>) -> Result<Self, BlockBuildingHelperError> {
         let true_block_value = block.true_block_value()?;
         Ok(Self {
@@ -185,7 +188,7 @@ impl BlockBuildingHelperFromProvider {
     /// - Query fee_recipient_balance_start.
     /// - pre_block_call.
     /// - Estimate payout tx cost.
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::result_large_err)]
     pub fn new(
         state_provider: Arc<dyn StateProvider>,
         building_ctx: BlockBuildingContext,
@@ -272,6 +275,7 @@ impl BlockBuildingHelperFromProvider {
     }
 
     /// Inserts payout tx if necessary and updates built_block_trace.
+    #[expect(clippy::result_large_err)]
     fn finalize_block_execution(
         &mut self,
         local_ctx: &mut ThreadBlockBuildingContext,

Diff for: crates/rbuilder/src/building/builders/mock_block_building_helper.rs

@@ -1,17 +1,14 @@
-use crate::building::ThreadBlockBuildingContext;
-use crate::live_builder::simulation::SimulatedOrderCommand;
-use crate::primitives::SimValue;
-use crate::provider::RootHasher;
-use crate::roothash::RootHashError;
 use crate::{
     building::{
         BlockBuildingContext, BuiltBlockTrace, CriticalCommitOrderError, ExecutionError,
-        ExecutionResult,
+        ExecutionResult, ThreadBlockBuildingContext,
     },
-    primitives::SimulatedOrder,
+    live_builder::simulation::SimulatedOrderCommand,
+    primitives::{SimValue, SimulatedOrder},
+    provider::RootHasher,
+    roothash::RootHashError,
 };
-use alloy_primitives::B256;
-use alloy_primitives::U256;
+use alloy_primitives::{B256, U256};
 use reth::providers::ExecutionOutcome;
 use reth_primitives::SealedBlock;
 use time::OffsetDateTime;

Diff for: crates/rbuilder/src/building/mod.rs

@@ -635,6 +635,7 @@ impl<Tracer: SimulationTracer> PartialBlock<Tracer> {
     }
 
     /// returns (requests, withdrawals_root)
+    #[expect(clippy::result_large_err)]
     pub fn process_requests(
         &self,
         state: &mut BlockState,
@@ -697,7 +698,7 @@ impl<Tracer: SimulationTracer> PartialBlock<Tracer> {
     }
 
     /// Mostly based on reth's (v1.2) default_ethereum_payload_builder.
-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::result_large_err)]
     pub fn finalize(
         self,
         state: &mut BlockState,

Diff for: crates/rbuilder/src/building/sim.rs

@@ -22,6 +22,7 @@ use std::{
 };
 use tracing::{error, trace};
 
+#[expect(clippy::large_enum_variant)]
 #[derive(Debug)]
 pub enum OrderSimResult {
     Success(SimulatedOrder, Vec<(Address, u64)>),

Diff for: crates/rbuilder/src/live_builder/order_input/mod.rs

@@ -171,6 +171,7 @@ impl OrderInputConfig {
 }
 
 /// Commands we can get from RPC or mempool fetcher.
+#[expect(clippy::large_enum_variant)]
 #[derive(Debug, Clone)]
 pub enum ReplaceableOrderPoolCommand {
     /// New or update order

Diff for: crates/rbuilder/src/live_builder/order_input/order_sink.rs

@@ -46,7 +46,7 @@ impl Drop for OrderPrinter {
 }
 
 ///////////////////////
-
+#[expect(clippy::large_enum_variant)]
 #[derive(Debug, Clone)]
 pub enum OrderPoolCommand {
     //OrderSink::insert_order

Diff for: crates/rbuilder/src/primitives/mod.rs

@@ -339,6 +339,7 @@ impl ShareBundleTx {
 
 /// Body element of a mev share bundle.
 /// [`ShareBundleInner::body`] is formed by several of these.
+#[expect(clippy::large_enum_variant)]
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ShareBundleBody {
     Tx(ShareBundleTx),

Diff for: crates/rbuilder/src/primitives/order_builder.rs

@@ -7,6 +7,7 @@ use super::{
 };
 
 /// Helper object to build Orders for testing.
+#[expect(clippy::large_enum_variant)]
 #[derive(Debug)]
 pub enum OrderBuilder {
     MempoolTx(Option<TransactionSignedEcRecoveredWithBlobs>),

Diff for: crates/rbuilder/src/provider/mod.rs

@@ -48,6 +48,7 @@ pub trait RootHasher: std::fmt::Debug + Send + Sync {
         cancel: CancellationToken,
     );
 
+    #[expect(clippy::result_large_err)]
     /// State root for changes outcome on top of parent block.
     fn state_root(&self, outcome: &ExecutionOutcome) -> Result<B256, RootHashError>;
 }

Diff for: crates/rbuilder/src/roothash/mod.rs

@@ -109,7 +109,7 @@ where
     parallel_root_calculator.incremental_root()
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::result_large_err)]
 pub fn calculate_state_root<P, HasherType>(
     provider: P,
     hasher: &HasherType,

Diff for: crates/rbuilder/src/telemetry/servers/mod.rs

@@ -1,9 +1,9 @@
 //! Telemetry contains two servers.
 //!
 //! - [full]: verbose server exposing detailed operational information about the
-//!          builder.
+//!   builder.
 //! - [redacted]: deliberately redacted server serves information suitable for
-//!           tdx builders to expose in real-time.
+//!   tdx builders to expose in real-time.
 //!
 //! The redacted server is seperate from the debug server because it may be desirable
 //! to expose debug and redacted data differently in tdx builders. e.g. redacted data