pshenmic-dpp 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pshenmic-dpp",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "main": "dist/wasm/pshenmic_dpp.js",
   "repository": {
     "type": "git",

package/packages/{cbor-conversation → cbor_conversation}/Cargo.toml

@@ -15,7 +15,3 @@ pshenmic_dpp_utils = {path = "../utils"}
 base64 = "0.22.1"
 ciborium = "0.2.2"
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
-
-[profile.release]
-lto = true
-opt-level = 'z'

package/packages/data_contract/Cargo.toml

@@ -11,11 +11,7 @@ wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
 pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_enums = {path = "../enums"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
-    "data-contract-json-conversion"
+    "data-contract-json-conversion",
+    "platform-value"
 ]}
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
-#serde = { version = "1.0.219", features = ["derive"] }
-
-[profile.release]
-lto = true
-opt-level = 'z'

package/packages/data_contract/src/lib.rs

@@ -1,18 +1,18 @@
 use dpp::dashcore::hashes::serde::Serialize;
-use dpp::data_contract::accessors::v0::DataContractV0Getters;
+use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
 use dpp::data_contract::conversion::json::DataContractJsonConversionMethodsV0;
 use dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0;
 use dpp::data_contract::document_type::DocumentTypeRef;
 use dpp::data_contract::errors::DataContractError;
 use dpp::data_contract::schema::DataContractSchemaMethodsV0;
 use dpp::data_contract::{DataContract, DataContractV0};
-use dpp::platform_value::string_encoding::Encoding::Base58;
+use dpp::prelude::IdentityNonce;
 use dpp::serialization::{
     PlatformDeserializableWithPotentialValidationFromVersionedStructure,
     PlatformSerializableWithPlatformVersion,
 };
 use pshenmic_dpp_enums::platform::PlatformVersionWASM;
-use pshenmic_dpp_utils::{ToSerdeJSONExt, WithJsError};
+use pshenmic_dpp_utils::{ToSerdeJSONExt, WithJsError, identifier_from_js_value};
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -40,18 +40,13 @@ impl DataContractWASM {
         full_validation: bool,
         platform_version: PlatformVersionWASM,
     ) -> Result<DataContractWASM, JsValue> {
-        let value = js_value.with_serde_to_platform_value();
+        let value = js_value.with_serde_to_platform_value()?;
 
-        match value {
-            Ok(v) => {
-                let v0_contract =
-                    DataContractV0::from_value(v, full_validation, &platform_version.into())
-                        .with_js_error()?;
+        let v0_contract =
+            DataContractV0::from_value(value, full_validation, &platform_version.into())
+                .with_js_error()?;
 
-                Ok(DataContractWASM(DataContract::V0(v0_contract)))
-            }
-            Err(err) => Err(err),
-        }
+        Ok(DataContractWASM(DataContract::V0(v0_contract)))
     }
 
     #[wasm_bindgen(js_name = "fromBytes")]
@@ -65,12 +60,9 @@ impl DataContractWASM {
             full_validation,
             &platform_version.into(),
         )
-        .with_js_error();
+        .with_js_error()?;
 
-        match rs_data_contract {
-            Ok(rs_data_contract) => Ok(DataContractWASM(rs_data_contract)),
-            Err(err) => Err(err),
-        }
+        Ok(DataContractWASM(rs_data_contract))
     }
 
     #[wasm_bindgen(js_name = "toBytes")]
