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

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

@@ -1,11 +1,13 @@
 mod apply;
 mod validation;
 
+use std::collections::HashMap;
+
 pub use apply::*;
 pub use validation::*;
 
 use dpp::{
-    data_contract::state_transition::DataContractCreateTransition,
+    data_contract::state_transition::data_contract_create_transition::DataContractCreateTransition,
     state_transition::{
         StateTransitionConvert, StateTransitionIdentitySigned, StateTransitionLike,
     },
@@ -13,13 +15,15 @@ use dpp::{
 use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::protocol_error::from_protocol_error;
 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, IdentityPublicKeyWasm,
+    StateTransitionExecutionContextWasm,
 };
 
+#[derive(Clone)]
 #[wasm_bindgen(js_name=DataContractCreateTransition)]
 pub struct DataContractCreateTransitionWasm(DataContractCreateTransition);
 
@@ -38,15 +42,14 @@ impl From<DataContractCreateTransitionWasm> for DataContractCreateTransition {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct DataContractCreateTransitionParameters {
-    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>>,
+    #[serde(flatten)]
+    extra: HashMap<String, serde_json::Value>,
 }
 
 #[wasm_bindgen(js_class=DataContractCreateTransition)]
@@ -79,7 +82,7 @@ impl DataContractCreateTransitionWasm {
 
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
-        self.0.get_owner_id().clone().into()
+        (*self.0.get_owner_id()).into()
     }
 
     #[wasm_bindgen(js_name=getType)]
@@ -112,7 +115,7 @@ impl DataContractCreateTransitionWasm {
         self.0
             .get_modified_data_ids()
             .into_iter()
-            .map(|identifier| Into::<IdentifierWrapper>::into(identifier.clone()).into())
+            .map(|identifier| Into::<IdentifierWrapper>::into(identifier).into())
             .collect()
     }
 
@@ -135,4 +138,32 @@ impl DataContractCreateTransitionWasm {
     pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) {
         self.0.set_execution_context(context.into())
     }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
+        let serde_object = self
+            .0
+            .to_object(skip_signature.unwrap_or(false))
+            .map_err(from_protocol_error)?;
+        serde_object
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .map_err(|e| e.into())
+    }
+
+    #[wasm_bindgen]
+    pub fn sign(
+        &mut self,
+        identity_public_key: &IdentityPublicKeyWasm,
+        private_key: Vec<u8>,
+        bls: JsBlsAdapter,
+    ) -> Result<(), JsValue> {
+        let bls_adapter = BlsAdapter(bls);
+        self.0
+            .sign(
+                &identity_public_key.to_owned().into(),
+                &private_key,
+                &bls_adapter,
+            )
+            .map_err(from_dpp_err)
+    }
 }

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

@@ -1,4 +1,14 @@
-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 std::sync::Arc;
+
+use dpp::{
+    data_contract::state_transition::data_contract_create_transition::validation::state::{
+        validate_data_contract_create_transition_basic::DataContractCreateTransitionBasicValidator,
+        validate_data_contract_create_transition_state::validate_data_contract_create_transition_state as dpp_validate_data_contract_create_transition_state,
+    },
+    state_transition::state_transition_execution_context::StateTransitionExecutionContext,
+    validation::DataValidatorWithContext,
+    version::ProtocolVersionValidator,
+};
 use wasm_bindgen::prelude::*;
 
 use crate::validation::ValidationResultWasm;
@@ -8,17 +18,38 @@ use crate::{
     DataContractCreateTransitionWasm,
 };
 
+use super::DataContractCreateTransitionParameters;
+
 #[wasm_bindgen(js_name=validateDataContractCreateTransitionState)]
 pub async fn validate_data_contract_create_transition_state(
     state_repository: ExternalStateRepositoryLike,
     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::<ValidationResultWasm>::into)
-    .map_err(from_dpp_err)
+    .map_err(from_dpp_err)?;
+    Ok(validation_result.map(|_| JsValue::undefined()).into())
+}
+
+#[wasm_bindgen(js_name=validateDataContractCreateTransitionBasic)]
+pub async fn validate_data_contract_create_transition_basic(
+    raw_parameters: JsValue,
+) -> Result<ValidationResultWasm, JsError> {
+    let parameters: DataContractCreateTransitionParameters =
+        serde_wasm_bindgen::from_value(raw_parameters)?;
+
+    let validator = DataContractCreateTransitionBasicValidator::new(Arc::new(
+        ProtocolVersionValidator::default(),
+    ))?;
+
+    let validation_result = validator.validate(
+        &serde_json::to_value(&parameters)?,
+        &StateTransitionExecutionContext::default(),
+    )?;
+
+    Ok(validation_result.map(|_| JsValue::undefined()).into())
 }

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

