Rename to MontgomeryPoint to MontgomeryXpoint

Author: daxpedda

ed448-goldilocks/src/edwards/extended.rs

@@ -528,8 +528,8 @@ impl EdwardsPoint {
         T: FieldElement::ZERO,
     };
 
-    /// Convert this point to [`MontgomeryPoint`]
-    pub fn to_montgomery(&self) -> MontgomeryPoint {
+    /// Convert this point to [`MontgomeryXpoint`]
+    pub fn to_montgomery_x(&self) -> MontgomeryXpoint {
         // u = y^2 * [(1-dy^2)/(1-y^2)]
 
         let affine = self.to_affine();
@@ -539,7 +539,7 @@ impl EdwardsPoint {
 
         let u = yy * (FieldElement::ONE - dyy) * (FieldElement::ONE - yy).invert();
 
-        MontgomeryPoint(u.to_bytes())
+        MontgomeryXpoint(u.to_bytes())
     }
 
     /// Generic scalar multiplication to compute s*P

ed448-goldilocks/src/lib.rs

@@ -61,7 +61,7 @@ pub use edwards::{
     WideEdwardsScalarBytes,
 };
 pub use field::{MODULUS_LIMBS, ORDER, Scalar, WIDE_ORDER};
-pub use montgomery::{MontgomeryPoint, ProjectiveMontgomeryPoint};
+pub use montgomery::{MontgomeryXpoint, ProjectiveMontgomeryXpoint};
 pub use ristretto::{CompressedRistretto, RistrettoPoint};
 #[cfg(feature = "signing")]
 pub use sign::*;

ed448-goldilocks/src/montgomery.rs

@@ -19,19 +19,19 @@ use core::ops::Mul;
 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq};
 
 // Low order points on Curve448 and it's twist
-const LOW_A: MontgomeryPoint = MontgomeryPoint([
+const LOW_A: MontgomeryXpoint = MontgomeryXpoint([
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 ]);
-const LOW_B: MontgomeryPoint = MontgomeryPoint([
+const LOW_B: MontgomeryXpoint = MontgomeryXpoint([
     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 ]);
-const LOW_C: MontgomeryPoint = MontgomeryPoint([
+const LOW_C: MontgomeryXpoint = MontgomeryXpoint([
     0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff,
     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -40,51 +40,51 @@ const LOW_C: MontgomeryPoint = MontgomeryPoint([
 
 /// A point in Montgomery form
 #[derive(Copy, Clone)]
-pub struct MontgomeryPoint(pub [u8; 56]);
+pub struct MontgomeryXpoint(pub [u8; 56]);
 
-impl Default for MontgomeryPoint {
-    fn default() -> MontgomeryPoint {
+impl Default for MontgomeryXpoint {
+    fn default() -> MontgomeryXpoint {
         Self([0u8; 56])
     }
 }
 
-impl elliptic_curve::zeroize::DefaultIsZeroes for MontgomeryPoint {}
+impl elliptic_curve::zeroize::DefaultIsZeroes for MontgomeryXpoint {}
 
-impl fmt::Debug for MontgomeryPoint {
+impl fmt::Debug for MontgomeryXpoint {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         self.0[..].fmt(formatter)
     }
 }
 
-impl ConstantTimeEq for MontgomeryPoint {
-    fn ct_eq(&self, other: &MontgomeryPoint) -> Choice {
+impl ConstantTimeEq for MontgomeryXpoint {
+    fn ct_eq(&self, other: &MontgomeryXpoint) -> Choice {
         self.0.ct_eq(&other.0)
     }
 }
 
-impl PartialEq for MontgomeryPoint {
-    fn eq(&self, other: &MontgomeryPoint) -> bool {
+impl PartialEq for MontgomeryXpoint {
+    fn eq(&self, other: &MontgomeryXpoint) -> bool {
         self.ct_eq(other).into()
     }
 }
-impl Eq for MontgomeryPoint {}
+impl Eq for MontgomeryXpoint {}
 
 /// A Projective point in Montgomery form
 #[derive(Copy, Clone, Debug)]
-pub struct ProjectiveMontgomeryPoint {
+pub struct ProjectiveMontgomeryXpoint {
     U: FieldElement,
     W: FieldElement,
 }
 
-impl Mul<&EdwardsScalar> for &MontgomeryPoint {
-    type Output = MontgomeryPoint;
+impl Mul<&EdwardsScalar> for &MontgomeryXpoint {
+    type Output = MontgomeryXpoint;
 
     #[allow(clippy::suspicious_arithmetic_impl)]
-    fn mul(self, scalar: &EdwardsScalar) -> MontgomeryPoint {
+    fn mul(self, scalar: &EdwardsScalar) -> MontgomeryXpoint {
         // Algorithm 8 of Costello-Smith 2017
         let affine_u = FieldElement::from_bytes(&self.0);
-        let mut x0 = ProjectiveMontgomeryPoint::identity();
-        let mut x1 = ProjectiveMontgomeryPoint {
+        let mut x0 = ProjectiveMontgomeryXpoint::identity();
+        let mut x1 = ProjectiveMontgomeryXpoint {
             U: affine_u,
             W: FieldElement::ONE,
         };
@@ -95,7 +95,7 @@ impl Mul<&EdwardsScalar> for &MontgomeryPoint {
             let bit = bits[s] as u8;
             let choice: u8 = swap ^ bit;
 
-            ProjectiveMontgomeryPoint::conditional_swap(&mut x0, &mut x1, Choice::from(choice));
+            ProjectiveMontgomeryXpoint::conditional_swap(&mut x0, &mut x1, Choice::from(choice));
             differential_add_and_double(&mut x0, &mut x1, &affine_u);
 
             swap = bit;
@@ -105,15 +105,15 @@ impl Mul<&EdwardsScalar> for &MontgomeryPoint {
     }
 }
 
-impl Mul<&MontgomeryPoint> for &EdwardsScalar {
-    type Output = MontgomeryPoint;
+impl Mul<&MontgomeryXpoint> for &EdwardsScalar {
+    type Output = MontgomeryXpoint;
 
-    fn mul(self, point: &MontgomeryPoint) -> MontgomeryPoint {
+    fn mul(self, point: &MontgomeryXpoint) -> MontgomeryXpoint {
         point * self
     }
 }
 
-impl MontgomeryPoint {
+impl MontgomeryXpoint {
     /// Returns the generator specified in RFC7748
     pub const GENERATOR: Self = Self([
         0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -140,30 +140,30 @@ impl MontgomeryPoint {
     }
 
     /// Convert the point to a ProjectiveMontgomeryPoint
-    pub fn to_projective(&self) -> ProjectiveMontgomeryPoint {
-        ProjectiveMontgomeryPoint {
+    pub fn to_projective(&self) -> ProjectiveMontgomeryXpoint {
+        ProjectiveMontgomeryXpoint {
             U: FieldElement::from_bytes(&self.0),
             W: FieldElement::ONE,
         }
     }
 }
 
-impl ConditionallySelectable for ProjectiveMontgomeryPoint {
+impl ConditionallySelectable for ProjectiveMontgomeryXpoint {
     fn conditional_select(
-        a: &ProjectiveMontgomeryPoint,
-        b: &ProjectiveMontgomeryPoint,
+        a: &ProjectiveMontgomeryXpoint,
+        b: &ProjectiveMontgomeryXpoint,
         choice: Choice,
-    ) -> ProjectiveMontgomeryPoint {
-        ProjectiveMontgomeryPoint {
+    ) -> ProjectiveMontgomeryXpoint {
+        ProjectiveMontgomeryXpoint {
             U: FieldElement::conditional_select(&a.U, &b.U, choice),
             W: FieldElement::conditional_select(&a.W, &b.W, choice),
         }
     }
 }
 
 fn differential_add_and_double(
-    P: &mut ProjectiveMontgomeryPoint,
-    Q: &mut ProjectiveMontgomeryPoint,
+    P: &mut ProjectiveMontgomeryXpoint,
+    Q: &mut ProjectiveMontgomeryXpoint,
     affine_PmQ: &FieldElement,
 ) {
     let t0 = P.U + P.W;
@@ -199,19 +199,19 @@ fn differential_add_and_double(
     Q.W = t17; // W_{Q'} = U_D * 4 (W_P U_Q - U_P W_Q)^2
 }
 
-impl ProjectiveMontgomeryPoint {
+impl ProjectiveMontgomeryXpoint {
     /// The identity element of the group: the point at infinity.
-    pub fn identity() -> ProjectiveMontgomeryPoint {
-        ProjectiveMontgomeryPoint {
+    pub fn identity() -> ProjectiveMontgomeryXpoint {
+        ProjectiveMontgomeryXpoint {
             U: FieldElement::ONE,
             W: FieldElement::ZERO,
         }
     }
 
     /// Convert the point to affine form
-    pub fn to_affine(&self) -> MontgomeryPoint {
+    pub fn to_affine(&self) -> MontgomeryXpoint {
         let x = self.U * self.W.invert();
-        MontgomeryPoint(x.to_bytes())
+        MontgomeryXpoint(x.to_bytes())
     }
 }
 
@@ -226,11 +226,11 @@ mod tests {
         use crate::GOLDILOCKS_BASE_POINT as bp;
 
         // Montgomery scalar mul
-        let montgomery_bp = bp.to_montgomery();
+        let montgomery_bp = bp.to_montgomery_x();
         let montgomery_res = &montgomery_bp * &scalar;
 
         // Goldilocks scalar mul
         let goldilocks_point = bp.scalar_mul(&scalar);
-        assert_eq!(goldilocks_point.to_montgomery(), montgomery_res);
+        assert_eq!(goldilocks_point.to_montgomery_x(), montgomery_res);
     }
 }