Merge pull request #1224 from input-output-hk/jpraynaud/798-cardano-crypto-helper-refactor

Use anyhow in `common/crypto_helper`

Author: jpraynaud

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-common"
-version = "0.2.113"
+version = "0.2.114"
 authors = { workspace = true }
 edition = { workspace = true }
 documentation = { workspace = true }

mithril-common/Cargo.toml

@@ -11,6 +11,7 @@
 //! The trait `SerDeShelleyFileFormat` can be implemented for any structure that implements
 //! `Serialize` and `Deserialize`.
 
+use anyhow::{anyhow, Context};
 use hex::FromHex;
 use kes_summed_ed25519::kes::Sum6Kes;
 use kes_summed_ed25519::traits::KesSk;
@@ -22,6 +23,8 @@ use std::io::Write;
 use std::path::Path;
 use thiserror::Error;
 
+use crate::StdError;
+
 /// We need to create this struct because the design of Sum6Kes takes
 /// a reference to a mutable pointer. It is therefore not possible to
 /// implement Ser/Deser using serde.
@@ -33,22 +36,8 @@ pub struct Sum6KesBytes(#[serde(with = "As::<Bytes>")] pub [u8; 612]);
 
 /// Parse error
 #[derive(Error, Debug)]
-pub enum ParseError {
-    #[error("io error: `{0}`")]
-    IO(#[from] std::io::Error),
-
-    #[error("JSON parse error: `{0}`")]
-    JsonFormat(#[from] serde_json::Error),
-
-    #[error("CBOR hex codec error: `{0}`")]
-    CborHex(#[from] hex::FromHexError),
-
-    #[error("CBOR parse error: `{0}`")]
-    CborFormat(#[from] serde_cbor::Error),
-
-    #[error("Invalid KES format")]
-    KesFormat,
-}
+#[error("Codec parse error: `{0:?}`")]
+pub struct CodecParseError(StdError);
 
 /// Fields for a shelley formatted file (holds for vkeys, skeys or certs)
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
@@ -71,30 +60,48 @@ pub trait SerDeShelleyFileFormat: Serialize + DeserializeOwned {
 
     /// Deserialize a type `T: Serialize + DeserializeOwned` from file following Cardano
     /// Shelley file format.
-    fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, ParseError> {
-        let data = fs::read_to_string(path)?;
-        let file: ShelleyFileFormat = serde_json::from_str(&data)?;
-        let hex_vector = Vec::from_hex(file.cbor_hex)?;
+    fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, CodecParseError> {
+        let data = fs::read_to_string(path)
+            .with_context(|| "SerDeShelleyFileFormat can not read data from file {}")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
+        let file: ShelleyFileFormat = serde_json::from_str(&data)
+            .with_context(|| "SerDeShelleyFileFormat can not unserialize json data")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
+        let hex_vector = Vec::from_hex(file.cbor_hex)
+            .with_context(|| "SerDeShelleyFileFormat can not unserialize hex data")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
+        let a: Self = serde_cbor::from_slice(&hex_vector)
+            .with_context(|| "SerDeShelleyFileFormat can not unserialize cbor data")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
 
-        let a: Self = serde_cbor::from_slice(&hex_vector)?;
         Ok(a)
     }
 
     /// Serialize a type `T: Serialize + DeserializeOwned` to file following Cardano
     /// Shelley file format.
-    fn to_file<P: AsRef<Path>>(&self, path: P) -> Result<(), ParseError> {
-        let cbor_string = hex::encode(serde_cbor::to_vec(&self)?);
+    fn to_file<P: AsRef<Path>>(&self, path: P) -> Result<(), CodecParseError> {
+        let cbor_string = hex::encode(
+            serde_cbor::to_vec(&self)
+                .with_context(|| "SerDeShelleyFileFormat can not serialize data to cbor")
+                .map_err(|e| CodecParseError(anyhow!(e)))?,
+        );
 
         let file_format = ShelleyFileFormat {
             file_type: Self::TYPE.to_string(),
             description: Self::DESCRIPTION.to_string(),
             cbor_hex: cbor_string,
         };
 
-        let mut file = fs::File::create(path)?;
-        let json_str = serde_json::to_string(&file_format)?;
+        let mut file = fs::File::create(path)
+            .with_context(|| "SerDeShelleyFileFormat can not create file")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
+        let json_str = serde_json::to_string(&file_format)
+            .with_context(|| "SerDeShelleyFileFormat can not serialize data to json")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
 
-        write!(file, "{json_str}")?;
+        write!(file, "{json_str}")
+            .with_context(|| "SerDeShelleyFileFormat can not write data to file")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
         Ok(())
     }
 }
@@ -106,10 +113,16 @@ impl SerDeShelleyFileFormat for Sum6KesBytes {
     /// Deserialize a Cardano key from file. Cardano KES key Shelley format does not
     /// contain the period (it is always zero). Therefore we need to include it in the
     /// deserialisation.
-    fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, ParseError> {
-        let data = fs::read_to_string(path)?;
-        let file: ShelleyFileFormat = serde_json::from_str(&data)?;
-        let mut hex_vector = Vec::from_hex(file.cbor_hex)?;
+    fn from_file<P: AsRef<Path>>(path: P) -> Result<Self, CodecParseError> {
+        let data = fs::read_to_string(path)
+            .with_context(|| "Sum6KesBytes can not read data from file")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
+        let file: ShelleyFileFormat = serde_json::from_str(&data)
+            .with_context(|| "Sum6KesBytes can not unserialize json data")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
+        let mut hex_vector = Vec::from_hex(file.cbor_hex)
+            .with_context(|| "Sum6KesBytes can not unserialize hex data")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
 
         // We check whether the serialisation was performed by the haskell library or the rust library
         if (hex_vector[2] & 4u8) == 0 {
@@ -119,16 +132,18 @@ impl SerDeShelleyFileFormat for Sum6KesBytes {
             hex_vector.extend_from_slice(&[0u8; 4]);
         }
 
-        let a: Self = serde_cbor::from_slice(&hex_vector)?;
+        let a: Self = serde_cbor::from_slice(&hex_vector)
+            .with_context(|| "Sum6KesBytes can not unserialize cbor data")
+            .map_err(|e| CodecParseError(anyhow!(e)))?;
         Ok(a)
     }
 }
 
 impl<'a> TryFrom<&'a mut Sum6KesBytes> for Sum6Kes<'a> {
-    type Error = ParseError;
+    type Error = CodecParseError;
 
     fn try_from(value: &'a mut Sum6KesBytes) -> Result<Self, Self::Error> {
-        Self::from_bytes(&mut value.0).map_err(|_| ParseError::KesFormat)
+        Self::from_bytes(&mut value.0).map_err(|e| CodecParseError(anyhow!(format!("{e:?}"))))
     }
 }
 

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

@@ -3,20 +3,24 @@
 //! These wrappers allows keeping mithril-stm agnostic to Cardano, while providing some
 //! guarantees that mithril-stm will not be misused in the context of Cardano.  
 
-use crate::crypto_helper::{
-    cardano::{ParseError, SerDeShelleyFileFormat},
-    types::{
-        ProtocolParameters, ProtocolPartyId, ProtocolSignerVerificationKey,
-        ProtocolSignerVerificationKeySignature, ProtocolStakeDistribution,
+use crate::{
+    crypto_helper::{
+        cardano::SerDeShelleyFileFormat,
+        types::{
+            ProtocolParameters, ProtocolPartyId, ProtocolSignerVerificationKey,
+            ProtocolSignerVerificationKeySignature, ProtocolStakeDistribution,
+        },
+        ProtocolOpCert,
     },
-    ProtocolOpCert,
+    StdError, StdResult,
 };
 
 use mithril_stm::key_reg::{ClosedKeyReg, KeyReg};
 use mithril_stm::stm::{Stake, StmInitializer, StmParameters, StmSigner, StmVerificationKeyPoP};
 use mithril_stm::RegisterError;
 
 use crate::crypto_helper::cardano::Sum6KesBytes;
+use anyhow::{anyhow, Context};
 use blake2::{
     digest::{consts::U32, FixedOutput},
     Blake2b, Digest,
@@ -36,7 +40,7 @@ type D = Blake2b<U32>;
 pub type KESPeriod = u32;
 
 /// New registration error
-#[derive(Error, Debug, PartialEq, Eq)]
+#[derive(Error, Debug)]
 pub enum ProtocolRegistrationErrorWrapper {
     /// Error raised when a party id is needed but not provided
     // TODO: Should be removed once the signer certification is fully deployed
@@ -72,16 +76,16 @@ pub enum ProtocolRegistrationErrorWrapper {
     PoolAddressEncoding,
 
     /// Error raised when a core registration error occurs
-    #[error("core registration error: '{0}'")]
-    CoreRegister(#[from] RegisterError),
+    #[error("core registration error: '{0:?}'")]
+    CoreRegister(StdError),
 }
 
 /// New initializer error
 #[derive(Error, Debug)]
 pub enum ProtocolInitializerErrorWrapper {
-    /// Error raised when a codec parse error occurs
-    #[error("codec parse error: '{0}'")]
-    Codec(#[from] ParseError),
+    /// Error raised when the underlying protocol initializer fails
+    #[error("protocol initializer error {0:?}")]
+    ProtocolInitializer(StdError),
 
     /// Error raised when a KES update error occurs
     #[error("KES key cannot be updated for period {0}")]
@@ -122,19 +126,22 @@ impl StmInitializerWrapper {
         kes_period: Option<KESPeriod>,
         stake: Stake,
         rng: &mut R,
-    ) -> Result<Self, ProtocolInitializerErrorWrapper> {
+    ) -> StdResult<Self> {
         let stm_initializer = StmInitializer::setup(params, stake, rng);
         let kes_signature = if let Some(kes_sk_path) = kes_sk_path {
-            let mut kes_sk_bytes = Sum6KesBytes::from_file(kes_sk_path)?;
+            let mut kes_sk_bytes = Sum6KesBytes::from_file(kes_sk_path)
+                .map_err(|e| anyhow!(e))
+                .with_context(|| "StmInitializerWrapper can not read KES secret key from file")?;
             let mut kes_sk = Sum6Kes::try_from(&mut kes_sk_bytes)
-                .map_err(ProtocolInitializerErrorWrapper::Codec)?;
+                .map_err(|e| ProtocolInitializerErrorWrapper::ProtocolInitializer(anyhow!(e)))
+                .with_context(|| "StmInitializerWrapper can not use KES secret key")?;
             let kes_sk_period = kes_sk.get_period();
             let provided_period = kes_period.unwrap_or_default();
             if kes_sk_period > provided_period {
-                return Err(ProtocolInitializerErrorWrapper::KesMismatch(
+                return Err(anyhow!(ProtocolInitializerErrorWrapper::KesMismatch(
                     kes_sk_period,
                     provided_period,
-                ));
+                )));
             }
 
             // We need to perform the evolutions
@@ -192,7 +199,10 @@ impl StmInitializerWrapper {
         self,
         closed_reg: ClosedKeyReg<D>,
     ) -> Result<StmSigner<D>, ProtocolRegistrationErrorWrapper> {
-        Ok(self.stm_initializer.new_signer(closed_reg)?)
+        self.stm_initializer
+            .new_signer(closed_reg)
+            .with_context(|| "StmInitializerWrapper can not create a new signer")
+            .map_err(|e| ProtocolRegistrationErrorWrapper::CoreRegister(anyhow!(e)))
     }
 
     /// Convert to bytes
@@ -279,7 +289,8 @@ impl KeyRegWrapper {
         if let Some(&stake) = self.stake_distribution.get(&pool_id_bech32) {
             self.stm_key_reg
                 .register(stake, pk.into())
-                .map_err(ProtocolRegistrationErrorWrapper::CoreRegister)?;
+                .with_context(|| format!("KeyRegWrapper can not register pool {pool_id_bech32}"))
+                .map_err(|e| ProtocolRegistrationErrorWrapper::CoreRegister(anyhow!(e)))?;
             return Ok(pool_id_bech32);
         }
         Err(ProtocolRegistrationErrorWrapper::PartyIdNonExisting)

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

@@ -1,9 +1,11 @@
-use ed25519_dalek::{SignatureError, Signer, SigningKey};
+use ed25519_dalek::{Signer, SigningKey};
 use rand_chacha::rand_core::{self, CryptoRng, RngCore, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
+use crate::{StdError, StdResult};
+
 use super::ProtocolKey;
 
 /// Wrapper of [Ed25519:PublicKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.VerifyingKey.html).
@@ -20,7 +22,7 @@ pub type EraMarkersVerifierSignature = ProtocolKey<ed25519_dalek::Signature>;
 pub enum EraMarkersVerifierError {
     /// Error raised when a Signature verification fail
     #[error("era markers signature verification error: '{0}'")]
-    SignatureVerification(#[from] SignatureError),
+    SignatureVerification(StdError),
 }
 
 /// A cryptographic signer that is responsible for signing the EraMarkers
@@ -85,11 +87,7 @@ impl EraMarkersVerifier {
     }
 
     /// Verifies the signature of a message
-    pub fn verify(
-        &self,
-        message: &[u8],
-        signature: &EraMarkersVerifierSignature,
-    ) -> Result<(), EraMarkersVerifierError> {
+    pub fn verify(&self, message: &[u8], signature: &EraMarkersVerifierSignature) -> StdResult<()> {
         Ok(self.verification_key.verify_strict(message, signature)?)
     }
 }

mithril-common/src/crypto_helper/era.rs

@@ -1,5 +1,6 @@
-use crate::StdResult;
-use ed25519_dalek::{SignatureError, Signer, SigningKey};
+use crate::{StdError, StdResult};
+use anyhow::anyhow;
+use ed25519_dalek::{Signer, SigningKey};
 use rand_chacha::rand_core::{self, CryptoRng, RngCore, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use serde::{Deserialize, Serialize};
@@ -10,11 +11,8 @@ use super::{ProtocolGenesisSecretKey, ProtocolGenesisSignature, ProtocolGenesisV
 
 #[derive(Error, Debug)]
 /// [ProtocolGenesisSigner] and [ProtocolGenesisVerifier] related errors.
-pub enum ProtocolGenesisError {
-    /// Error raised when a Genesis Signature verification fail
-    #[error("genesis signature verification error: '{0}'")]
-    SignatureVerification(#[from] SignatureError),
-}
+#[error("genesis signature verification error: '{0}'")]
+pub struct ProtocolGenesisError(StdError);
 
 /// A protocol Genesis Signer that is responsible for signing the
 /// [Genesis Certificate](https://mithril.network/doc/mithril/mithril-protocol/certificates#the-certificate-chain-design)
@@ -90,12 +88,11 @@ impl ProtocolGenesisVerifier {
     }
 
     /// Verifies the signature of a message
-    pub fn verify(
-        &self,
-        message: &[u8],
-        signature: &ProtocolGenesisSignature,
-    ) -> Result<(), ProtocolGenesisError> {
-        Ok(self.verification_key.verify_strict(message, signature)?)
+    pub fn verify(&self, message: &[u8], signature: &ProtocolGenesisSignature) -> StdResult<()> {
+        Ok(self
+            .verification_key
+            .verify_strict(message, signature)
+            .map_err(|e| ProtocolGenesisError(anyhow!(e)))?)
     }
 }
 

mithril-common/src/crypto_helper/genesis.rs

@@ -7,7 +7,7 @@ use crate::{
     era::{EraMarker, EraReaderAdapter},
     StdError, StdResult,
 };
-use anyhow::anyhow;
+use anyhow::{anyhow, Context};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
@@ -80,7 +80,8 @@ impl EraMarkersPayload {
 
         markers_verifier
             .verify(&self.message_to_bytes()?, &signature)
-            .map_err(|e| EraMarkersPayloadError::VerifySignature(e.into()))
+            .with_context(|| "era markers payload could not verify signature")
+            .map_err(EraMarkersPayloadError::VerifySignature)
     }
 
     /// Sign an era markers payload

mithril-common/src/era/adapters/cardano_chain.rs

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-signer"
-version = "0.2.79"
+version = "0.2.80"
 description = "A Mithril Signer"
 authors = { workspace = true }
 edition = { workspace = true }