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

package/src/identity/identity_facade.rs

@@ -1,47 +1,215 @@
+use std::convert::TryInto;
+
 use std::sync::Arc;
 
 use wasm_bindgen::prelude::*;
 
 use dpp::identity::validation::PublicKeysValidator;
-use dpp::identity::IdentityFacade;
+use dpp::identity::{Identity, IdentityFacade};
+
+use crate::bls_adapter::BlsAdapter;
+use crate::buffer::Buffer;
+use crate::errors::{from_dpp_err, RustConversionError};
+use crate::identifier::IdentifierWrapper;
+use crate::identity::errors::InvalidIdentityError;
 
-use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::utils::ToSerdeJSONExt;
 use crate::validation::ValidationResultWasm;
+use crate::{
+    create_asset_lock_proof_from_wasm_instance, with_js_error, ChainAssetLockProofWasm,
+    IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm,
+    IdentityWasm, InstantAssetLockProofWasm,
+};
+use dpp::dashcore::{consensus, InstantLock, Transaction};
+
 use dpp::version::ProtocolVersionValidator;
 use dpp::NonConsensusError;
+use serde::Deserialize;
 
+#[derive(Clone)]
 #[wasm_bindgen(js_name=IdentityFacade)]
 pub struct IdentityFacadeWasm(IdentityFacade<BlsAdapter>);
 
