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

package/src/data_trigger/get_data_triggers_factory.rs

@@ -0,0 +1,65 @@
+use std::{convert::TryFrom, iter::FromIterator};
+
+use dpp::{
+    data_trigger::get_data_triggers_factory::{data_triggers, get_data_triggers},
+    document::document_transition::Action,
+    prelude::{DataTrigger, Identifier},
+};
+use itertools::Itertools;
+use js_sys::Array;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    identifier::IdentifierWrapper,
+    utils::{Inner, IntoWasm, WithJsError},
+};
+
+use super::DataTriggerWasm;
+
+#[wasm_bindgen(js_name=getDataTriggers)]
+pub fn get_data_triggers_wasm(
+    js_data_contract_id: &IdentifierWrapper,
+    document_type: String,
+    transition_action_string: String,
+    data_triggers_list: Array,
+) -> Result<Array, JsValue> {
+    let transition_action = Action::try_from(transition_action_string).with_js_error()?;
+    let data_contract_id: Identifier = js_data_contract_id.into();
+
+    let data_triggers: Vec<DataTrigger> = data_triggers_list
+        .iter()
+        .map(|value| {
+            value
+                .to_wasm::<DataTriggerWasm>("DataTrigger")
+                .map(|v| v.to_owned().into_inner())
+        })
+        .try_collect()?;
+
+    let data_triggers: Vec<JsValue> = get_data_triggers(
+        &data_contract_id,
+        &document_type,
+        transition_action,
+        data_triggers.iter(),
+    )
+    .with_js_error()?
+    .into_iter()
+    .map(|dt| DataTriggerWasm::from(dt).into())
+    .collect();
+
+    Ok(js_sys::Array::from_iter(data_triggers))
+}
+
+#[wasm_bindgen(js_name=getAllDataTriggers)]
+pub fn get_all_data_triggers() -> Result<Array, JsValue> {
+    let data_triggers: Vec<DataTriggerWasm> = data_triggers()
+        .with_js_error()?
+        .into_iter()
+        .map(DataTriggerWasm::from)
+        .collect();
+    let array_with_data_triggers = js_sys::Array::new();
+    for data_trigger in data_triggers {
+        array_with_data_triggers.push(&data_trigger.into());
+    }
+
+    Ok(array_with_data_triggers)
+}

package/src/data_trigger/mod.rs

