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

package/src/identity/state_transition/identity_topup_transition/identity_topup_transition.rs

@@ -1,34 +1,36 @@
-use crate::utils::{ToSerdeJSONExt, WithJsError};
+use crate::utils::WithJsError;
 
-use std::convert::TryInto;
 use std::default::Default;
 
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
+use dpp::identity::KeyType;
+use dpp::platform_value::BinaryData;
+use dpp::serialization::ValueConvertible;
+use dpp::state_transition::identity_topup_transition::fields::IDENTIFIER_FIELDS;
+use dpp::version::PlatformVersion;
+use serde_json::Value as JsonValue;
 use wasm_bindgen::prelude::*;
 
 use crate::identifier::IdentifierWrapper;
 
 use crate::{
     buffer::Buffer,
-    create_asset_lock_proof_from_wasm_instance,
-    errors::RustConversionError,
     identity::state_transition::asset_lock_proof::{
         ChainAssetLockProofWasm, InstantAssetLockProofWasm,
     },
-    with_js_error,
+    utils, with_js_error,
 };
 
-use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
-
-use crate::errors::from_dpp_err;
-use dpp::identity::KeyType;
+use crate::identity::state_transition::create_asset_lock_proof_from_wasm_instance;
 use dpp::platform_value::string_encoding::Encoding;
-use dpp::platform_value::{string_encoding, BinaryData};
-use dpp::state_transition::StateTransitionConvert;
+use dpp::platform_value::{string_encoding, ReplacementType, Value};
+use dpp::serialization::PlatformSerializable;
+use dpp::state_transition::identity_topup_transition::accessors::IdentityTopUpTransitionAccessorsV0;
+use dpp::state_transition::identity_topup_transition::IdentityTopUpTransition;
+use dpp::state_transition::StateTransition;
 use dpp::{
-    identifier::Identifier,
-    identity::state_transition::{
-        asset_lock_proof::AssetLockProof, identity_topup_transition::IdentityTopUpTransition,
-    },
+    identifier::Identifier, identity::state_transition::asset_lock_proof::AssetLockProof,
     state_transition::StateTransitionLike,
 };
 
