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

package/src/document/factory.rs

@@ -0,0 +1,257 @@
+use std::{collections::HashMap, convert::TryFrom, sync::Arc};
+
+use anyhow::anyhow;
+
+use dpp::{
+    document::{
+        self,
+        document_factory::{DocumentFactory, FactoryOptions},
+        document_transition::Action,
+        fetch_and_validate_data_contract::DataContractFetcherAndValidator,
+    },
+    prelude::Document,
+};
+
+use wasm_bindgen::prelude::*;
+
+use crate::document::errors::InvalidActionNameError;
+
+use crate::{
+    document::document_data_to_bytes,
+    identifier::identifier_from_js_value,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    utils::{
+        replace_identifiers_with_bytes_without_failing, IntoWasm, ToSerdeJSONExt, WithJsError,
+    },
+    DataContractWasm, DocumentWasm, DocumentsBatchTransitionWasm,
+};
+
+use super::validator::DocumentValidatorWasm;
+
+#[wasm_bindgen(js_name=DocumentTransitions)]
+#[derive(Debug, Default)]
+pub struct DocumentTransitions {
+    create: Vec<DocumentWasm>,
+    replace: Vec<DocumentWasm>,
+    delete: Vec<DocumentWasm>,
+}
+
+#[wasm_bindgen(js_class=DocumentTransitions)]
+impl DocumentTransitions {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    #[wasm_bindgen(js_name = "addTransitionCreate")]
+    pub fn add_transition_create(&mut self, transition: DocumentWasm) {
+        self.create.push(transition)
+    }
+
+    #[wasm_bindgen(js_name = "addTransitionReplace")]
+    pub fn add_transition_replace(&mut self, transition: DocumentWasm) {
+        self.replace.push(transition)
+    }
+
+    #[wasm_bindgen(js_name = "addTransitionDelete")]
+    pub fn add_transition_delete(&mut self, transition: DocumentWasm) {
+        self.delete.push(transition)
+    }
+}
+
+#[wasm_bindgen(js_name = DocumentFactory)]
+pub struct DocumentFactoryWASM(DocumentFactory<ExternalStateRepositoryLikeWrapper>);
+
+impl DocumentFactoryWASM {
+    pub(crate) fn new_with_state_repository_wrapper(
+        protocol_version: u32,
+        document_validator: DocumentValidatorWasm,
+        state_repository: ExternalStateRepositoryLikeWrapper,
+    ) -> Self {
+        let factory = DocumentFactory::new(
+            protocol_version,
+            document_validator.into(),
+            DataContractFetcherAndValidator::new(Arc::new(state_repository)),
+        );
+
+        DocumentFactoryWASM(factory)
+    }
+}
+
+#[wasm_bindgen(js_class=DocumentFactory)]
+impl DocumentFactoryWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        protocol_version: u32,
+        document_validator: DocumentValidatorWasm,
+        state_repository: ExternalStateRepositoryLike,
+    ) -> DocumentFactoryWASM {
+        let factory = DocumentFactory::new(
+            protocol_version,
+            document_validator.into(),
+            DataContractFetcherAndValidator::new(Arc::new(
+                ExternalStateRepositoryLikeWrapper::new(state_repository),
+            )),
+        );
+
+        DocumentFactoryWASM(factory)
+    }
+
+    #[wasm_bindgen]
+    pub fn create(
+        &self,
+        data_contract: &DataContractWasm,
+        js_owner_id: &JsValue,
+        document_type: &str,
+        data: &JsValue,
+    ) -> Result<DocumentWasm, JsValue> {
+        let owner_id = identifier_from_js_value(js_owner_id)?;
+        let dynamic_data = data.with_serde_to_json_value()?;
+
+        let document = self
+            .0
+            .create(
+                data_contract.to_owned().into(),
+                owner_id,
+                document_type.to_string(),
+                dynamic_data,
+            )
+            .with_js_error()?;
+
+        Ok(document.into())
+    }
+
+    #[wasm_bindgen(js_name=createStateTransition)]
+    pub fn create_state_transition(
+        &self,
+        documents: &JsValue,
+    ) -> Result<DocumentsBatchTransitionWasm, JsValue> {
+        let documents_by_action = extract_documents_by_action(documents)?;
+        let batch_transition = self
+            .0
+            .create_state_transition(documents_by_action)
+            .with_js_error()?;
+
+        Ok(batch_transition.into())
+    }
+
+    #[wasm_bindgen(js_name=createFromObject)]
+    pub async fn create_from_object(
+        &self,
+        raw_document_js: JsValue,
+        options: JsValue,
+    ) -> Result<DocumentWasm, JsValue> {
+        let mut raw_document = raw_document_js.with_serde_to_json_value()?;
+        let options: FactoryOptions = if !options.is_undefined() && options.is_object() {
+            let raw_options = options.with_serde_to_json_value()?;
+            serde_json::from_value(raw_options).with_js_error()?
+        } else {
+            Default::default()
+        };
+        replace_identifiers_with_bytes_without_failing(
+            &mut raw_document,
+            document::IDENTIFIER_FIELDS,
+        );
+
+        let mut document = self
+            .0
+            .create_from_object(raw_document, options)
+            .await
+            .with_js_error()?;
+
+        document_data_to_bytes(&mut document)?;
+        Ok(document.into())
+    }
+
+    #[wasm_bindgen(js_name=createFromBuffer)]
+    pub async fn create_from_buffer(
+        &self,
+        buffer: Vec<u8>,
+        options: &JsValue,
+    ) -> Result<DocumentWasm, JsValue> {
+        let options: FactoryOptions = if !options.is_undefined() && options.is_object() {
+            let raw_options = options.with_serde_to_json_value()?;
+            serde_json::from_value(raw_options).with_js_error()?
+        } else {
+            Default::default()
+        };
+
+        let document = self
+            .0
+            .create_from_buffer(buffer, options)
+            .await
+            .with_js_error()?;
+
+        Ok(document.into())
+    }
+}
+
+fn extract_documents_by_action(
+    documents: &JsValue,
+) -> Result<HashMap<Action, Vec<Document>>, JsValue> {
+    check_actions(documents)?;
+
+    let mut documents_by_action: HashMap<Action, Vec<Document>> = Default::default();
+
+    let documents_create = extract_documents_of_action(documents, "create").with_js_error()?;
+    let documents_replace = extract_documents_of_action(documents, "replace").with_js_error()?;
+    let documents_delete = extract_documents_of_action(documents, "delete").with_js_error()?;
+
+    documents_by_action.insert(Action::Create, documents_create);
+    documents_by_action.insert(Action::Replace, documents_replace);
+    documents_by_action.insert(Action::Delete, documents_delete);
+
+    Ok(documents_by_action)
+}
+
+fn check_actions(documents: &JsValue) -> Result<(), JsValue> {
+    if !documents.is_object() {
+        return Err(anyhow!("Expected documents to be an object")).with_js_error();
+    }
+
+    let documents_object = js_sys::Object::from(documents.clone());
+
+    let actions: js_sys::Array = js_sys::Object::keys(&documents_object);
+
+    for action in actions.iter() {
+        let action_string: String = action
+            .as_string()
+            .ok_or_else(|| anyhow!("Expected all keys to be strings"))
+            .with_js_error()?;
+        Action::try_from(action_string)
+            .map_err(|_| InvalidActionNameError::new(vec![action.clone()]))?;
+    }
+
+    Ok(())
+}
+
+fn extract_documents_of_action(
+    documents: &JsValue,
+    action: &str,
+) -> Result<Vec<Document>, anyhow::Error> {
+    let mut extracted_documents: Vec<Document> = vec![];
+    let documents_with_action =
+        js_sys::Reflect::get(documents, &action.to_string().into()).unwrap_or(JsValue::NULL);
+    if documents_with_action.is_null() || documents_with_action.is_undefined() {
+        return Ok(extracted_documents);
+    }
+    let documents_array = js_sys::Array::try_from(documents_with_action)
+        .map_err(|e| anyhow!("property '{}' isn't an array: {}", action, e))?;
+
+    for js_document in documents_array.iter() {
+        let document: Document = js_document
+            .to_wasm::<DocumentWasm>("Document")
+            .map_err(|e| {
+                anyhow!(
+                    "Element in '{}' isn't a Document instance: {:#?}",
+                    action,
+                    e
+                )
+            })?
+            .clone()
+            .into();
+        extracted_documents.push(document)
+    }
+
+    Ok(extracted_documents)
+}