@@ -1,6 +1,6 @@
 use std::ops::Deref;
 
-use dpp::data_contract::state_transition::apply_data_contract_update_transition_factory::ApplyDataContractUpdateTransition;
+use dpp::data_contract::state_transition::data_contract_update_transition::apply_data_contract_update_transition_factory::ApplyDataContractUpdateTransition;
 use wasm_bindgen::prelude::*;
 
 use crate::{

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

@@ -1,11 +1,13 @@
 mod apply;
 mod validation;
 
+use std::collections::HashMap;
+
 pub use apply::*;
 pub use validation::*;
 
 use dpp::{
-    data_contract::state_transition::DataContractUpdateTransition,
+    data_contract::state_transition::data_contract_update_transition::DataContractUpdateTransition,
     state_transition::{
         StateTransitionConvert, StateTransitionIdentitySigned, StateTransitionLike,
     },
@@ -15,11 +17,12 @@ use wasm_bindgen::prelude::*;
 
 use crate::{
     buffer::Buffer,
-    errors::{from_dpp_err, RustConversionError},
+    errors::{from_dpp_err, protocol_error::from_protocol_error},
     identifier::IdentifierWrapper,
     with_js_error, DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
 };
 
+#[derive(Clone)]
 #[wasm_bindgen(js_name=DataContractUpdateTransition)]
 pub struct DataContractUpdateTransitionWasm(DataContractUpdateTransition);
 
@@ -38,15 +41,14 @@ impl From<DataContractUpdateTransitionWasm> for DataContractUpdateTransition {
 #[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>>,
+    #[serde(flatten)]
+    extra: HashMap<String, serde_json::Value>,
 }
 
 #[wasm_bindgen(js_class=DataContractUpdateTransition)]
@@ -79,7 +81,7 @@ impl DataContractUpdateTransitionWasm {
 
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
-        self.0.get_owner_id().clone().into()
+        (*self.0.get_owner_id()).into()
     }
 
     #[wasm_bindgen(js_name=getType)]
@@ -112,7 +114,7 @@ impl DataContractUpdateTransitionWasm {
         self.0
             .get_modified_data_ids()
             .into_iter()
-            .map(|identifier| Into::<IdentifierWrapper>::into(identifier.clone()).into())
+            .map(|identifier| Into::<IdentifierWrapper>::into(identifier).into())
             .collect()
     }
 
@@ -144,4 +146,15 @@ impl DataContractUpdateTransitionWasm {
             .map_err(from_dpp_err)?;
         Ok(Buffer::from_bytes(&bytes))
     }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
+        let serde_object = self
+            .0
+            .to_object(skip_signature.unwrap_or(false))
+            .map_err(from_protocol_error)?;
+        serde_object
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .map_err(|e| e.into())
+    }
 }

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

@@ -1,16 +1,24 @@
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, sync::Arc};
 
-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 dpp::validation::AsyncDataValidatorWithContext;
+use dpp::{
+    data_contract::state_transition::data_contract_update_transition::validation::{
+        basic::{
+            validate_indices_are_backward_compatible as dpp_validate_indices_are_backward_compatible,
+            DataContractUpdateTransitionBasicValidator,
+        },
+        state::validate_data_contract_update_transition_state::validate_data_contract_update_transition_state as dpp_validate_data_contract_update_transition_state,
+    },
+    version::ProtocolVersionValidator,
 };
 use wasm_bindgen::prelude::*;
 
 use crate::{
+    data_contract::state_transition::data_contract_update_transition::DataContractUpdateTransitionParameters,
     errors::{from_dpp_err, protocol_error::from_protocol_error},
     state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
     validation::ValidationResultWasm,
-    DataContractUpdateTransitionWasm,
+    DataContractUpdateTransitionWasm, StateTransitionExecutionContextWasm,
 };
 
 #[wasm_bindgen(js_name=validateDataContractUpdateTransitionState)]
