@dashevo/wasm-dpp 0.23.0-dev.15 → 0.24.0-dev.11

package/src/data_contract_factory/data_contract_factory.rs

@@ -0,0 +1,155 @@
+use std::convert::TryInto;
+
+use dpp::{
+    data_contract::{
+        validation::data_contract_validator::DataContractValidator, DataContractFactory,
+        EntropyGenerator,
+    },
+    prelude::Identifier,
+    version::ProtocolVersionValidator,
+};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    data_contract::errors::InvalidDataContractError,
+    errors::{consensus_error::from_consensus_error, from_dpp_err, RustConversionError},
+    with_js_error, DataContractCreateTransitionWasm, DataContractParameters, DataContractWasm,
+};
+
+#[wasm_bindgen(js_name=DataContractValidator)]
+pub struct DataContractValidatorWasm(DataContractValidator);
+
+impl From<DataContractValidator> for DataContractValidatorWasm {
+    fn from(v: DataContractValidator) -> Self {
+        DataContractValidatorWasm(v)
+    }
+}
+
+impl Into<DataContractValidator> for DataContractValidatorWasm {
+    fn into(self) -> DataContractValidator {
+        self.0
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractValidator)]
+impl DataContractValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        DataContractValidator::new(std::sync::Arc::new(ProtocolVersionValidator::default())).into()
+    }
+}
+
+#[wasm_bindgen(js_name=DataContractFactory)]
+pub struct DataContractFactoryWasm(DataContractFactory);
+
+impl From<DataContractFactory> for DataContractFactoryWasm {
+    fn from(v: DataContractFactory) -> Self {
+        DataContractFactoryWasm(v)
+    }
+}
+
+impl Into<DataContractFactory> for DataContractFactoryWasm {
+    fn into(self) -> DataContractFactory {
+        self.0
+    }
+}
+
+#[wasm_bindgen]
+extern "C" {
+    pub type ExternalEntropyGenerator;
+
+    #[wasm_bindgen(structural, method)]
+    pub fn generate(this: &ExternalEntropyGenerator) -> Vec<u8>;
+}
+
+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)
+            .try_into()
+            .expect("Bad entropy generator provided: should return 32 bytes");
+        res
+    }
+}
+#[wasm_bindgen(js_class=DataContractFactory)]
+impl DataContractFactoryWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        protocol_version: u32,
+        validate_data_contract: DataContractValidatorWasm,
+        external_entropy_generator_arg: Option<ExternalEntropyGenerator>,
+    ) -> DataContractFactoryWasm {
+        if let Some(external_entropy_generator) = external_entropy_generator_arg {
+            DataContractFactory::new_with_entropy_generator(
+                protocol_version,
+                validate_data_contract.into(),
+                Box::new(external_entropy_generator),
+            )
+        } else {
+            DataContractFactory::new(protocol_version, validate_data_contract.into()).into()
+        }
+        .into()
+    }
+
+    #[wasm_bindgen(js_name=create)]
+    pub fn create(
+        &self,
+        owner_id: Vec<u8>,
+        documents: JsValue,
+    ) -> Result<DataContractWasm, JsValue> {
+        let documents_json: serde_json::Value =
+            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)
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=createFromObject)]
+    pub async fn create_from_object(
+        &self,
+        object: JsValue,
+        skip_validation: Option<bool>,
+    ) -> Result<DataContractWasm, JsValue> {
+        let parameters: DataContractParameters =
+            with_js_error!(serde_wasm_bindgen::from_value(object.clone()))?;
+        let parameters_json = serde_json::to_value(parameters).expect("Implements Serialize");
+        let result = self
+            .0
+            .create_from_object(parameters_json, skip_validation.unwrap_or(false))
+            .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(other) => Err(from_dpp_err(other)),
+        }
+    }
+
+    #[wasm_bindgen(js_name=createFromBuffer)]
+    pub async fn create_from_buffer(
+        &self,
+        buffer: Vec<u8>,
+        skip_validation: Option<bool>,
+    ) -> Result<DataContractWasm, JsValue> {
+        self.0
+            .create_from_buffer(buffer, skip_validation.unwrap_or(false))
+            .await
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=createDataContractCreateTransition)]
+    pub async fn create_data_contract_create_transition(
+        &self,
+        data_contract: DataContractWasm,
+    ) -> Result<DataContractCreateTransitionWasm, JsValue> {
+        self.0
+            .create_data_contract_create_transition(data_contract.into())
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+}

