pshenmic-dpp 1.0.4 → 1.0.6

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

@@ -0,0 +1,197 @@
+use dpp::identity::identity_public_key::v0::IdentityPublicKeyV0;
+use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel};
+use dpp::platform_value::BinaryData;
+use dpp::platform_value::string_encoding::Encoding::Hex;
+use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
+use dpp::state_transition::public_key_in_creation::accessors::{
+    IdentityPublicKeyInCreationV0Getters, IdentityPublicKeyInCreationV0Setters,
+};
+use dpp::state_transition::public_key_in_creation::v0::IdentityPublicKeyInCreationV0;
+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 pshenmic_dpp_utils::IntoWasm;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[derive(Clone)]
+#[wasm_bindgen(js_name = "IdentityPublicKeyInCreationWASM")]
+pub struct IdentityPublicKeyInCreationWASM(IdentityPublicKeyInCreation);
+
+impl From<IdentityPublicKeyInCreation> for IdentityPublicKeyInCreationWASM {
+    fn from(value: IdentityPublicKeyInCreation) -> Self {
+        IdentityPublicKeyInCreationWASM(value)
+    }
+}
+
+impl From<IdentityPublicKeyInCreationWASM> for IdentityPublicKeyInCreation {
+    fn from(value: IdentityPublicKeyInCreationWASM) -> Self {
+        value.0
+    }
+}
+
+impl TryFrom<JsValue> for IdentityPublicKeyInCreationWASM {
+    type Error = JsValue;
+    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        let value =
+            value.to_wasm::<IdentityPublicKeyInCreationWASM>("IdentityPublicKeyInCreationWASM")?;
+
+        Ok(value.clone())
+    }
+}
+
+impl From<IdentityPublicKeyInCreationWASM> for IdentityPublicKey {
+    fn from(value: IdentityPublicKeyInCreationWASM) -> Self {
+        let contract_bounds = match value.0.contract_bounds() {
+            None => None,
+            Some(bounds) => Some(bounds.clone()),
+        };
+
+        IdentityPublicKey::V0(IdentityPublicKeyV0 {
+            id: value.0.id(),
+            purpose: value.0.purpose(),
+            security_level: value.0.security_level(),
+            contract_bounds,
+            key_type: value.0.key_type(),
+            read_only: value.0.read_only(),
+            data: value.0.data().clone(),
+            disabled_at: None,
+        })
+    }
+}
+
+#[wasm_bindgen]
+impl IdentityPublicKeyInCreationWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        id: u32,
+        js_purpose: JsValue,
+        js_security_level: JsValue,
+        js_key_type: JsValue,
+        read_only: bool,
+        binary_data: Vec<u8>,
+        signature: Vec<u8>,
+    ) -> Result<IdentityPublicKeyInCreationWASM, 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(IdentityPublicKeyInCreationWASM(
+            IdentityPublicKeyInCreation::V0(IdentityPublicKeyInCreationV0 {
+                id,
+                key_type: KeyType::from(key_type),
+                purpose: Purpose::from(purpose),
+                security_level: SecurityLevel::from(security_level),
+                contract_bounds: None,
+                read_only,
+                data: BinaryData::from(binary_data),
+                signature: BinaryData::from(signature),
+            }),
+        ))
+    }
+
+    #[wasm_bindgen(js_name = toIdentityPublicKey)]
+    pub fn to_identity_public_key(&self) -> Result<IdentityPublicKeyWASM, JsValue> {
+        IdentityPublicKeyWASM::new(
+            self.0.id(),
+            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,
+        )
+    }
+
+    #[wasm_bindgen(getter = keyId)]
+    pub fn get_key_id(&self) -> u32 {
+        self.0.id()
+    }
+
+    #[wasm_bindgen(getter = purpose)]
+    pub fn get_purpose(&self) -> String {
+        PurposeWASM::from(self.0.purpose()).into()
+    }
+
+    #[wasm_bindgen(getter = securityLevel)]
+    pub fn get_security_level(&self) -> String {
+        SecurityLevelWASM::from(self.0.security_level()).into()
+    }
+
+    #[wasm_bindgen(getter = keyType)]
+    pub fn get_key_type(&self) -> String {
+        KeyTypeWASM::from(self.0.key_type()).into()
+    }
+
+    #[wasm_bindgen(getter = readOnly)]
+    pub fn get_read_only(&self) -> bool {
+        self.0.read_only()
+    }
+
+    #[wasm_bindgen(getter = data)]
+    pub fn get_data(&self) -> Vec<u8> {
+        self.0.data().to_vec()
+    }
+
+    #[wasm_bindgen(getter = signature)]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
+    }
+
+    #[wasm_bindgen(setter = keyId)]
+    pub fn set_key_id(&mut self, key_id: u32) {
+        self.0.set_id(key_id)
+    }
+
+    #[wasm_bindgen(setter = 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(setter = securityLevel)]
+    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(setter = keyType)]
+    pub fn set_key_type(&mut self, key_type: JsValue) -> Result<(), JsValue> {
+        let key_type = KeyTypeWASM::try_from(key_type)?;
+        self.0.set_type(key_type.into());
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = readOnly)]
+    pub fn set_read_only(&mut self, read_only: bool) {
+        self.0.set_read_only(read_only)
+    }
+
+    #[wasm_bindgen(setter = data)]
+    pub fn set_data(&mut self, binary_data: Vec<u8>) {
+        let data = BinaryData::from(binary_data);
+        self.0.set_data(data)
+    }
+
+    #[wasm_bindgen(setter = signature)]
+    pub fn set_signature(&mut self, binary_data: Vec<u8>) {
+        let signature = BinaryData::from(binary_data);
+        self.0.set_signature(signature)
+    }
+}
+
+impl IdentityPublicKeyInCreationWASM {
+    pub fn vec_from_js_value(
+        js_add_public_keys: &js_sys::Array,
+    ) -> Result<Vec<IdentityPublicKeyInCreationWASM>, JsValue> {
+        let add_public_keys: Vec<IdentityPublicKeyInCreationWASM> = js_add_public_keys
+            .iter()
+            .map(|key| IdentityPublicKeyInCreationWASM::try_from(key))
+            .collect::<Result<Vec<IdentityPublicKeyInCreationWASM>, JsValue>>()?;
+
+        Ok(add_public_keys)
+    }
+}

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

