@dashevo/wasm-dpp 0.25.0-dev.16 → 0.25.0-dev.17

package/src/identity/state_transition/identity_credit_transfer_transition/transition.rs

@@ -1,22 +1,27 @@
-use crate::utils::{ToSerdeJSONExt, WithJsError};
-
+use crate::utils::WithJsError;
+use dpp::platform_value::{ReplacementType, Value};
+use serde_json::Value as JsonValue;
 use std::convert::TryInto;
 use std::default::Default;
 
+use dpp::version::PlatformVersion;
 use wasm_bindgen::prelude::*;
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
 use crate::identifier::IdentifierWrapper;
-use crate::{buffer::Buffer, errors::RustConversionError, with_js_error, IdentityPublicKeyWasm};
+use crate::identity::IdentityPublicKeyWasm;
+use crate::{buffer::Buffer, utils, with_js_error};
 use dpp::identifier::Identifier;
-use dpp::identity::state_transition::identity_credit_transfer_transition::IdentityCreditTransferTransition;
 use dpp::identity::KeyType;
 use dpp::platform_value::string_encoding::Encoding;
 use dpp::platform_value::{string_encoding, BinaryData};
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::{PlatformSerializable, ValueConvertible};
+use dpp::state_transition::identity_credit_transfer_transition::accessors::IdentityCreditTransferTransitionAccessorsV0;
+use dpp::state_transition::identity_credit_transfer_transition::fields::IDENTIFIER_FIELDS;
+use dpp::state_transition::identity_credit_transfer_transition::IdentityCreditTransferTransition;
 use dpp::state_transition::StateTransitionLike;
 use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned};
-
 #[wasm_bindgen(js_name=IdentityCreditTransferTransition)]
 #[derive(Clone)]
 pub struct IdentityCreditTransferTransitionWasm(IdentityCreditTransferTransition);
@@ -36,19 +41,18 @@ impl From<IdentityCreditTransferTransitionWasm> for IdentityCreditTransferTransi
 #[wasm_bindgen(js_class = IdentityCreditTransferTransition)]
 impl IdentityCreditTransferTransitionWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(raw_parameters: JsValue) -> Result<IdentityCreditTransferTransitionWasm, JsValue> {
-        let raw_state_transition = raw_parameters.with_serde_to_platform_value()?;
+    pub fn new(platform_version: u32) -> Result<IdentityCreditTransferTransitionWasm, JsValue> {
+        let platform_version =
+            &PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
 
-        let identity_credit_transfer_transition =
-            IdentityCreditTransferTransition::from_raw_object(raw_state_transition)
-                .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
-
-        Ok(identity_credit_transfer_transition.into())
+        IdentityCreditTransferTransition::default_versioned(&platform_version)
+            .map(Into::into)
+            .map_err(from_dpp_err)
     }
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        IdentityCreditTransferTransition::get_type() as u8
+        self.0.state_transition_type() as u8
     }
 
     #[wasm_bindgen(getter, js_name=identityId)]
