pshenmic-dpp 1.0.4 → 1.0.6

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

@@ -0,0 +1,67 @@
+use dpp::dashcore::network::constants::Network;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+#[wasm_bindgen(js_name = "NetworkWASM")]
+#[allow(non_camel_case_types)]
+pub enum NetworkWASM {
+    Mainnet = 0,
+    Testnet = 1,
+    Devnet = 2,
+    Regtest = 3,
+}
+
+impl TryFrom<JsValue> for NetworkWASM {
+    type Error = JsValue;
+    fn try_from(value: JsValue) -> Result<Self, 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() {
+                    "mainnet" => Ok(NetworkWASM::Mainnet),
+                    "testnet" => Ok(NetworkWASM::Testnet),
+                    "devnet" => Ok(NetworkWASM::Devnet),
+                    "regtest" => Ok(NetworkWASM::Regtest),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported network name ({})",
+                        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(NetworkWASM::Mainnet),
+                    1 => Ok(NetworkWASM::Testnet),
+                    2 => Ok(NetworkWASM::Devnet),
+                    3 => Ok(NetworkWASM::Regtest),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported network name ({})",
+                        enum_val
+                    ))),
+                },
+            },
+        }
+    }
+}
+
+impl From<NetworkWASM> for String {
+    fn from(value: NetworkWASM) -> Self {
+        match value {
+            NetworkWASM::Mainnet => "Mainnet".to_string(),
+            NetworkWASM::Testnet => "Testnet".to_string(),
+            NetworkWASM::Devnet => "Devnet".to_string(),
+            NetworkWASM::Regtest => "Regtest".to_string(),
+        }
+    }
+}
+
+impl From<NetworkWASM> for Network {
+    fn from(network: NetworkWASM) -> Self {
+        match network {
+            NetworkWASM::Mainnet => Network::Dash,
+            NetworkWASM::Testnet => Network::Testnet,
+            NetworkWASM::Devnet => Network::Devnet,
+            NetworkWASM::Regtest => Network::Regtest,
+        }
+    }
+}

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

@@ -7,19 +7,79 @@ 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")]
+#[derive(Default)]
 #[allow(non_camel_case_types)]
 pub enum PlatformVersionWASM {
-    PLATFORM_V1,
-    PLATFORM_V2,
-    PLATFORM_V3,
-    PLATFORM_V4,
-    PLATFORM_V5,
-    PLATFORM_V6,
-    PLATFORM_V7,
-    PLATFORM_V8,
+    #[default]
+    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/enums/src/withdrawal/mod.rs

@@ -0,0 +1,72 @@
+use dpp::withdrawal::Pooling;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen]
+pub enum PoolingWASM {
+    Never = 0,
+    IfAvailable = 1,
+    Standard = 2,
+}
+
+impl From<PoolingWASM> for Pooling {
+    fn from(pooling: PoolingWASM) -> Self {
+        match pooling {
+            PoolingWASM::Never => Pooling::Never,
+            PoolingWASM::IfAvailable => Pooling::IfAvailable,
+            PoolingWASM::Standard => Pooling::Standard,
+        }
+    }
+}
+
+impl From<Pooling> for PoolingWASM {
+    fn from(pooling: Pooling) -> Self {
+        match pooling {
+            Pooling::Never => PoolingWASM::Never,
+            Pooling::IfAvailable => PoolingWASM::IfAvailable,
+            Pooling::Standard => PoolingWASM::Standard,
+        }
+    }
+}
+
+impl TryFrom<JsValue> for PoolingWASM {
+    type Error = JsValue;
+    fn try_from(value: JsValue) -> Result<Self, 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() {
+                    "never" => Ok(PoolingWASM::Never),
+                    "ifavailable" => Ok(PoolingWASM::IfAvailable),
+                    "standard" => Ok(PoolingWASM::Standard),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported pooling 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(PoolingWASM::Never),
+                    1 => Ok(PoolingWASM::IfAvailable),
+                    2 => Ok(PoolingWASM::Standard),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported pooling value ({})",
+                        enum_val
+                    ))),
+                },
+            },
+        }
+    }
+}
+
+impl From<PoolingWASM> for String {
+    fn from(pooling_wasm: PoolingWASM) -> String {
+        match pooling_wasm {
+            PoolingWASM::Never => String::from("Never"),
+            PoolingWASM::IfAvailable => String::from("IfAvailable"),
+            PoolingWASM::Standard => String::from("Standard"),
+        }
+    }
+}

package/packages/identifier/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "pshenmic_dpp_identifier"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = []}
+pshenmic_dpp_utils = { path = "../utils" }

package/packages/identifier/src/lib.rs

