@dashevo/wasm-dpp 0.25.0-dev.9 → 0.25.1

package/src/identity/identity.rs

@@ -0,0 +1,275 @@
+use crate::buffer::Buffer;
+use crate::errors::from_dpp_err;
+use crate::identifier::IdentifierWrapper;
+use crate::identity::IdentityPublicKeyWasm;
+use crate::metadata::MetadataWasm;
+use crate::utils::{IntoWasm, WithJsError};
+use crate::{utils, with_js_error};
+use dpp::identity::accessors::{IdentityGettersV0, IdentitySettersV0};
+use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
+use dpp::identity::{Identity, IdentityPublicKey, KeyID};
+use dpp::metadata::Metadata;
+use dpp::platform_value::{ReplacementType, Value};
+use dpp::serialization::PlatformDeserializable;
+use dpp::serialization::PlatformSerializable;
+use dpp::serialization::ValueConvertible;
+use dpp::version::PlatformVersion;
+use serde::Serialize;
+use serde_json::Value as JsonValue;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=Identity)]
+#[derive(Clone)]
+pub struct IdentityWasm {
+    inner: Identity,
+    metadata: Option<Metadata>,
+}
+
+impl From<IdentityWasm> for Identity {
+    fn from(identity: IdentityWasm) -> Self {
+        identity.inner
+    }
+}
+
+impl From<Identity> for IdentityWasm {
+    fn from(identity: Identity) -> Self {
+        Self {
+            inner: identity,
+            metadata: None,
+        }
+    }
+}
+#[wasm_bindgen(js_class=Identity)]
+impl IdentityWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(platform_version: u32) -> Result<IdentityWasm, JsValue> {
+        let platform_version =
+            &PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
+
+        Identity::default_versioned(&platform_version)
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> IdentifierWrapper {
+        self.inner.id().into()
+    }
+
+    #[wasm_bindgen(js_name=setId)]
+    pub fn set_id(&mut self, id: IdentifierWrapper) {
+        self.inner.set_id(id.into());
+    }
+
+    #[wasm_bindgen(js_name=setPublicKeys)]
+    pub fn set_public_keys(&mut self, public_keys: js_sys::Array) -> Result<usize, JsValue> {
+        if public_keys.length() == 0 {
+            return Err(format!("Setting public keys failed. The input ('{}') is invalid. You must use array of PublicKeys", public_keys.to_string()).into());
+        }
+
+        let public_keys = public_keys
+            .iter()
+            .into_iter()
+            .map(|key| {
+                key.to_wasm::<IdentityPublicKeyWasm>("IdentityPublicKey")
+                    .map(|key| {
+                        let key = IdentityPublicKey::from(key.to_owned());
+                        (key.id(), key)
+                    })
+            })
+            .collect::<Result<_, _>>()?;
+
+        self.inner.set_public_keys(public_keys);
+
+        Ok(self.inner.public_keys().len())
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeys)]
+    pub fn get_public_keys(&self) -> Vec<JsValue> {
+        self.inner
+            .public_keys()
+            .iter()
+            .map(|(_, k)| k.to_owned())
+            .map(IdentityPublicKeyWasm::from)
+            .map(JsValue::from)
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeyById)]
+    pub fn get_public_key_by_id(&self, key_id: u32) -> Option<IdentityPublicKeyWasm> {
+        let key_id = key_id as KeyID;
+        self.inner
+            .get_public_key_by_id(key_id)
+            .map(IdentityPublicKey::to_owned)
+            .map(Into::into)
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn balance(&self) -> f64 {
+        self.inner.balance() as f64
+    }
+
+    #[wasm_bindgen(js_name=getBalance)]
+    pub fn get_balance(&self) -> f64 {
+        self.inner.balance() as f64
+    }
+
+    #[wasm_bindgen(js_name=setBalance)]
+    pub fn set_balance(&mut self, balance: f64) {
+        self.inner.set_balance(balance as u64);
+    }
+
+    #[wasm_bindgen(js_name=increaseBalance)]
+    pub fn increase_balance(&mut self, amount: f64) -> f64 {
+        self.inner.increase_balance(amount as u64) as f64
+    }
+
+    #[wasm_bindgen(js_name=reduceBalance)]
+    pub fn reduce_balance(&mut self, amount: f64) -> f64 {
+        self.inner.reduce_balance(amount as u64) as f64
+    }
+
+    #[wasm_bindgen(js_name=setRevision)]
+    pub fn set_revision(&mut self, revision: f64) {
+        self.inner.set_revision(revision as u64);
+    }
+
+    #[wasm_bindgen(js_name=getRevision)]
+    pub fn get_revision(&self) -> f64 {
+        self.inner.revision() as f64
+    }
+
+    #[wasm_bindgen(js_name=setMetadata)]
+    pub fn set_metadata(&mut self, metadata: JsValue) -> Result<(), JsValue> {
+        if !metadata.is_falsy() {
+            let metadata = metadata.to_wasm::<MetadataWasm>("Metadata")?.to_owned();
+            self.metadata = Some(metadata.into());
+        }
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getMetadata)]
+    pub fn get_metadata(&self) -> Option<MetadataWasm> {
+        self.metadata.map(|metadata| metadata.to_owned().into())
+    }
+
+    #[wasm_bindgen(js_name=from)]
+    pub fn from(object: JsValue) -> Self {
+        let i: Identity = serde_json::from_str(&object.as_string().unwrap()).unwrap();
+        IdentityWasm {
+            inner: i,
+            metadata: None,
+        }
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let mut value = self.inner.to_object().with_js_error()?;
+
+        value
+            .replace_at_paths(
+                dpp::identity::IDENTIFIER_FIELDS_RAW_OBJECT,
+                ReplacementType::TextBase58,
+            )
+            .map_err(|e| e.to_string())?;
+
+        // Monkey patch public keys data to be deserializable
+        let public_keys = value
+            .get_array_mut_ref(dpp::identity::property_names::PUBLIC_KEYS)
+            .map_err(|e| e.to_string())?;
+
+        for key in public_keys.iter_mut() {
+            key.replace_at_paths(
+                dpp::identity::identity_public_key::BINARY_DATA_FIELDS,
+                ReplacementType::TextBase64,
+            )
+            .map_err(|e| e.to_string())?;
+        }
+
+        let json = value
+            .try_into_validating_json()
+            .map_err(|e| e.to_string())?
+            .to_string();
+
+        js_sys::JSON::parse(&json)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let js_public_keys = js_sys::Array::new();
+        for pk in self.inner.public_keys().values() {
+            let pk_wasm = IdentityPublicKeyWasm::from(pk.to_owned());
+            js_public_keys.push(&pk_wasm.to_object()?);
+        }
+
+        let value = self.inner.to_object().with_js_error()?;
+
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let js_object = with_js_error!(value.serialize(&serializer))?;
+
+        let id = Buffer::from_bytes(self.inner.id().as_slice());
+
+        js_sys::Reflect::set(&js_object, &"id".to_owned().into(), &id)?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"publicKeys".to_owned().into(),
+            &JsValue::from(&js_public_keys),
+        )?;
+
+        Ok(js_object)
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes =
+            PlatformSerializable::serialize_to_bytes(&self.inner.clone()).with_js_error()?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen]
+    pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
+        self.inner.hash().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=addPublicKey)]
+    pub fn add_public_key(&mut self, public_key: IdentityPublicKeyWasm) {
+        self.inner
+            .public_keys_mut()
+            .insert(public_key.get_id(), public_key.into());
+    }
+
+    #[wasm_bindgen(js_name=addPublicKeys)]
+    pub fn add_public_keys(&mut self, public_keys: js_sys::Array) -> Result<(), JsValue> {
+        if public_keys.length() == 0 {
+            return Err(format!("Setting public keys failed. The input ('{}') is invalid. You must use array of PublicKeys", public_keys.to_string()).into());
+        }
+
+        let public_keys: Vec<IdentityPublicKey> = public_keys
+            .iter()
+            .into_iter()
+            .map(|key| {
+                key.to_wasm::<IdentityPublicKeyWasm>("IdentityPublicKey")
+                    .map(|key| key.to_owned().into())
+            })
+            .collect::<Result<_, _>>()?;
+
+        self.inner.add_public_keys(public_keys);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeyMaxId)]
+    pub fn get_public_key_max_id(&self) -> f64 {
+        self.inner.get_public_key_max_id() as f64
+    }
+
+    #[wasm_bindgen(js_name=fromBuffer)]
+    pub fn from_buffer(buffer: Vec<u8>) -> Result<IdentityWasm, JsValue> {
+        let identity: Identity =
+            PlatformDeserializable::deserialize_from_bytes(buffer.as_slice()).with_js_error()?;
+        Ok(identity.into())
+    }
+}

