pshenmic-dpp 1.0.3 → 1.0.5

package/packages/enums/src/keys/security_level.rs

@@ -1,4 +1,5 @@
 use dpp::identity::SecurityLevel;
+use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen(js_name = SecurityLevel)]
@@ -9,6 +10,51 @@ pub enum SecurityLevelWASM {
     MEDIUM = 3,
 }
 
+impl TryFrom<JsValue> for SecurityLevelWASM {
+    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() {
+                    "master" => Ok(SecurityLevelWASM::MASTER),
+                    "critical" => Ok(SecurityLevelWASM::CRITICAL),
+                    "high" => Ok(SecurityLevelWASM::HIGH),
+                    "medium" => Ok(SecurityLevelWASM::MEDIUM),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported security level 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(SecurityLevelWASM::MASTER),
+                    1 => Ok(SecurityLevelWASM::CRITICAL),
+                    2 => Ok(SecurityLevelWASM::HIGH),
+                    3 => Ok(SecurityLevelWASM::MEDIUM),
+                    _ => Err(JsValue::from(format!(
+                        "unsupported security level value ({})",
+                        enum_val
+                    ))),
+                },
+            },
+        }
+    }
+}
+
+impl From<SecurityLevelWASM> for String {
+    fn from(level: SecurityLevelWASM) -> String {
+        match level {
+            SecurityLevelWASM::MASTER => String::from("MASTER"),
+            SecurityLevelWASM::CRITICAL => String::from("CRITICAL"),
+            SecurityLevelWASM::HIGH => String::from("HIGH"),
+            SecurityLevelWASM::MEDIUM => String::from("MEDIUM"),
+        }
+    }
+}
+
 impl From<SecurityLevelWASM> for SecurityLevel {
     fn from(security_level: SecurityLevelWASM) -> Self {
         match security_level {

package/packages/enums/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod batch;
 pub mod keys;
+pub mod network;
 pub mod platform;

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,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,10 +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_public_key = { path = "../identity_public_key" }
 pshenmic_dpp_utils = { path = "../utils" }
-
-[profile.release]
-lto = true
-opt-level = 'z'

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]
@@ -12,8 +12,4 @@ dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-
     "identity-value-conversion",
 ]}
 pshenmic_dpp_enums = {path = "../enums"}
-pshenmic_dpp_utils = {path = "../utils"}
-
-[profile.release]
-lto = true
-opt-level = 'z'
+pshenmic_dpp_utils = {path = "../utils"}

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,10 +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"}
-
-[profile.release]
-lto = true
-opt-level = 'z'
+pshenmic_dpp_enums = {path = "../enums"}

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

@@ -76,13 +76,15 @@ impl IdentityCreateTransitionWASM {
 
     #[wasm_bindgen(js_name = "fromStateTransition")]
     pub fn from_state_transition(
-        st: StateTransitionWASM,
+        st: &StateTransitionWASM,
     ) -> Result<IdentityCreateTransitionWASM, JsValue> {
-        let rs_st: StateTransition = st.into();
+        let rs_st: StateTransition = st.clone().into();
 
         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]
@@ -9,8 +9,4 @@ crate-type = ["cdylib", "lib"]
 [dependencies]
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "bls-signatures",
-]}
-
-[profile.release]
-lto = true
-opt-level = 'z'
+]}