@@ -0,0 +1,105 @@
+use dpp::platform_value::string_encoding::Encoding::{Base58, Base64, Hex};
+use dpp::prelude::Identifier;
+use pshenmic_dpp_utils::{IntoWasm, get_class_name, identifier_from_js_value};
+use wasm_bindgen::prelude::*;
+
+#[derive(Copy, Clone)]
+#[wasm_bindgen(js_name = "IdentifierWASM")]
+pub struct IdentifierWASM(Identifier);
+
+impl From<IdentifierWASM> for Identifier {
+    fn from(identifier: IdentifierWASM) -> Self {
+        identifier.0
+    }
+}
+
+impl From<Identifier> for IdentifierWASM {
+    fn from(identifier: Identifier) -> Self {
+        IdentifierWASM(identifier)
+    }
+}
+
+impl From<&IdentifierWASM> for Identifier {
+    fn from(identifier: &IdentifierWASM) -> Self {
+        identifier.clone().into()
+    }
+}
+
+impl TryFrom<JsValue> for IdentifierWASM {
+    type Error = JsValue;
+    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        let identifier = match get_class_name(&value).as_str() {
+            "IdentifierWASM" => value.to_wasm::<IdentifierWASM>("IdentifierWASM")?.clone(),
+            _ => identifier_from_js_value(&value)?.into(),
+        };
+
+        Ok(identifier)
+    }
+}
+
+impl TryFrom<&JsValue> for IdentifierWASM {
+    type Error = JsValue;
+    fn try_from(value: &JsValue) -> Result<Self, Self::Error> {
+        IdentifierWASM::try_from(value.clone())
+    }
+}
+
+#[wasm_bindgen]
+impl IdentifierWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(js_identifier: &JsValue) -> Result<IdentifierWASM, JsValue> {
+        IdentifierWASM::try_from(js_identifier)
+    }
+
+    #[wasm_bindgen(js_name = "base58")]
+    pub fn get_base58(&self) -> String {
+        self.0.to_string(Base58)
+    }
+
+    #[wasm_bindgen(js_name = "base64")]
+    pub fn get_base64(&self) -> String {
+        self.0.to_string(Base64)
+    }
+
+    #[wasm_bindgen(js_name = "hex")]
+    pub fn get_hex(&self) -> String {
+        self.0.to_string(Hex)
+    }
+
+    #[wasm_bindgen(js_name = "bytes")]
+    pub fn get_bytes(&self) -> Vec<u8> {
+        self.0.to_vec()
+    }
+
+    #[wasm_bindgen(js_name = "fromBase58")]
+    pub fn from_base58(base58: String) -> Result<IdentifierWASM, JsValue> {
+        let identitfier = Identifier::from_string(base58.as_str(), Base58)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        Ok(IdentifierWASM(identitfier))
+    }
+
+    #[wasm_bindgen(js_name = "fromBase64")]
+    pub fn from_base64(base64: String) -> Result<IdentifierWASM, JsValue> {
+        let identitfier = Identifier::from_string(base64.as_str(), Base64)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        Ok(IdentifierWASM(identitfier))
+    }
+
+    #[wasm_bindgen(js_name = "fromHex")]
+    pub fn from_hex(hex: String) -> Result<IdentifierWASM, JsValue> {
+        let identitfier = Identifier::from_string(hex.as_str(), Hex)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+
+        Ok(IdentifierWASM(identitfier))
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentifierWASM, JsValue> {
+        let identifier =
+            Identifier::from_vec(bytes).map_err(|err| JsValue::from(err.to_string()))?;
+
+        Ok(IdentifierWASM(identifier))
+    }
+}

package/packages/identity/Cargo.toml

@@ -1,16 +1,16 @@
 [package]
 name = "pshenmic_dpp_identity"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+wasm-bindgen = { version = "=0.2.100", default-features = false, 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_identifier = { path = "../identifier" }
+pshenmic_dpp_utils = { path = "../utils" }

package/packages/identity/src/lib.rs

@@ -1,11 +1,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_identifier::IdentifierWASM;
 use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
 use pshenmic_dpp_utils::WithJsError;
+use std::collections::BTreeMap;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -15,24 +16,20 @@ pub struct IdentityWASM(Identity);
 #[wasm_bindgen]
 impl IdentityWASM {
     #[wasm_bindgen(constructor)]
-    pub fn new(js_identifier: String) -> Result<IdentityWASM, JsValue> {
-        let identifier = Identifier::from_string(&*js_identifier, Base58);
+    pub fn new(js_identifier: &JsValue) -> Result<IdentityWASM, JsValue> {
+        let identifier: IdentifierWASM = js_identifier.try_into()?;
 
-        let identity =
-            Identity::create_basic_identity(identifier.unwrap(), PlatformVersion::first())
-                .with_js_error();
+        let identity = Identity::create_basic_identity(identifier.into(), PlatformVersion::first())
+            .with_js_error()?;
 
-        match identity {
-            Ok(identity) => Ok(IdentityWASM(identity)),
-            Err(err) => Err(err),
-        }
+        Ok(IdentityWASM(identity))
     }
 
     #[wasm_bindgen(js_name = "setId")]
-    pub fn set_id(&mut self, js_identifier: String) {
-        let identifier = Identifier::from_string(&*js_identifier, Base58).unwrap();
-
-        self.0.set_id(identifier);
+    pub fn set_id(&mut self, js_identifier: &JsValue) -> Result<(), JsValue> {
+        Ok(self
+            .0
+            .set_id(IdentifierWASM::try_from(js_identifier)?.into()))
     }
 
     #[wasm_bindgen(js_name = "setBalance")]
@@ -46,17 +43,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) -> IdentifierWASM {
+        self.0.id().into()
     }
 
     #[wasm_bindgen(js_name = "getBalance")]
@@ -76,10 +71,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 +95,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,13 +1,13 @@
 [package]
 name = "pshenmic_dpp_public_key"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "identity-value-conversion",
 ]}

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,17 +1,21 @@
 [package]
 name = "pshenmic_dpp_identity_transitions"
-version = "0.1.0"
 edition = "2024"
+version.workspace = true
 
 [lib]
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "state-transition-signing"
 ]}
+js-sys = "0.3.53"
 pshenmic_dpp_utils = {path = "../utils"}
-pshenmic_dpp_public_key = {path = "../public_key"}
+pshenmic_dpp_core_script = {path = "../core_script"}
+pshenmic_dpp_public_key = {path = "../identity_public_key" }
+pshenmic_dpp_identifier = {path = "../identifier" }
 pshenmic_dpp_state_transition = {path = "../state_transition"}
-pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_asset_lock_proof = {path = "../asset_lock_proof"}