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

package/src/identity/state_transition/validate_public_key_signatures.rs

@@ -0,0 +1,61 @@
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
+use crate::utils::ToSerdeJSONExt;
+
+use crate::validation::ValidationResultWasm;
+
+use crate::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransitionWasm;
+
+use dpp::identity::state_transition::validate_public_key_signatures::{
+    PublicKeysSignaturesValidator, TPublicKeysSignaturesValidator,
+};
+
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransition;
+
+use serde_json::Value as JsonValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name = PublicKeysSignaturesValidator)]
+pub struct PublicKeysSignaturesValidatorWasm(PublicKeysSignaturesValidator<BlsAdapter>);
+
+impl From<PublicKeysSignaturesValidator<BlsAdapter>> for PublicKeysSignaturesValidatorWasm {
+    fn from(validator: PublicKeysSignaturesValidator<BlsAdapter>) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class = PublicKeysSignaturesValidator)]
+impl PublicKeysSignaturesValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(bls: JsBlsAdapter) -> PublicKeysSignaturesValidatorWasm {
+        PublicKeysSignaturesValidator::new(BlsAdapter(bls)).into()
+    }
+
+    #[wasm_bindgen(js_name=validate)]
+    pub fn validate_public_key_signatures(
+        &self,
+        raw_state_transition: JsValue,
+        raw_public_keys: Vec<JsValue>,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let state_transition_json = raw_state_transition.with_serde_to_json_value()?;
+
+        let public_keys = raw_public_keys
+            .into_iter()
+            .map(|raw_key| {
+                let parsed_key: IdentityPublicKeyCreateTransition =
+                    IdentityPublicKeyCreateTransitionWasm::new(raw_key)?.into();
+                parsed_key
+                    .to_raw_json_object(false)
+                    .map_err(|e| from_dpp_err(e.into()))
+            })
+            .collect::<Result<Vec<JsonValue>, JsValue>>()?;
+
+        let result = self
+            .0
+            .validate_public_key_signatures(&state_transition_json, &public_keys)
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/identity/validation/identity_validator.rs

@@ -0,0 +1,50 @@
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
+use crate::utils;
+use crate::validation::ValidationResultWasm;
+use dpp::identity::validation::{IdentityValidator, PublicKeysValidator};
+use dpp::version::ProtocolVersionValidator;
+use serde_json::Value;
+use std::sync::Arc;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::{JsError, JsValue};
+
+#[wasm_bindgen(js_name=IdentityValidator)]
+pub struct IdentityValidatorWasm(IdentityValidator<PublicKeysValidator<BlsAdapter>>);
+
+impl From<IdentityValidator<PublicKeysValidator<BlsAdapter>>> for IdentityValidatorWasm {
+    fn from(v: IdentityValidator<PublicKeysValidator<BlsAdapter>>) -> Self {
+        Self(v)
+    }
+}
+
+impl From<IdentityValidatorWasm> for IdentityValidator<PublicKeysValidator<BlsAdapter>> {
+    fn from(v: IdentityValidatorWasm) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityValidator)]
+impl IdentityValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(bls: JsBlsAdapter) -> Result<IdentityValidatorWasm, JsError> {
+        Ok(IdentityValidator::new(
+            Arc::new(ProtocolVersionValidator::default()),
+            Arc::new(PublicKeysValidator::new(BlsAdapter(bls))?),
+        )?
+        .into())
+    }
+
+    #[wasm_bindgen]
+    pub fn validate(&self, raw_identity: JsValue) -> Result<ValidationResultWasm, JsValue> {
+        let identity_json = utils::stringify(&raw_identity)?;
+        let raw_identity: Value =
+            serde_json::from_str(&identity_json).map_err(|e| e.to_string())?;
+        let result = self
+            .0
+            .validate_identity(&raw_identity)
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/identity/validation/mod.rs

@@ -1,3 +1,5 @@
+mod identity_validator;
 mod public_keys_validator;
 
+pub use identity_validator::*;
 pub use public_keys_validator::*;

package/src/identity/validation/public_keys_validator.rs

@@ -19,9 +19,7 @@ impl PublicKeysValidatorWasm {
     #[wasm_bindgen(constructor)]
     pub fn new(adapter: JsBlsAdapter) -> Result<PublicKeysValidatorWasm, JsError> {
         Ok(Self {
-            public_key_validator: PublicKeysValidator::new(BlsAdapter(JsBlsAdapter::from(
-                adapter.clone(),
-            )))?,
+            public_key_validator: PublicKeysValidator::new(BlsAdapter(adapter.clone()))?,
             public_key_in_state_transition_validator: PublicKeysValidator::new_with_schema(
                 PUBLIC_KEY_SCHEMA_FOR_TRANSITION.clone(),
                 BlsAdapter(adapter),
@@ -36,10 +34,11 @@ impl PublicKeysValidatorWasm {
     ) -> Result<ValidationResultWasm, JsValue> {
         let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
 
-        self.public_key_validator
+        let validation_result = self
+            .public_key_validator
             .validate_keys(&raw_public_keys)
-            .map(ValidationResultWasm::from)
-            .map_err(|e| JsValue::from(e.to_string()))
+            .map_err(|e| JsValue::from(e.to_string()))?;
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
     }
 
     #[wasm_bindgen(js_name=validatePublicKeyStructure)]
@@ -47,12 +46,13 @@ impl PublicKeysValidatorWasm {
         &self,
         public_key: JsValue,
     ) -> Result<ValidationResultWasm, JsValue> {
-        let pk_serde_json = public_key.to_serde_json_value()?;
+        let pk_serde_json = public_key.with_serde_to_json_value()?;
 
-        self.public_key_validator
+        let validation_result = self
+            .public_key_validator
             .validate_public_key_structure(&pk_serde_json)
-            .map(ValidationResultWasm::from)
-            .map_err(|e| JsValue::from(e.to_string()))
+            .map_err(|e| JsValue::from(e.to_string()))?;
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
     }
 
     #[wasm_bindgen(js_name=validateKeysInStateTransition)]
@@ -62,9 +62,10 @@ impl PublicKeysValidatorWasm {
     ) -> Result<ValidationResultWasm, JsValue> {
         let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
 
-        self.public_key_in_state_transition_validator
+        let validation_result = self
+            .public_key_in_state_transition_validator
             .validate_keys(&raw_public_keys)
-            .map(ValidationResultWasm::from)
-            .map_err(|e| JsValue::from(e.to_string()))
+            .map_err(|e| JsValue::from(e.to_string()))?;
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
     }
 }

package/src/identity_public_key/public_keys_validator.rs

@@ -0,0 +1,44 @@
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+
+use crate::utils::{to_vec_of_serde_values, ToSerdeJSONExt};
+use crate::validation_result::ValidationResultWasm;
+use dpp::identity::validation::{PublicKeysValidator, TPublicKeysValidator};
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = PublicKeysValidator)]
+pub struct PublicKeysValidatorWasm(PublicKeysValidator<BlsAdapter>);
+
+#[wasm_bindgen(js_class = PublicKeysValidator)]
+impl PublicKeysValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(adapter: JsBlsAdapter) -> PublicKeysValidatorWasm {
+        Self(PublicKeysValidator::new(BlsAdapter(adapter)).unwrap())
+    }
+
+    #[wasm_bindgen(js_name=validateKeys)]
+    pub fn validate_keys(
+        &self,
+        public_keys: js_sys::Array,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
+
+        self.0
+            .validate_keys(&raw_public_keys)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name=validatePublicKeyStructure)]
+    pub fn validate_public_key_structure(
+        &self,
+        public_key: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let pk_serde_json = public_key.with_serde_to_json_value()?;
+
+        self.0
+            .validate_public_key_structure(&pk_serde_json)
+            .map(ValidationResultWasm::from)
+            .map_err(|e| JsValue::from(e.to_string()))
+    }
+}

package/src/lib.rs

@@ -1,6 +1,9 @@
+extern crate core;
+
 pub use dash_platform_protocol::*;
 pub use data_contract::*;
 pub use data_contract_factory::*;
+pub use data_trigger::*;
 pub use document::*;
 pub use identity::*;
 pub use metadata::*;
@@ -9,6 +12,7 @@ pub use state_transition::*;
 mod dash_platform_protocol;
 mod data_contract;
 mod data_contract_factory;
+mod data_trigger;
 mod document;
 pub mod errors;
 mod identifier;
@@ -16,9 +20,11 @@ mod identity;
 mod metadata;
 mod state_repository;
 mod state_transition;
+mod version;
 
 mod utils;
 
 mod bls_adapter;
 mod buffer;
+mod lodash;
 mod validation;

package/src/lodash.rs

@@ -0,0 +1,7 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(module = "lodash")]
+extern "C" {
+    #[wasm_bindgen(js_name = "set")]
+    pub fn lodash_set(object: &JsValue, path: &str, value: JsValue);
+}

