@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0-pr.1545.2

package/src/document/state_transition/document_batch_transition/document_transition/document_replace_transition.rs

@@ -1,7 +1,7 @@
 use std::convert;
 use std::convert::TryInto;
 
-use dpp::document::document_transition::document_base_transition::JsonValue;
+use serde_json::Value as JsonValue;
 
 use dpp::platform_value::btreemap_extensions::{
     BTreeValueMapHelper, BTreeValueMapPathHelper, BTreeValueMapReplacementPathHelper,
@@ -9,24 +9,29 @@ use dpp::platform_value::btreemap_extensions::{
 use dpp::platform_value::ReplacementType;
 use dpp::prelude::Revision;
 use dpp::{
-    document::document_transition::{
-        document_replace_transition, DocumentReplaceTransition, DocumentTransitionObjectLike,
-    },
     prelude::{DataContract, Identifier},
+    state_transition::documents_batch_transition::{
+        document_replace_transition, DocumentReplaceTransition,
+    },
     util::json_schema::JsonSchemaExt,
     ProtocolError,
 };
 use serde::Serialize;
 use wasm_bindgen::prelude::*;
+use dpp::data_contract::accessors::v0::DataContractV0Getters;
+use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
+use dpp::state_transition::documents_batch_transition::document_base_transition::v0::v0_methods::DocumentBaseTransitionV0Methods;
+use dpp::state_transition::documents_batch_transition::document_replace_transition::v0::v0_methods::DocumentReplaceTransitionV0Methods;
 
 use crate::{
     buffer::Buffer,
-    document_batch_transition::document_transition::to_object,
+    document::state_transition::document_batch_transition::document_transition::to_object,
     identifier::IdentifierWrapper,
     lodash::lodash_set,
     utils::{ToSerdeJSONExt, WithJsError},
     BinaryType, DataContractWasm,
 };
+use dpp::state_transition::documents_batch_transition::document_transition::action_type::DocumentTransitionActionType;
 
 #[wasm_bindgen(js_name=DocumentReplaceTransition)]
 #[derive(Debug, Clone)]
@@ -49,24 +54,32 @@ impl From<DocumentReplaceTransitionWasm> for DocumentReplaceTransition {
 #[wasm_bindgen(js_class=DocumentReplaceTransition)]
 impl DocumentReplaceTransitionWasm {
     #[wasm_bindgen(constructor)]
-    pub fn from_raw_object(
+    pub fn from_object(
         raw_object: JsValue,
         data_contract: &DataContractWasm,
     ) -> Result<DocumentReplaceTransitionWasm, JsValue> {
-        let data_contract: DataContract = data_contract.clone().into();
         let mut value = raw_object.with_serde_to_platform_value_map()?;
-        let document_type = value
-            .get_string(dpp::document::extended_document::property_names::DOCUMENT_TYPE)
+        let document_type_name = value
+            .get_string(dpp::document::extended_document::property_names::DOCUMENT_TYPE_NAME)
             .map_err(ProtocolError::ValueError)
             .with_js_error()?;
 
-        let (identifier_paths, _): (Vec<_>, Vec<_>) = data_contract
-            .get_identifiers_and_binary_paths_owned(document_type.as_str())
+        let document_type = data_contract
+            .inner()
+            .document_type_for_name(document_type_name)
             .with_js_error()?;
+        let identifier_paths = document_type.identifier_paths();
+        let binary_paths = document_type.binary_paths();
+
         value
             .replace_at_paths(identifier_paths, ReplacementType::Identifier)
             .map_err(ProtocolError::ValueError)
             .with_js_error()?;
+
+        value
+            .replace_at_paths(binary_paths, ReplacementType::BinaryBytes)
+            .map_err(ProtocolError::ValueError)
+            .with_js_error()?;
         let transition =
             DocumentReplaceTransition::from_value_map(value, data_contract).with_js_error()?;
 
@@ -75,36 +88,40 @@ impl DocumentReplaceTransitionWasm {
 
     #[wasm_bindgen(js_name=getAction)]
     pub fn action(&self) -> u8 {
-        self.inner.base.action as u8
+        DocumentTransitionActionType::Replace as u8
     }
 
     #[wasm_bindgen(js_name=getRevision)]
     pub fn revision(&self) -> Revision {
-        self.inner.revision
+        self.inner.revision()
     }
 
     #[wasm_bindgen(js_name=getUpdatedAt)]
     pub fn updated_at(&self) -> Option<js_sys::Date> {
         self.inner
-            .updated_at
+            .updated_at()
             .map(|timestamp| js_sys::Date::new(&JsValue::from_f64(timestamp as f64)))
     }
 
     #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self, options: &JsValue) -> Result<JsValue, JsValue> {
-        let (identifiers_paths, binary_paths) = self
-            .inner
-            .base
-            .data_contract
-            .get_identifiers_and_binary_paths(&self.inner.base.document_type_name)
+    pub fn to_object(
+        &self,
+        options: &JsValue,
+        data_contract: DataContractWasm,
+    ) -> Result<JsValue, JsValue> {
+        let document_type = data_contract
+            .inner()
+            .document_type_for_name(self.inner.base().document_type_name())
             .with_js_error()?;
+        let identifier_paths = document_type.identifier_paths();
+        let binary_paths = document_type.binary_paths();
 
         to_object(
             self.inner.to_object().with_js_error()?,
             options,
-            identifiers_paths
+            identifier_paths
                 .into_iter()
-                .chain(document_replace_transition::IDENTIFIER_FIELDS),
+                .chain(document_replace_transition::v0::IDENTIFIER_FIELDS),
             binary_paths,
         )
     }
@@ -119,20 +136,20 @@ impl DocumentReplaceTransitionWasm {
 
     // AbstractDataDocumentTransition
     #[wasm_bindgen(js_name=getData)]
-    pub fn get_data(&self) -> Result<JsValue, JsValue> {
-        let data = if let Some(ref data) = self.inner.data {
+    pub fn get_data(&self, data_contract: DataContractWasm) -> Result<JsValue, JsValue> {
+        let data = if let Some(ref data) = self.inner.data() {
             data
         } else {
             return Ok(JsValue::undefined());
         };
 
         let js_value = data.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?;
-        let (identifier_paths, binary_paths) = self
-            .inner
-            .base
-            .data_contract
-            .get_identifiers_and_binary_paths(&self.inner.base.document_type_name)
+        let document_type = data_contract
+            .inner()
+            .document_type_for_name(self.inner.base().document_type_name())
             .with_js_error()?;
+        let identifier_paths = document_type.identifier_paths();
+        let binary_paths = document_type.binary_paths();
 
         for path in identifier_paths {
             let bytes = data
@@ -159,27 +176,22 @@ impl DocumentReplaceTransitionWasm {
     // AbstractDocumentTransition
     #[wasm_bindgen(js_name=getId)]
     pub fn id(&self) -> IdentifierWrapper {
-        self.inner.base.id.into()
+        self.inner.base().id().into()
     }
 
     #[wasm_bindgen(js_name=getType)]
     pub fn document_type(&self) -> String {
-        self.inner.base.document_type_name.clone()
-    }
-
-    #[wasm_bindgen(js_name=getDataContract)]
-    pub fn data_contract(&self) -> DataContractWasm {
-        self.inner.base.data_contract.clone().into()
+        self.inner.base().document_type_name().clone()
     }
 
     #[wasm_bindgen(js_name=getDataContractId)]
     pub fn data_contract_id(&self) -> IdentifierWrapper {
-        self.inner.base.data_contract.id.into()
+        self.inner.base().data_contract_id().into()
     }
 
     #[wasm_bindgen(js_name=get)]
     pub fn get(&self, path: String) -> Result<JsValue, JsValue> {
-        let document_data = if let Some(ref data) = self.inner.data {
+        let document_data = if let Some(ref data) = self.inner.data() {
             data
         } else {
             return Ok(JsValue::undefined());

package/src/document/state_transition/document_batch_transition/document_transition/mod.rs

@@ -1,19 +1,23 @@
 mod document_create_transition;
-mod document_delete_transition;
-mod document_replace_transition;
+// mod document_delete_transition;
+// mod document_replace_transition;
 
-pub use document_create_transition::*;
-pub use document_delete_transition::*;
-pub use document_replace_transition::*;
+// pub use document_create_transition::*;
+// pub use document_delete_transition::*;
+// pub use document_replace_transition::*;
 
+use dpp::data_contract::accessors::v0::DataContractV0Getters;
+use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
 use dpp::platform_value::Value;
 use dpp::prelude::TimestampMillis;
+use dpp::state_transition::documents_batch_transition::document_transition::action_type::TransitionActionTypeGetter;
+use dpp::state_transition::documents_batch_transition::document_transition::DocumentTransitionV0Methods;
 use dpp::{
-    document::document_transition::{
-        DocumentCreateTransition, DocumentDeleteTransition, DocumentReplaceTransition,
-        DocumentTransitionExt, DocumentTransitionObjectLike,
+    prelude::Identifier,
+    state_transition::documents_batch_transition::{
+        document_transition::DocumentTransition, DocumentCreateTransition,
+        DocumentDeleteTransition, DocumentReplaceTransition,
     },
-    prelude::{DocumentTransition, Identifier},
     util::{json_schema::JsonSchemaExt, json_value::JsonValueExt},
     ProtocolError,
 };
@@ -42,22 +46,22 @@ impl DocumentTransitionWasm {
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> String {
-        self.0.get_document_type().to_owned()
+        self.0.document_type_name().to_owned()
     }
 
     #[wasm_bindgen(js_name=getAction)]
     pub fn get_action(&self) -> u8 {
-        self.0.get_action().into()
+        self.0.action_type() as u8
     }
 
-    #[wasm_bindgen(js_name=getDataContract)]
-    pub fn get_data_contract(&self) -> DataContractWasm {
-        self.0.get_data_contract().to_owned().into()
-    }
+    // #[wasm_bindgen(js_name=getDataContract)]
+    // pub fn get_data_contract(&self) -> DataContractWasm {
+    //     self.0.data_contract().to_owned().into()
+    // }
 
     #[wasm_bindgen(js_name=getDataContractId)]
     pub fn get_data_contract_id(&self) -> IdentifierWrapper {
-        self.0.get_data_contract_id().to_owned().into()
+        self.0.data_contract_id().to_owned().into()
     }
 
     #[wasm_bindgen(js_name=setDataContractId)]
@@ -69,16 +73,21 @@ impl DocumentTransitionWasm {
 
     #[wasm_bindgen(js_name=getRevision)]
     pub fn get_revision(&self) -> JsValue {
-        if let Some(revision) = self.0.get_revision() {
+        if let Some(revision) = self.0.revision() {
             (revision as f64).into()
         } else {
             JsValue::NULL
         }
     }
 
+    #[wasm_bindgen(js_name=setRevision)]
+    pub fn set_revision(&mut self, revision: u32) {
+        self.0.set_revision(revision as u64);
+    }
+
     #[wasm_bindgen(js_name=getCreatedAt)]
     pub fn get_created_at(&self) -> JsValue {
-        if let Some(created_at) = self.0.get_created_at() {
+        if let Some(created_at) = self.0.created_at() {
             js_sys::Date::new(&JsValue::from_f64(created_at as f64)).into()
         } else {
             JsValue::NULL
@@ -87,7 +96,7 @@ impl DocumentTransitionWasm {
 
     #[wasm_bindgen(js_name=getUpdatedAt)]
     pub fn get_updated_at(&self) -> JsValue {
-        if let Some(updated_at) = self.0.get_updated_at() {
+        if let Some(updated_at) = self.0.updated_at() {
             js_sys::Date::new(&JsValue::from_f64(updated_at as f64)).into()
         } else {
             JsValue::NULL
@@ -108,126 +117,129 @@ impl DocumentTransitionWasm {
             .set_created_at(created_at.map(|timestamp| timestamp.get_time() as TimestampMillis));
     }
 
-    #[wasm_bindgen(js_name=getData)]
-    pub fn get_data(&self) -> Result<JsValue, JsValue> {
-        if let Some(data) = self.0.get_data() {
-            let (identifier_paths, binary_paths) = self
-                .0
-                .get_data_contract()
-                .get_identifiers_and_binary_paths(self.0.get_document_type())
-                .with_js_error()?;
-
-            let js_value = to_object(
-                data.clone().into(),
-                &JsValue::NULL,
-                identifier_paths,
-                binary_paths,
-            )?;
-            Ok(js_value)
-        } else {
-            Ok(JsValue::NULL)
-        }
-    }
-
-    #[wasm_bindgen(js_name=get)]
-    pub fn get(&self, path: &str) -> JsValue {
-        let binary_type = self.get_binary_type_of_path(path);
-
-        if let Some(value) = self.0.get_dynamic_property(path) {
-            match binary_type {
-                BinaryType::Identifier => {
-                    if let Ok(bytes) = value.to_identifier_bytes() {
-                        let id: IdentifierWrapper = Identifier::from_bytes(&bytes).unwrap().into();
-                        return id.into();
-                    }
-                }
-                BinaryType::Buffer => {
-                    if let Ok(bytes) = value.to_binary_bytes() {
-                        return Buffer::from_bytes(&bytes).into();
-                    }
-                }
-                BinaryType::None => {
-                    let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-                    if let Ok(js_value) = value.serialize(&serializer) {
-                        return js_value;
-                    }
-                }
-            }
-        }
-
-        JsValue::undefined()
-    }
-
-    #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self, options: &JsValue) -> Result<JsValue, JsValue> {
-        match self.0 {
-            DocumentTransition::Create(ref t) => {
-                DocumentCreateTransitionWasm::from(t.to_owned()).to_object(options)
-            }
-            DocumentTransition::Replace(ref t) => {
-                DocumentReplaceTransitionWasm::from(t.to_owned()).to_object(options)
-            }
-            DocumentTransition::Delete(ref t) => {
-                DocumentDeleteTransitionWasm::from(t.to_owned()).to_object(options)
-            }
-        }
-    }
-
-    #[wasm_bindgen(js_name=toJSON)]
-    pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let json_value = self.0.to_json().with_js_error()?;
-        with_js_error!(json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible()))
-    }
-
-    #[wasm_bindgen(js_name=fromTransitionCreate)]
-    pub fn from_transition_create(
-        js_create_transition: DocumentCreateTransitionWasm,
-    ) -> DocumentTransitionWasm {
-        let transition_create: DocumentCreateTransition = js_create_transition.into();
-        let document_transition = DocumentTransition::Create(transition_create);
-
-        document_transition.into()
-    }
-
-    #[wasm_bindgen(js_name=fromTransitionReplace)]
-    pub fn from_transition_replace(
-        js_replace_transition: DocumentReplaceTransitionWasm,
-    ) -> DocumentTransitionWasm {
-        let transition_replace: DocumentReplaceTransition = js_replace_transition.into();
-        let document_transition = DocumentTransition::Replace(transition_replace);
-
-        document_transition.into()
-    }
-
-    #[wasm_bindgen(js_name=fromTransitionDelete)]
-    pub fn from_transition_delete(
-        js_delete_transition: DocumentDeleteTransitionWasm,
-    ) -> DocumentTransitionWasm {
-        let transition_delete: DocumentDeleteTransition = js_delete_transition.into();
-        let document_transition = DocumentTransition::Delete(transition_delete);
-
-        document_transition.into()
-    }
-}
-
-impl DocumentTransitionWasm {
-    fn get_binary_type_of_path(&self, path: impl AsRef<str>) -> BinaryType {
-        let maybe_binary_properties = self
-            .0
-            .get_data_contract()
-            .get_binary_properties(self.0.get_document_type());
-
-        if let Ok(binary_properties) = maybe_binary_properties {
-            if let Some(data) = binary_properties.get(path.as_ref()) {
-                if data.is_type_of_identifier() {
-                    return BinaryType::Identifier;
-                }
-                return BinaryType::Buffer;
-            }
-        }
-        BinaryType::None
-    }
+    // #[wasm_bindgen(js_name=getData)]
+    // pub fn get_data(&self) -> Result<JsValue, JsValue> {
+    //     if let Some(data) = self.0.data() {
+    //         let (identifier_paths, binary_paths) = self
+    //             .0
+    //             .data_contract()
+    //             .get_identifiers_and_binary_paths(self.0.document_type_name())
+    //             .with_js_error()?;
+    //
+    //         let js_value = to_object(
+    //             data.clone().into(),
+    //             &JsValue::NULL,
+    //             identifier_paths,
+    //             binary_paths,
+    //         )?;
+    //         Ok(js_value)
+    //     } else {
+    //         Ok(JsValue::NULL)
+    //     }
+    // }
+    //
+    // #[wasm_bindgen(js_name=get)]
+    // pub fn get(&self, path: &str, data_contract: &DataContractWasm) -> JsValue {
+    //     let binary_type = self.get_binary_type_of_path(path, data_contract);
+    //
+    //     if let Some(value) = self.0.get_dynamic_property(path) {
+    //         match binary_type {
+    //             BinaryType::Identifier => {
+    //                 if let Ok(bytes) = value.to_identifier_bytes() {
+    //                     let id: IdentifierWrapper = Identifier::from_bytes(&bytes).unwrap().into();
+    //                     return id.into();
+    //                 }
+    //             }
+    //             BinaryType::Buffer => {
+    //                 if let Ok(bytes) = value.to_binary_bytes() {
+    //                     return Buffer::from_bytes(&bytes).into();
+    //                 }
+    //             }
+    //             BinaryType::None => {
+    //                 let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+    //                 if let Ok(js_value) = value.serialize(&serializer) {
+    //                     return js_value;
+    //                 }
+    //             }
+    //         }
+    //     }
+    //
+    //     JsValue::undefined()
+    // }
+
+    // #[wasm_bindgen(js_name=toObject)]
+    // pub fn to_object(
+    //     &self,
+    //     options: &JsValue,
+    //     data_contract: &DataContractWasm,
+    // ) -> Result<JsValue, JsValue> {
+    //     match self.0 {
+    //         DocumentTransition::Create(ref t) => DocumentCreateTransitionWasm::from(t.to_owned())
+    //             .to_object(options, data_contract.inner()),
+    //         DocumentTransition::Replace(ref t) => DocumentReplaceTransitionWasm::from(t.to_owned())
+    //             .to_object(options, data_contract.inner()),
+    //         DocumentTransition::Delete(ref t) => DocumentDeleteTransitionWasm::from(t.to_owned())
+    //             .to_object(options, data_contract.inner()),
+    //     }
+    // }
+
+    // #[wasm_bindgen(js_name=toJSON)]
+    // pub fn to_json(&self) -> Result<JsValue, JsValue> {
+    //     let json_value = self.0.to_json().with_js_error()?;
+    //     with_js_error!(json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible()))
+    // }
+    //
+    // #[wasm_bindgen(js_name=fromTransitionCreate)]
+    // pub fn from_transition_create(
+    //     js_create_transition: DocumentCreateTransitionWasm,
+    // ) -> DocumentTransitionWasm {
+    //     let transition_create: DocumentCreateTransition = js_create_transition.into();
+    //     let document_transition = DocumentTransition::Create(transition_create);
+    //
+    //     document_transition.into()
+    // }
+    //
+    // #[wasm_bindgen(js_name=fromTransitionReplace)]
+    // pub fn from_transition_replace(
+    //     js_replace_transition: DocumentReplaceTransitionWasm,
+    // ) -> DocumentTransitionWasm {
+    //     let transition_replace: DocumentReplaceTransition = js_replace_transition.into();
+    //     let document_transition = DocumentTransition::Replace(transition_replace);
+    //
+    //     document_transition.into()
+    // }
+    //
+    // #[wasm_bindgen(js_name=fromTransitionDelete)]
+    // pub fn from_transition_delete(
+    //     js_delete_transition: DocumentDeleteTransitionWasm,
+    // ) -> DocumentTransitionWasm {
+    //     let transition_delete: DocumentDeleteTransition = js_delete_transition.into();
+    //     let document_transition = DocumentTransition::Delete(transition_delete);
+    //
+    //     document_transition.into()
+    // }
 }
+//
+// impl DocumentTransitionWasm {
+//     fn get_binary_type_of_path(
+//         &self,
+//         path: impl AsRef<str>,
+//         data_contract: DataContractWasm,
+//     ) -> Result<BinaryType, JsValue> {
+//         let document_type = data_contract
+//             .inner()
+//             .document_type_for_name(self.0.document_type_name().as_str())
+//             .with_js_error()?;
+//
+//         if document_type.binary_paths().contains(&path) {
+//             Ok(BinaryType::Buffer)
+//         } else if document_type.identifier_paths().contains(&path) {
+//             Ok(BinaryType::Identifier)
+//         } else {
+//             Ok(BinaryType::None)
+//         }
+//     }
+// }
 
 impl From<DocumentTransition> for DocumentTransitionWasm {
     fn from(v: DocumentTransition) -> Self {
@@ -257,19 +269,19 @@ impl Inner for DocumentTransitionWasm {
     }
 }
 
-pub fn from_document_transition_to_js_value(document_transition: DocumentTransition) -> JsValue {
-    match document_transition {
-        DocumentTransition::Create(create_transition) => {
-            DocumentCreateTransitionWasm::from(create_transition).into()
-        }
-        DocumentTransition::Replace(replace_transition) => {
-            DocumentReplaceTransitionWasm::from(replace_transition).into()
-        }
-        DocumentTransition::Delete(delete_transition) => {
-            DocumentDeleteTransitionWasm::from(delete_transition).into()
-        }
-    }
-}
+// pub fn from_document_transition_to_js_value(document_transition: DocumentTransition) -> JsValue {
+//     match document_transition {
+//         DocumentTransition::Create(create_transition) => {
+//             DocumentCreateTransitionWasm::from(create_transition).into()
+//         }
+//         DocumentTransition::Replace(replace_transition) => {
+//             DocumentReplaceTransitionWasm::from(replace_transition).into()
+//         }
+//         DocumentTransition::Delete(delete_transition) => {
+//             DocumentDeleteTransitionWasm::from(delete_transition).into()
+//         }
+//     }
+// }
 
 pub(crate) fn to_object<'a>(
     value: Value,
@@ -292,7 +304,7 @@ pub(crate) fn to_object<'a>(
     let js_value = value.serialize(&serializer)?;
 
     for path in identifiers_paths.into_iter() {
-        if let Ok(bytes) = value.remove_value_at_path_into::<Vec<u8>>(path) {
+        if let Ok(bytes) = value.remove_value_at_path_into::<Vec<u8>>(path.clone()) {
             let buffer = Buffer::from_bytes_owned(bytes);
             if !options.skip_identifiers_conversion {
                 lodash_set(&js_value, path, buffer.into());