@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0

package/src/identity/identity_factory.rs

@@ -1,34 +1,37 @@
-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::identity::identity::IdentityWasm;
+use crate::identity::state_transition::ChainAssetLockProofWasm;
+use crate::identity::state_transition::IdentityCreditTransferTransitionWasm;
+use crate::identity::state_transition::InstantAssetLockProofWasm;
 
 use crate::{
-    create_asset_lock_proof_from_wasm_instance, with_js_error, ChainAssetLockProofWasm,
-    IdentityCreateTransitionWasm, IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm,
-    IdentityWasm, InstantAssetLockProofWasm,
+    identity::state_transition::create_asset_lock_proof_from_wasm_instance,
+    identity::state_transition::IdentityCreateTransitionWasm,
+    identity::state_transition::IdentityTopUpTransitionWasm,
+    identity::state_transition::IdentityUpdateTransitionWasm, with_js_error,
 };
 use dpp::dashcore::{consensus, InstantLock, Transaction};
-use dpp::identity::factory::IdentityFactory;
 
 use dpp::prelude::Identity;
 
 use serde::Deserialize;
 use std::convert::TryInto;
 
-use std::sync::Arc;
+use crate::utils::WithJsError;
+use dpp::identity::identity_factory::IdentityFactory;
 
-use crate::utils::{with_serde_to_platform_value, WithJsError};
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;
 
 #[wasm_bindgen(js_name=IdentityFactory)]
-pub struct IdentityFactoryWasm(IdentityFactory<BlsAdapter>);
+pub struct IdentityFactoryWasm(IdentityFactory);
 
