fix: typos, clippy

Author: julio4

src/payload/ext/block.rs

@@ -35,7 +35,7 @@ pub trait BlockExt<P: Platform>: super::sealed::Sealed {
 	/// Address of the fees recipient for the block.
 	fn coinbase(&self) -> Address;
 
-	/// Returns the balance of the given address at the begining of the block
+	/// Returns the balance of the given address at the beginning of the block
 	/// before any transactions are executed.
 	fn balance_of(&self, address: Address) -> ProviderResult<U256>;
 }
@@ -101,7 +101,7 @@ impl<P: Platform> BlockExt<P> for BlockContext<P> {
 		self.attributes().suggested_fee_recipient()
 	}
 
-	/// Returns the balance of the given address at the begining of the block
+	/// Returns the balance of the given address at the beginning of the block
 	/// before any transactions are executed.
 	fn balance_of(&self, address: Address) -> ProviderResult<U256> {
 		self

src/payload/ext/checkpoint.rs

@@ -77,7 +77,7 @@ pub trait CheckpointExt<P: Platform>: super::sealed::Sealed {
 		history.take(immutable_prefix + 1)
 	}
 
-	/// Creates a new span that includes this checkpoints and all other
+	/// Creates a new span that includes this checkpoint and all other
 	/// checkpoints that are between this checkpoint and the given checkpoint.
 	///
 	/// The two checkpoints must be part of the same linear history, meaning that
@@ -185,7 +185,7 @@ impl<P: Platform> CheckpointExt<P> for Checkpoint<P> {
 			.expect("history is always linear between self and root")
 	}
 
-	/// Creates a new span that includes this checkpoints and all other
+	/// Creates a new span that includes this checkpoint and all other
 	/// checkpoints that are between this checkpoint and the given checkpoint.
 	///
 	/// The two checkpoints must be part of the same linear history, meaning that

src/payload/ext/span.rs

@@ -17,7 +17,7 @@ pub trait SpanExt<P: Platform>: super::sealed::Sealed {
 
 	/// Checks if this span contains a checkpoint with a transaction with a given
 	/// hash.
-	fn contains(&self, txhash: impl Into<TxHash>) -> bool;
+	fn contains(&self, tx_hash: impl Into<TxHash>) -> bool;
 
 	/// Iterates of all transactions in the span in chronological order as they
 	/// appear in the payload under construction.
@@ -56,8 +56,8 @@ pub trait SpanExt<P: Platform>: super::sealed::Sealed {
 impl<P: Platform> SpanExt<P> for Span<P> {
 	/// Checks if this span contains a checkpoint with a transaction with a given
 	/// hash.
-	fn contains(&self, txhash: impl Into<TxHash>) -> bool {
-		let hash = txhash.into();
+	fn contains(&self, tx_hash: impl Into<TxHash>) -> bool {
+		let hash = tx_hash.into();
 		self.iter().any(|checkpoint| {
 			checkpoint
 				.transactions()

src/payload/span.rs

@@ -22,7 +22,7 @@ pub enum Error {
 ///
 /// A span can be used as a database reference for an evm instance. When a span
 /// is used as a database, only new state that was created or modified by
-/// checkpoints in the span are visible, any state from checkpoints outside of
+/// checkpoints in the span are visible, any state from checkpoints outside
 /// the span or the base state of the block is not available.
 #[derive(Clone)]
 pub struct Span<P: Platform> {
@@ -78,9 +78,9 @@ impl<P: Platform> Span<P> {
 			checkpoints.push(prev.clone());
 
 			if prev == ancestor {
-				// we've reached the ancestor checkpoint and we have linear history. The
-				// collected checkpoints are in reverse order, so we need to reverse
-				// them before returning.
+				// we've reached the ancestor checkpoint, and we have linear history.
+				// The collected checkpoints are in reverse order, so we need to
+				// reverse them before returning.
 				return Ok(Self {
 					checkpoints: checkpoints.into_iter().rev().collect(),
 				});

src/pipelines/events.rs

@@ -10,8 +10,9 @@ use {
 /// pipeline.
 ///
 /// Notes:
-///  - In a pipeline with nested pipelines, the top-level pipline's event bus is
-///    responsible for handling all events of all contained pipelines and steps.
+///  - In a pipeline with nested pipelines, the top-level pipeline's event bus
+///    is responsible for handling all events of all contained pipelines and
+///    steps.
 #[derive(Default, Debug)]
 pub(super) struct EventsBus<P: Platform> {
 	publishers: DashMap<TypeId, Sender<Arc<dyn Any + Send + Sync>>>,

src/pipelines/exec/mod.rs

@@ -33,7 +33,7 @@ type PipelineOutput<P: Platform> =
 
 /// This type is responsible for executing a single run of a pipeline.
 ///
-/// It's execution is driven by the future poll that it implements. Each call to
+/// The execution is driven by the future poll that it implements. Each call to
 /// `poll` will run one step of the pipeline at a time, or parts of a step if
 /// the step is async and needs many polls before it completes. The executor
 /// future will resolve when the whole pipeline has been executed, or when an
@@ -123,7 +123,7 @@ impl<P: Platform, Provider: traits::ProviderBounds<P>>
 impl<P: Platform, Provider: traits::ProviderBounds<P>>
 	PipelineExecutor<P, Provider>
 {
-	/// This method creates a future that encapsulates the execution an an async
+	/// This method creates a future that encapsulates the execution as an async
 	/// step. The created future will be held inside `Cursor::StepInProgress` and
 	/// polled until it resolves.
 	///
@@ -243,7 +243,7 @@ impl<P: Platform, Provider: traits::ProviderBounds<P>>
 
 		async move {
 			// invoke the `after_job` method of each step in the pipeline
-			// if any of them failes we fail the pipeline execution, othwerwise
+			// if any of them fails, we fail the pipeline execution, otherwise
 			// we return the output of the pipeline.
 			for step in pipeline.iter_steps() {
 				let navi = step.navigator(&pipeline).expect(
@@ -279,7 +279,7 @@ where
 	fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
 		let executor = self.get_mut();
 
-		// The executor has not ran any steps yet, it is invoking the `before_job`
+		// The executor has not run any steps yet, it is invoking the `before_job`
 		// method of each step in the pipeline.
 		if let Cursor::Initializing(ref mut future) = executor.cursor {
 			if let Poll::Ready(output) = future.as_mut().poll_unpin(cx) {
@@ -404,7 +404,7 @@ enum Cursor<P: Platform> {
 
 	/// The pipeline is currently initializing all steps for a new payload job.
 	///
-	/// This happens once before any step is executed and it calls the
+	/// This happens once before any step is executed, and it calls the
 	/// `before_job` method of each step in the pipeline.
 	Initializing(
 		Pin<
@@ -419,8 +419,8 @@ enum Cursor<P: Platform> {
 	Finalizing(Pin<Box<dyn Future<Output = PipelineOutput<P>> + Send>>),
 
 	/// The pipeline is currently preparing to execute the next step.
-	/// We are in this state only for a brief moment inside the `poll` method
-	/// and it will never be seen by the `run_step` method.
+	/// We are in this state only for a brief moment inside the `poll` method, and
+	/// it will never be seen by the `run_step` method.
 	PreparingStep,
 }
 

src/pipelines/exec/navi.rs

@@ -79,7 +79,7 @@ impl StepPath {
 		self.depth() == 1
 	}
 
-	/// Returns `true` the the path is pointing to a prologue of a pipeline.
+	/// Returns `true` if the path is pointing to a prologue of a pipeline.
 	pub(crate) fn is_prologue(&self) -> bool {
 		self.leaf() == PROLOGUE_INDEX
 	}
@@ -426,11 +426,11 @@ impl<'a, P: Platform> StepNavigator<'a, P> {
 		let is_last = position + 1 >= enclosing_pipeline.steps().len();
 
 		match (self.behavior(), is_last) {
-			(Behavior::Loop, true) => {
+			(Loop, true) => {
 				// we are the last step in a loop pipeline, go to first step.
 				Self(self.0.replace_leaf(STEP0_INDEX), self.1.clone()).enter()
 			}
-			(Behavior::Once, true) => {
+			(Once, true) => {
 				// we are last step in a non-loop pipeline, this is the end of a
 				// single iteration loop.
 				self.after_loop()
@@ -469,7 +469,7 @@ impl<P: Platform> StepNavigator<'_, P> {
 	fn behavior(&self) -> Behavior {
 		// top-level pipelines are always `Once`.
 		if self.0.is_toplevel() {
-			return Behavior::Once;
+			return Once;
 		}
 
 		// to identify the behavior of the pipeline that contains the current step
@@ -560,7 +560,7 @@ impl<P: Platform> StepNavigator<'_, P> {
 		}
 	}
 
-	/// Finds the next step to run afer the prologue of the current pipeline.
+	/// Finds the next step to run after the prologue of the current pipeline.
 	fn after_prologue(self) -> Option<Self> {
 		if self.pipeline().steps().is_empty() {
 			// no steps, go to epilogue.
@@ -583,8 +583,8 @@ impl<P: Platform> StepNavigator<'_, P> {
 		// is last step in the enclosing pipeline?
 		if step_index + 1 >= enclosing_pipeline.steps().len() {
 			match ancestor.behavior() {
-				Behavior::Loop => ancestor.after_prologue(),
-				Behavior::Once => ancestor.after_loop(),
+				Loop => ancestor.after_prologue(),
+				Once => ancestor.after_loop(),
 			}
 		} else {
 			// there are more items in the enclosing pipeline, so we can just
@@ -681,7 +681,7 @@ mod test {
 			Pipeline::<Ethereum>::default().with_step(Step1),
 			StepPath::step0(),
 			// name autogenerated from source location
-			vec![format!("navi_{}", (line!() - 3))]
+			vec![format!("navi_{}", line!() - 3)]
 		);
 
 		// one step with prologue
@@ -773,17 +773,17 @@ mod test {
 			.with_step(Step2)
 			.with_step(Step3);
 		let navigator = StepNavigator::entrypoint(&pipeline).unwrap();
-		assert_eq!(navigator.behavior(), Behavior::Once);
+		assert_eq!(navigator.behavior(), Once);
 
 		let pipeline =
 			Pipeline::<Ethereum>::default().with_pipeline(Loop, (Step1,));
 		let navigator = StepNavigator::entrypoint(&pipeline).unwrap();
-		assert_eq!(navigator.behavior(), Behavior::Loop);
+		assert_eq!(navigator.behavior(), Loop);
 
 		let pipeline =
 			Pipeline::<Ethereum>::default().with_pipeline(Once, (Step1,));
 		let navigator = StepNavigator::entrypoint(&pipeline).unwrap();
-		assert_eq!(navigator.behavior(), Behavior::Once);
+		assert_eq!(navigator.behavior(), Once);
 	}
 
 	#[test]

src/pipelines/exec/scope.rs

@@ -61,7 +61,7 @@ use {
 /// `PipelineExecutor::advance_cursor`.
 ///
 /// Scopes manage:
-/// 	- The metrics name for each pipeline and its nested pipelines
+///   - The metrics name for each pipeline and its nested pipelines
 ///   - Limits calculation and renewal for pipeline steps.
 pub(crate) struct RootScope<P: Platform> {
 	root: RwLock<Scope<P>>,

src/pipelines/job.rs

@@ -30,7 +30,7 @@ use {
 ///
 /// This is a long-running job that will be polled by the CL node until it is
 /// resolved. The job future must resolve within 1 second from the moment
-/// [`PayloadJob::resolve_kind`] is called with [`PaylodKind::Earliest`].
+/// [`PayloadJob::resolve_kind`] is called with [`PayloadKind::Earliest`].
 pub(super) struct PayloadJob<P, Provider>
 where
 	P: Platform,
@@ -96,7 +96,7 @@ where
 			// protocol.
 			PayloadKind::Earliest => {
 				debug!(
-					"Resolving earliest payload for job {}",
+					"Resolving the earliest payload for job {}",
 					self.block.attributes().payload_id()
 				);
 				(self.fut.clone(), KeepPayloadJobAlive::No)
@@ -120,7 +120,7 @@ where
 
 	fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
 		// When the payload job future is polled, we begin executing the pipeline
-		// production future immediatelly as well, so that the time between the
+		// production future immediately as well, so that the time between the
 		// creation of the job and the call to `resolve_kind` is utilized for the
 		// pipeline execution.
 		//
@@ -134,15 +134,15 @@ where
 			return Poll::Ready(Err(e));
 		}
 
-		// On happy paths or in-progress pipielines, keep the future alive. Reth
+		// On happy paths or in-progress pipelines, keep the future alive. Reth
 		// will drop it when a payload is resolved.
 		Poll::Pending
 	}
 }
 
 /// This future wraps the `PipelineExecutor` and is used to poll the
 /// internal executor of the pipeline. Once this future is resolved, it
-/// can be polled again and will return copie of the resolved payload.
+/// can be polled again and will return copy of the resolved payload.
 pub(super) struct ExecutorFuture<P, Provider>
 where
 	P: Platform,
@@ -154,7 +154,7 @@ where
 }
 
 /// This enum allows us to wrap the `PipelineExecutor` future
-/// and cache the result of the execution. Also it makes the executor future
+/// and cache the result of the execution. Also, it makes the executor future
 /// clonable, so that many copies of the future could be returned from
 /// `resolve_kind`.
 ///

src/pipelines/limits.rs

@@ -21,7 +21,7 @@ pub trait ScopedLimits<P: Platform>: Send + Sync + 'static {
 	fn create(&self, payload: &Checkpoint<P>, enclosing: &Limits) -> Limits;
 }
 
-/// Convinience trait that allows API users to either use a `ScopedLimits` type
+/// Convenience trait that allows API users to either use a `ScopedLimits` type
 /// or a concrete limits value in [`Pipeline::with_limits`].
 pub trait IntoScopedLimits<P: Platform, Marker = ()> {
 	/// Convert the type into a limits factory.
@@ -105,35 +105,7 @@ impl<T> From<Zero> for ScaleOp<T> {
 
 impl<P: Platform> ScopedLimits<P> for Scaled {
 	fn create(&self, _: &Checkpoint<P>, enclosing: &Limits) -> Limits {
-		let mut limits = *enclosing;
-
-		if let Some(ref op) = self.gas {
-			limits.gas_limit = op.apply(limits.gas_limit);
-		}
-
-		if let Some(ref op) = self.deadline {
-			limits.deadline = op.apply(limits.deadline);
-		}
-
-		if let Some(ref op) = self.max_txs {
-			limits.max_transactions = op.apply(limits.max_transactions);
-		}
-
-		if let Some(ref op) = self.max_blob_count {
-			limits.blob_params = limits.blob_params.map(|params| BlobParams {
-				max_blob_count: op.apply(params.max_blob_count),
-				..params
-			});
-		}
-
-		if let Some(ref op) = self.max_blobs_per_tx {
-			limits.blob_params = limits.blob_params.map(|params| BlobParams {
-				max_blobs_per_tx: op.apply(params.max_blobs_per_tx),
-				..params
-			});
-		}
-
-		limits
+		self.from(enclosing)
 	}
 }