@dashevo/wasm-dpp 0.25.0-dev.16 → 0.25.0-dev.18

package/src/data_contract/data_contract_facade.rs

@@ -1,38 +1,40 @@
-use crate::errors::protocol_error::from_protocol_error;
 use std::convert::TryFrom;
 
-use crate::{
-    js_value_to_data_contract_value, DataContractCreateTransitionWasm,
-    DataContractUpdateTransitionWasm, DataContractWasm,
-};
-use dpp::data_contract::{CreatedDataContract, DataContract, DataContractFacade};
+use dpp::data_contract::created_data_contract::CreatedDataContract;
+use dpp::data_contract::DataContract;
+use dpp::data_contract::DataContractFacade;
 use dpp::identifier::Identifier;
-use dpp::version::ProtocolVersionValidator;
 
+use crate::data_contract::state_transition::DataContractCreateTransitionWasm;
+use crate::data_contract::state_transition::DataContractUpdateTransitionWasm;
+use crate::data_contract::DataContractWasm;
 use crate::entropy_generator::ExternalEntropyGenerator;
-use crate::utils::{get_bool_from_options, IntoWasm, WithJsError, SKIP_VALIDATION_PROPERTY_NAME};
-use crate::validation::ValidationResultWasm;
+use crate::errors::protocol_error::from_protocol_error;
+use crate::utils::{
+    get_bool_from_options, IntoWasm, ToSerdeJSONExt, WithJsError, SKIP_VALIDATION_PROPERTY_NAME,
+};
 
-use dpp::{Convertible, ProtocolError};
+use dpp::ProtocolError;
 use std::sync::Arc;
 
+use crate::identity::identity_facade::IdentityFacadeWasm;
+use dpp::identity::IdentityFacade;
 use wasm_bindgen::prelude::*;
 
+impl From<DataContractFacade> for DataContractFacadeWasm {
+    fn from(facade: DataContractFacade) -> Self {
+        Self(Arc::new(facade))
+    }
+}
+
 #[wasm_bindgen(js_name=DataContractFacade)]
 #[derive(Clone)]
-pub struct DataContractFacadeWasm(Arc<DataContractFacade>);
+pub struct DataContractFacadeWasm(pub(crate) Arc<DataContractFacade>);
 
 impl DataContractFacadeWasm {
-    pub fn new(
-        protocol_version: u32,
-        protocol_version_validator: Arc<ProtocolVersionValidator>,
-        entropy_generator: ExternalEntropyGenerator,
-    ) -> Self {
-        let inner = DataContractFacade::new_with_entropy_generator(
-            protocol_version,
-            protocol_version_validator,
-            Box::new(entropy_generator),
-        );
+    pub fn new(protocol_version: u32, entropy_generator: ExternalEntropyGenerator) -> Self {
+        let inner = DataContractFacade::new(protocol_version, Some(Box::new(entropy_generator)))
+            .expect("should create facade");
 
         Self(Arc::new(inner))
     }
@@ -81,10 +83,9 @@ impl DataContractFacadeWasm {
 
         self.0
             .create_from_object(
-                js_value_to_data_contract_value(js_raw_data_contract)?,
+                js_raw_data_contract.with_serde_to_platform_value()?,
                 skip_validation,
             )
-            .await
             .map(DataContractWasm::from)
             .map_err(from_protocol_error)
     }
@@ -103,7 +104,6 @@ impl DataContractFacadeWasm {
         };
         self.0
             .create_from_buffer(buffer, skip_validation)
-            .await
             .map(Into::into)
             .map_err(from_protocol_error)
     }
@@ -133,26 +133,4 @@ impl DataContractFacadeWasm {
             .map(Into::into)
             .map_err(from_protocol_error)
     }
-
-    /// Validate Data Contract
-    pub async fn validate(
-        &self,
-        js_raw_data_contract: JsValue,
-    ) -> Result<ValidationResultWasm, JsValue> {
-        let raw_data_contract = if let Ok(data_contract_ref) =
-            js_raw_data_contract.to_wasm::<DataContractWasm>("DataContract")
-        {
-            let data_contract: DataContract = data_contract_ref.to_owned().into();
-            data_contract.to_cleaned_object().with_js_error()?
-        } else {
-            js_value_to_data_contract_value(js_raw_data_contract)?
-        };
-
-        self.0
-            .validate(raw_data_contract)
-            .await
-            .map(|v| v.map(|_| JsValue::UNDEFINED))
-            .map(Into::into)
-            .map_err(from_protocol_error)
-    }
 }