package/src/data_contract_factory/mod.rs

@@ -0,0 +1 @@
+mod data_contract_factory;

package/src/document/errors/document_already_exists_error.rs

@@ -0,0 +1,28 @@
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use dpp::prelude::DocumentTransition;
+use thiserror::Error;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Document already exists")]
+pub struct DocumentAlreadyExistsError {
+    document_transition: DocumentTransition,
+}
+
+#[wasm_bindgen]
+impl DocumentAlreadyExistsError {
+    #[wasm_bindgen(js_name=getDocumentTransition)]
+    pub fn get_document_transition(&self) -> JsValue {
+        from_document_transition_to_js_value(self.document_transition.clone())
+    }
+}
+
+impl DocumentAlreadyExistsError {
+    pub fn new(document_transition: DocumentTransition) -> DocumentAlreadyExistsError {
+        Self {
+            document_transition,
+        }
+    }
+}

package/src/document/errors/document_not_provided_error.rs

@@ -0,0 +1,28 @@
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use dpp::prelude::DocumentTransition;
+use thiserror::Error;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Document was not provided for apply of state transition")]
+pub struct DocumentNotProvidedError {
+    document_transition: DocumentTransition,
+}
+
+#[wasm_bindgen]
+impl DocumentNotProvidedError {
+    #[wasm_bindgen(js_name=getDocumentTransition)]
+    pub fn get_document_transition(&self) -> JsValue {
+        from_document_transition_to_js_value(self.document_transition.clone())
+    }
+}
+
+impl DocumentNotProvidedError {
+    pub fn new(document_transition: DocumentTransition) -> DocumentNotProvidedError {
+        Self {
+            document_transition,
+        }
+    }
+}

package/src/document/errors/invalid_action_name_error.rs

@@ -0,0 +1,24 @@
+use thiserror::Error;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Invalid Document action submitted")]
+pub struct InvalidActionNameError {
+    actions: Vec<String>,
+}
+
+#[wasm_bindgen]
+impl InvalidActionNameError {
+    #[wasm_bindgen(constructor)]
+    pub fn new(actions: Vec<JsValue>) -> Self {
+        let actions: Vec<String> = into_vec_of(&actions);
+        Self { actions }
+    }
+
+    #[wasm_bindgen(js_name=getActions)]
+    pub fn get_actions(&self) -> Vec<JsValue> {
+        to_vec_js(self.actions.clone())
+    }
+}

package/src/document/errors/invalid_document_action_error.rs

@@ -0,0 +1,28 @@
+use crate::document::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use dpp::prelude::DocumentTransition;
+use thiserror::Error;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Invalid Document action: '{}'", document_transition.action())]
+pub struct InvalidDocumentActionError {
+    document_transition: DocumentTransition,
+}
+
+#[wasm_bindgen]
+impl InvalidDocumentActionError {
+    #[wasm_bindgen(js_name=getDocumentTransition)]
+    pub fn get_document_transition(&self) -> JsValue {
+        from_document_transition_to_js_value(self.document_transition.clone())
+    }
+}
+
+impl InvalidDocumentActionError {
+    pub fn new(document_transition: DocumentTransition) -> Self {
+        Self {
+            document_transition,
+        }
+    }
+}

package/src/document/errors/invalid_document_error.rs

@@ -0,0 +1,32 @@
+use thiserror::Error;
+
+use crate::DocumentWasm;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Invalid document: {:?}", errors)]
+pub struct InvalidDocumentError {
+    // the point is how we hold all there different types in  the Vector
+    errors: Vec<JsValue>,
+    document: DocumentWasm,
+}
+
+#[wasm_bindgen]
+impl InvalidDocumentError {
+    #[wasm_bindgen(constructor)]
+    pub fn new(document: DocumentWasm, errors: Vec<JsValue>) -> InvalidDocumentError {
+        Self { document, errors }
+    }
+
+    #[wasm_bindgen(js_name=getErrors)]
+    pub fn get_errors(&self) -> Vec<JsValue> {
+        self.errors.clone()
+    }
+
+    #[wasm_bindgen(js_name=getDocument)]
+    pub fn get_document(&self) -> DocumentWasm {
+        self.document.clone()
+    }
+}

