FCMP++: point to cycle scalar impl

This is the function to convert a Helios point to Selene scalar,
and Selene point to Helios scalar, which is critical when growing
the curve trees merkle tree. Each tree elem is a hash of the
preceeding layer's scalars. The hash is a point, we convert each
point to scalars on the curve's respective cycle.

Author: j-berman

src/fcmp_pp/fcmp_pp_rust/Cargo.lock

@@ -12,6 +12,7 @@ ciphersuite = { version = "0.4.2", features = ["ed25519"] }
 dalek-ff-group = "0.4.4"
 helioselene = { git = "https://github.com/monero-oxide/monero-oxide", rev = "50dd3dbc0cc9048247eb734d27eb1d516aecacd2" }
 
+ec-divisors = { git = "https://github.com/monero-oxide/monero-oxide", rev = "50dd3dbc0cc9048247eb734d27eb1d516aecacd2", features = ["ed25519"] }
 full-chain-membership-proofs = { git = "https://github.com/monero-oxide/monero-oxide", rev = "50dd3dbc0cc9048247eb734d27eb1d516aecacd2" }
 
 monero-generators = { git = "https://github.com/monero-oxide/monero-oxide", rev = "50dd3dbc0cc9048247eb734d27eb1d516aecacd2" }

src/fcmp_pp/fcmp_pp_rust/Cargo.toml

@@ -98,6 +98,10 @@ struct HeliosPoint helios_hash_init_point(void);
 
 struct SelenePoint selene_hash_init_point(void);
 
+int selene_point_to_helios_scalar(struct SelenePoint selene_point, struct HeliosScalar *helios_scalar_out);
+
+int helios_point_to_selene_scalar(struct HeliosPoint helios_point, struct SeleneScalar *selene_scalar_out);
+
 struct HeliosScalar helios_zero_scalar(void);
 
 struct SeleneScalar selene_zero_scalar(void);

src/fcmp_pp/fcmp_pp_rust/fcmp++.h

@@ -6,6 +6,8 @@ use ciphersuite::{
     Ciphersuite,
 };
 
+use ec_divisors::DivisorCurve;
+
 use full_chain_membership_proofs::tree::hash_grow;
 use helioselene::{
     Field25519 as SeleneScalar, HeliosPoint, HelioseleneField as HeliosScalar, Selene,
@@ -78,6 +80,28 @@ ec_elem_to_bytes!(selene_point_to_bytes, SelenePoint, to_bytes);
 
 ec_elem_from_bytes!(selene_scalar_from_bytes, SeleneScalar, Selene, read_F);
 
+macro_rules! point_to_cycle_scalar {
+    ($fn_name:ident, $Point:ty, $Scalar:ty) => {
+        /// # Safety
+        ///
+        /// This function assumes scalar_out is a non-null pointer to the expected type.
+        #[no_mangle]
+        pub unsafe extern "C" fn $fn_name(point: $Point, scalar_out: *mut $Scalar) -> c_int {
+            if scalar_out.is_null() {
+                return -1;
+            }
+            let Some(xy_coords) = <$Point>::to_xy(point) else {
+                return -2;
+            };
+            *scalar_out = xy_coords.0;
+            0
+        }
+    };
+}
+
+point_to_cycle_scalar!(selene_point_to_helios_scalar, SelenePoint, HeliosScalar);
+point_to_cycle_scalar!(helios_point_to_selene_scalar, HeliosPoint, SeleneScalar);
+
 // Undefined behavior occurs when the data pointer passed to core::slice::from_raw_parts is null,
 // even when len is 0. slice_from_raw_parts_0able() lets you pass p as null, as long as len is 0
 const unsafe fn slice_from_raw_parts_0able<'a, T>(p: *const T, len: usize) -> &'a [T] {

src/fcmp_pp/fcmp_pp_rust/src/lib.rs

@@ -61,6 +61,22 @@ Helios::Point Helios::hash_init_point() const
     return ::helios_hash_init_point();
 }
 //----------------------------------------------------------------------------------------------------------------------
+Selene::CycleScalar Selene::point_to_cycle_scalar(const Selene::Point &point) const
+{
+    Selene::CycleScalar helios_scalar;
+    int r = ::selene_point_to_helios_scalar(point, &helios_scalar);
+    CHECK_FFI_RES;
+    return helios_scalar;
+}
+//----------------------------------------------------------------------------------------------------------------------
+Helios::CycleScalar Helios::point_to_cycle_scalar(const Helios::Point &point) const
+{
+    Helios::CycleScalar selene_scalar;
+    int r = ::helios_point_to_selene_scalar(point, &selene_scalar);
+    CHECK_FFI_RES;
+    return selene_scalar;
+}
+//----------------------------------------------------------------------------------------------------------------------
 Selene::Scalar Selene::zero_scalar() const
 {
     return ::selene_zero_scalar();

src/fcmp_pp/tower_cycle.cpp

@@ -48,6 +48,9 @@ class Curve
 public:
     virtual typename C::Point hash_init_point() const = 0;
 
+    // Read the x-coordinate from this curve's point to get this curve's cycle scalar
+    virtual typename C::CycleScalar point_to_cycle_scalar(const typename C::Point &point) const = 0;
+
     virtual typename C::Point hash_grow(
         const typename C::Point &existing_hash,
         const std::size_t offset,
@@ -77,6 +80,8 @@ class Selene final : public Curve<SeleneT>
 public:
     Point hash_init_point() const override;
 
+    CycleScalar point_to_cycle_scalar(const Point &point) const override;
+
     Point hash_grow(
         const Point &existing_hash,
         const std::size_t offset,
@@ -106,6 +111,8 @@ class Helios final : public Curve<HeliosT>
 public:
     Point hash_init_point() const override;
 
+    CycleScalar point_to_cycle_scalar(const Point &point) const override;
+
     Point hash_grow(
         const Point &existing_hash,
         const std::size_t offset,