@@ -0,0 +1,141 @@
+use dpp::identifier::Identifier;
+use dpp::identity::state_transition::{AssetLockProved, OptionallyAssetLockProved};
+use dpp::prelude::UserFeeIncrease;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable};
+use dpp::state_transition::identity_topup_transition::IdentityTopUpTransition;
+use dpp::state_transition::identity_topup_transition::accessors::IdentityTopUpTransitionAccessorsV0;
+use dpp::state_transition::identity_topup_transition::v0::IdentityTopUpTransitionV0;
+use dpp::state_transition::{StateTransition, StateTransitionLike};
+use pshenmic_dpp_asset_lock_proof::AssetLockProofWASM;
+use pshenmic_dpp_identifier::IdentifierWASM;
+use pshenmic_dpp_state_transition::StateTransitionWASM;
+use pshenmic_dpp_utils::WithJsError;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "IdentityTopUpTransitionWASM")]
+#[derive(Clone)]
+pub struct IdentityTopUpTransitionWASM(IdentityTopUpTransition);
+
+#[wasm_bindgen]
+impl IdentityTopUpTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        asset_lock_proof: &AssetLockProofWASM,
+        js_identity_id: JsValue,
+        user_fee_increase: UserFeeIncrease,
+    ) -> Result<IdentityTopUpTransitionWASM, JsValue> {
+        let identity_id: Identifier = IdentifierWASM::try_from(js_identity_id)?.into();
+
+        Ok(IdentityTopUpTransitionWASM(IdentityTopUpTransition::V0(
+            IdentityTopUpTransitionV0 {
+                asset_lock_proof: asset_lock_proof.clone().into(),
+                identity_id,
+                user_fee_increase,
+                signature: Default::default(),
+            },
+        )))
+    }
+
+    #[wasm_bindgen(js_name = "getModifiedDataIds")]
+    pub fn get_modified_data_ids(&self) -> Vec<IdentifierWASM> {
+        self.0
+            .modified_data_ids()
+            .iter()
+            .map(|id| id.clone().into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name = "getOptionalAssetLockProof")]
+    pub fn get_optional_asset_lock_proof(&self) -> JsValue {
+        match self.0.optional_asset_lock_proof() {
+            Some(asset_lock) => JsValue::from(AssetLockProofWASM::from(asset_lock.clone())),
+            None => JsValue::null(),
+        }
+    }
+
+    #[wasm_bindgen(getter = "userFeeIncrease")]
+    pub fn get_user_fee_increase(&self) -> UserFeeIncrease {
+        self.0.user_fee_increase()
+    }
+
+    #[wasm_bindgen(getter = "identityIdentifier")]
+    pub fn get_identity_identifier(&self) -> IdentifierWASM {
+        self.0.identity_id().clone().into()
+    }
+
+    #[wasm_bindgen(getter = "assetLockProof")]
+    pub fn get_asset_lock_proof(&self) -> AssetLockProofWASM {
+        self.0.asset_lock_proof().clone().into()
+    }
+
+    #[wasm_bindgen(setter = "userFeeIncrease")]
+    pub fn set_user_fee_increase(&mut self, user_fee_increase: UserFeeIncrease) {
+        self.0.set_user_fee_increase(user_fee_increase);
+    }
+
+    #[wasm_bindgen(setter = "identityIdentifier")]
+    pub fn set_identity_identifier(
+        &mut self,
+        js_identity_identifier: &JsValue,
+    ) -> Result<(), JsValue> {
+        let identity_identifier: Identifier =
+            IdentifierWASM::try_from(js_identity_identifier)?.into();
+        Ok(self.0.set_identity_id(identity_identifier.clone().into()))
+    }
+
+    #[wasm_bindgen(setter = "assetLockProof")]
+    pub fn set_asset_lock_proof(
+        &mut self,
+        asset_lock_proof: &AssetLockProofWASM,
+    ) -> Result<(), JsValue> {
+        self.0
+            .set_asset_lock_proof(asset_lock_proof.clone().into())
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(getter = "signature")]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
+    }
+
+    #[wasm_bindgen(js_name = "getSignableBytes")]
+    pub fn get_signable_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.signable_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(setter = "signature")]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature_bytes(signature)
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityTopUpTransitionWASM, JsValue> {
+        let rs_transition =
+            IdentityTopUpTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error()?;
+
+        Ok(IdentityTopUpTransitionWASM(rs_transition))
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        StateTransitionWASM::from(StateTransition::from(self.0.clone()))
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        st: StateTransitionWASM,
+    ) -> Result<IdentityTopUpTransitionWASM, JsValue> {
+        let rs_st: StateTransition = st.into();
+
+        match rs_st {
+            StateTransition::IdentityTopUp(st) => Ok(IdentityTopUpTransitionWASM(st)),
+            _ => Err(JsValue::from_str(&"Invalid state transition type)")),
+        }
+    }
+}

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

