@@ -102,3 +102,13 @@ uses: actions-rs/cargo@v1
         with:
           command: clippy
           args: --all-targets --all-features -- -D warnings
+
+  typos:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Use typos with config file
+      uses: crate-ci/typos@master
+      with: 
+        config: .github/workflows/typos.toml

@@ -0,0 +1,2 @@
+[default.extend-words]
+groth = "groth"

@@ -231,7 +231,7 @@
             require(eval_z == 0, "checkAndCommitAuxPolys: wrong zero poly");
             require(eval_l == y_vals[i], "checkAndCommitAuxPolys: wrong lagrange poly");
         }
-        // z(x) has len(x_vals) + 1 coeffs, we add to the commmitment the last coeff of z(x)
+        // z(x) has len(x_vals) + 1 coeffs, we add to the commitment the last coeff of z(x)
         z_commit = add(z_commit, mulScalar(G1_CRS[z_coeffs.length - 1], z_coeffs[z_coeffs.length - 1]));
 
         return (z_commit, l_commit);

@@ -58,12 +58,12 @@ cs: ConstraintSystemRef<F>,
         z_i: Vec<FpVar<F>>,
     ) -> Result<Vec<FpVar<F>>, SynthesisError> {
         let four = FpVar::<F>::new_constant(cs.clone(), F::from(4u32))?;
-        let fourty = FpVar::<F>::new_constant(cs.clone(), F::from(40u32))?;
+        let forty = FpVar::<F>::new_constant(cs.clone(), F::from(40u32))?;
         let onehundred = FpVar::<F>::new_constant(cs.clone(), F::from(100u32))?;
         let a = z_i[0].clone() + four.clone();
-        let b = z_i[1].clone() + fourty.clone();
+        let b = z_i[1].clone() + forty.clone();
         let c = z_i[2].clone() * four;
-        let d = z_i[3].clone() * fourty;
+        let d = z_i[3].clone() * forty;
         let e = z_i[4].clone() + onehundred;
 
         Ok(vec![a, b, c, d, e])
@@ -140,7 +140,7 @@ folding_scheme.prove_step().unwrap();
         println!("Nova::prove_step {}: {:?}", i, start.elapsed());
     }
 
-    let (running_instance, incomming_instance, cyclefold_instance) = folding_scheme.instances();
+    let (running_instance, incoming_instance, cyclefold_instance) = folding_scheme.instances();
 
     println!("Run the Nova's IVC verifier");
     NOVA::verify(
@@ -149,7 +149,7 @@ initial_state.clone(),
         folding_scheme.state(), // latest state
         Fr::from(num_steps as u32),
         running_instance,
-        incomming_instance,
+        incoming_instance,
         cyclefold_instance,
     )
     .unwrap();

@@ -125,7 +125,7 @@ folding_scheme.prove_step().unwrap();
         println!("Nova::prove_step {}: {:?}", i, start.elapsed());
     }
 
-    let (running_instance, incomming_instance, cyclefold_instance) = folding_scheme.instances();
+    let (running_instance, incoming_instance, cyclefold_instance) = folding_scheme.instances();
 
     println!("Run the Nova's IVC verifier");
     NOVA::verify(
@@ -134,7 +134,7 @@ initial_state,
         folding_scheme.state(), // latest state
         Fr::from(num_steps as u32),
         running_instance,
-        incomming_instance,
+        incoming_instance,
         cyclefold_instance,
     )
     .unwrap();

@@ -13,7 +13,7 @@ use folding_schemes::transcript::poseidon::poseidon_test_config;
 
 // This method computes the Prover & Verifier parameters for the example.
 // Warning: this method is only for testing purposes. For a real world use case those parameters