@@ -84,23 +76,24 @@ impl DataContractWASM {
 
     #[wasm_bindgen(js_name = "toValue")]
     pub fn to_value(&self, platform_version: PlatformVersionWASM) -> Result<JsValue, JsValue> {
-        let value = self
-            .0
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        self.0
             .clone()
             .to_value(&platform_version.into())
-            .with_js_error();
-
-        match value {
-            Ok(v) => Ok(serde_wasm_bindgen::to_value(&v).unwrap()),
-            Err(err) => Err(err),
-        }
+            .with_js_error()?
+            .serialize(&serializer)
+            .map_err(JsValue::from)
     }
 
-    #[wasm_bindgen(js_name = "getSchema")]
-    pub fn get_schema(&self) -> JsValue {
+    #[wasm_bindgen(js_name = "getSchemas")]
+    pub fn get_schemas(&self) -> Result<JsValue, JsValue> {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
 
-        self.0.document_schemas().serialize(&serializer).unwrap()
+        self.0
+            .document_schemas()
+            .serialize(&serializer)
+            .map_err(JsValue::from)
     }
 
     #[wasm_bindgen(js_name = "getDataContractVersion")]
@@ -108,32 +101,54 @@ impl DataContractWASM {
         self.0.version()
     }
 
-    #[wasm_bindgen(js_name = "getDataContractIdentifier")]
-    pub fn get_data_contract_identifier(&self) -> JsValue {
-        JsValue::from_str(&*self.0.id().to_string(Base58))
+    #[wasm_bindgen(js_name = "getId")]
+    pub fn get_id(&self) -> Vec<u8> {
+        self.0.id().to_vec()
     }
 
     #[wasm_bindgen(js_name = "getOwnerId")]
-    pub fn get_owner_id(&self) -> JsValue {
-        JsValue::from_str(&*self.0.owner_id().to_string(Base58))
+    pub fn get_owner_id(&self) -> Vec<u8> {
+        self.0.owner_id().to_vec()
     }
 
     #[wasm_bindgen(js_name = "getConfig")]
-    pub fn get_config(&self) -> JsValue {
+    pub fn get_config(&self) -> Result<JsValue, JsValue> {
         self.0
             .config()
             .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
-            .unwrap()
+            .map_err(JsValue::from)
     }
 
     #[wasm_bindgen(js_name = "toJson")]
     pub fn to_json(&self, platform_version: PlatformVersionWASM) -> Result<JsValue, JsValue> {
-        let json = self.0.to_json(&platform_version.into()).with_js_error();
+        let json = self.0.to_json(&platform_version.into()).with_js_error()?;
+
+        json.serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .map_err(JsValue::from)
+    }
+
+    #[wasm_bindgen(js_name = "generateId")]
+    pub fn generate_id(
+        js_owner_id: JsValue,
+        identity_nonce: IdentityNonce,
+    ) -> Result<Vec<u8>, JsValue> {
+        let owner_id = identifier_from_js_value(&js_owner_id)?;
+
+        Ok(DataContract::generate_data_contract_id_v0(owner_id, identity_nonce).to_vec())
+    }
+
+    #[wasm_bindgen(js_name = "setId")]
+    pub fn set_id(&mut self, js_data_contract_id: JsValue) -> Result<(), JsValue> {
+        let data_contract_id = identifier_from_js_value(&js_data_contract_id)?;
+
+        Ok(self.0.set_id(data_contract_id))
+    }
+
+    #[wasm_bindgen(js_name = "setOwnerId")]
+    pub fn set_owner_id(&mut self, js_owner_id: JsValue) -> Result<(), JsValue> {
+        let owner_id = identifier_from_js_value(&js_owner_id)?;
 
-        match json {
-            Ok(json) => Ok(json.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?),
-            Err(err) => Err(err),
-        }
+        Ok(self.0.set_owner_id(owner_id))
     }
 }
 

package/packages/data_contract_transitions/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "pshenmic_dpp_data_contract_transitions"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
+    "state-transition-signing"
+]}
+pshenmic_dpp_data_contract = {path = "../data_contract"}
+pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_utils = {path = "../utils"}
+pshenmic_dpp_state_transition = {path = "../state_transition"}

package/packages/data_contract_transitions/src/create/mod.rs

@@ -0,0 +1,154 @@
+use dpp::ProtocolError;
+use dpp::data_contract::serialized_version::DataContractInSerializationFormat;
+use dpp::prelude::{DataContract, IdentityNonce};
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::state_transition::StateTransition;
+use dpp::state_transition::data_contract_create_transition::accessors::DataContractCreateTransitionAccessorsV0;
+use dpp::state_transition::data_contract_create_transition::{
+    DataContractCreateTransition, DataContractCreateTransitionV0,
+};
+use dpp::validation::operations::ProtocolValidationOperation;
+use dpp::version::{
+    FeatureVersion, ProtocolVersion, TryFromPlatformVersioned, TryIntoPlatformVersioned,
+};
+use pshenmic_dpp_data_contract::DataContractWASM;
+use pshenmic_dpp_enums::platform::PlatformVersionWASM;
+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 = "DataContractCreateTransitionWASM")]
+pub struct DataContractCreateTransitionWASM(DataContractCreateTransition);
+
+#[wasm_bindgen]
+impl DataContractCreateTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        data_contract: &DataContractWASM,
+        identity_nonce: IdentityNonce,
+        platform_version: Option<PlatformVersionWASM>,
+    ) -> Result<DataContractCreateTransitionWASM, JsValue> {
+        let rs_data_contract: DataContract = data_contract.clone().into();
+
+        let rs_data_contract_in_serialized: Result<
+            DataContractInSerializationFormat,
+            ProtocolError,
+        > = rs_data_contract.try_into_platform_versioned(
+            &platform_version
+                .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
+                .into(),
+        );
+
+        let rs_data_contract_create_transition_v0: DataContractCreateTransitionV0 =
+            DataContractCreateTransitionV0 {
+                data_contract: rs_data_contract_in_serialized.with_js_error()?,
+                identity_nonce,
+                user_fee_increase: 0,
+                signature_public_key_id: 0,
+                signature: Default::default(),
+            };
+
+        let rs_data_contract_transition =
+            DataContractCreateTransition::V0(rs_data_contract_create_transition_v0);
+
+        Ok(DataContractCreateTransitionWASM(
+            rs_data_contract_transition,
+        ))
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<DataContractCreateTransitionWASM, JsValue> {
+        let rs_data_contract_create_transition: DataContractCreateTransition =
+            DataContractCreateTransition::deserialize_from_bytes(bytes.as_slice())
+                .with_js_error()?;
+
+        Ok(DataContractCreateTransitionWASM(
+            rs_data_contract_create_transition,
+        ))
+    }
+
+    #[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 = "getFeatureVersion")]
+    pub fn get_feature_version(&self) -> FeatureVersion {
+        self.0.feature_version()
+    }
+
+    #[wasm_bindgen(js_name = "verifyProtocolVersion")]
+    pub fn verify_protocol_version(
+        &self,
+        protocol_version: ProtocolVersion,
+    ) -> Result<bool, JsValue> {
+        self.0
+            .verify_protocol_version(protocol_version)
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "setDataContract")]
+    pub fn set_data_contract(
+        &mut self,
+        data_contract: DataContractWASM,
+        platform_version_wasm: Option<PlatformVersionWASM>,
+    ) -> Result<(), JsValue> {
+        let data_contract_serialization_format =
+            DataContractInSerializationFormat::try_from_platform_versioned(
+                DataContract::from(data_contract),
+                &platform_version_wasm
+                    .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
+                    .into(),
+            )
+            .with_js_error()?;
+
+        self.0.set_data_contract(data_contract_serialization_format);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = "getDataContract")]
+    pub fn get_data_contract(
+        &self,
+        platform_version_wasm: Option<PlatformVersionWASM>,
+        full_validation: Option<bool>,
+    ) -> Result<DataContractWASM, JsValue> {
+        let rs_data_contract_serialization_format = self.0.data_contract();
+
+        let mut validation_operations: Vec<ProtocolValidationOperation> = Vec::new();
+
+        let rs_data_contract = DataContract::try_from_platform_versioned(
+            rs_data_contract_serialization_format.clone(),
+            full_validation.unwrap_or(false),
+            &mut validation_operations,
+            &platform_version_wasm
+                .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
+                .into(),
+        )
+        .with_js_error()?;
+
+        Ok(DataContractWASM::from(rs_data_contract))
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        let rs_state_transition = StateTransition::from(self.0.clone());
+
+        StateTransitionWASM::from(rs_state_transition)
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        state_transition: &StateTransitionWASM,
+    ) -> Result<DataContractCreateTransitionWASM, JsValue> {
+        let rs_transition = StateTransition::from(state_transition.clone());
+
+        match rs_transition {
+            StateTransition::DataContractCreate(state_transition) => {
+                Ok(DataContractCreateTransitionWASM(state_transition))
+            }
+            _ => Err(JsValue::from("Incorrect transition type")),
+        }
+    }
+}