package/src/identity/identity_facade.rs

@@ -1,94 +1,88 @@
 use std::convert::TryInto;
 
-use std::sync::Arc;
-
 use wasm_bindgen::prelude::*;
 
-use dpp::identity::validation::PublicKeysValidator;
 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::utils::{ToSerdeJSONExt, WithJsError};
-use crate::validation::ValidationResultWasm;
-use crate::{
-    create_asset_lock_proof_from_wasm_instance, with_js_error, ChainAssetLockProofWasm,
-    IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm,
-    IdentityWasm, InstantAssetLockProofWasm,
+use crate::identity::state_transition::{
+    create_asset_lock_proof_from_wasm_instance, ChainAssetLockProofWasm,
+    IdentityCreateTransitionWasm, IdentityCreditTransferTransitionWasm,
+    IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm, InstantAssetLockProofWasm,
 };
+
+use crate::utils::WithJsError;
+use crate::with_js_error;
 use dpp::dashcore::{consensus, InstantLock, Transaction};
 
-use dpp::version::ProtocolVersionValidator;
-use dpp::{Convertible, NonConsensusError};
+use crate::identity::IdentityWasm;
+use dpp::NonConsensusError;
 use serde::Deserialize;
 
 #[derive(Clone)]
 #[wasm_bindgen(js_name=IdentityFacade)]
-pub struct IdentityFacadeWasm(IdentityFacade<BlsAdapter>);
+pub struct IdentityFacadeWasm(IdentityFacade);
 
 impl IdentityFacadeWasm {
-    pub fn new(
-        protocol_version_validator: Arc<ProtocolVersionValidator>,
-        public_keys_validator: Arc<PublicKeysValidator<BlsAdapter>>,
-    ) -> IdentityFacadeWasm {
-        let identity_facade = IdentityFacade::new(
-            protocol_version_validator.protocol_version(),
-            protocol_version_validator,
-            public_keys_validator,
-        )
-        .unwrap();
+    pub fn new(protocol_version: u32) -> IdentityFacadeWasm {
+        let identity_facade = IdentityFacade::new(protocol_version);
 
         IdentityFacadeWasm(identity_facade)
     }
 }
 
+impl From<&IdentityFacade> for IdentityFacadeWasm {
+    fn from(identity_facade: &IdentityFacade) -> Self {
+        Self(identity_facade.to_owned())
+    }
+}
 #[wasm_bindgen(js_class=IdentityFacade)]
 impl IdentityFacadeWasm {
     #[wasm_bindgen]
     pub fn create(
         &self,
-        asset_lock_proof: JsValue,
+        id: IdentifierWrapper,
         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)?;
+        let public_keys = super::factory_utils::parse_public_keys(public_keys)?;
 
         self.0
-            .create(asset_lock_proof, public_keys)
+            .create(id.into(), public_keys)
             .map(|identity| identity.into())
             .with_js_error()
     }
 
-    #[wasm_bindgen(js_name=createFromObject)]
-    pub fn create_from_object(
-        &self,
-        identity_object: JsValue,
-        options: Option<js_sys::Object>,
-    ) -> Result<IdentityWasm, JsValue> {
-        let options: FromObjectOptions = if let Some(options) = options {
-            with_js_error!(serde_wasm_bindgen::from_value(options.into()))?
-        } else {
-            Default::default()
-        };
-
-        let raw_identity = identity_object.with_serde_to_platform_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)),
-        }
-    }
+    // TODO(versioning): not used anymore?
+    // #[wasm_bindgen(js_name=createFromObject)]
+    // pub fn create_from_object(
+    //     &self,
+    //     identity_object: JsValue,
+    //     options: Option<js_sys::Object>,
+    // ) -> Result<IdentityWasm, JsValue> {
+    //     let options: FromObjectOptions = if let Some(options) = options {
+    //         with_js_error!(serde_wasm_bindgen::from_value(options.into()))?
+    //     } else {
+    //         Default::default()
+    //     };
+    //
+    //     let raw_identity = identity_object.with_serde_to_platform_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(
@@ -115,17 +109,18 @@ impl IdentityFacadeWasm {
         }
     }
 
