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

package/src/data_contract/index.rs

@@ -1,6 +1,9 @@
-use dpp::{data_contract::extra::IndexProperty, util::json_schema::Index};
+use dpp::{data_contract::document_type::IndexProperty, util::json_schema::Index};
+use serde::{ser::SerializeMap, Serialize, Serializer};
 use wasm_bindgen::prelude::*;
 
+use crate::{errors::RustConversionError, with_js_error};
+
 #[wasm_bindgen(js_name=IndexProperty)]
 #[derive(Debug, Clone)]
 pub struct IndexPropertyWasm {
@@ -38,6 +41,51 @@ impl From<Index> for IndexDefinitionWasm {
     }
 }
 
+/// Wrapper structure to serialize `Index` the way js-dpp expects it.
+#[derive(Debug)]
+struct IndexSerializeJs<'a>(&'a Index);
+
+impl Serialize for IndexSerializeJs<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(3))?;
+        map.serialize_entry("name", &self.0.name)?;
+        if self.0.unique {
+            map.serialize_entry("unique", &true)?;
+        }
+        map.serialize_entry(
+            "properties",
+            &self
+                .0
+                .properties
+                .iter()
+                .map(IndexPropertySerializeJs)
+                .collect::<Vec<_>>(),
+        )?;
+
+        map.end()
+    }
+}
+
+/// Wrapper structure to serialize `InderProperty` the way js-dpp expects it.
+#[derive(Debug)]
+struct IndexPropertySerializeJs<'a>(&'a IndexProperty);
+
+impl Serialize for IndexPropertySerializeJs<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(1))?;
+        let order_str = if self.0.ascending { "asc" } else { "desc" };
+        map.serialize_entry(&self.0.name, order_str)?;
+
+        map.end()
+    }
+}
+
 #[wasm_bindgen(js_class=IndexDefinition)]
 impl IndexDefinitionWasm {
     #[wasm_bindgen(js_name=getName)]
@@ -58,4 +106,11 @@ impl IndexDefinitionWasm {
     pub fn is_unique(&self) -> bool {
         self.inner.unique
     }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let object = with_js_error!(IndexSerializeJs(&self.inner).serialize(&serializer))?;
+        Ok(object)
+    }
 }

package/src/data_contract/mod.rs

@@ -4,6 +4,7 @@ pub use state_transition::*;
 
 mod data_contract;
 pub mod errors;
+
 mod state_transition;
 
 mod index;

package/src/data_contract/state_transition/data_contract_create_transition/mod.rs

@@ -14,10 +14,8 @@ use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
 use crate::{
-    buffer::Buffer,
-    errors::{from_dpp_err, RustConversionError},
-    identifier::IdentifierWrapper,
-    with_js_error, DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
+    buffer::Buffer, errors::from_dpp_err, identifier::IdentifierWrapper, with_js_error,
+    DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
 };
 
 #[wasm_bindgen(js_name=DataContractCreateTransition)]
@@ -29,9 +27,9 @@ impl From<DataContractCreateTransition> for DataContractCreateTransitionWasm {
     }
 }
 