@@ -51,23 +53,20 @@ impl From<IdentityTopUpTransitionWasm> for IdentityTopUpTransition {
 #[wasm_bindgen(js_class = IdentityTopUpTransition)]
 impl IdentityTopUpTransitionWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(raw_parameters: JsValue) -> Result<IdentityTopUpTransitionWasm, JsValue> {
-        let raw_state_transition = raw_parameters.with_serde_to_platform_value()?;
-
-        let identity_topup_transition =
-            IdentityTopUpTransition::from_raw_object(raw_state_transition)
-                .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
+    pub fn new(platform_version: u32) -> Result<IdentityTopUpTransitionWasm, JsValue> {
+        let platform_version =
+            &PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
 
-        Ok(identity_topup_transition.into())
+        IdentityTopUpTransition::default_versioned(&platform_version)
+            .map(Into::into)
+            .map_err(from_dpp_err)
     }
 
     #[wasm_bindgen(js_name=setAssetLockProof)]
     pub fn set_asset_lock_proof(&mut self, asset_lock_proof: JsValue) -> Result<(), JsValue> {
         let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?;
 
-        self.0
-            .set_asset_lock_proof(asset_lock_proof)
-            .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
+        self.0.set_asset_lock_proof(asset_lock_proof);
 
         Ok(())
     }
@@ -79,7 +78,7 @@ impl IdentityTopUpTransitionWasm {
 
     #[wasm_bindgen(js_name=getAssetLockProof)]
     pub fn get_asset_lock_proof(&self) -> JsValue {
-        let asset_lock_proof = self.0.get_asset_lock_proof().to_owned();
+        let asset_lock_proof = self.0.asset_lock_proof().to_owned();
 
         match asset_lock_proof {
             AssetLockProof::Chain(chain_asset_lock_proof) => {
@@ -93,7 +92,7 @@ impl IdentityTopUpTransitionWasm {
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        self.0.get_type() as u8
+        self.0.state_transition_type() as u8
     }
 
     #[wasm_bindgen(getter, js_name=identityId)]
@@ -103,23 +102,28 @@ impl IdentityTopUpTransitionWasm {
 
     #[wasm_bindgen(js_name=getIdentityId)]
     pub fn get_identity_id(&self) -> IdentifierWrapper {
-        (*self.0.get_identity_id()).into()
+        (*self.0.identity_id()).into()
+    }
+
+    #[wasm_bindgen(js_name=setIdentityId)]
+    pub fn set_identity_id(&mut self, identity_id: &IdentifierWrapper) {
+        self.0.set_identity_id(identity_id.to_owned().into());
     }
 
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
-        (*self.0.get_owner_id()).into()
+        self.0.owner_id().to_owned().into()
     }
 
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self, options: JsValue) -> Result<JsValue, JsValue> {
         let opts: super::to_object::ToObjectOptions = if options.is_object() {
-            with_js_error!(serde_wasm_bindgen::from_value(options))?
+            with_js_error!(serde_wasm_bindgen::from_value(options.clone()))?
         } else {
             Default::default()
         };
 
-        let object = super::to_object::to_object_struct(&self.0, opts);
+        let object = super::to_object::to_object_struct(&self.0, &opts);
         let js_object = js_sys::Object::new();
 
         js_sys::Reflect::set(
@@ -128,11 +132,11 @@ impl IdentityTopUpTransitionWasm {
             &object.transition_type.into(),
         )?;
 
-        js_sys::Reflect::set(
-            &js_object,
-            &"protocolVersion".to_owned().into(),
-            &object.protocol_version.into(),
-        )?;
+        let version = match self.0 {
+            IdentityTopUpTransition::V0(_) => "0",
+        };
+
+        js_sys::Reflect::set(&js_object, &"$version".to_owned().into(), &version.into())?;
 
         if let Some(signature) = object.signature {
             let signature_value: JsValue = if signature.is_empty() {
@@ -169,24 +173,17 @@ impl IdentityTopUpTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self, options: JsValue) -> Result<JsValue, JsValue> {
-        let opts: super::to_object::ToObjectOptions = if options.is_object() {
-            with_js_error!(serde_wasm_bindgen::from_value(options))?
-        } else {
-            Default::default()
-        };
-
-        let buffer = self
-            .0
-            .to_cbor_buffer(opts.skip_signature.unwrap_or(false))
-            .map_err(from_dpp_err)?;
-
-        Ok(Buffer::from_bytes(&buffer).into())
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes = PlatformSerializable::serialize_to_bytes(&StateTransition::IdentityTopUp(
+            self.0.clone(),
+        ))
+        .with_js_error()?;
+        Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=toJSON)]
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let object = super::to_object::to_object_struct(&self.0, Default::default());
+        let object = super::to_object::to_object_struct(&self.0, &Default::default());
         let js_object = js_sys::Object::new();
 
         js_sys::Reflect::set(
@@ -195,12 +192,6 @@ impl IdentityTopUpTransitionWasm {
             &object.transition_type.into(),
         )?;
 
-        js_sys::Reflect::set(
-            &js_object,
-            &"protocolVersion".to_owned().into(),
-            &object.protocol_version.into(),
-        )?;
-
         if let Some(signature) = object.signature {
             let signature_value: JsValue = if signature.is_empty() {
                 JsValue::undefined()
@@ -211,6 +202,12 @@ impl IdentityTopUpTransitionWasm {
             js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?;
         }
 
+        let version = match self.0 {
+            IdentityTopUpTransition::V0(_) => "0",
+        };
+
+        js_sys::Reflect::set(&js_object, &"$version".to_owned().into(), &version.into())?;
+
         let asset_lock_proof_json = match object.asset_lock_proof {
             AssetLockProof::Instant(instant_asset_lock_proof) => {
                 InstantAssetLockProofWasm::from(instant_asset_lock_proof).to_json()?
@@ -238,8 +235,8 @@ impl IdentityTopUpTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=getModifiedDataIds)]
-    pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
-        let ids = self.0.get_modified_data_ids();
+    pub fn modified_data_ids(&self) -> Vec<JsValue> {
+        let ids = self.0.modified_data_ids();
 
         ids.into_iter()
             .map(|id| <IdentifierWrapper as std::convert::From<Identifier>>::from(id).into())
@@ -285,18 +282,26 @@ impl IdentityTopUpTransitionWasm {
             BlsAdapter(JsValue::undefined().into())
         };
 
-        self.0
+        // TODO: not the best approach because it involves cloning the transition
+        // Probably it worth to return `sign_by_private_key` per state transition
+        let mut wrapper = StateTransition::IdentityTopUp(self.0.clone());
+        wrapper
             .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter)
-            .with_js_error()
+            .with_js_error()?;
+
+        self.0.set_signature(wrapper.signature().to_owned());
+
+        Ok(())
     }
 
     #[wasm_bindgen(js_name=getSignature)]
     pub fn get_signature(&self) -> Buffer {
-        Buffer::from_bytes(self.0.get_signature().as_slice())
+        Buffer::from_bytes(self.0.signature().as_slice())
     }
 
     #[wasm_bindgen(js_name=setSignature)]
     pub fn set_signature(&mut self, signature: Option<Vec<u8>>) {
-        self.0.signature = BinaryData::new(signature.unwrap_or(vec![]))
+        self.0
+            .set_signature(BinaryData::new(signature.unwrap_or(vec![])))
     }
 }

package/src/identity/state_transition/identity_topup_transition/identity_topup_transition_basic_validator.rs

@@ -4,8 +4,6 @@ use dpp::identity::state_transition::asset_lock_proof::{
 };
 use dpp::identity::state_transition::identity_topup_transition::validation::basic::IdentityTopUpTransitionBasicValidator;
 
-use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
-
 use dpp::version::{ProtocolVersionValidator, COMPATIBILITY_MAP, LATEST_VERSION};
 use dpp::ProtocolError;
 

package/src/identity/state_transition/identity_topup_transition/mod.rs

@@ -1,8 +1,8 @@
 pub use identity_topup_transition::*;
 
-pub mod apply_identity_topup_transition;
+// pub mod apply_identity_topup_transition;
 pub mod identity_topup_transition;
-pub mod identity_topup_transition_basic_validator;
-pub mod identity_topup_transition_state_validator;
+// pub mod identity_topup_transition_basic_validator;
+// pub mod identity_topup_transition_state_validator;
 
 mod to_object;

package/src/identity/state_transition/identity_topup_transition/to_object.rs

@@ -1,9 +1,7 @@
 use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
-use dpp::{
-    identifier::Identifier,
-    identity::state_transition::identity_topup_transition::IdentityTopUpTransition,
-    state_transition::StateTransitionLike,
-};
+use dpp::state_transition::identity_topup_transition::accessors::IdentityTopUpTransitionAccessorsV0;
+use dpp::state_transition::identity_topup_transition::IdentityTopUpTransition;
+use dpp::{identifier::Identifier, state_transition::StateTransitionLike};
 use serde::Deserialize;
 use std::default::Default;
 
@@ -16,7 +14,6 @@ pub struct ToObjectOptions {
 #[derive(Default)]
 pub struct ToObject {
     pub transition_type: u8,
-    pub protocol_version: u32,
     pub identity_id: Identifier,
     pub asset_lock_proof: AssetLockProof,
     pub signature: Option<Vec<u8>>,
@@ -24,18 +21,17 @@ pub struct ToObject {
 
 pub fn to_object_struct(
     transition: &IdentityTopUpTransition,
-    options: ToObjectOptions,
+    options: &ToObjectOptions,
 ) -> ToObject {
     let mut to_object = ToObject {
-        transition_type: transition.get_type() as u8,
-        protocol_version: transition.get_protocol_version(),
-        identity_id: *transition.get_identity_id(),
-        asset_lock_proof: transition.get_asset_lock_proof().to_owned(),
+        transition_type: transition.state_transition_type() as u8,
+        identity_id: *transition.identity_id(),
+        asset_lock_proof: transition.asset_lock_proof().to_owned(),
         signature: None,
     };
 
     if !options.skip_signature.unwrap_or(false) {
-        to_object.signature = Some(transition.get_signature().to_vec());
+        to_object.signature = Some(transition.signature().to_vec());
     }
 
     to_object

package/src/identity/state_transition/identity_update_transition/identity_update_public_keys_validator.rs

@@ -2,7 +2,7 @@ use crate::errors::from_dpp_err;
 use crate::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm;
 use crate::utils::WithJsError;
 use crate::validation::ValidationResultWasm;
-use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreation;
 use dpp::identity::state_transition::identity_update_transition::validate_public_keys::IdentityUpdatePublicKeysValidator;
 use dpp::identity::validation::TPublicKeysValidator;
 use dpp::platform_value::Value;
@@ -31,7 +31,7 @@ impl IdentityUpdatePublicKeysValidatorWasm {
         let public_keys = raw_public_keys
             .into_iter()
             .map(|raw_key| {
-                let parsed_key: IdentityPublicKeyInCreationWithWitness =
+                let parsed_key: IdentityPublicKeyInCreation =
                     IdentityPublicKeyWithWitnessWasm::new(raw_key)?.into();
 
                 parsed_key.to_raw_object(false).with_js_error()