@@ -19,13 +27,14 @@ pub async fn validate_data_contract_update_transition_state(
     state_transition: DataContractUpdateTransitionWasm,
 ) -> Result<ValidationResultWasm, JsValue> {
     let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
-    dpp_validate_data_contract_update_transition_state(
+    let result = dpp_validate_data_contract_update_transition_state(
         &wrapped_state_repository,
         &state_transition.into(),
     )
     .await
-    .map(Into::into)
-    .map_err(from_dpp_err)
+    .map_err(from_dpp_err)?;
+
+    Ok(result.map(|_| JsValue::undefined()).into())
 }
 
 #[wasm_bindgen(js_name=validateIndicesAreBackwardCompatible)]
@@ -40,7 +49,34 @@ pub fn validate_indices_are_backward_compatible(
         new_documents_schema,
     )?;
 
-    dpp_validate_indices_are_backward_compatible(old_documents.iter(), new_documents.iter())
-        .map(Into::into)
-        .map_err(from_protocol_error)
+    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())
+}
+
+#[wasm_bindgen(js_name=validateDataContractUpdateTransitionBasic)]
+pub async fn validate_data_contract_update_transition_basic(
+    state_repository: ExternalStateRepositoryLike,
+    raw_parameters: JsValue,
+    execution_context: &StateTransitionExecutionContextWasm,
+) -> Result<ValidationResultWasm, JsError> {
+    let parameters: DataContractUpdateTransitionParameters =
+        serde_wasm_bindgen::from_value(raw_parameters)?;
+
+    let validator: DataContractUpdateTransitionBasicValidator<ExternalStateRepositoryLikeWrapper> =
+        DataContractUpdateTransitionBasicValidator::new(
+            Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository)),
+            Arc::new(ProtocolVersionValidator::default()),
+        )?;
+
+    let validation_result = validator
+        .validate(
+            &serde_json::to_value(&parameters)?,
+            &execution_context.into(),
+        )
+        .await?;
+
+    Ok(validation_result.map(|_| JsValue::undefined()).into())
 }

package/src/data_contract_factory/data_contract_factory.rs

@@ -1,4 +1,5 @@
 use std::convert::TryInto;
