diff --git a/src/gadgets/nonnative/bn/big_uint.rs b/src/gadgets/nonnative/bn/big_uint.rs
index 72200e65..fb759313 100644
--- a/src/gadgets/nonnative/bn/big_uint.rs
+++ b/src/gadgets/nonnative/bn/big_uint.rs
@@ -25,7 +25,7 @@ use crate::{
 // integer-type, but only a wrapper for
 // storing a natural number with limbs.
 #[derive(PartialEq, Debug, Clone)]
-pub struct BigUint<F: PrimeField> {
+pub struct BigUint<F> {
     limbs: Vec<F>,
     width: NonZeroUsize,
 }
diff --git a/src/ivc/cyclefold/mod.rs b/src/ivc/cyclefold/mod.rs
index b3aa089a..6ff75137 100644
--- a/src/ivc/cyclefold/mod.rs
+++ b/src/ivc/cyclefold/mod.rs
@@ -1,6 +1,5 @@
-use std::num::NonZeroUsize;
-
 use halo2_proofs::halo2curves::ff::{FromUniformBytes, PrimeFieldBits};
+use std::num::NonZeroUsize;
 
 use crate::{
     main_gate::MainGateConfig,
diff --git a/src/ivc/cyclefold/sfc/input/assigned.rs b/src/ivc/cyclefold/sfc/input/assigned.rs
index d679e6c4..ccc2f122 100644
--- a/src/ivc/cyclefold/sfc/input/assigned.rs
+++ b/src/ivc/cyclefold/sfc/input/assigned.rs
@@ -1,55 +1,23 @@
 use std::iter;
 
 use halo2_proofs::halo2curves::ff::PrimeField;
+use itertools::Itertools;
 
 use crate::{
     halo2_proofs::plonk::Error as Halo2PlonkError,
-    main_gate::{self, AdviceCyclicAssignor, AssignedValue, RegionCtx, WrapValue},
+    ivc,
+    main_gate::{self, AdviceCyclicAssignor, AssignedValue, MainGate, RegionCtx, WrapValue},
 };
 
 pub type MainGateConfig = main_gate::MainGateConfig<{ super::super::T_MAIN_GATE }>;
 
-type BigUint<F> = Vec<AssignedValue<F>>;
+pub type BigUint<F> = Vec<F>;
 
-#[derive(Clone)]
-pub struct BigUintPoint<F: PrimeField> {
-    pub x_limbs: BigUint<F>,
-    pub y_limbs: BigUint<F>,
-}
-
-impl<F: PrimeField> BigUintPoint<F> {
-    fn assign_advice_from(
-        region: &mut RegionCtx<'_, F>,
-        original: &super::BigUintPoint<F>,
-        main_gate_config: &MainGateConfig,
-    ) -> Result<Self, Halo2PlonkError> {
-        let super::BigUintPoint { x, y } = original;
-        let mut assigner = main_gate_config.advice_cycle_assigner();
-
-        Ok(Self {
-            x_limbs: assigner.assign_all_advice(region, || "x", x.limbs().iter().copied())?,
-            y_limbs: assigner.assign_all_advice(region, || "y", y.limbs().iter().copied())?,
-        })
-    }
-
-    fn iter_wrap_values(&self) -> impl '_ + Iterator<Item = WrapValue<F>> {
-        self.x_limbs
-            .iter()
-            .chain(self.y_limbs.iter())
-            .cloned()
-            .map(|l| WrapValue::Assigned(l))
-    }
-}
-
-#[derive(Clone)]
-pub struct NativePlonkInstance<F: PrimeField> {
-    pub(crate) W_commitments: Vec<BigUintPoint<F>>,
-    pub(crate) instances: Vec<Vec<AssignedValue<F>>>,
-    pub(crate) challenges: Vec<AssignedValue<F>>,
-}
+pub type BigUintPoint<F> = ivc::protogalaxy::verify_chip::BigUintPoint<F>;
+pub type NativePlonkInstance<F> = ivc::protogalaxy::verify_chip::AssignedPlonkInstance<F>;
 
 impl<F: PrimeField> NativePlonkInstance<F> {
-    fn assign_advice_from(
+    pub fn assign_advice_from_native(
         region: &mut RegionCtx<'_, F>,
         original: &super::NativePlonkInstance<F>,
         main_gate_config: &MainGateConfig,
@@ -62,7 +30,8 @@ impl<F: PrimeField> NativePlonkInstance<F> {
 
         let W_commitments = W_commitments
             .iter()
-            .map(|p| BigUintPoint::assign_advice_from(region, p, main_gate_config))
+            .cloned()
+            .map(|p| p.assign(region, main_gate_config))
             .collect::<Result<Vec<_>, _>>()?;
 
         let mut assigner = main_gate_config.advice_cycle_assigner();
@@ -83,45 +52,19 @@ impl<F: PrimeField> NativePlonkInstance<F> {
             challenges,
         })
     }
-
-    fn iter_wrap_values(&self) -> impl '_ + Iterator<Item = WrapValue<F>> {
-        let Self {
-            W_commitments,
-            instances,
-            challenges,
-        } = self;
-
-        W_commitments
-            .iter()
-            .flat_map(|W_commitment| W_commitment.iter_wrap_values())
-            .chain(instances.iter().flat_map(|instance| {
-                instance
-                    .iter()
-                    .map(|value| WrapValue::Assigned(value.clone()))
-            }))
-            .chain(
-                challenges
-                    .iter()
-                    .map(|cha| WrapValue::Assigned(cha.clone())),
-            )
-    }
 }
 
-#[derive(Clone)]
-pub struct ProtoGalaxyAccumulatorInstance<F: PrimeField> {
-    pub(crate) ins: NativePlonkInstance<F>,
-    pub(crate) betas: Box<[AssignedValue<F>]>,
-    pub(crate) e: AssignedValue<F>,
-}
+pub type ProtoGalaxyAccumulatorInstance<F> =
+    ivc::protogalaxy::verify_chip::AssignedAccumulatorInstance<F>;
 
 impl<F: PrimeField> ProtoGalaxyAccumulatorInstance<F> {
-    fn assign_advice_from(
+    fn assign_advice_from_native(
         region: &mut RegionCtx<'_, F>,
         original: &super::ProtoGalaxyAccumulatorInstance<F>,
         main_gate_config: &MainGateConfig,
     ) -> Result<Self, Halo2PlonkError> {
         let super::ProtoGalaxyAccumulatorInstance { ins, betas, e } = original;
-        let ins = NativePlonkInstance::assign_advice_from(region, ins, main_gate_config)?;
+        let ins = NativePlonkInstance::assign_advice_from_native(region, ins, main_gate_config)?;
 
         let mut assigner = main_gate_config.advice_cycle_assigner();
         Ok(Self {
@@ -133,19 +76,39 @@ impl<F: PrimeField> ProtoGalaxyAccumulatorInstance<F> {
         })
     }
 
-    fn iter_wrap_values(&self) -> impl '_ + Iterator<Item = WrapValue<F>> {
-        let Self { ins, betas, e } = self;
-        ins.iter_wrap_values()
-            .chain(betas.iter().cloned().map(WrapValue::Assigned))
-            .chain(iter::once(WrapValue::Assigned(e.clone())))
+    fn conditional_select<const T: usize>(
+        region: &mut RegionCtx<'_, F>,
+        mg: &MainGate<F, T>,
+        lhs: &Self,
+        rhs: &Self,
+        cond: &AssignedValue<F>,
+    ) -> Result<Self, Halo2PlonkError> {
+        let Self {
+            ins: lhs_ins,
+            betas: lhs_betas,
+            e: lhs_e,
+        } = lhs;
+
+        let Self {
+            ins: rhs_ins,
+            betas: rhs_betas,
+            e: rhs_e,
+        } = rhs;
+
+        Ok(Self {
+            ins: NativePlonkInstance::conditional_select(region, mg, lhs_ins, rhs_ins, cond)?,
+            betas: lhs_betas
+                .iter()
+                .zip_eq(rhs_betas)
+                .map(|(l, r)| mg.conditional_select(region, l, r, cond))
+                .collect::<Result<Vec<_>, _>>()?
+                .into_boxed_slice(),
+            e: mg.conditional_select(region, lhs_e, rhs_e, cond)?,
+        })
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct ProtogalaxyProof<F: PrimeField> {
-    pub poly_F: Vec<AssignedValue<F>>,
-    pub poly_K: Vec<AssignedValue<F>>,
-}
+pub type ProtogalaxyProof<F> = ivc::protogalaxy::verify_chip::AssignedProof<F>;
 
 impl<F: PrimeField> ProtogalaxyProof<F> {
     fn assign_advice_from(
@@ -157,8 +120,12 @@ impl<F: PrimeField> ProtogalaxyProof<F> {
         let super::nifs::protogalaxy::Proof { poly_F, poly_K } = original;
 
         Ok(Self {
-            poly_F: assigner.assign_all_advice(region, || "poly_F", poly_F.iter().cloned())?,
-            poly_K: assigner.assign_all_advice(region, || "poly_K", poly_K.iter().cloned())?,
+            poly_F: assigner
+                .assign_all_advice(region, || "poly_F", poly_F.iter().cloned())?
+                .into(),
+            poly_K: assigner
+                .assign_all_advice(region, || "poly_K", poly_K.iter().cloned())?
+                .into(),
         })
     }
 
@@ -166,8 +133,9 @@ impl<F: PrimeField> ProtogalaxyProof<F> {
         let Self { poly_F, poly_K } = self;
 
         poly_K
+            .0
             .iter()
-            .chain(poly_F.iter())
+            .chain(poly_F.0.iter())
             .cloned()
             .map(WrapValue::Assigned)
     }
@@ -193,12 +161,16 @@ impl<F: PrimeField> SelfTrace<F> {
         } = original;
 
         Ok(Self {
-            input_accumulator: ProtoGalaxyAccumulatorInstance::assign_advice_from(
+            input_accumulator: ProtoGalaxyAccumulatorInstance::assign_advice_from_native(
                 region,
                 input_accumulator,
                 main_gate_config,
             )?,
-            incoming: NativePlonkInstance::assign_advice_from(region, incoming, main_gate_config)?,
+            incoming: NativePlonkInstance::assign_advice_from_native(
+                region,
+                incoming,
+                main_gate_config,
+            )?,
             proof: ProtogalaxyProof::assign_advice_from(region, proof, main_gate_config)?,
         })
     }
@@ -220,8 +192,8 @@ impl<F: PrimeField> SelfTrace<F> {
 #[derive(Clone)]
 pub struct PairedPlonkInstance<F: PrimeField> {
     pub(crate) W_commitments: Vec<(AssignedValue<F>, AssignedValue<F>)>,
-    pub(crate) instances: Vec<Vec<BigUint<F>>>,
-    pub(crate) challenges: Vec<BigUint<F>>,
+    pub(crate) instances: Vec<Vec<BigUint<AssignedValue<F>>>>,
+    pub(crate) challenges: Vec<BigUint<AssignedValue<F>>>,
 }
 
 impl<F: PrimeField> PairedPlonkInstance<F> {
@@ -303,7 +275,7 @@ impl<F: PrimeField> PairedPlonkInstance<F> {
 pub struct SangriaAccumulatorInstance<F: PrimeField> {
     pub(crate) ins: PairedPlonkInstance<F>,
     pub(crate) E_commitment: (AssignedValue<F>, AssignedValue<F>),
-    pub(crate) u: BigUint<F>,
+    pub(crate) u: BigUint<AssignedValue<F>>,
 }
 
 impl<F: PrimeField> SangriaAccumulatorInstance<F> {
diff --git a/src/ivc/cyclefold/sfc/input/mod.rs b/src/ivc/cyclefold/sfc/input/mod.rs
index c5c1d571..13fc0d82 100644
--- a/src/ivc/cyclefold/sfc/input/mod.rs
+++ b/src/ivc/cyclefold/sfc/input/mod.rs
@@ -1,6 +1,7 @@
 use std::array;
 
 use super::super::{DEFAULT_LIMBS_COUNT_LIMIT, DEFAULT_LIMB_WIDTH};
+pub use crate::ivc::protogalaxy::verify_chip::BigUintPoint;
 use crate::{
     gadgets::nonnative::bn::big_uint::BigUint,
     halo2_proofs::halo2curves::{ff::PrimeField, CurveAffine},
@@ -11,39 +12,6 @@ use crate::{
 
 pub mod assigned;
 
-#[derive(Debug, Clone)]
-pub struct BigUintPoint<F: PrimeField> {
-    x: BigUint<F>,
-    y: BigUint<F>,
-}
-
-impl<F: PrimeField, RO: ROTrait<F>> AbsorbInRO<F, RO> for BigUintPoint<F> {
-    fn absorb_into(&self, ro: &mut RO) {
-        ro.absorb_field_iter(self.x.limbs().iter().chain(self.y.limbs().iter()).cloned());
-    }
-}
-
-impl<C: CurveAffine> From<&C> for BigUintPoint<C::ScalarExt> {
-    fn from(value: &C) -> Self {
-        let c = value.coordinates().unwrap();
-        Self {
-            x: BigUint::from_different_field(c.x(), DEFAULT_LIMB_WIDTH, DEFAULT_LIMBS_COUNT_LIMIT)
-                .unwrap(),
-            y: BigUint::from_different_field(c.y(), DEFAULT_LIMB_WIDTH, DEFAULT_LIMBS_COUNT_LIMIT)
-                .unwrap(),
-        }
-    }
-}
-
-impl<F: PrimeField> BigUintPoint<F> {
-    fn identity() -> Self {
-        Self {
-            x: BigUint::zero(DEFAULT_LIMB_WIDTH),
-            y: BigUint::zero(DEFAULT_LIMB_WIDTH),
-        }
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct NativePlonkInstance<F: PrimeField> {
     pub(crate) W_commitments: Vec<BigUintPoint<F>>,
@@ -88,7 +56,12 @@ impl<F: PrimeField, RO: ROTrait<F>> AbsorbInRO<F, RO> for PairedPlonkInstance<F>
 impl<C: CurveAffine> From<plonk::PlonkInstance<C>> for NativePlonkInstance<C::ScalarExt> {
     fn from(value: plonk::PlonkInstance<C>) -> Self {
         Self {
-            W_commitments: value.W_commitments.iter().map(BigUintPoint::from).collect(),
+            W_commitments: value
+                .W_commitments
+                .iter()
+                .map(BigUintPoint::new)
+                .collect::<Result<Vec<_>, _>>()
+                .unwrap(),
             instances: value.instances,
             challenges: value.challenges,
         }
@@ -148,7 +121,7 @@ impl<F: PrimeField> SelfTrace<F> {
         };
 
         let ins = NativePlonkInstance::<F> {
-            W_commitments: vec![BigUintPoint::identity(); W_commitments_len],
+            W_commitments: vec![BigUintPoint::<F>::identity(); W_commitments_len],
             instances: native_plonk_structure
                 .num_io
                 .iter()
@@ -335,8 +308,8 @@ impl<const ARITY: usize, F: PrimeField> Input<ARITY, F> {
             input_accumulator: ProtoGalaxyAccumulatorInstance {
                 ins: NativePlonkInstance {
                     W_commitments: vec![BigUintPoint {
-                        x: random_big_uint(&mut gen),
-                        y: random_big_uint(&mut gen),
+                        x: random_big_uint(&mut gen).limbs().to_vec(),
+                        y: random_big_uint(&mut gen).limbs().to_vec(),
                     }],
                     instances: vec![
                         vec![gen.next().unwrap(); 10]; // 5 instances each with 10 field elements
@@ -349,8 +322,8 @@ impl<const ARITY: usize, F: PrimeField> Input<ARITY, F> {
             },
             incoming: NativePlonkInstance {
                 W_commitments: vec![BigUintPoint {
-                    x: random_big_uint(&mut gen),
-                    y: random_big_uint(&mut gen),
+                    x: random_big_uint(&mut gen).limbs().to_vec(),
+                    y: random_big_uint(&mut gen).limbs().to_vec(),
                 }],
                 instances: vec![
                     vec![gen.next().unwrap(); 10]; // 10 instances each with 10 field elements
diff --git a/src/ivc/cyclefold/sfc/mod.rs b/src/ivc/cyclefold/sfc/mod.rs
index 4fa7af61..09da5083 100644
--- a/src/ivc/cyclefold/sfc/mod.rs
+++ b/src/ivc/cyclefold/sfc/mod.rs
@@ -15,7 +15,6 @@ use crate::{
         StepCircuit,
     },
     main_gate::{MainGate, MainGateConfig, RegionCtx},
-    polynomial::univariate::UnivariatePoly,
     poseidon::ROTrait,
 };
 
@@ -114,28 +113,29 @@ where
                 Halo2PlonkError::Synthesis
             })?;
 
-        let _self_acc_out = layouter.assign_region(
-            || "sfc protogalaxy",
-            |region| {
-                let mut region = RegionCtx::new(region, 0);
-
-                protogalaxy::verify_chip::verify(
-                    &mut region,
-                    config.mg.clone(),
-                    ro_chip(config.mg.clone()),
-                    verify_chip::AssignedVerifierParam {
-                        pp_digest: input.pp_digest.clone(),
-                    },
-                    input.self_trace.input_accumulator.clone().into(),
-                    &[input.self_trace.incoming.clone().into()],
-                    input.self_trace.proof.clone().into(),
-                )
-                .map_err(|err| {
-                    error!("while protogalaxy::verify: {err:?}");
-                    Halo2PlonkError::Synthesis
-                })
-            },
-        )?;
+        let _self_acc_out: input::assigned::ProtoGalaxyAccumulatorInstance<C::ScalarExt> = layouter
+            .assign_region(
+                || "sfc protogalaxy",
+                |region| {
+                    let mut region = RegionCtx::new(region, 0);
+
+                    protogalaxy::verify_chip::verify(
+                        &mut region,
+                        config.mg.clone(),
+                        ro_chip(config.mg.clone()),
+                        verify_chip::AssignedVerifierParam {
+                            pp_digest: input.pp_digest.clone(),
+                        },
+                        input.self_trace.input_accumulator.clone(),
+                        &[input.self_trace.incoming.clone()],
+                        input.self_trace.proof.clone(),
+                    )
+                    .map_err(|err| {
+                        error!("while protogalaxy::verify: {err:?}");
+                        Halo2PlonkError::Synthesis
+                    })
+                },
+            )?;
 
         layouter.assign_region(
             || "sfc out",
@@ -163,67 +163,3 @@ where
         todo!()
     }
 }
-
-impl<F: PrimeField> From<input::assigned::ProtoGalaxyAccumulatorInstance<F>>
-    for verify_chip::AssignedAccumulatorInstance<F>
-{
-    fn from(value: input::assigned::ProtoGalaxyAccumulatorInstance<F>) -> Self {
-        use self::input::assigned::{NativePlonkInstance, ProtoGalaxyAccumulatorInstance};
-
-        let ProtoGalaxyAccumulatorInstance {
-            ins:
-                NativePlonkInstance {
-                    W_commitments,
-                    instances,
-                    challenges,
-                },
-            betas,
-            e,
-        } = value;
-
-        Self {
-            betas,
-            e,
-            ins: verify_chip::AssignedPlonkInstance {
-                instances,
-                challenges,
-                W_commitments: W_commitments
-                    .into_iter()
-                    .map(|W_commitment| (W_commitment.x_limbs, W_commitment.y_limbs))
-                    .collect(),
-            },
-        }
-    }
-}
-
-impl<F: PrimeField> From<input::assigned::ProtogalaxyProof<F>> for verify_chip::AssignedProof<F> {
-    fn from(value: input::assigned::ProtogalaxyProof<F>) -> Self {
-        let input::assigned::ProtogalaxyProof { poly_F, poly_K } = value;
-
-        verify_chip::AssignedProof {
-            poly_F: verify_chip::AssignedUnivariatePoly(UnivariatePoly(poly_F.into_boxed_slice())),
-            poly_K: verify_chip::AssignedUnivariatePoly(UnivariatePoly(poly_K.into_boxed_slice())),
-        }
-    }
-}
-
-impl<F: PrimeField> From<input::assigned::NativePlonkInstance<F>>
-    for verify_chip::AssignedPlonkInstance<F>
-{
-    fn from(value: input::assigned::NativePlonkInstance<F>) -> Self {
-        let input::assigned::NativePlonkInstance {
-            W_commitments,
-            instances,
-            challenges,
-        } = value;
-
-        Self {
-            instances,
-            challenges,
-            W_commitments: W_commitments
-                .into_iter()
-                .map(|W_commitment| (W_commitment.x_limbs, W_commitment.y_limbs))
-                .collect(),
-        }
-    }
-}
diff --git a/src/ivc/protogalaxy/mod.rs b/src/ivc/protogalaxy/mod.rs
index 913ae5d5..4ab020c4 100644
--- a/src/ivc/protogalaxy/mod.rs
+++ b/src/ivc/protogalaxy/mod.rs
@@ -22,9 +22,9 @@ pub mod verify_chip {
             self,
             poly::{PolyChallenges, PolyContext},
         },
-        plonk::PlonkInstance,
+        plonk,
         polynomial::{lagrange::iter_cyclic_subgroup, univariate::UnivariatePoly},
-        poseidon::ROCircuitTrait,
+        poseidon::{AbsorbInRO, ROCircuitTrait, ROTrait},
         prelude::DEFAULT_LIMB_WIDTH,
         util,
     };
@@ -58,91 +58,216 @@ pub mod verify_chip {
     }
 
     pub type BigUint<F> = Vec<F>;
-    pub type BigUintPoint<F> = (BigUint<F>, BigUint<F>);
 
-    /// Assigned version of [`crate::plonk::PlonkInstance`]
-    pub struct AssignedPlonkInstance<F: PrimeField> {
-        pub W_commitments: Vec<BigUintPoint<AssignedValue<F>>>,
-        pub instances: Vec<Vec<AssignedValue<F>>>,
-        pub challenges: Vec<AssignedValue<F>>,
+    #[derive(Debug, Clone)]
+    pub struct BigUintPoint<F> {
+        pub x: BigUint<F>,
+        pub y: BigUint<F>,
     }
 
-    fn to_bn<C: CurveAffine>(v: &C) -> Result<BigUintPoint<C::ScalarExt>, big_uint::Error> {
-        let coordinates = v.coordinates().unwrap();
+    impl<F> BigUintPoint<F> {
+        fn x_limbs(&self) -> impl Iterator<Item = &F> {
+            self.x.iter()
+        }
 
-        let x = big_uint::BigUint::<C::ScalarExt>::from_different_field::<C::Base>(
-            coordinates.x(),
-            DEFAULT_LIMB_WIDTH,
-            DEFAULT_LIMBS_COUNT_LIMIT,
-        )?;
+        fn y_limbs(&self) -> impl Iterator<Item = &F> {
+            self.y.iter()
+        }
+    }
 
-        let y = big_uint::BigUint::<C::ScalarExt>::from_different_field::<C::Base>(
-            coordinates.y(),
-            DEFAULT_LIMB_WIDTH,
-            DEFAULT_LIMBS_COUNT_LIMIT,
-        )?;
+    impl<F: PrimeField, RO: ROTrait<F>> AbsorbInRO<F, RO> for BigUintPoint<F> {
+        fn absorb_into(&self, ro: &mut RO) {
+            ro.absorb_field_iter(self.x.iter().chain(self.y.iter()).cloned());
+        }
+    }
 
-        Ok((x.limbs().to_vec(), y.limbs().to_vec()))
+    impl<F: PrimeField> BigUintPoint<AssignedValue<F>> {
+        pub fn iter_wrap_values(&self) -> impl '_ + Iterator<Item = WrapValue<F>> {
+            let Self { x, y } = self;
+            x.iter()
+                .chain(y.iter())
+                .map(|v| WrapValue::Assigned(v.clone()))
+        }
+
+        fn conditional_select<const T: usize>(
+            region: &mut RegionCtx<'_, F>,
+            mg: &MainGate<F, T>,
+            lhs: &Self,
+            rhs: &Self,
+            cond: &AssignedValue<F>,
+        ) -> Result<Self, Halo2PlonkError> {
+            let Self { x: lhs_x, y: lhs_y } = lhs;
+            let Self { x: rhs_x, y: rhs_y } = rhs;
+
+            let x = lhs_x
+                .iter()
+                .zip_eq(rhs_x.iter())
+                .map(|(l, r)| mg.conditional_select(region, l, r, cond))
+                .collect::<Result<Vec<_>, _>>()?;
+
+            let y = lhs_y
+                .iter()
+                .zip_eq(rhs_y.iter())
+                .map(|(l, r)| mg.conditional_select(region, l, r, cond))
+                .collect::<Result<Vec<_>, _>>()?;
+
+            Ok(Self { x, y })
+        }
+    }
+
+    impl<F: PrimeField> BigUintPoint<F> {
+        pub fn new<C: CurveAffine<ScalarExt = F>>(v: &C) -> Result<Self, big_uint::Error> {
+            let coordinates = v.coordinates().unwrap();
+
+            let x = big_uint::BigUint::<C::ScalarExt>::from_different_field::<C::Base>(
+                coordinates.x(),
+                DEFAULT_LIMB_WIDTH,
+                DEFAULT_LIMBS_COUNT_LIMIT,
+            )?;
+
+            let y = big_uint::BigUint::<C::ScalarExt>::from_different_field::<C::Base>(
+                coordinates.y(),
+                DEFAULT_LIMB_WIDTH,
+                DEFAULT_LIMBS_COUNT_LIMIT,
+            )?;
+
+            Ok(Self {
+                x: x.limbs().to_vec(),
+                y: y.limbs().to_vec(),
+            })
+        }
+
+        pub fn assign<const T: usize>(
+            self,
+            region: &mut RegionCtx<F>,
+            main_gate_config: &MainGateConfig<T>,
+        ) -> Result<BigUintPoint<AssignedValue<F>>, Halo2PlonkError> {
+            let mut assigner = main_gate_config.advice_cycle_assigner();
+
+            Ok(BigUintPoint {
+                x: assigner.assign_all_advice(region, || "x", self.x.into_iter())?,
+                y: assigner.assign_all_advice(region, || "y", self.y.into_iter())?,
+            })
+        }
+    }
+
+    impl<F: PrimeField> BigUintPoint<F> {
+        pub fn identity() -> Self {
+            Self {
+                x: big_uint::BigUint::zero(DEFAULT_LIMB_WIDTH).limbs().to_vec(),
+                y: big_uint::BigUint::zero(DEFAULT_LIMB_WIDTH).limbs().to_vec(),
+            }
+        }
+    }
+
+    /// Assigned version of [`crate::plonk::PlonkInstance`]
+    #[derive(Clone)]
+    pub struct AssignedPlonkInstance<F: PrimeField> {
+        pub W_commitments: Vec<BigUintPoint<AssignedValue<F>>>,
+        pub instances: Vec<Vec<AssignedValue<F>>>,
+        pub challenges: Vec<AssignedValue<F>>,
     }
 
     impl<F: PrimeField> AssignedPlonkInstance<F> {
         pub fn assign_advice_from<const T: usize, C: CurveAffine<ScalarExt = F>>(
             region: &mut RegionCtx<F>,
+            original: plonk::PlonkInstance<C>,
             main_gate_config: MainGateConfig<T>,
-            original: PlonkInstance<C>,
         ) -> Result<Self, Error> {
-            let PlonkInstance {
+            let plonk::PlonkInstance {
                 W_commitments,
                 instances,
                 challenges,
             } = original;
 
-            let mut assigner = main_gate_config.advice_cycle_assigner();
-
             let W_commitments = W_commitments
                 .iter()
-                .enumerate()
-                .map(|(i, W_commitment)| {
-                    let (x, y) = to_bn(W_commitment).unwrap();
-
-                    Ok((
-                        assigner.assign_all_advice(
-                            region,
-                            || format!("W_commitments[{i}]"),
-                            x.into_iter(),
-                        )?,
-                        assigner.assign_all_advice(
-                            region,
-                            || format!("W_commitments[{i}]"),
-                            y.into_iter(),
-                        )?,
-                    ))
+                .map(|W_commitment| {
+                    BigUintPoint::new(W_commitment)
+                        .expect("TODO")
+                        .assign(region, &main_gate_config)
                 })
-                .collect::<Result<Vec<_>, _>>();
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|err| Error::Assign {
+                    annotation: "W_commitments",
+                    err,
+                })?;
 
-            let instances = instances
-                .iter()
-                .map(|instance| {
-                    assigner.assign_all_advice(region, || "instance", instance.iter().cloned())
-                })
-                .collect::<Result<Vec<_>, _>>();
+            let mut assigner = main_gate_config.advice_cycle_assigner();
 
-            let challenges =
-                assigner.assign_all_advice(region, || "challenges", challenges.iter().cloned());
+            Ok(Self {
+                W_commitments,
+                instances: instances
+                    .into_iter()
+                    .map(|instance| {
+                        assigner.assign_all_advice(region, || "instance", instance.into_iter())
+                    })
+                    .collect::<Result<Vec<_>, _>>()
+                    .map_err(|err| Error::Assign {
+                        annotation: "instances",
+                        err,
+                    })?,
+                challenges: assigner
+                    .assign_all_advice(region, || "challenges", challenges.into_iter())
+                    .map_err(|err| Error::Assign {
+                        annotation: "challenges",
+                        err,
+                    })?,
+            })
+        }
 
-            let map_err = |err| Error::Assign {
-                annotation: "PlonkInstance",
-                err,
-            };
+        pub fn conditional_select<const T: usize>(
+            region: &mut RegionCtx<'_, F>,
+            mg: &MainGate<F, T>,
+            lhs: &Self,
+            rhs: &Self,
+            cond: &AssignedValue<F>,
+        ) -> Result<Self, Halo2PlonkError> {
+            let Self {
+                W_commitments: lhs_W_commitments,
+                instances: lhs_instances,
+                challenges: lhs_challenges,
+            } = lhs;
+            let Self {
+                W_commitments: rhs_W_commitments,
+                instances: rhs_instances,
+                challenges: rhs_challenges,
+            } = rhs;
 
             Ok(Self {
-                W_commitments: W_commitments.map_err(map_err)?,
-                instances: instances.map_err(map_err)?,
-                challenges: challenges.map_err(map_err)?,
+                W_commitments: lhs_W_commitments
+                    .iter()
+                    .zip_eq(rhs_W_commitments.iter())
+                    .map(|(lhs_W_commitment, rhs_W_commitment)| {
+                        BigUintPoint::conditional_select(
+                            region,
+                            mg,
+                            lhs_W_commitment,
+                            rhs_W_commitment,
+                            cond,
+                        )
+                    })
+                    .collect::<Result<Vec<_>, _>>()?,
+                instances: lhs_instances
+                    .iter()
+                    .zip_eq(rhs_instances.iter())
+                    .map(|(l_instance, r_instance)| {
+                        l_instance
+                            .iter()
+                            .zip_eq(r_instance.iter())
+                            .map(|(l, r)| mg.conditional_select(region, l, r, cond))
+                            .collect::<Result<Vec<_>, _>>()
+                    })
+                    .collect::<Result<Vec<Vec<_>>, _>>()?,
+                challenges: lhs_challenges
+                    .iter()
+                    .zip_eq(rhs_challenges.iter())
+                    .map(|(l, r)| mg.conditional_select(region, l, r, cond))
+                    .collect::<Result<Vec<_>, _>>()?,
             })
         }
 
-        pub fn iter_wrap_value(&self) -> impl '_ + Iterator<Item = WrapValue<F>> {
+        pub fn iter_wrap_values(&self) -> impl '_ + Iterator<Item = WrapValue<F>> {
             let Self {
                 W_commitments,
                 instances,
@@ -151,21 +276,22 @@ pub mod verify_chip {
 
             W_commitments
                 .iter()
-                .flat_map(|(W_commitment_x, W_commitment_y)| {
-                    W_commitment_x.iter().chain(W_commitment_y.iter()).cloned()
-                })
+                .flat_map(|W_commitment| W_commitment.iter_wrap_values())
+                .chain(instances.iter().flat_map(|instance| {
+                    instance
+                        .iter()
+                        .map(|value| WrapValue::Assigned(value.clone()))
+                }))
                 .chain(
-                    instances
+                    challenges
                         .iter()
-                        .flat_map(|instance| instance.iter())
-                        .cloned(),
+                        .map(|cha| WrapValue::Assigned(cha.clone())),
                 )
-                .chain(challenges.iter().cloned())
-                .map(|value| WrapValue::Assigned(value))
         }
     }
 
     /// Assigned version of [`crate::nifs::protogalaxy::accumulator::AccumulatorInstance`]
+    #[derive(Clone)]
     pub struct AssignedAccumulatorInstance<F: PrimeField> {
         pub ins: AssignedPlonkInstance<F>,
         pub betas: Box<[AssignedValue<F>]>,
@@ -173,7 +299,7 @@ pub mod verify_chip {
     }
 
     impl<F: PrimeField> AssignedAccumulatorInstance<F> {
-        pub fn assign<const T: usize, C: CurveAffine<ScalarExt = F>>(
+        pub fn assign_advice_from<const T: usize, C: CurveAffine<ScalarExt = F>>(
             region: &mut RegionCtx<F>,
             main_gate_config: MainGateConfig<T>,
             acc: protogalaxy::AccumulatorInstance<C>,
@@ -181,7 +307,7 @@ pub mod verify_chip {
             let protogalaxy::AccumulatorInstance { ins, betas, e } = acc;
 
             let ins =
-                AssignedPlonkInstance::assign_advice_from(region, main_gate_config.clone(), ins)?;
+                AssignedPlonkInstance::assign_advice_from(region, ins, main_gate_config.clone())?;
 
             let mut assigner = main_gate_config.advice_cycle_assigner();
 
@@ -207,10 +333,10 @@ pub mod verify_chip {
             Ok(Self { ins, betas, e })
         }
 
-        pub fn iter_wrap_value(&self) -> impl '_ + Iterator<Item = WrapValue<F>> {
+        pub fn iter_wrap_values(&self) -> impl '_ + Iterator<Item = WrapValue<F>> {
             let Self { ins, betas, e } = self;
 
-            ins.iter_wrap_value()
+            ins.iter_wrap_values()
                 .chain(betas.iter().map(|beta| WrapValue::Assigned(beta.clone())))
                 .chain(iter::once(WrapValue::Assigned(e.clone())))
         }
@@ -275,9 +401,32 @@ pub mod verify_chip {
     }
 
     /// Assigned version of [`crate::polynomial::univariate::UnivariatePoly`]
+    #[derive(Clone)]
     pub struct AssignedUnivariatePoly<F: PrimeField>(pub UnivariatePoly<AssignedValue<F>>);
 
+    impl<F: PrimeField> From<UnivariatePoly<AssignedValue<F>>> for AssignedUnivariatePoly<F> {
+        fn from(value: UnivariatePoly<AssignedValue<F>>) -> Self {
+            Self(value)
+        }
+    }
+
+    impl<F: PrimeField> From<Vec<AssignedValue<F>>> for AssignedUnivariatePoly<F> {
+        fn from(value: Vec<AssignedValue<F>>) -> Self {
+            Self(UnivariatePoly(value.into_boxed_slice()))
+        }
+    }
+
+    impl<F: PrimeField> FromIterator<AssignedValue<F>> for AssignedUnivariatePoly<F> {
+        fn from_iter<T: IntoIterator<Item = AssignedValue<F>>>(iter: T) -> Self {
+            Self(UnivariatePoly::from_iter(iter))
+        }
+    }
+
     impl<F: PrimeField> AssignedUnivariatePoly<F> {
+        pub fn new(coeff: Box<[AssignedValue<F>]>) -> Self {
+            Self(UnivariatePoly(coeff))
+        }
+
         pub fn assign<const T: usize>(
             region: &mut RegionCtx<F>,
             main_gate_config: MainGateConfig<T>,
@@ -405,6 +554,7 @@ pub mod verify_chip {
     }
 
     /// Assigned version of [`crate::nifs::protogalaxy::Proof]
+    #[derive(Clone)]
     pub struct AssignedProof<F: PrimeField> {
         pub poly_F: AssignedUnivariatePoly<F>,
         pub poly_K: AssignedUnivariatePoly<F>,
@@ -511,8 +661,8 @@ pub mod verify_chip {
         {
             let delta = ro_circuit
                 .absorb_iter(vp.iter_wrap_value())
-                .absorb_iter(accumulator.iter_wrap_value())
-                .absorb_iter(incoming.iter().flat_map(|tr| tr.iter_wrap_value()))
+                .absorb_iter(accumulator.iter_wrap_values())
+                .absorb_iter(incoming.iter().flat_map(|tr| tr.iter_wrap_values()))
                 .squeeze(region)?;
 
             let alpha = ro_circuit
@@ -758,10 +908,9 @@ pub mod verify_chip {
             ro_circuit.absorb_iter(pi.instances.iter().flat_map(|inst| inst.iter()));
 
             for (W_commitment, challenge) in pi.W_commitments.iter().zip_eq(pi.challenges.iter()) {
-                let (W_commitment_x, W_commitment_y) = W_commitment;
                 let expected = ro_circuit
-                    .absorb_iter(W_commitment_x.iter())
-                    .absorb_iter(W_commitment_y.iter())
+                    .absorb_iter(W_commitment.x_limbs())
+                    .absorb_iter(W_commitment.y_limbs())
                     .squeeze(region)?;
 
                 region.constrain_equal(expected.cell(), challenge.cell())?;
@@ -883,6 +1032,7 @@ pub mod verify_chip {
                 self,
                 protogalaxy::{AccumulatorArgs, VerifierParam},
             },
+            plonk::PlonkInstance,
             polynomial,
             table::WitnessCollector,
         };
@@ -968,7 +1118,7 @@ pub mod verify_chip {
                             params,
                         )
                         .unwrap();
-                        let acc = AssignedAccumulatorInstance::assign(
+                        let acc = AssignedAccumulatorInstance::assign_advice_from(
                             &mut region,
                             config.clone(),
                             acc.clone().into(),