package/src/document/errors/invalid_initial_revision_error.rs

@@ -0,0 +1,25 @@
+use thiserror::Error;
+
+use crate::DocumentWasm;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Invalid Document Initial revision '{}'", document.get_revision())]
+pub struct InvalidInitialRevisionError {
+    document: DocumentWasm,
+}
+
+#[wasm_bindgen]
+impl InvalidInitialRevisionError {
+    #[wasm_bindgen(constructor)]
+    pub fn new(document: DocumentWasm) -> InvalidInitialRevisionError {
+        Self { document }
+    }
+
+    #[wasm_bindgen(js_name=getDocumentTransition)]
+    pub fn get_document_transition(&self) -> DocumentWasm {
+        self.document.clone()
+    }
+}

package/src/document/errors/mismatch_owners_ids_error.rs

@@ -0,0 +1,27 @@
+use thiserror::Error;
+
+use crate::DocumentWasm;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Documents have mixed owner ids")]
+pub struct MismatchOwnersIdsError {
+    documents: Vec<DocumentWasm>,
+}
+
+#[wasm_bindgen]
+impl MismatchOwnersIdsError {
+    #[wasm_bindgen(constructor)]
+    pub fn new(documents: Vec<JsValue>) -> MismatchOwnersIdsError {
+        Self {
+            documents: into_vec_of(&documents),
+        }
+    }
+
+    #[wasm_bindgen(js_name=getDocumentTransition)]
+    pub fn get_documents(&self) -> Vec<JsValue> {
+        to_vec_js(self.documents.clone())
+    }
+}

package/src/document/errors/mod.rs