+use std::sync::Arc;
 
 use dpp::{
     data_contract::{
@@ -12,10 +13,7 @@ use wasm_bindgen::prelude::*;
 
 use crate::{
     data_contract::errors::InvalidDataContractError,
-    errors::{
-        consensus_error::from_consensus_error, from_dpp_err, protocol_error::from_protocol_error,
-        RustConversionError,
-    },
+    errors::{from_dpp_err, protocol_error::from_protocol_error},
     validation::ValidationResultWasm,
     with_js_error, DataContractCreateTransitionWasm, DataContractParameters, DataContractWasm,
 };
@@ -35,6 +33,12 @@ impl From<DataContractValidatorWasm> for DataContractValidator {
     }
 }
 
+impl Default for DataContractValidatorWasm {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[wasm_bindgen(js_class=DataContractValidator)]
 impl DataContractValidatorWasm {
     #[wasm_bindgen(constructor)]
@@ -42,15 +46,14 @@ impl DataContractValidatorWasm {
         DataContractValidator::new(std::sync::Arc::new(ProtocolVersionValidator::default())).into()
     }
 
-    #[wasm_bindgen(js_name=validate)]
+    #[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");
-        self.0
-            .validate(&json_object)
-            .map(Into::into)
-            .map_err(from_protocol_error)
+
+        let validation_result = self.0.validate(&json_object).map_err(from_protocol_error)?;
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
     }
 }
 
@@ -97,11 +100,11 @@ impl DataContractFactoryWasm {
         if let Some(external_entropy_generator) = external_entropy_generator_arg {
             DataContractFactory::new_with_entropy_generator(
                 protocol_version,
-                validate_data_contract.into(),
+                Arc::new(validate_data_contract.into()),
                 Box::new(external_entropy_generator),
             )
         } else {
-            DataContractFactory::new(protocol_version, validate_data_contract.into())
+            DataContractFactory::new(protocol_version, Arc::new(validate_data_contract.into()))
         }
         .into()
     }
@@ -116,7 +119,7 @@ impl DataContractFactoryWasm {
             with_js_error!(serde_wasm_bindgen::from_value(documents))?;
         let identifier = Identifier::from_bytes(&owner_id).map_err(from_dpp_err)?;
         self.0
-            .create(identifier, documents_json)
+            .create(identifier, documents_json, None)
             .map(Into::into)
             .map_err(from_dpp_err)
     }
@@ -136,9 +139,8 @@ impl DataContractFactoryWasm {
             .await;
         match result {
             Ok(data_contract) => Ok(data_contract.into()),
-            Err(dpp::ProtocolError::InvalidDataContractError { errors, .. }) => {
-                let js_errors = errors.into_iter().map(from_consensus_error).collect();
-                Err(InvalidDataContractError::new(js_errors, object).into())
+            Err(dpp::ProtocolError::InvalidDataContractError(err)) => {
+                Err(InvalidDataContractError::new(err.errors, object).into())
             }
             Err(other) => Err(from_dpp_err(other)),
         }
@@ -160,10 +162,10 @@ impl DataContractFactoryWasm {
     #[wasm_bindgen(js_name=createDataContractCreateTransition)]
     pub async fn create_data_contract_create_transition(
         &self,
-        data_contract: DataContractWasm,
+        data_contract: &DataContractWasm,
     ) -> Result<DataContractCreateTransitionWasm, JsValue> {
         self.0
-            .create_data_contract_create_transition(data_contract.into())
+            .create_data_contract_create_transition(data_contract.clone().into())
             .map(Into::into)
             .map_err(from_dpp_err)
     }

package/src/data_trigger/data_trigger_execution_context.rs

@@ -0,0 +1,95 @@
+use std::sync::Arc;
+
+use dpp::{data_trigger::DataTriggerExecutionContext, state_repository::StateRepositoryLike};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    identifier::{identifier_from_js_value, IdentifierWrapper},
+    state_repository::ExternalStateRepositoryLike,
+    utils::Inner,
+    DataContractWasm, StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name=DataTriggerExecutionContext)]
+pub struct DataTriggerExecutionContextWasm {
+    state_repository: Arc<ExternalStateRepositoryLike>,
+    owner_id: IdentifierWrapper,
+    data_contract: DataContractWasm,
+    state_transition_execution_context: StateTransitionExecutionContextWasm,
+}
+
+#[wasm_bindgen(js_class=DataTriggerExecutionContext)]
+impl DataTriggerExecutionContextWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+        js_owner_id: &JsValue,
+        data_contract: DataContractWasm,
+        state_transition_execution_context: StateTransitionExecutionContextWasm,
+    ) -> Result<DataTriggerExecutionContextWasm, JsValue> {
+        let owner_id: IdentifierWrapper = identifier_from_js_value(js_owner_id)?.into();
+
+        Ok(Self {
+            state_repository: Arc::new(state_repository),
+            owner_id,
+            data_contract,
+            state_transition_execution_context,
+        })
+    }
+
+    #[wasm_bindgen(getter, js_name=ownerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.owner_id.clone()
+    }
+
+    #[wasm_bindgen(setter, js_name=ownerId)]
+    pub fn set_owner_id(&mut self, owner_id: &JsValue) -> Result<(), JsValue> {
+        let id = identifier_from_js_value(owner_id)?;
+        self.owner_id = id.into();
+        Ok(())
+    }
+
+    #[wasm_bindgen(getter, js_name=dataContract)]
+    pub fn get_data_contract(&self) -> DataContractWasm {
+        self.data_contract.clone()
+    }
+
+    #[wasm_bindgen(setter, js_name=dataContract)]
+    pub fn set_data_contract(&mut self, data_contract: &DataContractWasm) {
+        self.data_contract = data_contract.clone();
+    }
+
+    #[wasm_bindgen(getter, js_name=stateTransitionExecutionContext)]
+    pub fn get_state_transition_execution_context(&self) -> StateTransitionExecutionContextWasm {
+        self.state_transition_execution_context.clone()
+    }
+
+    #[wasm_bindgen(setter, js_name=statTransitionExecutionContext)]
+    pub fn set_state_transition_execution_context(
+        &mut self,
+        context: &StateTransitionExecutionContextWasm,
+    ) {
+        self.state_transition_execution_context = context.clone();
+    }
+}
+
+impl DataTriggerExecutionContextWasm {
+    pub fn state_repository(&self) -> Arc<ExternalStateRepositoryLike> {
+        self.state_repository.clone()
+    }
+}
+
+pub(crate) fn data_trigger_context_from_wasm<'a, SR>(
+    value: &'a DataTriggerExecutionContextWasm,
+    external_state_repository: &'a SR,
+) -> DataTriggerExecutionContext<'a, SR>
+where
+    SR: StateRepositoryLike,
+{
+    DataTriggerExecutionContext {
+        data_contract: value.data_contract.inner(),
+        owner_id: value.owner_id.inner(),
+        state_transition_execution_context: value.state_transition_execution_context.inner(),
+        state_repository: external_state_repository,
+    }
+}