-impl Into<DataContractCreateTransition> for DataContractCreateTransitionWasm {
-    fn into(self) -> DataContractCreateTransition {
-        self.0
+impl From<DataContractCreateTransitionWasm> for DataContractCreateTransition {
+    fn from(val: DataContractCreateTransitionWasm) -> Self {
+        val.0
     }
 }
 
@@ -69,7 +67,7 @@ impl DataContractCreateTransitionWasm {
 
     #[wasm_bindgen(js_name=getProtocolVersion)]
     pub fn get_protocol_version(&self) -> u32 {
-        self.0.protocol_version.into()
+        self.0.protocol_version
     }
 
     #[wasm_bindgen(js_name=getEntropy)]

package/src/data_contract/state_transition/data_contract_create_transition/validation.rs

@@ -1,10 +1,10 @@
 use dpp::data_contract::state_transition::data_contract_create_transition::validation::state::validate_data_contract_create_transition_state::validate_data_contract_create_transition_state as dpp_validate_data_contract_create_transition_state;
 use wasm_bindgen::prelude::*;
 
+use crate::validation::ValidationResultWasm;
 use crate::{
     errors::from_dpp_err,
     state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
-    validation_result::ValidationResultWasm,
     DataContractCreateTransitionWasm,
 };
 
@@ -14,11 +14,11 @@ pub async fn validate_data_contract_create_transition_state(
     state_transition: DataContractCreateTransitionWasm,
 ) -> Result<ValidationResultWasm, JsValue> {
     let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
-    dpp_validate_data_contract_create_transition_state(
+    let validation_result = dpp_validate_data_contract_create_transition_state(
         &wrapped_state_repository,
         &state_transition.into(),
     )
     .await
-    .map(Into::into)
-    .map_err(from_dpp_err)
+    .map_err(from_dpp_err)?;
+    Ok(validation_result.map(|_| JsValue::undefined()).into())
 }

package/src/data_contract/state_transition/data_contract_update_transition/apply.rs

@@ -0,0 +1,44 @@
+use std::ops::Deref;
+
+use dpp::data_contract::state_transition::apply_data_contract_update_transition_factory::ApplyDataContractUpdateTransition;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    DataContractUpdateTransitionWasm,
+};
+
+#[wasm_bindgen(js_name=ApplyDataContractUpdateTransition)]
+pub struct ApplyDataContractUpdateTransitionWasm(
+    ApplyDataContractUpdateTransition<ExternalStateRepositoryLikeWrapper>,
+);
+
+impl From<ApplyDataContractUpdateTransition<ExternalStateRepositoryLikeWrapper>>
+    for ApplyDataContractUpdateTransitionWasm
+{
+    fn from(wa: ApplyDataContractUpdateTransition<ExternalStateRepositoryLikeWrapper>) -> Self {
+        ApplyDataContractUpdateTransitionWasm(wa)
+    }
+}
+
+#[wasm_bindgen(js_class=ApplyDataContractUpdateTransition)]
+impl ApplyDataContractUpdateTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+    ) -> ApplyDataContractUpdateTransitionWasm {
+        let pinned_js_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+        ApplyDataContractUpdateTransition::new(pinned_js_state_repository).into()
+    }
+
+    #[wasm_bindgen(js_name=applyDataContractUpdateTransition)]
+    pub async fn apply_data_contract_update_transition(
+        &self,
+        transition: DataContractUpdateTransitionWasm,
+    ) -> Result<(), JsError> {
+        self.0
+            .apply_data_contract_update_transition(&transition.into())
+            .await
+            .map_err(|e| e.deref().into())
+    }
+}

package/src/data_contract/state_transition/data_contract_update_transition/mod.rs

@@ -0,0 +1,145 @@
+mod apply;
+mod validation;
+
+pub use apply::*;
+pub use validation::*;
+
+use dpp::{
+    data_contract::state_transition::DataContractUpdateTransition,
+    state_transition::{
+        StateTransitionConvert, StateTransitionIdentitySigned, StateTransitionLike,
+    },
+};
+use serde::{Deserialize, Serialize};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    buffer::Buffer, errors::from_dpp_err, identifier::IdentifierWrapper, with_js_error,
+    DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name=DataContractUpdateTransition)]
+pub struct DataContractUpdateTransitionWasm(DataContractUpdateTransition);
+
+impl From<DataContractUpdateTransition> for DataContractUpdateTransitionWasm {
+    fn from(v: DataContractUpdateTransition) -> Self {
+        DataContractUpdateTransitionWasm(v)
+    }
+}
+
+impl From<DataContractUpdateTransitionWasm> for DataContractUpdateTransition {
+    fn from(val: DataContractUpdateTransitionWasm) -> Self {
+        val.0
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DataContractUpdateTransitionParameters {
+    protocol_version: u32,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    data_contract: Option<DataContractParameters>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    entropy: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    signature_public_key_id: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    signature: Option<Vec<u8>>,
+}
+
+#[wasm_bindgen(js_class=DataContractUpdateTransition)]
+impl DataContractUpdateTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<DataContractUpdateTransitionWasm, JsValue> {
+        let parameters: DataContractUpdateTransitionParameters =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+        DataContractUpdateTransition::from_raw_object(
+            serde_json::to_value(parameters).expect("the struct will be a valid json"),
+        )
+        .map(Into::into)
+        .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=getDataContract)]
+    pub fn get_data_contract(&self) -> DataContractWasm {
+        self.0.data_contract.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn get_protocol_version(&self) -> u32 {
+        self.0.protocol_version
+    }
+
+    #[wasm_bindgen(js_name=getEntropy)]
+    pub fn get_entropy(&self) -> Buffer {
+        Buffer::from_bytes(&self.0.data_contract.entropy)
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.0.get_owner_id().clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u32 {
+        self.0.get_type() as u32
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        Ok(self
+            .0
+            .to_json(skip_signature.unwrap_or(false))
+            .map_err(from_dpp_err)?
+            .serialize(&serializer)
+            .expect("JSON is a valid object"))
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self, skip_signature: Option<bool>) -> Result<Buffer, JsValue> {
+        let bytes = self
+            .0
+            .to_buffer(skip_signature.unwrap_or(false))
+            .map_err(from_dpp_err)?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen(js_name=getModifiedDataIds)]
+    pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
+        self.0
+            .get_modified_data_ids()
+            .into_iter()
+            .map(|identifier| Into::<IdentifierWrapper>::into(identifier.clone()).into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=isDataContractStateTransition)]
+    pub fn is_data_contract_state_transition(&self) -> bool {
+        self.0.is_data_contract_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isDocumentStateTransition)]
+    pub fn is_document_state_transition(&self) -> bool {
+        self.0.is_document_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isIdentityStateTransition)]
+    pub fn is_identity_state_transition(&self) -> bool {
+        self.0.is_identity_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=setExecutionContext)]
+    pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) {
+        self.0.set_execution_context(context.into())
+    }
+
+    #[wasm_bindgen(js_name=hash)]
+    pub fn hash(&self, skip_signature: Option<bool>) -> Result<Buffer, JsValue> {
+        let bytes = self
+            .0
+            .hash(skip_signature.unwrap_or(false))
+            .map_err(from_dpp_err)?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+}