@@ -0,0 +1,55 @@
+use wasm_bindgen::prelude::*;
+
+pub use document_already_exists_error::*;
+pub use document_not_provided_error::*;
+use dpp::document::errors::DocumentError;
+pub use invalid_action_name_error::*;
+pub use invalid_document_action_error::*;
+pub use invalid_document_error::*;
+pub use invalid_initial_revision_error::*;
+pub use mismatch_owners_ids_error::*;
+pub use no_documents_supplied_error::*;
+
+use crate::errors::consensus_error::from_consensus_error;
+use crate::{utils::*, DocumentWasm};
+
+mod document_already_exists_error;
+mod document_not_provided_error;
+mod invalid_action_name_error;
+mod invalid_document_action_error;
+mod invalid_document_error;
+mod invalid_initial_revision_error;
+mod mismatch_owners_ids_error;
+mod no_documents_supplied_error;
+
+pub fn from_document_to_js_error(e: DocumentError) -> JsValue {
+    match e {
+        DocumentError::DocumentAlreadyExists {
+            document_transition,
+        } => DocumentAlreadyExistsError::new(document_transition).into(),
+        DocumentError::DocumentNotProvided {
+            document_transition,
+        } => DocumentNotProvidedError::new(document_transition).into(),
+
+        DocumentError::InvalidActionName { actions } => {
+            InvalidActionNameError::new(to_vec_js(actions)).into()
+        }
+        DocumentError::InvalidDocument { errors, document } => InvalidDocumentError::new(
+            (*document).into(),
+            errors.into_iter().map(from_consensus_error).collect(),
+        )
+        .into(),
+        DocumentError::InvalidDocumentAction {
+            document_transition,
+        } => InvalidDocumentActionError::new(document_transition).into(),
+        DocumentError::InvalidInitialRevision { 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::NotDocumentsSupplied => NotDocumentsSuppliedError::new().into(),
+    }
+}

package/src/document/errors/no_documents_supplied_error.rs

@@ -0,0 +1,22 @@
+use thiserror::Error;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("No documents were supplied to state transition")]
+pub struct NotDocumentsSuppliedError {}
+
+#[wasm_bindgen]
+impl NotDocumentsSuppliedError {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        NotDocumentsSuppliedError {}
+    }
+}
+
+impl Default for NotDocumentsSuppliedError {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/src/document/mod.rs

@@ -0,0 +1,158 @@
+use std::convert::TryInto;
+
+use serde::{Deserialize, Serialize};
+use wasm_bindgen::prelude::*;
+
+use dpp::document::Document;
+
+use crate::errors::{from_dpp_err, RustConversionError};
+use crate::identifier::IdentifierWrapper;
+use crate::with_js_error;
+use crate::{DataContractWasm, MetadataWasm};
+
+pub mod errors;
+pub mod state_transition;
+
+#[wasm_bindgen(js_name=Document)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DocumentWasm(Document);
+
+#[wasm_bindgen(js_class=Document)]
+impl DocumentWasm {
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn get_protocol_version(&self) -> u32 {
+        self.0.protocol_version
+    }
+
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> IdentifierWrapper {
+        self.0.id.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> String {
+        self.0.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn get_data_contract_id(&self) -> IdentifierWrapper {
+        self.0.data_contract_id.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getDataContract)]
+    pub fn get_data_contract(&self) -> DataContractWasm {
+        self.0.data_contract.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.0.owner_id.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=setRevision)]
+    pub fn set_revision(&mut self, rev: u32) {
+        self.0.revision = rev
+    }
+
+    #[wasm_bindgen(js_name=getRevision)]
+    pub fn get_revision(&self) -> u32 {
+        self.0.revision
+    }
+
+    #[wasm_bindgen(js_name=setEntropy)]
+    pub fn set_entropy(&mut self, e: Vec<u8>) -> Result<(), JsValue> {
+        let entropy: [u8; 32] = e.try_into().map_err(|_| {
+            RustConversionError::Error(String::from(
+                "unable to turn the data into 32 bytes array of bytes",
+            ))
+            .to_js_value()
+        })?;
+        self.0.entropy = entropy;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getEntropy)]
+    pub fn get_entropy(&mut self) -> Vec<u8> {
+        self.0.entropy.to_vec()
+    }
+
+    #[wasm_bindgen(js_name=setData)]
+    pub fn set_data(&mut self, d: JsValue) -> Result<(), JsValue> {
+        self.0.data = with_js_error!(serde_wasm_bindgen::from_value(d))?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getData)]
+    pub fn get_data(&mut self) -> Result<JsValue, JsValue> {
+        with_js_error!(serde_wasm_bindgen::to_value(&self.0.data))
+    }
+
+    #[wasm_bindgen(js_name=set)]
+    pub fn set(&mut self, _path: String, _d: JsValue) {
+        // TODO use lodash via extern
+        unimplemented!()
+    }
+
+    #[wasm_bindgen(js_name=get)]
+    pub fn get(&mut self, _path: String) -> JsValue {
+        // TODO use lodash via extern
+        unimplemented!()
+    }
+
+    #[wasm_bindgen(js_name=setCreatedAt)]
+    pub fn set_created_at(&mut self, ts: i64) {
+        self.0.created_at = Some(ts);
+    }
+
+    #[wasm_bindgen(js_name=setUpdatedAt)]
+    pub fn set_updated_at(&mut self, ts: i64) {
+        self.0.updated_at = Some(ts);
+    }
+
+    #[wasm_bindgen(js_name=getCreatedAt)]
+    pub fn get_created_at(&self) -> Option<i64> {
+        self.0.created_at
+    }
+
+    #[wasm_bindgen(js_name=getUpdatedAt)]
+    pub fn get_updated_at(&self) -> Option<i64> {
+        self.0.updated_at
+    }
+
+    #[wasm_bindgen(js_name=getMetadata)]
+    pub fn get_metadata(&self) -> Option<MetadataWasm> {
+        self.0.metadata.clone().map(Into::into)
+    }
+
+    #[wasm_bindgen(js_name=setMetadata)]
+    pub fn set_metadata(&mut self, metadata: MetadataWasm) {
+        self.0.metadata = Some(metadata.into());
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        with_js_error!(serde_wasm_bindgen::to_value(&self.0))
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        self.to_object()
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self) -> Result<Vec<u8>, JsValue> {
+        let buffer = self.0.to_buffer().map_err(from_dpp_err)?;
+        Ok(buffer)
+    }
+
+    #[wasm_bindgen(js_name=hash)]
+    pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.hash().map_err(from_dpp_err)
+    }
+}
+
+impl From<Document> for DocumentWasm {
+    fn from(d: Document) -> Self {
+        DocumentWasm(d)
+    }
+}

