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

package/src/errors/data_contract_not_present_error.rs

@@ -0,0 +1,23 @@
+use dpp::prelude::Identifier;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+
+#[wasm_bindgen(js_name=DataContractNotPresentNotConsensusError)]
+pub struct DataContractNotPresentNotConsensusErrorWasm {
+    data_contract_id: Identifier,
+}
+
+impl DataContractNotPresentNotConsensusErrorWasm {
+    pub fn new(data_contract_id: Identifier) -> Self {
+        Self { data_contract_id }
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractNotPresentNotConsensusError)]
+impl DataContractNotPresentNotConsensusErrorWasm {
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn get_data_contract_id(&self) -> Buffer {
+        Buffer::from_bytes(self.data_contract_id.as_bytes())
+    }
+}

package/src/errors/dpp_error.rs

@@ -0,0 +1,17 @@
+use crate::identity::errors::{
+    AssetLockOutputNotFoundErrorWasm, AssetLockTransactionIsNotFoundErrorWasm,
+};
+use dpp::DPPError;
+use wasm_bindgen::JsValue;
+
+pub fn from_dpp_error_ref(e: &DPPError) -> JsValue {
+    match e {
+        DPPError::AssetLockOutputNotFoundError(e) => {
+            AssetLockOutputNotFoundErrorWasm::from(e).into()
+        }
+        DPPError::AssetLockTransactionIsNotFoundError(e) => {
+            AssetLockTransactionIsNotFoundErrorWasm::from(e).into()
+        }
+        _ => unimplemented!(),
+    }
+}

package/src/errors/from.rs

@@ -1,12 +1,21 @@
+use dpp::DashPlatformProtocolInitError;
+
 use wasm_bindgen::JsValue;
 
 use dpp::errors::ProtocolError;
 
 use crate::data_contract::errors::from_data_contract_to_js_error;
 use crate::document::errors::from_document_to_js_error;
+use crate::identifier::errors::IdentifierErrorWasm;
+
+use super::consensus_error::from_consensus_error;
+use super::data_contract_not_present_error::DataContractNotPresentNotConsensusErrorWasm;
 
 pub fn from_dpp_err(pe: ProtocolError) -> JsValue {
     match pe {
+        ProtocolError::AbstractConsensusError(consensus_error) => {
+            from_consensus_error(*consensus_error)
+        }
         ProtocolError::DataContractError(e) => from_data_contract_to_js_error(e),
 
         ProtocolError::Document(e) => from_document_to_js_error(*e),
@@ -19,6 +28,19 @@ pub fn from_dpp_err(pe: ProtocolError) -> JsValue {
         )
         .into(),
 
+        ProtocolError::DataContractNotPresentError(err) => {
+            DataContractNotPresentNotConsensusErrorWasm::new(err.data_contract_id()).into()
+        }
+
+        ProtocolError::IdentifierError(err) => IdentifierErrorWasm::new(err).into(),
         _ => JsValue::from_str(&format!("Error conversion not implemented: {pe:#}",)),
     }
 }
+
+pub fn from_dpp_init_error(e: DashPlatformProtocolInitError) -> JsValue {
+    match e {
+        DashPlatformProtocolInitError::SchemaDeserializationError(e) => e.to_string().into(),
+        DashPlatformProtocolInitError::ValidationError(e) => e.to_string().into(),
+        DashPlatformProtocolInitError::InvalidSchemaError(e) => e.to_string().into(),
+    }
+}

package/src/errors/js_conversion.rs

@@ -1,7 +1,8 @@
+use anyhow::anyhow;
 use serde_json;
 use serde_wasm_bindgen::Error;
 use thiserror::Error;
-use wasm_bindgen::JsValue;
+use wasm_bindgen::{JsCast, JsValue};
 
 /// This is a rust-specific errors. In addition to all errors defined in `js-dpp`, the
 /// error might be triggered when using JS bindings