-#[wasm_bindgen(js_class=IdentityFacade)]
 impl IdentityFacadeWasm {
-    #[wasm_bindgen(constructor)]
-    pub fn new(bls_adapter: JsBlsAdapter) -> IdentityFacadeWasm {
-        let bls = BlsAdapter(bls_adapter);
-        // TODO: REMOVE THAT LINE, TAKE IT AS AN ARGUMENT
-        let protocol_version_validator = ProtocolVersionValidator::default();
-        let public_keys_validator = PublicKeysValidator::new(bls).unwrap();
+    pub fn new(
+        protocol_version_validator: Arc<ProtocolVersionValidator>,
+        public_keys_validator: Arc<PublicKeysValidator<BlsAdapter>>,
+    ) -> IdentityFacadeWasm {
         let identity_facade = IdentityFacade::new(
-            Arc::new(protocol_version_validator),
-            Arc::new(public_keys_validator),
+            protocol_version_validator.protocol_version(),
+            protocol_version_validator,
+            public_keys_validator,
         )
         .unwrap();
 
         IdentityFacadeWasm(identity_facade)
     }
+}
 
-    #[wasm_bindgen()]
-    pub fn validate(
+#[wasm_bindgen(js_class=IdentityFacade)]
+impl IdentityFacadeWasm {
+    #[wasm_bindgen]
+    pub fn create(
         &self,
-        raw_identity_object: JsValue,
-    ) -> Result<ValidationResultWasm, NonConsensusErrorWasm> {
-        let identity_json = serde_wasm_bindgen::from_value(raw_identity_object)
-            .expect("unable to serialize identity");
-        // TODO: handle the case when
+        asset_lock_proof: JsValue,
+        public_keys: js_sys::Array,
+    ) -> Result<IdentityWasm, JsValue> {
+        let (asset_lock_proof, public_keys) =
+            super::factory_utils::parse_create_args(asset_lock_proof, public_keys)?;
+
         self.0
+            .create(asset_lock_proof, public_keys)
+            .map(|identity| identity.into())
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=createFromObject)]
+    pub fn create_from_object(
+        &self,
+        identity_object: JsValue,
+        options: JsValue,
+    ) -> Result<IdentityWasm, JsValue> {
+        let options: FromObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let raw_identity = identity_object.with_serde_to_json_value()?;
+
+        let result = self
+            .0
+            .create_from_object(raw_identity, options.skip_validation.unwrap_or(false));
+
+        match result {
+            Ok(identity) => Ok(identity.into()),
+            Err(dpp::ProtocolError::InvalidIdentityError { errors, .. }) => {
+                Err(InvalidIdentityError::new(errors, identity_object).into())
+            }
+            Err(other) => Err(from_dpp_err(other)),
+        }
+    }
+
+    #[wasm_bindgen(js_name=createFromBuffer)]
+    pub fn create_from_buffer(
+        &self,
+        buffer: Vec<u8>,
+        options: JsValue,
+    ) -> Result<IdentityWasm, JsValue> {
+        let options: FromObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let result = self
+            .0
+            .create_from_buffer(buffer.clone(), options.skip_validation.unwrap_or(false));
+
+        match result {
+            Ok(identity) => Ok(identity.into()),
+            Err(dpp::ProtocolError::InvalidIdentityError { errors, .. }) => {
+                Err(InvalidIdentityError::new(errors, Buffer::from_bytes(&buffer).into()).into())
+            }
+            Err(other) => Err(from_dpp_err(other)),
+        }
+    }
+
+    #[wasm_bindgen]
+    pub fn validate(&self, identity: IdentityWasm) -> Result<ValidationResultWasm, JsValue> {
+        let identity: Identity = identity.into();
+        let identity_json = identity.to_object().map_err(from_dpp_err)?;
+
+        let validation_result = self
+            .0
             .validate(&identity_json)
-            .map(|res| res.into())
-            .map_err(|err| err.into())
+            .map_err(|e| from_dpp_err(e.into()))?;
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+
+    #[wasm_bindgen(js_name=createInstantAssetLockProof)]
+    pub fn create_instant_asset_lock_proof(
+        &self,
+        instant_lock: Vec<u8>,
+        asset_lock_transaction: Vec<u8>,
+        output_index: u32,
+    ) -> Result<InstantAssetLockProofWasm, JsValue> {
+        let instant_lock: InstantLock =
+            consensus::deserialize(&instant_lock).map_err(|e| e.to_string())?;
+
+        let asset_lock_transaction: Transaction =
+            consensus::deserialize(&asset_lock_transaction).map_err(|e| e.to_string())?;
+
+        Ok(IdentityFacade::<BlsAdapter>::create_instant_lock_proof(
+            instant_lock,
+            asset_lock_transaction,
+            output_index,
+        )
+        .into())
+    }
+
+    #[wasm_bindgen(js_name=createChainAssetLockProof)]
+    pub fn create_chain_asset_lock_proof(
+        &self,
+        core_chain_locked_height: u32,
+        out_point: Vec<u8>,
+    ) -> Result<ChainAssetLockProofWasm, JsValue> {
+        let out_point: [u8; 36] = out_point.try_into().map_err(|_| {
+            RustConversionError::Error(String::from("outPoint must be a 36 byte array"))
+                .to_js_value()
+        })?;
+
+        Ok(IdentityFacade::<BlsAdapter>::create_chain_asset_lock_proof(
+            core_chain_locked_height,
+            out_point,
+        )
+        .into())
+    }
+
+    #[wasm_bindgen(js_name=createIdentityCreateTransition)]
+    pub fn create_identity_create_transition(
+        &self,
+        identity: &IdentityWasm,
+    ) -> Result<IdentityCreateTransitionWasm, JsValue> {
+        self.0
+            .create_identity_create_transition(Identity::from(identity.to_owned()))
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=createIdentityTopUpTransition)]
+    pub fn create_identity_topup_transition(
+        &self,
+        identity_id: &IdentifierWrapper,
+        asset_lock_proof: &JsValue,
+    ) -> Result<IdentityTopUpTransitionWasm, JsValue> {
+        let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(asset_lock_proof)?;
+
+        self.0
+            .create_identity_topup_transition(identity_id.to_owned().into(), asset_lock_proof)
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=createIdentityUpdateTransition)]
+    pub fn create_identity_update_transition(
+        &self,
+        identity: &IdentityWasm,
+        public_keys: &JsValue,
+    ) -> Result<IdentityUpdateTransitionWasm, JsValue> {
+        let (add_public_keys, disable_public_keys) =
+            super::factory_utils::parse_create_identity_update_transition_keys(public_keys)?;
+        let now = js_sys::Date::now() as u64;
+
+        self.0
+            .create_identity_update_transition(
+                identity.to_owned().into(),
+                add_public_keys,
+                disable_public_keys,
+                Some(now),
+            )
+            .map(Into::into)
+            .map_err(from_dpp_err)
     }
 }
 
@@ -53,3 +221,9 @@ impl From<NonConsensusError> for NonConsensusErrorWasm {
         Self(err)
     }
 }
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct FromObjectOptions {
+    pub skip_validation: Option<bool>,
+}

package/src/identity/identity_factory.rs

