fix suggestions

Author: Mr-Leshiy

rust/rbac-registration/src/cardano/cip509/cip509.rs

@@ -240,7 +240,7 @@ impl Cip509 {
     /// Would return only signing public keys for the present certificates,
     /// if certificate marked as deleted or undefined it would be skipped.
     #[must_use]
-    pub fn signing_pk_for_role(
+    pub fn signing_public_key_for_role(
         &self,
         role: RoleId,
     ) -> Option<VerifyingKey> {

rust/rbac-registration/src/cardano/cip509/types/cert_or_pk.rs

@@ -21,7 +21,7 @@ pub enum CertOrPk {
 
 impl CertOrPk {
     /// Extract public key from the given certificate or public key.
-    pub(crate) fn extract_pk(&self) -> Option<VerifyingKey> {
+    pub(crate) fn extract_public_key(&self) -> Option<VerifyingKey> {
         match self {
             CertOrPk::X509(Some(x509)) => extract_key::x509_key(x509).ok(),
             CertOrPk::C509(Some(c509)) => extract_key::c509_key(c509).ok(),

rust/rbac-registration/src/cardano/cip509/utils/cip134_uri_set.rs

@@ -92,17 +92,16 @@ impl Cip0134UriSet {
     pub(crate) fn role_uris(
         &self,
         role: usize,
-    ) -> HashSet<Cip0134Uri> {
-        let mut result = HashSet::new();
-
-        if let Some(uris) = self.x_uris().get(&role) {
-            result.extend(uris.iter().cloned());
-        }
-        if let Some(uris) = self.c_uris().get(&role) {
-            result.extend(uris.iter().cloned());
-        }
-
-        result
+    ) -> impl Iterator<Item = &Cip0134Uri> {
+        let x_iter = self
+            .x_uris()
+            .get(&role)
+            .map_or_else(|| [].iter(), |uris| uris.iter());
+        let c_iter = self
+            .c_uris()
+            .get(&role)
+            .map_or_else(|| [].iter(), |uris| uris.iter());
+        x_iter.chain(c_iter)
     }
 
     /// Returns a set of stake addresses by the given role.
@@ -112,7 +111,6 @@ impl Cip0134UriSet {
         role: usize,
     ) -> HashSet<StakeAddress> {
         self.role_uris(role)
-            .iter()
             .filter_map(|uri| {
                 match uri.address() {
                     Address::Stake(a) => Some(a.clone().into()),
@@ -401,7 +399,7 @@ mod tests {
         let set = cip509.certificate_uris().unwrap();
         assert!(!set.is_empty());
         assert!(set.c_uris().is_empty());
-        assert_eq!(set.role_uris(0).len(), 1);
+        assert_eq!(set.role_uris(0).count(), 1);
         assert_eq!(set.role_stake_addresses(0).len(), 1);
         assert_eq!(set.stake_addresses().len(), 1);
 

rust/rbac-registration/src/cardano/state.rs

@@ -31,7 +31,7 @@ pub trait RbacChainsState {
 
     /// Returns a corresponding to the RBAC chain's Catalyst ID corresponding by the given
     /// signing public key.
-    fn chain_catalyst_id_from_signing_pk(
+    fn chain_catalyst_id_from_signing_public_key(
         &self,
         key: &VerifyingKey,
     ) -> impl Future<Output = anyhow::Result<Option<CatalystId>>> + Send;
@@ -40,6 +40,6 @@ pub trait RbacChainsState {
     /// RBAC chain's by the given `CatalystId`.
     fn take_stake_address_from_chains(
         &mut self,
-        addresses: impl Iterator<Item = StakeAddress> + Send,
+        addresses: impl IntoIterator<Item = StakeAddress> + Send,
     ) -> impl Future<Output = anyhow::Result<()>> + Send;
 }

rust/rbac-registration/src/registration/cardano/mod.rs

@@ -71,15 +71,15 @@ impl RegistrationChain {
                     );
             }
 
-            check_signing_pk(cat_id, cip509, state).await?;
+            check_signing_public_key(cat_id, cip509, state).await?;
         }
 
         if cip509.report().is_problematic() {
             return Ok(None);
         }
 
         state
-            .take_stake_address_from_chains(cip509.stake_addresses().into_iter())
+            .take_stake_address_from_chains(cip509.stake_addresses())
             .await?;
 
         Ok(Some(new_chain))
@@ -133,7 +133,7 @@ impl RegistrationChain {
             }
         }
 
-        check_signing_pk(self.catalyst_id(), cip509, state).await?;
+        check_signing_public_key(self.catalyst_id(), cip509, state).await?;
 
         if cip509.report().is_problematic() {
             Ok(None)
@@ -151,7 +151,7 @@ impl RegistrationChain {
         &self,
         cip509: &Cip509,
     ) -> Option<Self> {
-        let latest_signing_pk = self.get_latest_signing_pk_for_role(RoleId::Role0);
+        let latest_signing_pk = self.get_latest_signing_public_key_for_role(RoleId::Role0);
         let new_inner = if let Some((signing_pk, _)) = latest_signing_pk {
             self.inner.update(cip509, signing_pk)?
         } else {
@@ -247,11 +247,11 @@ impl RegistrationChain {
     /// Get the latest signing public key for a role.
     /// Returns the public key and the rotation,`None` if not found.
     #[must_use]
-    pub fn get_latest_signing_pk_for_role(
+    pub fn get_latest_signing_public_key_for_role(
         &self,
         role: RoleId,
     ) -> Option<(VerifyingKey, KeyRotation)> {
-        self.inner.get_latest_signing_pk_for_role(role)
+        self.inner.get_latest_signing_public_key_for_role(role)
     }
 
     /// Get the latest encryption public key for a role.
@@ -261,7 +261,7 @@ impl RegistrationChain {
         &self,
         role: RoleId,
     ) -> Option<(VerifyingKey, KeyRotation)> {
-        self.inner.get_latest_encryption_pk_for_role(role)
+        self.inner.get_latest_encryption_public_key_for_role(role)
     }
 
     /// Get signing public key for a role with given rotation.
@@ -274,7 +274,7 @@ impl RegistrationChain {
     ) -> Option<VerifyingKey> {
         self.inner.role_data_record.get(role).and_then(|rdr| {
             rdr.signing_key_from_rotation(rotation)
-                .and_then(CertOrPk::extract_pk)
+                .and_then(CertOrPk::extract_public_key)
         })
     }
 
@@ -288,7 +288,7 @@ impl RegistrationChain {
     ) -> Option<VerifyingKey> {
         self.inner.role_data_record.get(role).and_then(|rdr| {
             rdr.encryption_key_from_rotation(rotation)
-                .and_then(CertOrPk::extract_pk)
+                .and_then(CertOrPk::extract_public_key)
         })
     }
 
@@ -398,7 +398,7 @@ impl RegistrationChainInner {
             return None;
         };
 
-        let Some(registration) = cip509.metadata().cloned() else {
+        let Some(registration) = cip509.metadata() else {
             cip509.report().missing_field("metadata", context);
             return None;
         };
@@ -408,7 +408,7 @@ impl RegistrationChainInner {
         let mut role_data_record = HashMap::new();
         let point_tx_idx = cip509.origin().clone();
         update_role_data(
-            &registration,
+            registration,
             &mut role_data_history,
             &mut role_data_record,
             &point_tx_idx,
@@ -423,7 +423,7 @@ impl RegistrationChainInner {
         let Some(signing_pk) = role0_data
             .signing_keys()
             .last()
-            .and_then(|key| key.data().extract_pk())
+            .and_then(|key| key.data().extract_public_key())
         else {
             cip509
                 .report()
@@ -643,31 +643,31 @@ impl RegistrationChainInner {
     /// Get the latest signing public key for a role.
     /// Returns the public key and the rotation,`None` if not found.
     #[must_use]
-    pub fn get_latest_signing_pk_for_role(
+    pub fn get_latest_signing_public_key_for_role(
         &self,
         role: RoleId,
     ) -> Option<(VerifyingKey, KeyRotation)> {
         self.role_data_record.get(&role).and_then(|rdr| {
             rdr.signing_keys().last().and_then(|key| {
                 let rotation = KeyRotation::from_latest_rotation(rdr.signing_keys());
 
-                key.data().extract_pk().map(|pk| (pk, rotation))
+                key.data().extract_public_key().map(|pk| (pk, rotation))
             })
         })
     }
 
     /// Get the latest encryption public key for a role.
     /// Returns the public key and the rotation, `None` if not found.
     #[must_use]
-    pub fn get_latest_encryption_pk_for_role(
+    pub fn get_latest_encryption_public_key_for_role(
         &self,
         role: RoleId,
     ) -> Option<(VerifyingKey, KeyRotation)> {
         self.role_data_record.get(&role).and_then(|rdr| {
             rdr.encryption_keys().last().and_then(|key| {
                 let rotation = KeyRotation::from_latest_rotation(rdr.encryption_keys());
 
-                key.data().extract_pk().map(|pk| (pk, rotation))
+                key.data().extract_public_key().map(|pk| (pk, rotation))
             })
         })
     }
@@ -731,7 +731,7 @@ fn check_validation_signature(
 
 /// Checks that a new registration doesn't contain a signing key that was used by any
 /// other chain.
-async fn check_signing_pk<State>(
+async fn check_signing_public_key<State>(
     cat_id: &CatalystId,
     cip509: &Cip509,
     state: &State,
@@ -740,8 +740,10 @@ where
     State: RbacChainsState,
 {
     for role in cip509.all_roles() {
-        if let Some(key) = cip509.signing_pk_for_role(role)
-            && let Some(previous) = state.chain_catalyst_id_from_signing_pk(&key).await?
+        if let Some(key) = cip509.signing_public_key_for_role(role)
+            && let Some(previous) = state
+                .chain_catalyst_id_from_signing_public_key(&key)
+                .await?
             && &previous != cat_id
         {
             cip509.report().functional_validation(
@@ -835,7 +837,7 @@ mod test {
         assert_eq!(role_0_data.extended_data().len(), 2);
 
         let (_k, r) = update
-            .get_latest_signing_pk_for_role(RoleId::Role0)
+            .get_latest_signing_public_key_for_role(RoleId::Role0)
             .unwrap();
         assert_eq!(r, KeyRotation::from(1));
         assert!(