package/src/data_contract/state_transition/data_contract_update_transition/validation.rs

@@ -0,0 +1,49 @@
+use std::collections::BTreeMap;
+
+use dpp::data_contract::state_transition::data_contract_update_transition::validation::{
+    basic::validate_indices_are_backward_compatible as dpp_validate_indices_are_backward_compatible,
+    state::validate_data_contract_update_transition_state::validate_data_contract_update_transition_state as dpp_validate_data_contract_update_transition_state,
+};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    errors::{from_dpp_err, protocol_error::from_protocol_error},
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    validation::ValidationResultWasm,
+    DataContractUpdateTransitionWasm,
+};
+
+#[wasm_bindgen(js_name=validateDataContractUpdateTransitionState)]
+pub async fn validate_data_contract_update_transition_state(
+    state_repository: ExternalStateRepositoryLike,
+    state_transition: DataContractUpdateTransitionWasm,
+) -> Result<ValidationResultWasm, JsValue> {
+    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+    let result = dpp_validate_data_contract_update_transition_state(
+        &wrapped_state_repository,
+        &state_transition.into(),
+    )
+    .await
+    .map_err(from_dpp_err)?;
+
+    Ok(result.map(|_| JsValue::undefined()).into())
+}
+
+#[wasm_bindgen(js_name=validateIndicesAreBackwardCompatible)]
+pub fn validate_indices_are_backward_compatible(
+    old_documents_schema: JsValue,
+    new_documents_schema: JsValue,
+) -> Result<ValidationResultWasm, JsValue> {
+    let old_documents = serde_wasm_bindgen::from_value::<BTreeMap<String, serde_json::Value>>(
+        old_documents_schema,
+    )?;
+    let new_documents = serde_wasm_bindgen::from_value::<BTreeMap<String, serde_json::Value>>(
+        new_documents_schema,
+    )?;
+
+    let result =
+        dpp_validate_indices_are_backward_compatible(old_documents.iter(), new_documents.iter())
+            .map_err(from_protocol_error)?;
+
+    Ok(result.map(|_| JsValue::undefined()).into())
+}

package/src/data_contract/state_transition/mod.rs

@@ -1,3 +1,5 @@
 mod data_contract_create_transition;
+mod data_contract_update_transition;
 
 pub use data_contract_create_transition::*;
+pub use data_contract_update_transition::*;

package/src/data_contract_factory/data_contract_factory.rs

@@ -12,7 +12,10 @@ use wasm_bindgen::prelude::*;
 
 use crate::{
     data_contract::errors::InvalidDataContractError,
-    errors::{consensus_error::from_consensus_error, from_dpp_err, RustConversionError},
+    errors::{
+        consensus_error::from_consensus_error, from_dpp_err, protocol_error::from_protocol_error,
+    },
+    validation::ValidationResultWasm,
     with_js_error, DataContractCreateTransitionWasm, DataContractParameters, DataContractWasm,
 };
 
@@ -25,9 +28,9 @@ impl From<DataContractValidator> for DataContractValidatorWasm {
     }
 }
 
