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

package/src/utils.rs

@@ -1,15 +1,37 @@
-use dpp::dashcore::anyhow::Context;
+use dpp::{
+    dashcore::{anyhow, anyhow::Context},
+    ProtocolError,
+};
+
 use js_sys::Function;
+use serde::de::DeserializeOwned;
 use serde_json::Value;
+use wasm_bindgen::convert::RefFromWasmAbi;
 use wasm_bindgen::prelude::*;
 
+use crate::errors::{from_dpp_err, RustConversionError};
+
 pub trait ToSerdeJSONExt {
-    fn to_serde_json_value(&self) -> Result<Value, JsValue>;
+    fn with_serde_to_json_value(&self) -> Result<Value, JsValue>;
+    fn with_serde_into<D: DeserializeOwned>(&self) -> Result<D, JsValue>
+    where
+        D: for<'de> serde::de::Deserialize<'de> + 'static;
 }
 
 impl ToSerdeJSONExt for JsValue {
-    fn to_serde_json_value(&self) -> Result<Value, JsValue> {
-        to_serde_json_value(self)
+    /// Converts the `JsValue` into `serde_json::Value`. It's an expensive conversion,
+    /// as `JsValue` must be stringified first
+    fn with_serde_to_json_value(&self) -> Result<Value, JsValue> {
+        with_serde_to_json_value(self)
+    }
+
+    /// converts the `JsValue` into any type that is supported by serde. It's an expensive conversion
+    /// as the `jsValue` must be stringified first
+    fn with_serde_into<D>(&self) -> Result<D, JsValue>
+    where
+        D: for<'de> serde::de::Deserialize<'de> + 'static,
+    {
+        with_serde_into(self)
     }
 }
 
@@ -25,7 +47,7 @@ pub fn to_vec_of_serde_values(
 ) -> Result<Vec<Value>, JsValue> {
     values
         .into_iter()
-        .map(|v| v.as_ref().to_serde_json_value())
+        .map(|v| v.as_ref().with_serde_to_json_value())
         .collect()
 }
 
@@ -38,7 +60,7 @@ where
         .collect()
 }
 