package/src/document/fetch_and_validate_data_contract.rs

@@ -0,0 +1,77 @@
+use dpp::{
+    document::{self, fetch_and_validate_data_contract::fetch_and_validate_data_contract},
+    prelude::DataContract,
+    state_transition::state_transition_execution_context::StateTransitionExecutionContext,
+    validation::ValidationResult,
+};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    utils::{replace_identifiers_with_bytes_without_failing, ToSerdeJSONExt, WithJsError},
+    validation::ValidationResultWasm,
+    DataContractWasm,
+};
+
+#[wasm_bindgen(js_name=FetchAndValidateDataContractFactory)]
+pub struct DataContractFetcherAndValidatorWasm {
+    state_repository: ExternalStateRepositoryLikeWrapper,
+}
+
+impl DataContractFetcherAndValidatorWasm {
+    pub(crate) fn new_with_state_repository_wrapper(
+        state_repository: ExternalStateRepositoryLikeWrapper,
+    ) -> Self {
+        Self { state_repository }
+    }
+}
+
+#[wasm_bindgen(js_class=FetchAndValidateDataContractFactory)]
+impl DataContractFetcherAndValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(state_repository: ExternalStateRepositoryLike) -> Self {
+        let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+        Self {
+            state_repository: wrapped_state_repository,
+        }
+    }
+
+    #[wasm_bindgen(js_name=validate)]
+    pub async fn validate(
+        &self,
+        js_raw_document: &JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        fetch_and_validate_data_contract_inner(&self.state_repository, js_raw_document).await
+    }
+}
+
+#[wasm_bindgen(js_name = fetchAndValidateDataContract)]
+pub async fn fetch_and_validate_data_contract_wasm(
+    state_repository: ExternalStateRepositoryLike,
+    js_raw_document: JsValue,
+) -> Result<ValidationResultWasm, JsValue> {
+    let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+    fetch_and_validate_data_contract_inner(&wrapped_state_repository, &js_raw_document).await
+}
+
+async fn fetch_and_validate_data_contract_inner(
+    state_repository: &ExternalStateRepositoryLikeWrapper,
+    js_raw_document: &JsValue,
+) -> Result<ValidationResultWasm, JsValue> {
+    let mut document_value = js_raw_document.with_serde_to_json_value()?;
+    replace_identifiers_with_bytes_without_failing(
+        &mut document_value,
+        document::IDENTIFIER_FIELDS,
+    );
+
+    // TODO! remove the context. The the providing the context in state repository should be optional
+    let ctx = StateTransitionExecutionContext::default();
+    let validation_result =
+        fetch_and_validate_data_contract(state_repository, &document_value, &ctx)
+            .await
+            .with_js_error()?;
+    let result_with_js_value: ValidationResult<JsValue> = validation_result
+        .map(|dc| <DataContractWasm as std::convert::From<DataContract>>::from(dc).into());
+
+    Ok(result_with_js_value.into())
+}

package/src/document/generate_document_id.rs

@@ -0,0 +1,17 @@
+use dpp::document::generate_document_id::generate_document_id;
+use wasm_bindgen::prelude::*;
+
+use crate::identifier::{identifier_from_js_value, IdentifierWrapper};
+
+#[wasm_bindgen(js_name=generateDocumentId)]
+pub fn generate_document_id_wasm(
+    contract_id: &JsValue,
+    owner_id: &JsValue,
+    document_type: String,
+    entropy: Vec<u8>,
+) -> Result<IdentifierWrapper, JsValue> {
+    let contract_id = identifier_from_js_value(contract_id)?;
+    let owner_id = identifier_from_js_value(owner_id)?;
+    let id = generate_document_id(&contract_id, &owner_id, &document_type, &entropy);
+    Ok(id.into())
+}