@dashevo/wasm-dpp 0.24.0-dev.12 → 0.24.0-dev.13

package/src/document/factory.rs

@@ -0,0 +1,192 @@
+use std::sync::Arc;
+
+use dpp::{
+    document::{
+        self,
+        document_factory::{DocumentFactory, FactoryOptions},
+        document_transition::Action,
+        fetch_and_validate_data_contract::DataContractFetcherAndValidator,
+    },
+    util::json_value::{JsonValueExt, ReplaceWith},
+};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    identifier::identifier_from_js_value,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    utils::{ToSerdeJSONExt, WithJsError},
+    DataContractWasm, DocumentWasm, DocumentsBatchTransitionWASM, DocumentsContainer,
+};
+
+use super::validator::DocumentValidatorWasm;
+
+#[wasm_bindgen(js_name=DocumentTransitions)]
+#[derive(Debug, Default)]
+pub struct DocumentTransitions {
+    create: Vec<DocumentWasm>,
+    replace: Vec<DocumentWasm>,
+    delete: Vec<DocumentWasm>,
+}
+
+#[wasm_bindgen(js_class=DocumentTransitions)]
+impl DocumentTransitions {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    #[wasm_bindgen(js_name = "addTransitionCreate")]
+    pub fn add_transition_create(&mut self, transition: DocumentWasm) {
+        self.create.push(transition)
+    }
+
+    #[wasm_bindgen(js_name = "addTransitionReplace")]
+    pub fn add_transition_replace(&mut self, transition: DocumentWasm) {
+        self.replace.push(transition)
+    }
+
+    #[wasm_bindgen(js_name = "addTransitionDelete")]
+    pub fn add_transition_delete(&mut self, transition: DocumentWasm) {
+        self.delete.push(transition)
+    }
+}
+
+#[wasm_bindgen(js_name = DocumentFactory)]
+pub struct DocumentFactoryWASM(DocumentFactory<ExternalStateRepositoryLikeWrapper>);
+
+#[wasm_bindgen(js_class=DocumentFactory)]
+impl DocumentFactoryWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        protocol_version: u32,
+        document_validator: DocumentValidatorWasm,
+        state_repository: ExternalStateRepositoryLike,
+    ) -> DocumentFactoryWASM {
+        console_error_panic_hook::set_once();
+        let factory = DocumentFactory::new(
+            protocol_version,
+            document_validator.into(),
+            DataContractFetcherAndValidator::new(Arc::new(
+                ExternalStateRepositoryLikeWrapper::new(state_repository),
+            )),
+        );
+
+        DocumentFactoryWASM(factory)
+    }
+
+    #[wasm_bindgen(js_name=create)]
+    pub fn create(
+        &self,
+        data_contract: DataContractWasm,
+        js_owner_id: &JsValue,
+        document_type: &str,
+        data: &JsValue,
+    ) -> Result<DocumentWasm, JsValue> {
+        let owner_id = identifier_from_js_value(js_owner_id)?;
+        let dynamic_data = data.with_serde_to_json_value()?;
+        let document = self
+            .0
+            .create(
+                data_contract.into(),
+                owner_id,
+                document_type.to_string(),
+                dynamic_data,
+            )
+            .with_js_error()?;
+
+        Ok(document.into())
+    }
+
+    #[wasm_bindgen(js_name=createStateTransition)]
+    pub fn create_state_transition(
+        &self,
+        documents_container: DocumentsContainer,
+    ) -> Result<DocumentsBatchTransitionWASM, JsValue> {
+        let mut documents_container = documents_container;
+
+        let batch_transition = self
+            .0
+            .create_state_transition([
+                (Action::Create, documents_container.take_documents_create()),
+                (
+                    Action::Replace,
+                    documents_container.take_documents_replace(),
+                ),
+                (Action::Delete, documents_container.take_documents_delete()),
+            ])
+            .with_js_error()?;
+
+        Ok(batch_transition.into())
+    }
+
+    #[wasm_bindgen(js_name=createFromObject)]
+    pub async fn create_from_object(
+        &self,
+        raw_document_js: JsValue,
+        options: JsValue,
+    ) -> Result<DocumentWasm, JsValue> {
+        let mut raw_document = raw_document_js.with_serde_to_json_value()?;
+        let options: FactoryOptions = if !options.is_undefined() && options.is_object() {
+            let raw_options = options.with_serde_to_json_value()?;
+            serde_json::from_value(raw_options).with_js_error()?
+        } else {
+            Default::default()
+        };
+
+        // Errors are ignored. When `Buffer` crosses the WASM boundary it becomes an Array.
+        // When `Identifier` crosses the WASM boundary, it becomes a String. From perspective of JS
+        // `Identifier` and `Buffer` are used interchangeably, so we we can expect the replacing may fail when `Buffer` is provided
+        let _ = raw_document
+            .replace_identifier_paths(document::IDENTIFIER_FIELDS, ReplaceWith::Bytes)
+            .with_js_error();
+
+        let mut document = self
+            .0
+            .create_from_object(raw_document, options)
+            .await
+            .with_js_error()?;
+
+        // When data contract is available, replace remaining dynamic paths
+        let mut document_data = document.data.take();
+        let (identifier_paths, binary_paths) = document
+            .get_identifiers_and_binary_paths()
+            .with_js_error()?;
+        document_data
+            .replace_identifier_paths(identifier_paths, ReplaceWith::Bytes)
+            .with_js_error()?;
+        document_data
+            .replace_binary_paths(binary_paths, ReplaceWith::Bytes)
+            .with_js_error()?;
+        document.data = document_data;
+
+        Ok(document.into())
+    }
+
+    #[wasm_bindgen(js_name=createFromBuffer)]
+    pub async fn create_from_buffer(
+        &self,
+        buffer: Vec<u8>,
+        options: &JsValue,
+    ) -> Result<DocumentWasm, JsValue> {
+        let options: FactoryOptions = if !options.is_undefined() && options.is_object() {
+            let raw_options = options.with_serde_to_json_value()?;
+            serde_json::from_value(raw_options).with_js_error()?
+        } else {
+            Default::default()
+        };
+
+        let document = self
+            .0
+            .create_from_buffer(buffer, options)
+            .await
+            .with_js_error()?;
+
+        Ok(document.into())
+    }
+}
+
+impl DocumentFactoryWASM {
+    pub(crate) fn into_inner(self) -> DocumentFactory<ExternalStateRepositoryLikeWrapper> {
+        self.0
+    }
+}