package/packages/data_contract_transitions/src/lib.rs

@@ -0,0 +1,2 @@
+mod create;
+mod update;

package/packages/data_contract_transitions/src/update/mod.rs

@@ -0,0 +1,135 @@
+use dpp::data_contract::serialized_version::DataContractInSerializationFormat;
+use dpp::prelude::{DataContract, IdentityNonce};
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::state_transition::StateTransition;
+use dpp::state_transition::data_contract_update_transition::DataContractUpdateTransition;
+use dpp::state_transition::data_contract_update_transition::accessors::DataContractUpdateTransitionAccessorsV0;
+use dpp::validation::operations::ProtocolValidationOperation;
+use dpp::version::{FeatureVersion, ProtocolVersion, TryFromPlatformVersioned};
+use pshenmic_dpp_data_contract::DataContractWASM;
+use pshenmic_dpp_enums::platform::PlatformVersionWASM;
+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 = "DataContractUpdateTransitionWASM")]
+pub struct DataContractUpdateTransitionWASM(DataContractUpdateTransition);
+
+#[wasm_bindgen]
+impl DataContractUpdateTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        data_contract: &DataContractWASM,
+        identity_nonce: IdentityNonce,
+        platform_version: Option<PlatformVersionWASM>,
+    ) -> Result<DataContractUpdateTransitionWASM, JsValue> {
+        let rs_data_contract_update_transition =
+            DataContractUpdateTransition::try_from_platform_versioned(
+                (DataContract::from(data_contract.clone()), identity_nonce),
+                &platform_version
+                    .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
+                    .into(),
+            )
+            .with_js_error()?;
+
+        Ok(DataContractUpdateTransitionWASM(
+            rs_data_contract_update_transition,
+        ))
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<DataContractUpdateTransitionWASM, JsValue> {
+        let rs_data_contract_update_transition: DataContractUpdateTransition =
+            DataContractUpdateTransition::deserialize_from_bytes(bytes.as_slice())
+                .with_js_error()?;
+
+        Ok(DataContractUpdateTransitionWASM(
+            rs_data_contract_update_transition,
+        ))
+    }
+
+    #[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 = "getFeatureVersion")]
+    pub fn get_feature_version(&self) -> FeatureVersion {
+        self.0.feature_version()
+    }
+
+    #[wasm_bindgen(js_name = "verifyProtocolVersion")]
+    pub fn verify_protocol_version(
+        &self,
+        protocol_version: ProtocolVersion,
+    ) -> Result<bool, JsValue> {
+        self.0
+            .verify_protocol_version(protocol_version)
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "setDataContract")]
+    pub fn set_data_contract(
+        &mut self,
+        data_contract: &DataContractWASM,
+        platform_version_wasm: Option<PlatformVersionWASM>,
+    ) -> Result<(), JsValue> {
+        let data_contract_serialization_format =
+            DataContractInSerializationFormat::try_from_platform_versioned(
+                DataContract::from(data_contract.clone()),
+                &platform_version_wasm
+                    .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
+                    .into(),
+            )
+            .with_js_error()?;
+
+        self.0.set_data_contract(data_contract_serialization_format);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name = "getDataContract")]
+    pub fn get_data_contract(
+        &self,
+        full_validation: Option<bool>,
+        platform_version_wasm: Option<PlatformVersionWASM>,
+    ) -> Result<DataContractWASM, JsValue> {
+        let data_contract_serialization_format = self.0.data_contract();
+
+        let mut validation_operations: Vec<ProtocolValidationOperation> = Vec::new();
+
+        let rs_data_contract = DataContract::try_from_platform_versioned(
+            data_contract_serialization_format.clone(),
+            full_validation.unwrap_or(false),
+            &mut validation_operations,
+            &platform_version_wasm
+                .unwrap_or(PlatformVersionWASM::PLATFORM_V1)
+                .into(),
+        )
+        .with_js_error()?;
+
+        Ok(DataContractWASM::from(rs_data_contract))
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        let rs_state_transition = StateTransition::from(self.0.clone());
+
+        StateTransitionWASM::from(rs_state_transition)
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        state_transition: &StateTransitionWASM,
+    ) -> Result<DataContractUpdateTransitionWASM, JsValue> {
+        let rs_transition = StateTransition::from(state_transition.clone());
+
+        match rs_transition {
+            StateTransition::DataContractUpdate(state_transition) => {
+                Ok(DataContractUpdateTransitionWASM(state_transition))
+            }
+            _ => Err(JsValue::from("Incorrect transition type")),
+        }
+    }
+}

