Upgrade ed25519-dalek dependency to v2.0.0

Author: Alenar

Cargo.lock

@@ -22,7 +22,7 @@ bech32 = "0.9.1"
 blake2 = "0.10.6"
 chrono = { version = "0.4.26", features = ["serde"] }
 digest = "0.10.7"
-ed25519-dalek = { version = "1.0.1", features = ["serde"] }
+ed25519-dalek = { version = "2.0.0", features = ["rand_core", "serde"] }
 fixed = "1.23.1"
 glob = "0.3.1"
 hex = "0.4.3"
@@ -34,7 +34,6 @@ kes-summed-ed25519 = { version = "0.2.0", features = [
 ] }
 mockall = "0.11.4"
 nom = "7.1.3"
-rand-chacha-dalek-compat = { package = "rand_chacha", version = "0.2" }
 rand_chacha = "0.3.1"
 rand_core = "0.6.4"
 rayon = "1.7.0"

mithril-common/Cargo.toml

@@ -1,6 +1,6 @@
-use ed25519_dalek::Keypair as ColdKeypair;
-use rand_chacha_dalek_compat::rand_core::SeedableRng;
-use rand_chacha_dalek_compat::ChaCha20Rng;
+use ed25519_dalek::SigningKey as ColdKeypair;
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
 
 /// A cold key generator / test only
 #[derive(Debug)]

mithril-common/src/crypto_helper/cardano/cold_key.rs

@@ -6,9 +6,10 @@ use crate::crypto_helper::ProtocolPartyId;
 
 use bech32::{self, ToBase32, Variant};
 use blake2::{digest::consts::U28, Blake2b, Digest};
-use ed25519_dalek::{Keypair as EdKeypair, Signer};
-use ed25519_dalek::{PublicKey as EdPublicKey, Signature as EdSignature, Verifier};
+use ed25519_dalek::{Signature as EdSignature, Verifier, VerifyingKey as EdPublicKey};
+use ed25519_dalek::{Signer, SigningKey as EdKeypair};
 use kes_summed_ed25519::PublicKey as KesPublicKey;
+use nom::AsBytes;
 use serde::de::Error;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use sha2::Sha256;
@@ -59,7 +60,7 @@ impl OpCert {
         start_kes_period: u64,
         cold_keypair: EdKeypair,
     ) -> Self {
-        let cold_vk: EdPublicKey = cold_keypair.public;
+        let cold_vk: EdPublicKey = cold_keypair.verifying_key();
         let cert_sig = cold_keypair.sign(&Self::compute_message_to_sign(
             &kes_vk,
             issue_number,
@@ -112,7 +113,7 @@ impl OpCert {
         let mut hasher = Blake2b::<U28>::new();
         hasher.update(self.cold_vk.as_bytes());
         let mut pool_id = [0u8; 28];
-        pool_id.copy_from_slice(hasher.finalize().as_slice());
+        pool_id.copy_from_slice(hasher.finalize().as_bytes());
         bech32::encode("pool", pool_id.to_base32(), Variant::Bech32)
             .map_err(|_| OpCertError::PoolAddressEncoding)
     }
@@ -166,7 +167,7 @@ impl<'de> Deserialize<'de> for OpCert {
                 .map_err(|_| Error::custom("KES vk serialisation error"))?,
             issue_number: raw_cert.0 .1,
             start_kes_period: raw_cert.0 .2,
-            cert_sig: EdSignature::from_bytes(&raw_cert.0 .3)
+            cert_sig: EdSignature::from_slice(&raw_cert.0 .3)
                 .map_err(|_| Error::custom("ed25519 signature serialisation error"))?,
             cold_vk: raw_cert.1,
         })

mithril-common/src/crypto_helper/cardano/opcert.rs

@@ -1,16 +1,16 @@
-use ed25519_dalek::{ExpandedSecretKey, SignatureError};
-use rand_chacha_dalek_compat::rand_core::{self, CryptoRng, RngCore, SeedableRng};
-use rand_chacha_dalek_compat::ChaCha20Rng;
+use ed25519_dalek::{SignatureError, Signer, SigningKey};
+use rand_chacha::rand_core::{self, CryptoRng, RngCore, SeedableRng};
+use rand_chacha::ChaCha20Rng;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 use super::ProtocolKey;
 
-/// Alias of [Ed25519:PublicKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.PublicKey.html).
-pub type EraMarkersVerifierVerificationKey = ProtocolKey<ed25519_dalek::PublicKey>;
+/// Alias of [Ed25519:PublicKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.VerifyingKey.html).
+pub type EraMarkersVerifierVerificationKey = ProtocolKey<ed25519_dalek::VerifyingKey>;
 
-/// Alias of [Ed25519:SecretKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.SecretKey.html).
-pub type EraMarkersVerifierSecretKey = ProtocolKey<ed25519_dalek::SecretKey>;
+/// Alias of [Ed25519:SigningKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.SigningKey.html).
+pub type EraMarkersVerifierSecretKey = ProtocolKey<ed25519_dalek::SigningKey>;
 
 /// Alias of [Ed25519:Signature](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.Signature.html).
 pub type EraMarkersVerifierSignature = ProtocolKey<ed25519_dalek::Signature>;
@@ -35,7 +35,7 @@ impl EraMarkersSigner {
     where
         R: CryptoRng + RngCore,
     {
-        let secret_key = ed25519_dalek::SecretKey::generate(&mut rng);
+        let secret_key = SigningKey::generate(&mut rng);
         Self::from_secret_key(secret_key.into())
     }
 
@@ -56,31 +56,14 @@ impl EraMarkersSigner {
         Self { secret_key }
     }
 
-    /// Create a an expanded secret key
-    fn create_expanded_secret_key(&self) -> ExpandedSecretKey {
-        ExpandedSecretKey::from(&*self.secret_key)
-    }
-
-    /// Create a EraMarkersVerifierVerificationKey
-    fn create_verification_key(
-        &self,
-        expanded_secret_key: &ExpandedSecretKey,
-    ) -> EraMarkersVerifierVerificationKey {
-        EraMarkersVerifierVerificationKey::new(expanded_secret_key.into())
-    }
-
     /// Create a EraMarkersVerifier
     pub fn create_verifier(&self) -> EraMarkersVerifier {
-        let expanded_secret_key = self.create_expanded_secret_key();
-        let verification_key = self.create_verification_key(&expanded_secret_key);
-        EraMarkersVerifier::from_verification_key(verification_key)
+        EraMarkersVerifier::from_verification_key(self.secret_key.verifying_key().into())
     }
 
     /// Signs a message and returns a EraMarkersVerifierSignature
     pub fn sign(&self, message: &[u8]) -> EraMarkersVerifierSignature {
-        let expanded_secret_key = self.create_expanded_secret_key();
-        let verification_key = self.create_verification_key(&expanded_secret_key);
-        expanded_secret_key.sign(message, &verification_key).into()
+        self.secret_key.sign(message).into()
     }
 }
 
@@ -139,7 +122,7 @@ mod tests {
         let verifier = signer.create_verifier();
         let signer_2 = EraMarkersSigner::create_deterministic_signer();
         let verifier_2 = signer.create_verifier();
-        assert_eq!(signer.secret_key.as_bytes(), signer_2.secret_key.as_bytes());
+        assert_eq!(signer.secret_key.to_bytes(), signer_2.secret_key.to_bytes());
         assert_eq!(
             verifier.verification_key.as_bytes(),
             verifier_2.verification_key.as_bytes()