fmt, clippy

src/fcmp/fcmp_rust/src/lib.rs

@@ -2,37 +2,48 @@ use std::io;
 
 use rand_core::OsRng;
 
+use ciphersuite::{
+    group::{
+        ff::{Field, PrimeField},
+        Group, GroupEncoding,
+    },
+    Ciphersuite, Ed25519, Helios, Selene,
+};
+use helioselene::{
+    Field25519 as SeleneScalar, HeliosPoint, HelioseleneField as HeliosScalar, SelenePoint,
+};
 use transcript::RecommendedTranscript;
-use helioselene::{HeliosPoint, SelenePoint, HelioseleneField as HeliosScalar, Field25519 as SeleneScalar};
-use ciphersuite::{group::{Group, GroupEncoding, ff::{PrimeField, Field}}, Ciphersuite, Ed25519, Selene, Helios};
 
 use generalized_bulletproofs::Generators;
 
 use ec_divisors::DivisorCurve;
 use full_chain_membership_proofs::tree::hash_grow;
 
-// TODO: cleaner const usage of generators
+// TODO: Use a macro to de-duplicate some of of this code
-// TODO: try to get closer to underlying types
+
-// TODO: maybe don't do both tuple and Box? Just make these all boxes
 #[repr(C)]
 pub struct HeliosGenerators {
-  generators: Box<Generators<RecommendedTranscript, Helios>>
+    generators: Box<Generators<RecommendedTranscript, Helios>>,
 }
 #[repr(C)]
 pub struct SeleneGenerators {
-  generators: Box<Generators<RecommendedTranscript, Selene>>
+    generators: Box<Generators<RecommendedTranscript, Selene>>,
 }
 
 #[no_mangle]
 pub extern "C" fn random_helios_generators(n: usize) -> HeliosGenerators {
     let helios_generators = generalized_bulletproofs::tests::generators::<Helios>(n);
-  HeliosGenerators { generators: Box::new(helios_generators) }
+    HeliosGenerators {
+        generators: Box::new(helios_generators),
+    }
 }
 
 #[no_mangle]
 pub extern "C" fn random_selene_generators(n: usize) -> SeleneGenerators {
     let selene_generators = generalized_bulletproofs::tests::generators::<Selene>(n);
-  SeleneGenerators { generators: Box::new(selene_generators) }
+    SeleneGenerators {
+        generators: Box::new(selene_generators),
+    }
 }
 
 #[no_mangle]
@@ -71,11 +82,12 @@ pub extern "C" fn selene_point_to_bytes(selene_point: SelenePoint) -> *const u8
 }
 
 // Get the x coordinate of the ed25519 point
-// TODO: use generics for below logic
+// TODO: Move this to C++
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[no_mangle]
 pub extern "C" fn ed25519_point_to_selene_scalar(ed25519_point: *const u8) -> SeleneScalar {
-  // TODO: unwrap or else error
     let mut ed25519_point = unsafe { core::slice::from_raw_parts(ed25519_point, 32) };
+    // TODO: If not moved to C++, at least return an error here (instead of unwrapping)
     let ed25519_point = <Ed25519>::read_G(&mut ed25519_point).unwrap();
 
     let xy_coords = <Ed25519 as Ciphersuite>::G::to_xy(ed25519_point);
@@ -83,7 +95,6 @@ pub extern "C" fn ed25519_point_to_selene_scalar(ed25519_point: *const u8) -> Se
     x
 }
 
-// TODO: use generics for below logic
 #[no_mangle]
 pub extern "C" fn selene_point_to_helios_scalar(selene_point: SelenePoint) -> HeliosScalar {
     let xy_coords = SelenePoint::to_xy(selene_point);
@@ -91,7 +102,6 @@ pub extern "C" fn selene_point_to_helios_scalar(selene_point: SelenePoint) -> He
     x
 }
 
-// TODO: use generics for below logic
 #[no_mangle]
 pub extern "C" fn helios_point_to_selene_scalar(helios_point: HeliosPoint) -> SeleneScalar {
     let xy_coords = HeliosPoint::to_xy(helios_point);
@@ -116,9 +126,9 @@ pub struct Slice<T> {
 }
 pub type HeliosScalarSlice = Slice<HeliosScalar>;
 pub type SeleneScalarSlice = Slice<SeleneScalar>;
-impl<'a, T> Into<&'a [T]> for Slice<T> {
+impl<'a, T> From<Slice<T>> for &'a [T] {
-  fn into(self) -> &'a [T] {
+    fn from(slice: Slice<T>) -> Self {
-    unsafe { core::slice::from_raw_parts(self.buf, self.len) }
+        unsafe { core::slice::from_raw_parts(slice.buf, slice.len) }
     }
 }
 
@@ -129,21 +139,26 @@ pub struct CResult<T, E> {
 }
 impl<T, E> CResult<T, E> {
     fn ok(value: T) -> Self {
-    CResult { value, err: core::ptr::null() }
+        CResult {
+            value,
+            err: core::ptr::null(),
+        }
     }
     fn err(default: T, err: E) -> Self {
-    CResult { value: default, err: Box::into_raw(Box::new(err)) }
+        CResult {
+            value: default,
+            err: Box::into_raw(Box::new(err)),
+        }
     }
 }
 
-// TODO: use generics for curves
 #[no_mangle]
 pub extern "C" fn hash_grow_helios(
     helios_generators: &HeliosGenerators,
     existing_hash: HeliosPoint,
     offset: usize,
     prior_children: HeliosScalarSlice,
-  new_children: HeliosScalarSlice
+    new_children: HeliosScalarSlice,
 ) -> CResult<HeliosPoint, io::Error> {
     let hash = hash_grow(
         &helios_generators.generators,
@@ -156,18 +171,20 @@ pub extern "C" fn hash_grow_helios(
     if let Some(hash) = hash {
         CResult::ok(hash)
     } else {
-    CResult::err(HeliosPoint::identity(), io::Error::new(io::ErrorKind::Other, "failed to grow hash"))
+        CResult::err(
+            HeliosPoint::identity(),
+            io::Error::new(io::ErrorKind::Other, "failed to grow hash"),
+        )
     }
 }
 
-// TODO: use generics for curves
 #[no_mangle]
 pub extern "C" fn hash_grow_selene(
     selene_generators: &SeleneGenerators,
     existing_hash: SelenePoint,
     offset: usize,
     prior_children: SeleneScalarSlice,
-  new_children: SeleneScalarSlice
+    new_children: SeleneScalarSlice,
 ) -> CResult<SelenePoint, io::Error> {
     let hash = hash_grow(
         &selene_generators.generators,
@@ -180,7 +197,9 @@ pub extern "C" fn hash_grow_selene(
     if let Some(hash) = hash {
         CResult::ok(hash)
     } else {
-    CResult::err(SelenePoint::identity(), io::Error::new(io::ErrorKind::Other, "failed to grow hash"))
+        CResult::err(
+            SelenePoint::identity(),
+            io::Error::new(io::ErrorKind::Other, "failed to grow hash"),
+        )
     }
-
 }