pshenmic-dpp 1.0.4 → 1.0.5

package/packages/enums/src/platform/mod.rs

@@ -7,19 +7,77 @@ use dpp::version::v5::PLATFORM_V5;
 use dpp::version::v6::PLATFORM_V6;
 use dpp::version::v7::PLATFORM_V7;
 use dpp::version::v8::PLATFORM_V8;
+use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen(js_name = "PlatformVersionWASM")]
 #[allow(non_camel_case_types)]
 pub enum PlatformVersionWASM {
-    PLATFORM_V1,
-    PLATFORM_V2,
-    PLATFORM_V3,
-    PLATFORM_V4,
-    PLATFORM_V5,
-    PLATFORM_V6,
-    PLATFORM_V7,
-    PLATFORM_V8,
+    PLATFORM_V1 = 0,
+    PLATFORM_V2 = 1,
+    PLATFORM_V3 = 2,
+    PLATFORM_V4 = 3,
+    PLATFORM_V5 = 4,
+    PLATFORM_V6 = 5,
+    PLATFORM_V7 = 6,
+    PLATFORM_V8 = 7,
+}
+
+impl TryFrom<JsValue> for PlatformVersionWASM {
+    type Error = JsValue;
+    fn try_from(value: JsValue) -> Result<PlatformVersionWASM, Self::Error> {
+        match value.is_string() {
+            true => match value.as_string() {
+                None => Err(JsValue::from("cannot read value from enum")),
+                Some(enum_val) => match enum_val.to_lowercase().as_str() {
+                    "platform_v1" => Ok(PlatformVersionWASM::PLATFORM_V1),
+                    "platform_v2" => Ok(PlatformVersionWASM::PLATFORM_V2),
+                    "platform_v3" => Ok(PlatformVersionWASM::PLATFORM_V3),
+                    "platform_v4" => Ok(PlatformVersionWASM::PLATFORM_V4),
+                    "platform_v5" => Ok(PlatformVersionWASM::PLATFORM_V5),
+                    "platform_v6" => Ok(PlatformVersionWASM::PLATFORM_V6),
+                    "platform_v7" => Ok(PlatformVersionWASM::PLATFORM_V7),
+                    "platform_v8" => Ok(PlatformVersionWASM::PLATFORM_V8),
+                    _ => Err(JsValue::from(format!(
+                        "unknown platform version value: {}",
+                        enum_val
+                    ))),
+                },
+            },
+            false => match value.as_f64() {
+                None => Err(JsValue::from("cannot read value from enum")),
+                Some(enum_val) => match enum_val as u8 {
+                    0 => Ok(PlatformVersionWASM::PLATFORM_V1),
+                    1 => Ok(PlatformVersionWASM::PLATFORM_V2),
+                    2 => Ok(PlatformVersionWASM::PLATFORM_V3),
+                    3 => Ok(PlatformVersionWASM::PLATFORM_V4),
+                    4 => Ok(PlatformVersionWASM::PLATFORM_V5),
+                    5 => Ok(PlatformVersionWASM::PLATFORM_V6),
+                    6 => Ok(PlatformVersionWASM::PLATFORM_V7),
+                    7 => Ok(PlatformVersionWASM::PLATFORM_V8),
+                    _ => Err(JsValue::from(format!(
+                        "unknown platform version value: {}",
+                        enum_val
+                    ))),
+                },
+            },
+        }
+    }
+}
+
+impl From<PlatformVersionWASM> for String {
+    fn from(version: PlatformVersionWASM) -> String {
+        match version {
+            PlatformVersionWASM::PLATFORM_V1 => String::from("PLATFORM_V1"),
+            PlatformVersionWASM::PLATFORM_V2 => String::from("PLATFORM_V2"),
+            PlatformVersionWASM::PLATFORM_V3 => String::from("PLATFORM_V3"),
+            PlatformVersionWASM::PLATFORM_V4 => String::from("PLATFORM_V4"),
+            PlatformVersionWASM::PLATFORM_V5 => String::from("PLATFORM_V5"),
+            PlatformVersionWASM::PLATFORM_V6 => String::from("PLATFORM_V6"),
+            PlatformVersionWASM::PLATFORM_V7 => String::from("PLATFORM_V7"),
+            PlatformVersionWASM::PLATFORM_V8 => String::from("PLATFORM_V8"),
+        }
+    }
 }
 
 impl From<PlatformVersionWASM> for PlatformVersion {

package/packages/identity/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_identity"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
@@ -11,6 +11,5 @@ wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "identity-serialization"
 ]}
-serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
-pshenmic_dpp_public_key = { path = "../public_key" }
-pshenmic_dpp_utils = { path = "../utils" }
+pshenmic_dpp_public_key = { path = "../identity_public_key" }
+pshenmic_dpp_utils = { path = "../utils" }

package/packages/identity/src/lib.rs

@@ -2,10 +2,12 @@ use dpp::identifier::Identifier;
 use dpp::identity::accessors::{IdentityGettersV0, IdentitySettersV0};
 use dpp::identity::{Identity, KeyID};
 use dpp::platform_value::string_encoding::Encoding::Base58;
+use dpp::prelude::IdentityPublicKey;
 use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
 use dpp::version::PlatformVersion;
 use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
-use pshenmic_dpp_utils::WithJsError;
+use pshenmic_dpp_utils::{WithJsError, identifier_from_js_value};
+use std::collections::BTreeMap;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -29,10 +31,10 @@ impl IdentityWASM {
     }
 
     #[wasm_bindgen(js_name = "setId")]
-    pub fn set_id(&mut self, js_identifier: String) {
-        let identifier = Identifier::from_string(&*js_identifier, Base58).unwrap();
+    pub fn set_id(&mut self, js_identifier: JsValue) -> Result<(), JsValue> {
+        let identifier = identifier_from_js_value(&js_identifier)?;
 
-        self.0.set_id(identifier);
+        Ok(self.0.set_id(identifier))
     }
 
     #[wasm_bindgen(js_name = "setBalance")]
@@ -46,17 +48,15 @@ impl IdentityWASM {
     }
 
     #[wasm_bindgen(js_name = "addPublicKey")]
-    pub fn set_public_key(&mut self, public_key: IdentityPublicKeyWASM) {
-        self.0.add_public_key(public_key.into());
+    pub fn add_public_key(&mut self, public_key: &IdentityPublicKeyWASM) {
+        self.0.add_public_key(public_key.clone().into());
     }
 
     // GETTERS
 
     #[wasm_bindgen(js_name = "getId")]
-    pub fn get_id(&self) -> String {
-        let id = self.0.id();
-
-        id.to_string(Base58)
+    pub fn get_id(&self) -> Vec<u8> {
+        self.0.id().to_vec()
     }
 
     #[wasm_bindgen(js_name = "getBalance")]
@@ -76,10 +76,15 @@ impl IdentityWASM {
     }
 
     #[wasm_bindgen(js_name = "getPublicKeys")]
-    pub fn get_public_keys(&self) -> JsValue {
-        let keys = self.0.public_keys();
-
-        serde_wasm_bindgen::to_value(keys).unwrap()
+    pub fn get_public_keys(&self) -> Vec<IdentityPublicKeyWASM> {
+        let keys = self
+            .0
+            .public_keys()
+            .iter()
+            .map(|(_index, key)| IdentityPublicKeyWASM::from(key.clone()))
+            .collect();
+
+        keys
     }
 
     #[wasm_bindgen(js_name = "toBytes")]
@@ -95,3 +100,9 @@ impl IdentityWASM {
         }
     }
 }
+
+impl IdentityWASM {
+    pub fn get_rs_public_keys(&self) -> BTreeMap<KeyID, IdentityPublicKey> {
+        self.0.public_keys().clone()
+    }
+}

package/packages/{public_key → identity_public_key}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_public_key"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]

package/packages/{public_key → identity_public_key}/src/lib.rs

@@ -1,3 +1,6 @@
+use dpp::dashcore::Network;
+use dpp::dashcore::secp256k1::hashes::hex::{Case, DisplayHex};
+use dpp::identity::hash::IdentityPublicKeyHashMethodsV0;
 use dpp::identity::identity_public_key::accessors::v0::{
     IdentityPublicKeyGettersV0, IdentityPublicKeySettersV0,
 };
@@ -9,6 +12,7 @@ use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
 use pshenmic_dpp_enums::keys::key_type::KeyTypeWASM;
 use pshenmic_dpp_enums::keys::purpose::PurposeWASM;
 use pshenmic_dpp_enums::keys::security_level::SecurityLevelWASM;
+use pshenmic_dpp_enums::network::NetworkWASM;
 use pshenmic_dpp_utils::WithJsError;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
@@ -34,46 +38,69 @@ impl IdentityPublicKeyWASM {
     #[wasm_bindgen(constructor)]
     pub fn new(
         id: u32,
-        purpose: PurposeWASM,
-        security_level: SecurityLevelWASM,
-        key_type: KeyTypeWASM,
+        js_purpose: JsValue,
+        js_security_level: JsValue,
+        js_key_type: JsValue,
         read_only: bool,
         binary_data: &str,
         disabled_at: Option<TimestampMillis>,
-    ) -> Self {
-        IdentityPublicKeyWASM(IdentityPublicKey::from(IdentityPublicKeyV0 {
-            id,
-            purpose: Purpose::from(purpose),
-            security_level: SecurityLevel::from(security_level),
-            contract_bounds: None,
-            key_type: KeyType::from(key_type),
-            read_only: read_only,
-            data: BinaryData::from_string(binary_data, Hex).unwrap(),
-            disabled_at,
-        }))
+    ) -> Result<Self, JsValue> {
+        let purpose = PurposeWASM::try_from(js_purpose)?;
+        let security_level = SecurityLevelWASM::try_from(js_security_level)?;
+        let key_type = KeyTypeWASM::try_from(js_key_type)?;
+
+        Ok(IdentityPublicKeyWASM(IdentityPublicKey::from(
+            IdentityPublicKeyV0 {
+                id,
+                purpose: Purpose::from(purpose),
+                security_level: SecurityLevel::from(security_level),
+                contract_bounds: None,
+                key_type: KeyType::from(key_type),
+                read_only,
+                data: BinaryData::from_string(binary_data, Hex).unwrap(),
+                disabled_at,
+            },
+        )))
     }
 }
 
 #[wasm_bindgen]
 impl IdentityPublicKeyWASM {
+    #[wasm_bindgen(js_name = "validatePrivateKey")]
+    pub fn validate_private_key(
+        &self,
+        js_private_key_bytes: Vec<u8>,
+        js_network: JsValue,
+    ) -> Result<bool, JsValue> {
+        let mut private_key_bytes = [0u8; 32];
+        let len = js_private_key_bytes.len().min(32);
+        private_key_bytes[..len].copy_from_slice(&js_private_key_bytes[..len]);
+
+        let network = Network::from(NetworkWASM::try_from(js_network)?);
+
+        self.0
+            .validate_private_key_bytes(&private_key_bytes, network)
+            .with_js_error()
+    }
+
     #[wasm_bindgen(js_name = getKeyId)]
     pub fn get_key_id(&self) -> u32 {
         self.0.id()
     }
 
     #[wasm_bindgen(js_name = getPurpose)]
-    pub fn get_purpose(&self) -> PurposeWASM {
-        PurposeWASM::from(self.0.purpose())
+    pub fn get_purpose(&self) -> String {
+        PurposeWASM::from(self.0.purpose()).into()
     }
 
     #[wasm_bindgen(js_name = getSecurityLevel)]
-    pub fn get_security_level(&self) -> SecurityLevelWASM {
-        SecurityLevelWASM::from(self.0.security_level())
+    pub fn get_security_level(&self) -> String {
+        SecurityLevelWASM::from(self.0.security_level()).into()
     }
 
     #[wasm_bindgen(js_name = getKeyType)]
-    pub fn get_key_type(&self) -> KeyTypeWASM {
-        KeyTypeWASM::from(self.0.key_type())
+    pub fn get_key_type(&self) -> String {
+        KeyTypeWASM::from(self.0.key_type()).into()
     }
 
     #[wasm_bindgen(js_name = getReadOnly)]
@@ -97,19 +124,26 @@ impl IdentityPublicKeyWASM {
     }
 
     #[wasm_bindgen(js_name = setPurpose)]
-    pub fn set_purpose(&mut self, purpose: PurposeWASM) {
-        self.0.set_purpose(Purpose::from(purpose))
+    pub fn set_purpose(&mut self, purpose: JsValue) -> Result<(), JsValue> {
+        Ok(self
+            .0
+            .set_purpose(Purpose::from(PurposeWASM::try_from(purpose)?)))
     }
 
     #[wasm_bindgen(js_name = setSecurityLevel)]
-    pub fn set_security_level(&mut self, security_level: SecurityLevelWASM) {
-        self.0
-            .set_security_level(SecurityLevel::from(security_level))
+    pub fn set_security_level(&mut self, security_level: JsValue) -> Result<(), JsValue> {
+        Ok(self
+            .0
+            .set_security_level(SecurityLevel::from(SecurityLevelWASM::try_from(
+                security_level,
+            )?)))
     }
 
     #[wasm_bindgen(js_name = setKeyType)]
-    pub fn set_key_type(&mut self, key_type: KeyTypeWASM) {
-        self.0.set_key_type(KeyType::from(key_type))
+    pub fn set_key_type(&mut self, key_type: JsValue) -> Result<(), JsValue> {
+        Ok(self
+            .0
+            .set_key_type(KeyType::from(KeyTypeWASM::try_from(key_type)?)))
     }
 
     #[wasm_bindgen(js_name = setReadOnly)]
@@ -120,6 +154,7 @@ impl IdentityPublicKeyWASM {
     #[wasm_bindgen(js_name = setData)]
     pub fn set_data(&mut self, binary_data: &str) {
         let data = BinaryData::from_string(binary_data, Hex).unwrap();
+
         self.0.set_data(data)
     }
 
@@ -128,6 +163,18 @@ impl IdentityPublicKeyWASM {
         self.0.set_disabled_at(disabled_at)
     }
 
+    #[wasm_bindgen(js_name = "getPublicKeyHash")]
+    pub fn public_key_hash(&self) -> Result<String, JsValue> {
+        let hash = self
+            .0
+            .public_key_hash()
+            .with_js_error()
+            .map(|slice| slice.to_vec())?
+            .to_hex_string(Case::Lower);
+
+        Ok(hash)
+    }
+
     #[wasm_bindgen(js_name = toBytes)]
     pub fn to_byes(&self) -> Result<Vec<u8>, JsValue> {
         self.0.serialize_to_bytes().with_js_error()

package/packages/identity_transitions/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_identity_transitions"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
@@ -12,6 +12,6 @@ dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-
     "state-transition-signing"
 ]}
 pshenmic_dpp_utils = {path = "../utils"}
-pshenmic_dpp_public_key = {path = "../public_key"}
+pshenmic_dpp_public_key = {path = "../identity_public_key" }
 pshenmic_dpp_state_transition = {path = "../state_transition"}
 pshenmic_dpp_enums = {path = "../enums"}

package/packages/identity_transitions/src/create_transition/mod.rs

@@ -82,7 +82,9 @@ impl IdentityCreateTransitionWASM {
 
         match rs_st {
             StateTransition::IdentityCreate(st) => Ok(IdentityCreateTransitionWASM(st)),
-            _ => Err(JsValue::from_str(&"Invalid state transition type)")),
+            _ => Err(JsValue::from_str(
+                &"Invalid state document_transition type)",
+            )),
         }
     }
 

package/packages/identity_transitions/src/create_transition/public_key_in_creation/mod.rs

@@ -11,6 +11,7 @@ use pshenmic_dpp_enums::keys::key_type::KeyTypeWASM;
 use pshenmic_dpp_enums::keys::purpose::PurposeWASM;
 use pshenmic_dpp_enums::keys::security_level::SecurityLevelWASM;
 use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
+use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen(js_name = "IdentityPublicKeyInCreationWASM")]
@@ -57,8 +58,8 @@ impl IdentityPublicKeyInCreationWASM {
         security_level: SecurityLevelWASM,
         key_type: KeyTypeWASM,
         read_only: bool,
-        binary_data: &str,
-        signature: &str,
+        binary_data: Vec<u8>,
+        signature: Vec<u8>,
     ) -> IdentityPublicKeyInCreationWASM {
         IdentityPublicKeyInCreationWASM(IdentityPublicKeyInCreation::V0(
             IdentityPublicKeyInCreationV0 {
@@ -68,19 +69,19 @@ impl IdentityPublicKeyInCreationWASM {
                 security_level: SecurityLevel::from(security_level),
                 contract_bounds: None,
                 read_only,
-                data: BinaryData::from_string(binary_data, Hex).unwrap(),
-                signature: BinaryData::from_string(signature, Hex).unwrap(),
+                data: BinaryData::from(binary_data),
+                signature: BinaryData::from(signature),
             },
         ))
     }
 
     #[wasm_bindgen(js_name = toIdentityPublicKey)]
-    pub fn to_identity_public_key(&self) -> IdentityPublicKeyWASM {
+    pub fn to_identity_public_key(&self) -> Result<IdentityPublicKeyWASM, JsValue> {
         IdentityPublicKeyWASM::new(
             self.0.id(),
-            self.0.purpose().into(),
-            self.0.security_level().into(),
-            self.0.key_type().into(),
+            JsValue::from(PurposeWASM::from(self.0.purpose())),
+            JsValue::from(SecurityLevelWASM::from(self.0.security_level())),
+            JsValue::from(KeyTypeWASM::from(self.0.key_type())),
             self.0.read_only(),
             self.0.data().to_string(Hex).as_str(),
             None,
@@ -93,18 +94,18 @@ impl IdentityPublicKeyInCreationWASM {
     }
 
     #[wasm_bindgen(js_name = getPurpose)]
-    pub fn get_purpose(&self) -> PurposeWASM {
-        PurposeWASM::from(self.0.purpose())
+    pub fn get_purpose(&self) -> String {
+        PurposeWASM::from(self.0.purpose()).into()
     }
 
     #[wasm_bindgen(js_name = getSecurityLevel)]
-    pub fn get_security_level(&self) -> SecurityLevelWASM {
-        SecurityLevelWASM::from(self.0.security_level())
+    pub fn get_security_level(&self) -> String {
+        SecurityLevelWASM::from(self.0.security_level()).into()
     }
 
     #[wasm_bindgen(js_name = getKeyType)]
-    pub fn get_key_type(&self) -> KeyTypeWASM {
-        KeyTypeWASM::from(self.0.key_type())
+    pub fn get_key_type(&self) -> String {
+        KeyTypeWASM::from(self.0.key_type()).into()
     }
 
     #[wasm_bindgen(js_name = getReadOnly)]
@@ -123,14 +124,17 @@ impl IdentityPublicKeyInCreationWASM {
     }
 
     #[wasm_bindgen(js_name = setPurpose)]
-    pub fn set_purpose(&mut self, purpose: PurposeWASM) {
-        self.0.set_purpose(Purpose::from(purpose))
+    pub fn set_purpose(&mut self, js_purpose: JsValue) -> Result<(), JsValue> {
+        let purpose = PurposeWASM::try_from(js_purpose)?;
+        Ok(self.0.set_purpose(Purpose::from(purpose)))
     }
 
     #[wasm_bindgen(js_name = setSecurityLevel)]
-    pub fn set_security_level(&mut self, security_level: SecurityLevelWASM) {
-        self.0
-            .set_security_level(SecurityLevel::from(security_level))
+    pub fn set_security_level(&mut self, js_security_level: JsValue) -> Result<(), JsValue> {
+        let security_level = SecurityLevelWASM::try_from(js_security_level)?;
+        Ok(self
+            .0
+            .set_security_level(SecurityLevel::from(security_level)))
     }
 
     #[wasm_bindgen(js_name = setReadOnly)]
@@ -139,8 +143,8 @@ impl IdentityPublicKeyInCreationWASM {
     }
 
     #[wasm_bindgen(js_name = setData)]
-    pub fn set_data(&mut self, binary_data: &str) {
-        let data = BinaryData::from_string(binary_data, Hex).unwrap();
+    pub fn set_data(&mut self, binary_data: Vec<u8>) {
+        let data = BinaryData::from(binary_data);
         self.0.set_data(data)
     }
 }

package/packages/mock_bls/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_mock_bls"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]

package/packages/private_key/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_private_key"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
@@ -10,4 +10,5 @@ crate-type = ["cdylib", "lib"]
 wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "identity-value-conversion",
-]}
+]}
+pshenmic_dpp_enums = {path = "../enums"}

package/packages/private_key/src/lib.rs

@@ -1,4 +1,8 @@
 use dpp::dashcore::PrivateKey;
+use dpp::dashcore::hashes::hex::FromHex;
+use dpp::dashcore::key::Secp256k1;
+use dpp::dashcore::secp256k1::hashes::hex::{Case, DisplayHex};
+use pshenmic_dpp_enums::network::NetworkWASM;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -7,8 +11,8 @@ pub struct PrivateKeyWASM(PrivateKey);
 
 #[wasm_bindgen]
 impl PrivateKeyWASM {
-    #[wasm_bindgen(constructor)]
-    pub fn new(wif: &str) -> Result<Self, JsValue> {
+    #[wasm_bindgen(js_name = "fromWIF")]
+    pub fn from_wif(wif: &str) -> Result<Self, JsValue> {
         let pk = PrivateKey::from_wif(wif).map_err(|err| JsValue::from_str(&*err.to_string()));
 
         match pk {
@@ -16,17 +20,51 @@ impl PrivateKeyWASM {
             Err(err) => Err(err),
         }
     }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>, js_network: JsValue) -> Result<Self, JsValue> {
+        let network = NetworkWASM::try_from(js_network)?;
+
+        let pk = PrivateKey::from_slice(bytes.as_slice(), network.into())
+            .map_err(|err| JsValue::from_str(&*err.to_string()))?;
+
+        Ok(PrivateKeyWASM(pk))
+    }
+
+    #[wasm_bindgen(js_name = "fromHex")]
+    pub fn from_hex(hex_key: &str, js_network: JsValue) -> Result<Self, JsValue> {
+        let network = NetworkWASM::try_from(js_network)?;
+
+        let bytes = Vec::from_hex(hex_key).map_err(|err| JsValue::from(err.to_string()))?;
+
+        let pk = PrivateKey::from_slice(bytes.as_slice(), network.into())
+            .map_err(|err| JsValue::from_str(&*err.to_string()))?;
+
+        Ok(PrivateKeyWASM(pk))
+    }
 }
 
 #[wasm_bindgen]
 impl PrivateKeyWASM {
-    #[wasm_bindgen(js_name = "getKeyWIF")]
-    pub fn get_key_wif(&self) -> String {
+    #[wasm_bindgen(js_name = "getWIF")]
+    pub fn get_wif(&self) -> String {
         self.0.to_wif()
     }
 
-    #[wasm_bindgen(js_name = "getKeyBytes")]
-    pub fn get_key_bytes(&self) -> Vec<u8> {
+    #[wasm_bindgen(js_name = "getBytes")]
+    pub fn get_bytes(&self) -> Vec<u8> {
         self.0.to_bytes()
     }
+
+    #[wasm_bindgen(js_name = "getHex")]
+    pub fn get_hex(&self) -> String {
+        self.0.to_bytes().to_hex_string(Case::Upper)
+    }
+
+    #[wasm_bindgen(js_name = "getPublicKeyHash")]
+    pub fn get_public_key_hash(&self) -> String {
+        let secp = Secp256k1::new();
+
+        self.0.public_key(&secp).pubkey_hash().to_hex()
+    }
 }

package/packages/state_transition/Cargo.toml

@@ -1,18 +1,19 @@
 [package]
 name = "pshenmic_dpp_state_transition"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
-pshenmic_dpp_public_key = {path = "../public_key"}
+wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"], default-features = false }
+pshenmic_dpp_public_key = {path = "../identity_public_key" }
 pshenmic_dpp_private_key = {path = "../private_key"}
 pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_mock_bls = {path = "../mock_bls"}
 pshenmic_dpp_enums = {path = "../enums"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "state-transition-signing"
-]}
+]}
+sha2 = "0.10.8"