Allow converting CoreKeyShare into KeyInfo without validation

Author: survived

key-share/src/lib.rs

@@ -22,7 +22,7 @@ use generic_ec_zkp::polynomial::lagrange_coefficient;
 mod utils;
 mod valid;
 
-pub use self::valid::{Valid, Validate, ValidateError, ValidateFromParts};
+pub use self::valid::{Valid, ValidProjection, Validate, ValidateError, ValidateFromParts};
 
 /// Core key share
 ///
@@ -339,6 +339,34 @@ impl<E: Curve> CoreKeyShare<E> {
     }
 }
 
+impl<E: Curve> From<&DirtyCoreKeyShare<E>> for DirtyKeyInfo<E> {
+    fn from(key_share: &DirtyCoreKeyShare<E>) -> Self {
+        DirtyKeyInfo {
+            curve: key_share.curve,
+            shared_public_key: key_share.shared_public_key,
+            public_shares: key_share.public_shares.clone(),
+            vss_setup: key_share.vss_setup.clone(),
+            #[cfg(feature = "hd-wallets")]
+            chain_code: key_share.chain_code,
+        }
+    }
+}
+impl<E: Curve> From<DirtyCoreKeyShare<E>> for DirtyKeyInfo<E> {
+    fn from(key_share: DirtyCoreKeyShare<E>) -> Self {
+        DirtyKeyInfo {
+            curve: key_share.curve,
+            shared_public_key: key_share.shared_public_key,
+            public_shares: key_share.public_shares,
+            vss_setup: key_share.vss_setup,
+            #[cfg(feature = "hd-wallets")]
+            chain_code: key_share.chain_code,
+        }
+    }
+}
+
+impl<E: Curve> ValidProjection<DirtyCoreKeyShare<E>> for DirtyKeyInfo<E> {}
+impl<E: Curve> ValidProjection<&DirtyCoreKeyShare<E>> for DirtyKeyInfo<E> {}
+
 /// Error indicating that key share is not valid
 #[derive(Debug, thiserror::Error)]
 #[error(transparent)]

key-share/src/valid.rs

@@ -46,13 +46,27 @@ where
             Ok(Self(T::from_parts(parts)))
         }
     }
+
+    /// Constructs `Self` from its [`ValidProjection`]
+    pub fn from<K>(value: Valid<K>) -> Self
+    where
+        T: ValidProjection<K>,
+        K: Validate,
+    {
+        Self(value.0.into())
+    }
 }
 
 impl<T> Valid<T> {
     /// Returns wraped validated value
     pub fn into_inner(self) -> T {
         self.0
     }
+
+    /// Returns a wrapped reference to validated data
+    pub fn as_ref(&self) -> Valid<&T> {
+        Valid(&self.0)
+    }
 }
 
 impl<T> AsRef<T> for Valid<T> {
@@ -90,6 +104,13 @@ pub trait Validate {
     }
 }
 
+impl<T: Validate> Validate for &T {
+    type Error = <T as Validate>::Error;
+    fn is_valid(&self) -> Result<(), Self::Error> {
+        (*self).is_valid()
+    }
+}
+
 /// Represents a type that can be constructed and validated from `Parts`
 ///
 /// That can be particularly useful when vaidating `Parts` is cheaper than validating `Self`.
@@ -153,6 +174,9 @@ pub trait ValidateFromParts<Parts>: Validate {
     fn from_parts(parts: Parts) -> Self;
 }
 
+/// Marker trait stating that `Self` is projection of `T`: if `T` is valid, then `Self::from(T)` is valid as well
+pub trait ValidProjection<T: Validate>: Validate + From<T> {}
+
 /// Validation error
 ///
 /// Contains an error that explains why value was considered invalid, and the value itself. It can be used