diff --git a/starky/src/config.rs b/starky/src/config.rs
index 24fb725a..500cd957 100644
--- a/starky/src/config.rs
+++ b/starky/src/config.rs
@@ -29,17 +29,6 @@ impl StarkConfig {
     }
 
     pub(crate) fn fri_params(&self, degree_bits: usize) -> FriParams {
-        let fri_config = &self.fri_config;
-        let reduction_arity_bits = fri_config.reduction_strategy.reduction_arity_bits(
-            degree_bits,
-            fri_config.rate_bits,
-            fri_config.num_query_rounds,
-        );
-        FriParams {
-            config: fri_config.clone(),
-            hiding: false,
-            degree_bits,
-            reduction_arity_bits,
-        }
+        self.fri_config.fri_params(degree_bits, false)
     }
 }
diff --git a/starky/src/fibonacci_stark.rs b/starky/src/fibonacci_stark.rs
index 08125180..bd1775e1 100644
--- a/starky/src/fibonacci_stark.rs
+++ b/starky/src/fibonacci_stark.rs
@@ -67,9 +67,9 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for FibonacciStar
         yield_constr
             .constraint_last_row(vars.local_values[1] - vars.public_inputs[Self::PI_INDEX_RES]);
 
-        // x0 <- x1
+        // x0' <- x1
         yield_constr.constraint(vars.next_values[0] - vars.local_values[1]);
-        // x1 <- x0 + x1
+        // x1' <- x0 + x1
         yield_constr.constraint(vars.next_values[1] - vars.local_values[0] - vars.local_values[1]);
     }
 
@@ -89,10 +89,10 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for FibonacciStar
         yield_constr.constraint_first_row(builder, pis_constraints[1]);
         yield_constr.constraint_last_row(builder, pis_constraints[2]);
 
-        // x0 <- x1
+        // x0' <- x1
         let first_col_constraint = builder.sub_extension(vars.next_values[0], vars.local_values[1]);
         yield_constr.constraint(builder, first_col_constraint);
