feat: add a convenience method to get the public key data for a private key depending on the key type

Author: QuantumExplorer

packages/rs-dpp/src/identity/identity_public_key/key_type.rs

@@ -17,7 +17,7 @@ use lazy_static::lazy_static;
 
 use crate::fee::Credits;
 use crate::version::PlatformVersion;
-use crate::ProtocolError;
+use crate::{InvalidVectorSizeError, ProtocolError};
 #[cfg(feature = "random-public-keys")]
 use rand::rngs::StdRng;
 #[cfg(feature = "random-public-keys")]
@@ -204,6 +204,61 @@ impl KeyType {
         }
     }
 
+    /// Gets the public key data for a private key depending on the key type
+    pub fn public_key_data_from_private_key_data(
+        &self,
+        private_key_bytes: Vec<u8>,
+        network: Network,
+    ) -> Result<Vec<u8>, ProtocolError> {
+        match self {
+            KeyType::ECDSA_SECP256K1 => {
+                let secp = Secp256k1::new();
+                let secret_key =
+                    dashcore::secp256k1::SecretKey::from_slice(private_key_bytes.as_slice())
+                        .map_err(|e| ProtocolError::Generic(e.to_string()))?;
+                let private_key = dashcore::PrivateKey::new(secret_key, network);
+
+                Ok(private_key.public_key(&secp).to_bytes())
+            }
+            KeyType::BLS12_381 => {
+                let private_key =
+                    bls_signatures::PrivateKey::from_bytes(private_key_bytes.as_slice(), false)
+                        .map_err(|e| ProtocolError::Generic(e.to_string()))?;
+                let public_key_bytes = private_key
+                    .g1_element()
+                    .expect("expected to get a public key from a bls private key")
+                    .to_bytes()
+                    .to_vec();
+                Ok(public_key_bytes)
+            }
+            KeyType::ECDSA_HASH160 => {
+                let secp = Secp256k1::new();
+                let secret_key =
+                    dashcore::secp256k1::SecretKey::from_slice(private_key_bytes.as_slice())
+                        .map_err(|e| ProtocolError::Generic(e.to_string()))?;
+                let private_key = dashcore::PrivateKey::new(secret_key, network);
+
+                Ok(ripemd160_sha256(private_key.public_key(&secp).to_bytes().as_slice()).to_vec())
+            }
+            KeyType::EDDSA_25519_HASH160 => {
+                let key_pair = ed25519_dalek::SigningKey::from_bytes(
+                    &private_key_bytes.as_slice().try_into().map_err(|_| {
+                        ProtocolError::InvalidVectorSizeError(InvalidVectorSizeError::new(
+                            32,
+                            private_key_bytes.len(),
+                        ))
+                    })?,
+                );
+                Ok(ripemd160_sha256(key_pair.verifying_key().to_bytes().as_slice()).to_vec())
+            }
+            KeyType::BIP13_SCRIPT_HASH => {
+                return Err(ProtocolError::NotSupported(
+                    "Converting a private key to a script hash is not supported".to_string(),
+                ));
+            }
+        }
+    }
+
     #[cfg(feature = "random-public-keys")]
     /// Gets the default size of the public key
     pub fn random_public_and_private_key_data_v0(&self, rng: &mut StdRng) -> (Vec<u8>, Vec<u8>) {