feat: improve type errors

Author: apskhem

rust/catalyst-types/Cargo.toml

@@ -16,7 +16,6 @@ workspace = true
 name = "catalyst_types"
 
 [dependencies]
-anyhow = "1.0.95"
 blake2b_simd = "1.0.2"
 coset = "0.3.8"
 ed25519-dalek = "2.1.1"

rust/catalyst-types/src/conversion.rs

@@ -1,6 +1,26 @@
 //! Conversion functions
 
-use anyhow::bail;
+use thiserror::Error;
+
+/// Errors that can occur when converting bytes to an Ed25519 verifying key.
+#[derive(Debug, Error)]
+pub enum VKeyFromBytesError {
+    /// Indicates the provided byte slice has an invalid length.
+    #[error("Invalid byte length: expected {expected} bytes, got {actual}")]
+    InvalidLength {
+        /// The expected number of bytes (must be 32).
+        expected: usize,
+        /// The actual number of bytes in the provided input.
+        actual: usize,
+    },
+    /// Indicates that the bytes could not be parsed into an Ed25519 public key.
+    #[error("Failed to parse Ed25519 public key: {source}")]
+    ParseError {
+        /// The underlying error from `ed25519_dalek`.
+        #[from]
+        source: ed25519_dalek::SignatureError,
+    },
+}
 
 /// Convert an `<T>` to `<R>` (saturate if out of range).
 /// Note can convert any int to float, or f32 to f64 as well.
@@ -35,21 +55,20 @@ pub fn from_saturating<
 /// # Errors
 ///
 /// Fails if the bytes are not a valid ED25519 Public Key
