From 6e8673dcde2e55ecd81ebb7c67d3c23774a0decf Mon Sep 17 00:00:00 2001
From: Pratyush Mishra <pratyushmishra@berkeley.edu>
Date: Wed, 3 Jan 2024 14:57:53 -0500
Subject: [PATCH] Rename `to_{non_unique_}bytes` -> `to_{non_unique_}bytes_le`

---
 src/boolean/convert.rs                        |  2 +-
 src/boolean/mod.rs                            |  2 +-
 src/convert.rs                                | 16 ++--
 src/fields/cubic_extension.rs                 | 16 ++--
 src/fields/emulated_fp/allocated_field_var.rs |  2 +-
 src/fields/emulated_fp/field_var.rs           |  8 +-
 src/fields/fp/mod.rs                          | 12 +--
 src/fields/quadratic_extension.rs             | 12 +--
 .../curves/short_weierstrass/bls12/mod.rs     | 28 +++----
 .../curves/short_weierstrass/mnt4/mod.rs      | 80 +++++++++----------
 .../curves/short_weierstrass/mnt6/mod.rs      | 80 +++++++++----------
 src/groups/curves/short_weierstrass/mod.rs    | 16 ++--
 src/groups/curves/twisted_edwards/mod.rs      | 12 +--
 src/uint/convert.rs                           | 14 ++--
 14 files changed, 152 insertions(+), 148 deletions(-)

diff --git a/src/boolean/convert.rs b/src/boolean/convert.rs
index 21e9fc09..d4ce1518 100644
--- a/src/boolean/convert.rs
+++ b/src/boolean/convert.rs
@@ -4,7 +4,7 @@ use crate::convert::{ToBytesGadget, ToConstraintFieldGadget};
 impl<F: Field> ToBytesGadget<F> for Boolean<F> {
     /// Outputs `1u8` if `self` is true, and `0u8` otherwise.
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
         let value = self.value().map(u8::from).ok();
         let mut bits = [Boolean::FALSE; 8];
         bits[0] = self.clone();
diff --git a/src/boolean/mod.rs b/src/boolean/mod.rs
index 0193f58b..f32c4a45 100644
--- a/src/boolean/mod.rs
+++ b/src/boolean/mod.rs
@@ -215,7 +215,7 @@ mod test {
         for val in [true, false].iter() {
             let cs = ConstraintSystem::<Fr>::new_ref();
             let a = Boolean::new_witness(cs.clone(), || Ok(*val))?;
-            let bytes = a.to_bytes()?;
+            let bytes = a.to_bytes_le()?;
             assert_eq!(bytes.len(), 1);
             let byte = &bytes[0];
             assert_eq!(byte.value()?, *val as u8);
diff --git a/src/convert.rs b/src/convert.rs
index e04abc48..c6f6b1e7 100644
--- a/src/convert.rs
+++ b/src/convert.rs
@@ -69,20 +69,24 @@ pub trait ToBytesGadget<F: Field> {
     /// Outputs a canonical, little-endian, byte decomposition of `self`.
     ///
     /// This is the correct default for 99% of use cases.
-    fn to_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError>;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError>;
 
     /// Outputs a possibly non-unique byte decomposition of `self`.
     ///
     /// If you're not absolutely certain that your usecase can get away with a
-    /// non-canonical representation, please use `self.to_bytes(cs)` instead.
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
-        self.to_bytes()
+    /// non-canonical representation, please use `self.to_bytes_le(cs)` instead.
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+        self.to_bytes_le()
     }
 }
 
 impl<'a, F: Field, T: 'a + ToBytesGadget<F>> ToBytesGadget<F> for &'a T {
-    fn to_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
-        (*self).to_bytes()
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+        (*self).to_bytes_le()
+    }
+
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+        (*self).to_non_unique_bytes_le()
     }
 }
 