package/src/data_trigger/data_trigger_execution_result.rs

@@ -0,0 +1,48 @@
+use dpp::data_trigger::DataTriggerExecutionResult;
+use js_sys::Array;
+use wasm_bindgen::prelude::*;
+
+use crate::{errors::consensus_error::from_state_error, utils::Inner};
+
+#[wasm_bindgen(js_name=DataTriggerExecutionResult)]
+pub struct DataTriggerExecutionResultWasm(DataTriggerExecutionResult);
+
+impl From<DataTriggerExecutionResult> for DataTriggerExecutionResultWasm {
+    fn from(value: DataTriggerExecutionResult) -> Self {
+        DataTriggerExecutionResultWasm(value)
+    }
+}
+
+#[wasm_bindgen(js_class=DataTriggerExecutionResult)]
+impl DataTriggerExecutionResultWasm {
+    #[wasm_bindgen(js_name=isOk)]
+    pub fn is_ok(&self) -> bool {
+        self.0.errors.is_empty()
+    }
+
+    #[wasm_bindgen(js_name=getErrors)]
+    pub fn get_errors(&self) -> Array {
+        let errors = self.0.get_errors().iter().map(from_state_error);
+        let array_with_errors = Array::new();
+        for error in errors {
+            array_with_errors.push(&error);
+        }
+        array_with_errors
+    }
+}
+
+impl Inner for DataTriggerExecutionResultWasm {
+    type InnerItem = DataTriggerExecutionResult;
+
+    fn into_inner(self) -> Self::InnerItem {
+        self.0
+    }
+
+    fn inner(&self) -> &Self::InnerItem {
+        &self.0
+    }
+
+    fn inner_mut(&mut self) -> &mut Self::InnerItem {
+        &mut self.0
+    }
+}

package/src/data_trigger/execute_data_triggers_factory.rs

@@ -0,0 +1,60 @@
+use dpp::document::validation::state::execute_data_triggers::execute_data_triggers_with_custom_list;
+use itertools::Itertools;
+use js_sys::Array;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    document_batch_transition::document_transition::DocumentTransitionWasm,
+    state_repository::ExternalStateRepositoryLikeWrapper,
+    utils::{Inner, IntoWasm, WithJsError},
+    DataTriggerWasm,
+};
+
+use super::{
+    data_trigger_execution_context::{
+        data_trigger_context_from_wasm, DataTriggerExecutionContextWasm,
+    },
+    data_trigger_execution_result::DataTriggerExecutionResultWasm,
+};
+
+#[wasm_bindgen(js_name=executeDataTriggers)]
+pub async fn execute_data_triggers_wasm(
+    js_document_transitions: Array,
+    js_context: DataTriggerExecutionContextWasm,
+    js_data_triggers: Array,
+) -> Result<Array, JsValue> {
+    let st_wrapper =
+        ExternalStateRepositoryLikeWrapper::new_with_arc(js_context.state_repository());
+    let context = data_trigger_context_from_wasm(&js_context, &st_wrapper);
+    let document_transitions: Vec<_> = js_document_transitions
+        .iter()
+        .map(|v| {
+            v.to_wasm::<DocumentTransitionWasm>("DocumentTransition")
+                .map(|v| v.to_owned())
+        })
+        .try_collect()?;
+
+    let data_triggers: Vec<_> = js_data_triggers
+        .iter()
+        .map(|v| {
+            v.to_wasm::<DataTriggerWasm>("DataTrigger")
+                .map(|v| v.to_owned().into_inner())
+        })
+        .try_collect()?;
+
+    let results = execute_data_triggers_with_custom_list(
+        document_transitions.iter().map(|v| v.inner()),
+        &context,
+        data_triggers,
+    )
+    .await
+    .with_js_error()?;
+
+    let array_with_results = js_sys::Array::new();
+    for result in results {
+        let result_wasm: DataTriggerExecutionResultWasm = result.into();
+        array_with_results.push(&result_wasm.into());
+    }
+
+    Ok(array_with_results)
+}