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

package/src/data_contract_factory/data_contract_factory.rs

@@ -1,68 +1,21 @@
+use std::convert::TryFrom;
 use std::sync::Arc;
 
-use dpp::{
-    data_contract::{
-        validation::data_contract_validator::DataContractValidator, DataContractFactory,
-    },
-    platform_value,
-    prelude::Identifier,
-    version::ProtocolVersionValidator,
-    ProtocolError,
-};
+use dpp::data_contract::created_data_contract::CreatedDataContract;
+use dpp::{data_contract::DataContractFactory, platform_value, prelude::Identifier, ProtocolError};
 use wasm_bindgen::prelude::*;
 
 use crate::entropy_generator::ExternalEntropyGenerator;
-use crate::utils::WithJsError;
+use crate::utils::{ToSerdeJSONExt, WithJsError};
 
+use crate::data_contract::{DataContractCreateTransitionWasm, DataContractWasm};
 use crate::{
     data_contract::errors::InvalidDataContractError,
     errors::{from_dpp_err, protocol_error::from_protocol_error},
-    js_value_to_data_contract_value,
-    validation::ValidationResultWasm,
-    with_js_error, DataContractCreateTransitionWasm, DataContractParameters, DataContractWasm,
+    with_js_error,
 };
 
-#[wasm_bindgen(js_name=DataContractValidator)]
-pub struct DataContractValidatorWasm(DataContractValidator);
-
-impl From<DataContractValidator> for DataContractValidatorWasm {
-    fn from(v: DataContractValidator) -> Self {
-        DataContractValidatorWasm(v)
-    }
-}
-
-impl From<DataContractValidatorWasm> for DataContractValidator {
-    fn from(val: DataContractValidatorWasm) -> Self {
-        val.0
-    }
-}
-
-impl Default for DataContractValidatorWasm {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[wasm_bindgen(js_class=DataContractValidator)]
-impl DataContractValidatorWasm {
-    #[wasm_bindgen(constructor)]
-    pub fn new() -> Self {
-        DataContractValidator::new(std::sync::Arc::new(ProtocolVersionValidator::default())).into()
-    }
-
-    #[wasm_bindgen]
-    pub fn validate(&self, raw_data_contract: JsValue) -> Result<ValidationResultWasm, JsValue> {
-        let parameters: DataContractParameters =
-            with_js_error!(serde_wasm_bindgen::from_value(raw_data_contract))?;
-        let platform_object = platform_value::to_value(parameters).expect("Implements Serialize");
-
-        let validation_result = self
-            .0
-            .validate(&platform_object)
-            .map_err(from_protocol_error)?;
-        Ok(validation_result.map(|_| JsValue::undefined()).into())
-    }
-}
+use dpp::util::entropy_generator::EntropyGenerator;
 
 #[wasm_bindgen(js_name=DataContractFactory)]
 pub struct DataContractFactoryWasm(DataContractFactory);
@@ -84,18 +37,15 @@ impl DataContractFactoryWasm {
     #[wasm_bindgen(constructor)]
     pub fn new(
         protocol_version: u32,
-        validate_data_contract: DataContractValidatorWasm,
         external_entropy_generator_arg: Option<ExternalEntropyGenerator>,
     ) -> DataContractFactoryWasm {
         if let Some(external_entropy_generator) = external_entropy_generator_arg {
-            DataContractFactory::new_with_entropy_generator(
-                protocol_version,
-                Arc::new(validate_data_contract.into()),
-                Box::new(external_entropy_generator),
-            )
+            DataContractFactory::new(protocol_version, Some(Box::new(external_entropy_generator)))
         } else {
-            DataContractFactory::new(protocol_version, Arc::new(validate_data_contract.into()))
+            DataContractFactory::new(protocol_version, None)
         }
+        .with_js_error()
+        .expect("should create a factory")
         .into()
     }
 
@@ -104,38 +54,47 @@ impl DataContractFactoryWasm {
         &self,
         owner_id: Vec<u8>,
         documents: JsValue,
+        config: JsValue,
     ) -> Result<DataContractWasm, JsValue> {
         let documents_object: platform_value::Value =
             with_js_error!(serde_wasm_bindgen::from_value(documents))?;
+
+        let contract_config = if config.is_object() && !config.is_falsy() {
+            let raw_config = config.with_serde_to_json_value()?;
+            Some(serde_json::from_value(raw_config).with_js_error()?)
+        } else {
+            None
+        };
+
         let identifier = Identifier::from_bytes(&owner_id)
             .map_err(ProtocolError::ValueError)
             .with_js_error()?;
         //todo: contract config
         self.0
-            .create(identifier, documents_object, None, None)
+            .create_with_value_config(identifier, documents_object, contract_config, None)
             .map(Into::into)
             .with_js_error()
     }
 
-    #[wasm_bindgen(js_name=createFromObject)]
-    pub async fn create_from_object(
-        &self,
-        object: JsValue,
-        skip_validation: Option<bool>,
-    ) -> Result<DataContractWasm, JsValue> {
-        let parameters_value = js_value_to_data_contract_value(object.clone())?;
-        let result = self
-            .0
-            .create_from_object(parameters_value, skip_validation.unwrap_or(false))
-            .await;
-        match result {
-            Ok(data_contract) => Ok(data_contract.into()),
-            Err(dpp::ProtocolError::InvalidDataContractError(err)) => {
-                Err(InvalidDataContractError::new(err.errors, object).into())
-            }
-            Err(other) => Err(from_dpp_err(other)),
-        }
-    }
+    // #[wasm_bindgen(js_name=createFromObject)]
+    // pub async fn create_from_object(
+    //     &self,
+    //     object: JsValue,
+    //     skip_validation: Option<bool>,
+    // ) -> Result<DataContractWasm, JsValue> {
+    //     let parameters_value = js_value_to_data_contract_value(object.clone())?;
+    //     let result = self
+    //         .0
+    //         .create_from_object(parameters_value, skip_validation.unwrap_or(false))
+    //         .await;
+    //     match result {
+    //         Ok(data_contract) => Ok(data_contract.into()),
+    //         Err(dpp::ProtocolError::InvalidDataContractError(err)) => {
+    //             Err(InvalidDataContractError::new(err.errors, object).into())
+    //         }
+    //         Err(other) => Err(from_dpp_err(other)),
+    //     }
+    // }
 
     #[wasm_bindgen(js_name=createFromBuffer)]
     pub async fn create_from_buffer(
@@ -145,7 +104,6 @@ impl DataContractFactoryWasm {
     ) -> Result<DataContractWasm, JsValue> {
         self.0
             .create_from_buffer(buffer, skip_validation.unwrap_or(false))
-            .await
             .map(Into::into)
             .map_err(from_protocol_error)
     }
@@ -156,7 +114,9 @@ impl DataContractFactoryWasm {
         data_contract: &DataContractWasm,
     ) -> Result<DataContractCreateTransitionWasm, JsValue> {
         self.0
-            .create_data_contract_create_transition(data_contract.clone().into())
+            .create_data_contract_create_transition(
+                CreatedDataContract::try_from(data_contract).with_js_error()?,
+            )
             .map(Into::into)
             .with_js_error()
     }

package/src/document/document_facade.rs

@@ -2,32 +2,31 @@ use std::sync::Arc;
 
 use wasm_bindgen::{prelude::*, JsValue};
 
+use crate::document::factory::DocumentFactoryWASM;
 use crate::{
-    fetch_and_validate_data_contract::DataContractFetcherAndValidatorWasm,
     utils::{get_class_name, IntoWasm},
-    validation::ValidationResultWasm,
-    DataContractWasm, DocumentFactoryWASM, DocumentValidatorWasm, DocumentsBatchTransitionWasm,
-    ExtendedDocumentWasm,
+    DataContractWasm, ExtendedDocumentWasm,
 };
 
+use crate::document::state_transition::document_batch_transition::DocumentsBatchTransitionWasm;
+
 #[derive(Clone)]
 #[wasm_bindgen(js_name=DocumentFacade)]
 pub struct DocumentFacadeWasm {
-    validator: Arc<DocumentValidatorWasm>,
+    // validator: Arc<DocumentValidatorWasm>,
     factory: Arc<DocumentFactoryWASM>,
-    data_contract_fetcher_and_validator: Arc<DataContractFetcherAndValidatorWasm>,
+    // data_contract_fetcher_and_validator: Arc<DataContractFetcherAndValidatorWasm>,
 }
 
 impl DocumentFacadeWasm {
     pub fn new_with_arc(
-        document_validator: Arc<DocumentValidatorWasm>,
+        // document_validator: Arc<DocumentValidatorWasm>,
         document_factory: Arc<DocumentFactoryWASM>,
-        data_contract_fetcher_and_validator: Arc<DataContractFetcherAndValidatorWasm>,
+        // data_contract_fetcher_and_validator: Arc<DataContractFetcherAndValidatorWasm>,
     ) -> Self {
         Self {
-            validator: document_validator,
             factory: document_factory,
-            data_contract_fetcher_and_validator,
+            // data_contract_fetcher_and_validator,
         }
     }
 }
@@ -35,15 +34,9 @@ impl DocumentFacadeWasm {
 #[wasm_bindgen(js_class=DocumentFacade)]
 impl DocumentFacadeWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(
-        document_validator: DocumentValidatorWasm,
-        document_factory: DocumentFactoryWASM,
-        data_contract_fetcher_and_validator: DataContractFetcherAndValidatorWasm,
-    ) -> Self {
+    pub fn new(document_factory: DocumentFactoryWASM) -> Self {
         Self {
-            validator: Arc::new(document_validator),
             factory: Arc::new(document_factory),
-            data_contract_fetcher_and_validator: Arc::new(data_contract_fetcher_and_validator),
         }
     }
 
@@ -58,35 +51,47 @@ impl DocumentFacadeWasm {
         self.factory
             .create(data_contract, js_owner_id, document_type, data)
     }
+    //
+    // /// Creates Document from object
+    // #[wasm_bindgen(js_name=createFromObject)]
+    // pub async fn create_from_object(
+    //     &self,
+    //     raw_document: JsValue,
+    //     options: Option<js_sys::Object>,
+    // ) -> Result<ExtendedDocumentWasm, JsValue> {
+    //     self.factory
+    //         .create_from_object(
+    //             raw_document,
+    //             options.map(Into::into).unwrap_or(JsValue::undefined()),
+    //         )
+    //         .await
+    // }
+    //
+    // /// Creates Document form bytes
+    // #[wasm_bindgen(js_name=createFromBuffer)]
+    // pub async fn create_from_buffer(
+    //     &self,
+    //     bytes: Vec<u8>,
+    //     options: Option<js_sys::Object>,
+    // ) -> Result<ExtendedDocumentWasm, JsValue> {
+    //     self.factory
+    //         .create_from_buffer(
+    //             bytes,
+    //             &options.map(Into::into).unwrap_or(JsValue::undefined()),
+    //         )
+    //         .await
+    // }
 
-    /// Creates Document from object
-    #[wasm_bindgen(js_name=createFromObject)]
-    pub async fn create_from_object(
-        &self,
-        raw_document: JsValue,
-        options: Option<js_sys::Object>,
-    ) -> Result<ExtendedDocumentWasm, JsValue> {
-        self.factory
-            .create_from_object(
-                raw_document,
-                options.map(Into::into).unwrap_or(JsValue::undefined()),
-            )
-            .await
-    }
-
-    /// Creates Document form bytes
-    #[wasm_bindgen(js_name=createFromBuffer)]
-    pub async fn create_from_buffer(
+    // TODO(rs-drive-abci): add tests
+    #[wasm_bindgen(js_name=createExtendedDocumentFromDocumentBuffer)]
+    pub fn create_extended_from_document_buffer(
         &self,
-        bytes: Vec<u8>,
-        options: Option<js_sys::Object>,
+        buffer: Vec<u8>,
+        document_type: &str,
+        data_contract: &DataContractWasm,
     ) -> Result<ExtendedDocumentWasm, JsValue> {
         self.factory
-            .create_from_buffer(
-                bytes,
-                &options.map(Into::into).unwrap_or(JsValue::undefined()),
-            )
-            .await
+            .create_extended_from_document_buffer(buffer, document_type, data_contract)
     }
 
     /// Creates Documents State Transition
@@ -98,38 +103,38 @@ impl DocumentFacadeWasm {
         self.factory.create_state_transition(documents)
     }
 
-    /// Creates Documents State Transition
-    #[wasm_bindgen(js_name=validate)]
-    pub async fn validate_document(
-        &self,
-        document: &JsValue,
-    ) -> Result<ValidationResultWasm, JsValue> {
-        let raw_document = if get_class_name(document) == "ExtendedDocument" {
-            let document = document.to_wasm::<ExtendedDocumentWasm>("ExtendedDocument")?;
-            document.to_object(&JsValue::NULL)?
-        } else {
-            document.to_owned()
-        };
-
-        self.validate_raw_document(raw_document).await
-    }
-
-    /// Creates Documents State Transition
-    pub async fn validate_raw_document(
-        &self,
-        js_raw_document: JsValue,
-    ) -> Result<ValidationResultWasm, JsValue> {
-        let result = self
-            .data_contract_fetcher_and_validator
-            .validate(&js_raw_document)
-            .await?;
-        if !result.is_valid() {
-            return Ok(result);
-        }
-        let data_contract = result
-            .get_data()
-            .to_wasm::<DataContractWasm>("DataContract")?;
-
-        self.validator.validate(&js_raw_document, &data_contract)
-    }
+    // /// Creates Documents State Transition
+    // #[wasm_bindgen(js_name=validate)]
+    // pub async fn validate_document(
+    //     &self,
+    //     document: &JsValue,
+    // ) -> Result<ValidationResultWasm, JsValue> {
+    //     let raw_document = if get_class_name(document) == "ExtendedDocument" {
+    //         let document = document.to_wasm::<ExtendedDocumentWasm>("ExtendedDocument")?;
+    //         document.to_object(&JsValue::NULL)?
+    //     } else {
+    //         document.to_owned()
+    //     };
+    //
+    //     self.validate_raw_document(raw_document).await
+    // }
+    //
+    // /// Creates Documents State Transition
+    // pub async fn validate_raw_document(
+    //     &self,
+    //     js_raw_document: JsValue,
+    // ) -> Result<ValidationResultWasm, JsValue> {
+    //     let result = self
+    //         .data_contract_fetcher_and_validator
+    //         .validate(&js_raw_document)
+    //         .await?;
+    //     if !result.is_valid() {
+    //         return Ok(result);
+    //     }
+    //     let data_contract = result
+    //         .get_data()
+    //         .to_wasm::<DataContractWasm>("DataContract")?;
+    //
+    //     self.validator.validate(&js_raw_document, &data_contract)
+    // }
 }

package/src/document/errors/document_already_exists_error.rs

@@ -1,5 +1,5 @@
-use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
-use dpp::prelude::DocumentTransition;
+// use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use dpp::state_transition::documents_batch_transition::document_transition::DocumentTransition;
 use thiserror::Error;
 
 use super::*;
@@ -13,10 +13,10 @@ pub struct DocumentAlreadyExistsError {
 
 #[wasm_bindgen]
 impl DocumentAlreadyExistsError {
-    #[wasm_bindgen(js_name=getDocumentTransition)]
-    pub fn get_document_transition(&self) -> JsValue {
-        from_document_transition_to_js_value(self.document_transition.clone())
-    }
+    // #[wasm_bindgen(js_name=getDocumentTransition)]
+    // pub fn get_document_transition(&self) -> JsValue {
+    //     from_document_transition_to_js_value(self.document_transition.clone())
+    // }
 }
 
 impl DocumentAlreadyExistsError {

package/src/document/errors/document_no_revision_error.rs

@@ -1,5 +1,6 @@
 use thiserror::Error;
 
+use crate::data_contract::DataContractWasm;
 use crate::DocumentWasm;
 
 use super::*;

package/src/document/errors/document_not_provided_error.rs

@@ -1,5 +1,5 @@
-use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
-use dpp::prelude::DocumentTransition;
+// use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use dpp::state_transition::documents_batch_transition::document_transition::DocumentTransition;
 use thiserror::Error;
 
 use super::*;
@@ -13,10 +13,10 @@ pub struct DocumentNotProvidedError {
 
 #[wasm_bindgen]
 impl DocumentNotProvidedError {
-    #[wasm_bindgen(js_name=getDocumentTransition)]
-    pub fn get_document_transition(&self) -> JsValue {
-        from_document_transition_to_js_value(self.document_transition.clone())
-    }
+    // #[wasm_bindgen(js_name=getDocumentTransition)]
+    // pub fn get_document_transition(&self) -> JsValue {
+    //     from_document_transition_to_js_value(self.document_transition.clone())
+    // }
 }
 
 impl DocumentNotProvidedError {

package/src/document/errors/invalid_document_action_error.rs

@@ -1,22 +1,23 @@
-use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
-use dpp::prelude::DocumentTransition;
+// use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use dpp::state_transition::documents_batch_transition::document_transition::DocumentTransition;
 use thiserror::Error;
 
 use super::*;
+use dpp::state_transition::documents_batch_transition::document_transition::action_type::TransitionActionTypeGetter;
 
 #[wasm_bindgen]
 #[derive(Error, Debug)]
-#[error("Invalid Document action: '{}'", document_transition.action())]
+#[error("Invalid Document action: '{:?}'", document_transition.action_type())]
 pub struct InvalidDocumentActionError {
     document_transition: DocumentTransition,
 }
 
 #[wasm_bindgen]
 impl InvalidDocumentActionError {
-    #[wasm_bindgen(js_name=getDocumentTransition)]
-    pub fn get_document_transition(&self) -> JsValue {
-        from_document_transition_to_js_value(self.document_transition.clone())
-    }
+    // #[wasm_bindgen(js_name=getDocumentTransition)]
+    // pub fn get_document_transition(&self) -> JsValue {
+    //     from_document_transition_to_js_value(self.document_transition.clone())
+    // }
 }
 
 impl InvalidDocumentActionError {
@@ -26,3 +27,6 @@ impl InvalidDocumentActionError {
         }
     }
 }
+
+#[test]
+fn data_contract_create_check_tx() {}

package/src/document/errors/invalid_document_error.rs

@@ -30,4 +30,9 @@ impl InvalidDocumentError {
     pub fn get_document(&self) -> JsValue {
         self.raw_document.clone()
     }
+
+    #[wasm_bindgen(js_name=getMessage)]
+    pub fn get_message(&self) -> String {
+        self.to_string()
+    }
 }

package/src/document/errors/invalid_initial_revision_error.rs

@@ -1,4 +1,4 @@
-use crate::ExtendedDocumentWasm;
+use crate::document::DocumentWasm;
 use thiserror::Error;
 
 use super::*;
@@ -7,18 +7,18 @@ use super::*;
 #[derive(Error, Debug)]
 #[error("Invalid Document Initial revision '{}'", document.get_revision().unwrap_or_default())]
 pub struct InvalidInitialRevisionError {
-    document: ExtendedDocumentWasm,
+    document: DocumentWasm,
 }
 
 #[wasm_bindgen]
 impl InvalidInitialRevisionError {
     #[wasm_bindgen(constructor)]
-    pub fn new(document: ExtendedDocumentWasm) -> InvalidInitialRevisionError {
+    pub fn new(document: DocumentWasm) -> InvalidInitialRevisionError {
         Self { document }
     }
 
     #[wasm_bindgen(js_name=getDocument)]
-    pub fn get_document_transition(&self) -> ExtendedDocumentWasm {
+    pub fn get_document_transition(&self) -> DocumentWasm {
         self.document.clone()
     }
 }

package/src/document/errors/mismatch_owners_ids_error.rs

@@ -1,5 +1,5 @@
-use crate::ExtendedDocumentWasm;
-use dpp::document::ExtendedDocument;
+use crate::document::DocumentWasm;
+use dpp::document::Document;
 use itertools::Itertools;
 use thiserror::Error;
 
@@ -9,7 +9,7 @@ use super::*;
 #[derive(Error, Debug)]
 #[error("Documents have mixed owner ids")]
 pub struct MismatchOwnerIdsError {
-    documents: Vec<ExtendedDocumentWasm>,
+    documents: Vec<DocumentWasm>,
 }
 
 #[wasm_bindgen]
@@ -28,12 +28,9 @@ impl MismatchOwnerIdsError {
 }
 
 impl MismatchOwnerIdsError {
-    pub fn from_documents(documents: Vec<ExtendedDocument>) -> MismatchOwnerIdsError {
+    pub fn from_documents(documents: Vec<Document>) -> MismatchOwnerIdsError {
         Self {
-            documents: documents
-                .into_iter()
-                .map(ExtendedDocumentWasm::from)
-                .collect_vec(),
+            documents: documents.into_iter().map(DocumentWasm::from).collect_vec(),
         }
     }
 }

package/src/document/errors/mod.rs

@@ -4,6 +4,7 @@ use wasm_bindgen::prelude::*;
 use crate::document::errors::document_no_revision_error::DocumentNoRevisionError;
 use crate::document::errors::invalid_action_error::InvalidActionError;
 use crate::document::errors::revision_absent_error::RevisionAbsentError;
+use crate::document::errors::trying_to_delete_immutable_document_error::TryingToDeleteImmutableDocumentError;
 use crate::document::errors::trying_to_replace_immutable_document_error::TryingToReplaceImmutableDocumentError;
 pub use document_already_exists_error::*;
 pub use document_not_provided_error::*;
@@ -29,6 +30,7 @@ mod invalid_initial_revision_error;
 mod mismatch_owners_ids_error;
 mod no_documents_supplied_error;
 mod revision_absent_error;
+mod trying_to_delete_immutable_document_error;
 mod trying_to_replace_immutable_document_error;
 
 pub fn from_document_to_js_error(e: DocumentError) -> JsValue {
@@ -73,5 +75,8 @@ pub fn from_document_to_js_error(e: DocumentError) -> JsValue {
             TryingToReplaceImmutableDocumentError::new((*document).into()).into()
         }
         DocumentError::InvalidActionError(action) => InvalidActionError::new(action.into()).into(),
+        DocumentError::TryingToDeleteImmutableDocument { document } => {
+            TryingToDeleteImmutableDocumentError::new((*document).into()).into()
+        }
     }
 }

package/src/document/errors/revision_absent_error.rs

@@ -1,4 +1,4 @@
-use crate::ExtendedDocumentWasm;
+use crate::document::DocumentWasm;
 use thiserror::Error;
 
 use super::*;
@@ -7,18 +7,18 @@ use super::*;
 #[derive(Error, Debug)]
 #[error("The revision was absent, but was needed")]
 pub struct RevisionAbsentError {
-    extended_document: ExtendedDocumentWasm,
+    document: DocumentWasm,
 }
 
 #[wasm_bindgen]
 impl RevisionAbsentError {
     #[wasm_bindgen(constructor)]
-    pub fn new(extended_document: ExtendedDocumentWasm) -> RevisionAbsentError {
-        Self { extended_document }
+    pub fn new(document: DocumentWasm) -> RevisionAbsentError {
+        Self { document }
     }
 
     #[wasm_bindgen(js_name=getDocument)]
-    pub fn get_document_transition(&self) -> ExtendedDocumentWasm {
-        self.extended_document.clone()
+    pub fn get_document_transition(&self) -> DocumentWasm {
+        self.document.clone()
     }
 }

package/src/document/errors/trying_to_delete_immutable_document_error.rs

@@ -0,0 +1,19 @@
+use crate::document::DocumentWasm;
+use thiserror::Error;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Trying to delete an immutable document")]
+pub struct TryingToDeleteImmutableDocumentError {
+    document: DocumentWasm,
+}
+
+#[wasm_bindgen]
+impl TryingToDeleteImmutableDocumentError {
+    #[wasm_bindgen(constructor)]
+    pub fn new(document: DocumentWasm) -> Self {
+        TryingToDeleteImmutableDocumentError { document }
+    }
+}

package/src/document/errors/trying_to_replace_immutable_document_error.rs

@@ -1,4 +1,4 @@
-use crate::ExtendedDocumentWasm;
+use crate::document::DocumentWasm;
 use thiserror::Error;
 
 use super::*;
@@ -7,13 +7,13 @@ use super::*;
 #[derive(Error, Debug)]
 #[error("Trying to update an immutable document")]
 pub struct TryingToReplaceImmutableDocumentError {
-    extended_document: ExtendedDocumentWasm,
+    document: DocumentWasm,
 }
 
 #[wasm_bindgen]
 impl TryingToReplaceImmutableDocumentError {
     #[wasm_bindgen(constructor)]
-    pub fn new(extended_document: ExtendedDocumentWasm) -> Self {
-        TryingToReplaceImmutableDocumentError { extended_document }
+    pub fn new(document: DocumentWasm) -> Self {
+        TryingToReplaceImmutableDocumentError { document }
     }
 }