package/packages/document/Cargo.toml

@@ -14,9 +14,4 @@ pshenmic_dpp_data_contract = {path = "../data_contract"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "document-value-conversion"
 ]}
-#serde = { version = "1.0.197", features = ["derive"] }
-serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
-
-[profile.release]
-lto = true
-opt-level = 'z'
+serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }

package/packages/document_batch/Cargo.toml

@@ -14,9 +14,4 @@ pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_state_transition = {path = "../state_transition"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "document-json-conversion",
-]}
-
-
-[profile.release]
-lto = true
-opt-level = 'z'
+]}

package/packages/enums/Cargo.toml

@@ -10,7 +10,4 @@ crate-type = ["cdylib", "lib"]
 wasm-bindgen = "0.2.100"
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "identity-value-conversion",
-]}
-[profile.release]
-lto = true
-opt-level = 'z'
+]}

package/packages/identity/Cargo.toml

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

package/packages/identity_transitions/Cargo.toml

@@ -14,8 +14,4 @@ dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-
 pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_public_key = {path = "../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,9 +76,9 @@ 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)),

package/packages/mock_bls/Cargo.toml

@@ -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'
+]}

package/packages/private_key/Cargo.toml

@@ -10,8 +10,4 @@ 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",
-]}
-
-[profile.release]
-lto = true
-opt-level = 'z'
+]}