package/src/metadata.rs

@@ -3,7 +3,10 @@
 pub use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
+use crate::utils::ToSerdeJSONExt;
 use dpp::metadata::Metadata;
+use dpp::util::deserializer::ProtocolVersion;
+use dpp::util::json_value::JsonValueExt;
 
 #[wasm_bindgen(js_name=Metadata)]
 #[derive(Debug)]
@@ -14,6 +17,13 @@ impl std::convert::From<Metadata> for MetadataWasm {
         MetadataWasm(v)
     }
 }
+
+impl std::convert::From<&MetadataWasm> for Metadata {
+    fn from(v: &MetadataWasm) -> Self {
+        v.0.clone()
+    }
+}
+
 impl std::convert::Into<Metadata> for MetadataWasm {
     fn into(self) -> Metadata {
         self.0
@@ -24,21 +34,35 @@ impl std::convert::Into<Metadata> for MetadataWasm {
 #[wasm_bindgen(js_class=Metadata)]
 impl MetadataWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(block_height: JsValue, core_chain_locked_height: JsValue) -> Self {
-        // TODO: return an error instead of unwraps
-        let block_height = block_height.as_f64().unwrap() as u64;
-        let core_chain_locked_height = core_chain_locked_height.as_f64().unwrap() as u64;
+    pub fn new(options: JsValue) -> Result<MetadataWasm, JsValue> {
+        let metadata_options = options.with_serde_to_json_value()?;
+        let block_height = metadata_options
+            .get_f64("blockHeight")
+            .map_err(|e| JsError::new(&e.to_string()))?;
+        let core_chain_locked_height = metadata_options
+            .get_f64("coreChainLockedHeight")
+            .map_err(|e| JsError::new(&e.to_string()))?;
+        let time_ms = metadata_options
+            .get_f64("timeMs")
+            .map_err(|e| JsError::new(&e.to_string()))?;
+        let protocol_version = metadata_options
+            .get_f64("protocolVersion")
+            .map_err(|e| JsError::new(&e.to_string()))?;
+
         let inner = Metadata {
-            block_height,
-            core_chain_locked_height,
+            block_height: block_height as u64,
+            core_chain_locked_height: core_chain_locked_height as u64,
+            time_ms: time_ms as u64,
+            protocol_version: protocol_version as u64 as ProtocolVersion,
         };
-        inner.into()
+        Ok(inner.into())
     }
 
     #[wasm_bindgen(js_name=from)]
-    pub fn from(object: JsValue) -> Self {
-        let i: Metadata = serde_json::from_str(&object.as_string().unwrap()).unwrap();
-        MetadataWasm(i)
+    pub fn from(object: JsValue) -> Result<MetadataWasm, JsValue> {
+        let metadata: Metadata = serde_wasm_bindgen::from_value(object)?;
+
+        Ok(MetadataWasm(metadata))
     }
 
     #[wasm_bindgen(js_name=toJSON)]
@@ -51,4 +75,24 @@ impl MetadataWasm {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         self.0.serialize(&serializer).expect("implements Serialize")
     }
+
+    #[wasm_bindgen(js_name=getBlockHeight)]
+    pub fn block_height(&self) -> f64 {
+        self.0.block_height as f64
+    }
+
+    #[wasm_bindgen(js_name=getCoreChainLockedHeight)]
+    pub fn core_chain_locked_height(&self) -> f64 {
+        self.0.core_chain_locked_height as f64
+    }
+
+    #[wasm_bindgen(js_name=getTimeMs)]
+    pub fn time_ms(&self) -> f64 {
+        self.0.time_ms as f64
+    }
+
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn protocol_version(&self) -> f64 {
+        self.0.protocol_version as f64
+    }
 }