-    #[wasm_bindgen]
-    pub fn validate(&self, identity: &IdentityWasm) -> Result<ValidationResultWasm, JsValue> {
-        let identity: Identity = identity.to_owned().into();
-        let identity_json = identity.to_cleaned_object().with_js_error()?;
-
-        let validation_result = self
-            .0
-            .validate(&identity_json)
-            .map_err(|e| from_dpp_err(e.into()))?;
-        Ok(validation_result.map(|_| JsValue::undefined()).into())
-    }
+    // TODO(versioning): restore?
+    // #[wasm_bindgen]
+    // pub fn validate(&self, identity: &IdentityWasm) -> Result<ValidationResultWasm, JsValue> {
+    //     let identity: Identity = identity.to_owned().into();
+    //     let identity_json = identity.to_cleaned_object().with_js_error()?;
+    //
+    //     let validation_result = self
+    //         .0
+    //         .validate(&identity_json)
+    //         .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(
@@ -140,7 +135,7 @@ impl IdentityFacadeWasm {
         let asset_lock_transaction: Transaction =
             consensus::deserialize(&asset_lock_transaction).map_err(|e| e.to_string())?;
 
-        Ok(IdentityFacade::<BlsAdapter>::create_instant_lock_proof(
+        Ok(IdentityFacade::create_instant_lock_proof(
             instant_lock,
             asset_lock_transaction,
             output_index,
@@ -159,20 +154,25 @@ impl IdentityFacadeWasm {
                 .to_js_value()
         })?;
 
-        Ok(IdentityFacade::<BlsAdapter>::create_chain_asset_lock_proof(
-            core_chain_locked_height,
-            out_point,
+        Ok(
+            IdentityFacade::create_chain_asset_lock_proof(core_chain_locked_height, out_point)
+                .into(),
         )
-        .into())
     }
 
     #[wasm_bindgen(js_name=createIdentityCreateTransition)]
     pub fn create_identity_create_transition(
         &self,
         identity: &IdentityWasm,
+        asset_lock_proof: JsValue,
     ) -> Result<IdentityCreateTransitionWasm, JsValue> {
+        let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?;
+
         self.0
-            .create_identity_create_transition(Identity::from(identity.to_owned()))
+            .create_identity_create_transition(
+                Identity::from(identity.to_owned()),
+                asset_lock_proof,
+            )
             .map(Into::into)
             .with_js_error()
     }
@@ -191,6 +191,23 @@ impl IdentityFacadeWasm {
             .with_js_error()
     }
 
+    #[wasm_bindgen(js_name=createIdentityCreditTransferTransition)]
+    pub fn create_identity_credit_transfer_transition(
+        &self,
+        identity_id: &IdentifierWrapper,
+        recipient_id: &IdentifierWrapper,
+        amount: u64,
+    ) -> Result<IdentityCreditTransferTransitionWasm, JsValue> {
+        self.0
+            .create_identity_credit_transfer_transition(
+                identity_id.to_owned().into(),
+                recipient_id.to_owned().into(),
+                amount,
+            )
+            .map(Into::into)
+            .with_js_error()
+    }
+
     #[wasm_bindgen(js_name=createIdentityUpdateTransition)]
     pub fn create_identity_update_transition(
         &self,