upgrades reddsa to newer commit to use frost 2.0.0-rc

Author: jowparks

src/dkg/error.rs

@@ -2,7 +2,6 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-pub mod error;
 pub mod group_key;
 pub mod round1;
 pub mod round2;

src/dkg/mod.rs

@@ -5,8 +5,8 @@
 use crate::checksum::Checksum;
 use crate::checksum::ChecksumHasher;
 use crate::checksum::CHECKSUM_LEN;
-use crate::dkg::error::Error;
 use crate::dkg::group_key::GroupSecretKeyShard;
+use crate::error::IronfishFrostError;
 use crate::frost;
 use crate::frost::keys::dkg::round1::Package;
 use crate::frost::keys::dkg::round1::SecretPackage;
@@ -87,23 +87,24 @@ impl<'a> From<&'a SerializableSecretPackage> for &'a SecretPackage {
 }
 
 impl SerializableSecretPackage {
-    fn serialize_into<W: io::Write>(&self, mut writer: W) -> io::Result<()> {
+    fn serialize_into<W: io::Write>(&self, mut writer: W) -> Result<(), IronfishFrostError> {
         writer.write_all(&self.identifier.serialize())?;
         write_variable_length(&mut writer, &self.coefficients, |writer, scalar| {
             writer.write_all(&scalar.to_bytes())
         })?;
-        write_variable_length(&mut writer, self.commitment.serialize(), |writer, array| {
+        let serialized = self.commitment.serialize()?;
+        write_variable_length(&mut writer, serialized, |writer, array| {
             writer.write_all(&array)
         })?;
         write_u16(&mut writer, self.min_signers)?;
         write_u16(&mut writer, self.max_signers)?;
         Ok(())
     }
 
-    fn deserialize_from<R: io::Read>(mut reader: R) -> io::Result<Self> {
+    fn deserialize_from<R: io::Read>(mut reader: R) -> Result<Self, IronfishFrostError> {
         let mut identifier = [0u8; 32];
         reader.read_exact(&mut identifier)?;
-        let identifier = Identifier::deserialize(&identifier).map_err(io::Error::other)?;
+        let identifier = Identifier::deserialize(&identifier)?;
 
         let coefficients = read_variable_length(&mut reader, |reader| {
             let mut scalar = [0u8; 32];
@@ -119,8 +120,7 @@ impl SerializableSecretPackage {
                 reader.read_exact(&mut array)?;
                 Ok(array)
             },
-        )?)
-        .map_err(io::Error::other)?;
+        )?)?;
 
         let min_signers = read_u16(&mut reader)?;
         let max_signers = read_u16(&mut reader)?;
@@ -160,7 +160,7 @@ pub fn export_secret_package<R: RngCore + CryptoRng>(
 pub fn import_secret_package(
     exported: &[u8],
     secret: &participant::Secret,
-) -> io::Result<SecretPackage> {
+) -> Result<SecretPackage, IronfishFrostError> {
     let serialized = multienc::decrypt(secret, exported).map_err(io::Error::other)?;
     SerializableSecretPackage::deserialize_from(&serialized[..]).map(|pkg| pkg.into())
 }
@@ -254,21 +254,22 @@ impl PublicPackage {
         buf
     }
 
-    pub fn serialize_into<W: io::Write>(&self, mut writer: W) -> io::Result<()> {
+    pub fn serialize_into<W: io::Write>(&self, mut writer: W) -> Result<(), IronfishFrostError> {
         self.identity.serialize_into(&mut writer)?;
-        let frost_package = self.frost_package.serialize().map_err(io::Error::other)?;
+        let frost_package = self.frost_package.serialize()?;
         write_variable_length_bytes(&mut writer, &frost_package)?;
         write_variable_length_bytes(&mut writer, &self.group_secret_key_shard_encrypted)?;
         writer.write_all(&self.checksum.to_le_bytes())?;
         Ok(())
     }
 
-    pub fn deserialize_from<R: io::Read>(mut reader: R) -> io::Result<Self> {
+    pub fn deserialize_from<R: io::Read>(mut reader: R) -> Result<Self, IronfishFrostError> {
         let identity = Identity::deserialize_from(&mut reader).expect("reading identity failed");
 
         let frost_package = read_variable_length_bytes(&mut reader)?;
-        let frost_package = Package::deserialize(&frost_package).map_err(io::Error::other)?;
-        let group_secret_key_shard_encrypted = read_variable_length_bytes(&mut reader)?;
+        let frost_package = Package::deserialize(&frost_package)?;
+
+        let group_secret_key_shard_encrypted = read_encrypted_blob(&mut reader)?;
 
         let mut checksum = [0u8; CHECKSUM_LEN];
         reader.read_exact(&mut checksum)?;
@@ -288,7 +289,7 @@ pub fn round1<'a, I, R>(
     min_signers: u16,
     participants: I,
     mut csrng: R,
-) -> Result<(Vec<u8>, PublicPackage), Error>
+) -> Result<(Vec<u8>, PublicPackage), IronfishFrostError>
 where
     I: IntoIterator<Item = &'a Identity>,
     R: RngCore + CryptoRng,
@@ -300,25 +301,21 @@ where
     let participants = participants;
 
     if !participants.contains(&self_identity) {
-        return Err(Error::InvalidInput(
-            "participants must include self_identity".to_string(),
-        ));
+        return Err(IronfishFrostError::InvalidInput);
     }
 
-    let max_signers = u16::try_from(participants.len())
-        .map_err(|_| Error::InvalidInput("too many participants".to_string()))?;
+    let max_signers =
+        u16::try_from(participants.len()).map_err(|_| IronfishFrostError::InvalidInput)?;
 
     let (secret_package, public_package) = frost::keys::dkg::part1(
         self_identity.to_frost_identifier(),
         max_signers,
         min_signers,
         &mut csrng,
-    )
-    .map_err(Error::FrostError)?;
+    )?;
 
     let encrypted_secret_package =
-        export_secret_package(&secret_package, self_identity, &mut csrng)
-            .map_err(Error::EncryptionError)?;
+        export_secret_package(&secret_package, self_identity, &mut csrng)?;
 
     let group_secret_key_shard = GroupSecretKeyShard::random(&mut csrng);