-        // x1 <- x0 + x1
+        // x1' <- x0 + x1
         let second_col_constraint = {
             let tmp = builder.sub_extension(vars.next_values[1], vars.local_values[0]);
             builder.sub_extension(tmp, vars.local_values[1])
@@ -125,11 +125,11 @@ mod tests {
     use crate::prover::prove;
     use crate::recursive_verifier::{
         add_virtual_stark_proof_with_pis, recursively_verify_stark_proof,
-        set_startk_proof_with_pis_target,
+        set_stark_proof_with_pis_target,
     };
     use crate::stark::Stark;
     use crate::stark_testing::test_stark_low_degree;
-    use crate::verifier::verify;
+    use crate::verifier::verify_stark_proof;
 
     fn fibonacci<F: Field>(n: usize, x0: F, x1: F) -> F {
         (0..n).fold((x0, x1), |x, _| (x.1, x.0 + x.1)).1
@@ -155,7 +155,7 @@ mod tests {
             &mut TimingTree::default(),
         )?;
 
-        verify(stark, proof, &config)
+        verify_stark_proof(stark, proof, &config)
     }
 
     #[test]
@@ -165,7 +165,6 @@ mod tests {
         type F = <C as GenericConfig<D>>::F;
         type S = FibonacciStark<F, D>;
 
-        let config = StarkConfig::standard_fast_config();
         let num_rows = 1 << 5;
         let stark = S::new(num_rows);
         test_stark_low_degree(stark)
@@ -191,7 +190,7 @@ mod tests {
             public_inputs,
             &mut TimingTree::default(),
         )?;
-        verify(stark, proof.clone(), &config)?;
+        verify_stark_proof(stark, proof.clone(), &config)?;
 
         recursive_proof::<F, C, S, C, D>(stark, proof, &config, true)
     }
@@ -219,7 +218,7 @@ mod tests {
         let mut pw = PartialWitness::new();
         let degree_bits = inner_proof.proof.recover_degree_bits(inner_config);
         let pt = add_virtual_stark_proof_with_pis(&mut builder, stark, inner_config, degree_bits);
-        set_startk_proof_with_pis_target(&mut pw, &pt, &inner_proof);
+        set_stark_proof_with_pis_target(&mut pw, &pt, &inner_proof);
 
         recursively_verify_stark_proof::<F, InnerC, S, D>(&mut builder, stark, pt, inner_config);
 
diff --git a/starky/src/get_challenges.rs b/starky/src/get_challenges.rs
index 3d815caf..24845c9a 100644
--- a/starky/src/get_challenges.rs
+++ b/starky/src/get_challenges.rs
@@ -17,7 +17,6 @@ use crate::proof::{
     StarkProofWithPublicInputsTarget,
 };
 
-#[allow(clippy::too_many_arguments)]
 fn get_challenges<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
     trace_cap: &MerkleCap<F, C::Hasher>,
     quotient_polys_cap: &MerkleCap<F, C::Hasher>,
@@ -29,8 +28,6 @@ fn get_challenges<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, cons
     degree_bits: usize,
 ) -> Result<StarkProofChallenges<F, D>> {
     let num_challenges = config.num_challenges;
-    let num_fri_queries = config.fri_config.num_query_rounds;
-    let lde_size = 1 << (degree_bits + config.fri_config.rate_bits);
 
     let mut challenger = Challenger::<F, C::Hasher>::new();
 
@@ -115,14 +112,11 @@ pub(crate) fn get_challenges_target<
     final_poly: &PolynomialCoeffsExtTarget<D>,
     pow_witness: Target,
     config: &StarkConfig,
-    degree_bits: usize,
 ) -> StarkProofChallengesTarget<D>
 where
     C::Hasher: AlgebraicHasher<F>,
 {
     let num_challenges = config.num_challenges;
-    let num_fri_queries = config.fri_config.num_query_rounds;
-    let lde_size = 1 << (degree_bits + config.fri_config.rate_bits);
 
     let mut challenger = RecursiveChallenger::<F, C::Hasher, D>::new(builder);
 
@@ -152,7 +146,6 @@ impl<const D: usize> StarkProofWithPublicInputsTarget<D> {
         &self,
         builder: &mut CircuitBuilder<F, D>,
         config: &StarkConfig,
-        degree_bits: usize,
     ) -> StarkProofChallengesTarget<D>
     where
         C::Hasher: AlgebraicHasher<F>,
@@ -179,7 +172,6 @@ impl<const D: usize> StarkProofWithPublicInputsTarget<D> {
             final_poly,
             *pow_witness,
             config,
-            degree_bits,
         )
     }
 }
diff --git a/starky/src/lib.rs b/starky/src/lib.rs
index 01667c28..aee0ddbe 100644
--- a/starky/src/lib.rs
+++ b/starky/src/lib.rs
@@ -2,6 +2,7 @@
 #![allow(dead_code)]
 #![allow(unused_variables)]
 #![allow(incomplete_features)]
+#![allow(clippy::too_many_arguments)]
 #![feature(generic_const_exprs)]
 
 pub mod config;
diff --git a/starky/src/proof.rs b/starky/src/proof.rs
index 8e225e79..e3fb6f72 100644
--- a/starky/src/proof.rs
+++ b/starky/src/proof.rs
@@ -15,7 +15,6 @@ use rayon::prelude::*;
 
 use crate::config::StarkConfig;
 
-// TODO: Permutation polynomials.
 #[derive(Debug, Clone)]
 pub struct StarkProof<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize> {
     /// Merkle cap of LDEs of trace values.
diff --git a/starky/src/recursive_verifier.rs b/starky/src/recursive_verifier.rs
index d6d559b6..1a31488e 100644
--- a/starky/src/recursive_verifier.rs
+++ b/starky/src/recursive_verifier.rs
@@ -35,7 +35,7 @@ pub fn recursively_verify_stark_proof<
 {
     assert_eq!(proof_with_pis.public_inputs.len(), S::PUBLIC_INPUTS);
     let degree_bits = proof_with_pis.proof.recover_degree_bits(inner_config);
-    let challenges = proof_with_pis.get_challenges::<F, C>(builder, inner_config, degree_bits);
+    let challenges = proof_with_pis.get_challenges::<F, C>(builder, inner_config);
 
     recursively_verify_stark_proof_with_challenges::<F, C, S, D>(
         builder,
@@ -71,8 +71,6 @@ fn recursively_verify_stark_proof_with_challenges<
         proof,
         public_inputs,
     } = proof_with_pis;
-    let local_values = &proof.openings.local_values;
-    let next_values = &proof.openings.local_values;
     let StarkOpeningSetTarget {
         local_values,
         next_values,
@@ -181,7 +179,7 @@ pub fn add_virtual_stark_proof<F: RichField + Extendable<D>, S: Stark<F, D>, con
     config: &StarkConfig,
     degree_bits: usize,
 ) -> StarkProofTarget<D> {
-    let fri_params = config.fri_config.fri_params(degree_bits, false);
+    let fri_params = config.fri_params(degree_bits);
     let cap_height = fri_params.config.cap_height;
 
     let num_leaves_per_oracle = &[
@@ -214,7 +212,7 @@ fn add_stark_opening_set<F: RichField + Extendable<D>, S: Stark<F, D>, const D:
     }
 }
 
-pub fn set_startk_proof_with_pis_target<F, C: GenericConfig<D, F = F>, W, const D: usize>(
+pub fn set_stark_proof_with_pis_target<F, C: GenericConfig<D, F = F>, W, const D: usize>(
     witness: &mut W,
     stark_proof_with_pis_target: &StarkProofWithPublicInputsTarget<D>,
     stark_proof_with_pis: &StarkProofWithPublicInputs<F, C, D>,
diff --git a/starky/src/stark.rs b/starky/src/stark.rs
index 3ef976e0..98365344 100644
--- a/starky/src/stark.rs
+++ b/starky/src/stark.rs
@@ -96,7 +96,7 @@ pub trait Stark<F: RichField + Extendable<D>, const D: usize>: Sync {
         };
         FriInstanceInfo {
             oracles: vec![no_blinding_oracle; 3],
-            batches: vec![zeta_batch],
+            batches: vec![zeta_batch, zeta_right_batch],
         }
     }
 
@@ -124,7 +124,7 @@ pub trait Stark<F: RichField + Extendable<D>, const D: usize>: Sync {
         };
         FriInstanceInfoTarget {
             oracles: vec![no_blinding_oracle; 3],
-            batches: vec![zeta_batch],
+            batches: vec![zeta_batch, zeta_right_batch],
         }
     }
 }
diff --git a/starky/src/verifier.rs b/starky/src/verifier.rs
index 201f4b9c..b27cf2b3 100644
--- a/starky/src/verifier.rs
+++ b/starky/src/verifier.rs
@@ -12,7 +12,7 @@ use crate::proof::{StarkOpeningSet, StarkProofChallenges, StarkProofWithPublicIn
 use crate::stark::Stark;
 use crate::vars::StarkEvaluationVars;
 
-pub fn verify<
+pub fn verify_stark_proof<
     F: RichField + Extendable<D>,
     C: GenericConfig<D, F = F>,
     S: Stark<F, D>,
@@ -30,10 +30,10 @@ where
     ensure!(proof_with_pis.public_inputs.len() == S::PUBLIC_INPUTS);
     let degree_bits = proof_with_pis.proof.recover_degree_bits(config);
     let challenges = proof_with_pis.get_challenges(config, degree_bits)?;
-    verify_with_challenges(stark, proof_with_pis, challenges, degree_bits, config)
+    verify_stark_proof_with_challenges(stark, proof_with_pis, challenges, degree_bits, config)
 }
 
-pub(crate) fn verify_with_challenges<
+pub(crate) fn verify_stark_proof_with_challenges<
     F: RichField + Extendable<D>,
     C: GenericConfig<D, F = F>,
     S: Stark<F, D>,
@@ -54,8 +54,6 @@ where
         proof,
         public_inputs,
     } = proof_with_pis;
-    let local_values = &proof.openings.local_values;
-    let next_values = &proof.openings.local_values;
     let StarkOpeningSet {
         local_values,
         next_values,
diff --git a/system_zero/src/system_zero.rs b/system_zero/src/system_zero.rs
index 2eeb4697..c1062e2a 100644
--- a/system_zero/src/system_zero.rs
+++ b/system_zero/src/system_zero.rs
@@ -117,7 +117,7 @@ mod tests {
     use starky::prover::prove;
     use starky::stark::Stark;
     use starky::stark_testing::test_stark_low_degree;
-    use starky::verifier::verify;
+    use starky::verifier::verify_stark_proof;
 
     use crate::system_zero::SystemZero;
 
@@ -136,7 +136,7 @@ mod tests {
         let trace = system.generate_trace();
         let proof = prove::<F, C, S, D>(system, &config, trace, public_inputs, &mut timing)?;
 
-        verify(system, proof, &config)
+        verify_stark_proof(system, proof, &config)
     }
 
     #[test]