-pub fn to_serde_json_value(data: &JsValue) -> Result<Value, JsValue> {
+pub fn with_serde_to_json_value(data: &JsValue) -> Result<Value, JsValue> {
     let data = stringify(data)?;
     let value: Value = serde_json::from_str(&data)
         .with_context(|| format!("cant convert {data:#?} to serde json value"))
@@ -46,10 +68,21 @@ pub fn to_serde_json_value(data: &JsValue) -> Result<Value, JsValue> {
     Ok(value)
 }
 
+pub fn with_serde_into<D>(data: &JsValue) -> Result<D, JsValue>
+where
+    D: for<'de> serde::de::Deserialize<'de> + 'static,
+{
+    let data = stringify(data)?;
+    let value: D = serde_json::from_str(&data)
+        .with_context(|| format!("cant convert {:#?} to serde json value", data))
+        .map_err(|e| format!("{:#}", e))?;
+    Ok(value)
+}
+
 pub fn stringify(data: &JsValue) -> Result<String, JsValue> {
     let replacer_func = Function::new_with_args(
         "key, value",
-        "return value.type=='Buffer' ? value.data : value ",
+        "return value && value.type=='Buffer' ? value.data : value ",
     );
 
     let data_string: String =
@@ -57,3 +90,65 @@ pub fn stringify(data: &JsValue) -> Result<String, JsValue> {
 
     Ok(data_string)
 }
+
+pub trait WithJsError<T> {
+    /// Converts the error into JsValue
+    fn with_js_error(self) -> Result<T, JsValue>;
+}
+
+impl<T> WithJsError<T> for Result<T, anyhow::Error> {
+    fn with_js_error(self) -> Result<T, JsValue> {
+        match self {
+            Ok(ok) => Ok(ok),
+            Err(error) => Err(format!("{error:#}").into()),
+        }
+    }
+}
+
+impl<T> WithJsError<T> for Result<T, ProtocolError> {
+    fn with_js_error(self) -> Result<T, JsValue> {
+        match self {
+            Ok(ok) => Ok(ok),
+            Err(error) => Err(from_dpp_err(error)),
+        }
+    }
+}
+
+impl<T> WithJsError<T> for Result<T, serde_json::Error> {
+    fn with_js_error(self) -> Result<T, JsValue> {
+        match self {
+            Ok(ok) => Ok(ok),
+            Err(error) => Err(RustConversionError::from(error).to_js_value()),
+        }
+    }
+}
+
+pub fn generic_of_js_val<T: RefFromWasmAbi<Abi = u32>>(
+    js_value: &JsValue,
+    class_name: &str,
+) -> Result<T::Anchor, JsValue> {
+    if !js_value.is_object() {
+        return Err(JsValue::from_str(
+            format!("Value supplied as {} is not an object", class_name).as_str(),
+        ));
+    }
+
+    let ctor_name = js_sys::Object::get_prototype_of(js_value)
+        .constructor()
+        .name();
+
+    if ctor_name == class_name {
+        let ptr = js_sys::Reflect::get(js_value, &JsValue::from_str("ptr"))?;
+        let ptr_u32: u32 =
+            ptr.as_f64()
+                .ok_or_else(|| JsValue::from("Invalid JS object pointer"))? as u32;
+        let reference = unsafe { T::ref_from_abi(ptr_u32) };
+        Ok(reference)
+    } else {
+        let error_string = format!(
+            "JS object constructor name mismatch. Expected {}, provided {}.",
+            class_name, ctor_name
+        );
+        Err(JsValue::from(&error_string))
+    }
+}

package/src/validation/json_schema_validator.rs

@@ -0,0 +1,41 @@
+use anyhow::Context;
+use dpp::validation::JsonSchemaValidator;
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+
+use crate::utils::{ToSerdeJSONExt, WithJsError};
+
+#[wasm_bindgen(js_name=JsonSchemaValidator)]
+pub struct JsonSchemaValidatorWasm(JsonSchemaValidator);
+
+#[wasm_bindgen(js_class=JsonSchemaValidator)]
+impl JsonSchemaValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        schema_js: &JsValue,
+        definitions: &JsValue,
+    ) -> Result<JsonSchemaValidatorWasm, JsValue> {
+        let schema = schema_js.with_serde_to_json_value()?;
+        let maybe_defs: Option<Value> = if definitions.is_object() {
+            Some(definitions.with_serde_to_json_value()?)
+        } else {
+            None
+        };
+
+        let validator = if let Some(defs) = maybe_defs {
+            let map = defs
+                .as_object()
+                .context("definitions are not a map")
+                .with_js_error()?;
+            JsonSchemaValidator::new_with_definitions(schema, map)
+                .context("Schema Validator creation with definitions failed")
+                .with_js_error()?
+        } else {
+            JsonSchemaValidator::new(schema)
+                .context("Schema Validator creation failed")
+                .with_js_error()?
+        };
+
+        Ok(JsonSchemaValidatorWasm(validator))
+    }
+}

package/src/validation/mod.rs

@@ -1,3 +1,5 @@
+mod json_schema_validator;
 mod validation_result;
 
+pub use json_schema_validator::*;
 pub use validation_result::*;

package/src/validation/validation_result.rs

@@ -4,7 +4,17 @@ use js_sys::JsString;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=ValidationResult)]
-pub struct ValidationResultWasm(ValidationResult<()>);
+#[derive(Debug)]
+pub struct ValidationResultWasm(ValidationResult<JsValue>);
+
+impl<T> From<ValidationResult<T>> for ValidationResultWasm
+where
+    T: Into<JsValue> + Clone,
+{
+    fn from(validation_result: ValidationResult<T>) -> Self {
+        ValidationResultWasm(validation_result.map(Into::into))
+    }
+}
 
 #[wasm_bindgen(js_class=ValidationResult)]
 impl ValidationResultWasm {
@@ -32,10 +42,18 @@ impl ValidationResultWasm {
             .map(from_consensus_error_ref)
             .collect()
     }
-}
 
-impl From<ValidationResult<()>> for ValidationResultWasm {
-    fn from(validation_result: ValidationResult<()>) -> Self {
-        ValidationResultWasm(validation_result)
+    #[wasm_bindgen(js_name=getData)]
+    pub fn get_data(&self) -> JsValue {
+        self.0.data().unwrap_or(&JsValue::undefined()).to_owned()
+    }
+
+    #[wasm_bindgen(js_name=getFirstError)]
+    pub fn get_first_error(&self) -> JsValue {
+        if !self.0.errors.is_empty() {
+            from_consensus_error_ref(&self.0.errors[0])
+        } else {
+            JsValue::undefined()
+        }
     }
 }

package/src/version/mod.rs

@@ -0,0 +1,2 @@
+mod protocol_version;
+pub use protocol_version::*;

package/src/version/protocol_version.rs

@@ -0,0 +1,26 @@
+use dpp::version::ProtocolVersionValidator;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=ProtocolVersionValidator)]
+pub struct ProtocolVersionValidatorWasm(ProtocolVersionValidator);
+
+#[wasm_bindgen(js_class=ProtocolVersionValidator)]
+impl ProtocolVersionValidatorWasm {
+    // TODO should the constructor be without parameters?
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> ProtocolVersionValidatorWasm {
+        ProtocolVersionValidatorWasm(ProtocolVersionValidator::default())
+    }
+}
+
+impl From<ProtocolVersionValidator> for ProtocolVersionValidatorWasm {
+    fn from(doc_validator: ProtocolVersionValidator) -> Self {
+        ProtocolVersionValidatorWasm(doc_validator)
+    }
+}
+
+impl From<ProtocolVersionValidatorWasm> for ProtocolVersionValidator {
+    fn from(val: ProtocolVersionValidatorWasm) -> Self {
+        val.0
+    }
+}