package/src/data_contract/errors/mod.rs

@@ -6,6 +6,7 @@ use wasm_bindgen::prelude::*;
 
 pub use data_contract_generic_error::*;
 use dpp::data_contract::errors::DataContractError;
+use dpp::ProtocolError;
 pub use invalid_data_contract::*;
 
 pub fn from_data_contract_to_js_error(e: DataContractError) -> JsValue {

package/src/data_contract/mod.rs

@@ -8,7 +8,7 @@ pub mod errors;
 mod state_transition;
 
 mod data_contract_facade;
-mod index;
+// mod index;
 
 pub use data_contract_facade::DataContractFacadeWasm;
-pub use index::*;
+// pub use index::*;

package/src/data_contract/state_transition/data_contract_create_transition/mod.rs

@@ -1,33 +1,30 @@
-mod apply;
-mod validation;
+// mod validation;
 
 use std::collections::HashMap;
 
-pub use apply::*;
-pub use validation::*;
-
-use dpp::consensus::signature::SignatureError;
-use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::{PlatformDeserializable, PlatformSerializable};
-use dpp::state_transition::StateTransition;
-use dpp::{
-    data_contract::state_transition::data_contract_create_transition::DataContractCreateTransition,
-    platform_value,
-    state_transition::{
-        StateTransitionConvert, StateTransitionIdentitySigned, StateTransitionLike,
-    },
-    ProtocolError,
-};
-use serde::{Deserialize, Serialize};
+// pub use validation::*;
+
+use crate::errors::protocol_error::from_protocol_error;
+use dpp::data_contract::JsonValue;
+use dpp::errors::consensus::signature::SignatureError;
+use dpp::errors::consensus::ConsensusError;
+use dpp::platform_value::Value;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::state_transition::data_contract_create_transition::accessors::DataContractCreateTransitionAccessorsV0;
+use dpp::state_transition::data_contract_create_transition::DataContractCreateTransition;
+use dpp::state_transition::StateTransitionIdentitySigned;
+use dpp::state_transition::{JsonStateTransitionSerializationOptions, StateTransitionJsonConvert};
+use dpp::state_transition::{StateTransition, StateTransitionValueConvert};
+use dpp::version::{PlatformVersion, TryIntoPlatformVersioned};
+use dpp::{state_transition::StateTransitionLike, ProtocolError};
+use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
-use crate::errors::protocol_error::from_protocol_error;
-use crate::utils::WithJsError;
-use crate::{
-    buffer::Buffer, identifier::IdentifierWrapper, with_js_error, DataContractParameters,
-    DataContractWasm, IdentityPublicKeyWasm,
-};
+use crate::data_contract::DataContractWasm;
+use crate::identity::IdentityPublicKeyWasm;
+use crate::utils::{ToSerdeJSONExt, WithJsError};
+use crate::{buffer::Buffer, identifier::IdentifierWrapper, with_js_error};
 
 #[derive(Clone)]
 #[wasm_bindgen(js_name=DataContractCreateTransition)]
@@ -45,88 +42,77 @@ impl From<DataContractCreateTransitionWasm> for DataContractCreateTransition {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct DataContractCreateTransitionParameters {
-    #[serde(skip_serializing_if = "Option::is_none", default)]
-    data_contract: Option<DataContractParameters>,
-    #[serde(skip_serializing_if = "Option::is_none", default)]
-    entropy: Option<Vec<u8>>,
-    #[serde(skip_serializing_if = "Option::is_none", default)]
-    signature: Option<Vec<u8>>,
-    #[serde(flatten)]
-    extra: HashMap<String, serde_json::Value>,
-}
-
 #[wasm_bindgen(js_class=DataContractCreateTransition)]
 impl DataContractCreateTransitionWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(raw_parameters: JsValue) -> Result<DataContractCreateTransitionWasm, JsValue> {
-        let parameters: DataContractCreateTransitionParameters =
-            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
-        let transition_object = platform_value::to_value(parameters)
-            .map_err(ProtocolError::ValueError)
-            .with_js_error()?;
-        DataContractCreateTransition::from_raw_object(transition_object)
-            .map(Into::into)
-            .with_js_error()
+    pub fn new(value: JsValue) -> Result<DataContractCreateTransitionWasm, JsValue> {
+        let platform_value = PlatformVersion::first();
+
+        DataContractCreateTransition::from_object(
+            value.with_serde_to_platform_value()?,
+            platform_value,
+        )
+        .map(Into::into)
+        .with_js_error()
     }
 
     #[wasm_bindgen(js_name=getDataContract)]
     pub fn get_data_contract(&self) -> DataContractWasm {
-        self.0.data_contract.clone().into()
+        DataContractWasm::try_from_serialization_format(self.0.data_contract().clone(), false)
+            .expect("should convert from serialziation format")
     }
 
-    #[wasm_bindgen(js_name=setDataContractConfig)]
-    pub fn set_data_contract_config(&mut self, config: JsValue) -> Result<(), JsValue> {
-        let res = serde_wasm_bindgen::from_value(config);
-        self.0.data_contract.config = res.unwrap();
-        Ok(())
-    }
-
-    #[wasm_bindgen(js_name=getProtocolVersion)]
-    pub fn get_protocol_version(&self) -> u32 {
-        self.0.protocol_version
-    }
+    // #[wasm_bindgen(js_name=setDataContractConfig)]
+    // pub fn set_data_contract_config(&mut self, config: JsValue) -> Result<(), JsValue> {
+    //     let res = serde_wasm_bindgen::from_value(config);
+    //     self.0.data_contract.config = res.unwrap();
+    //     Ok(())
+    // }
 
     #[wasm_bindgen(js_name=getEntropy)]
     pub fn get_entropy(&self) -> Buffer {
-        Buffer::from_bytes_owned(self.0.entropy.to_vec())
+        Buffer::from_bytes_owned(self.0.entropy().to_vec())
     }
 
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
-        (*self.0.get_owner_id()).into()
+        self.0.owner_id().into()
     }
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u32 {
-        self.0.get_type() as u32
-    }
-
-    #[wasm_bindgen(js_name=toJSON)]
-    pub fn to_json(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        Ok(self
-            .0
-            .to_json(skip_signature.unwrap_or(false))
-            .with_js_error()?
-            .serialize(&serializer)
-            .expect("JSON is a valid object"))
-    }
+        self.0.state_transition_type() as u32
+    }
+    //
+    // #[wasm_bindgen(js_name=toJSON)]
+    // pub fn to_json(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
+    //     let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+    //
+    //     let options = JsonStateTransitionSerializationOptions {
+    //         skip_signature: skip_signature.unwrap_or(false),
+    //         ..Default::default()
+    //     };
+    //
+    //     let platform_version = PlatformVersion::first();
+    //
+    //     let json: Value = self.0.to_json(options).with_js_error()?.into();
+    //
+    //     Ok(json.serialize(&serializer).expect("JSON is a valid object"))
+    // }
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
-        let bytes =
-            PlatformSerializable::serialize(&StateTransition::DataContractCreate(self.0.clone()))
-                .with_js_error()?;
+        let bytes = PlatformSerializable::serialize_to_bytes(&StateTransition::DataContractCreate(
+            self.0.clone(),
+        ))
+        .with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=fromBuffer)]
     pub fn from_buffer(buffer: Vec<u8>) -> Result<DataContractCreateTransitionWasm, JsValue> {
         let state_transition: StateTransition =
-            PlatformDeserializable::deserialize(&buffer).with_js_error()?;
+            PlatformDeserializable::deserialize_from_bytes(&buffer).with_js_error()?;
         match state_transition {
             StateTransition::DataContractCreate(dct) => Ok(dct.into()),
             _ => Err(JsValue::from_str("Invalid state transition type")),
@@ -134,9 +120,9 @@ impl DataContractCreateTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=getModifiedDataIds)]
-    pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
+    pub fn modified_data_ids(&self) -> Vec<JsValue> {
         self.0
-            .get_modified_data_ids()
+            .modified_data_ids()
             .into_iter()
             .map(|identifier| Into::<IdentifierWrapper>::into(identifier).into())
             .collect()
@@ -163,9 +149,10 @@ impl DataContractCreateTransitionWasm {
             .0
             .to_cleaned_object(skip_signature.unwrap_or(false))
             .map_err(from_protocol_error)?;
-        serde_object
-            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
-            .map_err(|e| e.into())
+
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        serde_object.serialize(&serializer).map_err(|e| e.into())
     }
 
     #[wasm_bindgen]
@@ -176,14 +163,23 @@ impl DataContractCreateTransitionWasm {
         bls: JsBlsAdapter,
     ) -> Result<(), JsValue> {
         let bls_adapter = BlsAdapter(bls);
-
-        self.0
+        // TODO: come up with a better way to set signature to the binding.
+        let mut state_transition = StateTransition::DataContractCreate(self.0.clone());
+        state_transition
             .sign(
                 &identity_public_key.to_owned().into(),
                 &private_key,
                 &bls_adapter,
             )
-            .with_js_error()
+            .with_js_error()?;
+
+        let signature = state_transition.signature().to_owned();
+        let signature_public_key_id = state_transition.signature_public_key_id().unwrap_or(0);
+
+        self.0.set_signature(signature);
+        self.0.set_signature_public_key_id(signature_public_key_id);
+
+        Ok(())
     }
 
     #[wasm_bindgen(js_name=verifySignature)]
@@ -194,8 +190,7 @@ impl DataContractCreateTransitionWasm {
     ) -> Result<bool, JsValue> {
         let bls_adapter = BlsAdapter(bls);
 
-        let verification_result = self
-            .0
+        let verification_result = StateTransition::DataContractCreate(self.0.clone())
             .verify_signature(&identity_public_key.to_owned().into(), &bls_adapter);
 
         match verification_result {

package/src/data_contract/state_transition/data_contract_update_transition/mod.rs

@@ -1,35 +1,34 @@
-mod apply;
-mod validation;
+// mod validation;
 
 use std::collections::HashMap;
+use std::hash::Hash;
 
-pub use apply::*;
-pub use validation::*;
+// pub use validation::*;
 
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::{PlatformDeserializable, PlatformSerializable};
-use dpp::state_transition::StateTransition;
+use dpp::ed25519_dalek::ed25519::signature::SignerMut;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::state_transition::data_contract_update_transition::accessors::DataContractUpdateTransitionAccessorsV0;
+use dpp::state_transition::data_contract_update_transition::DataContractUpdateTransition;
+use dpp::state_transition::StateTransitionIdentitySigned;
+use dpp::state_transition::{StateTransition, StateTransitionValueConvert};
+use dpp::version::PlatformVersion;
 use dpp::{
-    consensus::signature::SignatureError,
-    data_contract::state_transition::data_contract_update_transition::DataContractUpdateTransition,
-    platform_value,
-    state_transition::{
-        StateTransitionConvert, StateTransitionIdentitySigned, StateTransitionLike,
-    },
+    consensus::signature::SignatureError, platform_value, state_transition::StateTransitionLike,
     ProtocolError,
 };
 use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
+use crate::data_contract::DataContractWasm;
+use crate::errors::protocol_error::from_protocol_error;
+use crate::identity::IdentityPublicKeyWasm;
+use crate::utils::ToSerdeJSONExt;
 use crate::{
     bls_adapter::{BlsAdapter, JsBlsAdapter},
     utils::WithJsError,
-    IdentityPublicKeyWasm,
-};
-use crate::{
-    buffer::Buffer, errors::protocol_error::from_protocol_error, identifier::IdentifierWrapper,
-    with_js_error, DataContractParameters, DataContractWasm,
 };
+use crate::{buffer::Buffer, identifier::IdentifierWrapper, with_js_error};
 
 #[derive(Clone)]
 #[wasm_bindgen(js_name=DataContractUpdateTransition)]
@@ -47,83 +46,69 @@ impl From<DataContractUpdateTransitionWasm> for DataContractUpdateTransition {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct DataContractUpdateTransitionParameters {
-    #[serde(skip_serializing_if = "Option::is_none", default)]
-    data_contract: Option<DataContractParameters>,
-    #[serde(skip_serializing_if = "Option::is_none", default)]
-    entropy: Option<Vec<u8>>,
-    #[serde(skip_serializing_if = "Option::is_none", default)]
-    signature: Option<Vec<u8>>,
-    #[serde(flatten)]
-    extra: HashMap<String, serde_json::Value>,
-}
-
 #[wasm_bindgen(js_class=DataContractUpdateTransition)]
 impl DataContractUpdateTransitionWasm {
     #[wasm_bindgen(constructor)]
     pub fn new(raw_parameters: JsValue) -> Result<DataContractUpdateTransitionWasm, JsValue> {
-        let parameters: DataContractUpdateTransitionParameters =
-            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
-        let raw_data_contract_update_transition = platform_value::to_value(parameters)
-            .map_err(ProtocolError::ValueError)
-            .with_js_error()?;
-        DataContractUpdateTransition::from_raw_object(raw_data_contract_update_transition)
-            .map(Into::into)
-            .with_js_error()
+        let platform_version = PlatformVersion::first();
+
+        DataContractUpdateTransition::from_object(
+            raw_parameters.with_serde_to_platform_value()?,
+            platform_version,
+        )
+        .map(Into::into)
+        .with_js_error()
     }
 
     #[wasm_bindgen(js_name=getDataContract)]
     pub fn get_data_contract(&self) -> DataContractWasm {
-        self.0.data_contract.clone().into()
-    }
+        let platform_version = PlatformVersion::first();
 
-    #[wasm_bindgen(js_name=setDataContractConfig)]
-    pub fn set_data_contract_config(&mut self, config: JsValue) -> Result<(), JsValue> {
-        let res = serde_wasm_bindgen::from_value(config);
-        self.0.data_contract.config = res.unwrap();
-        Ok(())
+        DataContractWasm::try_from_serialization_format(self.0.data_contract().clone(), false)
+            .expect("should create data contract from serialized format")
     }
 
-    #[wasm_bindgen(js_name=getProtocolVersion)]
-    pub fn get_protocol_version(&self) -> u32 {
-        self.0.protocol_version
-    }
+    // #[wasm_bindgen(js_name=setDataContractConfig)]
+    // pub fn set_data_contract_config(&mut self, config: JsValue) -> Result<(), JsValue> {
+    //     let res = serde_wasm_bindgen::from_value(config);
+    //     self.0.data_contract.config = res.unwrap();
+    //     Ok(())
+    // }
 
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
-        (*self.0.get_owner_id()).into()
+        self.0.owner_id().into()
     }
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u32 {
-        self.0.get_type() as u32
+        self.0.state_transition_type() as u32
     }
 
-    #[wasm_bindgen(js_name=toJSON)]
-    pub fn to_json(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        Ok(self
-            .0
-            .to_json(skip_signature.unwrap_or(false))
-            .with_js_error()?
-            .serialize(&serializer)
-            .expect("JSON is a valid object"))
-    }
+    // #[wasm_bindgen(js_name=toJSON)]
+    // pub fn to_json(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
+    //     let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+    //     Ok(self
+    //         .0
+    //         .to_json(skip_signature.unwrap_or(false))
+    //         .with_js_error()?
+    //         .serialize(&serializer)
+    //         .expect("JSON is a valid object"))
+    // }
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
-        let bytes =
-            PlatformSerializable::serialize(&StateTransition::DataContractUpdate(self.0.clone()))
-                .with_js_error()?;
+        let bytes = PlatformSerializable::serialize_to_bytes(&StateTransition::DataContractUpdate(
+            self.0.clone(),
+        ))
+        .with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=fromBuffer)]
     pub fn from_buffer(buffer: Vec<u8>) -> Result<DataContractUpdateTransitionWasm, JsValue> {
         let state_transition: StateTransition =
-            PlatformDeserializable::deserialize(&buffer).with_js_error()?;
+            PlatformDeserializable::deserialize_from_bytes(&buffer).with_js_error()?;
         match state_transition {
             StateTransition::DataContractUpdate(dct) => Ok(dct.into()),
             _ => Err(JsValue::from_str("Invalid state transition type")),
@@ -131,9 +116,9 @@ impl DataContractUpdateTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=getModifiedDataIds)]
-    pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
+    pub fn modified_data_ids(&self) -> Vec<JsValue> {
         self.0
-            .get_modified_data_ids()
+            .modified_data_ids()
             .into_iter()
             .map(|identifier| Into::<IdentifierWrapper>::into(identifier).into())
             .collect()
@@ -154,14 +139,14 @@ impl DataContractUpdateTransitionWasm {
         self.0.is_identity_state_transition()
     }
 
-    #[wasm_bindgen(js_name=hash)]
-    pub fn hash(&self, skip_signature: Option<bool>) -> Result<Buffer, JsValue> {
-        let bytes = self
-            .0
-            .hash(skip_signature.unwrap_or(false))
-            .with_js_error()?;
-        Ok(Buffer::from_bytes(&bytes))
-    }
+    // #[wasm_bindgen(js_name=hash)]
+    // pub fn hash(&self, skip_signature: Option<bool>) -> Result<Buffer, JsValue> {
+    //     let bytes = self
+    //         .0
+    //         .hash(skip_signature.unwrap_or(false))
+    //         .with_js_error()?;
+    //     Ok(Buffer::from_bytes(&bytes))
+    // }
 
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
@@ -169,6 +154,7 @@ impl DataContractUpdateTransitionWasm {
             .0
             .to_cleaned_object(skip_signature.unwrap_or(false))
             .map_err(from_protocol_error)?;
+
         serde_object
             .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
             .map_err(|e| e.into())
@@ -182,14 +168,23 @@ impl DataContractUpdateTransitionWasm {
         bls: JsBlsAdapter,
     ) -> Result<(), JsValue> {
         let bls_adapter = BlsAdapter(bls);
-
-        self.0
+        // TODO: come up with a better way to set signature to the binding.
+        let mut state_transition = StateTransition::DataContractUpdate(self.0.clone());
+        state_transition
             .sign(
                 &identity_public_key.to_owned().into(),
                 &private_key,
                 &bls_adapter,
             )
-            .with_js_error()
+            .with_js_error()?;
+
+        let signature = state_transition.signature().to_owned();
+        let signature_public_key_id = state_transition.signature_public_key_id().unwrap_or(0);
+
+        self.0.set_signature(signature);
+        self.0.set_signature_public_key_id(signature_public_key_id);
+
+        Ok(())
     }
 
     #[wasm_bindgen(js_name=verifySignature)]
@@ -200,8 +195,7 @@ impl DataContractUpdateTransitionWasm {
     ) -> Result<bool, JsValue> {
         let bls_adapter = BlsAdapter(bls);
 
-        let verification_result = self
-            .0
+        let verification_result = StateTransition::DataContractUpdate(self.0.clone())
             .verify_signature(&identity_public_key.to_owned().into(), &bls_adapter);
 
         match verification_result {