-// should be generated carefuly (both the PoseidonConfig and the PedersenParams).
+// should be generated carefully (both the PoseidonConfig and the PedersenParams).
 #[allow(clippy::type_complexity)]
 pub(crate) fn test_nova_setup<FC: FCircuit<Fr>>(
     F_circuit: FC,

@@ -97,7 +97,7 @@ coeffs: m.c,
     };
 
     R1CS::<F> {
-        l: cs.num_instance_variables - 1, // -1 to substract the first '1'
+        l: cs.num_instance_variables - 1, // -1 to subtract the first '1'
         A,
         B,
         C,

@@ -80,7 +80,7 @@ type Proof = (C::ScalarField, C);
 
     /// commit implements the CommitmentProver commit interface, adapting the implementation from
     /// https://github.com/arkworks-rs/poly-commit/tree/c724fa666e935bbba8db5a1421603bab542e15ab/poly-commit/src/kzg10/mod.rs#L178
-    /// with the main difference being the removal of the blinding factors and the no-dependancy to
+    /// with the main difference being the removal of the blinding factors and the no-dependency to
     /// the Pairing trait.
     fn commit(
         params: &Self::Params,
@@ -105,7 +105,7 @@ }
 
     /// prove implements the CommitmentProver prove interface, adapting the implementation from
     /// https://github.com/arkworks-rs/poly-commit/tree/c724fa666e935bbba8db5a1421603bab542e15ab/poly-commit/src/kzg10/mod.rs#L307
-    /// with the main difference being the removal of the blinding factors and the no-dependancy to
+    /// with the main difference being the removal of the blinding factors and the no-dependency to
     /// the Pairing trait.
     fn prove(
         params: &Self::Params,

@@ -10,7 +10,7 @@ use ark_relations::r1cs::{Namespace, SynthesisError};
 use ark_std::{One, Zero};
 use core::borrow::Borrow;
 
-/// NonNativeAffineVar represents an elliptic curve point in Affine represenation in the non-native
+/// NonNativeAffineVar represents an elliptic curve point in Affine representation in the non-native
 /// field, over the constraint field. It is not intended to perform operations, but just to contain
 /// the affine coordinates in order to perform hash operations of the point.
 #[derive(Debug, Clone)]

@@ -111,7 +111,7 @@ ccs: &CCS<C>,
         w: &Witness<C::ScalarField>,
     ) -> Result<(), Error> {
         // check that C is the commitment of w. Notice that this is not verifying a Pedersen
-        // opening, but checking that the Commmitment comes from committing to the witness.
+        // opening, but checking that the commitment comes from committing to the witness.
         if self.C != Pedersen::commit(pedersen_params, &w.w, &w.r_w)? {
             return Err(Error::NotSatisfied);
         }

@@ -96,7 +96,7 @@ ccs: &CCS<C>,
         w: &Witness<C::ScalarField>,
     ) -> Result<(), Error> {
         // check that C is the commitment of w. Notice that this is not verifying a Pedersen
-        // opening, but checking that the Commmitment comes from committing to the witness.
+        // opening, but checking that the commitment comes from committing to the witness.
         if self.C != Pedersen::commit(pedersen_params, &w.w, &w.r_w)? {
             return Err(Error::NotSatisfied);
         }
@@ -133,7 +133,7 @@ ccs.check_relation(&z.clone()).unwrap();
 
         let pedersen_params = Pedersen::<Projective>::new_params(&mut rng, ccs.n - ccs.l - 1);
         let (lcccs, _) = ccs.to_lcccs(&mut rng, &pedersen_params, &z).unwrap();
-        // with our test vector comming from R1CS, v should have length 3
+        // with our test vector coming from R1CS, v should have length 3
         assert_eq!(lcccs.v.len(), 3);
 
         let vec_L_j_x = lcccs.compute_Ls(&ccs, &z);
@@ -164,7 +164,7 @@
         let pedersen_params = Pedersen::<Projective>::new_params(&mut rng, ccs.n - ccs.l - 1);
         // Compute v_j with the right z
         let (lcccs, _) = ccs.to_lcccs(&mut rng, &pedersen_params, &z).unwrap();
-        // with our test vector comming from R1CS, v should have length 3
+        // with our test vector coming from R1CS, v should have length 3
         assert_eq!(lcccs.v.len(), 3);
 
         // Bad compute L_j(x) with the bad z

@@ -445,7 +445,7 @@ // check cf_u_i.cmE=0, cf_u_i.u=1
         (cf_u_i.cmE.is_zero()?).conditional_enforce_equal(&Boolean::TRUE, &is_not_basecase)?;
         (cf_u_i.u.is_one()?).conditional_enforce_equal(&Boolean::TRUE, &is_not_basecase)?;
 
-        // check the fold of all the parameteres of the CycleFold instances, where the elliptic
+        // check the fold of all the parameters of the CycleFold instances, where the elliptic
         // curve points relations are checked natively in Curve1 circuit (this one)
         let v = NIFSFullGadget::<C2, GC2>::verify(
             cf_r_bits,
@@ -572,7 +572,7 @@ // check that the natively computed and in-circuit computed hashes match
         assert_eq!(hVar.value().unwrap(), h);
     }
 
-    // checks that the gadget and native implementations of the challenge computation matcbh
+    // checks that the gadget and native implementations of the challenge computation match
     #[test]
     fn test_challenge_gadget() {
         let mut rng = ark_std::test_rng();

@@ -50,7 +50,7 @@ <C1 as Group>::ScalarField: Absorb,
     <C2 as Group>::ScalarField: Absorb,
     C1: CurveGroup<BaseField = C2::ScalarField, ScalarField = C2::BaseField>,
     for<'b> &'b GC2: GroupOpsBounds<'b, C2, GC2>,
-    // constrain FS into Nova, since this is a Decider specificly for Nova
+    // constrain FS into Nova, since this is a Decider specifically for Nova
     Nova<C1, GC1, C2, GC2, FC, CP1, CP2>: From<FS>,
 {
     type ProverParam = S::ProvingKey;

@@ -491,11 +491,11 @@ z_0: Vec<C1::ScalarField>, // initial state
         z_i: Vec<C1::ScalarField>, // last state
         num_steps: C1::ScalarField,
         running_instance: Self::CommittedInstanceWithWitness,
-        incomming_instance: Self::CommittedInstanceWithWitness,
+        incoming_instance: Self::CommittedInstanceWithWitness,
         cyclefold_instance: Self::CFCommittedInstanceWithWitness,
     ) -> Result<(), Error> {
         let (U_i, W_i) = running_instance;
-        let (u_i, w_i) = incomming_instance;
+        let (u_i, w_i) = incoming_instance;
         let (cf_U_i, cf_W_i) = cyclefold_instance;
 
         if u_i.x.len() != 1 || U_i.x.len() != 1 {

@@ -143,7 +143,7 @@ // fold witness
         // use r_T=1 since we don't need hiding property for cm(T)
         let w3 = NIFS::<C, CP>::fold_witness(r, w1, w2, T, C::ScalarField::one())?;
 
-        // fold committed instancs
+        // fold committed instances
         let ci3 = NIFS::<C, CP>::fold_committed_instance(r, ci1, ci2, &cmT);
 
         Ok((w3, ci3))
@@ -161,7 +161,7 @@ ) -> CommittedInstance<C> {
         NIFS::<C, CP>::fold_committed_instance(r, ci1, ci2, cmT)
     }
 
-    /// Verify commited folded instance (ci) relations. Notice that this method does not open the
+    /// Verify committed folded instance (ci) relations. Notice that this method does not open the
     /// commitments, but just checks that the given committed instances (ci1, ci2) when folded
     /// result in the folded committed instance (ci3) values.
     pub fn verify_folded_instance(
@@ -426,16 +426,16 @@ .unwrap();
 
         let num_iters = 10;
         for i in 0..num_iters {
-            // prepare the incomming instance
-            let incomming_instance_z = get_test_z(i + 4);
-            let (w, x) = r1cs.split_z(&incomming_instance_z);
-            let incomming_instance_w = Witness::<Projective>::new(w.clone(), r1cs.A.n_rows);
-            let incomming_committed_instance = incomming_instance_w
+            // prepare the incoming instance
+            let incoming_instance_z = get_test_z(i + 4);
+            let (w, x) = r1cs.split_z(&incoming_instance_z);
+            let incoming_instance_w = Witness::<Projective>::new(w.clone(), r1cs.A.n_rows);
+            let incoming_committed_instance = incoming_instance_w
                 .commit::<Pedersen<Projective>>(&pedersen_params, x)
                 .unwrap();
             r1cs.check_relaxed_instance_relation(
-                &incomming_instance_w,
-                &incomming_committed_instance,
+                &incoming_instance_w,
+                &incoming_committed_instance,
             )
             .unwrap();
 
@@ -447,16 +447,16 @@ &pedersen_params,
                 &r1cs,
                 &running_instance_w,
                 &running_committed_instance,
-                &incomming_instance_w,
-                &incomming_committed_instance,
+                &incoming_instance_w,
+                &incoming_committed_instance,
             )
             .unwrap();
             let (folded_w, _) = NIFS::<Projective, Pedersen<Projective>>::fold_instances(
                 r,
                 &running_instance_w,
                 &running_committed_instance,
-                &incomming_instance_w,
-                &incomming_committed_instance,
+                &incoming_instance_w,
+                &incoming_committed_instance,
                 &T,
                 cmT,
             )
@@ -466,7 +466,7 @@ // NIFS.V
             let folded_committed_instance = NIFS::<Projective, Pedersen<Projective>>::verify(
                 r,
                 &running_committed_instance,
-                &incomming_committed_instance,
+                &incoming_committed_instance,
                 &cmT,
             );
 

@@ -40,7 +40,7 @@ r1cs: &R1CS<C::ScalarField>,
         // running instance
         instance: &CommittedInstance<C>,
         w: &Witness<C::ScalarField>,
-        // incomming instances
+        // incoming instances
         vec_instances: &[CommittedInstance<C>],
         vec_w: &[Witness<C::ScalarField>],
     ) -> Result<
@@ -226,7 +226,7 @@ transcript: &mut (impl Transcript<C> + ProtoGalaxyTranscript<C>),
         r1cs: &R1CS<C::ScalarField>,
         // running instance
         instance: &CommittedInstance<C>,
-        // incomming instances
+        // incoming instances
         vec_instances: &[CommittedInstance<C>],
         // polys from P
         F_coeffs: Vec<C::ScalarField>,
@@ -440,7 +440,7 @@ let f_w = eval_f(&r1cs, &z).unwrap();
         assert!(!is_zero_vec(&f_w));
     }
 
-    // k represents the number of instances to be fold, appart from the running instance
+    // k represents the number of instances to be fold, apart from the running instance
     #[allow(clippy::type_complexity)]
     fn prepare_inputs(
         k: usize,
@@ -522,7 +522,7 @@ &witnesses,
         )
         .unwrap();
 
-        // veriier
+        // verifier
         let folded_instance_v = Folding::<Projective>::verify(
             &mut transcript_v,
             &r1cs,
@@ -572,7 +572,7 @@ &witnesses,
                 )
                 .unwrap();
 
-            // veriier
+            // verifier
             let folded_instance_v = Folding::<Projective>::verify(
                 &mut transcript_v,
                 &r1cs,

@@ -42,7 +42,7 @@ #[error("Vector's length ({0}) is not the expected ({1})")]
     NotExpectedLength(usize, usize),
     #[error("Can not be empty")]
     Empty,
-    #[error("Pedersen parameters length is not suficient (generators.len={0} < vector.len={1} unsatisfied)")]
+    #[error("Pedersen parameters length is not sufficient (generators.len={0} < vector.len={1} unsatisfied)")]
     PedersenParamsLen(usize, usize),
     #[error("Commitment verification failed")]
     CommitmentVerificationFail,
@@ -116,7 +116,7 @@ z_i: Vec<C1::ScalarField>, // last state
         // number of steps between the initial state and the last state
         num_steps: C1::ScalarField,
         running_instance: Self::CommittedInstanceWithWitness,
-        incomming_instance: Self::CommittedInstanceWithWitness,
+        incoming_instance: Self::CommittedInstanceWithWitness,
         cyclefold_instance: Self::CFCommittedInstanceWithWitness,
     ) -> Result<(), Error>;
 }

@@ -57,7 +57,7 @@ c
     }
 }
 
-// Returns the point coordinates in Fr, so it can be absrobed by the transcript. It does not work
+// Returns the point coordinates in Fr, so it can be absorbed by the transcript. It does not work
 // over bytes in order to have a logic that can be reproduced in-circuit.
 fn prepare_point<C: CurveGroup>(p: &C) -> Result<Vec<C::ScalarField>, Error> {
     let affine = p.into_affine();