diff --git a/src/fields/cubic_extension.rs b/src/fields/cubic_extension.rs
index 20c040f4..d0b64a71 100644
--- a/src/fields/cubic_extension.rs
+++ b/src/fields/cubic_extension.rs
@@ -435,10 +435,10 @@ where
     P: CubicExtVarConfig<BF>,
 {
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::BasePrimeField>>, SynthesisError> {
-        let mut c0 = self.c0.to_bytes()?;
-        let mut c1 = self.c1.to_bytes()?;
-        let mut c2 = self.c2.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::BasePrimeField>>, SynthesisError> {
+        let mut c0 = self.c0.to_bytes_le()?;
+        let mut c1 = self.c1.to_bytes_le()?;
+        let mut c2 = self.c2.to_bytes_le()?;
         c0.append(&mut c1);
         c0.append(&mut c2);
 
@@ -446,10 +446,10 @@ where
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::BasePrimeField>>, SynthesisError> {
-        let mut c0 = self.c0.to_non_unique_bytes()?;
-        let mut c1 = self.c1.to_non_unique_bytes()?;
-        let mut c2 = self.c2.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::BasePrimeField>>, SynthesisError> {
+        let mut c0 = self.c0.to_non_unique_bytes_le()?;
+        let mut c1 = self.c1.to_non_unique_bytes_le()?;
+        let mut c2 = self.c2.to_non_unique_bytes_le()?;
 
         c0.append(&mut c1);
         c0.append(&mut c2);
diff --git a/src/fields/emulated_fp/allocated_field_var.rs b/src/fields/emulated_fp/allocated_field_var.rs
index 92b575fd..095563a7 100644
--- a/src/fields/emulated_fp/allocated_field_var.rs
+++ b/src/fields/emulated_fp/allocated_field_var.rs
@@ -681,7 +681,7 @@ impl<TargetF: PrimeField, BaseF: PrimeField> ToBytesGadget<BaseF>
     for AllocatedEmulatedFpVar<TargetF, BaseF>
 {
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> R1CSResult<Vec<UInt8<BaseF>>> {
+    fn to_bytes_le(&self) -> R1CSResult<Vec<UInt8<BaseF>>> {
         let mut bits = self.to_bits_le()?;
 
         let num_bits = TargetF::BigInt::NUM_LIMBS * 64;
diff --git a/src/fields/emulated_fp/field_var.rs b/src/fields/emulated_fp/field_var.rs
index 09fcc22b..b8ad9052 100644
--- a/src/fields/emulated_fp/field_var.rs
+++ b/src/fields/emulated_fp/field_var.rs
@@ -297,23 +297,23 @@ impl<TargetF: PrimeField, BaseF: PrimeField> ToBytesGadget<BaseF>
     /// Outputs the unique byte decomposition of `self` in *little-endian*
     /// form.
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> R1CSResult<Vec<UInt8<BaseF>>> {
+    fn to_bytes_le(&self) -> R1CSResult<Vec<UInt8<BaseF>>> {
         match self {
             Self::Constant(c) => Ok(UInt8::constant_vec(
                 c.into_bigint().to_bytes_le().as_slice(),
             )),
 
-            Self::Var(v) => v.to_bytes(),
+            Self::Var(v) => v.to_bytes_le(),
         }
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> R1CSResult<Vec<UInt8<BaseF>>> {
+    fn to_non_unique_bytes_le(&self) -> R1CSResult<Vec<UInt8<BaseF>>> {
         match self {
             Self::Constant(c) => Ok(UInt8::constant_vec(
                 c.into_bigint().to_bytes_le().as_slice(),
             )),
-            Self::Var(v) => v.to_non_unique_bytes(),
+            Self::Var(v) => v.to_non_unique_bytes_le(),
         }
     }
 }
diff --git a/src/fields/fp/mod.rs b/src/fields/fp/mod.rs
index ae01d9b3..eff7cf67 100644
--- a/src/fields/fp/mod.rs
+++ b/src/fields/fp/mod.rs
@@ -552,7 +552,7 @@ impl<F: PrimeField> ToBytesGadget<F> for AllocatedFp<F> {
     /// This method enforces that the decomposition represents
     /// an integer that is less than `F::MODULUS`.
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
         let num_bits = F::BigInt::NUM_LIMBS * 64;
         let mut bits = self.to_bits_le()?;
         let remainder = core::iter::repeat(Boolean::constant(false)).take(num_bits - bits.len());
@@ -565,7 +565,7 @@ impl<F: PrimeField> ToBytesGadget<F> for AllocatedFp<F> {
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
         let num_bits = F::BigInt::NUM_LIMBS * 64;
         let mut bits = self.to_non_unique_bits_le()?;
         let remainder = core::iter::repeat(Boolean::constant(false)).take(num_bits - bits.len());
@@ -957,22 +957,22 @@ impl<F: PrimeField> ToBytesGadget<F> for FpVar<F> {
     /// Outputs the unique byte decomposition of `self` in *little-endian*
     /// form.
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
         match self {
             Self::Constant(c) => Ok(UInt8::constant_vec(
                 c.into_bigint().to_bytes_le().as_slice(),
             )),
-            Self::Var(v) => v.to_bytes(),
+            Self::Var(v) => v.to_bytes_le(),
         }
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
         match self {
             Self::Constant(c) => Ok(UInt8::constant_vec(
                 c.into_bigint().to_bytes_le().as_slice(),
             )),
-            Self::Var(v) => v.to_non_unique_bytes(),
+            Self::Var(v) => v.to_non_unique_bytes_le(),
         }
     }
 }
diff --git a/src/fields/quadratic_extension.rs b/src/fields/quadratic_extension.rs
index da944cfd..a38f47c1 100644
--- a/src/fields/quadratic_extension.rs
+++ b/src/fields/quadratic_extension.rs
@@ -435,17 +435,17 @@ where
     P: QuadExtVarConfig<BF>,
 {
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::BasePrimeField>>, SynthesisError> {
-        let mut c0 = self.c0.to_bytes()?;
-        let mut c1 = self.c1.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::BasePrimeField>>, SynthesisError> {
+        let mut c0 = self.c0.to_bytes_le()?;
+        let mut c1 = self.c1.to_bytes_le()?;
         c0.append(&mut c1);
         Ok(c0)
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::BasePrimeField>>, SynthesisError> {
-        let mut c0 = self.c0.to_non_unique_bytes()?;
-        let mut c1 = self.c1.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::BasePrimeField>>, SynthesisError> {
+        let mut c0 = self.c0.to_non_unique_bytes_le()?;
+        let mut c1 = self.c1.to_non_unique_bytes_le()?;
         c0.append(&mut c1);
         Ok(c0)
     }
diff --git a/src/groups/curves/short_weierstrass/bls12/mod.rs b/src/groups/curves/short_weierstrass/bls12/mod.rs
index 7ac9f9b8..deb6b19a 100644
--- a/src/groups/curves/short_weierstrass/bls12/mod.rs
+++ b/src/groups/curves/short_weierstrass/bls12/mod.rs
@@ -79,20 +79,20 @@ impl<P: Bls12Config> AllocVar<G1Prepared<P>, P::Fp> for G1PreparedVar<P> {
 impl<P: Bls12Config> ToBytesGadget<P::Fp> for G1PreparedVar<P> {
     #[inline]
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut bytes = self.0.x.to_bytes()?;
-        let y_bytes = self.0.y.to_bytes()?;
-        let inf_bytes = self.0.infinity.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut bytes = self.0.x.to_bytes_le()?;
+        let y_bytes = self.0.y.to_bytes_le()?;
+        let inf_bytes = self.0.infinity.to_bytes_le()?;
         bytes.extend_from_slice(&y_bytes);
         bytes.extend_from_slice(&inf_bytes);
         Ok(bytes)
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut bytes = self.0.x.to_non_unique_bytes()?;
-        let y_bytes = self.0.y.to_non_unique_bytes()?;
-        let inf_bytes = self.0.infinity.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut bytes = self.0.x.to_non_unique_bytes_le()?;
+        let y_bytes = self.0.y.to_non_unique_bytes_le()?;
+        let inf_bytes = self.0.infinity.to_non_unique_bytes_le()?;
         bytes.extend_from_slice(&y_bytes);
         bytes.extend_from_slice(&inf_bytes);
         Ok(bytes)
@@ -174,21 +174,21 @@ impl<P: Bls12Config> AllocVar<G2Prepared<P>, P::Fp> for G2PreparedVar<P> {
 impl<P: Bls12Config> ToBytesGadget<P::Fp> for G2PreparedVar<P> {
     #[inline]
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
         let mut bytes = Vec::new();
         for coeffs in &self.ell_coeffs {
-            bytes.extend_from_slice(&coeffs.0.to_bytes()?);
-            bytes.extend_from_slice(&coeffs.1.to_bytes()?);
+            bytes.extend_from_slice(&coeffs.0.to_bytes_le()?);
+            bytes.extend_from_slice(&coeffs.1.to_bytes_le()?);
         }
         Ok(bytes)
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
         let mut bytes = Vec::new();
         for coeffs in &self.ell_coeffs {
-            bytes.extend_from_slice(&coeffs.0.to_non_unique_bytes()?);
-            bytes.extend_from_slice(&coeffs.1.to_non_unique_bytes()?);
+            bytes.extend_from_slice(&coeffs.0.to_non_unique_bytes_le()?);
+            bytes.extend_from_slice(&coeffs.1.to_non_unique_bytes_le()?);
         }
         Ok(bytes)
     }
diff --git a/src/groups/curves/short_weierstrass/mnt4/mod.rs b/src/groups/curves/short_weierstrass/mnt4/mod.rs
index 7908852e..3b960c82 100644
--- a/src/groups/curves/short_weierstrass/mnt4/mod.rs
+++ b/src/groups/curves/short_weierstrass/mnt4/mod.rs
@@ -105,11 +105,11 @@ impl<P: MNT4Config> G1PreparedVar<P> {
 impl<P: MNT4Config> ToBytesGadget<P::Fp> for G1PreparedVar<P> {
     #[inline]
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut x = self.x.to_bytes()?;
-        let mut y = self.y.to_bytes()?;
-        let mut x_twist = self.x_twist.to_bytes()?;
-        let mut y_twist = self.y_twist.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut x = self.x.to_bytes_le()?;
+        let mut y = self.y.to_bytes_le()?;
+        let mut x_twist = self.x_twist.to_bytes_le()?;
+        let mut y_twist = self.y_twist.to_bytes_le()?;
 
         x.append(&mut y);
         x.append(&mut x_twist);
@@ -118,11 +118,11 @@ impl<P: MNT4Config> ToBytesGadget<P::Fp> for G1PreparedVar<P> {
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut x = self.x.to_non_unique_bytes()?;
-        let mut y = self.y.to_non_unique_bytes()?;
-        let mut x_twist = self.x_twist.to_non_unique_bytes()?;
-        let mut y_twist = self.y_twist.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut x = self.x.to_non_unique_bytes_le()?;
+        let mut y = self.y.to_non_unique_bytes_le()?;
+        let mut x_twist = self.x_twist.to_non_unique_bytes_le()?;
+        let mut y_twist = self.y_twist.to_non_unique_bytes_le()?;
 
         x.append(&mut y);
         x.append(&mut x_twist);
@@ -201,41 +201,41 @@ impl<P: MNT4Config> AllocVar<G2Prepared<P>, P::Fp> for G2PreparedVar<P> {
 impl<P: MNT4Config> ToBytesGadget<P::Fp> for G2PreparedVar<P> {
     #[inline]
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut x = self.x.to_bytes()?;
-        let mut y = self.y.to_bytes()?;
-        let mut x_over_twist = self.x_over_twist.to_bytes()?;
-        let mut y_over_twist = self.y_over_twist.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut x = self.x.to_bytes_le()?;
+        let mut y = self.y.to_bytes_le()?;
+        let mut x_over_twist = self.x_over_twist.to_bytes_le()?;
+        let mut y_over_twist = self.y_over_twist.to_bytes_le()?;
 
         x.append(&mut y);
         x.append(&mut x_over_twist);
         x.append(&mut y_over_twist);
 
         for coeff in &self.double_coefficients {
-            x.extend_from_slice(&coeff.to_bytes()?);
+            x.extend_from_slice(&coeff.to_bytes_le()?);
         }
         for coeff in &self.addition_coefficients {
-            x.extend_from_slice(&coeff.to_bytes()?);
+            x.extend_from_slice(&coeff.to_bytes_le()?);
         }
         Ok(x)
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut x = self.x.to_non_unique_bytes()?;
-        let mut y = self.y.to_non_unique_bytes()?;
-        let mut x_over_twist = self.x_over_twist.to_non_unique_bytes()?;
-        let mut y_over_twist = self.y_over_twist.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut x = self.x.to_non_unique_bytes_le()?;
+        let mut y = self.y.to_non_unique_bytes_le()?;
+        let mut x_over_twist = self.x_over_twist.to_non_unique_bytes_le()?;
+        let mut y_over_twist = self.y_over_twist.to_non_unique_bytes_le()?;
 
         x.append(&mut y);
         x.append(&mut x_over_twist);
         x.append(&mut y_over_twist);
 
         for coeff in &self.double_coefficients {
-            x.extend_from_slice(&coeff.to_non_unique_bytes()?);
+            x.extend_from_slice(&coeff.to_non_unique_bytes_le()?);
         }
         for coeff in &self.addition_coefficients {
-            x.extend_from_slice(&coeff.to_non_unique_bytes()?);
+            x.extend_from_slice(&coeff.to_non_unique_bytes_le()?);
         }
         Ok(x)
     }
@@ -379,11 +379,11 @@ impl<P: MNT4Config> AllocVar<AteDoubleCoefficients<P>, P::Fp> for AteDoubleCoeff
 impl<P: MNT4Config> ToBytesGadget<P::Fp> for AteDoubleCoefficientsVar<P> {
     #[inline]
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut c_h = self.c_h.to_bytes()?;
-        let mut c_4c = self.c_4c.to_bytes()?;
-        let mut c_j = self.c_j.to_bytes()?;
-        let mut c_l = self.c_l.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut c_h = self.c_h.to_bytes_le()?;
+        let mut c_4c = self.c_4c.to_bytes_le()?;
+        let mut c_j = self.c_j.to_bytes_le()?;
+        let mut c_l = self.c_l.to_bytes_le()?;
 
         c_h.append(&mut c_4c);
         c_h.append(&mut c_j);
@@ -392,11 +392,11 @@ impl<P: MNT4Config> ToBytesGadget<P::Fp> for AteDoubleCoefficientsVar<P> {
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut c_h = self.c_h.to_non_unique_bytes()?;
-        let mut c_4c = self.c_4c.to_non_unique_bytes()?;
-        let mut c_j = self.c_j.to_non_unique_bytes()?;
-        let mut c_l = self.c_l.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut c_h = self.c_h.to_non_unique_bytes_le()?;
+        let mut c_4c = self.c_4c.to_non_unique_bytes_le()?;
+        let mut c_j = self.c_j.to_non_unique_bytes_le()?;
+        let mut c_l = self.c_l.to_non_unique_bytes_le()?;
 
         c_h.append(&mut c_4c);
         c_h.append(&mut c_j);
@@ -456,18 +456,18 @@ impl<P: MNT4Config> AllocVar<AteAdditionCoefficients<P>, P::Fp> for AteAdditionC
 impl<P: MNT4Config> ToBytesGadget<P::Fp> for AteAdditionCoefficientsVar<P> {
     #[inline]
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut c_l1 = self.c_l1.to_bytes()?;
-        let mut c_rz = self.c_rz.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut c_l1 = self.c_l1.to_bytes_le()?;
+        let mut c_rz = self.c_rz.to_bytes_le()?;
 
         c_l1.append(&mut c_rz);
         Ok(c_l1)
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut c_l1 = self.c_l1.to_non_unique_bytes()?;
-        let mut c_rz = self.c_rz.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut c_l1 = self.c_l1.to_non_unique_bytes_le()?;
+        let mut c_rz = self.c_rz.to_non_unique_bytes_le()?;
 
         c_l1.append(&mut c_rz);
         Ok(c_l1)
diff --git a/src/groups/curves/short_weierstrass/mnt6/mod.rs b/src/groups/curves/short_weierstrass/mnt6/mod.rs
index 9e534298..3fdf923d 100644
--- a/src/groups/curves/short_weierstrass/mnt6/mod.rs
+++ b/src/groups/curves/short_weierstrass/mnt6/mod.rs
@@ -105,11 +105,11 @@ impl<P: MNT6Config> AllocVar<G1Prepared<P>, P::Fp> for G1PreparedVar<P> {
 impl<P: MNT6Config> ToBytesGadget<P::Fp> for G1PreparedVar<P> {
     #[inline]
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut x = self.x.to_bytes()?;
-        let mut y = self.y.to_bytes()?;
-        let mut x_twist = self.x_twist.to_bytes()?;
-        let mut y_twist = self.y_twist.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut x = self.x.to_bytes_le()?;
+        let mut y = self.y.to_bytes_le()?;
+        let mut x_twist = self.x_twist.to_bytes_le()?;
+        let mut y_twist = self.y_twist.to_bytes_le()?;
 
         x.append(&mut y);
         x.append(&mut x_twist);
@@ -118,11 +118,11 @@ impl<P: MNT6Config> ToBytesGadget<P::Fp> for G1PreparedVar<P> {
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut x = self.x.to_non_unique_bytes()?;
-        let mut y = self.y.to_non_unique_bytes()?;
-        let mut x_twist = self.x_twist.to_non_unique_bytes()?;
-        let mut y_twist = self.y_twist.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut x = self.x.to_non_unique_bytes_le()?;
+        let mut y = self.y.to_non_unique_bytes_le()?;
+        let mut x_twist = self.x_twist.to_non_unique_bytes_le()?;
+        let mut y_twist = self.y_twist.to_non_unique_bytes_le()?;
 
         x.append(&mut y);
         x.append(&mut x_twist);
@@ -201,41 +201,41 @@ impl<P: MNT6Config> AllocVar<G2Prepared<P>, P::Fp> for G2PreparedVar<P> {
 impl<P: MNT6Config> ToBytesGadget<P::Fp> for G2PreparedVar<P> {
     #[inline]
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut x = self.x.to_bytes()?;
-        let mut y = self.y.to_bytes()?;
-        let mut x_over_twist = self.x_over_twist.to_bytes()?;
-        let mut y_over_twist = self.y_over_twist.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut x = self.x.to_bytes_le()?;
+        let mut y = self.y.to_bytes_le()?;
+        let mut x_over_twist = self.x_over_twist.to_bytes_le()?;
+        let mut y_over_twist = self.y_over_twist.to_bytes_le()?;
 
         x.append(&mut y);
         x.append(&mut x_over_twist);
         x.append(&mut y_over_twist);
 
         for coeff in self.double_coefficients.iter() {
-            x.extend_from_slice(&coeff.to_bytes()?);
+            x.extend_from_slice(&coeff.to_bytes_le()?);
         }
         for coeff in self.addition_coefficients.iter() {
-            x.extend_from_slice(&coeff.to_bytes()?);
+            x.extend_from_slice(&coeff.to_bytes_le()?);
         }
         Ok(x)
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut x = self.x.to_non_unique_bytes()?;
-        let mut y = self.y.to_non_unique_bytes()?;
-        let mut x_over_twist = self.x_over_twist.to_non_unique_bytes()?;
-        let mut y_over_twist = self.y_over_twist.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut x = self.x.to_non_unique_bytes_le()?;
+        let mut y = self.y.to_non_unique_bytes_le()?;
+        let mut x_over_twist = self.x_over_twist.to_non_unique_bytes_le()?;
+        let mut y_over_twist = self.y_over_twist.to_non_unique_bytes_le()?;
 
         x.append(&mut y);
         x.append(&mut x_over_twist);
         x.append(&mut y_over_twist);
 
         for coeff in self.double_coefficients.iter() {
-            x.extend_from_slice(&coeff.to_non_unique_bytes()?);
+            x.extend_from_slice(&coeff.to_non_unique_bytes_le()?);
         }
         for coeff in self.addition_coefficients.iter() {
-            x.extend_from_slice(&coeff.to_non_unique_bytes()?);
+            x.extend_from_slice(&coeff.to_non_unique_bytes_le()?);
         }
         Ok(x)
     }
@@ -379,11 +379,11 @@ impl<P: MNT6Config> AllocVar<AteDoubleCoefficients<P>, P::Fp> for AteDoubleCoeff
 impl<P: MNT6Config> ToBytesGadget<P::Fp> for AteDoubleCoefficientsVar<P> {
     #[inline]
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut c_h = self.c_h.to_bytes()?;
-        let mut c_4c = self.c_4c.to_bytes()?;
-        let mut c_j = self.c_j.to_bytes()?;
-        let mut c_l = self.c_l.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut c_h = self.c_h.to_bytes_le()?;
+        let mut c_4c = self.c_4c.to_bytes_le()?;
+        let mut c_j = self.c_j.to_bytes_le()?;
+        let mut c_l = self.c_l.to_bytes_le()?;
 
         c_h.append(&mut c_4c);
         c_h.append(&mut c_j);
@@ -392,11 +392,11 @@ impl<P: MNT6Config> ToBytesGadget<P::Fp> for AteDoubleCoefficientsVar<P> {
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut c_h = self.c_h.to_non_unique_bytes()?;
-        let mut c_4c = self.c_4c.to_non_unique_bytes()?;
-        let mut c_j = self.c_j.to_non_unique_bytes()?;
-        let mut c_l = self.c_l.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut c_h = self.c_h.to_non_unique_bytes_le()?;
+        let mut c_4c = self.c_4c.to_non_unique_bytes_le()?;
+        let mut c_j = self.c_j.to_non_unique_bytes_le()?;
+        let mut c_l = self.c_l.to_non_unique_bytes_le()?;
 
         c_h.append(&mut c_4c);
         c_h.append(&mut c_j);
@@ -454,18 +454,18 @@ impl<P: MNT6Config> AllocVar<AteAdditionCoefficients<P>, P::Fp> for AteAdditionC
 impl<P: MNT6Config> ToBytesGadget<P::Fp> for AteAdditionCoefficientsVar<P> {
     #[inline]
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut c_l1 = self.c_l1.to_bytes()?;
-        let mut c_rz = self.c_rz.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut c_l1 = self.c_l1.to_bytes_le()?;
+        let mut c_rz = self.c_rz.to_bytes_le()?;
 
         c_l1.append(&mut c_rz);
         Ok(c_l1)
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
-        let mut c_l1 = self.c_l1.to_non_unique_bytes()?;
-        let mut c_rz = self.c_rz.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<P::Fp>>, SynthesisError> {
+        let mut c_l1 = self.c_l1.to_non_unique_bytes_le()?;
+        let mut c_rz = self.c_rz.to_non_unique_bytes_le()?;
 
         c_l1.append(&mut c_rz);
         Ok(c_l1)
diff --git a/src/groups/curves/short_weierstrass/mod.rs b/src/groups/curves/short_weierstrass/mod.rs
index 82743058..d18f7209 100644
--- a/src/groups/curves/short_weierstrass/mod.rs
+++ b/src/groups/curves/short_weierstrass/mod.rs
@@ -953,22 +953,22 @@ where
     for<'a> &'a F: FieldOpsBounds<'a, P::BaseField, F>,
 {
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<BasePrimeField<P>>>, SynthesisError> {
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<BasePrimeField<P>>>, SynthesisError> {
         let g = self.to_affine()?;
-        let mut bytes = g.x.to_bytes()?;
-        let y_bytes = g.y.to_bytes()?;
-        let inf_bytes = g.infinity.to_bytes()?;
+        let mut bytes = g.x.to_bytes_le()?;
+        let y_bytes = g.y.to_bytes_le()?;
+        let inf_bytes = g.infinity.to_bytes_le()?;
         bytes.extend_from_slice(&y_bytes);
         bytes.extend_from_slice(&inf_bytes);
         Ok(bytes)
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<BasePrimeField<P>>>, SynthesisError> {
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<BasePrimeField<P>>>, SynthesisError> {
         let g = self.to_affine()?;
-        let mut bytes = g.x.to_non_unique_bytes()?;
-        let y_bytes = g.y.to_non_unique_bytes()?;
-        let inf_bytes = g.infinity.to_non_unique_bytes()?;
+        let mut bytes = g.x.to_non_unique_bytes_le()?;
+        let y_bytes = g.y.to_non_unique_bytes_le()?;
+        let inf_bytes = g.infinity.to_non_unique_bytes_le()?;
         bytes.extend_from_slice(&y_bytes);
         bytes.extend_from_slice(&inf_bytes);
         Ok(bytes)
diff --git a/src/groups/curves/twisted_edwards/mod.rs b/src/groups/curves/twisted_edwards/mod.rs
index f88431d9..82095bfd 100644
--- a/src/groups/curves/twisted_edwards/mod.rs
+++ b/src/groups/curves/twisted_edwards/mod.rs
@@ -920,17 +920,17 @@ where
     for<'b> &'b F: FieldOpsBounds<'b, P::BaseField, F>,
 {
     #[tracing::instrument(target = "r1cs")]
-    fn to_bytes(&self) -> Result<Vec<UInt8<BasePrimeField<P>>>, SynthesisError> {
-        let mut x_bytes = self.x.to_bytes()?;
-        let y_bytes = self.y.to_bytes()?;
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<BasePrimeField<P>>>, SynthesisError> {
+        let mut x_bytes = self.x.to_bytes_le()?;
+        let y_bytes = self.y.to_bytes_le()?;
         x_bytes.extend_from_slice(&y_bytes);
         Ok(x_bytes)
     }
 
     #[tracing::instrument(target = "r1cs")]
-    fn to_non_unique_bytes(&self) -> Result<Vec<UInt8<BasePrimeField<P>>>, SynthesisError> {
-        let mut x_bytes = self.x.to_non_unique_bytes()?;
-        let y_bytes = self.y.to_non_unique_bytes()?;
+    fn to_non_unique_bytes_le(&self) -> Result<Vec<UInt8<BasePrimeField<P>>>, SynthesisError> {
+        let mut x_bytes = self.x.to_non_unique_bytes_le()?;
+        let y_bytes = self.y.to_non_unique_bytes_le()?;
         x_bytes.extend_from_slice(&y_bytes);
 
         Ok(x_bytes)
diff --git a/src/uint/convert.rs b/src/uint/convert.rs
index 45ceb3e5..51522e77 100644
--- a/src/uint/convert.rs
+++ b/src/uint/convert.rs
@@ -97,7 +97,7 @@ impl<const N: usize, T: PrimUInt, ConstraintF: Field> ToBytesGadget<ConstraintF>
     for UInt<N, T, ConstraintF>
 {
     #[tracing::instrument(target = "r1cs", skip(self))]
-    fn to_bytes(&self) -> Result<Vec<UInt8<ConstraintF>>, SynthesisError> {
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<ConstraintF>>, SynthesisError> {
         Ok(self
             .to_bits_le()?
             .chunks(8)
@@ -107,23 +107,23 @@ impl<const N: usize, T: PrimUInt, ConstraintF: Field> ToBytesGadget<ConstraintF>
 }
 
 impl<const N: usize, T: PrimUInt, F: Field> ToBytesGadget<F> for [UInt<N, T, F>] {
-    fn to_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
         let mut bytes = Vec::with_capacity(self.len() * (N / 8));
         for elem in self {
-            bytes.extend_from_slice(&elem.to_bytes()?);
+            bytes.extend_from_slice(&elem.to_bytes_le()?);
         }
         Ok(bytes)
     }
 }
 
 impl<const N: usize, T: PrimUInt, F: Field> ToBytesGadget<F> for Vec<UInt<N, T, F>> {
-    fn to_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
-        self.as_slice().to_bytes()
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+        self.as_slice().to_bytes_le()
     }
 }
 
 impl<'a, const N: usize, T: PrimUInt, F: Field> ToBytesGadget<F> for &'a [UInt<N, T, F>] {
-    fn to_bytes(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
-        (*self).to_bytes()
+    fn to_bytes_le(&self) -> Result<Vec<UInt8<F>>, SynthesisError> {
+        (*self).to_bytes_le()
     }
 }