@@ -41,23 +42,69 @@ impl From<serde_wasm_bindgen::Error> for RustConversionError {
 #[macro_export]
 macro_rules! with_js_error {
     ($o:expr) => {
-        $o.map_err(|e| RustConversionError::from(e).to_js_value())
+        $o.map_err(|e| $crate::errors::RustConversionError::from(e).to_js_value())
     };
 }
 
 #[macro_export]
 macro_rules! bail_js {
     ($msg:literal) => ({
-        return Err(RustConversionError::from(String::from($msg)).to_js_value())
+        return Err($crate::errors::RustConversionError::from(String::from($msg)).to_js_value())
     });
 
     ($err:expr $(,)?) => ({
         use $crate::private::kind::*;
-        return Err(RustConversionError::from($err).to_js_value())
+        return Err($crate::errors::RustConversionError::from($err).to_js_value())
     });
 
     ($fmt:expr, $($arg:tt)*) => {
-        return Err(RustConversionError::from(format!($fmt, $($arg)*)).to_js_value())
+        return Err($crate::errors::RustConversionError::from(format!($fmt, $($arg)*)).to_js_value())
     };
 
 }
+
+#[macro_export]
+macro_rules! console_log {
+    ($msg:literal) => {{
+        web_sys::console::log_1(&format!($msg).into())
+    }};
+
+    ($msg:expr $(,)?) => {{
+        web_sys::console::log_1(&format!("{}", $msg).into())
+    }};
+
+    ($fmt:expr, $($arg:tt)*) => {
+        web_sys::console::log_1(&format!($fmt, $($arg)*).into())
+    };
+}
+
+pub fn from_js_error(e: JsValue) -> anyhow::Error {
+    let message = if e.is_instance_of::<js_sys::Error>() {
+        js_sys::Reflect::get(&e, &"message".into())
+            .map(|e| {
+                e.as_string()
+                    .unwrap_or_else(|| String::from("Unknown JS Error: empty error message."))
+            })
+            .unwrap_or_else(|_| String::from("Unknown JS Error: unable to access error message"))
+    } else {
+        // TODO: is there a simpler way to to call `toString()`?
+        let to_string_value = js_sys::Reflect::get(&e, &JsValue::from_str("toString"))
+            .unwrap_or_else(|_| JsValue::undefined());
+
+        let message = if let Some(to_string_function) =
+            to_string_value.dyn_ref::<js_sys::Function>()
+        {
+            to_string_function
+                .call0(&e)
+                .unwrap_or_else(|_| JsValue::from_str("Unknown JS Error: call toString() failed"))
+                .as_string()
+                .unwrap()
+        } else {
+            String::from("Unknown Error: toString() is not a function")
+        };
+
+        message
+    };
+
+    anyhow!(message)
+}

package/src/errors/mod.rs

@@ -3,9 +3,15 @@ pub use js_conversion::*;
 
 pub mod consensus;
 pub mod consensus_error;
+
 mod from;
 mod js_conversion;
 pub mod protocol_error;
 mod public_key_validation_error;
 
 pub use public_key_validation_error::*;
+
+mod compatible_protocol_version_is_not_defined_error;
+pub mod data_contract_not_present_error;
+pub mod dpp_error;
+pub use compatible_protocol_version_is_not_defined_error::*;

package/src/errors/protocol_error.rs

@@ -1,12 +1,23 @@
+use crate::data_contract::errors::InvalidDataContractError;
 use wasm_bindgen::JsValue;
 
 use super::consensus_error::from_consensus_error;
 
-pub fn from_protocol_error(e: dpp::ProtocolError) -> JsValue {
-    match e {
+pub fn from_protocol_error(protocol_error: dpp::ProtocolError) -> JsValue {
+    match protocol_error {
         dpp::ProtocolError::AbstractConsensusError(consensus_error) => {
             from_consensus_error(*consensus_error)
         }
-        _ => unimplemented!(),
+        dpp::ProtocolError::InvalidDataContractError(err) => {
+            let raw_data_contract = err.raw_data_contract();
+            let protocol = serde_wasm_bindgen::to_value(&raw_data_contract);
+            protocol.map_or_else(JsValue::from, |raw_contract| {
+                InvalidDataContractError::new(err.errors, raw_contract).into()
+            })
+        }
+        dpp::ProtocolError::Error(anyhow_error) => {
+            format!("Non-protocol error: {}", anyhow_error).into()
+        }
+        _ => todo!("Implement protocol error conversions"),
     }
 }

package/src/identifier/errors.rs

@@ -0,0 +1,30 @@
+use thiserror::Error;
+use wasm_bindgen::prelude::*;
+
+#[derive(Error, Debug)]
+#[wasm_bindgen(js_name=IdentifierError)]
+#[error("{message}")]
+pub struct IdentifierErrorWasm {
+    message: String,
+}
+
+impl IdentifierErrorWasm {
+    pub fn new(message: impl Into<String>) -> Self {
+        Self {
+            message: message.into(),
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=IdentifierError)]
+impl IdentifierErrorWasm {
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn get_message(&self) -> String {
+        self.message.clone()
+    }
+
+    #[wasm_bindgen(js_name=toString)]
+    pub fn print(&self) -> String {
+        format!("IdentifierError: {0}", { &self.message })
+    }
+}

package/src/identifier/mod.rs

@@ -1,9 +1,20 @@
+pub mod errors;
+
+use dpp::prelude::Identifier;
+use dpp::util::string_encoding::Encoding;
+use itertools::Itertools;
 pub use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsCast;
 
+use crate::bail_js;
 use crate::buffer::Buffer;
 use crate::errors::from_dpp_err;
+use crate::identifier::errors::IdentifierErrorWasm;
+use crate::utils::Inner;
+use crate::utils::ToSerdeJSONExt;
+use crate::utils::WithJsError;
 use dpp::identifier;
 
 #[derive(Serialize, Deserialize, PartialEq, Eq)]
@@ -20,6 +31,7 @@ extern "C" {
     fn log(a: &str);
 }
 
+#[derive(Clone, Debug)]
 #[wasm_bindgen(js_name=Identifier, inspectable)]
 pub struct IdentifierWrapper {
     wrapped: identifier::Identifier,
@@ -31,12 +43,32 @@ impl std::convert::From<identifier::Identifier> for IdentifierWrapper {
     }
 }
 
+impl std::convert::From<&IdentifierWrapper> for identifier::Identifier {
+    fn from(s: &IdentifierWrapper) -> Self {
+        s.wrapped
+    }
+}
+
+impl std::convert::From<IdentifierWrapper> for Identifier {
+    fn from(s: IdentifierWrapper) -> Self {
+        s.wrapped
+    }
+}
+
 #[wasm_bindgen(js_class=Identifier)]
 impl IdentifierWrapper {
     #[wasm_bindgen(constructor)]
-    pub fn new(buffer: Vec<u8>) -> Result<IdentifierWrapper, JsValue> {
-        // TODO: remove unwrap
-        let identifier = identifier::Identifier::from_bytes(&buffer).map_err(from_dpp_err)?;
+    pub fn new(js_value: JsValue) -> Result<IdentifierWrapper, JsValue> {
+        // Can be possible reworked with Buffer::is_buffer(&js_value)
+        // but until we use Buffer shim for both Node and Web,
+        // it will return false negative in Node.JS environment
+        if !js_value.has_type::<js_sys::Uint8Array>() {
+            return Err(IdentifierErrorWasm::new("Identifier expects Buffer").into());
+        }
+
+        let vec = js_value.dyn_into::<js_sys::Uint8Array>()?.to_vec();
+
+        let identifier = identifier::Identifier::from_bytes(&vec).map_err(from_dpp_err)?;
 
         Ok(IdentifierWrapper {
             wrapped: identifier,
@@ -47,13 +79,12 @@ impl IdentifierWrapper {
         if value.is_string() {
             let string = value.as_string().unwrap();
             Ok(IdentifierWrapper::from_string(string, encoding))
-        } else if value.has_type::<js_sys::Uint8Array>() {
-            let vec = value.dyn_into::<js_sys::Uint8Array>()?.to_vec();
-            IdentifierWrapper::new(vec)
+        } else if value.has_type::<js_sys::Uint8Array>() && encoding.is_none() {
+            IdentifierWrapper::new(value)
+        } else if value.has_type::<js_sys::Uint8Array>() && encoding.is_some() {
+            Err(IdentifierErrorWasm::new("encoding accepted only with type string").into())
         } else {
-            Err(JsValue::from(
-                "Identifier.from received an unexpected value",
-            ))
+            Err(IdentifierErrorWasm::new("Identifier.from received an unexpected value").into())
         }
     }
 
@@ -73,7 +104,7 @@ impl IdentifierWrapper {
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Buffer {
-        Buffer::from_bytes(self.wrapped.buffer.as_slice())
+        Buffer::from_bytes(&self.wrapped.buffer)
     }
 
     #[wasm_bindgen(js_name=toJSON)]
@@ -97,7 +128,60 @@ impl IdentifierWrapper {
         self.wrapped.buffer.len()
     }
 
-    pub fn inner(&self) -> Vec<u8> {
+    #[wasm_bindgen(js_name=toBytes)]
+    pub fn to_bytes(&self) -> Vec<u8> {
         self.wrapped.buffer.to_vec()
     }
+
+    #[wasm_bindgen(js_name=clone)]
+    pub fn deep_clone(&self) -> IdentifierWrapper {
+        IdentifierWrapper {
+            wrapped: self.wrapped,
+        }
+    }
+}
+
+impl Inner for IdentifierWrapper {
+    type InnerItem = Identifier;
+
+    fn into_inner(self) -> Identifier {
+        self.wrapped
+    }
+
+    fn inner(&self) -> &Identifier {
+        &self.wrapped
+    }
+
+    fn inner_mut(&mut self) -> &mut Identifier {
+        &mut self.wrapped
+    }
+}
+
+// Try to extract Identifier from **stringified** identifier.
+// The `js_value` can be a stringified instance of: `Identifier`, `Buffer` or `Array`
+pub(crate) fn identifier_from_js_value(js_value: &JsValue) -> Result<Identifier, JsValue> {
+    if js_value.is_undefined() || js_value.is_null() {
+        bail_js!("the identifier cannot be null or undefined")
+    }
+    let value = js_value.with_serde_to_json_value()?;
+    match value {
+        Value::Array(arr) => {
+            let bytes: Vec<u8> = arr.into_iter().map(value_to_u8).try_collect()?;
+            Identifier::from_bytes(&bytes).with_js_error()
+        }
+        Value::String(string) => Identifier::from_string(&string, Encoding::Base58).with_js_error(),
+        _ => {
+            bail_js!("Invalid ID. Expected array or string")
+        }
+    }
+}
+
+fn value_to_u8(v: Value) -> Result<u8, JsValue> {
+    let number = v
+        .as_u64()
+        .ok_or_else(|| format!("failed converting {} into u64", v))?;
+    if number > u8::MAX as u64 {
+        bail_js!("the integer in the array isn't a byte: {}", number);
+    }
+    Ok(number as u8)
 }

package/src/identity/errors/asset_lock_output_not_found_error.rs

@@ -0,0 +1,11 @@
+use dpp::identity::errors::AssetLockOutputNotFoundError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=AssetLockOutputNotFoundError)]
+pub struct AssetLockOutputNotFoundErrorWasm(AssetLockOutputNotFoundError);
+
+impl From<&AssetLockOutputNotFoundError> for AssetLockOutputNotFoundErrorWasm {
+    fn from(e: &AssetLockOutputNotFoundError) -> Self {
+        Self(e.clone())
+    }
+}

package/src/identity/errors/asset_lock_transaction_is_not_found_error.rs

@@ -0,0 +1,20 @@
+use dpp::dashcore::hashes::hex::ToHex;
+use dpp::identity::errors::AssetLockTransactionIsNotFoundError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=AssetLockTransactionIsNotFoundError)]
+pub struct AssetLockTransactionIsNotFoundErrorWasm(AssetLockTransactionIsNotFoundError);
+
+impl From<&AssetLockTransactionIsNotFoundError> for AssetLockTransactionIsNotFoundErrorWasm {
+    fn from(e: &AssetLockTransactionIsNotFoundError) -> Self {
+        Self(e.clone())
+    }
+}
+
+#[wasm_bindgen(js_class=AssetLockTransactionIsNotFoundError)]
+impl AssetLockTransactionIsNotFoundErrorWasm {
+    #[wasm_bindgen(js_name=getTransactionId)]
+    pub fn transaction_id(&self) -> JsValue {
+        self.0.transaction_id().to_hex().into()
+    }
+}

package/src/identity/errors/invalid_identity_error.rs

@@ -0,0 +1,32 @@
+use crate::errors::consensus_error::from_consensus_error_ref;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=InvalidIdentityError)]
+pub struct InvalidIdentityError {
+    errors: Vec<ConsensusError>,
+    raw_identity: JsValue,
+}
+
+impl InvalidIdentityError {
+    pub fn new(errors: Vec<ConsensusError>, raw_identity: JsValue) -> Self {
+        InvalidIdentityError {
+            errors,
+            raw_identity,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIdentityError)]
+impl InvalidIdentityError {
+    #[wasm_bindgen(js_name=getErrors)]
+    pub fn get_errors(&self) -> Vec<JsValue> {
+        self.errors.iter().map(from_consensus_error_ref).collect()
+    }
+
+    #[wasm_bindgen(js_name=getRawIdentity)]
+    pub fn get_raw_identity(&self) -> JsValue {
+        self.raw_identity.clone()
+    }
+}

package/src/identity/errors/mod.rs

@@ -0,0 +1,9 @@
+pub use asset_lock_output_not_found_error::*;
+pub use asset_lock_transaction_is_not_found_error::*;
+pub use invalid_identity_error::*;
+pub use unknown_asset_lock_proof_type_error::*;
+
+mod asset_lock_output_not_found_error;
+mod asset_lock_transaction_is_not_found_error;
+mod invalid_identity_error;
+mod unknown_asset_lock_proof_type_error;

package/src/identity/errors/unknown_asset_lock_proof_type_error.rs

@@ -0,0 +1,26 @@
+use dpp::identity::errors::UnknownAssetLockProofTypeError;
+use wasm_bindgen::prelude::*;
+
+#[derive(Clone)]
+#[wasm_bindgen(js_name=UnknownAssetLockProofTypeError)]
+pub struct UnknownAssetLockProofTypeErrorWasm(UnknownAssetLockProofTypeError);
+
+impl From<&UnknownAssetLockProofTypeError> for UnknownAssetLockProofTypeErrorWasm {
+    fn from(e: &UnknownAssetLockProofTypeError) -> Self {
+        Self(e.clone())
+    }
+}
+
+impl From<UnknownAssetLockProofTypeError> for UnknownAssetLockProofTypeErrorWasm {
+    fn from(e: UnknownAssetLockProofTypeError) -> Self {
+        Self(e)
+    }
+}
+
+#[wasm_bindgen(js_class=UnknownAssetLockProofTypeError)]
+impl UnknownAssetLockProofTypeErrorWasm {
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> Option<u8> {
+        self.0.asset_lock_type()
+    }
+}

package/src/identity/factory_utils.rs

@@ -0,0 +1,87 @@
+use crate::errors::RustConversionError;
+use crate::identity::identity_public_key_transitions::IdentityPublicKeyCreateTransitionWasm;
+use crate::utils::{generic_of_js_val, to_vec_of_serde_values};
+use crate::{create_asset_lock_proof_from_wasm_instance, IdentityPublicKeyWasm};
+use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransition;
+use dpp::identity::{IdentityPublicKey, KeyID};
+use std::collections::BTreeMap;
+use wasm_bindgen::__rt::Ref;
+use wasm_bindgen::{JsCast, JsValue};
+
+pub fn parse_create_args(
+    asset_lock_proof: JsValue,
+    public_keys: js_sys::Array,
+) -> Result<(AssetLockProof, BTreeMap<KeyID, IdentityPublicKey>), JsValue> {
+    let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?;
+
+    let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
+
+    let public_keys = raw_public_keys
+        .into_iter()
+        .map(|v| IdentityPublicKey::from_raw_object(v).map(|key| (key.id, key)))
+        .collect::<Result<_, _>>()
+        .map_err(|e| format!("converting to collection of IdentityPublicKeys failed: {e:#}"))?;
+
+    Ok((asset_lock_proof, public_keys))
+}
+
+type AddPublicKeys = Option<Vec<IdentityPublicKeyCreateTransition>>;
+type DisablePublicKeys = Option<Vec<KeyID>>;
+
+pub fn parse_create_identity_update_transition_keys(
+    public_keys: &JsValue,
+) -> Result<(AddPublicKeys, DisablePublicKeys), JsValue> {
+    let mut add_public_keys = None;
+
+    if js_sys::Reflect::has(public_keys, &"add".into()).unwrap_or(false) {
+        let raw_add_public_keys = js_sys::Reflect::get(public_keys, &"add".into()).unwrap();
+
+        let add_public_keys_array: &js_sys::Array = raw_add_public_keys
+            .dyn_ref::<js_sys::Array>()
+            .ok_or_else(|| {
+                RustConversionError::Error(String::from("public keys to add must be array"))
+                    .to_js_value()
+            })?;
+
+        let keys: Vec<IdentityPublicKeyCreateTransition> = add_public_keys_array
+            .iter()
+            .map(|key| {
+                let public_key: Ref<IdentityPublicKeyCreateTransitionWasm> =
+                    generic_of_js_val::<IdentityPublicKeyCreateTransitionWasm>(
+                        &key,
+                        "IdentityPublicKeyCreateTransition",
+                    )?;
+
+                Ok(public_key.clone().into())
+            })
+            .collect::<Result<Vec<IdentityPublicKeyCreateTransition>, JsValue>>()?;
+
+        add_public_keys = Some(keys)
+    }
+
+    let mut disable_public_keys = None;
+
+    if js_sys::Reflect::has(public_keys, &"disable".into()).unwrap_or(false) {
+        let raw_disable_public_keys = js_sys::Reflect::get(public_keys, &"disable".into()).unwrap();
+        let disable_public_keys_array: &js_sys::Array = raw_disable_public_keys
+            .dyn_ref::<js_sys::Array>()
+            .ok_or_else(|| {
+                RustConversionError::Error(String::from("public keys to disable must be array"))
+                    .to_js_value()
+            })?;
+
+        let keys: Vec<KeyID> = disable_public_keys_array
+            .iter()
+            .map(|key| {
+                let public_key_wasm: Ref<IdentityPublicKeyWasm> =
+                    generic_of_js_val::<IdentityPublicKeyWasm>(&key, "IdentityPublicKey")?;
+                Ok(public_key_wasm.get_id())
+            })
+            .collect::<Result<Vec<KeyID>, JsValue>>()?;
+
+        disable_public_keys = Some(keys)
+    }
+
+    Ok((add_public_keys, disable_public_keys))
+}