diff --git a/halo2_proofs/benches/arithmetic.rs b/halo2_proofs/benches/arithmetic.rs
index 4ae88af137..00981ef973 100644
--- a/halo2_proofs/benches/arithmetic.rs
+++ b/halo2_proofs/benches/arithmetic.rs
@@ -1,13 +1,13 @@
 #[macro_use]
 extern crate criterion;
 
-use crate::arithmetic::small_multiexp;
+use crate::arithmetic::{parallelize, small_multiexp, CurveAffine, CurveExt};
 use crate::halo2curves::pasta::{EqAffine, Fp};
+use group::cofactor::CofactorCurveAffine;
 use group::ff::Field;
+use group::{Curve, Group};
 use halo2_proofs::*;
 
-use halo2_proofs::poly::{commitment::ParamsProver, ipa::commitment::ParamsIPA};
-
 use criterion::{black_box, Criterion};
 use rand_core::OsRng;
 
@@ -16,8 +16,40 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     // small multiexp
     {
-        let params: ParamsIPA<EqAffine> = ParamsIPA::new(5);
-        let g = &mut params.get_g().to_vec();
+        let k = 5u32;
+        let n: u64 = 1 << k;
+        let id = <EqAffine as CofactorCurveAffine>::Curve::identity();
+
+        let g_projective = {
+            let mut g = Vec::with_capacity(n as usize);
+            g.resize(n as usize, id);
+
+            parallelize(&mut g, move |g, start| {
+                let hasher = <EqAffine as CurveAffine>::CurveExt::hash_to_curve("Halo2-Parameters");
+
+                for (i, g) in g.iter_mut().enumerate() {
+                    let i = (i + start) as u32;
+
+                    let mut message = [0u8; 5];
+                    message[1..5].copy_from_slice(&i.to_le_bytes());
+
+                    *g = hasher(&message);
+                }
+            });
+
+            g
+        };
+
+        let mut g = {
+            let mut g: Vec<EqAffine> = vec![id.into(); n as usize];
+            parallelize(&mut g, |g, starts| {
+                <EqAffine as CofactorCurveAffine>::Curve::batch_normalize(
+                    &g_projective[starts..(starts + g.len())],
+                    g,
+                );
+            });
+            g
+        };
         let len = g.len() / 2;
         let (g_lo, g_hi) = g.split_at_mut(len);
 
diff --git a/halo2_proofs/examples/serialization.rs b/halo2_proofs/examples/serialization.rs
index 39b6b1192f..8367c2c177 100644
--- a/halo2_proofs/examples/serialization.rs
+++ b/halo2_proofs/examples/serialization.rs
@@ -11,6 +11,7 @@ use halo2_proofs::{
         ConstraintSystem, Error, Fixed, Instance, ProvingKey,
     },
     poly::{
+        commitment::ParamsProver,
         kzg::{
             commitment::{KZGCommitmentScheme, ParamsKZG},
             multiopen::{ProverGWC, VerifierGWC},
@@ -173,16 +174,17 @@ fn main() {
     .expect("prover should not fail");
     let proof = transcript.finalize();
 
-    let strategy = SingleStrategy::new(&params);
+    let verifier_params = params.into_verifier_params();
+    let strategy = SingleStrategy::new(&verifier_params);
     let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]);
     assert!(verify_proof::<
         KZGCommitmentScheme<Bn256>,
-        VerifierGWC<'_, Bn256>,
+        VerifierGWC<Bn256>,
         Challenge255<G1Affine>,
         Blake2bRead<&[u8], G1Affine, Challenge255<G1Affine>>,
         SingleStrategy<'_, Bn256>,
     >(
-        &params,
+        &verifier_params,
         pk.get_vk(),
         strategy,
         &[instances],
diff --git a/halo2_proofs/src/plonk/verifier.rs b/halo2_proofs/src/plonk/verifier.rs
index 76675bcdfa..fca7e0b1bc 100644
--- a/halo2_proofs/src/plonk/verifier.rs
+++ b/halo2_proofs/src/plonk/verifier.rs
@@ -7,7 +7,7 @@ use super::{
     VerifyingKey,
 };
 use crate::arithmetic::compute_inner_product;
-use crate::poly::commitment::{CommitmentScheme, Verifier};
+use crate::poly::commitment::{CommitmentScheme, ParamsVerifier, Verifier};
 use crate::poly::VerificationStrategy;
 use crate::poly::{
     commitment::{Blind, Params},
@@ -52,7 +52,9 @@ where
                 instance
                     .iter()
                     .map(|instance| {
-                        if instance.len() > params.n() as usize - (vk.cs.blinding_factors() + 1) {
+                        if instance.len()
+                            > params.trimed_size() as usize - (vk.cs.blinding_factors() + 1)
+                        {
                             return Err(Error::InstanceTooLarge);
                         }
                         let mut poly = instance.to_vec();
diff --git a/halo2_proofs/src/poly/commitment.rs b/halo2_proofs/src/poly/commitment.rs
index ebc26fe9c3..f09ca0aba8 100644
--- a/halo2_proofs/src/poly/commitment.rs
+++ b/halo2_proofs/src/poly/commitment.rs
@@ -87,15 +87,16 @@ pub trait ParamsProver<'params, C: CurveAffine>: Params<'params, C> {
     fn commit(&self, poly: &Polynomial<C::ScalarExt, Coeff>, r: Blind<C::ScalarExt>)
         -> C::CurveExt;
 
-    /// Getter for g generators
-    fn get_g(&self) -> &[C];
-
     /// Returns verification parameters.
-    fn verifier_params(&'params self) -> &'params Self::ParamsVerifier;
+    fn into_verifier_params(self) -> Self::ParamsVerifier;
 }
 
 /// Verifier specific functionality with circuit constraints
-pub trait ParamsVerifier<'params, C: CurveAffine>: Params<'params, C> {}
+pub trait ParamsVerifier<'params, C: CurveAffine>: Params<'params, C> {
+    /// Returns the size of the trimed parameters.
+    /// This is the maximum size of the PI that these params can be used to commit to.
+    fn trimed_size(&self) -> u64;
+}
 
 /// Multi scalar multiplication engine
 pub trait MSM<C: CurveAffine>: Clone + Debug + Send + Sync {
diff --git a/halo2_proofs/src/poly/ipa/commitment.rs b/halo2_proofs/src/poly/ipa/commitment.rs
index 7be053c49c..24e7ebe777 100644
--- a/halo2_proofs/src/poly/ipa/commitment.rs
+++ b/halo2_proofs/src/poly/ipa/commitment.rs
@@ -56,7 +56,12 @@ impl<C: CurveAffine> CommitmentScheme for IPACommitmentScheme<C> {
 /// Verifier parameters
 pub type ParamsVerifierIPA<C> = ParamsIPA<C>;
 
-impl<'params, C: CurveAffine> ParamsVerifier<'params, C> for ParamsIPA<C> {}
+impl<'params, C: CurveAffine> ParamsVerifier<'params, C> for ParamsIPA<C> {
+    fn trimed_size(&self) -> u64 {
+        // IPA parameters are never trimed so their sized is always the full size of the domain.
+        self.n
+    }
+}
 
 impl<'params, C: CurveAffine> Params<'params, C> for ParamsIPA<C> {
     type MSM = MSMIPA<'params, C>;
@@ -145,7 +150,7 @@ impl<'params, C: CurveAffine> Params<'params, C> for ParamsIPA<C> {
 impl<'params, C: CurveAffine> ParamsProver<'params, C> for ParamsIPA<C> {
     type ParamsVerifier = ParamsVerifierIPA<C>;
 
-    fn verifier_params(&'params self) -> &'params Self::ParamsVerifier {
+    fn into_verifier_params(self) -> Self::ParamsVerifier {
         self
     }
 
@@ -221,10 +226,6 @@ impl<'params, C: CurveAffine> ParamsProver<'params, C> for ParamsIPA<C> {
 
         best_multiexp::<C>(&tmp_scalars, &tmp_bases)
     }
-
-    fn get_g(&self) -> &[C] {
-        &self.g
-    }
 }
 
 #[cfg(test)]
diff --git a/halo2_proofs/src/poly/kzg/commitment.rs b/halo2_proofs/src/poly/kzg/commitment.rs
index 114b9ac013..5e079501ac 100644
--- a/halo2_proofs/src/poly/kzg/commitment.rs
+++ b/halo2_proofs/src/poly/kzg/commitment.rs
@@ -27,6 +27,22 @@ pub struct ParamsKZG<E: Engine> {
     pub(crate) s_g2: E::G2Affine,
 }
 
+/// KZG multi-open verification parameters.
+/// These parameters need to support the veification of a KZG PLONK proof.
+/// As a consequence, they need to support the computation of the PI commitment.
+#[derive(Debug, Clone)]
+pub struct ParamsVerifierKZG<E: Engine> {
+    // Log-size of the domain.
+    pub(crate) k: u32,
+    // Domain size.
+    pub(crate) n: u64,
+    // This is the maximum size of PI supported.
+    pub(crate) trimed_size: u32,
+
+    pub(crate) g_lagrange: Vec<E::G1Affine>,
+    pub(crate) s_g2: E::G2Affine,
+}
+
 /// Umbrella commitment scheme construction for all KZG variants
 #[derive(Debug)]
 pub struct KZGCommitmentScheme<E: Engine> {
@@ -57,6 +73,7 @@ where
 impl<E: Engine + Debug> ParamsKZG<E>
 where
     E::G1Affine: SerdeCurveAffine,
+    E::G2Affine: SerdeCurveAffine,
     E::G1: CurveExt<AffineExt = E::G1Affine>,
 {
     /// Initializes parameters for the curve, draws toxic secret from given rng.
@@ -267,10 +284,129 @@ where
     }
 }
 
-// TODO: see the issue at https://github.com/appliedzkp/halo2/issues/45
-// So we probably need much smaller verifier key. However for new bases in g1 should be in verifier keys.
-/// KZG multi-open verification parameters
-pub type ParamsVerifierKZG<C> = ParamsKZG<C>;
+impl<E: Engine + Debug> ParamsVerifierKZG<E>
+where
+    E::Fr: PrimeField,
+    E::G1: CurveExt<AffineExt = E::G1Affine>,
+    E::G1Affine: SerdeCurveAffine,
+    E::G2Affine: SerdeCurveAffine,
+{
+    /// Reduce the size of the verifier parameters by eliminating elements of `g_lagrange`.
+    /// The resulting parameters are only able to compute commitments up to the inputed `size`.
+    /// As a result, this will be the maximum size of PI supported.
+    pub fn trim(mut self, size: usize) -> Self {
+        assert!(size as u64 <= self.n);
+        self.trimed_size = size as u32;
+        self.g_lagrange.truncate(size);
+        self
+    }
+
+    /// Writes verifier parameters to buffer.
+    pub fn write_custom<W: io::Write>(&self, writer: &mut W, format: SerdeFormat) -> io::Result<()>
+    where
+        E::G2Affine: SerdeCurveAffine,
+    {
+        writer.write_all(&self.k.to_le_bytes())?;
+        writer.write_all(&self.trimed_size.to_le_bytes())?;
+        for el in self.g_lagrange.iter() {
+            el.write(writer, format)?;
+        }
+        self.s_g2.write(writer, format)?;
+        Ok(())
+    }
+
+    /// Reads verifier parameters from a buffer.
+    pub fn read_custom<R: io::Read>(reader: &mut R, format: SerdeFormat) -> io::Result<Self>
+    where
+        E::G2Affine: SerdeCurveAffine,
+    {
+        let mut k = [0u8; 4];
+        reader.read_exact(&mut k[..])?;
+        let k = u32::from_le_bytes(k);
+        let n = 1 << k;
+        // This is a generous bound on the size of the domain.
+        debug_assert!(k < 32);
+
+        let mut trimed_size = [0u8; 4];
+        reader.read_exact(&mut trimed_size[..])?;
+        let trimed_size = u32::from_le_bytes(trimed_size);
+
+        let g_lagrange = match format {
+            SerdeFormat::Processed => {
+                use group::GroupEncoding;
+                let load_points_from_file_parallelly =
+                    |reader: &mut R| -> io::Result<Vec<Option<E::G1Affine>>> {
+                        let mut points_compressed = vec![
+                                <<E as Engine>::G1Affine as GroupEncoding>::Repr::default();
+                                trimed_size as usize
+                            ];
+                        for points_compressed in points_compressed.iter_mut() {
+                            reader.read_exact((*points_compressed).as_mut())?;
+                        }
+
+                        let mut points = vec![Option::<E::G1Affine>::None; trimed_size as usize];
+                        parallelize(&mut points, |points, chunks| {
+                            for (i, point) in points.iter_mut().enumerate() {
+                                *point = Option::from(E::G1Affine::from_bytes(
+                                    &points_compressed[chunks + i],
+                                ));
+                            }
+                        });
+                        Ok(points)
+                    };
+
+                let g_lagrange = load_points_from_file_parallelly(reader)?;
+                g_lagrange
+                    .iter()
+                    .map(|point| {
+                        point.ok_or_else(|| {
+                            io::Error::new(io::ErrorKind::Other, "invalid point encoding")
+                        })
+                    })
+                    .collect::<Result<_, _>>()?
+            }
+            SerdeFormat::RawBytes => (0..trimed_size)
+                .map(|_| <E::G1Affine as SerdeCurveAffine>::read(reader, format))
+                .collect::<Result<Vec<_>, _>>()?,
+            SerdeFormat::RawBytesUnchecked => (0..trimed_size)
+                .map(|_| <E::G1Affine as SerdeCurveAffine>::read(reader, format).unwrap())
+                .collect::<Vec<_>>(),
+        };
+        let s_g2 = E::G2Affine::read(reader, format)?;
+
+        Ok(Self {
+            k,
+            n,
+            trimed_size,
+            g_lagrange,
+            s_g2,
+        })
+    }
+}
+
+impl<E: Engine + Debug> From<ParamsKZG<E>> for ParamsVerifierKZG<E> {
+    fn from(value: ParamsKZG<E>) -> Self {
+        Self {
+            k: value.k,
+            n: value.n,
+            trimed_size: value.n as u32,
+            g_lagrange: value.g_lagrange.clone(),
+            s_g2: value.s_g2,
+        }
+    }
+}
+
+impl<E: Engine + Debug> From<&ParamsKZG<E>> for ParamsVerifierKZG<E> {
+    fn from(value: &ParamsKZG<E>) -> Self {
+        Self {
+            k: value.k,
+            n: value.n,
+            trimed_size: value.n as u32,
+            g_lagrange: value.g_lagrange.clone(),
+            s_g2: value.s_g2,
+        }
+    }
+}
 
 impl<'params, E: Engine + Debug> Params<'params, E::G1Affine> for ParamsKZG<E>
 where
@@ -322,12 +458,60 @@ where
     }
 }
 
-impl<'params, E: Engine + Debug> ParamsVerifier<'params, E::G1Affine> for ParamsKZG<E>
+impl<'params, E: Engine + Debug> Params<'params, E::G1Affine> for ParamsVerifierKZG<E>
 where
     E::G1Affine: SerdeCurveAffine<ScalarExt = <E as Engine>::Fr, CurveExt = <E as Engine>::G1>,
     E::G1: CurveExt<AffineExt = E::G1Affine>,
     E::G2Affine: SerdeCurveAffine,
 {
+    type MSM = MSMKZG<E>;
+
+    fn k(&self) -> u32 {
+        self.k
+    }
+
+    fn n(&self) -> u64 {
+        self.n
+    }
+
+    fn downsize(&mut self, _k: u32) {
+        // Verifier parameters cannot be downsized since they do not contain the original powers of g.
+        panic!("Verifier parameters cannot be downsized. You may want to use `trim` instead.")
+    }
+
+    fn empty_msm(&'params self) -> MSMKZG<E> {
+        MSMKZG::new()
+    }
+
+    fn commit_lagrange(&self, poly: &Polynomial<E::Fr, LagrangeCoeff>, _: Blind<E::Fr>) -> E::G1 {
+        let mut scalars = Vec::with_capacity(poly.len());
+        scalars.extend(poly.iter());
+        let bases = &self.g_lagrange;
+        let size = scalars.len();
+        assert!(bases.len() >= size);
+        best_multiexp(&scalars, &bases[0..size])
+    }
+
+    /// Writes params to a buffer.
+    fn write<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
+        self.write_custom(writer, SerdeFormat::RawBytes)
+    }
+
+    /// Reads params from a buffer.
+    fn read<R: io::Read>(reader: &mut R) -> io::Result<Self> {
+        Self::read_custom(reader, SerdeFormat::RawBytes)
+    }
+}
+
+impl<'params, E: Engine + Debug> ParamsVerifier<'params, E::G1Affine> for ParamsVerifierKZG<E>
+where
+    E::G1Affine: SerdeCurveAffine<ScalarExt = <E as Engine>::Fr, CurveExt = <E as Engine>::G1>,
+    E::G1: CurveExt<AffineExt = E::G1Affine>,
+    E::G2Affine: SerdeCurveAffine,
+{
+    fn trimed_size(&self) -> u64 {
+        self.trimed_size as u64
+    }
 }
 
 impl<'params, E: Engine + Debug> ParamsProver<'params, E::G1Affine> for ParamsKZG<E>
@@ -338,8 +522,8 @@ where
 {
     type ParamsVerifier = ParamsVerifierKZG<E>;
 
-    fn verifier_params(&'params self) -> &'params Self::ParamsVerifier {
-        self
+    fn into_verifier_params(self) -> Self::ParamsVerifier {
+        self.into()
     }
 
     fn new(k: u32) -> Self {
@@ -354,10 +538,6 @@ where
         assert!(bases.len() >= size);
         best_multiexp(&scalars, &bases[0..size])
     }
-
-    fn get_g(&self) -> &[E::G1Affine] {
-        &self.g
-    }
 }
 
 #[cfg(test)]
diff --git a/halo2_proofs/src/poly/kzg/msm.rs b/halo2_proofs/src/poly/kzg/msm.rs
index f9b8c284bd..a37509df15 100644
--- a/halo2_proofs/src/poly/kzg/msm.rs
+++ b/halo2_proofs/src/poly/kzg/msm.rs
@@ -1,10 +1,11 @@
 use std::fmt::Debug;
 
-use super::commitment::ParamsKZG;
+use super::commitment::ParamsVerifierKZG;
 use crate::{
     arithmetic::{best_multiexp, parallelize},
     poly::commitment::MSM,
 };
+use group::prime::PrimeCurveAffine;
 use group::{Curve, Group};
 use halo2curves::{
     pairing::{Engine, MillerLoopResult, MultiMillerLoop},
@@ -78,7 +79,6 @@ where
     }
 
     fn eval(&self) -> E::G1 {
-        use group::prime::PrimeCurveAffine;
         let mut bases = vec![E::G1Affine::identity(); self.scalars.len()];
         E::G1::batch_normalize(&self.bases, &mut bases);
         best_multiexp(&self.scalars, &bases)
@@ -132,12 +132,13 @@ where
     }
 }
 
-impl<'params, E: MultiMillerLoop + Debug> From<&'params ParamsKZG<E>> for DualMSM<'params, E>
+impl<'params, E: MultiMillerLoop + Debug> From<&'params ParamsVerifierKZG<E>>
+    for DualMSM<'params, E>
 where
     E::G1Affine: CurveAffine<ScalarExt = <E as Engine>::Fr, CurveExt = <E as Engine>::G1>,
     E::G1: CurveExt<AffineExt = E::G1Affine>,
 {
-    fn from(params: &'params ParamsKZG<E>) -> Self {
+    fn from(params: &'params ParamsVerifierKZG<E>) -> Self {
         DualMSM::new(params)
     }
 }
@@ -149,7 +150,7 @@ where
     E::G1Affine: CurveAffine<ScalarExt = <E as Engine>::Fr, CurveExt = <E as Engine>::G1>,
     E::G1: CurveExt<AffineExt = E::G1Affine>,
 {
-    pub(crate) params: &'a ParamsKZG<E>,
+    pub(crate) params: &'a ParamsVerifierKZG<E>,
     pub(crate) left: MSMKZG<E>,
     pub(crate) right: MSMKZG<E>,
 }
@@ -160,7 +161,7 @@ where
     E::G1: CurveExt<AffineExt = E::G1Affine>,
 {
     /// Create a new two channel MSM accumulator instance
-    pub fn new(params: &'a ParamsKZG<E>) -> Self {
+    pub fn new(params: &'a ParamsVerifierKZG<E>) -> Self {
         Self {
             params,
             left: MSMKZG::new(),
@@ -183,7 +184,7 @@ where
     /// Performs final pairing check with given verifier params and two channel linear combination
     pub fn check(self) -> bool {
         let s_g2_prepared = E::G2Prepared::from(self.params.s_g2);
-        let n_g2_prepared = E::G2Prepared::from(-self.params.g2);
+        let n_g2_prepared = E::G2Prepared::from(-E::G2Affine::generator());
 
         let left = self.left.eval();
         let right = self.right.eval();
diff --git a/halo2_proofs/src/poly/kzg/multiopen/gwc/verifier.rs b/halo2_proofs/src/poly/kzg/multiopen/gwc/verifier.rs
index fcfda6941f..ebadea647a 100644
--- a/halo2_proofs/src/poly/kzg/multiopen/gwc/verifier.rs
+++ b/halo2_proofs/src/poly/kzg/multiopen/gwc/verifier.rs
@@ -1,11 +1,12 @@
 use std::fmt::Debug;
+use std::marker::PhantomData;
 
 use super::{construct_intermediate_sets, ChallengeU, ChallengeV};
 use crate::arithmetic::powers;
 use crate::helpers::SerdeCurveAffine;
 use crate::poly::commitment::Verifier;
 use crate::poly::commitment::MSM;
-use crate::poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG};
+use crate::poly::kzg::commitment::{KZGCommitmentScheme, ParamsVerifierKZG};
 use crate::poly::kzg::msm::{DualMSM, MSMKZG};
 use crate::poly::kzg::strategy::GuardKZG;
 use crate::poly::query::Query;
@@ -14,16 +15,17 @@ use crate::poly::Error;
 use crate::transcript::{EncodedChallenge, TranscriptRead};
 
 use ff::Field;
+use group::prime::PrimeCurveAffine;
 use halo2curves::pairing::{Engine, MultiMillerLoop};
 use halo2curves::CurveExt;
 
 #[derive(Debug)]
 /// Concrete KZG verifier with GWC variant
-pub struct VerifierGWC<'params, E: Engine> {
-    params: &'params ParamsKZG<E>,
+pub struct VerifierGWC<E: Engine> {
+    _p0: PhantomData<E>,
 }
 
-impl<'params, E> Verifier<'params, KZGCommitmentScheme<E>> for VerifierGWC<'params, E>
+impl<'params, E> Verifier<'params, KZGCommitmentScheme<E>> for VerifierGWC<E>
 where
     E: MultiMillerLoop + Debug,
     E::G1Affine: SerdeCurveAffine<ScalarExt = <E as Engine>::Fr, CurveExt = <E as Engine>::G1>,
@@ -35,8 +37,8 @@ where
 
     const QUERY_INSTANCE: bool = false;
 
-    fn new(params: &'params ParamsKZG<E>) -> Self {
-        Self { params }
+    fn new(_params: &'params ParamsVerifierKZG<E>) -> Self {
+        Self { _p0: PhantomData }
     }
 
     fn verify_proof<
@@ -116,7 +118,7 @@ where
 
         msm_accumulator.right.add_msm(&witness_with_aux);
         msm_accumulator.right.add_msm(&commitment_multi);
-        let g0: E::G1 = self.params.g[0].into();
+        let g0: E::G1 = E::G1Affine::generator().into();
         msm_accumulator.right.append_term(eval_multi, -g0);
 
         Ok(Self::Guard::new(msm_accumulator))
diff --git a/halo2_proofs/src/poly/kzg/multiopen/shplonk/verifier.rs b/halo2_proofs/src/poly/kzg/multiopen/shplonk/verifier.rs
index 5d03940177..fed8abc3eb 100644
--- a/halo2_proofs/src/poly/kzg/multiopen/shplonk/verifier.rs
+++ b/halo2_proofs/src/poly/kzg/multiopen/shplonk/verifier.rs
@@ -1,4 +1,5 @@
 use std::fmt::Debug;
+use std::marker::PhantomData;
 
 use super::ChallengeY;
 use super::{construct_intermediate_sets, ChallengeU, ChallengeV};
@@ -8,7 +9,7 @@ use crate::arithmetic::{
 use crate::helpers::SerdeCurveAffine;
 use crate::poly::commitment::Verifier;
 use crate::poly::commitment::MSM;
-use crate::poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG};
+use crate::poly::kzg::commitment::{KZGCommitmentScheme, ParamsVerifierKZG};
 use crate::poly::kzg::msm::DualMSM;
 use crate::poly::kzg::msm::{PreMSM, MSMKZG};
 use crate::poly::kzg::strategy::GuardKZG;
@@ -16,17 +17,19 @@ use crate::poly::query::{CommitmentReference, VerifierQuery};
 use crate::poly::Error;
 use crate::transcript::{EncodedChallenge, TranscriptRead};
 use ff::Field;
+use group::prime::PrimeCurveAffine;
 use halo2curves::pairing::{Engine, MultiMillerLoop};
 use halo2curves::CurveExt;
 use std::ops::MulAssign;
 
 /// Concrete KZG multiopen verifier with SHPLONK variant
 #[derive(Debug)]
-pub struct VerifierSHPLONK<'params, E: Engine> {
-    params: &'params ParamsKZG<E>,
+pub struct VerifierSHPLONK<E: Engine> {
+    // params: &'params ParamsVerifierKZG<E>,
+    _p0: PhantomData<E>,
 }
 
-impl<'params, E> Verifier<'params, KZGCommitmentScheme<E>> for VerifierSHPLONK<'params, E>
+impl<'params, E> Verifier<'params, KZGCommitmentScheme<E>> for VerifierSHPLONK<E>
 where
     E: MultiMillerLoop + Debug,
     E::Fr: Ord,
@@ -39,8 +42,8 @@ where
 
     const QUERY_INSTANCE: bool = false;
 
-    fn new(params: &'params ParamsKZG<E>) -> Self {
-        Self { params }
+    fn new(_params: &'params ParamsVerifierKZG<E>) -> Self {
+        Self { _p0: PhantomData }
     }
 
     /// Verify a multi-opening proof
@@ -126,7 +129,7 @@ where
             r_outer_acc += power_of_v * r_inner_acc * z_diff_i;
         }
         let mut outer_msm = outer_msm.normalize();
-        let g1: E::G1 = self.params.g[0].into();
+        let g1: E::G1 = E::G1Affine::generator().into();
         outer_msm.append_term(-r_outer_acc, g1);
         outer_msm.append_term(-z_0, h1.into());
         outer_msm.append_term(*u, h2.into());
diff --git a/halo2_proofs/src/poly/kzg/strategy.rs b/halo2_proofs/src/poly/kzg/strategy.rs
index ee80d800ac..a837d40a1a 100644
--- a/halo2_proofs/src/poly/kzg/strategy.rs
+++ b/halo2_proofs/src/poly/kzg/strategy.rs
@@ -1,5 +1,5 @@
 use super::{
-    commitment::{KZGCommitmentScheme, ParamsKZG},
+    commitment::{KZGCommitmentScheme, ParamsVerifierKZG},
     msm::DualMSM,
 };
 use crate::{
@@ -66,7 +66,7 @@ where
     E::G1: CurveExt<AffineExt = E::G1Affine>,
 {
     /// Constructs an empty batch verifier
-    pub fn new(params: &'params ParamsKZG<E>) -> Self {
+    pub fn new(params: &'params ParamsVerifierKZG<E>) -> Self {
         AccumulatorStrategy {
             msm_accumulator: DualMSM::new(params),
         }
@@ -94,7 +94,7 @@ where
     E::G1: CurveExt<AffineExt = E::G1Affine>,
 {
     /// Constructs an empty batch verifier
-    pub fn new(params: &'params ParamsKZG<E>) -> Self {
+    pub fn new(params: &'params ParamsVerifierKZG<E>) -> Self {
         SingleStrategy {
             msm: DualMSM::new(params),
         }
@@ -118,7 +118,7 @@ where
 {
     type Output = Self;
 
-    fn new(params: &'params ParamsKZG<E>) -> Self {
+    fn new(params: &'params ParamsVerifierKZG<E>) -> Self {
         AccumulatorStrategy::new(params)
     }
 
@@ -157,7 +157,7 @@ where
 {
     type Output = ();
 
-    fn new(params: &'params ParamsKZG<E>) -> Self {
+    fn new(params: &'params ParamsVerifierKZG<E>) -> Self {
         Self::new(params)
     }
 
diff --git a/halo2_proofs/src/poly/multiopen_test.rs b/halo2_proofs/src/poly/multiopen_test.rs
index 47c6731167..320d07037a 100644
--- a/halo2_proofs/src/poly/multiopen_test.rs
+++ b/halo2_proofs/src/poly/multiopen_test.rs
@@ -36,7 +36,7 @@ mod test {
             Blake2bWrite<_, _, Challenge255<_>>,
         >(&params);
 
-        let verifier_params = params.verifier_params();
+        let verifier_params = params.into_verifier_params();
 
         verify::<
             IPACommitmentScheme<EqAffine>,
@@ -44,7 +44,7 @@ mod test {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
-        >(verifier_params, &proof[..], false);
+        >(&verifier_params, &proof[..], false);
 
         verify::<
             IPACommitmentScheme<EqAffine>,
@@ -52,7 +52,7 @@ mod test {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
-        >(verifier_params, &proof[..], true);
+        >(&verifier_params, &proof[..], true);
     }
 
     #[test]
@@ -73,7 +73,7 @@ mod test {
             Keccak256Write<_, _, Challenge255<_>>,
         >(&params);
 
-        let verifier_params = params.verifier_params();
+        let verifier_params = params.into_verifier_params();
 
         verify::<
             IPACommitmentScheme<EqAffine>,
@@ -81,7 +81,7 @@ mod test {
             _,
             Keccak256Read<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
-        >(verifier_params, &proof[..], false);
+        >(&verifier_params, &proof[..], false);
 
         verify::<
             IPACommitmentScheme<EqAffine>,
@@ -89,7 +89,7 @@ mod test {
             _,
             Keccak256Read<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
-        >(verifier_params, &proof[..], true);
+        >(&verifier_params, &proof[..], true);
     }
 
     #[test]
@@ -106,10 +106,10 @@ mod test {
         let proof =
             create_proof::<_, ProverGWC<_>, _, Blake2bWrite<_, _, Challenge255<_>>>(&params);
 
-        let verifier_params = params.verifier_params();
+        let verifier_params = params.into_verifier_params();
 
         verify::<_, VerifierGWC<_>, _, Blake2bRead<_, _, Challenge255<_>>, AccumulatorStrategy<_>>(
-            verifier_params,
+            &verifier_params,
             &proof[..],
             false,
         );
@@ -120,7 +120,7 @@ mod test {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
-        >(verifier_params, &proof[..], true);
+        >(&verifier_params, &proof[..], true);
     }
 
     #[test]
@@ -141,7 +141,7 @@ mod test {
             Blake2bWrite<_, _, Challenge255<_>>,
         >(&params);
 
-        let verifier_params = params.verifier_params();
+        let verifier_params = params.into_verifier_params();
 
         verify::<
             KZGCommitmentScheme<Bn256>,
@@ -149,7 +149,7 @@ mod test {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
-        >(verifier_params, &proof[..], false);
+        >(&verifier_params, &proof[..], false);
 
         verify::<
             KZGCommitmentScheme<Bn256>,
@@ -157,7 +157,7 @@ mod test {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
-        >(verifier_params, &proof[..], true);
+        >(&verifier_params, &proof[..], true);
     }
 
     fn verify<
diff --git a/halo2_proofs/tests/plonk_api.rs b/halo2_proofs/tests/plonk_api.rs
index 16f2031e35..7b2b3f5006 100644
--- a/halo2_proofs/tests/plonk_api.rs
+++ b/halo2_proofs/tests/plonk_api.rs
@@ -549,7 +549,7 @@ fn plonk_api() {
             rng, &params, &pk,
         );
 
-        let verifier_params = params.verifier_params();
+        let verifier_params = params.into_verifier_params();
 
         verify_proof::<
             _,
@@ -557,7 +557,7 @@ fn plonk_api() {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
-        >(verifier_params, pk.get_vk(), &proof[..]);
+        >(&verifier_params, pk.get_vk(), &proof[..]);
     }
 
     fn test_plonk_api_shplonk() {
@@ -578,7 +578,7 @@ fn plonk_api() {
             rng, &params, &pk,
         );
 
-        let verifier_params = params.verifier_params();
+        let verifier_params = params.into_verifier_params();
 
         verify_proof::<
             _,
@@ -586,7 +586,7 @@ fn plonk_api() {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
-        >(verifier_params, pk.get_vk(), &proof[..]);
+        >(&verifier_params, pk.get_vk(), &proof[..]);
     }
 
     fn test_plonk_api_ipa() {
@@ -607,7 +607,7 @@ fn plonk_api() {
             rng, &params, &pk,
         );
 
-        let verifier_params = params.verifier_params();
+        let verifier_params = params.into_verifier_params();
 
         verify_proof::<
             _,
@@ -615,7 +615,7 @@ fn plonk_api() {
             _,
             Blake2bRead<_, _, Challenge255<_>>,
             AccumulatorStrategy<_>,
-        >(verifier_params, pk.get_vk(), &proof[..]);
+        >(&verifier_params, pk.get_vk(), &proof[..]);
 
         // Check that the verification key has not changed unexpectedly
         {