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

package/src/dash_platform_protocol.rs

@@ -3,24 +3,121 @@ use std::sync::Arc;
 use wasm_bindgen::prelude::*;
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::document_facade::DocumentFacadeWasm;
+use crate::fetch_and_validate_data_contract::DataContractFetcherAndValidatorWasm;
+use crate::identity_facade::IdentityFacadeWasm;
+use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
+use crate::{with_js_error, DataContractFacadeWasm};
+use crate::{DocumentFactoryWASM, DocumentValidatorWasm};
 use dpp::identity::validation::PublicKeysValidator;
-use dpp::identity::IdentityFacade;
-use dpp::version::ProtocolVersionValidator;
+
+use crate::state_transition_facade::StateTransitionFacadeWasm;
+use dpp::version::{ProtocolVersionValidator, COMPATIBILITY_MAP, LATEST_VERSION};
+
+use serde::{Deserialize, Serialize};
 
 #[wasm_bindgen(js_name=DashPlatformProtocol)]
-pub struct DashPlatformProtocol(IdentityFacade<BlsAdapter>);
+pub struct DashPlatformProtocol {
+    identity: IdentityFacadeWasm,
+    document: DocumentFacadeWasm,
+    data_contract: DataContractFacadeWasm,
+    state_transition: StateTransitionFacadeWasm,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct DPPOptions {
+    #[serde(rename = "protocolVersion")]
+    pub current_protocol_version: Option<u32>,
+}
 
 #[wasm_bindgen(js_class=DashPlatformProtocol)]
 impl DashPlatformProtocol {
     #[wasm_bindgen(constructor)]
-    pub fn new(bls_adapter: JsBlsAdapter) -> DashPlatformProtocol {
-        let bls = BlsAdapter(bls_adapter);
-        // TODO: remove default validator and make a real one instead
-        let validator = ProtocolVersionValidator::default();
-        let public_keys_validator = PublicKeysValidator::new(bls).unwrap();
+    pub fn new(
+        options: JsValue,
+        bls_adapter: JsBlsAdapter,
+        state_repository: ExternalStateRepositoryLike,
+    ) -> Result<DashPlatformProtocol, JsValue> {
+        // TODO: wrap whole thing around rs-dpp/dash_platform_protocol?
+        let options: DPPOptions = with_js_error!(serde_wasm_bindgen::from_value(options))?;
+        let wrapped_state_repository =
+            ExternalStateRepositoryLikeWrapper::new(state_repository.clone());
+        let bls = BlsAdapter(bls_adapter.clone());
+
+        let protocol_version = options.current_protocol_version.unwrap_or(LATEST_VERSION);
+        let protocol_version_validator = Arc::new(ProtocolVersionValidator::new(
+            protocol_version,
+            LATEST_VERSION,
+            COMPATIBILITY_MAP.clone(),
+        ));
+        let public_keys_validator = Arc::new(PublicKeysValidator::new(bls).unwrap());
+
         let identity_facade =
-            IdentityFacade::new(Arc::new(validator), Arc::new(public_keys_validator)).unwrap();
+            IdentityFacadeWasm::new(protocol_version_validator.clone(), public_keys_validator);
+
+        let document_facade = init_document_facade(
+            protocol_version,
+            protocol_version_validator.clone(),
+            wrapped_state_repository,
+        );
+
+        let data_contract_facade =
+            DataContractFacadeWasm::new(protocol_version, protocol_version_validator.clone());
+
+        let state_transition_facade = StateTransitionFacadeWasm::new(
+            state_repository,
+            bls_adapter,
+            protocol_version_validator,
+        )?;
+
+        Ok(Self {
+            document: document_facade,
+            identity: identity_facade,
+            data_contract: data_contract_facade,
+            state_transition: state_transition_facade,
+        })
+    }
 
-        DashPlatformProtocol(identity_facade)
+    #[wasm_bindgen(getter = dataContract)]
+    pub fn data_contract(&self) -> DataContractFacadeWasm {
+        self.data_contract.clone()
     }
+
+    #[wasm_bindgen(getter=document)]
+    pub fn document(&self) -> DocumentFacadeWasm {
+        self.document.clone()
+    }
+
+    #[wasm_bindgen(getter = identity)]
+    pub fn identity(&self) -> IdentityFacadeWasm {
+        self.identity.clone()
+    }
+
+    #[wasm_bindgen(getter = stateTransition)]
+    pub fn state_transition(&self) -> StateTransitionFacadeWasm {
+        self.state_transition.clone()
+    }
+}
+
+fn init_document_facade(
+    protocol_version: u32,
+    protocol_version_validator: Arc<ProtocolVersionValidator>,
+    state_repository: ExternalStateRepositoryLikeWrapper,
+) -> DocumentFacadeWasm {
+    let document_validator = DocumentValidatorWasm::new_with_arc(protocol_version_validator);
+
+    let document_factory = DocumentFactoryWASM::new_with_state_repository_wrapper(
+        protocol_version,
+        document_validator.clone(),
+        state_repository.clone(),
+    );
+
+    let data_contract_fetcher_and_validator =
+        DataContractFetcherAndValidatorWasm::new_with_state_repository_wrapper(state_repository);
+
+    DocumentFacadeWasm::new(
+        document_validator,
+        document_factory,
+        data_contract_fetcher_and_validator,
+    )
 }

package/src/data_contract/data_contract.rs

@@ -11,7 +11,9 @@ use dpp::data_contract::{DataContract, SCHEMA_URI};
 use dpp::util::string_encoding::Encoding;
 
 use crate::errors::{from_dpp_err, RustConversionError};
+use crate::identifier::identifier_from_js_value;
 use crate::metadata::MetadataWasm;
+use crate::utils::WithJsError;
 use crate::{bail_js, with_js_error};
 use crate::{buffer::Buffer, identifier::IdentifierWrapper};
 
@@ -25,6 +27,12 @@ impl std::convert::From<DataContract> for DataContractWasm {
     }
 }
 
+impl std::convert::From<&DataContractWasm> for DataContract {
+    fn from(v: &DataContractWasm) -> Self {
+        v.0.clone()
+    }
+}
+
 impl std::convert::Into<DataContract> for DataContractWasm {
     fn into(self) -> DataContract {
         self.0
@@ -34,11 +42,16 @@ impl std::convert::Into<DataContract> for DataContractWasm {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct DataContractParameters {
-    #[serde(rename = "$schema")]
-    schema: String,
-    #[serde(rename = "$id")]
-    id: Vec<u8>,
-    owner_id: Vec<u8>,
+    #[serde(
+        rename = "$schema",
+        skip_serializing_if = "serde_json::Value::is_null",
+        default
+    )]
+    schema: serde_json::Value,
+    #[serde(rename = "$id", skip_serializing_if = "Option::is_none")]
+    id: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    owner_id: Option<Vec<u8>>,
     #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
     documents: serde_json::Value,
     #[serde(
@@ -47,8 +60,20 @@ pub(crate) struct DataContractParameters {
         rename = "$defs"
     )]
     defs: serde_json::Value,
-    protocol_version: u32,
-    version: u32,
+    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
+    protocol_version: serde_json::Value,
+    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
+    version: serde_json::Value,
+
+    #[serde(flatten)]
+    _extras: serde_json::Value, // Captures excess fields to trigger validation failure later.
+}
+
+pub fn js_value_to_serde_value(raw_parameters: JsValue) -> Result<Value, JsValue> {
+    let parameters: DataContractParameters =
+        with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+
+    serde_json::to_value(parameters).map_err(|e| e.to_string().into())
 }
 
 #[wasm_bindgen(js_class=DataContract)]
@@ -72,12 +97,19 @@ impl DataContractWasm {
 
     #[wasm_bindgen(js_name=getId)]
     pub fn get_id(&self) -> IdentifierWrapper {
-        self.0.id.clone().into()
+        self.0.id.into()
+    }
+
+    #[wasm_bindgen(js_name=setId)]
+    pub fn set_id(&mut self, id: &JsValue) -> Result<(), JsValue> {
+        let id = identifier_from_js_value(id)?;
+        self.0.id = id;
+        Ok(())
     }
 
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
-        self.0.owner_id.clone().into()
+        self.0.owner_id.into()
     }
 
     #[wasm_bindgen(js_name=getVersion)]
@@ -270,12 +302,23 @@ impl DataContractWasm {
     }
 
     #[wasm_bindgen(js_name=from)]
-    pub fn from(v: JsValue) -> Result<DataContractWasm, JsValue> {
+    pub fn from_js_value(v: JsValue) -> Result<DataContractWasm, JsValue> {
         let json_contract: Value = with_js_error!(serde_wasm_bindgen::from_value(v))?;
         Ok(DataContract::try_from(json_contract)
             .map_err(from_dpp_err)?
             .into())
     }
+
+    #[wasm_bindgen(js_name=fromBuffer)]
+    pub fn from_buffer(b: &[u8]) -> Result<DataContractWasm, JsValue> {
+        let data_contract = DataContract::from_cbor(b).with_js_error()?;
+        Ok(data_contract.into())
+    }
+
+    #[wasm_bindgen(js_name=clone)]
+    pub fn deep_clone(&self) -> Self {
+        self.clone()
+    }
 }
 
 #[wasm_bindgen(js_name=DataContractDefaults)]
@@ -288,3 +331,9 @@ impl DataContractDefaults {
         SCHEMA_URI.to_string()
     }
 }