@@ -63,22 +67,32 @@ impl IdentityCreditTransferTransitionWasm {
 
     #[wasm_bindgen(getter, js_name=amount)]
     pub fn amount(&self) -> u64 {
-        self.0.get_amount()
+        self.0.amount()
     }
 
     #[wasm_bindgen(js_name=getIdentityId)]
     pub fn get_identity_id(&self) -> IdentifierWrapper {
-        (*self.0.get_identity_id()).into()
+        self.0.identity_id().into()
     }
 
     #[wasm_bindgen(js_name=getRecipientId)]
     pub fn get_recipient_id(&self) -> IdentifierWrapper {
-        (*self.0.get_recipient_id()).into()
+        self.0.recipient_id().into()
+    }
+
+    #[wasm_bindgen(js_name=setIdentityId)]
+    pub fn set_identity_id(&mut self, identity_id: &IdentifierWrapper) {
+        self.0.set_identity_id(identity_id.into());
+    }
+
+    #[wasm_bindgen(js_name=setRecipientId)]
+    pub fn set_recipient_id(&mut self, recipient_id: &IdentifierWrapper) {
+        self.0.set_recipient_id(recipient_id.into());
     }
 
     #[wasm_bindgen(js_name=getAmount)]
     pub fn get_amount(&self) -> f64 {
-        self.0.get_amount() as f64
+        self.0.amount() as f64
     }
 
     #[wasm_bindgen(js_name=setAmount)]
@@ -103,11 +117,11 @@ impl IdentityCreditTransferTransitionWasm {
             &object.transition_type.into(),
         )?;
 
-        js_sys::Reflect::set(
-            &js_object,
-            &"protocolVersion".to_owned().into(),
-            &object.protocol_version.into(),
-        )?;
+        let version = match self.0 {
+            IdentityCreditTransferTransition::V0(_) => "0",
+        };
+
+        js_sys::Reflect::set(&js_object, &"$version".to_owned().into(), &version.into())?;
 
         if let Some(signature) = object.signature {
             let signature_value: JsValue = if signature.is_empty() {
@@ -156,9 +170,9 @@ impl IdentityCreditTransferTransitionWasm {
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
-        let bytes = PlatformSerializable::serialize(&StateTransition::IdentityCreditTransfer(
-            self.0.clone(),
-        ))
+        let bytes = PlatformSerializable::serialize_to_bytes(
+            &StateTransition::IdentityCreditTransfer(self.0.clone()),
+        )
         .with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
@@ -174,11 +188,11 @@ impl IdentityCreditTransferTransitionWasm {
             &object.transition_type.into(),
         )?;
 
-        js_sys::Reflect::set(
-            &js_object,
-            &"protocolVersion".to_owned().into(),
-            &object.protocol_version.into(),
-        )?;
+        let version = match self.0 {
+            IdentityCreditTransferTransition::V0(_) => "0",
+        };
+
+        js_sys::Reflect::set(&js_object, &"$version".to_owned().into(), &version.into())?;
 
         if let Some(signature) = object.signature {
             let signature_value: JsValue = if signature.is_empty() {
@@ -230,8 +244,8 @@ impl IdentityCreditTransferTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=getModifiedDataIds)]
-    pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
-        let ids = self.0.get_modified_data_ids();
+    pub fn modified_data_ids(&self) -> Vec<JsValue> {
+        let ids = self.0.modified_data_ids();
 
         ids.into_iter()
             .map(|id| <IdentifierWrapper as std::convert::From<Identifier>>::from(id).into())
@@ -277,19 +291,27 @@ impl IdentityCreditTransferTransitionWasm {
             BlsAdapter(JsValue::undefined().into())
         };
 
-        self.0
+        // TODO: not the best approach because it involves cloning the transition
+        // Probably it worth to return `sign_by_private_key` per state transition
+        let mut wrapper = StateTransition::IdentityCreditTransfer(self.0.clone());
+        wrapper
             .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter)
-            .with_js_error()
+            .with_js_error()?;
+
+        self.0.set_signature(wrapper.signature().to_owned());
+
+        Ok(())
     }
 
     #[wasm_bindgen(js_name=getSignature)]
     pub fn get_signature(&self) -> Buffer {
-        Buffer::from_bytes(self.0.get_signature().as_slice())
+        Buffer::from_bytes(self.0.signature().as_slice())
     }
 
     #[wasm_bindgen(js_name=setSignature)]
     pub fn set_signature(&mut self, signature: Option<Vec<u8>>) {
-        self.0.signature = BinaryData::new(signature.unwrap_or(vec![]))
+        self.0
+            .set_signature(BinaryData::new(signature.unwrap_or(vec![])))
     }
 
     #[wasm_bindgen]
@@ -300,12 +322,23 @@ impl IdentityCreditTransferTransitionWasm {
         bls: JsBlsAdapter,
     ) -> Result<(), JsValue> {
         let bls_adapter = BlsAdapter(bls);
-        self.0
+
+        // TODO: come up with a better way to set signature to the binding.
+        let mut state_transition = StateTransition::IdentityCreditTransfer(self.0.clone());
+        state_transition
             .sign(
                 &identity_public_key.to_owned().into(),
                 &private_key,
                 &bls_adapter,
             )
-            .with_js_error()
+            .with_js_error()?;
+
+        let signature = state_transition.signature().to_owned();
+        let signature_public_key_id = state_transition.signature_public_key_id().unwrap_or(0);
+
+        self.0.set_signature(signature);
+        self.0.set_signature_public_key_id(signature_public_key_id);
+
+        Ok(())
     }
 }

package/src/identity/state_transition/identity_public_key_transitions.rs

@@ -1,17 +1,22 @@
 //todo: move this file to transition
 use dpp::dashcore::anyhow;
-use dpp::document::document_transition::document_base_transition::JsonValue;
-use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreation;
-use dpp::platform_value::BinaryData;
-use dpp::Convertible;
+use dpp::platform_value::{BinaryData, ReplacementType, Value};
+use dpp::serialization::ValueConvertible;
+use dpp::state_transition::public_key_in_creation::accessors::{
+    IdentityPublicKeyInCreationV0Getters, IdentityPublicKeyInCreationV0Setters,
+};
+use dpp::state_transition::public_key_in_creation::v0::BINARY_DATA_FIELDS;
+use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
+use js_sys::Reflect::delete_property;
 pub use serde::{Deserialize, Serialize};
-use std::convert::{TryFrom, TryInto};
+use serde_json::Value as JsonValue;
+use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
 
 use crate::errors::from_dpp_err;
 use crate::utils::WithJsError;
 use crate::{buffer::Buffer, utils, with_js_error};
-
+use dpp::version::PlatformVersion;
 #[derive(Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 struct ToObjectOptions {
@@ -25,93 +30,99 @@ pub struct IdentityPublicKeyWithWitnessWasm(IdentityPublicKeyInCreation);
 #[wasm_bindgen(js_class = IdentityPublicKeyWithWitness)]
 impl IdentityPublicKeyWithWitnessWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(raw_public_key: JsValue) -> Result<IdentityPublicKeyWithWitnessWasm, JsValue> {
-        let data_string = utils::stringify(&raw_public_key)?;
-        let value: JsonValue = serde_json::from_str(&data_string).map_err(|e| e.to_string())?;
-
-        let pk = IdentityPublicKeyInCreation::from_json_object(value).with_js_error()?;
+    pub fn new(platform_version: u32) -> Result<IdentityPublicKeyWithWitnessWasm, JsValue> {
+        let platform_version =
+            &PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
 
-        Ok(IdentityPublicKeyWithWitnessWasm(pk))
+        IdentityPublicKeyInCreation::default_versioned(&platform_version)
+            .map(Into::into)
+            .map_err(from_dpp_err)
     }
 
     #[wasm_bindgen(js_name=getId)]
     pub fn get_id(&self) -> u32 {
-        self.0.id
+        self.0.id()
     }
 
     #[wasm_bindgen(js_name=setId)]
     pub fn set_id(&mut self, id: u32) {
-        self.0.id = id;
+        self.0.set_id(id);
     }
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        self.0.key_type as u8
+        self.0.key_type() as u8
     }
 
     #[wasm_bindgen(js_name=setType)]
     pub fn set_type(&mut self, key_type: u8) -> Result<(), JsValue> {
-        self.0.key_type = key_type
-            .try_into()
-            .map_err(|e: anyhow::Error| e.to_string())?;
+        self.0.set_type(
+            key_type
+                .try_into()
+                .map_err(|e: anyhow::Error| e.to_string())?,
+        );
         Ok(())
     }
 
     #[wasm_bindgen(js_name=setData)]
     pub fn set_data(&mut self, data: Vec<u8>) -> Result<(), JsValue> {
-        self.0.data = BinaryData::new(data);
+        self.0.set_data(BinaryData::new(data));
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getData)]
     pub fn get_data(&self) -> Buffer {
-        Buffer::from_bytes_owned(self.0.data.to_vec())
+        Buffer::from_bytes_owned(self.0.data().to_vec())
     }
 
     #[wasm_bindgen(js_name=setPurpose)]
     pub fn set_purpose(&mut self, purpose: u8) -> Result<(), JsValue> {
-        self.0.purpose = purpose
-            .try_into()
-            .map_err(|e: anyhow::Error| e.to_string())?;
+        self.0.set_purpose(
+            purpose
+                .try_into()
+                .map_err(|e: anyhow::Error| e.to_string())?,
+        );
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getPurpose)]
     pub fn get_purpose(&self) -> u8 {
-        self.0.purpose as u8
+        self.0.purpose() as u8
     }
 
     #[wasm_bindgen(js_name=setSecurityLevel)]
     pub fn set_security_level(&mut self, security_level: u8) -> Result<(), JsValue> {
-        self.0.security_level = security_level
-            .try_into()
-            .map_err(|e: anyhow::Error| e.to_string())?;
+        self.0.set_security_level(
+            security_level
+                .try_into()
+                .map_err(|e: anyhow::Error| e.to_string())?,
+        );
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getSecurityLevel)]
     pub fn get_security_level(&self) -> u8 {
-        self.0.security_level as u8
+        self.0.security_level() as u8
     }
 
     #[wasm_bindgen(js_name=setReadOnly)]
     pub fn set_read_only(&mut self, read_only: bool) {
-        self.0.read_only = read_only;
+        self.0.set_read_only(read_only);
     }
 
     #[wasm_bindgen(js_name=isReadOnly)]
     pub fn is_read_only(&self) -> bool {
-        self.0.read_only
+        self.0.read_only()
     }
 
     #[wasm_bindgen(js_name=setSignature)]
     pub fn set_signature(&mut self, signature: Vec<u8>) {
-        self.0.signature = BinaryData::new(signature)
+        self.0.set_signature(BinaryData::new(signature))
     }
 
     #[wasm_bindgen(js_name=getSignature)]
     pub fn get_signature(&self) -> Vec<u8> {
-        self.0.signature.to_vec()
+        self.0.signature().to_vec()
     }
 
     #[wasm_bindgen(js_name=hash)]
