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

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

@@ -0,0 +1,147 @@
+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, RustConversionError},
+    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,46 @@
+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);
+    dpp_validate_data_contract_update_transition_state(
+        &wrapped_state_repository,
+        &state_transition.into(),
+    )
+    .await
+    .map(Into::into)
+    .map_err(from_dpp_err)
+}
+
+#[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,
+    )?;
+
+    dpp_validate_indices_are_backward_compatible(old_documents.iter(), new_documents.iter())
+        .map(Into::into)
+        .map_err(from_protocol_error)
+}

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,11 @@ 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,
+        RustConversionError,
+    },
+    validation::ValidationResultWasm,
     with_js_error, DataContractCreateTransitionWasm, DataContractParameters, DataContractWasm,
 };
 
@@ -25,9 +29,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 +41,17 @@ impl DataContractValidatorWasm {
     pub fn new() -> Self {
         DataContractValidator::new(std::sync::Arc::new(ProtocolVersionValidator::default())).into()
     }
+
+    #[wasm_bindgen(js_name=validate)]
+    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");
+        self.0
+            .validate(&json_object)
+            .map(Into::into)
+            .map_err(from_protocol_error)
+    }
 }
 
 #[wasm_bindgen(js_name=DataContractFactory)]
@@ -48,9 +63,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 +80,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 +101,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 +154,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/document_already_exists_error.rs

@@ -1,4 +1,4 @@
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 use dpp::prelude::DocumentTransition;
 use thiserror::Error;
 

package/src/document/errors/document_not_provided_error.rs

@@ -1,4 +1,4 @@
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 use dpp::prelude::DocumentTransition;
 use thiserror::Error;
 

package/src/document/errors/invalid_document_action_error.rs

@@ -1,4 +1,4 @@
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 use dpp::prelude::DocumentTransition;
 use thiserror::Error;
 

package/src/errors/consensus/basic/data_contract/data_contract_max_depth_exceed_error.rs

@@ -1,19 +1,19 @@
 use wasm_bindgen::prelude::*;
 