-pub fn vkey_from_bytes(bytes: &[u8]) -> anyhow::Result<ed25519_dalek::VerifyingKey> {
+pub fn vkey_from_bytes(bytes: &[u8]) -> Result<ed25519_dalek::VerifyingKey, VKeyFromBytesError> {
     if bytes.len() != ed25519_dalek::PUBLIC_KEY_LENGTH {
-        bail!(
-            "Failed to convert bytes to ED25519 public key. Expected {} bytes, got {}",
-            ed25519_dalek::PUBLIC_KEY_LENGTH,
-            bytes.len()
-        );
+        return Err(VKeyFromBytesError::InvalidLength {
+            expected: ed25519_dalek::PUBLIC_KEY_LENGTH,
+            actual: bytes.len(),
+        });
     }
 
     let mut ed25519 = [0u8; ed25519_dalek::PUBLIC_KEY_LENGTH];
     ed25519.copy_from_slice(bytes); // Can't panic because we already validated its size.
 
     let pubkey = match ed25519_dalek::VerifyingKey::from_bytes(&ed25519) {
         Ok(key) => key,
-        Err(err) => bail!("Failed to convert Ed25519 public key in SimplePublicKeyType {err}"),
+        Err(err) => return Err(VKeyFromBytesError::ParseError { source: err }),
     };
     Ok(pubkey)
 }

rust/catalyst-types/src/hashes.rs

@@ -2,9 +2,9 @@
 
 use std::{fmt, str::FromStr};
 
-use anyhow::bail;
 use blake2b_simd::Params;
 use pallas_crypto::hash::Hash;
+use thiserror::Error;
 
 /// Number of bytes in a blake2b 224 hash.
 pub const BLAKE_2B224_SIZE: usize = 224 / 8;
@@ -24,6 +24,20 @@ pub const BLAKE_2B128_SIZE: usize = 128 / 8;
 /// `Blake2B` 128bit Hash
 pub type Blake2b128Hash = Blake2bHash<BLAKE_2B128_SIZE>;
 
+/// Errors that can occur when converting to a `Blake2bHash`.
+#[derive(Debug, Error)]
+pub enum Blake2bHashError {
+    /// Indicates that the input byte slice has invalid length of bytes to create a valid
+    /// hash.
+    #[error("Invalid length: expected {expected} bytes, got {actual}")]
+    InvalidLength {
+        /// The expected number of bytes (must be 32 or 28).
+        expected: usize,
+        /// The actual number of bytes in the provided input.
+        actual: usize,
+    },
+}
+
 /// data that is a blake2b [`struct@Hash`] of `BYTES` long.
 ///
 /// Possible values with Cardano are 32 bytes long (block hash or transaction
@@ -73,11 +87,14 @@ impl<const BYTES: usize> From<Blake2bHash<BYTES>> for Vec<u8> {
 
 /// Convert hash in a form of byte array into the `Blake2bHash` type.
 impl<const BYTES: usize> TryFrom<&[u8]> for Blake2bHash<BYTES> {
-    type Error = anyhow::Error;
+    type Error = Blake2bHashError;
 
     fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
         if value.len() < BYTES {
-            bail!("Invalid input length");
+            return Err(Blake2bHashError::InvalidLength {
+                expected: BYTES,
+                actual: value.len(),
+            });
         }
 
         let mut hash = [0; BYTES];
@@ -88,15 +105,15 @@ impl<const BYTES: usize> TryFrom<&[u8]> for Blake2bHash<BYTES> {
 }
 
 impl<const BYTES: usize> TryFrom<&Vec<u8>> for Blake2bHash<BYTES> {
-    type Error = anyhow::Error;
+    type Error = Blake2bHashError;
 
     fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
         value.as_slice().try_into()
     }
 }
 
 impl<const BYTES: usize> TryFrom<Vec<u8>> for Blake2bHash<BYTES> {
-    type Error = anyhow::Error;
+    type Error = Blake2bHashError;
 
     fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
         value.as_slice().try_into()

rust/catalyst-types/src/kid_uri/authority.rs

@@ -5,6 +5,20 @@ use std::{
     str::FromStr,
 };
 
+use thiserror::Error;
+
+/// Errors that can occur when parsing an `Authority` from a string.
+#[allow(clippy::module_name_repetitions)]
+#[derive(Debug, Error)]
+pub enum AuthorityError {
+    /// The input string does not match any known authority.
+    #[error("Unknown Authority: {input}")]
+    UnknownAuthority {
+        /// The input string.
+        input: String,
+    },
+}
+
 /// URI Authority
 #[derive(Debug, Clone)]
 pub enum Authority {
@@ -15,13 +29,17 @@ pub enum Authority {
 }
 
 impl FromStr for Authority {
-    type Err = anyhow::Error;
+    type Err = AuthorityError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "cardano" => Ok(Authority::Cardano),
             "midnight" => Ok(Authority::Midnight),
-            _ => Err(anyhow::anyhow!("Unknown Authority: {s}")),
+            _ => {
+                Err(AuthorityError::UnknownAuthority {
+                    input: s.to_string(),
+                })
+            },
         }
     }
 }

rust/catalyst-types/src/kid_uri/role0_pk.rs

@@ -5,30 +5,64 @@ use std::{
     str::FromStr,
 };
 
+use thiserror::Error;
+
+/// Errors that can occur when parsing a `Role0PublicKey` from a string.
+#[derive(Debug, Error)]
+pub enum Role0PublicKeyError {
+    /// The input string does not start with the required "0x" prefix.
+    #[error("Role0 Public Key hex string must start with '0x': {input}")]
+    MissingPrefix {
+        /// The input string.
+        input: String,
+    },
+    /// The input string is not a valid hex-encoded string.
+    #[error("Role0 Public Key is not a valid hex string: {source}")]
+    InvalidHex {
+        /// The underlying error from `hex`.
+        #[from]
+        source: hex::FromHexError,
+    },
+    /// The decoded key does not have the required length of 32 bytes.
+    #[error("Role0 Public Key must have 32 bytes: {input}, len: {len}")]
+    InvalidLength {
+        /// The input string.
+        input: String,
+        /// The actual length of the input.
+        len: usize
+    },
+    /// Unexpected error during key conversion.
+    #[error("Unable to read Role0 Public Key, this should never happen")]
+    ConversionError,
+}
+
 /// Role0 Public Key.
 #[derive(Debug, Clone)]
 pub struct Role0PublicKey([u8; 32]);
 
 impl FromStr for Role0PublicKey {
-    type Err = anyhow::Error;
+    type Err = Role0PublicKeyError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let Some(role0_hex) = s.strip_prefix("0x") else {
-            anyhow::bail!("Role0 Public Key hex string must start with '0x': {}", s);
-        };
-        let role0_key = hex::decode(role0_hex)
-            .map_err(|e| anyhow::anyhow!("Role0 Public Key is not a valid hex string: {}", e))?;
+        let role0_hex = s.strip_prefix("0x").ok_or_else(|| {
+            Role0PublicKeyError::MissingPrefix {
+                input: s.to_string(),
+            }
+        })?;
+
+        let role0_key = hex::decode(role0_hex).map_err(Role0PublicKeyError::from)?;
+
         if role0_key.len() != 32 {
-            anyhow::bail!(
-                "Role0 Public Key must have 32 bytes: {role0_hex}, len: {}",
-                role0_key.len()
-            );
+            return Err(Role0PublicKeyError::InvalidLength {
+                input: role0_hex.to_string(),
+                len: role0_key.len(),
+            });
         }
-        let role0 = role0_key.try_into().map_err(|e| {
-            anyhow::anyhow!(
-                "Unable to read Role0 Public Key, this should never happen. Eror: {e:?}"
-            )
-        })?;
+
+        let role0: [u8; 32] = role0_key
+            .try_into()
+            .map_err(|_| Role0PublicKeyError::ConversionError)?;
+
         Ok(Role0PublicKey(role0))
     }
 }

rust/catalyst-types/src/uuid/mod.rs

@@ -1,5 +1,8 @@
 //! `UUID` types.
 
+use thiserror::Error;
+use uuid::Uuid;
+
 mod uuid_v4;
 mod uuid_v7;
 
@@ -9,19 +12,38 @@ pub use uuid_v7::UuidV7 as V7;
 /// Invalid Doc Type UUID
 pub const INVALID_UUID: uuid::Uuid = uuid::Uuid::from_bytes([0x00; 16]);
 
+/// Errors that can occur when decoding CBOR-encoded UUIDs.
+#[derive(Debug, Error)]
+pub enum CborUuidError {
+    /// Indicates that the CBOR value is not a valid UUID tag.
+    #[error("Invalid CBOR encoded UUID type")]
+    InvalidCborType,
+    /// Indicates that the byte slice has an invalid size for a UUID.
+    #[error("Invalid CBOR encoded UUID type: invalid bytes size")]
+    InvalidByteSize,
+    /// Indicates that the UUID version does not match the expected version.
+    #[error("UUID {uuid} is not `v{expected_version}`")]
+    InvalidVersion {
+        /// The decoded UUID that was checked.
+        uuid: Uuid,
+        /// The expected version of the UUID, which did not match the decoded one.
+        expected_version: usize,
+    },
+}
+
 /// CBOR tag for UUID content.
 pub const UUID_CBOR_TAG: u64 = 37;
 
 /// Decode `CBOR` encoded `UUID`.
-pub(crate) fn decode_cbor_uuid(val: &coset::cbor::Value) -> anyhow::Result<uuid::Uuid> {
+pub(crate) fn decode_cbor_uuid(val: &coset::cbor::Value) -> Result<uuid::Uuid, CborUuidError> {
     let Some((UUID_CBOR_TAG, coset::cbor::Value::Bytes(bytes))) = val.as_tag() else {
-        anyhow::bail!("Invalid CBOR encoded UUID type");
+        return Err(CborUuidError::InvalidCborType);
     };
     let uuid = uuid::Uuid::from_bytes(
         bytes
             .clone()
             .try_into()
-            .map_err(|_| anyhow::anyhow!("Invalid CBOR encoded UUID type, invalid bytes size"))?,
+            .map_err(|_| CborUuidError::InvalidByteSize)?,
     );
     Ok(uuid)
 }

rust/catalyst-types/src/uuid/uuid_v4.rs

@@ -41,20 +41,21 @@ impl Display for UuidV4 {
 }
 
 impl TryFrom<&coset::cbor::Value> for UuidV4 {
-    type Error = anyhow::Error;
+    type Error = super::CborUuidError;
 
     fn try_from(cbor_value: &coset::cbor::Value) -> Result<Self, Self::Error> {
         match decode_cbor_uuid(cbor_value) {
             Ok(uuid) => {
                 if uuid.get_version_num() == Self::UUID_VERSION_NUMBER {
                     Ok(Self { uuid })
                 } else {
-                    anyhow::bail!("UUID {uuid} is not `v{}`", Self::UUID_VERSION_NUMBER);
+                    Err(super::CborUuidError::InvalidVersion {
+                        uuid,
+                        expected_version: Self::UUID_VERSION_NUMBER,
+                    })
                 }
             },
-            Err(e) => {
-                anyhow::bail!("Invalid UUID. Error: {e}");
-            },
+            Err(e) => Err(e),
         }
     }
 }

rust/catalyst-types/src/uuid/uuid_v7.rs

@@ -41,20 +41,21 @@ impl Display for UuidV7 {
 }
 
 impl TryFrom<&coset::cbor::Value> for UuidV7 {
-    type Error = anyhow::Error;
+    type Error = super::CborUuidError;
 
     fn try_from(cbor_value: &coset::cbor::Value) -> Result<Self, Self::Error> {
         match decode_cbor_uuid(cbor_value) {
             Ok(uuid) => {
                 if uuid.get_version_num() == Self::UUID_VERSION_NUMBER {
                     Ok(Self { uuid })
                 } else {
-                    anyhow::bail!("UUID {uuid} is not `v{}`", Self::UUID_VERSION_NUMBER);
+                    Err(super::CborUuidError::InvalidVersion {
+                        uuid,
+                        expected_version: Self::UUID_VERSION_NUMBER,
+                    })
                 }
             },
-            Err(e) => {
-                anyhow::bail!("Invalid UUID. Error: {e}");
-            },
+            Err(e) => Err(e),
         }
     }
 }