@@ -0,0 +1,213 @@
+use crate::public_key_in_creation::IdentityPublicKeyInCreationWASM;
+use dpp::identity::KeyID;
+use dpp::identity::state_transition::OptionallyAssetLockProved;
+use dpp::prelude::{IdentityNonce, Revision, UserFeeIncrease};
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable};
+use dpp::state_transition::identity_update_transition::IdentityUpdateTransition;
+use dpp::state_transition::identity_update_transition::accessors::IdentityUpdateTransitionAccessorsV0;
+use dpp::state_transition::identity_update_transition::v0::IdentityUpdateTransitionV0;
+use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
+use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned, StateTransitionLike};
+use pshenmic_dpp_asset_lock_proof::AssetLockProofWASM;
+use pshenmic_dpp_enums::keys::purpose::PurposeWASM;
+use pshenmic_dpp_identifier::IdentifierWASM;
+use pshenmic_dpp_state_transition::StateTransitionWASM;
+use pshenmic_dpp_utils::WithJsError;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "IdentityUpdateTransitionWASM")]
+#[derive(Clone)]
+pub struct IdentityUpdateTransitionWASM(IdentityUpdateTransition);
+
+#[wasm_bindgen]
+impl IdentityUpdateTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        js_identity_id: &JsValue,
+        revision: Revision,
+        nonce: IdentityNonce,
+        user_fee_increase: Option<UserFeeIncrease>,
+        js_add_public_keys: &js_sys::Array,
+        disable_public_keys: Vec<KeyID>,
+    ) -> Result<IdentityUpdateTransitionWASM, JsValue> {
+        let identity_id = IdentifierWASM::try_from(js_identity_id)?;
+
+        let add_public_keys: Vec<IdentityPublicKeyInCreationWASM> =
+            IdentityPublicKeyInCreationWASM::vec_from_js_value(js_add_public_keys)?;
+
+        Ok(IdentityUpdateTransitionWASM(IdentityUpdateTransition::V0(
+            IdentityUpdateTransitionV0 {
+                identity_id: identity_id.into(),
+                revision,
+                nonce,
+                add_public_keys: add_public_keys
+                    .clone()
+                    .iter()
+                    .map(|key| key.clone().into())
+                    .collect(),
+                disable_public_keys,
+                user_fee_increase: user_fee_increase.unwrap_or(0),
+                signature_public_key_id: 0,
+                signature: Default::default(),
+            },
+        )))
+    }
+
+    #[wasm_bindgen(getter = "revision")]
+    pub fn get_revision(&self) -> Revision {
+        self.0.revision()
+    }
+
+    #[wasm_bindgen(getter = "nonce")]
+    pub fn get_nonce(&self) -> IdentityNonce {
+        self.0.nonce()
+    }
+
+    #[wasm_bindgen(getter = "identityIdentifier")]
+    pub fn get_identity_identifier(&self) -> IdentifierWASM {
+        self.0.identity_id().into()
+    }
+
+    #[wasm_bindgen(js_name = "getPurposeRequirement")]
+    pub fn get_purpose_requirement(&self) -> Vec<String> {
+        self.0
+            .purpose_requirement()
+            .iter()
+            .map(|purpose| PurposeWASM::from(purpose.clone()).into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name = "getModifiedDataIds")]
+    pub fn get_modified_data_ids(&self) -> Vec<IdentifierWASM> {
+        self.0
+            .modified_data_ids()
+            .iter()
+            .map(|id| id.clone().into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name = "getOptionalAssetLockProof")]
+    pub fn get_optional_asset_lock_proof(&self) -> JsValue {
+        match self.0.optional_asset_lock_proof() {
+            Some(asset_lock) => JsValue::from(AssetLockProofWASM::from(asset_lock.clone())),
+            None => JsValue::null(),
+        }
+    }
+
+    #[wasm_bindgen(getter = "publicKeyIdsToDisable")]
+    pub fn get_public_key_ids_to_disable(&self) -> Vec<KeyID> {
+        self.0.public_key_ids_to_disable().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "publicKeyIdsToAdd")]
+    pub fn get_public_key_ids_to_add(&self) -> Vec<IdentityPublicKeyInCreationWASM> {
+        self.0
+            .public_keys_to_add()
+            .to_vec()
+            .iter()
+            .map(|id| id.clone().into())
+            .collect()
+    }
+
+    #[wasm_bindgen(getter = "userFeeIncrease")]
+    pub fn get_user_fee_increase(&self) -> UserFeeIncrease {
+        self.0.user_fee_increase()
+    }
+
+    #[wasm_bindgen(setter = "revision")]
+    pub fn set_revision(&mut self, revision: Revision) {
+        self.0.set_revision(revision);
+    }
+
+    #[wasm_bindgen(setter = "nonce")]
+    pub fn set_nonce(&mut self, nonce: IdentityNonce) {
+        self.0.set_nonce(nonce);
+    }
+
+    #[wasm_bindgen(setter = "identityIdentifier")]
+    pub fn set_identity_identifier(&mut self, js_identity_id: &JsValue) -> Result<(), JsValue> {
+        let identity_id = IdentifierWASM::try_from(js_identity_id)?;
+        self.0.set_identity_id(identity_id.clone().into());
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = "publicKeyIdsToAdd")]
+    pub fn set_public_key_ids_to_add(
+        &mut self,
+        js_add_public_keys: &js_sys::Array,
+    ) -> Result<(), JsValue> {
+        let add_public_keys: Vec<IdentityPublicKeyInCreationWASM> =
+            IdentityPublicKeyInCreationWASM::vec_from_js_value(js_add_public_keys)?;
+
+        let keys: Vec<IdentityPublicKeyInCreation> =
+            add_public_keys.iter().map(|id| id.clone().into()).collect();
+
+        Ok(self.0.set_public_keys_to_add(keys))
+    }
+
+    #[wasm_bindgen(setter = "publicKeyIdsToDisable")]
+    pub fn set_public_key_ids_to_disable(&mut self, public_keys: Vec<KeyID>) {
+        self.0.set_public_key_ids_to_disable(public_keys)
+    }
+
+    #[wasm_bindgen(setter = "userFeeIncrease")]
+    pub fn set_user_fee_increase(&mut self, user_fee_increase: UserFeeIncrease) {
+        self.0.set_user_fee_increase(user_fee_increase)
+    }
+
+    #[wasm_bindgen(getter = "signature")]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
+    }
+
+    #[wasm_bindgen(js_name = "getSignableBytes")]
+    pub fn get_signable_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.signable_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(getter = "signaturePublicKeyId")]
+    pub fn get_signature_public_key_id(&self) -> KeyID {
+        self.0.signature_public_key_id()
+    }
+
+    #[wasm_bindgen(setter = "signature")]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature_bytes(signature)
+    }
+
+    #[wasm_bindgen(setter = "signaturePublicKeyId")]
+    pub fn set_signature_public_key_id(&mut self, signature_public_key_id: KeyID) {
+        self.0.set_signature_public_key_id(signature_public_key_id)
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityUpdateTransitionWASM, JsValue> {
+        let rs_transition =
+            IdentityUpdateTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error()?;
+
+        Ok(IdentityUpdateTransitionWASM(rs_transition))
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        StateTransitionWASM::from(StateTransition::from(self.0.clone()))
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        st: StateTransitionWASM,
+    ) -> Result<IdentityUpdateTransitionWASM, JsValue> {
+        let rs_st: StateTransition = st.into();
+
+        match rs_st {
+            StateTransition::IdentityUpdate(st) => Ok(IdentityUpdateTransitionWASM(st)),
+            _ => Err(JsValue::from_str(&"Invalid state transition type)")),
+        }
+    }
+}

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,13 +1,14 @@
 [package]
 name = "pshenmic_dpp_private_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",
-]}
+]}
+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,20 @@
 [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", default-features = false, features = ["serde-serialize"] }
+pshenmic_dpp_public_key = {path = "../identity_public_key" }
 pshenmic_dpp_private_key = {path = "../private_key"}
 pshenmic_dpp_utils = {path = "../utils"}
+pshenmic_dpp_identifier = {path = "../identifier"}
 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"