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

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/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_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::*;
 

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

@@ -1,3 +1,7 @@
+pub mod identity_facade;
+mod identity_public_key;
+mod validation;
+
 use js_sys::Array;
 use serde_json::Value;
 use wasm_bindgen::prelude::*;
@@ -12,8 +16,8 @@ use crate::errors::from_dpp_err;
 use crate::identifier::IdentifierWrapper;
 use crate::utils;
 use crate::utils::to_vec_of_serde_values;
-use crate::IdentityPublicKeyWasm;
 use crate::MetadataWasm;
+pub use identity_public_key::*;
 
 #[wasm_bindgen(js_name=Identity)]
 #[derive(Clone)]
@@ -60,12 +64,7 @@ impl IdentityWasm {
             .into_iter()
             .map(IdentityPublicKey::from_json_object)
             .collect::<Result<_, _>>()
-            .map_err(|e| {
-                format!(
-                    "converting to collection of IdentityPublicKeys failed: {:#}",
-                    e
-                )
-            })?;
+            .map_err(|e| format!("converting to collection of IdentityPublicKeys failed: {e:#}"))?;
 
         self.0.set_public_keys(public_keys);
 

package/src/identity/validation/mod.rs

@@ -0,0 +1,3 @@
+mod public_keys_validator;
+
+pub use public_keys_validator::*;

package/src/identity/validation/public_keys_validator.rs

@@ -0,0 +1,70 @@
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+
+use crate::utils::{to_vec_of_serde_values, ToSerdeJSONExt};
+use crate::validation::ValidationResultWasm;
+use dpp::identity::validation::{
+    PublicKeysValidator, TPublicKeysValidator, PUBLIC_KEY_SCHEMA_FOR_TRANSITION,
+};
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = PublicKeysValidator)]
+pub struct PublicKeysValidatorWasm {
+    public_key_validator: PublicKeysValidator<BlsAdapter>,
+    public_key_in_state_transition_validator: PublicKeysValidator<BlsAdapter>,
+}
+
+#[wasm_bindgen(js_class = PublicKeysValidator)]
+impl PublicKeysValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(adapter: JsBlsAdapter) -> Result<PublicKeysValidatorWasm, JsError> {
+        Ok(Self {
+            public_key_validator: PublicKeysValidator::new(BlsAdapter(JsBlsAdapter::from(
+                adapter.clone(),
+            )))?,
+            public_key_in_state_transition_validator: PublicKeysValidator::new_with_schema(
+                PUBLIC_KEY_SCHEMA_FOR_TRANSITION.clone(),
+                BlsAdapter(adapter),
+            )?,
+        })
+    }
+
+    #[wasm_bindgen(js_name=validateKeys)]
+    pub fn validate_keys(
+        &self,
+        public_keys: js_sys::Array,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
+
+        self.public_key_validator
+            .validate_keys(&raw_public_keys)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name=validatePublicKeyStructure)]
+    pub fn validate_public_key_structure(
+        &self,
+        public_key: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let pk_serde_json = public_key.to_serde_json_value()?;
+
+        self.public_key_validator
+            .validate_public_key_structure(&pk_serde_json)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name=validateKeysInStateTransition)]
+    pub fn validate_keys_in_state_transition(
+        &self,
+        public_keys: js_sys::Array,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
+
+        self.public_key_in_state_transition_validator
+            .validate_keys(&raw_public_keys)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+}

package/src/lib.rs

@@ -3,9 +3,6 @@ pub use data_contract::*;
 pub use data_contract_factory::*;
 pub use document::*;
 pub use identity::*;
-pub use identity::*;
-pub use identity_facade::*;
-pub use identity_public_key::*;
 pub use metadata::*;
 pub use state_transition::*;
 
@@ -16,8 +13,6 @@ mod document;
 pub mod errors;
 mod identifier;
 mod identity;
-mod identity_facade;
-mod identity_public_key;
 mod metadata;
 mod state_repository;
 mod state_transition;
@@ -26,4 +21,4 @@ mod utils;
 
 mod bls_adapter;
 mod buffer;
-pub mod validation_result;
+mod validation;

package/src/utils.rs

@@ -41,8 +41,8 @@ where
 pub fn to_serde_json_value(data: &JsValue) -> Result<Value, JsValue> {
     let data = stringify(data)?;
     let value: Value = serde_json::from_str(&data)
-        .with_context(|| format!("cant convert {:#?} to serde json value", data))
-        .map_err(|e| format!("{:#}", e))?;
+        .with_context(|| format!("cant convert {data:#?} to serde json value"))
+        .map_err(|e| format!("{e:#}"))?;
     Ok(value)
 }
 

package/src/validation/mod.rs

@@ -0,0 +1,3 @@
+mod validation_result;
+
+pub use validation_result::*;

package/test/integration/identity/stateTransition/IdentityUpdateTransition/validation/state/validateIdentityUpdateTransitionStateFactory.spec.js

@@ -36,7 +36,7 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
 
     blockTime = Date.now();
 
-    stateRepositoryMock.fetchLatestPlatformBlockTime.returns(blockTime);
+    stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTime);
 
     validateIdentityUpdateTransitionState = validateIdentityUpdateTransitionStateFactory(
       stateRepositoryMock,