Merge pull request #228 from LLFourn/to_point_poly_flexible

Make to_point_poly more flexible

Author: LLFourn

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## UNRELEASED
 
+- Add `SharedKey::from_non_zero_poly`
+- Change `poly::scalar::to_point_poly` to make it less opinionated 
 - Add From/TryFrom conversions for `Scalar` to all unsigned integer types
 - Upgrade to bincode v2
 - MSRV 1.63 -> 1.85

schnorr_fun/src/frost/shared_key.rs

@@ -233,7 +233,7 @@ impl<T: PointType, Z: ZeroChoice> SharedKey<T, Z> {
     }
 }
 
-impl SharedKey<Normal> {
+impl SharedKey {
     /// Convert the key into a [BIP340] "x-only" SharedKey.
     ///
     /// This is the [BIP340] compatible version of the key which you can put in a segwitv1 output.
@@ -248,6 +248,18 @@ impl SharedKey<Normal> {
 
         SharedKey::from_inner(self.point_polynomial)
     }
+
+    /// Creates a non-zero `SharedKey` from a known `NonZero` first coefficient the other coefficients in `rest`.
+    pub fn from_non_zero_poly<Z>(
+        first_coef: Point,
+        rest: impl IntoIterator<Item = Point<Normal, Public, Z>>,
+    ) -> Self {
+        let mut poly = vec![first_coef.mark_zero()];
+        for point in rest.into_iter() {
+            poly.push(point.mark_zero());
+        }
+        Self::from_inner(poly)
+    }
 }
 
 impl SharedKey<Normal, Zero> {

secp256kfun/src/point.rs

@@ -79,6 +79,12 @@ impl<T, S, Z> AsRef<backend::Point> for Point<T, S, Z> {
     }
 }
 
+impl<T, S, Z> AsRef<Point<T, S, Z>> for Point<T, S, Z> {
+    fn as_ref(&self) -> &Point<T, S, Z> {
+        self
+    }
+}
+
 impl<T: Copy, S, Z> Copy for Point<T, S, Z> {}
 
 impl Point<Normal, Public, NonZero> {

secp256kfun/src/poly.rs

@@ -35,8 +35,13 @@ pub mod scalar {
     ///     .collect::<Vec<_>>();
     /// let point_poly = poly::scalar::to_point_poly(&secret_poly);
     /// ```
-    pub fn to_point_poly(scalar_poly: &[Scalar]) -> Vec<Point> {
-        scalar_poly.iter().map(|a| g!(a * G).normalize()).collect()
+    pub fn to_point_poly<S: Secrecy, Z: ZeroChoice>(
+        scalar_poly: impl IntoIterator<Item = impl AsRef<Scalar<S, Z>>>,
+    ) -> Vec<Point<Normal, Public, Z>> {
+        scalar_poly
+            .into_iter()
+            .map(|a| g!(a.as_ref() * G).normalize())
+            .collect()
     }
 
     /// Generate a [`Scalar`] polynomial with `length` coefficients.

secp256kfun/src/scalar.rs

@@ -59,6 +59,12 @@ impl<S, Z> AsRef<backend::Scalar> for Scalar<S, Z> {
     }
 }
 
+impl<S, Z> AsRef<Scalar<S, Z>> for Scalar<S, Z> {
+    fn as_ref(&self) -> &Scalar<S, Z> {
+        self
+    }
+}
+
 impl<S, Z> Clone for Scalar<S, Z> {
     fn clone(&self) -> Self {
         *self