package/src/document/state_transition/document_batch_transition/document_transition/document_create_transition.rs

@@ -0,0 +1,22 @@
+use dpp::document::document_transition::DocumentCreateTransition;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentCreateTransition)]
+#[derive(Debug, Clone)]
+pub struct DocumentCreateTransitionWasm {
+    inner: DocumentCreateTransition,
+}
+
+impl From<DocumentCreateTransition> for DocumentCreateTransitionWasm {
+    fn from(v: DocumentCreateTransition) -> Self {
+        Self { inner: v }
+    }
+}
+
+#[wasm_bindgen(js_class=DocumentCreateTransition)]
+impl DocumentCreateTransitionWasm {
+    #[wasm_bindgen(js_name=getAction)]
+    pub fn action(&self) -> u8 {
+        self.inner.base.action as u8
+    }
+}

package/src/document/state_transition/document_batch_transition/document_transition/document_delete_transition.rs

@@ -0,0 +1,22 @@
+use dpp::document::document_transition::DocumentDeleteTransition;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentDeleteTransition)]
+#[derive(Debug, Clone)]
+pub struct DocumentDeleteTransitionWasm {
+    inner: DocumentDeleteTransition,
+}
+
+impl From<DocumentDeleteTransition> for DocumentDeleteTransitionWasm {
+    fn from(v: DocumentDeleteTransition) -> Self {
+        Self { inner: v }
+    }
+}
+
+#[wasm_bindgen(js_class=DocumentDeleteTransition)]
+impl DocumentDeleteTransitionWasm {
+    #[wasm_bindgen(js_name=getAction)]
+    pub fn action(&self) -> u8 {
+        self.inner.base.action as u8
+    }
+}

package/src/document/state_transition/document_batch_transition/document_transition/document_update_transition.rs

@@ -0,0 +1,22 @@
+use dpp::document::document_transition::DocumentReplaceTransition;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentTransition)]
+#[derive(Debug, Clone)]
+pub struct DocumentReplaceTransitionWasm {
+    inner: DocumentReplaceTransition,
+}
+
+impl From<DocumentReplaceTransition> for DocumentReplaceTransitionWasm {
+    fn from(v: DocumentReplaceTransition) -> Self {
+        Self { inner: v }
+    }
+}
+
+#[wasm_bindgen(js_class=DocumentTransition)]
+impl DocumentReplaceTransitionWasm {
+    #[wasm_bindgen(js_name=getAction)]
+    pub fn action(&self) -> u8 {
+        self.inner.base.action as u8
+    }
+}

package/src/document/state_transition/document_batch_transition/document_transition/mod.rs

@@ -0,0 +1,24 @@
+mod document_create_transition;
+mod document_delete_transition;
+mod document_update_transition;
+
+pub use document_create_transition::*;
+pub use document_delete_transition::*;
+pub use document_update_transition::*;
+
+use dpp::prelude::DocumentTransition;
+use wasm_bindgen::prelude::*;
+
+pub fn from_document_transition_to_js_value(document_transition: DocumentTransition) -> JsValue {
+    match document_transition {
+        DocumentTransition::Create(create_transition) => {
+            DocumentCreateTransitionWasm::from(create_transition).into()
+        }
+        DocumentTransition::Replace(replace_transition) => {
+            DocumentReplaceTransitionWasm::from(replace_transition).into()
+        }
+        DocumentTransition::Delete(delete_transition) => {
+            DocumentDeleteTransitionWasm::from(delete_transition).into()
+        }
+    }
+}

package/src/document/state_transition/document_batch_transition/mod.rs

@@ -0,0 +1 @@
+pub mod document_transition;