-impl Into<DataContractValidator> for DataContractValidatorWasm {
-    fn into(self) -> DataContractValidator {
-        self.0
+impl From<DataContractValidatorWasm> for DataContractValidator {
+    fn from(val: DataContractValidatorWasm) -> Self {
+        val.0
     }
 }
 
@@ -37,6 +40,16 @@ impl DataContractValidatorWasm {
     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 json_object = serde_json::to_value(parameters).expect("Implements Serialize");
+        let validation_result = self.0.validate(&json_object).map_err(from_protocol_error)?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
 }
 
 #[wasm_bindgen(js_name=DataContractFactory)]
@@ -48,9 +61,9 @@ impl From<DataContractFactory> for DataContractFactoryWasm {
     }
 }
 
-impl Into<DataContractFactory> for DataContractFactoryWasm {
-    fn into(self) -> DataContractFactory {
-        self.0
+impl From<DataContractFactoryWasm> for DataContractFactory {
+    fn from(val: DataContractFactoryWasm) -> Self {
+        val.0
     }
 }
 
@@ -65,10 +78,10 @@ extern "C" {
 impl EntropyGenerator for ExternalEntropyGenerator {
     fn generate(&self) -> [u8; 32] {
         // TODO: think about changing API to return an error but does it worth it for JS?
-        let res = ExternalEntropyGenerator::generate(self)
+
+        ExternalEntropyGenerator::generate(self)
             .try_into()
-            .expect("Bad entropy generator provided: should return 32 bytes");
-        res
+            .expect("Bad entropy generator provided: should return 32 bytes")
     }
 }
 #[wasm_bindgen(js_class=DataContractFactory)]
@@ -86,7 +99,7 @@ impl DataContractFactoryWasm {
                 Box::new(external_entropy_generator),
             )
         } else {
-            DataContractFactory::new(protocol_version, validate_data_contract.into()).into()
+            DataContractFactory::new(protocol_version, validate_data_contract.into())
         }
         .into()
     }
@@ -139,7 +152,7 @@ impl DataContractFactoryWasm {
             .create_from_buffer(buffer, skip_validation.unwrap_or(false))
             .await
             .map(Into::into)
-            .map_err(from_dpp_err)
+            .map_err(from_protocol_error)
     }
 
     #[wasm_bindgen(js_name=createDataContractCreateTransition)]

package/src/document/errors/invalid_document_error.rs

@@ -1,7 +1,5 @@
 use thiserror::Error;
 
-use crate::DocumentWasm;
-
 use super::*;
 
 #[wasm_bindgen]
@@ -10,14 +8,17 @@ use super::*;
 pub struct InvalidDocumentError {
     // the point is how we hold all there different types in  the Vector
     errors: Vec<JsValue>,
-    document: DocumentWasm,
+    raw_document: JsValue,
 }
 
-#[wasm_bindgen]
+#[wasm_bindgen(js_class=InvalidDocumentError)]
 impl InvalidDocumentError {
     #[wasm_bindgen(constructor)]
-    pub fn new(document: DocumentWasm, errors: Vec<JsValue>) -> InvalidDocumentError {
-        Self { document, errors }
+    pub fn new(raw_document: JsValue, errors: Vec<JsValue>) -> InvalidDocumentError {
+        Self {
+            raw_document,
+            errors,
+        }
     }
 
     #[wasm_bindgen(js_name=getErrors)]
@@ -25,8 +26,8 @@ impl InvalidDocumentError {
         self.errors.clone()
     }
 
-    #[wasm_bindgen(js_name=getDocument)]
-    pub fn get_document(&self) -> DocumentWasm {
-        self.document.clone()
+    #[wasm_bindgen(js_name=getRawDocument)]
+    pub fn get_document(&self) -> JsValue {
+        self.raw_document.clone()
     }
 }

package/src/document/errors/invalid_initial_revision_error.rs

@@ -18,7 +18,7 @@ impl InvalidInitialRevisionError {
         Self { document }
     }
 
-    #[wasm_bindgen(js_name=getDocumentTransition)]
+    #[wasm_bindgen(js_name=getDocument)]
     pub fn get_document_transition(&self) -> DocumentWasm {
         self.document.clone()
     }

package/src/document/errors/mismatch_owners_ids_error.rs

@@ -1,3 +1,5 @@
+use dpp::prelude::Document;
+use itertools::Itertools;
 use thiserror::Error;
 
 use crate::DocumentWasm;
@@ -7,21 +9,29 @@ use super::*;
 #[wasm_bindgen]
 #[derive(Error, Debug)]
 #[error("Documents have mixed owner ids")]
-pub struct MismatchOwnersIdsError {
+pub struct MismatchOwnerIdsError {
     documents: Vec<DocumentWasm>,
 }
 
 #[wasm_bindgen]
-impl MismatchOwnersIdsError {
+impl MismatchOwnerIdsError {
     #[wasm_bindgen(constructor)]
-    pub fn new(documents: Vec<JsValue>) -> MismatchOwnersIdsError {
+    pub fn new(documents: Vec<JsValue>) -> MismatchOwnerIdsError {
         Self {
             documents: into_vec_of(&documents),
         }
     }
 
-    #[wasm_bindgen(js_name=getDocumentTransition)]
+    #[wasm_bindgen(js_name=getDocuments)]
     pub fn get_documents(&self) -> Vec<JsValue> {
         to_vec_js(self.documents.clone())
     }
 }
+
+impl MismatchOwnerIdsError {
+    pub fn from_documents(documents: Vec<Document>) -> MismatchOwnerIdsError {
+        Self {
+            documents: documents.into_iter().map(DocumentWasm::from).collect_vec(),
+        }
+    }
+}

package/src/document/errors/mod.rs

@@ -1,3 +1,4 @@
+use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
 pub use document_already_exists_error::*;
@@ -11,7 +12,7 @@ pub use mismatch_owners_ids_error::*;
 pub use no_documents_supplied_error::*;
 
 use crate::errors::consensus_error::from_consensus_error;
-use crate::{utils::*, DocumentWasm};
+use crate::utils::*;
 
 mod document_already_exists_error;
 mod document_not_provided_error;
@@ -24,32 +25,35 @@ mod no_documents_supplied_error;
 
 pub fn from_document_to_js_error(e: DocumentError) -> JsValue {
     match e {
-        DocumentError::DocumentAlreadyExists {
+        DocumentError::DocumentAlreadyExistsError {
             document_transition,
         } => DocumentAlreadyExistsError::new(document_transition).into(),
-        DocumentError::DocumentNotProvided {
+        DocumentError::DocumentNotProvidedError {
             document_transition,
         } => DocumentNotProvidedError::new(document_transition).into(),
 
-        DocumentError::InvalidActionName { actions } => {
+        DocumentError::InvalidActionNameError { actions } => {
             InvalidActionNameError::new(to_vec_js(actions)).into()
         }
-        DocumentError::InvalidDocument { errors, document } => InvalidDocumentError::new(
-            (*document).into(),
+        DocumentError::InvalidDocumentError {
+            errors,
+            raw_document,
+        } => InvalidDocumentError::new(
+            raw_document
+                .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+                .expect("Raw Document should be serializable into JsValue"),
             errors.into_iter().map(from_consensus_error).collect(),
         )
         .into(),
-        DocumentError::InvalidDocumentAction {
+        DocumentError::InvalidDocumentActionError {
             document_transition,
         } => InvalidDocumentActionError::new(document_transition).into(),
-        DocumentError::InvalidInitialRevision { document } => {
+        DocumentError::InvalidInitialRevisionError { document } => {
             InvalidInitialRevisionError::new((*document).into()).into()
         }
-        DocumentError::MismatchOwnersIds { documents } => {
-            let documents_wasm: Vec<DocumentWasm> =
-                documents.into_iter().map(DocumentWasm::from).collect();
-            MismatchOwnersIdsError::new(to_vec_js(documents_wasm)).into()
+        DocumentError::MismatchOwnerIdsError { documents } => {
+            MismatchOwnerIdsError::from_documents(documents).into()
         }
-        DocumentError::NotDocumentsSupplied => NotDocumentsSuppliedError::new().into(),
+        DocumentError::NoDocumentsSuppliedError => NoDocumentsSuppliedError::new().into(),
     }
 }

package/src/document/errors/no_documents_supplied_error.rs

@@ -5,17 +5,17 @@ use super::*;
 #[wasm_bindgen]
 #[derive(Error, Debug)]
 #[error("No documents were supplied to state transition")]
-pub struct NotDocumentsSuppliedError {}
+pub struct NoDocumentsSuppliedError {}
 
 #[wasm_bindgen]
-impl NotDocumentsSuppliedError {
+impl NoDocumentsSuppliedError {
     #[wasm_bindgen(constructor)]
     pub fn new() -> Self {
-        NotDocumentsSuppliedError {}
+        NoDocumentsSuppliedError {}
     }
 }
 
-impl Default for NotDocumentsSuppliedError {
+impl Default for NoDocumentsSuppliedError {
     fn default() -> Self {
         Self::new()
     }