@@ -0,0 +1,209 @@
+use crate::bls_adapter::BlsAdapter;
+use crate::buffer::Buffer;
+use crate::errors::{from_dpp_err, RustConversionError};
+use crate::identifier::IdentifierWrapper;
+use crate::identity::errors::InvalidIdentityError;
+use crate::identity::validation::IdentityValidatorWasm;
+
+use crate::{
+    create_asset_lock_proof_from_wasm_instance, utils, with_js_error, ChainAssetLockProofWasm,
+    IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm,
+    IdentityWasm, InstantAssetLockProofWasm,
+};
+use dpp::dashcore::{consensus, InstantLock, Transaction};
+use dpp::identity::factory::IdentityFactory;
+
+use dpp::prelude::Identity;
+
+use serde::Deserialize;
+use serde_json::Value;
+use std::convert::TryInto;
+
+use std::sync::Arc;
+
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=IdentityFactory)]
+pub struct IdentityFactoryWasm(IdentityFactory<BlsAdapter>);
+
+impl From<IdentityFactory<BlsAdapter>> for IdentityFactoryWasm {
+    fn from(factory: IdentityFactory<BlsAdapter>) -> Self {
+        Self(factory)
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityFactory)]
+impl IdentityFactoryWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        protocol_version: u32,
+        identity_validator: IdentityValidatorWasm,
+    ) -> Result<IdentityFactoryWasm, JsValue> {
+        let factory = IdentityFactory::new(protocol_version, Arc::new(identity_validator.into()));
+        Ok(factory.into())
+    }
+
+    #[wasm_bindgen]
+    pub fn create(
+        &self,
+        asset_lock_proof: JsValue,
+        public_keys: js_sys::Array,
+    ) -> Result<IdentityWasm, JsValue> {
+        let (asset_lock_proof, public_keys) =
+            super::factory_utils::parse_create_args(asset_lock_proof, public_keys)?;
+
+        self.0
+            .create(asset_lock_proof, public_keys)
+            .map(|identity| identity.into())
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=createFromObject)]
+    pub fn create_from_object(
+        &self,
+        identity_object: JsValue,
+        options: JsValue,
+    ) -> Result<IdentityWasm, JsValue> {
+        let options: FromObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let identity_json = utils::stringify(&identity_object)?;
+        let raw_identity: Value =
+            serde_json::from_str(&identity_json).map_err(|e| e.to_string())?;
+
+        let result = self
+            .0
+            .create_from_object(raw_identity, options.skip_validation.unwrap_or(false));
+
+        match result {
+            Ok(identity) => Ok(identity.into()),
+            Err(dpp::ProtocolError::InvalidIdentityError { errors, .. }) => {
+                Err(InvalidIdentityError::new(errors, identity_object).into())
+            }
+            Err(other) => Err(from_dpp_err(other)),
+        }
+    }
+
+    #[wasm_bindgen(js_name=createFromBuffer)]
+    pub fn create_from_buffer(
+        &self,
+        buffer: Vec<u8>,
+        options: JsValue,
+    ) -> Result<IdentityWasm, JsValue> {
+        let options: FromObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options))?
+        } else {
+            Default::default()
+        };
+
+        let result = self
+            .0
+            .create_from_buffer(buffer.clone(), options.skip_validation.unwrap_or(false));
+
+        match result {
+            Ok(identity) => Ok(identity.into()),
+            Err(dpp::ProtocolError::InvalidIdentityError { errors, .. }) => {
+                Err(InvalidIdentityError::new(errors, Buffer::from_bytes(&buffer).into()).into())
+            }
+            Err(other) => Err(from_dpp_err(other)),
+        }
+    }
+
+    #[wasm_bindgen(js_name=createInstantAssetLockProof)]
+    pub fn create_instant_asset_lock_proof(
+        &self,
+        instant_lock: Vec<u8>,
+        asset_lock_transaction: Vec<u8>,
+        output_index: u32,
+    ) -> Result<InstantAssetLockProofWasm, JsValue> {
+        let instant_lock: InstantLock =
+            consensus::deserialize(&instant_lock).map_err(|e| e.to_string())?;
+
+        let asset_lock_transaction: Transaction =
+            consensus::deserialize(&asset_lock_transaction).map_err(|e| e.to_string())?;
+
+        Ok(IdentityFactory::<BlsAdapter>::create_instant_lock_proof(
+            instant_lock,
+            asset_lock_transaction,
+            output_index,
+        )
+        .into())
+    }
+
+    #[wasm_bindgen(js_name=createChainAssetLockProof)]
+    pub fn create_chain_asset_lock_proof(
+        &self,
+        core_chain_locked_height: u32,
+        out_point: Vec<u8>,
+    ) -> Result<ChainAssetLockProofWasm, JsValue> {
+        let out_point: [u8; 36] = out_point.try_into().map_err(|_| {
+            RustConversionError::Error(String::from("outPoint must be a 36 byte array"))
+                .to_js_value()
+        })?;
+
+        Ok(
+            IdentityFactory::<BlsAdapter>::create_chain_asset_lock_proof(
+                core_chain_locked_height,
+                out_point,
+            )
+            .into(),
+        )
+    }
+
+    #[wasm_bindgen(js_name=createIdentityCreateTransition)]
+    pub fn create_identity_create_transition(
+        &self,
+        identity: &IdentityWasm,
+    ) -> Result<IdentityCreateTransitionWasm, JsValue> {
+        self.0
+            .create_identity_create_transition(Identity::from(identity.to_owned()))
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=createIdentityTopUpTransition)]
+    pub fn create_identity_topup_transition(
+        &self,
+        identity_id: &IdentifierWrapper,
+        asset_lock_proof: &JsValue,
+    ) -> Result<IdentityTopUpTransitionWasm, JsValue> {
+        let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(asset_lock_proof)?;
+
+        self.0
+            .create_identity_topup_transition(identity_id.to_owned().into(), asset_lock_proof)
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=createIdentityUpdateTransition)]
+    pub fn create_identity_update_transition(
+        &self,
+        identity: &IdentityWasm,
+        public_keys: &JsValue,
+    ) -> Result<IdentityUpdateTransitionWasm, JsValue> {
+        let (add_public_keys, disable_public_keys) =
+            super::factory_utils::parse_create_identity_update_transition_keys(public_keys)?;
+
+        let now = js_sys::Date::now() as u64;
+
+        self.0
+            .create_identity_update_transition(
+                identity.to_owned().into(),
+                add_public_keys,
+                disable_public_keys,
+                Some(now),
+            )
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct FromObjectOptions {
+    pub skip_validation: Option<bool>,
+}

package/src/identity/identity_public_key/mod.rs

@@ -4,8 +4,9 @@ use std::convert::{TryFrom, TryInto};
 use wasm_bindgen::prelude::*;
 
 use crate::errors::from_dpp_err;
+use crate::utils::Inner;
 use crate::{buffer::Buffer, utils};
-use dpp::identity::IdentityPublicKey;
+use dpp::identity::{IdentityPublicKey, KeyID};
 
 mod purpose;
 pub use purpose::*;
@@ -33,89 +34,84 @@ impl IdentityPublicKeyWasm {
     }
 
     #[wasm_bindgen(js_name=getId)]
-    pub fn get_id(&self) -> u32 {
-        self.0.get_id() as u32
+    pub fn get_id(&self) -> KeyID {
+        self.0.id
     }
 
     #[wasm_bindgen(js_name=setId)]
-    pub fn set_id(&mut self, id: u32) {
-        self.0.set_id(id.into());
+    pub fn set_id(&mut self, id: KeyID) {
+        self.0.id = id;
     }
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        self.0.get_type() as u8
+        self.0.key_type as u8
     }
 
     #[wasm_bindgen(js_name=setType)]
     pub fn set_type(&mut self, key_type: u8) -> Result<(), JsValue> {
-        self.0.set_type(
-            key_type
-                .try_into()
-                .map_err(|e: anyhow::Error| e.to_string())?,
-        );
+        self.0.key_type = key_type
+            .try_into()
+            .map_err(|e: anyhow::Error| e.to_string())?;
         Ok(())
     }
 
     #[wasm_bindgen(js_name=setData)]
     pub fn set_data(&mut self, data: Vec<u8>) -> Result<(), JsValue> {
-        self.0.set_data(data);
+        self.0.data = data;
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getData)]
     pub fn get_data(&self) -> Vec<u8> {
-        self.0.get_data().to_vec()
+        self.0.data.clone()
     }
 
     #[wasm_bindgen(js_name=setPurpose)]
     pub fn set_purpose(&mut self, purpose: u8) -> Result<(), JsValue> {
-        self.0.set_purpose(
-            purpose
-                .try_into()
-                .map_err(|e: anyhow::Error| e.to_string())?,
-        );
+        self.0.purpose = purpose
+            .try_into()
+            .map_err(|e: anyhow::Error| e.to_string())?;
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getPurpose)]
     pub fn get_purpose(&self) -> u8 {
-        self.0.get_purpose() as u8
+        self.0.purpose as u8
     }
 
     #[wasm_bindgen(js_name=setSecurityLevel)]