-#[wasm_bindgen(js_name=DataContractMaxDepthError)]
-pub struct DataContractMaxDepthErrorWasm {
+#[wasm_bindgen(js_name=DataContractMaxDepthExceedError)]
+pub struct DataContractMaxDepthExceedErrorWasm {
     depth: usize,
     code: u32,
 }
 
-impl DataContractMaxDepthErrorWasm {
+impl DataContractMaxDepthExceedErrorWasm {
     pub fn new(depth: usize, code: u32) -> Self {
-        DataContractMaxDepthErrorWasm { depth, code }
+        DataContractMaxDepthExceedErrorWasm { depth, code }
     }
 }
 
 #[wasm_bindgen(js_class=DataContractMaxDepthError)]
-impl DataContractMaxDepthErrorWasm {
+impl DataContractMaxDepthExceedErrorWasm {
     #[wasm_bindgen(js_name=getDepth)]
     pub fn get_expected_version(&self) -> usize {
         self.depth

package/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs

@@ -3,19 +3,19 @@ use std::iter::FromIterator;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DuplicateDocumentTransitionsWithIdsError)]
-pub struct DuplicateDocumentTransitionsWithIdsError {
+pub struct DuplicateDocumentTransitionsWithIdsErrorWasm {
     references: Vec<(String, Vec<u8>)>,
     code: u32,
 }
 
-impl DuplicateDocumentTransitionsWithIdsError {
+impl DuplicateDocumentTransitionsWithIdsErrorWasm {
     pub fn new(references: Vec<(String, Vec<u8>)>, code: u32) -> Self {
-        DuplicateDocumentTransitionsWithIdsError { references, code }
+        DuplicateDocumentTransitionsWithIdsErrorWasm { references, code }
     }
 }
 
 #[wasm_bindgen(js_class=DuplicateDocumentTransitionsWithIdsError)]
-impl DuplicateDocumentTransitionsWithIdsError {
+impl DuplicateDocumentTransitionsWithIdsErrorWasm {
     #[wasm_bindgen(js_name=getReferences)]
     pub fn get_references(&self) -> js_sys::Array {
         self.references

package/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs

@@ -0,0 +1,36 @@
+use crate::buffer::Buffer;
+use std::iter::FromIterator;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DuplicateDocumentTransitionsWithIndicesError)]
+pub struct DuplicateDocumentTransitionsWithIndicesErrorWasm {
+    references: Vec<(String, Vec<u8>)>,
+    code: u32,
+}
+
+impl DuplicateDocumentTransitionsWithIndicesErrorWasm {
+    pub fn new(references: Vec<(String, Vec<u8>)>, code: u32) -> Self {
+        DuplicateDocumentTransitionsWithIndicesErrorWasm { references, code }
+    }
+}
+
+#[wasm_bindgen(js_class=DuplicateDocumentTransitionsWithIndicesError)]
+impl DuplicateDocumentTransitionsWithIndicesErrorWasm {
+    #[wasm_bindgen(js_name=getReferences)]
+    pub fn get_references(&self) -> js_sys::Array {
+        self.references
+            .iter()
+            .map(|v| {
+                js_sys::Array::from_iter(vec![
+                    JsValue::from(v.0.clone()),
+                    JsValue::from(Buffer::from_bytes(&v.1)),
+                ])
+            })
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/document/missing_document_transition_type_error.rs

@@ -0,0 +1,20 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=MissingDocumentTransitionTypeError)]
+pub struct MissingDocumentTransitionTypeErrorWasm {
+    code: u32,
+}
+
+impl MissingDocumentTransitionTypeErrorWasm {
+    pub fn new(code: u32) -> Self {
+        MissingDocumentTransitionTypeErrorWasm { code }
+    }
+}
+
+#[wasm_bindgen(js_class=MissingDocumentTransitionTypeError)]
+impl MissingDocumentTransitionTypeErrorWasm {
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/document/mod.rs

@@ -1,19 +1,23 @@
 mod data_contract_not_present_error;
 mod duplicate_document_transitions_with_ids_error;
+mod duplicate_document_transitions_with_indices_error;
 mod inconsistent_compound_index_data_error;
 mod invalid_document_transition_action_error;
 mod invalid_document_transition_id_error;
 mod invalid_document_type_error;
 mod missing_data_contract_id_error;
 mod missing_document_transition_action_error;
+mod missing_document_transition_type_error;
 mod missing_document_type_error;
 
 pub use data_contract_not_present_error::*;
 pub use duplicate_document_transitions_with_ids_error::*;
+pub use duplicate_document_transitions_with_indices_error::*;
 pub use inconsistent_compound_index_data_error::*;
 pub use invalid_document_transition_action_error::*;
 pub use invalid_document_transition_id_error::*;
 pub use invalid_document_type_error::*;
 pub use missing_data_contract_id_error::*;
 pub use missing_document_transition_action_error::*;
+pub use missing_document_transition_type_error::*;
 pub use missing_document_type_error::*;

package/src/errors/consensus/basic/identity/duplicated_identity_public_key_error.rs

@@ -16,12 +16,12 @@ impl From<&DuplicatedIdentityPublicKeyError> for DuplicatedIdentityPublicKeyErro
 #[wasm_bindgen(js_class=DuplicatedIdentityPublicKeyError)]
 impl DuplicatedIdentityPublicKeyErrorWasm {
     #[wasm_bindgen(js_name=getDuplicatedPublicKeysIds)]
-    pub fn duplicated_public_keys_ids(&self) -> Vec<u32> {
+    pub fn duplicated_public_keys_ids(&self) -> js_sys::Array {
         // TODO: key ids probably should be u32
         self.inner
             .duplicated_public_keys_ids()
             .iter()
-            .map(|id| *id as u32)
+            .map(|id| JsValue::from(*id as u32))
             .collect()
     }
 

package/src/errors/consensus/basic/identity/duplicated_identity_public_key_id_error.rs

@@ -16,12 +16,12 @@ impl From<&DuplicatedIdentityPublicKeyIdError> for DuplicatedIdentityPublicKeyId
 #[wasm_bindgen(js_class=DuplicatedIdentityPublicKeyIdError)]
 impl DuplicatedIdentityPublicKeyIdErrorWasm {
     #[wasm_bindgen(js_name=getDuplicatedIds)]
-    pub fn duplicated_ids(&self) -> Vec<u32> {
+    pub fn duplicated_ids(&self) -> js_sys::Array {
         // TODO: key ids probably should be u32
         self.inner
             .duplicated_ids()
             .iter()
-            .map(|id| *id as u32)
+            .map(|id| JsValue::from(*id as u32))
             .collect()
     }
 

package/src/errors/consensus/basic/identity/invalid_identity_public_key_security_level_error.rs

@@ -25,12 +25,12 @@ impl InvalidIdentityPublicKeySecurityLevelErrorWasm {
         self.inner.public_key_id() as u32
     }
 
-    #[wasm_bindgen(js_name=getPurpose)]
+    #[wasm_bindgen(js_name=getPublicKeyPurpose)]
     pub fn purpose(&self) -> u8 {
         self.inner.purpose() as u8
     }
 
-    #[wasm_bindgen(js_name=getSecurityLevel)]
+    #[wasm_bindgen(js_name=getPublicKeySecurityLevel)]
     pub fn security_level(&self) -> u8 {
         self.inner.security_level() as u8
     }

package/src/errors/consensus/basic/json_schema_error.rs

@@ -141,7 +141,7 @@ impl From<&ValidationErrorKind> for Params {
                 .build(),
             ValidationErrorKind::MinItems { limit } => ParamsBuilder::new()
                 .set_keyword("minItems")
-                .add_param("maximum", Value::from(*limit))
+                .add_param("minItems", Value::from(*limit))
                 .build(),
             ValidationErrorKind::Minimum { limit } => ParamsBuilder::new()
                 .set_keyword("minimum")

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_condition_error.rs

@@ -1,5 +1,5 @@
 use crate::buffer::Buffer;
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 
 use dpp::identifier::Identifier;
 use dpp::prelude::DocumentTransition;

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_execution_error.rs

@@ -1,5 +1,5 @@
 use crate::buffer::Buffer;
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 
 use dpp::identifier::Identifier;
 use dpp::prelude::DocumentTransition;

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_invalid_result_error.rs

@@ -1,5 +1,5 @@
 use crate::buffer::Buffer;
-use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
 
 use dpp::identifier::Identifier;
 use dpp::prelude::DocumentTransition;

package/src/errors/consensus_error.rs

@@ -36,8 +36,9 @@ use crate::errors::consensus::basic::data_contract::{
     IncompatibleDataContractSchemaErrorWasm, InvalidDataContractIdErrorWasm,
 };
 use crate::errors::consensus::basic::document::{
-    DuplicateDocumentTransitionsWithIdsError, InvalidDocumentTransitionActionErrorWasm,
-    InvalidDocumentTransitionIdErrorWasm, MissingDataContractIdErrorWasm,
+    DuplicateDocumentTransitionsWithIdsErrorWasm, DuplicateDocumentTransitionsWithIndicesErrorWasm,
+    InvalidDocumentTransitionActionErrorWasm, InvalidDocumentTransitionIdErrorWasm,
+    MissingDataContractIdErrorWasm, MissingDocumentTypeErrorWasm,
 };
 use crate::errors::consensus::basic::state_transition::{
     InvalidStateTransitionTypeErrorWasm, MissingStateTransitionTypeErrorWasm,
@@ -62,7 +63,7 @@ use crate::errors::consensus::state::identity::{
 use dpp::errors::DataTriggerError;
 
 use super::consensus::basic::data_contract::{
-    DataContractMaxDepthErrorWasm, DuplicateIndexErrorWasm, DuplicateIndexNameErrorWasm,
+    DataContractMaxDepthExceedErrorWasm, DuplicateIndexErrorWasm, DuplicateIndexNameErrorWasm,
     IncompatibleRe2PatternErrorWasm, InvalidCompoundIndexErrorWasm,
     InvalidDataContractVersionErrorWasm, InvalidIndexPropertyTypeErrorWasm,
     InvalidIndexedPropertyConstraintErrorWasm, InvalidJsonSchemaRefErrorWasm,
@@ -75,7 +76,7 @@ use super::consensus::basic::decode::{
 use super::consensus::basic::document::{
     DataContractNotPresentErrorWasm, InconsistentCompoundIndexDataErrorWasm,
     InvalidDocumentTypeErrorWasm, MissingDocumentTransitionActionErrorWasm,
-    MissingDocumentTypeErrorWasm,
+    MissingDocumentTransitionTypeErrorWasm,
 };
 use super::consensus::basic::identity::{
     InvalidIdentityPublicKeyTypeErrorWasm, MissingPublicKeyErrorWasm,
@@ -99,7 +100,7 @@ pub fn from_consensus_error_ref(e: &DPPConsensusError) -> JsValue {
         DPPConsensusError::IncompatibleProtocolVersionError(e) => {
             IncompatibleProtocolVersionErrorWasm::from(e).into()
         }
-        DPPConsensusError::DuplicatedIdentityPublicKeyIdError(e) => {
+        DPPConsensusError::DuplicatedIdentityPublicKeyBasicIdError(e) => {
             DuplicatedIdentityPublicKeyIdErrorWasm::from(e).into()
         }
         DPPConsensusError::InvalidIdentityPublicKeyDataError(e) => {
@@ -108,7 +109,7 @@ pub fn from_consensus_error_ref(e: &DPPConsensusError) -> JsValue {
         DPPConsensusError::InvalidIdentityPublicKeySecurityLevelError(e) => {
             InvalidIdentityPublicKeySecurityLevelErrorWasm::from(e).into()
         }
-        DPPConsensusError::DuplicatedIdentityPublicKeyError(e) => {
+        DPPConsensusError::DuplicatedIdentityPublicKeyBasicError(e) => {
             DuplicatedIdentityPublicKeyErrorWasm::from(e).into()
         }
         DPPConsensusError::MissingMasterPublicKeyError(e) => {
@@ -351,7 +352,7 @@ fn from_basic_error(basic_error: &Box<BasicError>) -> JsValue {
             version,
         } => InvalidDataContractVersionErrorWasm::new(*expected_version, *version, code).into(),
         BasicError::DataContractMaxDepthExceedError(depth) => {
-            DataContractMaxDepthErrorWasm::new(*depth, code).into()
+            DataContractMaxDepthExceedErrorWasm::new(*depth, code).into()
         }
         BasicError::InvalidDocumentTypeError {
             document_type,
@@ -457,6 +458,9 @@ fn from_basic_error(basic_error: &Box<BasicError>) -> JsValue {
             code,
         )
         .into(),
+        BasicError::MissingDocumentTransitionTypeError => {
+            MissingDocumentTransitionTypeErrorWasm::new(code).into()
+        }
         BasicError::MissingDocumentTypeError => MissingDocumentTypeErrorWasm::new(code).into(),
         BasicError::MissingDocumentTransitionActionError => {
             MissingDocumentTransitionActionErrorWasm::new(code).into()
@@ -472,8 +476,11 @@ fn from_basic_error(basic_error: &Box<BasicError>) -> JsValue {
             InvalidDocumentTransitionIdErrorWasm::new(expected_id.clone(), invalid_id.clone(), code)
                 .into()
         }
+        BasicError::DuplicateDocumentTransitionsWithIndicesError { references } => {
+            DuplicateDocumentTransitionsWithIndicesErrorWasm::new(references.clone(), code).into()
+        }
         BasicError::DuplicateDocumentTransitionsWithIdsError { references } => {
-            DuplicateDocumentTransitionsWithIdsError::new(references.clone(), code).into()
+            DuplicateDocumentTransitionsWithIdsErrorWasm::new(references.clone(), code).into()
         }
         BasicError::MissingDataContractIdError => MissingDataContractIdErrorWasm::new(code).into(),
         BasicError::InvalidIdentifierError {

package/src/errors/from.rs

@@ -19,6 +19,6 @@ pub fn from_dpp_err(pe: ProtocolError) -> JsValue {
         )
         .into(),
 
-        _ => JsValue::from_str(&format!("Kek: {:#}", pe,)),
+        _ => JsValue::from_str(&format!("Error conversion not implemented: {pe:#}",)),
     }
 }

package/src/errors/mod.rs

@@ -5,6 +5,7 @@ pub mod consensus;
 pub mod consensus_error;
 mod from;
 mod js_conversion;
+pub mod protocol_error;
 mod public_key_validation_error;
 
 pub use public_key_validation_error::*;

package/src/errors/protocol_error.rs

@@ -0,0 +1,12 @@
+use wasm_bindgen::JsValue;
+
+use super::consensus_error::from_consensus_error;
+
+pub fn from_protocol_error(e: dpp::ProtocolError) -> JsValue {
+    match e {
+        dpp::ProtocolError::AbstractConsensusError(consensus_error) => {
+            from_consensus_error(*consensus_error)
+        }
+        _ => unimplemented!(),
+    }
+}

package/src/{identity_facade.rs → identity/identity_facade.rs}

@@ -6,7 +6,7 @@ use dpp::identity::validation::PublicKeysValidator;
 use dpp::identity::IdentityFacade;
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
-use crate::validation_result::ValidationResultWasm;
+use crate::validation::ValidationResultWasm;
 use dpp::version::ProtocolVersionValidator;
 use dpp::NonConsensusError;
 

package/src/{identity_public_key → identity/identity_public_key}/mod.rs

@@ -14,9 +14,6 @@ mod security_level;
 pub use security_level::*;
 
 mod key_type;
-mod public_keys_validator;
-
-pub use public_keys_validator::*;
 
 pub use key_type::*;