diff --git a/ext/crates/fp/src/vector/fp_wrapper/helpers.rs b/ext/crates/fp/src/vector/fp_wrapper/helpers.rs
index 3253dcd1b..e6e7f7e17 100644
--- a/ext/crates/fp/src/vector/fp_wrapper/helpers.rs
+++ b/ext/crates/fp/src/vector/fp_wrapper/helpers.rs
@@ -19,7 +19,7 @@ use crate::field::Field;
 
 impl<F: Field> FqVector<F> {
     pub(super) fn scale_helper(&mut self, c: F::ElementContainer) {
-        self.scale(self.fq.el(c))
+        self.scale(self.fq().el(c))
     }
 
     pub(super) fn entry_helper(&self, index: usize) -> F::ElementContainer {
@@ -27,11 +27,11 @@ impl<F: Field> FqVector<F> {
     }
 
     pub(super) fn set_entry_helper(&mut self, index: usize, value: F::ElementContainer) {
-        self.set_entry(index, self.fq.el(value))
+        self.set_entry(index, self.fq().el(value))
     }
 
     pub(super) fn add_helper(&mut self, other: &Self, c: F::ElementContainer) {
-        self.add(other, self.fq.el(c))
+        self.add(other, self.fq().el(c))
     }
 
     pub(super) fn add_offset_helper(
@@ -40,15 +40,15 @@ impl<F: Field> FqVector<F> {
         c: F::ElementContainer,
         offset: usize,
     ) {
-        self.add_offset(other, self.fq.el(c), offset)
+        self.add_offset(other, self.fq().el(c), offset)
     }
 
     pub(super) fn add_basis_element_helper(&mut self, index: usize, value: F::ElementContainer) {
-        self.add_basis_element(index, self.fq.el(value))
+        self.add_basis_element(index, self.fq().el(value))
     }
 
     pub(super) fn copy_from_slice_helper(&mut self, other: &[F::ElementContainer]) {
-        self.copy_from_slice(&other.iter().map(|x| self.fq.el(x.clone())).collect_vec())
+        self.copy_from_slice(&other.iter().map(|x| self.fq().el(x.clone())).collect_vec())
     }
 
     pub(super) fn add_truncate_helper(
@@ -56,7 +56,7 @@ impl<F: Field> FqVector<F> {
         other: &Self,
         c: F::ElementContainer,
     ) -> Option<()> {
-        self.add_truncate(other, self.fq.el(c))
+        self.add_truncate(other, self.fq().el(c))
     }
 
     pub(super) fn add_carry_helper<T>(
@@ -68,7 +68,7 @@ impl<F: Field> FqVector<F> {
     where
         for<'a> &'a mut T: TryInto<&'a mut Self>,
     {
-        self.add_carry(other, self.fq.el(c), rest)
+        self.add_carry(other, self.fq().el(c), rest)
     }
 
     pub(super) fn first_nonzero_helper(&self) -> Option<(usize, F::ElementContainer)> {
@@ -88,11 +88,11 @@ impl<F: Field> FqSlice<'_, F> {
 
 impl<F: Field> FqSliceMut<'_, F> {
     pub(super) fn scale_helper(&mut self, c: F::ElementContainer) {
-        self.scale(self.fq.el(c))
+        self.scale(self.fq().el(c))
     }
 
     pub(super) fn add_helper(&mut self, other: FqSlice<F>, c: F::ElementContainer) {
-        self.add(other, self.fq.el(c))
+        self.add(other, self.fq().el(c))
     }
 
     pub(super) fn add_offset_helper(
@@ -101,15 +101,15 @@ impl<F: Field> FqSliceMut<'_, F> {
         c: F::ElementContainer,
         offset: usize,
     ) {
-        self.add_offset(other, self.fq.el(c), offset)
+        self.add_offset(other, self.fq().el(c), offset)
     }
 
     pub(super) fn set_entry_helper(&mut self, index: usize, value: F::ElementContainer) {
-        self.set_entry(index, self.fq.el(value))
+        self.set_entry(index, self.fq().el(value))
     }
 
     pub(super) fn add_basis_element_helper(&mut self, index: usize, value: F::ElementContainer) {
-        self.add_basis_element(index, self.fq.el(value))
+        self.add_basis_element(index, self.fq().el(value))
     }
 
     pub(super) fn add_masked_helper(
@@ -118,7 +118,7 @@ impl<F: Field> FqSliceMut<'_, F> {
         c: F::ElementContainer,
         mask: &[usize],
     ) {
-        self.add_masked(other, self.fq.el(c), mask)
+        self.add_masked(other, self.fq().el(c), mask)
     }
 
     pub(super) fn add_unmasked_helper(
@@ -127,7 +127,7 @@ impl<F: Field> FqSliceMut<'_, F> {
         c: F::ElementContainer,
         mask: &[usize],
     ) {
-        self.add_unmasked(other, self.fq.el(c), mask)
+        self.add_unmasked(other, self.fq().el(c), mask)
     }
 
     pub(super) fn add_tensor_helper(
@@ -137,7 +137,7 @@ impl<F: Field> FqSliceMut<'_, F> {
         left: FqSlice<F>,
         right: FqSlice<F>,
     ) {
-        self.add_tensor(offset, self.fq.el(coeff), left, right)
+        self.add_tensor(offset, self.fq().el(coeff), left, right)
     }
 }
 
diff --git a/ext/crates/fp/src/vector/impl_fqslice.rs b/ext/crates/fp/src/vector/impl_fqslice.rs
index 689a8acce..30a23f308 100644
--- a/ext/crates/fp/src/vector/impl_fqslice.rs
+++ b/ext/crates/fp/src/vector/impl_fqslice.rs
@@ -14,25 +14,16 @@ use crate::{
 // Public methods
 
 impl<'a, F: Field> FqSlice<'a, F> {
-    pub(crate) fn new(fq: F, limbs: &'a [Limb], start: usize, end: usize) -> Self {
-        FqSlice {
-            fq,
-            limbs,
-            start,
-            end,
-        }
-    }
-
     pub fn prime(&self) -> ValidPrime {
-        self.fq.characteristic().to_dyn()
+        self.fq().characteristic().to_dyn()
     }
 
     pub fn len(&self) -> usize {
-        self.end - self.start
+        self.end() - self.start()
     }
 
     pub const fn is_empty(&self) -> bool {
-        self.start == self.end
+        self.start() == self.end()
     }
 
     pub fn entry(&self, index: usize) -> FieldElement<F> {
@@ -42,12 +33,12 @@ impl<'a, F: Field> FqSlice<'a, F> {
             index,
             self.len()
         );
-        let bit_mask = self.fq.bitmask();
-        let limb_index = self.fq.limb_bit_index_pair(index + self.start);
-        let mut result = self.limbs[limb_index.limb];
+        let bit_mask = self.fq().bitmask();
+        let limb_index = self.fq().limb_bit_index_pair(index + self.start());
+        let mut result = self.limbs()[limb_index.limb];
         result >>= limb_index.bit_index;
         result &= bit_mask;
-        self.fq.decode(result)
+        self.fq().decode(result)
     }
 
     /// TODO: implement prime 2 version
@@ -69,15 +60,15 @@ impl<'a, F: Field> FqSlice<'a, F> {
             return true;
         }
         let (min_mask, max_mask) = self.limb_masks();
-        if self.limbs[limb_range.start] & min_mask != 0 {
+        if self.limbs()[limb_range.start] & min_mask != 0 {
             return false;
         }
 
         let inner_range = self.limb_range_inner();
-        if !inner_range.is_empty() && self.limbs[inner_range].iter().any(|&x| x != 0) {
+        if !inner_range.is_empty() && self.limbs()[inner_range].iter().any(|&x| x != 0) {
             return false;
         }
-        if self.limbs[limb_range.end - 1] & max_mask != 0 {
+        if self.limbs()[limb_range.end - 1] & max_mask != 0 {
             return false;
         }
         true
@@ -87,24 +78,24 @@ impl<'a, F: Field> FqSlice<'a, F> {
     pub fn slice(self, start: usize, end: usize) -> Self {
         assert!(start <= end && end <= self.len());
 
-        FqSlice {
-            fq: self.fq,
-            limbs: self.limbs,
-            start: self.start + start,
-            end: self.start + end,
-        }
+        FqSlice::new(
+            self.fq(),
+            self.into_limbs(),
+            self.start() + start,
+            self.start() + end,
+        )
     }
 
     /// Converts a slice to an owned FqVector. This is vastly more efficient if the start of the vector is aligned.
     #[must_use]
     pub fn to_owned(self) -> FqVector<F> {
-        let mut new = FqVector::new(self.fq, self.len());
-        if self.start.is_multiple_of(self.fq.entries_per_limb()) {
+        let mut new = FqVector::new(self.fq(), self.len());
+        if self.start().is_multiple_of(self.fq().entries_per_limb()) {
             let limb_range = self.limb_range();
-            new.limbs[0..limb_range.len()].copy_from_slice(&self.limbs[limb_range]);
-            if !new.limbs.is_empty() {
-                let len = new.limbs.len();
-                new.limbs[len - 1] &= self.limb_masks().1;
+            new.limbs_mut()[0..limb_range.len()].copy_from_slice(&self.limbs()[limb_range]);
+            if !new.limbs().is_empty() {
+                let len = new.limbs().len();
+                new.limbs_mut()[len - 1] &= self.limb_masks().1;
             }
         } else {
             new.as_slice_mut().assign(self);
@@ -115,23 +106,19 @@ impl<'a, F: Field> FqSlice<'a, F> {
 
 // Limb methods
 impl<F: Field> FqSlice<'_, F> {
-    pub(crate) fn limbs(&self) -> &[Limb] {
-        self.limbs
-    }
-
     #[inline]
     pub(super) fn offset(&self) -> usize {
-        let bit_length = self.fq.bit_length();
-        let entries_per_limb = self.fq.entries_per_limb();
-        (self.start % entries_per_limb) * bit_length
+        let bit_length = self.fq().bit_length();
+        let entries_per_limb = self.fq().entries_per_limb();
+        (self.start() % entries_per_limb) * bit_length
     }
 
     #[inline]
     pub(super) fn limb_range(&self) -> std::ops::Range<usize> {
-        self.fq.range(self.start, self.end)
+        self.fq().range(self.start(), self.end())
     }
 
-    /// This function underflows if `self.end == 0`, which happens if and only if we are taking a
+    /// This function underflows if `self.end() == 0`, which happens if and only if we are taking a
     /// slice of width 0 at the start of an `FpVector`. This should be a very rare edge case.
     /// Dealing with the underflow properly would probably require using `saturating_sub` or
     /// something of that nature, and that has a nontrivial (10%) performance hit.
@@ -148,8 +135,8 @@ impl<F: Field> FqSlice<'_, F> {
 
     #[inline(always)]
     pub(super) fn max_limb_mask(&self) -> Limb {
-        let num_entries = 1 + (self.end - 1) % self.fq.entries_per_limb();
-        let bit_max = num_entries * self.fq.bit_length();
+        let num_entries = 1 + (self.end() - 1) % self.fq().entries_per_limb();
+        let bit_max = num_entries * self.fq().bit_length();
 
         (!0) >> (constants::BITS_PER_LIMB - bit_max)
     }
@@ -169,7 +156,7 @@ impl<F: Field> FqSlice<'_, F> {
 
 impl<'a, F: Field> From<&'a FqVector<F>> for FqSlice<'a, F> {
     fn from(v: &'a FqVector<F>) -> Self {
-        v.slice(0, v.len)
+        v.slice(0, v.len())
     }
 }
 
diff --git a/ext/crates/fp/src/vector/impl_fqslicemut.rs b/ext/crates/fp/src/vector/impl_fqslicemut.rs
index 202ac84e6..173f513dd 100644
--- a/ext/crates/fp/src/vector/impl_fqslicemut.rs
+++ b/ext/crates/fp/src/vector/impl_fqslicemut.rs
@@ -11,24 +11,15 @@ use crate::{
 };
 
 impl<'a, F: Field> FqSliceMut<'a, F> {
-    pub(crate) fn new(fq: F, limbs: &'a mut [Limb], start: usize, end: usize) -> Self {
-        FqSliceMut {
-            fq,
-            limbs,
-            start,
-            end,
-        }
-    }
-
     pub fn prime(&self) -> ValidPrime {
-        self.fq.characteristic().to_dyn()
+        self.fq().characteristic().to_dyn()
     }
 
     pub fn add_basis_element(&mut self, index: usize, value: FieldElement<F>) {
-        assert_eq!(self.fq, value.field());
-        if self.fq.q() == 2 {
-            let pair = self.fq.limb_bit_index_pair(index + self.start);
-            self.limbs[pair.limb] ^= self.fq.encode(value) << pair.bit_index;
+        assert_eq!(self.fq(), value.field());
+        if self.fq().q() == 2 {
+            let pair = self.fq().limb_bit_index_pair(index + self.start());
+            self.limbs_mut()[pair.limb] ^= self.fq().encode(value) << pair.bit_index;
         } else {
             let mut x = self.as_slice().entry(index);
             x += value;
@@ -37,30 +28,33 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
     }
 
     pub fn set_entry(&mut self, index: usize, value: FieldElement<F>) {
-        assert_eq!(self.fq, value.field());
+        assert_eq!(self.fq(), value.field());
         assert!(index < self.as_slice().len());
-        let bit_mask = self.fq.bitmask();
-        let limb_index = self.fq.limb_bit_index_pair(index + self.start);
-        let mut result = self.limbs[limb_index.limb];
+        let bit_mask = self.fq().bitmask();
+        let limb_index = self.fq().limb_bit_index_pair(index + self.start());
+        let mut result = self.limbs()[limb_index.limb];
         result &= !(bit_mask << limb_index.bit_index);
-        result |= self.fq.encode(value) << limb_index.bit_index;
-        self.limbs[limb_index.limb] = result;
+        result |= self.fq().encode(value) << limb_index.bit_index;
+        self.limbs_mut()[limb_index.limb] = result;
     }
 
     fn reduce_limbs(&mut self) {
-        if self.fq.q() != 2 {
+        let fq = self.fq();
+        if fq.q() != 2 {
             let limb_range = self.as_slice().limb_range();
 
-            for limb in &mut self.limbs[limb_range] {
-                *limb = self.fq.reduce(*limb);
+            for limb in self.limbs_mut()[limb_range].iter_mut() {
+                *limb = fq.reduce(*limb);
             }
         }
     }
 
     pub fn scale(&mut self, c: FieldElement<F>) {
-        assert_eq!(self.fq, c.field());
-        if self.fq.q() == 2 {
-            if c == self.fq.zero() {
+        assert_eq!(self.fq(), c.field());
+        let fq = self.fq();
+
+        if fq.q() == 2 {
+            if c == fq.zero() {
                 self.set_to_zero();
             }
             return;
@@ -72,20 +66,20 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
         }
         let (min_mask, max_mask) = self.as_slice().limb_masks();
 
-        let limb = self.limbs[limb_range.start];
+        let limb = self.limbs()[limb_range.start];
         let masked_limb = limb & min_mask;
         let rest_limb = limb & !min_mask;
-        self.limbs[limb_range.start] = self.fq.fma_limb(0, masked_limb, c.clone()) | rest_limb;
+        self.limbs_mut()[limb_range.start] = fq.fma_limb(0, masked_limb, c.clone()) | rest_limb;
 
         let inner_range = self.as_slice().limb_range_inner();
-        for limb in &mut self.limbs[inner_range] {
-            *limb = self.fq.fma_limb(0, *limb, c.clone());
+        for limb in self.limbs_mut()[inner_range].iter_mut() {
+            *limb = fq.fma_limb(0, *limb, c.clone());
         }
         if limb_range.len() > 1 {
-            let full_limb = self.limbs[limb_range.end - 1];
+            let full_limb = self.limbs()[limb_range.end - 1];
             let masked_limb = full_limb & max_mask;
             let rest_limb = full_limb & !max_mask;
-            self.limbs[limb_range.end - 1] = self.fq.fma_limb(0, masked_limb, c) | rest_limb;
+            self.limbs_mut()[limb_range.end - 1] = fq.fma_limb(0, masked_limb, c) | rest_limb;
         }
         self.reduce_limbs();
     }
@@ -96,29 +90,29 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
             return;
         }
         let (min_mask, max_mask) = self.as_slice().limb_masks();
-        self.limbs[limb_range.start] &= !min_mask;
+        self.limbs_mut()[limb_range.start] &= !min_mask;
 
         let inner_range = self.as_slice().limb_range_inner();
-        for limb in &mut self.limbs[inner_range] {
+        for limb in self.limbs_mut()[inner_range].iter_mut() {
             *limb = 0;
         }
-        self.limbs[limb_range.end - 1] &= !max_mask;
+        self.limbs_mut()[limb_range.end - 1] &= !max_mask;
     }
 
     pub fn add(&mut self, other: FqSlice<'_, F>, c: FieldElement<F>) {
-        assert_eq!(self.fq, c.field());
-        assert_eq!(self.fq, other.fq);
+        assert_eq!(self.fq(), c.field());
+        assert_eq!(self.fq(), other.fq());
 
         if self.as_slice().is_empty() {
             return;
         }
 
-        if self.fq.q() == 2 {
-            if c != self.fq.zero() {
+        if self.fq().q() == 2 {
+            if c != self.fq().zero() {
                 match self.as_slice().offset().cmp(&other.offset()) {
-                    Ordering::Equal => self.add_shift_none(other, self.fq.one()),
-                    Ordering::Less => self.add_shift_left(other, self.fq.one()),
-                    Ordering::Greater => self.add_shift_right(other, self.fq.one()),
+                    Ordering::Equal => self.add_shift_none(other, self.fq().one()),
+                    Ordering::Less => self.add_shift_left(other, self.fq().one()),
+                    Ordering::Greater => self.add_shift_right(other, self.fq().one()),
                 };
             }
         } else {
@@ -143,9 +137,9 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
         left: FqSlice<F>,
         right: FqSlice<F>,
     ) {
-        assert_eq!(self.fq, coeff.field());
-        assert_eq!(self.fq, left.fq);
-        assert_eq!(self.fq, right.fq);
+        assert_eq!(self.fq(), coeff.field());
+        assert_eq!(self.fq(), left.fq());
+        assert_eq!(self.fq(), right.fq());
 
         let right_dim = right.len();
 
@@ -158,10 +152,10 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
 
     /// TODO: improve efficiency
     pub fn assign(&mut self, other: FqSlice<'_, F>) {
-        assert_eq!(self.fq, other.fq);
+        assert_eq!(self.fq(), other.fq());
         if self.as_slice().offset() != other.offset() {
             self.set_to_zero();
-            self.add(other, self.fq.one());
+            self.add(other, self.fq().one());
             return;
         }
         let target_range = self.as_slice().limb_range();
@@ -173,19 +167,20 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
 
         let (min_mask, max_mask) = other.limb_masks();
 
-        let result = other.limbs[source_range.start] & min_mask;
-        self.limbs[target_range.start] &= !min_mask;
-        self.limbs[target_range.start] |= result;
+        let result = other.limbs()[source_range.start] & min_mask;
+        self.limbs_mut()[target_range.start] &= !min_mask;
+        self.limbs_mut()[target_range.start] |= result;
 
         let target_inner_range = self.as_slice().limb_range_inner();
         let source_inner_range = other.limb_range_inner();
         if !target_inner_range.is_empty() && !source_inner_range.is_empty() {
-            self.limbs[target_inner_range].clone_from_slice(&other.limbs[source_inner_range]);
+            self.limbs_mut()[target_inner_range]
+                .clone_from_slice(&other.limbs()[source_inner_range]);
         }
 
-        let result = other.limbs[source_range.end - 1] & max_mask;
-        self.limbs[target_range.end - 1] &= !max_mask;
-        self.limbs[target_range.end - 1] |= result;
+        let result = other.limbs()[source_range.end - 1] & max_mask;
+        self.limbs_mut()[target_range.end - 1] &= !max_mask;
+        self.limbs_mut()[target_range.end - 1] |= result;
     }
 
     /// Shifts the entries of `self` to the left by `shift` entries.
@@ -193,12 +188,12 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
         if shift == 0 {
             return;
         }
-        if self.start == 0 && shift.is_multiple_of(self.fq.entries_per_limb()) {
-            let limb_shift = shift / self.fq.entries_per_limb();
-            self.end -= shift;
-            let new_num_limbs = self.fq.number(self.end);
+        if self.start() == 0 && shift.is_multiple_of(self.fq().entries_per_limb()) {
+            let limb_shift = shift / self.fq().entries_per_limb();
+            *self.end_mut() -= shift;
+            let new_num_limbs = self.fq().number(self.end());
             for idx in 0..new_num_limbs {
-                self.limbs[idx] = self.limbs[idx + limb_shift];
+                self.limbs_mut()[idx] = self.limbs()[idx + limb_shift];
             }
         } else {
             unimplemented!()
@@ -207,40 +202,41 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
 
     /// Adds `c` * `other` to `self`. `other` must have the same length, offset, and prime as self.
     pub fn add_shift_none(&mut self, other: FqSlice<'_, F>, c: FieldElement<F>) {
-        assert_eq!(self.fq, c.field());
-        assert_eq!(self.fq, other.fq);
+        assert_eq!(self.fq(), c.field());
+        assert_eq!(self.fq(), other.fq());
+        let fq = self.fq();
 
         let target_range = self.as_slice().limb_range();
         let source_range = other.limb_range();
 
         let (min_mask, max_mask) = other.limb_masks();
 
-        self.limbs[target_range.start] = self.fq.fma_limb(
-            self.limbs[target_range.start],
-            other.limbs[source_range.start] & min_mask,
+        self.limbs_mut()[target_range.start] = fq.fma_limb(
+            self.limbs()[target_range.start],
+            other.limbs()[source_range.start] & min_mask,
             c.clone(),
         );
-        self.limbs[target_range.start] = self.fq.reduce(self.limbs[target_range.start]);
+        self.limbs_mut()[target_range.start] = fq.reduce(self.limbs()[target_range.start]);
 
         let target_inner_range = self.as_slice().limb_range_inner();
         let source_inner_range = other.limb_range_inner();
         if !source_inner_range.is_empty() {
-            for (left, right) in self.limbs[target_inner_range]
+            for (left, right) in self.limbs_mut()[target_inner_range]
                 .iter_mut()
-                .zip_eq(&other.limbs[source_inner_range])
+                .zip_eq(&other.limbs()[source_inner_range])
             {
-                *left = self.fq.fma_limb(*left, *right, c.clone());
-                *left = self.fq.reduce(*left);
+                *left = fq.fma_limb(*left, *right, c.clone());
+                *left = fq.reduce(*left);
             }
         }
         if source_range.len() > 1 {
             // The first and last limbs are distinct, so we process the last.
-            self.limbs[target_range.end - 1] = self.fq.fma_limb(
-                self.limbs[target_range.end - 1],
-                other.limbs[source_range.end - 1] & max_mask,
+            self.limbs_mut()[target_range.end - 1] = fq.fma_limb(
+                self.limbs()[target_range.end - 1],
+                other.limbs()[source_range.end - 1] & max_mask,
                 c,
             );
-            self.limbs[target_range.end - 1] = self.fq.reduce(self.limbs[target_range.end - 1]);
+            self.limbs_mut()[target_range.end - 1] = fq.reduce(self.limbs()[target_range.end - 1]);
         }
     }
 
@@ -295,72 +291,72 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
             }
 
             fn mask_first_limb<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                (other.limbs[i] & self.min_mask) >> self.offset_shift
+                (other.limbs()[i] & self.min_mask) >> self.offset_shift
             }
 
             fn mask_middle_limb_a<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                other.limbs[i] >> self.offset_shift
+                other.limbs()[i] >> self.offset_shift
             }
 
             fn mask_middle_limb_b<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                (other.limbs[i] << (self.tail_shift + self.zero_bits)) >> self.zero_bits
+                (other.limbs()[i] << (self.tail_shift + self.zero_bits)) >> self.zero_bits
             }
 
             fn mask_last_limb_a<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                let source_limb_masked = other.limbs[i] & self.max_mask;
+                let source_limb_masked = other.limbs()[i] & self.max_mask;
                 source_limb_masked << self.tail_shift
             }
 
             fn mask_last_limb_b<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                let source_limb_masked = other.limbs[i] & self.max_mask;
+                let source_limb_masked = other.limbs()[i] & self.max_mask;
                 source_limb_masked >> self.offset_shift
             }
         }
 
-        let dat = AddShiftLeftData::new(self.fq, self.as_slice(), other);
+        let dat = AddShiftLeftData::new(self.fq(), self.as_slice(), other);
         let mut i = 0;
         {
-            self.limbs[i + dat.min_target_limb] = self.fq.fma_limb(
-                self.limbs[i + dat.min_target_limb],
+            self.limbs_mut()[i + dat.min_target_limb] = self.fq().fma_limb(
+                self.limbs()[i + dat.min_target_limb],
                 dat.mask_first_limb(other, i + dat.min_source_limb),
                 c.clone(),
             );
         }
         for i in 1..dat.number_of_source_limbs - 1 {
-            self.limbs[i + dat.min_target_limb] = self.fq.fma_limb(
-                self.limbs[i + dat.min_target_limb],
+            self.limbs_mut()[i + dat.min_target_limb] = self.fq().fma_limb(
+                self.limbs()[i + dat.min_target_limb],
                 dat.mask_middle_limb_a(other, i + dat.min_source_limb),
                 c.clone(),
             );
-            self.limbs[i + dat.min_target_limb - 1] = self.fq.fma_limb(
-                self.limbs[i + dat.min_target_limb - 1],
+            self.limbs_mut()[i + dat.min_target_limb - 1] = self.fq().fma_limb(
+                self.limbs()[i + dat.min_target_limb - 1],
                 dat.mask_middle_limb_b(other, i + dat.min_source_limb),
                 c.clone(),
             );
-            self.limbs[i + dat.min_target_limb - 1] =
-                self.fq.reduce(self.limbs[i + dat.min_target_limb - 1]);
+            self.limbs_mut()[i + dat.min_target_limb - 1] =
+                self.fq().reduce(self.limbs()[i + dat.min_target_limb - 1]);
         }
         i = dat.number_of_source_limbs - 1;
         if i > 0 {
-            self.limbs[i + dat.min_target_limb - 1] = self.fq.fma_limb(
-                self.limbs[i + dat.min_target_limb - 1],
+            self.limbs_mut()[i + dat.min_target_limb - 1] = self.fq().fma_limb(
+                self.limbs()[i + dat.min_target_limb - 1],
                 dat.mask_last_limb_a(other, i + dat.min_source_limb),
                 c.clone(),
             );
-            self.limbs[i + dat.min_target_limb - 1] =
-                self.fq.reduce(self.limbs[i + dat.min_target_limb - 1]);
+            self.limbs_mut()[i + dat.min_target_limb - 1] =
+                self.fq().reduce(self.limbs()[i + dat.min_target_limb - 1]);
             if dat.number_of_source_limbs == dat.number_of_target_limbs {
-                self.limbs[i + dat.min_target_limb] = self.fq.fma_limb(
-                    self.limbs[i + dat.min_target_limb],
+                self.limbs_mut()[i + dat.min_target_limb] = self.fq().fma_limb(
+                    self.limbs()[i + dat.min_target_limb],
                     dat.mask_last_limb_b(other, i + dat.min_source_limb),
                     c,
                 );
-                self.limbs[i + dat.min_target_limb] =
-                    self.fq.reduce(self.limbs[i + dat.min_target_limb]);
+                self.limbs_mut()[i + dat.min_target_limb] =
+                    self.fq().reduce(self.limbs()[i + dat.min_target_limb]);
             }
         } else {
-            self.limbs[i + dat.min_target_limb] =
-                self.fq.reduce(self.limbs[i + dat.min_target_limb]);
+            self.limbs_mut()[i + dat.min_target_limb] =
+                self.fq().reduce(self.limbs()[i + dat.min_target_limb]);
         }
     }
 
@@ -414,98 +410,98 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
             }
 
             fn mask_first_limb_a<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                let source_limb_masked = other.limbs[i] & self.min_mask;
+                let source_limb_masked = other.limbs()[i] & self.min_mask;
                 (source_limb_masked << (self.offset_shift + self.zero_bits)) >> self.zero_bits
             }
 
             fn mask_first_limb_b<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                let source_limb_masked = other.limbs[i] & self.min_mask;
+                let source_limb_masked = other.limbs()[i] & self.min_mask;
                 source_limb_masked >> self.tail_shift
             }
 
             fn mask_middle_limb_a<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                (other.limbs[i] << (self.offset_shift + self.zero_bits)) >> self.zero_bits
+                (other.limbs()[i] << (self.offset_shift + self.zero_bits)) >> self.zero_bits
             }
 
             fn mask_middle_limb_b<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                other.limbs[i] >> self.tail_shift
+                other.limbs()[i] >> self.tail_shift
             }
 
             fn mask_last_limb_a<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                let source_limb_masked = other.limbs[i] & self.max_mask;
+                let source_limb_masked = other.limbs()[i] & self.max_mask;
                 source_limb_masked << self.offset_shift
             }
 
             fn mask_last_limb_b<F: Field>(&self, other: FqSlice<'_, F>, i: usize) -> Limb {
-                let source_limb_masked = other.limbs[i] & self.max_mask;
+                let source_limb_masked = other.limbs()[i] & self.max_mask;
                 source_limb_masked >> self.tail_shift
             }
         }
 
-        let dat = AddShiftRightData::new(self.fq, self.as_slice(), other);
+        let dat = AddShiftRightData::new(self.fq(), self.as_slice(), other);
         let mut i = 0;
         {
-            self.limbs[i + dat.min_target_limb] = self.fq.fma_limb(
-                self.limbs[i + dat.min_target_limb],
+            self.limbs_mut()[i + dat.min_target_limb] = self.fq().fma_limb(
+                self.limbs()[i + dat.min_target_limb],
                 dat.mask_first_limb_a(other, i + dat.min_source_limb),
                 c.clone(),
             );
-            self.limbs[i + dat.min_target_limb] =
-                self.fq.reduce(self.limbs[i + dat.min_target_limb]);
+            self.limbs_mut()[i + dat.min_target_limb] =
+                self.fq().reduce(self.limbs()[i + dat.min_target_limb]);
             if dat.number_of_target_limbs > 1 {
-                self.limbs[i + dat.min_target_limb + 1] = self.fq.fma_limb(
-                    self.limbs[i + dat.min_target_limb + 1],
+                self.limbs_mut()[i + dat.min_target_limb + 1] = self.fq().fma_limb(
+                    self.limbs()[i + dat.min_target_limb + 1],
                     dat.mask_first_limb_b(other, i + dat.min_source_limb),
                     c.clone(),
                 );
             }
         }
         for i in 1..dat.number_of_source_limbs - 1 {
-            self.limbs[i + dat.min_target_limb] = self.fq.fma_limb(
-                self.limbs[i + dat.min_target_limb],
+            self.limbs_mut()[i + dat.min_target_limb] = self.fq().fma_limb(
+                self.limbs()[i + dat.min_target_limb],
                 dat.mask_middle_limb_a(other, i + dat.min_source_limb),
                 c.clone(),
             );
-            self.limbs[i + dat.min_target_limb] =
-                self.fq.reduce(self.limbs[i + dat.min_target_limb]);
-            self.limbs[i + dat.min_target_limb + 1] = self.fq.fma_limb(
-                self.limbs[i + dat.min_target_limb + 1],
+            self.limbs_mut()[i + dat.min_target_limb] =
+                self.fq().reduce(self.limbs()[i + dat.min_target_limb]);
+            self.limbs_mut()[i + dat.min_target_limb + 1] = self.fq().fma_limb(
+                self.limbs()[i + dat.min_target_limb + 1],
                 dat.mask_middle_limb_b(other, i + dat.min_source_limb),
                 c.clone(),
             );
         }
         i = dat.number_of_source_limbs - 1;
         if i > 0 {
-            self.limbs[i + dat.min_target_limb] = self.fq.fma_limb(
-                self.limbs[i + dat.min_target_limb],
+            self.limbs_mut()[i + dat.min_target_limb] = self.fq().fma_limb(
+                self.limbs()[i + dat.min_target_limb],
                 dat.mask_last_limb_a(other, i + dat.min_source_limb),
                 c.clone(),
             );
-            self.limbs[i + dat.min_target_limb] =
-                self.fq.reduce(self.limbs[i + dat.min_target_limb]);
+            self.limbs_mut()[i + dat.min_target_limb] =
+                self.fq().reduce(self.limbs()[i + dat.min_target_limb]);
             if dat.number_of_target_limbs > dat.number_of_source_limbs {
-                self.limbs[i + dat.min_target_limb + 1] = self.fq.fma_limb(
-                    self.limbs[i + dat.min_target_limb + 1],
+                self.limbs_mut()[i + dat.min_target_limb + 1] = self.fq().fma_limb(
+                    self.limbs()[i + dat.min_target_limb + 1],
                     dat.mask_last_limb_b(other, i + dat.min_source_limb),
                     c.clone(),
                 );
             }
         }
         if dat.number_of_target_limbs > dat.number_of_source_limbs {
-            self.limbs[i + dat.min_target_limb + 1] =
-                self.fq.reduce(self.limbs[i + dat.min_target_limb + 1]);
+            self.limbs_mut()[i + dat.min_target_limb + 1] =
+                self.fq().reduce(self.limbs()[i + dat.min_target_limb + 1]);
         }
     }
 
     /// Given a mask v, add the `v[i]`th entry of `other` to the `i`th entry of `self`.
     pub fn add_masked(&mut self, other: FqSlice<'_, F>, c: FieldElement<F>, mask: &[usize]) {
         // TODO: If this ends up being a bottleneck, try to use PDEP/PEXT
-        assert_eq!(self.fq, c.field());
-        assert_eq!(self.fq, other.fq);
+        assert_eq!(self.fq(), c.field());
+        assert_eq!(self.fq(), other.fq());
         assert_eq!(self.as_slice().len(), mask.len());
         for (i, &x) in mask.iter().enumerate() {
             let entry = other.entry(x);
-            if entry != self.fq.zero() {
+            if entry != self.fq().zero() {
                 self.add_basis_element(i, entry * c.clone());
             }
         }
@@ -513,8 +509,8 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
 
     /// Given a mask v, add the `i`th entry of `other` to the `v[i]`th entry of `self`.
     pub fn add_unmasked(&mut self, other: FqSlice<'_, F>, c: FieldElement<F>, mask: &[usize]) {
-        assert_eq!(self.fq, c.field());
-        assert_eq!(self.fq, other.fq);
+        assert_eq!(self.fq(), c.field());
+        assert_eq!(self.fq(), other.fq());
         assert!(other.len() <= mask.len());
         for (i, v) in other.iter_nonzero() {
             self.add_basis_element(mask[i], v * c.clone());
@@ -523,49 +519,35 @@ impl<'a, F: Field> FqSliceMut<'a, F> {
 
     pub fn slice_mut(&mut self, start: usize, end: usize) -> FqSliceMut<'_, F> {
         assert!(start <= end && end <= self.as_slice().len());
-
-        FqSliceMut {
-            fq: self.fq,
-            limbs: &mut *self.limbs,
-            start: self.start + start,
-            end: self.start + end,
-        }
+        let orig_start = self.start();
+
+        FqSliceMut::new(
+            self.fq(),
+            self.limbs_mut(),
+            orig_start + start,
+            orig_start + end,
+        )
     }
 
     #[inline]
     #[must_use]
     pub fn as_slice(&self) -> FqSlice<'_, F> {
-        FqSlice {
-            fq: self.fq,
-            limbs: &*self.limbs,
-            start: self.start,
-            end: self.end,
-        }
+        FqSlice::new(self.fq(), self.limbs(), self.start(), self.end())
     }
 
     /// Generates a version of itself with a shorter lifetime
     #[inline]
     #[must_use]
     pub fn copy(&mut self) -> FqSliceMut<'_, F> {
-        FqSliceMut {
-            fq: self.fq,
-            limbs: self.limbs,
-            start: self.start,
-            end: self.end,
-        }
-    }
-
-    pub(crate) fn limbs(&self) -> &[Limb] {
-        self.limbs
-    }
+        let start = self.start();
+        let end = self.end();
 
-    pub(crate) fn limbs_mut(&mut self) -> &mut [Limb] {
-        self.limbs
+        FqSliceMut::new(self.fq(), self.limbs_mut(), start, end)
     }
 }
 
 impl<'a, F: Field> From<&'a mut FqVector<F>> for FqSliceMut<'a, F> {
     fn from(v: &'a mut FqVector<F>) -> Self {
-        v.slice_mut(0, v.len)
+        v.slice_mut(0, v.len())
     }
 }
diff --git a/ext/crates/fp/src/vector/impl_fqvector.rs b/ext/crates/fp/src/vector/impl_fqvector.rs
index 7810e1d2e..2a472a8b5 100644
--- a/ext/crates/fp/src/vector/impl_fqvector.rs
+++ b/ext/crates/fp/src/vector/impl_fqvector.rs
@@ -15,22 +15,15 @@ use crate::{
 impl<F: Field> FqVector<F> {
     pub fn new(fq: F, len: usize) -> Self {
         let number_of_limbs = fq.number(len);
-        Self {
-            fq,
-            len,
-            limbs: vec![0; number_of_limbs],
-        }
-    }
 
-    pub fn from_raw_parts(fq: F, len: usize, limbs: Vec<Limb>) -> Self {
-        debug_assert_eq!(limbs.len(), fq.number(len));
-        Self { fq, len, limbs }
+        Self::from_raw_parts(fq, len, vec![0; number_of_limbs])
     }
 
     pub fn new_with_capacity(fq: F, len: usize, capacity: usize) -> Self {
         let mut limbs = Vec::with_capacity(fq.number(capacity));
         limbs.resize(fq.number(len), 0);
-        Self { fq, len, limbs }
+
+        Self::from_raw_parts(fq, len, limbs)
     }
 
     pub fn from_slice(fq: F, slice: &[FieldElement<F>]) -> Self {
@@ -54,46 +47,28 @@ impl<F: Field> FqVector<F> {
     pub fn to_bytes(&self, buffer: &mut impl io::Write) -> io::Result<()> {
         // self.limbs is allowed to have more limbs than necessary, but we only save the
         // necessary ones.
-        let num_limbs = self.fq.number(self.len());
+        let num_limbs = self.fq().number(self.len());
         crate::limb::to_bytes(&self.limbs()[..num_limbs], buffer)
     }
 
-    pub fn fq(&self) -> F {
-        self.fq
-    }
-
-    pub const fn len(&self) -> usize {
-        self.len
-    }
-
     pub const fn is_empty(&self) -> bool {
-        self.len == 0
+        self.len() == 0
     }
 
     pub fn prime(&self) -> ValidPrime {
-        self.fq.characteristic().to_dyn()
+        self.fq().characteristic().to_dyn()
     }
 
     #[must_use]
     pub fn slice(&self, start: usize, end: usize) -> FqSlice<'_, F> {
-        assert!(start <= end && end <= self.len);
-        FqSlice {
-            fq: self.fq,
-            limbs: &self.limbs,
-            start,
-            end,
-        }
+        assert!(start <= end && end <= self.len());
+        FqSlice::new(self.fq(), self.limbs(), start, end)
     }
 
     #[must_use]
     pub fn slice_mut(&mut self, start: usize, end: usize) -> FqSliceMut<'_, F> {
-        assert!(start <= end && end <= self.len);
-        FqSliceMut {
-            fq: self.fq,
-            limbs: &mut self.limbs,
-            start,
-            end,
-        }
+        assert!(start <= end && end <= self.len());
+        FqSliceMut::new(self.fq(), self.limbs_mut(), start, end)
     }
 
     #[inline]
@@ -109,7 +84,7 @@ impl<F: Field> FqVector<F> {
     }
 
     pub fn add_basis_element(&mut self, index: usize, value: FieldElement<F>) {
-        assert_eq!(self.fq, value.field());
+        assert_eq!(self.fq(), value.field());
         self.as_slice_mut().add_basis_element(index, value);
     }
 
@@ -118,7 +93,7 @@ impl<F: Field> FqVector<F> {
     }
 
     pub fn set_entry(&mut self, index: usize, value: FieldElement<F>) {
-        assert_eq!(self.fq, value.field());
+        assert_eq!(self.fq(), value.field());
         self.as_slice_mut().set_entry(index, value);
     }
 
@@ -132,19 +107,21 @@ impl<F: Field> FqVector<F> {
 
     pub fn set_to_zero(&mut self) {
         // This is sound because `fq.encode(fq.zero())` is always zero.
-        for limb in &mut self.limbs {
+        for limb in self.limbs_mut() {
             *limb = 0;
         }
     }
 
     pub fn scale(&mut self, c: FieldElement<F>) {
-        assert_eq!(self.fq, c.field());
-        if c == self.fq.zero() {
+        assert_eq!(self.fq(), c.field());
+        let fq = self.fq();
+
+        if c == fq.zero() {
             self.set_to_zero();
         }
-        if self.fq.q() != 2 {
-            for limb in &mut self.limbs {
-                *limb = self.fq.reduce(self.fq.fma_limb(0, *limb, c.clone()));
+        if fq.q() != 2 {
+            for limb in self.limbs_mut() {
+                *limb = fq.reduce(fq.fma_limb(0, *limb, c.clone()));
             }
         }
     }
@@ -152,20 +129,27 @@ impl<F: Field> FqVector<F> {
     /// Add `other` to `self` on the assumption that the first `offset` entries of `other` are
     /// empty.
     pub fn add_offset(&mut self, other: &Self, c: FieldElement<F>, offset: usize) {
-        assert_eq!(self.fq, c.field());
-        assert_eq!(self.fq, other.fq);
+        assert_eq!(self.fq(), c.field());
+        assert_eq!(self.fq(), other.fq());
         assert_eq!(self.len(), other.len());
-        let fq = self.fq;
+
+        let fq = self.fq();
         let min_limb = offset / fq.entries_per_limb();
+
         if fq.q() == 2 {
             if c != fq.zero() {
-                crate::simd::add_simd(&mut self.limbs, &other.limbs, min_limb);
+                crate::simd::add_simd(self.limbs_mut(), other.limbs(), min_limb);
             }
         } else {
-            for (left, right) in self.limbs.iter_mut().zip_eq(&other.limbs).skip(min_limb) {
+            for (left, right) in self
+                .limbs_mut()
+                .iter_mut()
+                .zip_eq(other.limbs())
+                .skip(min_limb)
+            {
                 *left = fq.fma_limb(*left, *right, c.clone());
             }
-            for limb in &mut self.limbs[min_limb..] {
+            for limb in self.limbs_mut()[min_limb..].iter_mut() {
                 *limb = fq.reduce(*limb);
             }
         }
@@ -176,73 +160,69 @@ impl<F: Field> FqVector<F> {
     }
 
     pub fn assign(&mut self, other: &Self) {
-        assert_eq!(self.fq, other.fq);
+        assert_eq!(self.fq(), other.fq());
         assert_eq!(self.len(), other.len());
-        self.limbs.copy_from_slice(&other.limbs)
+        self.limbs_mut().copy_from_slice(other.limbs())
     }
 
     /// A version of [`FqVector::assign`] that allows `other` to be shorter than `self`.
     pub fn assign_partial(&mut self, other: &Self) {
-        assert_eq!(self.fq, other.fq);
+        assert_eq!(self.fq(), other.fq());
         assert!(other.len() <= self.len());
-        self.limbs[0..other.limbs.len()].copy_from_slice(&other.limbs);
-        for limb in self.limbs[other.limbs.len()..].iter_mut() {
+
+        self.limbs_mut()[0..other.limbs().len()].copy_from_slice(other.limbs());
+        for limb in self.limbs_mut()[other.limbs().len()..].iter_mut() {
             *limb = 0;
         }
     }
 
     pub fn is_zero(&self) -> bool {
-        self.limbs.iter().all(|&x| x == 0)
-    }
-
-    pub(crate) fn limbs(&self) -> &[Limb] {
-        &self.limbs
-    }
-
-    pub(crate) fn limbs_mut(&mut self) -> &mut [Limb] {
-        &mut self.limbs
+        self.limbs().iter().all(|&x| x == 0)
     }
 
     /// This function ensures the length of the vector is at least `len`. See also
     /// `set_scratch_vector_size`.
     pub fn extend_len(&mut self, len: usize) {
-        if self.len >= len {
+        if self.len() >= len {
             return;
         }
-        self.len = len;
-        self.limbs.resize(self.fq.number(len), 0);
+        *self.len_mut() = len;
+        let new_len = self.fq().number(len);
+        self.vec_mut().resize(new_len, 0);
     }
 
     /// This clears the vector and sets the length to `len`. This is useful for reusing
     /// allocations of temporary vectors.
     pub fn set_scratch_vector_size(&mut self, len: usize) {
-        self.limbs.clear();
-        self.limbs.resize(self.fq.number(len), 0);
-        self.len = len;
+        self.vec_mut().clear();
+        let new_len = self.fq().number(len);
+        self.vec_mut().resize(new_len, 0);
+        *self.len_mut() = len;
     }
 
     /// This replaces the contents of the vector with the contents of the slice. The two must have
     /// the same length.
     pub fn copy_from_slice(&mut self, slice: &[FieldElement<F>]) {
-        assert!(slice.iter().all(|x| x.field() == self.fq));
-        assert_eq!(self.len, slice.len());
+        assert!(slice.iter().all(|x| x.field() == self.fq()));
+        assert_eq!(self.len(), slice.len());
 
-        self.limbs.clear();
-        self.limbs.extend(
+        let fq = self.fq();
+        self.vec_mut().clear();
+        self.vec_mut().extend(
             slice
-                .chunks(self.fq.entries_per_limb())
-                .map(|x| self.fq.pack(x.iter().cloned())),
+                .chunks(fq.entries_per_limb())
+                .map(|x| fq.pack(x.iter().cloned())),
         );
     }
 
     pub fn sign_rule(&self, other: &Self) -> bool {
-        assert_eq!(self.fq, other.fq);
-        assert_eq!(self.fq.q(), 2);
+        assert_eq!(self.fq(), other.fq());
+        assert_eq!(self.fq().q(), 2);
 
         let mut result = 0;
-        for target_limb_idx in 0..self.limbs.len() {
-            let target_limb = other.limbs[target_limb_idx];
-            let source_limb = self.limbs[target_limb_idx];
+        for target_limb_idx in 0..self.limbs().len() {
+            let target_limb = other.limbs()[target_limb_idx];
+            let source_limb = self.limbs()[target_limb_idx];
             result ^= crate::limb::sign_rule(target_limb, source_limb);
             if target_limb.count_ones().is_multiple_of(2) {
                 continue;
@@ -255,10 +235,11 @@ impl<F: Field> FqVector<F> {
     }
 
     pub fn add_truncate(&mut self, other: &Self, c: FieldElement<F>) -> Option<()> {
-        assert_eq!(self.fq, other.fq);
-        for (left, right) in self.limbs.iter_mut().zip_eq(&other.limbs) {
-            *left = self.fq.fma_limb(*left, *right, c.clone());
-            *left = self.fq.truncate(*left)?;
+        assert_eq!(self.fq(), other.fq());
+        let fq = self.fq();
+        for (left, right) in self.limbs_mut().iter_mut().zip_eq(other.limbs()) {
+            *left = fq.fma_limb(*left, *right, c.clone());
+            *left = fq.truncate(*left)?;
         }
         Some(())
     }
@@ -273,9 +254,9 @@ impl<F: Field> FqVector<F> {
     where
         for<'a> &'a mut T: TryInto<&'a mut Self>,
     {
-        assert_eq!(self.fq, c.field());
-        if self.fq.q() == 2 {
-            let c = self.fq.encode(c);
+        assert_eq!(self.fq(), c.field());
+        if self.fq().q() == 2 {
+            let c = self.fq().encode(c);
             if c == 0 {
                 return false;
             }
@@ -286,16 +267,16 @@ impl<F: Field> FqVector<F> {
                     .try_into()
                     .ok()
                     .expect("rest vectors in add_carry must be of the same prime");
-                let rem = cur_vec.limbs[idx] ^ carry;
-                let quot = cur_vec.limbs[idx] & carry;
-                cur_vec.limbs[idx] = rem;
+                let rem = cur_vec.limbs()[idx] ^ carry;
+                let quot = cur_vec.limbs()[idx] & carry;
+                cur_vec.limbs_mut()[idx] = rem;
                 carry = quot;
                 cur_vec = carry_vec;
                 if quot == 0 {
                     return false;
                 }
             }
-            cur_vec.limbs[idx] ^= carry;
+            cur_vec.limbs_mut()[idx] ^= carry;
             true
         } else {
             unimplemented!()
@@ -306,35 +287,35 @@ impl<F: Field> FqVector<F> {
     where
         for<'a> &'a mut T: TryInto<&'a mut Self>,
     {
-        assert_eq!(self.fq, other.fq);
+        assert_eq!(self.fq(), other.fq());
         let mut result = false;
-        for i in 0..self.limbs.len() {
-            result |= self.add_carry_limb(i, other.limbs[i], c.clone(), rest);
+        for i in 0..self.limbs().len() {
+            result |= self.add_carry_limb(i, other.limbs()[i], c.clone(), rest);
         }
         result
     }
 
     /// Find the index and value of the first non-zero entry of the vector. `None` if the vector is zero.
     pub fn first_nonzero(&self) -> Option<(usize, FieldElement<F>)> {
-        let entries_per_limb = self.fq.entries_per_limb();
-        let bit_length = self.fq.bit_length();
-        let bitmask = self.fq.bitmask();
-        for (i, &limb) in self.limbs.iter().enumerate() {
+        let entries_per_limb = self.fq().entries_per_limb();
+        let bit_length = self.fq().bit_length();
+        let bitmask = self.fq().bitmask();
+        for (i, &limb) in self.limbs().iter().enumerate() {
             if limb == 0 {
                 continue;
             }
             let index = limb.trailing_zeros() as usize / bit_length;
             return Some((
                 i * entries_per_limb + index,
-                self.fq.decode((limb >> (index * bit_length)) & bitmask),
+                self.fq().decode((limb >> (index * bit_length)) & bitmask),
             ));
         }
         None
     }
 
     pub fn density(&self) -> f32 {
-        let num_nonzero = if self.fq.q() == 2 {
-            self.limbs
+        let num_nonzero = if self.fq().q() == 2 {
+            self.limbs()
                 .iter()
                 .copied()
                 .map(Limb::count_ones)
diff --git a/ext/crates/fp/src/vector/inner.rs b/ext/crates/fp/src/vector/inner.rs
index 21661bc38..430e0b83e 100644
--- a/ext/crates/fp/src/vector/inner.rs
+++ b/ext/crates/fp/src/vector/inner.rs
@@ -9,9 +9,9 @@ use crate::{field::Field, limb::Limb};
 /// not leave the `fp` library.
 #[derive(Debug, Hash, Eq, PartialEq, Clone)]
 pub struct FqVector<F: Field> {
-    pub(super) fq: F,
-    pub(super) len: usize,
-    pub(super) limbs: Vec<Limb>,
+    fq: F,
+    len: usize,
+    limbs: Vec<Limb>,
 }
 
 /// A slice of an `FqVector`.
@@ -19,10 +19,10 @@ pub struct FqVector<F: Field> {
 /// This immutably borrows the vector and implements `Copy`.
 #[derive(Debug, Copy, Clone)]
 pub struct FqSlice<'a, F: Field> {
-    pub(super) fq: F,
-    pub(super) limbs: &'a [Limb],
-    pub(super) start: usize,
-    pub(super) end: usize,
+    fq: F,
+    limbs: &'a [Limb],
+    start: usize,
+    end: usize,
 }
 
 /// A mutable slice of an `FqVector`.
@@ -32,10 +32,109 @@ pub struct FqSlice<'a, F: Field> {
 /// borrows `FqSliceMut` and returns a `FqSliceMut` with a shorter lifetime.
 #[derive(Debug)]
 pub struct FqSliceMut<'a, F: Field> {
-    pub(super) fq: F,
-    pub(super) limbs: &'a mut [Limb],
-    pub(super) start: usize,
-    pub(super) end: usize,
+    fq: F,
+    limbs: &'a mut [Limb],
+    start: usize,
+    end: usize,
 }
 
 // See impl_* for implementations
+
+// Accessors
+
+impl<F: Field> FqVector<F> {
+    pub fn from_raw_parts(fq: F, len: usize, limbs: Vec<Limb>) -> Self {
+        debug_assert_eq!(limbs.len(), fq.number(len));
+        Self { fq, len, limbs }
+    }
+
+    pub fn fq(&self) -> F {
+        self.fq
+    }
+
+    pub const fn len(&self) -> usize {
+        self.len
+    }
+
+    pub(super) fn limbs(&self) -> &[Limb] {
+        &self.limbs
+    }
+
+    pub(super) fn limbs_mut(&mut self) -> &mut [Limb] {
+        &mut self.limbs
+    }
+
+    pub(super) fn vec_mut(&mut self) -> &mut Vec<Limb> {
+        &mut self.limbs
+    }
+
+    pub(super) fn len_mut(&mut self) -> &mut usize {
+        &mut self.len
+    }
+}
+
+impl<'a, F: Field> FqSlice<'a, F> {
+    pub(super) fn new(fq: F, limbs: &'a [Limb], start: usize, end: usize) -> Self {
+        Self {
+            fq,
+            limbs,
+            start,
+            end,
+        }
+    }
+
+    pub fn fq(&self) -> F {
+        self.fq
+    }
+
+    pub(super) fn into_limbs(self) -> &'a [Limb] {
+        self.limbs
+    }
+
+    pub(super) const fn start(&self) -> usize {
+        self.start
+    }
+
+    pub(super) const fn end(&self) -> usize {
+        self.end
+    }
+
+    pub(super) fn limbs(&self) -> &[Limb] {
+        self.limbs
+    }
+}
+
+impl<'a, F: Field> FqSliceMut<'a, F> {
+    pub(super) fn new(fq: F, limbs: &'a mut [Limb], start: usize, end: usize) -> Self {
+        Self {
+            fq,
+            limbs,
+            start,
+            end,
+        }
+    }
+
+    pub fn fq(&self) -> F {
+        self.fq
+    }
+
+    pub(super) fn start(&self) -> usize {
+        self.start
+    }
+
+    pub(super) fn end(&self) -> usize {
+        self.end
+    }
+
+    pub(super) fn end_mut(&mut self) -> &mut usize {
+        &mut self.end
+    }
+
+    pub(super) fn limbs(&self) -> &[Limb] {
+        self.limbs
+    }
+
+    pub(super) fn limbs_mut(&mut self) -> &mut [Limb] {
+        self.limbs
+    }
+}
diff --git a/ext/crates/fp/src/vector/iter.rs b/ext/crates/fp/src/vector/iter.rs
index 0a7462176..3dcc00a0a 100644
--- a/ext/crates/fp/src/vector/iter.rs
+++ b/ext/crates/fp/src/vector/iter.rs
@@ -19,11 +19,11 @@ pub struct FqVectorIterator<'a, F> {
 impl<'a, F: Field> FqVectorIterator<'a, F> {
     pub(super) fn new(vec: FqSlice<'a, F>) -> Self {
         let counter = vec.len();
-        let limbs = vec.limbs;
+        let limbs = vec.into_limbs();
 
         if counter == 0 {
             return Self {
-                fq: vec.fq,
+                fq: vec.fq(),
                 limbs,
                 bit_length: 0,
                 entries_per_limb_m_1: 0,
@@ -34,20 +34,20 @@ impl<'a, F: Field> FqVectorIterator<'a, F> {
                 counter,
             };
         }
-        let pair = vec.fq.limb_bit_index_pair(vec.start);
+        let pair = vec.fq().limb_bit_index_pair(vec.start());
 
-        let bit_length = vec.fq.bit_length();
+        let bit_length = vec.fq().bit_length();
         let cur_limb = limbs[pair.limb] >> pair.bit_index;
 
-        let entries_per_limb = vec.fq.entries_per_limb();
+        let entries_per_limb = vec.fq().entries_per_limb();
         Self {
-            fq: vec.fq,
+            fq: vec.fq(),
             limbs,
             bit_length,
             entries_per_limb_m_1: entries_per_limb - 1,
-            bit_mask: vec.fq.bitmask(),
+            bit_mask: vec.fq().bitmask(),
             limb_index: pair.limb,
-            entries_left: entries_per_limb - (vec.start % entries_per_limb),
+            entries_left: entries_per_limb - (vec.start() % entries_per_limb),
             cur_limb,
             counter,
         }
@@ -126,14 +126,14 @@ pub struct FqVectorNonZeroIterator<'a, F> {
 
 impl<'a, F: Field> FqVectorNonZeroIterator<'a, F> {
     pub(super) fn new(vec: FqSlice<'a, F>) -> Self {
-        let entries_per_limb = vec.fq.entries_per_limb();
+        let entries_per_limb = vec.fq().entries_per_limb();
 
         let dim = vec.len();
-        let limbs = vec.limbs;
+        let limbs = vec.into_limbs();
 
         if dim == 0 {
             return Self {
-                fq: vec.fq,
+                fq: vec.fq(),
                 limbs,
                 limb_index: 0,
                 cur_limb_entries_left: 0,
@@ -142,12 +142,12 @@ impl<'a, F: Field> FqVectorNonZeroIterator<'a, F> {
                 dim: 0,
             };
         }
-        let min_index = vec.start;
-        let pair = vec.fq.limb_bit_index_pair(min_index);
+        let min_index = vec.start();
+        let pair = vec.fq().limb_bit_index_pair(min_index);
         let cur_limb = limbs[pair.limb] >> pair.bit_index;
         let cur_limb_entries_left = entries_per_limb - (min_index % entries_per_limb);
         Self {
-            fq: vec.fq,
+            fq: vec.fq(),
             limbs,
             limb_index: pair.limb,
             cur_limb_entries_left,