package/src/document/mod.rs

@@ -1,17 +1,44 @@
-use std::convert::TryInto;
-
+use dpp::dashcore::anyhow::Context;
+use dpp::prelude::Identifier;
+use dpp::util::json_schema::JsonSchemaExt;
+use dpp::util::json_value::{JsonValueExt, ReplaceWith};
+use dpp::util::string_encoding::Encoding;
 use serde::{Deserialize, Serialize};
+use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
 
-use dpp::document::Document;
+use dpp::document::{property_names, Document, IDENTIFIER_FIELDS};
 
-use crate::errors::{from_dpp_err, RustConversionError};
+use crate::buffer::Buffer;
+use crate::errors::RustConversionError;
 use crate::identifier::IdentifierWrapper;
+use crate::lodash::lodash_set;
+use crate::utils::WithJsError;
+use crate::utils::{with_serde_to_json_value, ToSerdeJSONExt};
 use crate::with_js_error;
 use crate::{DataContractWasm, MetadataWasm};
 
 pub mod errors;
+pub use state_transition::*;
+mod factory;
 pub mod state_transition;
+mod validator;
+
+pub use document_batch_transition::{DocumentsBatchTransitionWASM, DocumentsContainer};
+pub use factory::DocumentFactoryWASM;
+pub use validator::DocumentValidatorWasm;
+
+pub(super) enum BinaryType {
+    Identifier,
+    Buffer,
+    None,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct ConversionOptions {
+    skip_identifiers_conversion: bool,
+}
 
 #[wasm_bindgen(js_name=Document)]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -19,6 +46,40 @@ pub struct DocumentWasm(Document);
 
 #[wasm_bindgen(js_class=Document)]
 impl DocumentWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        js_raw_document: JsValue,
+        js_data_contract: &DataContractWasm,
+    ) -> Result<DocumentWasm, JsValue> {
+        let mut raw_document = with_serde_to_json_value(&js_raw_document)?;
+
+        let document_type = raw_document
+            .get_string(property_names::DOCUMENT_TYPE)
+            .with_js_error()?;
+
+        let (identifier_paths, _) = js_data_contract
+            .inner()
+            .get_identifiers_and_binary_paths(document_type)
+            .with_js_error()?;
+
+        // Errors are ignored. When `Buffer` crosses the WASM boundary it becomes an Array.
+        // When `Identifier` crosses the WASM boundary it becomes a String. From perspective of JS
+        // `Identifier` and `Buffer` are used interchangeably, so we we can expect the replacing may fail when `Buffer` is provided
+        let _ = raw_document
+            .replace_identifier_paths(
+                identifier_paths.into_iter().chain(IDENTIFIER_FIELDS),
+                ReplaceWith::Bytes,
+            )
+            .with_js_error();
+        // The binary paths are not being converted, because they always should be a `Buffer`. `Buffer` is always an Array
+
+        let document =
+            Document::from_raw_document(raw_document, js_data_contract.to_owned().into())
+                .with_js_error()?;
+
+        Ok(document.into())
+    }
+
     #[wasm_bindgen(js_name=getProtocolVersion)]
     pub fn get_protocol_version(&self) -> u32 {
         self.0.protocol_version
@@ -29,6 +90,11 @@ impl DocumentWasm {
         self.0.id.clone().into()
     }
 
+    #[wasm_bindgen(js_name=setId)]
+    pub fn set_id(&mut self, js_id: IdentifierWrapper) {
+        self.0.id = js_id.inner();
+    }
+
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> String {
         self.0.document_type.clone()
@@ -44,6 +110,11 @@ impl DocumentWasm {
         self.0.data_contract.clone().into()
     }
 
+    #[wasm_bindgen(js_name=setOwnerId)]
+    pub fn set_owner_id(&mut self, owner_id: IdentifierWrapper) {
+        self.0.owner_id = owner_id.inner();
+    }
+
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
         self.0.owner_id.clone().into()
@@ -72,8 +143,8 @@ impl DocumentWasm {
     }
 
     #[wasm_bindgen(js_name=getEntropy)]
-    pub fn get_entropy(&mut self) -> Vec<u8> {
-        self.0.entropy.to_vec()
+    pub fn get_entropy(&mut self) -> Buffer {
+        Buffer::from_bytes(&self.0.entropy)
     }
 
     #[wasm_bindgen(js_name=setData)]
@@ -84,39 +155,98 @@ impl DocumentWasm {
 
     #[wasm_bindgen(js_name=getData)]
     pub fn get_data(&mut self) -> Result<JsValue, JsValue> {
-        with_js_error!(serde_wasm_bindgen::to_value(&self.0.data))
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        Ok(with_js_error!(self.0.get_data().serialize(&serializer))?)
     }
 
     #[wasm_bindgen(js_name=set)]
-    pub fn set(&mut self, _path: String, _d: JsValue) {
-        // TODO use lodash via extern
-        unimplemented!()
+    pub fn set(&mut self, path: String, js_value_to_set: JsValue) -> Result<(), JsValue> {
+        let (identifier_paths, _) = self.0.get_identifiers_and_binary_paths().with_js_error()?;
+        for property_path in identifier_paths {
+            if property_path == path {
+                let id_value = js_value_to_set.with_serde_to_json_value()?;
+                let id_string = id_value
+                    .as_str()
+                    .context("the value must be a string")
+                    .with_js_error()?;
+                let id = Identifier::from_string(id_string, Encoding::Base58).with_js_error()?;
+                let new_value = serde_json::to_value(id.as_bytes()).with_js_error()?;
+
+                return self.0.set(&path, new_value).with_js_error();
+            } else if property_path.starts_with(&path) {
+                let (_, suffix) = property_path.split_at(path.len() + 1);
+                let mut value = js_value_to_set.with_serde_to_json_value()?;
+
+                if value.get_value(suffix).is_ok() {
+                    let id_string = value
+                        .remove_path_into::<String>(suffix)
+                        .with_context(|| format!("unable convert `{path}` into string"))
+                        .map_err(|e| format!("{e:#}"))?;
+                    let id: IdentifierWrapper =
+                        Identifier::from_string(&id_string, Encoding::Base58)
+                            .with_js_error()?
+                            .into();
+                    let new_value = serde_json::to_value(id.inner().as_bytes()).with_js_error()?;
+                    value.insert_with_path(suffix, new_value).with_js_error()?;
+
+                    return self.0.set(&path, value).with_js_error();
+                }
+            }
+        }
+
+        let value = js_value_to_set.with_serde_to_json_value()?;
+        self.0.set(&path, value).with_js_error()
     }
 
     #[wasm_bindgen(js_name=get)]
-    pub fn get(&mut self, _path: String) -> JsValue {
-        // TODO use lodash via extern
-        unimplemented!()
+    pub fn get(&mut self, path: String) -> JsValue {
+        let binary_type = self.get_binary_type_of_path(&path);
+
+        if let Some(value) = self.0.get(&path) {
+            match binary_type {
+                BinaryType::Identifier => {
+                    if let Ok(bytes) = serde_json::from_value::<Vec<u8>>(value.to_owned()) {
+                        let id: IdentifierWrapper = Identifier::from_bytes(&bytes).unwrap().into();
+
+                        return id.into();
+                    }
+                }
+                BinaryType::Buffer => {
+                    if let Ok(bytes) = serde_json::from_value::<Vec<u8>>(value.to_owned()) {
+                        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=setCreatedAt)]
-    pub fn set_created_at(&mut self, ts: i64) {
-        self.0.created_at = Some(ts);
+    pub fn set_created_at(&mut self, ts: f64) {
+        self.0.created_at = Some(ts as i64);
     }
 
     #[wasm_bindgen(js_name=setUpdatedAt)]
-    pub fn set_updated_at(&mut self, ts: i64) {
-        self.0.updated_at = Some(ts);
+    pub fn set_updated_at(&mut self, ts: f64) {
+        self.0.updated_at = Some(ts as i64);
     }
 
     #[wasm_bindgen(js_name=getCreatedAt)]
-    pub fn get_created_at(&self) -> Option<i64> {
-        self.0.created_at
+    pub fn get_created_at(&self) -> Option<f64> {
+        self.0.created_at.map(|v| v as f64)
     }
 
     #[wasm_bindgen(js_name=getUpdatedAt)]
-    pub fn get_updated_at(&self) -> Option<i64> {
-        self.0.updated_at
+    pub fn get_updated_at(&self) -> Option<f64> {
+        self.0.updated_at.map(|v| v as f64)
     }
 
     #[wasm_bindgen(js_name=getMetadata)]
@@ -125,29 +255,91 @@ impl DocumentWasm {
     }
 
     #[wasm_bindgen(js_name=setMetadata)]
-    pub fn set_metadata(&mut self, metadata: MetadataWasm) {
+    pub fn set_metadata(mut self, metadata: MetadataWasm) -> Self {
         self.0.metadata = Some(metadata.into());
+        self
     }
 
     #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self) -> Result<JsValue, JsValue> {
-        with_js_error!(serde_wasm_bindgen::to_value(&self.0))
+    pub fn to_object(&self, options: &JsValue) -> Result<JsValue, JsValue> {
+        let options: ConversionOptions = if !options.is_undefined() && options.is_object() {
+            let raw_options = options.with_serde_to_json_value()?;
+            serde_json::from_value(raw_options).with_js_error()?
+        } else {
+            Default::default()
+        };
+        let mut value = self.0.to_object().with_js_error()?;
+
+        let (identifiers_paths, binary_paths) =
+            self.0.get_identifiers_and_binary_paths().with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let js_value = value.serialize(&serializer)?;
+
+        for path in identifiers_paths.into_iter().chain(IDENTIFIER_FIELDS) {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                if !options.skip_identifiers_conversion {
+                    let buffer = Buffer::from_bytes(&bytes);
+                    lodash_set(&js_value, path, buffer.into());
+                } else {
+                    let id = IdentifierWrapper::new(bytes)?;
+                    lodash_set(&js_value, path, id.into());
+                }
+            }
+        }
+
+        for path in binary_paths {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let buffer = Buffer::from_bytes(&bytes);
+                lodash_set(&js_value, path, buffer.into());
+            }
+        }
+
+        Ok(js_value)
     }
 
     #[wasm_bindgen(js_name=toJSON)]
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        self.to_object()
+        let value = self.0.to_json().with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        with_js_error!(value.serialize(&serializer))
     }
 
     #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self) -> Result<Vec<u8>, JsValue> {
-        let buffer = self.0.to_buffer().map_err(from_dpp_err)?;
-        Ok(buffer)
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes = self.0.to_buffer().with_js_error()?;
+
+        Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=hash)]
-    pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
-        self.0.hash().map_err(from_dpp_err)
+    pub fn hash(&self) -> Result<Buffer, JsValue> {
+        let bytes = self.0.hash().with_js_error()?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen(js_name=clone)]
+    pub fn deep_clone(&self) -> Self {
+        self.clone()
+    }
+}
+
+impl DocumentWasm {
+    fn get_binary_type_of_path(&self, path: &String) -> BinaryType {
+        let maybe_binary_properties = self
+            .0
+            .data_contract
+            .get_binary_properties(&self.0.document_type);
+
+        if let Ok(binary_properties) = maybe_binary_properties {
+            if let Some(data) = binary_properties.get(path) {
+                if data.is_type_of_identifier() {
+                    return BinaryType::Identifier;
+                }
+                return BinaryType::Buffer;
+            }
+        }
+        BinaryType::None
     }
 }
 

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

@@ -1,6 +1,16 @@
-use dpp::document::document_transition::DocumentCreateTransition;
+use dpp::{
+    document::document_transition::{
+        document_create_transition, DocumentCreateTransition, DocumentTransitionObjectLike,
+    },
+    util::json_value::JsonValueExt,
+};
+use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
+use crate::{
+    buffer::Buffer, identifier::IdentifierWrapper, lodash::lodash_set, utils::WithJsError,
+};
+
 #[wasm_bindgen(js_name=DocumentCreateTransition)]
 #[derive(Debug, Clone)]
 pub struct DocumentCreateTransitionWasm {
@@ -19,4 +29,40 @@ impl DocumentCreateTransitionWasm {
     pub fn action(&self) -> u8 {
         self.inner.base.action as u8
     }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let mut value = self.inner.to_object().with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let js_value = value.serialize(&serializer)?;
+
+        let (identifiers_paths, binary_paths) = self
+            .inner
+            .base
+            .data_contract
+            .get_identifiers_and_binary_paths(&self.inner.base.document_type)
+            .with_js_error()?;
+
+        for path in identifiers_paths
+            .into_iter()
+            .chain(document_create_transition::IDENTIFIER_FIELDS)
+        {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let id = IdentifierWrapper::new(bytes)?;
+                lodash_set(&js_value, path, id.into());
+            }
+        }
+
+        for path in binary_paths
+            .into_iter()
+            .chain(document_create_transition::BINARY_FIELDS)
+        {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let buffer = Buffer::from_bytes(&bytes);
+                lodash_set(&js_value, path, buffer.into());
+            }
+        }
+
+        Ok(js_value)
+    }
 }

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

@@ -1,6 +1,14 @@
-use dpp::document::document_transition::DocumentDeleteTransition;
+use dpp::{
+    document::document_transition::{
+        document_delete_transition, DocumentDeleteTransition, DocumentTransitionObjectLike,
+    },
+    util::json_value::JsonValueExt,
+};
+use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
+use crate::{identifier::IdentifierWrapper, lodash::lodash_set, utils::WithJsError};
+
 #[wasm_bindgen(js_name=DocumentDeleteTransition)]
 #[derive(Debug, Clone)]
 pub struct DocumentDeleteTransitionWasm {
@@ -19,4 +27,20 @@ impl DocumentDeleteTransitionWasm {
     pub fn action(&self) -> u8 {
         self.inner.base.action as u8
     }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let mut value = self.inner.to_object().with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let js_value = value.serialize(&serializer)?;
+
+        for field in document_delete_transition::IDENTIFIER_FIELDS {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(field) {
+                let id = IdentifierWrapper::new(bytes)?;
+                lodash_set(&js_value, field, id.into());
+            }
+        }
+
+        Ok(js_value)
+    }
 }

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

@@ -0,0 +1,65 @@
+use dpp::{
+    document::document_transition::{
+        document_replace_transition, DocumentReplaceTransition, DocumentTransitionObjectLike,
+    },
+    util::json_value::JsonValueExt,
+};
+use serde::Serialize;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    buffer::Buffer, identifier::IdentifierWrapper, lodash::lodash_set, utils::WithJsError,
+};
+
+#[wasm_bindgen(js_name=DocumentTransition)]
+#[derive(Debug, Clone)]
+pub struct DocumentReplaceTransitionWasm {
+    inner: DocumentReplaceTransition,
+}
+
+impl From<DocumentReplaceTransition> for DocumentReplaceTransitionWasm {
+    fn from(v: DocumentReplaceTransition) -> Self {
+        Self { inner: v }
+    }
+}
+
+#[wasm_bindgen(js_class=DocumentTransition)]
+impl DocumentReplaceTransitionWasm {
+    #[wasm_bindgen(js_name=getAction)]
+    pub fn action(&self) -> u8 {
+        self.inner.base.action as u8
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let mut value = self.inner.to_object().with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let js_value = value.serialize(&serializer)?;
+
+        let (identifiers_paths, binary_paths) = self
+            .inner
+            .base
+            .data_contract
+            .get_identifiers_and_binary_paths(&self.inner.base.document_type)
+            .with_js_error()?;
+
+        for path in identifiers_paths
+            .into_iter()
+            .chain(document_replace_transition::IDENTIFIER_FIELDS)
+        {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let id = IdentifierWrapper::new(bytes)?;
+                lodash_set(&js_value, path, id.into());
+            }
+        }
+
+        for path in binary_paths.into_iter() {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let buffer = Buffer::from_bytes(&bytes);
+                lodash_set(&js_value, path, buffer.into());
+            }
+        }
+
+        Ok(js_value)
+    }
+}