package/packages/public_key/Cargo.toml

@@ -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/state_transition/Cargo.toml

@@ -15,8 +15,4 @@ 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"
-]}
-
-[profile.release]
-lto = true
-opt-level = 'z'
+]}

package/packages/state_transition/src/lib.rs

@@ -9,6 +9,7 @@ use pshenmic_dpp_utils::WithJsError;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
+#[derive(Clone)]
 #[wasm_bindgen(js_name = "StateTransitionWASM")]
 pub struct StateTransitionWASM(StateTransition);
 
@@ -29,11 +30,11 @@ impl StateTransitionWASM {
     #[wasm_bindgen(js_name=sign)]
     pub fn sign(
         &mut self,
-        private_key: PrivateKeyWASM,
-        public_key: IdentityPublicKeyWASM,
+        private_key: &PrivateKeyWASM,
+        public_key: &IdentityPublicKeyWASM,
     ) -> Result<JsValue, JsValue> {
         let sig = self.0.sign(
-            &public_key.into(),
+            &public_key.clone().into(),
             private_key.get_key_bytes().as_slice(),
             &MockBLS {},
         );
@@ -57,7 +58,7 @@ impl StateTransitionWASM {
     #[wasm_bindgen(js_name=signByPrivateKey)]
     pub fn sign_by_private_key(
         &mut self,
-        private_key: PrivateKeyWASM,
+        private_key: &PrivateKeyWASM,
         key_type: KeyTypeWASM,
     ) -> JsValue {
         let _sig = self
@@ -79,7 +80,7 @@ impl StateTransitionWASM {
 
     #[wasm_bindgen(js_name=toBytes)]
     pub fn to_bytes(&self) -> Result<JsValue, JsValue> {
-        let bytes = self.0.serialize_to_bytes().expect("Serialization failed");
+        let bytes = self.0.serialize_to_bytes().with_js_error()?;
 
         Ok(JsValue::from(bytes.clone()))
     }

package/packages/utils/Cargo.toml

@@ -17,8 +17,4 @@ js-sys = "0.3.53"
 serde_json = { version = "1.0", features = ["preserve_order"] }
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
 serde = { version = "1.0.197", features = ["derive"] }
-itertools = { version = "0.13" }
-
-[profile.release]
-lto = true
-opt-level = 'z'
+itertools = { version = "0.13" }