@@ -119,35 +130,33 @@ impl IdentityPublicKeyWithWitnessWasm {
         self.0.hash_as_vec().with_js_error()
     }
 
-    #[wasm_bindgen(js_name=isMaster)]
-    pub fn is_master(&self) -> bool {
-        self.0.is_master()
-    }
-
     #[wasm_bindgen(js_name=toJSON)]
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let val = self.0.to_json().map_err(from_dpp_err)?;
-        let json = val.to_string();
+        let mut value = self.0.to_object().map_err(from_dpp_err)?;
+
+        value
+            .replace_at_paths(
+                dpp::identity::identity_public_key::BINARY_DATA_FIELDS,
+                ReplacementType::TextBase64,
+            )
+            .map_err(|e| e.to_string())?;
+
+        let json = value
+            .try_into_validating_json()
+            .map_err(|e| e.to_string())?
+            .to_string();
+
         js_sys::JSON::parse(&json)
     }
 
     #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self, options: JsValue) -> Result<JsValue, JsValue> {
-        let opts: ToObjectOptions = if options.is_object() {
-            with_js_error!(serde_wasm_bindgen::from_value(options))?
-        } else {
-            Default::default()
-        };
-
-        let val = self
-            .0
-            .to_raw_json_object(opts.skip_signature.unwrap_or(false))
-            .map_err(|e| from_dpp_err(e.into()))?;
+    pub fn to_object(&self, skip_signature: bool) -> Result<JsValue, JsValue> {
+        let value = self.0.to_object().map_err(from_dpp_err)?;
 
-        let data_buffer = Buffer::from_bytes(self.0.data.as_slice());
+        let data_buffer = Buffer::from_bytes(self.0.data().as_slice());
 
-        let json = val.to_string();
-        let js_object = js_sys::JSON::parse(&json)?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let js_object = with_js_error!(value.serialize(&serializer))?;
 
         js_sys::Reflect::set(
             &js_object,
@@ -161,12 +170,17 @@ impl IdentityPublicKeyWithWitnessWasm {
             &JsValue::from(data_buffer),
         )?;
 
-        if !opts.skip_signature.unwrap_or(false) && !self.0.signature.is_empty() {
+        if !skip_signature {
+            let signature_buffer = Buffer::from_bytes(self.0.signature().as_slice());
             js_sys::Reflect::set(
                 &js_object,
                 &JsValue::from_str("signature"),
-                &JsValue::from(Buffer::from_bytes_owned(self.0.signature.to_vec())),
+                &JsValue::from(signature_buffer),
             )?;
+        } else {
+            let js_object = js_sys::Object::from(js_object);
+            delete_property(&js_object, &JsValue::from_str("signature"))?;
+            return Ok(js_object.into());
         }
 
         Ok(js_object)
@@ -193,17 +207,18 @@ impl From<IdentityPublicKeyInCreation> for IdentityPublicKeyWithWitnessWasm {
     }
 }
 
-impl TryFrom<JsValue> for IdentityPublicKeyWithWitnessWasm {
-    type Error = JsValue;
-
-    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
-        let str = String::from(js_sys::JSON::stringify(&value)?);
-        let val = serde_json::from_str(&str).map_err(|e| from_dpp_err(e.into()))?;
-        Ok(Self(
-            IdentityPublicKeyInCreation::from_raw_json_object(val).with_js_error()?,
-        ))
-    }
-}
+// TODO(versioning): restore
+// impl TryFrom<JsValue> for IdentityPublicKeyWithWitnessWasm {
+//     type Error = JsValue;
+//
+//     fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+//         let str = String::from(js_sys::JSON::stringify(&value)?);
+//         let val = serde_json::from_str(&str).map_err(|e| from_dpp_err(e.into()))?;
+//         Ok(Self(
+//             IdentityPublicKeyInCreation::from_raw_json_object(val).with_js_error()?,
+//         ))
+//     }
+// }
 
 impl From<IdentityPublicKeyWithWitnessWasm> for IdentityPublicKeyInCreation {
     fn from(pk: IdentityPublicKeyWithWitnessWasm) -> Self {