+
+impl DataContractWasm {
+    pub fn inner(&self) -> &DataContract {
+        &self.0
+    }
+}

package/src/data_contract/data_contract_facade.rs

@@ -0,0 +1,128 @@
+use crate::errors::protocol_error::from_protocol_error;
+
+use crate::{
+    js_value_to_serde_value, DataContractCreateTransitionWasm, DataContractUpdateTransitionWasm,
+    DataContractWasm,
+};
+use dpp::data_contract::DataContractFacade;
+use dpp::identifier::Identifier;
+use dpp::version::ProtocolVersionValidator;
+
+use crate::utils::{get_bool_from_options, SKIP_VALIDATION_PROPERTY_NAME};
+use crate::validation::ValidationResultWasm;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractFacade)]
+#[derive(Clone)]
+pub struct DataContractFacadeWasm(Arc<DataContractFacade>);
+
+impl DataContractFacadeWasm {
+    pub fn new(
+        protocol_version: u32,
+        protocol_version_validator: Arc<ProtocolVersionValidator>,
+    ) -> Self {
+        let inner = DataContractFacade::new(protocol_version, protocol_version_validator);
+
+        Self(Arc::new(inner))
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractFacade)]
+impl DataContractFacadeWasm {
+    /// Create Data Contract
+    #[wasm_bindgen]
+    pub fn create(
+        &self,
+        owner_id: Vec<u8>,
+        documents: JsValue,
+        definitions: JsValue,
+    ) -> Result<DataContractWasm, JsValue> {
+        let id = Identifier::from_bytes(&owner_id).map_err(from_protocol_error)?;
+
+        let definitions: Option<serde_json::Value> = if definitions.is_object() {
+            Some(serde_wasm_bindgen::from_value(definitions)?)
+        } else {
+            None
+        };
+
+        self.0
+            .create(id, serde_wasm_bindgen::from_value(documents)?, definitions)
+            .map(Into::into)
+            .map_err(from_protocol_error)
+    }
+
+    /// Create Data Contract from plain object
+    #[wasm_bindgen(js_name=createFromObject)]
+    pub async fn create_from_object(
+        &self,
+        js_raw_data_contract: JsValue,
+        options: JsValue,
+    ) -> Result<DataContractWasm, JsValue> {
+        let skip_validation = get_bool_from_options(options, SKIP_VALIDATION_PROPERTY_NAME, false)?;
+
+        self.0
+            .create_from_object(
+                js_value_to_serde_value(js_raw_data_contract)?,
+                skip_validation,
+            )
+            .await
+            .map(DataContractWasm::from)
+            .map_err(from_protocol_error)
+    }
+
+    /// Create Data Contract from buffer
+    #[wasm_bindgen(js_name=createFromBuffer)]
+    pub async fn create_from_buffer(
+        &self,
+        buffer: Vec<u8>,
+        options: JsValue,
+    ) -> Result<DataContractWasm, JsValue> {
+        let skip_validation = get_bool_from_options(options, SKIP_VALIDATION_PROPERTY_NAME, false)?;
+
+        self.0
+            .create_from_buffer(buffer, skip_validation)
+            .await
+            .map(Into::into)
+            .map_err(from_protocol_error)
+    }
+
+    /// Create Data Contract Create State Transition
+    #[wasm_bindgen(js_name=createDataContractCreateTransition)]
+    pub fn create_data_contract_create_transition(
+        &self,
+        data_contract: &DataContractWasm,
+    ) -> Result<DataContractCreateTransitionWasm, JsValue> {
+        self.0
+            .create_data_contract_create_transition(data_contract.clone().into())
+            .map(DataContractCreateTransitionWasm::from)
+            .map_err(from_protocol_error)
+    }
+
+    /// Create Data Contract Update State Transition
+    #[wasm_bindgen(js_name=createDataContractUpdateTransition)]
+    pub fn create_data_contract_update_transition(
+        &self,
+        data_contract: DataContractWasm,
+    ) -> Result<DataContractUpdateTransitionWasm, JsValue> {
+        self.0
+            .create_data_contract_update_transition(data_contract.into())
+            .map(Into::into)
+            .map_err(from_protocol_error)
+    }
+
+    /// Validate Data Contract
+    pub async fn validate(
+        &self,
+        js_raw_data_contract: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let raw_data_contract = js_value_to_serde_value(js_raw_data_contract)?;
+
+        self.0
+            .validate(raw_data_contract)
+            .await
+            .map(|v| v.map(|_| JsValue::UNDEFINED))
+            .map(Into::into)
+            .map_err(from_protocol_error)
+    }
+}

