fix: typos

plonky2x/core/src/frontend/curta/ec/aggregate/air.rs

@@ -120,7 +120,7 @@ impl<F: PrimeField64, R: CubicParameters<F>, E: EllipticCurveAir<PKAirParameters
         builder.set_to_expression_first_row(&accumulator.x, generator.x.expr());
         builder.set_to_expression_first_row(&accumulator.y, generator.y.expr());
 
-        // Flag constraints. The bus guarnatees correct values at cycle starts. for all other
+        // Flag constraints. The bus guarantees correct values at cycle starts. for all other
         // points, we constrain the selector to zero.
         builder.assert_expression_zero(flag.expr() * cycle.start_bit.not_expr());
 

plonky2x/core/src/frontend/ecc/ed25519/gadgets/curve.rs

@@ -231,7 +231,7 @@ impl<F: RichField + Extendable<D>, const D: usize> CircuitBuilderCurve<F, D>
         AffinePointTarget { x: x3, y: y3 }
     }
 
-    // This funciton will accept an affine point target and return
+    // This function will accept an affine point target and return
     // the point in compressed form (bit vector).
     fn compress_point<C: Curve>(&mut self, p: &AffinePointTarget<C>) -> CompressedPointTarget {
         let mut bits = biguint_to_bits_target::<F, D>(self, &p.y.value);

plonky2x/core/src/frontend/hint/asynchronous/builder.rs

@@ -121,7 +121,7 @@ mod tests {
         let back_time = output_stream.read::<ByteVariable>(&mut builder);
         builder.write(back_time);
 
-        // runing a few in parallel to make sure the tests takes roughly the duratio of one sleep.
+        // running a few in parallel to make sure the tests takes roughly the duratio of one sleep.
         let mut fail_input_stream = VariableStream::new();
         let fail_time = builder.constant::<ByteVariable>(10u8);
         fail_input_stream.write(&fail_time);

plonky2x/core/src/frontend/hint/asynchronous/generator.rs

@@ -199,7 +199,7 @@ impl<L: PlonkParameters<D>, H: AsyncHint<L, D>, const D: usize> AsyncHintRunner<
             HintPoll::Pending => {
                 // Check the hint channel for the output. If not ready, return `HintPoll::Pending`.
                 if let Ok(mut output_stream) = self.channel.rx_out.try_recv() {
-                    trace!("Async Hint {:?} : recieved output from hint", H::id());
+                    trace!("Async Hint {:?} : received output from hint", H::id());
                     let output_values = output_stream.read_all();
                     let output_vars = self.output_stream.real_all();
                     assert_eq!(output_values.len(), output_vars.len());

plonky2x/core/src/frontend/hint/synchronous.rs

@@ -96,7 +96,7 @@ mod tests {
         let b = output_stream.read::<ByteVariable>(&mut builder);
         builder.write(b);
 
-        // runing a few in parallel to make sure the tests takes roughly the duratio of one sleep.
+        // running a few in parallel to make sure the tests takes roughly the duratio of one sleep.
         let output_stream = builder.async_hint(input_stream.clone(), Async(hint.clone()));
         let _ = output_stream.read::<ByteVariable>(&mut builder);
         let output_stream = builder.async_hint(input_stream.clone(), Async(hint.clone()));

plonky2x/core/src/frontend/mapreduce/mod.rs

@@ -12,7 +12,7 @@
 //! we can pass in a block hash as the dynamic data to the map and reduce functions to say that
 //! in each map call we want to grab the storage slot at slot i, which is a compile time constant.
 //!
-//! Under the hood, we compute each map in a seperate proof and perform the reductions by generating
+//! Under the hood, we compute each map in a separate proof and perform the reductions by generating
 //! a proof for each reduction between two proofs until we have a single proof.
 
 pub mod generator;
@@ -192,7 +192,7 @@ impl<L: PlonkParameters<D>, const D: usize> CircuitBuilder<L, D> {
 
         // Build a map circuit which maps from I -> O using the closure `m`.
         let map_circuit = self.build_map(&map_fn);
-        debug!("succesfully built map circuit: id={}", map_circuit.id());
+        debug!("successfully built map circuit: id={}", map_circuit.id());
 
         // Save map circuit and map circuit input target to build folder.
         let map_circuit_id = map_circuit.id();
@@ -219,7 +219,7 @@ impl<L: PlonkParameters<D>, const D: usize> CircuitBuilder<L, D> {
                 &generator_serializer,
             );
             reduce_circuits.push(reduce_circuit);
-            debug!("succesfully built reduce circuit: id={}", reduce_circuit_id);
+            debug!("successfully built reduce circuit: id={}", reduce_circuit_id);
         }
 
         // Create generator to generate map and reduce proofs for each layer.