-    pub fn set_security_level(&mut self, purpose: u8) -> Result<(), JsValue> {
-        self.0.set_security_level(
-            purpose
-                .try_into()
-                .map_err(|e: anyhow::Error| e.to_string())?,
-        );
+    pub fn set_security_level(&mut self, security_level: u8) -> Result<(), JsValue> {
+        self.0.security_level = security_level
+            .try_into()
+            .map_err(|e: anyhow::Error| e.to_string())?;
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getSecurityLevel)]
     pub fn get_security_level(&self) -> u8 {
-        self.0.get_security_level() as u8
+        self.0.security_level as u8
     }
 
     #[wasm_bindgen(js_name=setReadOnly)]
-    pub fn set_readonly(&mut self, purpose: bool) {
-        self.0.set_readonly(purpose);
+    pub fn set_read_only(&mut self, read_only: bool) {
+        self.0.read_only = read_only;
     }
 
     #[wasm_bindgen(js_name=isReadOnly)]
-    pub fn is_readonly(&self) -> bool {
-        self.0.get_readonly()
+    pub fn is_read_only(&self) -> bool {
+        self.0.read_only
     }
 
     #[wasm_bindgen(js_name=setDisabledAt)]
     pub fn set_disabled_at(&mut self, timestamp: u32) {
+        // TODO: It's not gonna work, must be BigInt
         self.0.set_disabled_at(timestamp as u64);
     }
 
     #[wasm_bindgen(js_name=getDisabledAt)]
-    pub fn get_disabled_at(&self) -> Option<u32> {
-        self.0.get_disabled_at().map(|timestamp| timestamp as u32)
+    pub fn get_disabled_at(&self) -> Option<f64> {
+        self.0.disabled_at.map(|timestamp| timestamp as f64)
     }
 
     #[wasm_bindgen(js_name=hash)]
@@ -136,34 +132,49 @@ impl IdentityPublicKeyWasm {
     }
 
     #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self, some_option: Option<bool>) -> Result<JsValue, JsValue> {
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
         let val = self
             .0
-            .to_raw_json_object(some_option.unwrap_or(false))
+            .to_raw_json_object()
             .map_err(|e| from_dpp_err(e.into()))?;
 
-        let data_buffer = Buffer::from_bytes(self.0.get_data());
-        let signature_buffer = Buffer::from_bytes(self.0.get_signature());
+        let data_buffer = Buffer::from_bytes(self.0.data.as_slice());
 
         let json = val.to_string();
         let js_object = js_sys::JSON::parse(&json)?;
 
         js_sys::Reflect::set(
             &js_object,
-            &"data".to_owned().into(),
-            &JsValue::from(data_buffer),
+            &JsValue::from_str("type"),
+            &JsValue::from(self.get_type()),
         )?;
 
         js_sys::Reflect::set(
             &js_object,
-            &"signature".to_owned().into(),
-            &JsValue::from(signature_buffer),
+            &JsValue::from_str("data"),
+            &JsValue::from(data_buffer),
         )?;
 
         Ok(js_object)
     }
 }
 
+impl Inner for IdentityPublicKeyWasm {
+    type InnerItem = IdentityPublicKey;
+
+    fn into_inner(self) -> IdentityPublicKey {
+        self.0
+    }
+
+    fn inner(&self) -> &IdentityPublicKey {
+        &self.0
+    }
+
+    fn inner_mut(&mut self) -> &mut IdentityPublicKey {
+        &mut self.0
+    }
+}
+
 impl From<IdentityPublicKey> for IdentityPublicKeyWasm {
     fn from(v: IdentityPublicKey) -> Self {
         IdentityPublicKeyWasm(v)