package/src/data_contract/errors/invalid_data_contract.rs

@@ -1,26 +1,29 @@
+use crate::errors::consensus_error::from_consensus_error_ref;
+use dpp::consensus::ConsensusError;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidDataContractError)]
 #[derive(Debug)]
 pub struct InvalidDataContractError {
     // we have to store it as JsValue as the errors of 'class' Consensus are of different types
-    errors: Vec<JsValue>,
+    errors: Vec<ConsensusError>,
     raw_data_contract: JsValue,
 }
 
-#[wasm_bindgen(js_class=InvalidDataContractError)]
 impl InvalidDataContractError {
-    #[wasm_bindgen(constructor)]
-    pub fn new(errors: Vec<JsValue>, raw_data_contract: JsValue) -> Self {
+    pub fn new(errors: Vec<ConsensusError>, raw_data_contract: JsValue) -> Self {
         InvalidDataContractError {
             errors,
             raw_data_contract,
         }
     }
+}
 
+#[wasm_bindgen(js_class=InvalidDataContractError)]
+impl InvalidDataContractError {
     #[wasm_bindgen(js_name=getErrors)]
     pub fn get_errors(&self) -> Vec<JsValue> {
-        self.errors.clone().into_iter().map(JsValue::from).collect()
+        self.errors.iter().map(from_consensus_error_ref).collect()
     }
 
     #[wasm_bindgen(js_name=getRawDataContract)]
@@ -30,20 +33,17 @@ impl InvalidDataContractError {
 
     #[wasm_bindgen(js_name=getMessage)]
     pub fn get_message(&self) -> String {
-        let extended_message = if let Some(error_message) = self
-            .errors
-            .first()
-            .map(|e| Into::<js_sys::Error>::into(e.clone()).message())
-        {
-            let narrowed_message = if self.errors.len() > 1 {
-                format!(" and {} more", self.errors.len() - 1)
+        let extended_message =
+            if let Some(error_message) = self.errors.first().map(|e| e.to_string()) {
+                let narrowed_message = if self.errors.len() > 1 {
+                    format!(" and {} more", self.errors.len() - 1)
+                } else {
+                    "".to_owned()
+                };
+                format!(": \"{error_message}\"{narrowed_message}")
             } else {
                 "".to_owned()
             };
-            format!(": \"{error_message}\"{narrowed_message}")
-        } else {
-            "".to_owned()
-        };
 
         format!("Data contract decode error{extended_message}")
     }

package/src/data_contract/errors/invalid_document_type.rs

@@ -1,7 +1,7 @@
 use thiserror::Error;
 use wasm_bindgen::prelude::*;
 
-use crate::DataContractWasm;
+use crate::identifier::IdentifierWrapper;
 
 #[wasm_bindgen]
 #[derive(Error, Debug)]
@@ -9,25 +9,25 @@ use crate::DataContractWasm;
 pub struct InvalidDocumentTypeInDataContractError {
     // we have to store it as JsValue as the errors of 'class' Consensus are of different types
     doc_type: String,
-    data_contract: DataContractWasm,
+    data_contract_id: IdentifierWrapper,
 }
 
 #[wasm_bindgen]
 impl InvalidDocumentTypeInDataContractError {
     #[wasm_bindgen(constructor)]
-    pub fn new(doc_type: String, data_contract: DataContractWasm) -> Self {
+    pub fn new(doc_type: String, data_contract_id: IdentifierWrapper) -> Self {
         InvalidDocumentTypeInDataContractError {
             doc_type,
-            data_contract,
+            data_contract_id,
         }
     }
-    #[wasm_bindgen(js_name = "getDocType")]
+    #[wasm_bindgen(js_name = "getType")]
     pub fn get_doc_type(&self) -> String {
         self.doc_type.clone()
     }
 
-    #[wasm_bindgen(js_name = "getDataContract")]
-    pub fn get_data_contract(&self) -> DataContractWasm {
-        self.data_contract.clone()
+    #[wasm_bindgen(js_name = "getDataContractId")]
+    pub fn get_data_contract_id(&self) -> IdentifierWrapper {
+        self.data_contract_id.clone()
     }
 }

package/src/data_contract/errors/mod.rs

@@ -4,7 +4,6 @@ mod invalid_document_type;
 
 use wasm_bindgen::prelude::*;
 
-use crate::errors::consensus_error::from_consensus_error;
 pub use data_contract_already_exists::*;
 use dpp::data_contract::errors::DataContractError;
 pub use invalid_data_contract::*;
@@ -14,24 +13,19 @@ pub fn from_data_contract_to_js_error(e: DataContractError) -> JsValue {
         DataContractError::InvalidDataContractError {
             errors,
             raw_data_contract,
-        } => {
-            let js_errors = errors.into_iter().map(from_consensus_error).collect();
-
-            InvalidDataContractError::new(
-                js_errors,
-                serde_wasm_bindgen::to_value(&raw_data_contract)
-                    .expect("statically known structure should be a valid JSON"),
+        } => InvalidDataContractError::new(
+            errors,
+            serde_wasm_bindgen::to_value(&raw_data_contract)
+                .expect("statically known structure should be a valid JSON"),
+        )
+        .into(),
+        DataContractError::InvalidDocumentTypeError(err) => {
+            invalid_document_type::InvalidDocumentTypeInDataContractError::new(
+                err.document_type(),
+                err.data_contract_id().into(),
             )
             .into()
         }
-        DataContractError::InvalidDocumentTypeError {
-            doc_type,
-            data_contract,
-        } => invalid_document_type::InvalidDocumentTypeInDataContractError::new(
-            doc_type,
-            data_contract.into(),
-        )
-        .into(),
         _ => todo!(),
     }
 }

package/src/data_contract/index.rs

@@ -1,6 +1,9 @@
-use dpp::{data_contract::extra::IndexProperty, util::json_schema::Index};
+use dpp::{data_contract::document_type::IndexProperty, util::json_schema::Index};
+use serde::{ser::SerializeMap, Serialize, Serializer};
 use wasm_bindgen::prelude::*;
 
+use crate::with_js_error;
+
 #[wasm_bindgen(js_name=IndexProperty)]
 #[derive(Debug, Clone)]
 pub struct IndexPropertyWasm {
@@ -38,6 +41,51 @@ impl From<Index> for IndexDefinitionWasm {
     }
 }
 
+/// Wrapper structure to serialize `Index` the way js-dpp expects it.
+#[derive(Debug)]
+struct IndexSerializeJs<'a>(&'a Index);
+
+impl Serialize for IndexSerializeJs<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(3))?;
+        map.serialize_entry("name", &self.0.name)?;
+        if self.0.unique {
+            map.serialize_entry("unique", &true)?;
+        }
+        map.serialize_entry(
+            "properties",
+            &self
+                .0
+                .properties
+                .iter()
+                .map(IndexPropertySerializeJs)
+                .collect::<Vec<_>>(),
+        )?;
+
+        map.end()
+    }
+}
+
+/// Wrapper structure to serialize `InderProperty` the way js-dpp expects it.
+#[derive(Debug)]
+struct IndexPropertySerializeJs<'a>(&'a IndexProperty);
+
+impl Serialize for IndexPropertySerializeJs<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(1))?;
+        let order_str = if self.0.ascending { "asc" } else { "desc" };
+        map.serialize_entry(&self.0.name, order_str)?;
+
+        map.end()
+    }
+}
+
 #[wasm_bindgen(js_class=IndexDefinition)]
 impl IndexDefinitionWasm {
     #[wasm_bindgen(js_name=getName)]
@@ -58,4 +106,11 @@ impl IndexDefinitionWasm {
     pub fn is_unique(&self) -> bool {
         self.inner.unique
     }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let object = with_js_error!(IndexSerializeJs(&self.inner).serialize(&serializer))?;
+        Ok(object)
+    }
 }

package/src/data_contract/mod.rs

@@ -4,7 +4,11 @@ pub use state_transition::*;
 
 mod data_contract;
 pub mod errors;
+
 mod state_transition;
 
+mod data_contract_facade;
 mod index;
+
+pub use data_contract_facade::DataContractFacadeWasm;
 pub use index::*;

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

@@ -1,6 +1,6 @@
 use std::ops::Deref;
 
-use dpp::data_contract::state_transition::apply_data_contract_create_transition_factory::ApplyDataContractCreateTransition;
+use dpp::data_contract::state_transition::data_contract_create_transition::apply_data_contract_create_transition_factory::ApplyDataContractCreateTransition;
 use wasm_bindgen::prelude::*;
 
 use crate::{