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

package/src/document/errors/document_not_provided_error.rs

@@ -0,0 +1,28 @@
+use crate::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::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;

package/src/document/state_transition/mod.rs

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

package/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs

@@ -0,0 +1,36 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractHaveNewUniqueIndexError)]
+pub struct DataContractHaveNewUniqueIndexErrorWasm {
+    document_type: String,
+    index_name: String,
+    code: u32,
+}
+
+impl DataContractHaveNewUniqueIndexErrorWasm {
+    pub fn new(document_type: String, index_name: String, code: u32) -> Self {
+        DataContractHaveNewUniqueIndexErrorWasm {
+            document_type,
+            index_name,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractHaveNewUniqueIndexError)]
+impl DataContractHaveNewUniqueIndexErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getIndexName)]
+    pub fn get_index_name(&self) -> String {
+        self.index_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs

@@ -0,0 +1,36 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractImmutablePropertiesUpdateError)]
+pub struct DataContractImmutablePropertiesUpdateErrorWasm {
+    operation: String,
+    field_path: String,
+    code: u32,
+}
+
+impl DataContractImmutablePropertiesUpdateErrorWasm {
+    pub fn new(operation: String, field_path: String, code: u32) -> Self {
+        DataContractImmutablePropertiesUpdateErrorWasm {
+            operation,
+            field_path,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractImmutablePropertiesUpdateError)]
+impl DataContractImmutablePropertiesUpdateErrorWasm {
+    #[wasm_bindgen(js_name=getOperation)]
+    pub fn get_operation(&self) -> String {
+        self.operation.clone()
+    }
+
+    #[wasm_bindgen(js_name=getFieldPath)]
+    pub fn get_field_path(&self) -> String {
+        self.field_path.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs

@@ -0,0 +1,36 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractInvalidIndexDefinitionUpdateError)]
+pub struct DataContractInvalidIndexDefinitionUpdateErrorWasm {
+    document_type: String,
+    index_name: String,
+    code: u32,
+}
+
+impl DataContractInvalidIndexDefinitionUpdateErrorWasm {
+    pub fn new(document_type: String, index_name: String, code: u32) -> Self {
+        DataContractInvalidIndexDefinitionUpdateErrorWasm {
+            document_type,
+            index_name,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractInvalidIndexDefinitionUpdateError)]
+impl DataContractInvalidIndexDefinitionUpdateErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getIndexName)]
+    pub fn get_index_name(&self) -> String {
+        self.index_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/data_contract_max_depth_exceed_error.rs

@@ -0,0 +1,26 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractMaxDepthError)]
+pub struct DataContractMaxDepthErrorWasm {
+    depth: usize,
+    code: u32,
+}
+
+impl DataContractMaxDepthErrorWasm {
+    pub fn new(depth: usize, code: u32) -> Self {
+        DataContractMaxDepthErrorWasm { depth, code }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractMaxDepthError)]
+impl DataContractMaxDepthErrorWasm {
+    #[wasm_bindgen(js_name=getDepth)]
+    pub fn get_expected_version(&self) -> usize {
+        self.depth
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs

@@ -0,0 +1,36 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractUniqueIndicesChangedError)]
+pub struct DataContractUniqueIndicesChangedErrorWasm {
+    document_type: String,
+    index_name: String,
+    code: u32,
+}
+
+impl DataContractUniqueIndicesChangedErrorWasm {
+    pub fn new(document_type: String, index_name: String, code: u32) -> Self {
+        DataContractUniqueIndicesChangedErrorWasm {
+            document_type,
+            index_name,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractUniqueIndicesChangedError)]
+impl DataContractUniqueIndicesChangedErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentType)]
+    pub fn get_document_type(&self) -> String {
+        self.document_type.clone()
+    }
+
+    #[wasm_bindgen(js_name=getIndexName)]
+    pub fn get_index_name(&self) -> String {
+        self.index_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}