chore: kiduri

Author: apskhem

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

@@ -4,9 +4,9 @@ use thiserror::Error;
 
 use super::{key_rotation::KeyRotationError, role_index::RoleIndexError};
 
-/// Errors that can occur when parsing a `KidURI`
+/// Errors that can occur when parsing a `KidUri`
 #[derive(Error, Debug)]
-pub enum KidURIError {
+pub enum KidUriError {
     /// Invalid KID URI
     #[error("Invalid URI")]
     InvalidURI(#[from] fluent_uri::error::ParseError),

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

@@ -29,7 +29,7 @@ use role_index::RoleIndex;
 /// Identifier (`URI`).
 #[derive(Debug, Clone)]
 #[allow(clippy::module_name_repetitions)]
-pub struct KidURI {
+pub struct KidUri {
     /// Network
     network: String,
     /// Sub Network
@@ -46,13 +46,13 @@ pub struct KidURI {
     encryption: bool,
 }
 
-impl KidURI {
+impl KidUri {
     /// Encryption Key Identifier Fragment
     const ENCRYPTION_FRAGMENT: &EStr<Fragment> = EStr::new_or_panic("encrypt");
     /// URI scheme for Catalyst
     const SCHEME: &Scheme = Scheme::new_or_panic("kid.catalyst-rbac");
 
-    /// Get the network the `KidURI` is referencing the registration to.
+    /// Get the network the `KidUri` is referencing the registration to.
     #[must_use]
     pub fn network(&self) -> (String, Option<String>) {
         (self.network.clone(), self.subnet.clone())
@@ -83,8 +83,8 @@ impl KidURI {
     }
 }
 
-impl KidURI {
-    /// Create a new `KidURI` for a Signing Key
+impl KidUri {
+    /// Create a new `KidUri` for a Signing Key
     fn new(
         network: &str, subnet: Option<&str>, role0_pk: VerifyingKey, role: RoleIndex,
         rotation: KeyRotation,
@@ -99,7 +99,7 @@ impl KidURI {
         }
     }
 
-    /// Create a new `KidURI` for an Encryption Key
+    /// Create a new `KidUri` for an Encryption Key
     fn new_encryption(
         network: &str, subnet: Option<&str>, role0_pk: VerifyingKey, role: RoleIndex,
         rotation: KeyRotation,
@@ -110,21 +110,21 @@ impl KidURI {
     }
 }
 
-impl FromStr for KidURI {
-    type Err = errors::KidURIError;
+impl FromStr for KidUri {
+    type Err = errors::KidUriError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let uri = Uri::parse(s)?;
 
         // Check if its the correct scheme.
-        if uri.scheme() != KidURI::SCHEME {
-            return Err(errors::KidURIError::InvalidScheme);
+        if uri.scheme() != KidUri::SCHEME {
+            return Err(errors::KidUriError::InvalidScheme);
         }
 
         // Decode the network and subnet
         let auth = uri
             .authority()
-            .ok_or(errors::KidURIError::NoDefinedNetwork)?;
+            .ok_or(errors::KidUriError::NoDefinedNetwork)?;
         let network = auth.host();
         let subnet = auth.userinfo().map(std::string::ToString::to_string);
 
@@ -133,23 +133,23 @@ impl FromStr for KidURI {
         // Can ONLY have 3 path components, no more and no less
         // Less than 3 handled by errors below (4 because of leading `/` in path).
         if path.len() > 4 {
-            return Err(errors::KidURIError::InvalidPath);
+            return Err(errors::KidUriError::InvalidPath);
         };
 
         // Decode and validate the Role0 Public key from the path
-        let encoded_role0_key = path.get(1).ok_or(errors::KidURIError::InvalidRole0Key)?;
+        let encoded_role0_key = path.get(1).ok_or(errors::KidUriError::InvalidRole0Key)?;
         let decoded_role0_key =
             base64_url::decode(encoded_role0_key.decode().into_string_lossy().as_ref())?;
         let role0_pk = crate::conversion::vkey_from_bytes(&decoded_role0_key)
-            .or(Err(errors::KidURIError::InvalidRole0Key))?;
+            .or(Err(errors::KidUriError::InvalidRole0Key))?;
 
         // Decode and validate the Role Index from the path.
-        let encoded_role_index = path.get(2).ok_or(errors::KidURIError::InvalidRole)?;
+        let encoded_role_index = path.get(2).ok_or(errors::KidUriError::InvalidRole)?;
         let decoded_role_index = encoded_role_index.decode().into_string_lossy();
         let role_index = decoded_role_index.parse::<RoleIndex>()?;
 
         // Decode and validate the Rotation Value from the path.
-        let encoded_rotation = path.get(3).ok_or(errors::KidURIError::InvalidRotation)?;
+        let encoded_rotation = path.get(3).ok_or(errors::KidUriError::InvalidRotation)?;
         let decoded_rotation = encoded_rotation.decode().into_string_lossy();
         let rotation = decoded_rotation.parse::<KeyRotation>()?;
 
@@ -158,7 +158,7 @@ impl FromStr for KidURI {
                 if uri.fragment() == Some(Self::ENCRYPTION_FRAGMENT) {
                     Self::new_encryption(network, subnet.as_deref(), role0_pk, role_index, rotation)
                 } else {
-                    return Err(errors::KidURIError::InvalidEncryptionKeyFragment);
+                    return Err(errors::KidUriError::InvalidEncryptionKeyFragment);
                 }
             } else {
                 Self::new(network, subnet.as_deref(), role0_pk, role_index, rotation)
@@ -169,7 +169,7 @@ impl FromStr for KidURI {
     }
 }
 
-impl Display for KidURI {
+impl Display for KidUri {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
         write!(f, "{}://", Self::SCHEME.as_str())?;
         if let Some(subnet) = &self.subnet {
@@ -190,12 +190,12 @@ impl Display for KidURI {
     }
 }
 
-impl TryFrom<&[u8]> for KidURI {
-    type Error = errors::KidURIError;
+impl TryFrom<&[u8]> for KidUri {
+    type Error = errors::KidUriError;
 
     fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
         let kid_str = String::from_utf8_lossy(value);
-        KidURI::from_str(&kid_str)
+        KidUri::from_str(&kid_str)
     }
 }
 
@@ -204,7 +204,7 @@ mod tests {
     use ed25519_dalek::SigningKey;
     use rand::rngs::OsRng;
 
-    use super::KidURI;
+    use super::KidUri;
 
     const KID_TEST_VECTOR: [&str; 5] = [
         "kid.catalyst-rbac://cardano/FftxFnOrj2qmTuB2oZG2v0YEWJfKvQ9Gg8AgNAhDsKE/0/0",
@@ -217,7 +217,7 @@ mod tests {
     #[test]
     fn test_kid_uri_from_str() {
         for kid_string in KID_TEST_VECTOR {
-            let kid = kid_string.parse::<KidURI>().unwrap();
+            let kid = kid_string.parse::<KidUri>().unwrap();
             assert_eq!(format!("{kid}"), kid_string);
         }
     }

rust/catalyst-types/tests/mod.rs

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