chore(dpp): fix build errors and some lint warnings

lklimek · lklimek · commit e6bda11e2960 · 2024-11-14T12:02:23.000+01:00
diff --git a/packages/rs-dpp/src/errors/protocol_error.rs b/packages/rs-dpp/src/errors/protocol_error.rs
@@ -1,4 +1,3 @@
-use dashcore::blsful::BlsError;
 use thiserror::Error;
 
 use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError;
@@ -249,9 +248,10 @@ pub enum ProtocolError {
     #[error("invalid cbor error: {0}")]
     InvalidCBOR(String),
 
-    /// Invalid CBOR error
+    /// BLS signature error
+    #[cfg(feature = "bls-signatures")]
     #[error(transparent)]
-    BlsError(#[from] BlsError),
+    BlsError(#[from] dashcore::blsful::BlsError),
 }
 
 impl From<&str> for ProtocolError {
diff --git a/packages/rs-dpp/src/identity/identity_public_key/key_type.rs b/packages/rs-dpp/src/identity/identity_public_key/key_type.rs
@@ -8,21 +8,25 @@ use dashcore::secp256k1::rand::rngs::StdRng as EcdsaRng;
 #[cfg(feature = "random-public-keys")]
 use dashcore::secp256k1::rand::SeedableRng;
 use dashcore::secp256k1::Secp256k1;
-use dashcore::{blsful, ed25519_dalek, Network};
+use dashcore::Network;
 use itertools::Itertools;
 use lazy_static::lazy_static;
 
-use crate::bls_signatures::{Bls12381G2Impl, BlsError};
 use crate::fee::Credits;
 use crate::version::PlatformVersion;
-use crate::{bls_signatures, ProtocolError};
+use crate::ProtocolError;
 #[cfg(feature = "random-public-keys")]
 use rand::rngs::StdRng;
 #[cfg(feature = "random-public-keys")]
 use rand::Rng;
 use serde_repr::{Deserialize_repr, Serialize_repr};
 use std::collections::HashMap;
 use std::convert::TryFrom;
+#[cfg(feature = "bls-signatures")]
+use {
+    crate::bls_signatures::{self as bls_signatures, Bls12381G2Impl, BlsError},
+    dashcore::{blsful, ed25519_dalek},
+};
 
 #[allow(non_camel_case_types)]
 #[repr(u8)]
@@ -245,19 +249,17 @@ impl KeyType {
             KeyType::EDDSA_25519_HASH160 => {
                 #[cfg(feature = "ed25519-dalek")]
                 {
-                    let key_pair = ed25519_dalek::SigningKey::from_bytes(&private_key_bytes);
+                    let key_pair = ed25519_dalek::SigningKey::from_bytes(private_key_bytes);
                     Ok(ripemd160_sha256(key_pair.verifying_key().to_bytes().as_slice()).to_vec())
                 }
                 #[cfg(not(feature = "ed25519-dalek"))]
                 return Err(ProtocolError::NotSupported(
                     "Converting a private key to a eddsa hash 160 is not supported without the ed25519-dalek feature".to_string(),
                 ));
             }
-            KeyType::BIP13_SCRIPT_HASH => {
-                return Err(ProtocolError::NotSupported(
-                    "Converting a private key to a script hash is not supported".to_string(),
-                ));
-            }
+            KeyType::BIP13_SCRIPT_HASH => Err(ProtocolError::NotSupported(
+                "Converting a private key to a script hash is not supported".to_string(),
+            )),
         }
     }
 
diff --git a/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs b/packages/rs-dpp/src/identity/identity_public_key/v0/methods/mod.rs
@@ -1,17 +1,19 @@
-#[cfg(feature = "bls-signatures")]
-use crate::bls_signatures;
 use crate::identity::identity_public_key::methods::hash::IdentityPublicKeyHashMethodsV0;
 use crate::identity::identity_public_key::v0::IdentityPublicKeyV0;
 use crate::identity::KeyType;
 use crate::util::hash::ripemd160_sha256;
 use crate::ProtocolError;
 use anyhow::anyhow;
-use dashcore::blsful::Bls12381G2Impl;
 use dashcore::hashes::Hash;
 use dashcore::key::Secp256k1;
 use dashcore::secp256k1::SecretKey;
-use dashcore::{ed25519_dalek, Network, PublicKey as ECDSAPublicKey};
+use dashcore::{Network, PublicKey as ECDSAPublicKey};
 use platform_value::Bytes20;
+#[cfg(feature = "bls-signatures")]
+use {
+    crate::bls_signatures,
+    dashcore::{blsful::Bls12381G2Impl, ed25519_dalek},
+};
 
 impl IdentityPublicKeyHashMethodsV0 for IdentityPublicKeyV0 {
     /// Get the original public key hash
@@ -80,7 +82,7 @@ impl IdentityPublicKeyHashMethodsV0 for IdentityPublicKeyV0 {
                     }
                     let private_key = private_key.expect("expected private key");
 
-                    Ok(&private_key.public_key().0.to_compressed() == self.data.as_slice())
+                    Ok(private_key.public_key().0.to_compressed() == self.data.as_slice())
                 }
                 #[cfg(not(feature = "bls-signatures"))]
                 return Err(ProtocolError::NotSupported(
@@ -104,7 +106,7 @@ impl IdentityPublicKeyHashMethodsV0 for IdentityPublicKeyV0 {
             KeyType::EDDSA_25519_HASH160 => {
                 #[cfg(feature = "ed25519-dalek")]
                 {
-                    let key_pair = ed25519_dalek::SigningKey::from_bytes(&private_key_bytes);
+                    let key_pair = ed25519_dalek::SigningKey::from_bytes(private_key_bytes);
                     Ok(
                         ripemd160_sha256(key_pair.verifying_key().to_bytes().as_slice()).as_slice()
                             == self.data.as_slice(),
@@ -115,11 +117,9 @@ impl IdentityPublicKeyHashMethodsV0 for IdentityPublicKeyV0 {
                     "Converting a private key to a eddsa hash 160 is not supported without the ed25519-dalek feature".to_string(),
                 ));
             }
-            KeyType::BIP13_SCRIPT_HASH => {
-                return Err(ProtocolError::NotSupported(
-                    "Converting a private key to a script hash is not supported".to_string(),
-                ));
-            }
+            KeyType::BIP13_SCRIPT_HASH => Err(ProtocolError::NotSupported(
+                "Converting a private key to a script hash is not supported".to_string(),
+            )),
         }
     }
 }
@@ -140,10 +140,9 @@ mod tests {
         let (public_key_data, secret_key) = KeyType::BLS12_381
             .random_public_and_private_key_data(&mut rng, PlatformVersion::latest())
             .expect("expected to get keys");
-        let decoded_secret_key = dashcore::blsful::SecretKey::<Bls12381G2Impl>::from_be_bytes(
-            &secret_key.try_into().unwrap(),
-        )
-        .expect("expected to get secret key");
+        let decoded_secret_key =
+            dashcore::blsful::SecretKey::<Bls12381G2Impl>::from_be_bytes(&secret_key)
+                .expect("expected to get secret key");
         let public_key = decoded_secret_key.public_key();
         let decoded_public_key_data = public_key.0.to_compressed();
         assert_eq!(
@@ -158,10 +157,9 @@ mod tests {
         let (_, secret_key) = KeyType::BLS12_381
             .random_public_and_private_key_data(&mut rng, PlatformVersion::latest())
             .expect("expected to get keys");
-        let decoded_secret_key = dashcore::blsful::SecretKey::<Bls12381G2Impl>::from_be_bytes(
-            &secret_key.try_into().unwrap(),
-        )
-        .expect("expected to get secret key");
+        let decoded_secret_key =
+            dashcore::blsful::SecretKey::<Bls12381G2Impl>::from_be_bytes(&secret_key)
+                .expect("expected to get secret key");
         let signature = decoded_secret_key
             .sign(SignatureSchemes::Basic, b"hello")
             .expect("expected to sign");
@@ -184,7 +182,7 @@ mod tests {
         // Test for ECDSA_SECP256K1
         let key_type = KeyType::ECDSA_SECP256K1;
         let (public_key_data, private_key_data) = key_type
-            .random_public_and_private_key_data(&mut rng, &platform_version)
+            .random_public_and_private_key_data(&mut rng, platform_version)
             .expect("expected to generate random keys");
 
         let identity_public_key = IdentityPublicKeyV0 {
@@ -199,21 +197,15 @@ mod tests {
         };
 
         // Validate that the private key matches the public key
-        assert_eq!(
-            identity_public_key
-                .validate_private_key_bytes(&private_key_data, Network::Testnet)
-                .unwrap(),
-            true
-        );
+        assert!(identity_public_key
+            .validate_private_key_bytes(&private_key_data, Network::Testnet)
+            .unwrap(),);
 
         // Test with an invalid private key
         let invalid_private_key_bytes = [0u8; 32];
-        assert_eq!(
-            identity_public_key
-                .validate_private_key_bytes(&invalid_private_key_bytes, Network::Testnet)
-                .unwrap(),
-            false
-        );
+        assert!(!identity_public_key
+            .validate_private_key_bytes(&invalid_private_key_bytes, Network::Testnet)
+            .unwrap());
     }
 
     #[cfg(all(feature = "random-public-keys", feature = "bls-signatures"))]
@@ -225,7 +217,7 @@ mod tests {
         // Test for BLS12_381
         let key_type = KeyType::BLS12_381;
         let (public_key_data, private_key_data) = key_type
-            .random_public_and_private_key_data(&mut rng, &platform_version)
+            .random_public_and_private_key_data(&mut rng, platform_version)
             .expect("expected to generate random keys");
 
         let identity_public_key = IdentityPublicKeyV0 {
@@ -240,21 +232,15 @@ mod tests {
         };
 
         // Validate that the private key matches the public key
-        assert_eq!(
-            identity_public_key
-                .validate_private_key_bytes(&private_key_data, Network::Testnet)
-                .unwrap(),
-            true
-        );
+        assert!(identity_public_key
+            .validate_private_key_bytes(&private_key_data, Network::Testnet)
+            .unwrap());
 
         // Test with an invalid private key
         let invalid_private_key_bytes = [0u8; 32];
-        assert_eq!(
-            identity_public_key
-                .validate_private_key_bytes(&invalid_private_key_bytes, Network::Testnet)
-                .unwrap(),
-            false
-        );
+        assert!(!identity_public_key
+            .validate_private_key_bytes(&invalid_private_key_bytes, Network::Testnet)
+            .unwrap());
     }
 
     #[cfg(all(feature = "random-public-keys", feature = "ed25519-dalek"))]
@@ -266,7 +252,7 @@ mod tests {
         // Test for EDDSA_25519_HASH160
         let key_type = KeyType::EDDSA_25519_HASH160;
         let (public_key_data, private_key_data) = key_type
-            .random_public_and_private_key_data(&mut rng, &platform_version)
+            .random_public_and_private_key_data(&mut rng, platform_version)
             .expect("expected to generate random keys");
 
         let identity_public_key = IdentityPublicKeyV0 {
@@ -281,20 +267,14 @@ mod tests {
         };
 
         // Validate that the private key matches the public key
-        assert_eq!(
-            identity_public_key
-                .validate_private_key_bytes(&private_key_data, Network::Testnet)
-                .unwrap(),
-            true
-        );
+        assert!(identity_public_key
+            .validate_private_key_bytes(&private_key_data, Network::Testnet)
+            .unwrap());
 
         // Test with an invalid private key
         let invalid_private_key_bytes = [0u8; 32];
-        assert_eq!(
-            identity_public_key
-                .validate_private_key_bytes(&invalid_private_key_bytes, Network::Testnet)
-                .unwrap(),
-            false
-        );
+        assert!(!identity_public_key
+            .validate_private_key_bytes(&invalid_private_key_bytes, Network::Testnet)
+            .unwrap());
     }
 }
diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/methods/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/methods/v0/mod.rs
@@ -5,7 +5,6 @@ use crate::{
     state_transition::StateTransition,
     ProtocolError,
 };
-use platform_value::Identifier;
 #[cfg(feature = "state-transition-signing")]
 use platform_version::version::{FeatureVersion, PlatformVersion};
 
@@ -15,7 +14,7 @@ pub trait IdentityCreditTransferTransitionMethodsV0 {
     #[cfg(feature = "state-transition-signing")]
     fn try_from_identity<S: Signer>(
         identity: &Identity,
-        to_identity_with_identifier: Identifier,
+        to_identity_with_identifier: platform_value::Identifier,
         amount: u64,
         user_fee_increase: UserFeeIncrease,
         signer: S,
