chore: fmtfix

Author: apskhem

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

@@ -1,37 +1,37 @@
 //! COSE Signature Protected Header `kid` URI Authority.
 
 use std::{
-  fmt::{Display, Formatter},
-  str::FromStr,
+    fmt::{Display, Formatter},
+    str::FromStr,
 };
 
 /// URI Authority
 #[derive(Debug, Clone)]
 pub enum Authority {
-  /// Cardano Blockchain
-  Cardano,
-  /// Midnight Blockchain
-  Midnight,
+    /// Cardano Blockchain
+    Cardano,
+    /// Midnight Blockchain
+    Midnight,
 }
 
 impl FromStr for Authority {
-  type Err = anyhow::Error;
+    type Err = anyhow::Error;
 
-  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}")),
-      }
-  }
+    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}")),
+        }
+    }
 }
 
 impl Display for Authority {
-  fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
-      let authority = match self {
-          Self::Cardano => "cardano",
-          Self::Midnight => "midnight",
-      };
-      write!(f, "{authority}")
-  }
-}
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let authority = match self {
+            Self::Cardano => "cardano",
+            Self::Midnight => "midnight",
+        };
+        write!(f, "{authority}")
+    }
+}

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

@@ -40,4 +40,4 @@ pub enum KidURIError {
     /// Encryption key Identifier Fragment is not valid
     #[error("Invalid Encryption Key Fragment")]
     InvalidEncryptionKeyFragment,
-}
+}

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

@@ -1,9 +1,9 @@
 //! COSE Signature Protected Header `kid` Role0 Key Version.
 
 use std::{
-  fmt::{Display, Formatter},
-  num::ParseIntError,
-  str::FromStr,
+    fmt::{Display, Formatter},
+    num::ParseIntError,
+    str::FromStr,
 };
 
 use thiserror::Error;
@@ -12,31 +12,31 @@ use thiserror::Error;
 #[derive(Error, Debug)]
 #[allow(clippy::module_name_repetitions)]
 pub enum KeyRotationError {
-  /// Key Rotation could not be parsed from a string
-  #[error("Invalid Role Key Rotation")]
-  InvalidRole(#[from] ParseIntError),
+    /// Key Rotation could not be parsed from a string
+    #[error("Invalid Role Key Rotation")]
+    InvalidRole(#[from] ParseIntError),
 }
 
 /// Rotation count of the Role Key.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct KeyRotation(u16);
 
 impl From<u16> for KeyRotation {
-  fn from(value: u16) -> Self {
-      Self(value)
-  }
+    fn from(value: u16) -> Self {
+        Self(value)
+    }
 }
 
 impl FromStr for KeyRotation {
-  type Err = KeyRotationError;
+    type Err = KeyRotationError;
 
-  fn from_str(s: &str) -> Result<Self, Self::Err> {
-      Ok(Self(s.parse::<u16>()?))
-  }
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self(s.parse::<u16>()?))
+    }
 }
 
 impl Display for KeyRotation {
-  fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
-      write!(f, "{}", self.0)
-  }
-}
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(f, "{}", self.0)
+    }
+}

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

@@ -228,4 +228,4 @@ mod tests {
         let encoded_vk = base64_url::encode(vk.as_bytes());
         assert_eq!(encoded_vk, "1234");
     }
-}
+}

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

@@ -1,40 +1,40 @@
 //! COSE Signature Protected Header `kid` URI Role0 Public Key.
 
 use std::{
-  fmt::{Display, Formatter},
-  str::FromStr,
+    fmt::{Display, Formatter},
+    str::FromStr,
 };
 
 /// Role0 Public Key.
 #[derive(Debug, Clone)]
 pub struct Role0PublicKey([u8; 32]);
 
 impl FromStr for Role0PublicKey {
-  type Err = anyhow::Error;
+    type Err = anyhow::Error;
 
-  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))?;
-      if role0_key.len() != 32 {
-          anyhow::bail!(
-              "Role0 Public Key must have 32 bytes: {role0_hex}, 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:?}"
-          )
-      })?;
-      Ok(Role0PublicKey(role0))
-  }
+    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))?;
+        if role0_key.len() != 32 {
+            anyhow::bail!(
+                "Role0 Public Key must have 32 bytes: {role0_hex}, 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:?}"
+            )
+        })?;
+        Ok(Role0PublicKey(role0))
+    }
 }
 
 impl Display for Role0PublicKey {
-  fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
-      write!(f, "0x{}", hex::encode(self.0))
-  }
-}
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(f, "0x{}", hex::encode(self.0))
+    }
+}

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

@@ -41,4 +41,4 @@ impl Display for RoleIndex {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
         write!(f, "{}", self.0)
     }
-}
+}

rust/catalyst-types/tests/mod.rs

@@ -12,6 +12,8 @@ fn test_type_usage() {
     type D = catalyst_types::uuid::V4;
     type E = catalyst_types::uuid::V7;
 
+    type F = catalyst_types::kid_uri::KidURI;
+
     let bytes: [u8; 32] = [0; 32];
     let _ = catalyst_types::hashes::Blake2bHash::from(bytes);
 }