@@ -0,0 +1,121 @@
+use std::convert::TryFrom;
+
+use dpp::{document::document_transition::Action, prelude::DataTrigger};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    identifier::{identifier_from_js_value, IdentifierWrapper},
+    utils::{Inner, WithJsError},
+};
+pub mod data_trigger_execution_context;
+pub mod data_trigger_execution_result;
+pub mod execute_data_triggers_factory;
+pub mod get_data_triggers_factory;
+
+#[wasm_bindgen(js_name=DataTrigger)]
+#[derive(Clone)]
+pub struct DataTriggerWasm(DataTrigger);
+
+impl From<DataTrigger> for DataTriggerWasm {
+    fn from(value: DataTrigger) -> Self {
+        DataTriggerWasm(value)
+    }
+}
+
+impl From<&DataTrigger> for DataTriggerWasm {
+    fn from(value: &DataTrigger) -> Self {
+        DataTriggerWasm(value.clone())
+    }
+}
+
+impl From<DataTriggerWasm> for DataTrigger {
+    fn from(value: DataTriggerWasm) -> Self {
+        value.0
+    }
+}
+
+impl From<&DataTriggerWasm> for DataTrigger {
+    fn from(value: &DataTriggerWasm) -> Self {
+        value.0.clone()
+    }
+}
+
+#[wasm_bindgen(js_class=DataTrigger)]
+impl DataTriggerWasm {
+    #[wasm_bindgen(getter=dataContractId)]
+    pub fn get_data_contract_id(&self) -> IdentifierWrapper {
+        self.0.data_contract_id.into()
+    }
+
+    #[wasm_bindgen(setter=dataContractId)]
+    pub fn set_data_contract_id(&mut self, id: &JsValue) -> Result<(), JsValue> {
+        let id = identifier_from_js_value(id)?;
+        self.0.data_contract_id = id;
+        Ok(())
+    }
+
+    #[wasm_bindgen(getter=documentType)]
+    pub fn get_document_type(&self) -> String {
+        self.0.document_type.to_string()
+    }
+
+    #[wasm_bindgen(setter=documentType)]
+    pub fn set_document_type(&mut self, id: String) {
+        self.0.document_type = id;
+    }
+
+    #[wasm_bindgen(getter=dataTriggerKind)]
+    pub fn get_data_trigger_kind(&self) -> String {
+        let data_trigger_string: &str = self.0.data_trigger_kind.into();
+        data_trigger_string.to_owned()
+    }
+
+    #[wasm_bindgen(getter=transitionAction)]
+    pub fn get_transition_action(&self) -> String {
+        self.0.transition_action.to_string()
+    }
+
+    #[wasm_bindgen(setter=transitionAction)]
+    pub fn set_transition_action(&mut self, action_string: String) -> Result<(), JsValue> {
+        let action = Action::try_from(action_string).with_js_error()?;
+        self.0.transition_action = action;
+        Ok(())
+    }
+
+    #[wasm_bindgen(getter=topLevelIdentity)]
+    pub fn get_top_level_identity(&self) -> JsValue {
+        if let Some(ref id) = self.0.top_level_identity {
+            let id: IdentifierWrapper = id.to_owned().into();
+            id.into()
+        } else {
+            JsValue::undefined()
+        }
+    }
+
+    #[wasm_bindgen(setter=topLevelIdentity)]
+    pub fn set_top_level_identity(&mut self, maybe_id: &JsValue) -> Result<(), JsValue> {
+        if maybe_id.is_undefined() || maybe_id.is_null() {
+            self.0.top_level_identity = None
+        } else {
+            let id = identifier_from_js_value(maybe_id)?;
+            self.0.top_level_identity = Some(id);
+        }
+        Ok(())
+    }
+}
+
+impl Inner for DataTriggerWasm {
+    type InnerItem = DataTrigger;
+
+    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/document/document_facade.rs

@@ -0,0 +1,125 @@
+use std::sync::Arc;
+
+use wasm_bindgen::{prelude::*, JsValue};
+
+use crate::{
+    fetch_and_validate_data_contract::DataContractFetcherAndValidatorWasm,
+    utils::{get_class_name, IntoWasm},
+    validation::ValidationResultWasm,
+    DataContractWasm, DocumentFactoryWASM, DocumentValidatorWasm, DocumentWasm,
+    DocumentsBatchTransitionWasm,
+};
+
+#[derive(Clone)]
+#[wasm_bindgen(js_name=DocumentFacade)]
+pub struct DocumentFacadeWasm {
+    validator: Arc<DocumentValidatorWasm>,
+    factory: Arc<DocumentFactoryWASM>,
+    data_contract_fetcher_and_validator: Arc<DataContractFetcherAndValidatorWasm>,
+}
+
+impl DocumentFacadeWasm {
+    pub fn new_with_arc(
+        document_validator: Arc<DocumentValidatorWasm>,
+        document_factory: Arc<DocumentFactoryWASM>,
+        data_contract_fetcher_and_validator: Arc<DataContractFetcherAndValidatorWasm>,
+    ) -> Self {
+        Self {
+            validator: document_validator,
+            factory: document_factory,
+            data_contract_fetcher_and_validator,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=DocumentFacade)]
+impl DocumentFacadeWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        document_validator: DocumentValidatorWasm,
+        document_factory: DocumentFactoryWASM,
+        data_contract_fetcher_and_validator: DataContractFetcherAndValidatorWasm,
+    ) -> Self {
+        Self {
+            validator: Arc::new(document_validator),
+            factory: Arc::new(document_factory),
+            data_contract_fetcher_and_validator: Arc::new(data_contract_fetcher_and_validator),
+        }
+    }
+
+    #[wasm_bindgen(js_name=create)]
+    pub fn create(
+        &self,
+        data_contract: &DataContractWasm,
+        js_owner_id: &JsValue,
+        document_type: &str,
+        data: &JsValue,
+    ) -> Result<DocumentWasm, JsValue> {
+        self.factory
+            .create(data_contract, js_owner_id, document_type, data)
+    }
+
+    /// Creates Document from object
+    #[wasm_bindgen(js_name=createFromObject)]
+    pub async fn create_from_object(
+        &self,
+        raw_document: JsValue,
+        options: JsValue,
+    ) -> Result<DocumentWasm, JsValue> {
+        self.factory.create_from_object(raw_document, options).await
+    }
+
+    /// Creates Document form bytes
+    #[wasm_bindgen(js_name=createFromBuffer)]
+    pub async fn create_from_buffer(
+        &self,
+        bytes: Vec<u8>,
+        options: JsValue,
+    ) -> Result<DocumentWasm, JsValue> {
+        self.factory.create_from_buffer(bytes, &options).await
+    }
+
+    /// Creates Documents State Transition
+    #[wasm_bindgen(js_name=createStateTransition)]
+    pub fn create_state_transition(
+        &self,
+        documents: &JsValue, // documents_container: DocumentsContainer,
+    ) -> Result<DocumentsBatchTransitionWasm, JsValue> {
+        self.factory.create_state_transition(documents)
+    }
+
+    /// Creates Documents State Transition
+    #[wasm_bindgen(js_name=validate)]
+    pub async fn validate_document(
+        &self,
+        document: &JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let raw_document = if get_class_name(document) == "Document" {
+            let document = document.to_wasm::<DocumentWasm>("Document")?;
+            document.to_object(&JsValue::NULL)?
+        } else {
+            document.to_owned()
+        };
+
+        self.validate_raw_document(raw_document).await
+    }
+
+    /// Creates Documents State Transition
+    pub async fn validate_raw_document(
+        &self,
+        js_raw_document: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let result = self
+            .data_contract_fetcher_and_validator
+            .validate(&js_raw_document)
+            .await?;
+        if !result.is_valid() {
+            return Ok(result);
+        }
+        let data_contract = result
+            .get_data()
+            .to_wasm::<DataContractWasm>("DataContract")?;
+
+        self.validator.validate(&js_raw_document, &data_contract)
+    }
+}

package/src/document/errors/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()
     }