-impl From<IdentityFactory<BlsAdapter>> for IdentityFactoryWasm {
-    fn from(factory: IdentityFactory<BlsAdapter>) -> Self {
+impl From<IdentityFactory> for IdentityFactoryWasm {
+    fn from(factory: IdentityFactory) -> Self {
         Self(factory)
     }
 }
@@ -36,55 +39,52 @@ impl From<IdentityFactory<BlsAdapter>> for IdentityFactoryWasm {
 #[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()));
+    pub fn new(protocol_version: u32) -> Result<IdentityFactoryWasm, JsValue> {
+        let factory = IdentityFactory::new(protocol_version);
         Ok(factory.into())
     }
 
     #[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: 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 = with_serde_to_platform_value(&identity_object)?;
-
-        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: 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 = with_serde_to_platform_value(&identity_object)?;
+    //
+    //     let result = self
+    //         .0
+    //         .create_from_object(raw_identity);
+    //
+    //     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(
@@ -100,7 +100,7 @@ impl IdentityFactoryWasm {
 
         let result = self
             .0
-            .create_from_buffer(buffer.clone(), options.skip_validation.unwrap_or(false));
+            .create_from_buffer(buffer.clone(), options.skip_validation.unwrap_or(true));
 
         match result {
             Ok(identity) => Ok(identity.into()),
@@ -124,7 +124,7 @@ impl IdentityFactoryWasm {
         let asset_lock_transaction: Transaction =
             consensus::deserialize(&asset_lock_transaction).map_err(|e| e.to_string())?;
 
-        Ok(IdentityFactory::<BlsAdapter>::create_instant_lock_proof(
+        Ok(IdentityFactory::create_instant_lock_proof(
             instant_lock,
             asset_lock_transaction,
             output_index,
@@ -144,11 +144,8 @@ impl IdentityFactoryWasm {
         })?;
 
         Ok(
-            IdentityFactory::<BlsAdapter>::create_chain_asset_lock_proof(
-                core_chain_locked_height,
-                out_point,
-            )
-            .into(),
+            IdentityFactory::create_chain_asset_lock_proof(core_chain_locked_height, out_point)
+                .into(),
         )
     }
 
@@ -156,9 +153,15 @@ impl IdentityFactoryWasm {
     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()
     }
@@ -177,6 +180,23 @@ impl IdentityFactoryWasm {
             .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,

package/src/identity/identity_public_key/mod.rs

@@ -1,15 +1,20 @@
-use dpp::dashcore::anyhow;
-use dpp::document::document_transition::document_base_transition::JsonValue;
+use js_sys::Reflect::delete_property;
 pub use serde::{Deserialize, Serialize};
-use std::convert::{TryFrom, TryInto};
+use serde_json::Value as JsonValue;
+use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
 
-use crate::utils::{Inner, WithJsError};
+use crate::utils::WithJsError;
 use crate::{buffer::Buffer, utils, with_js_error};
+use dpp::identity::identity_public_key::accessors::v0::{
+    IdentityPublicKeyGettersV0, IdentityPublicKeySettersV0,
+};
+use dpp::identity::identity_public_key::hash::IdentityPublicKeyHashMethodsV0;
 use dpp::identity::{IdentityPublicKey, KeyID, TimestampMillis};
-use dpp::platform_value::BinaryData;
-use dpp::Convertible;
-
+use dpp::platform_value::{BinaryData, ReplacementType, Value};
+use dpp::serialization::ValueConvertible;
+use dpp::state_transition::public_key_in_creation::v0::BINARY_DATA_FIELDS;
+use dpp::version::PlatformVersion;
 mod purpose;
 pub use purpose::*;
 
@@ -22,89 +27,95 @@ use crate::errors::from_dpp_err;
 pub use key_type::*;
 
 #[wasm_bindgen(js_name=IdentityPublicKey)]
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Debug, Clone)]
 pub struct IdentityPublicKeyWasm(IdentityPublicKey);
 
 #[wasm_bindgen(js_class = IdentityPublicKey)]
 impl IdentityPublicKeyWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(raw_public_key: JsValue) -> Result<IdentityPublicKeyWasm, JsValue> {
-        let data_string = utils::stringify(&raw_public_key)?;
-        let value: JsonValue = serde_json::from_str(&data_string).map_err(|e| e.to_string())?;
-
-        let pk = IdentityPublicKey::from_json_object(value).with_js_error()?;
+    pub fn new(platform_version: u32) -> Result<IdentityPublicKeyWasm, JsValue> {
+        let platform_version =
+            &PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
 
-        Ok(IdentityPublicKeyWasm(pk))
+        IdentityPublicKey::default_versioned(&platform_version)
+            .map(Into::into)
+            .map_err(from_dpp_err)
     }
 
     #[wasm_bindgen(js_name=getId)]
     pub fn get_id(&self) -> KeyID {
-        self.0.id
+        self.0.id()
     }
 
     #[wasm_bindgen(js_name=setId)]
     pub fn set_id(&mut self, id: KeyID) {
-        self.0.id = id;
+        self.0.set_id(id);
     }
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        self.0.key_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.key_type = key_type
-            .try_into()
-            .map_err(|e: anyhow::Error| e.to_string())?;
+        self.0.set_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.data = BinaryData::new(data);
+        self.0.set_data(BinaryData::new(data));
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getData)]
     pub fn get_data(&self) -> Buffer {
-        Buffer::from_bytes_owned(self.0.data.to_vec())
+        Buffer::from_bytes_owned(self.0.data().to_vec())
     }
 
     #[wasm_bindgen(js_name=setPurpose)]
     pub fn set_purpose(&mut self, purpose: u8) -> Result<(), JsValue> {
-        self.0.purpose = purpose
-            .try_into()
-            .map_err(|e: anyhow::Error| e.to_string())?;
+        self.0.set_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.purpose as u8
+        self.0.purpose() as u8
     }
 
     #[wasm_bindgen(js_name=setSecurityLevel)]
     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())?;
+        self.0.set_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.security_level as u8
+        self.0.security_level() as u8
     }
 
     #[wasm_bindgen(js_name=setReadOnly)]
     pub fn set_read_only(&mut self, read_only: bool) {
-        self.0.read_only = read_only;
+        self.0.set_read_only(read_only);
     }
 
     #[wasm_bindgen(js_name=isReadOnly)]
     pub fn is_read_only(&self) -> bool {
-        self.0.read_only
+        self.0.read_only()
     }
 
     #[wasm_bindgen(js_name=setDisabledAt)]
@@ -116,13 +127,13 @@ impl IdentityPublicKeyWasm {
     #[wasm_bindgen(js_name=getDisabledAt)]
     pub fn get_disabled_at(&self) -> Option<js_sys::Date> {
         self.0
-            .disabled_at
+            .disabled_at()
             .map(|timestamp| js_sys::Date::new(&JsValue::from_f64(timestamp as f64)))
     }
 
     #[wasm_bindgen(js_name=hash)]
     pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
-        self.0.hash().with_js_error()
+        self.0.hash().map(|result| result.to_vec()).with_js_error()
     }
 
     #[wasm_bindgen(js_name=isMaster)]
@@ -132,16 +143,28 @@ impl IdentityPublicKeyWasm {
 
     #[wasm_bindgen(js_name=toJSON)]
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let val = self.0.to_json().map_err(from_dpp_err)?;
-        let json = val.to_string();
+        let mut value = self.0.to_object().map_err(from_dpp_err)?;
+
+        value
+            .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 value = self.0.to_cleaned_object().with_js_error()?;
+        let value = self.0.to_object().map_err(from_dpp_err)?;
 
-        let data_buffer = Buffer::from_bytes(self.0.data.as_slice());
+        let data_buffer = Buffer::from_bytes(self.0.data().as_slice());
 
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         let js_object = with_js_error!(value.serialize(&serializer))?;
@@ -162,38 +185,38 @@ impl IdentityPublicKeyWasm {
     }
 }
 
-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 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)
     }
 }
-
-impl TryFrom<JsValue> for IdentityPublicKeyWasm {
-    type Error = JsValue;
-
-    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
-        let str = String::from(js_sys::JSON::stringify(&value)?);
-        let val = serde_json::from_str(&str).map_err(|e| from_dpp_err(e.into()))?;
-        Ok(Self(IdentityPublicKey::from_value(val).with_js_error()?))
-    }
-}
-
+//
+// impl TryFrom<JsValue> for IdentityPublicKeyWasm {
+//     type Error = JsValue;
+//
+//     fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+//         let str = String::from(js_sys::JSON::stringify(&value)?);
+//         let val = serde_json::from_str(&str).map_err(|e| from_dpp_err(e.into()))?;
+//         Ok(Self(IdentityPublicKey::from_value(val).with_js_error()?))
+//     }
+// }
+//
 impl From<IdentityPublicKeyWasm> for IdentityPublicKey {
     fn from(pk: IdentityPublicKeyWasm) -> Self {
         pk.0