@dashevo/wasm-dpp 0.25.0-dev.1 → 0.25.0-dev.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.25.0-dev.1",
+  "version": "0.25.0-dev.11",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,8 +44,8 @@
     "@babel/core": "^7.15.5",
     "@babel/preset-env": "^7.15.4",
     "@dashevo/dashcore-lib": "~0.20.3",
-    "@dashevo/dpns-contract": "0.25.0-dev.1",
-    "@dashevo/dpp": "0.25.0-dev.1",
+    "@dashevo/dpns-contract": "0.25.0-dev.11",
+    "@dashevo/dpp": "0.25.0-dev.11",
     "@dashevo/wasm-re2": "~1.0.2",
     "@types/bs58": "^4.0.1",
     "@types/node": "^14.6.0",

package/src/dash_platform_protocol.rs

@@ -51,7 +51,7 @@ impl DashPlatformProtocol {
         // "attempted to set a logger after the logging system was already initialized"
         // Usage of unsafe is fine here as we are in a single-threaded JS environment
         unsafe {
-            if cfg!(LOGGER_INITIALIZED) && !LOGGER_INITIALIZED {
+            if !LOGGER_INITIALIZED {
                 LOGGER_INITIALIZED = true;
                 wasm_logger::init(wasm_logger::Config::new(log::Level::Debug));
             }

package/src/data_contract/data_contract.rs

@@ -11,6 +11,7 @@ use dpp::data_contract::{DataContract, SCHEMA_URI};
 use dpp::platform_value::string_encoding::Encoding;
 use dpp::platform_value::{Bytes32, Value};
 
+use dpp::serialization_traits::PlatformSerializable;
 use dpp::{platform_value, Convertible};
 
 use crate::errors::RustConversionError;
@@ -303,7 +304,7 @@ impl DataContractWasm {
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
-        let bytes = self.0.to_cbor_buffer().with_js_error()?;
+        let bytes = PlatformSerializable::serialize(&self.0).with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
 

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

@@ -8,6 +8,8 @@ pub use validation::*;
 
 use dpp::consensus::signature::SignatureError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization_traits::PlatformSerializable;
+use dpp::state_transition::StateTransition;
 use dpp::{
     data_contract::state_transition::data_contract_create_transition::DataContractCreateTransition,
     platform_value,
@@ -107,11 +109,10 @@ impl DataContractCreateTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self, skip_signature: Option<bool>) -> Result<Buffer, JsValue> {
-        let bytes = self
-            .0
-            .to_cbor_buffer(skip_signature.unwrap_or(false))
-            .with_js_error()?;
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes =
+            PlatformSerializable::serialize(&StateTransition::DataContractCreate(self.0.clone()))
+                .with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
 

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

@@ -7,6 +7,8 @@ pub use apply::*;
 pub use validation::*;
 
 use dpp::consensus::ConsensusError;
+use dpp::serialization_traits::PlatformSerializable;
+use dpp::state_transition::StateTransition;
 use dpp::{
     consensus::signature::SignatureError,
     data_contract::state_transition::data_contract_update_transition::DataContractUpdateTransition,
@@ -109,11 +111,10 @@ impl DataContractUpdateTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self, skip_signature: Option<bool>) -> Result<Buffer, JsValue> {
-        let bytes = self
-            .0
-            .to_cbor_buffer(skip_signature.unwrap_or(false))
-            .with_js_error()?;
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes =
+            PlatformSerializable::serialize(&StateTransition::DataContractUpdate(self.0.clone()))
+                .with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
 

package/src/document/extended_document.rs

@@ -7,6 +7,7 @@ use dpp::util::json_schema::JsonSchemaExt;
 use dpp::util::json_value::JsonValueExt;
 
 use dpp::platform_value::converter::serde_json::BTreeValueJsonConverter;
+use dpp::serialization_traits::PlatformSerializable;
 use dpp::ProtocolError;
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
@@ -325,8 +326,7 @@ impl ExtendedDocumentWasm {
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
-        let bytes = self.0.to_cbor_buffer().with_js_error()?;
-
+        let bytes = PlatformSerializable::serialize(&self.0.clone()).with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
 

package/src/document/state_transition/document_batch_transition/mod.rs

@@ -19,6 +19,8 @@ use serde::{Deserialize, Serialize};
 use dpp::consensus::signature::SignatureError;
 use dpp::consensus::ConsensusError;
 use dpp::platform_value::{BinaryData, ReplacementType};
+use dpp::serialization_traits::PlatformSerializable;
+use dpp::state_transition::StateTransition;
 use wasm_bindgen::prelude::*;
 
 use crate::{
@@ -369,15 +371,10 @@ impl DocumentsBatchTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self, options: &JsValue) -> Result<Buffer, JsValue> {
-        let skip_signature = if options.is_object() {
-            let options = options.with_serde_to_json_value()?;
-            options.get_bool("skipSignature").unwrap_or_default()
-        } else {
-            false
-        };
-        let bytes = self.0.to_cbor_buffer(skip_signature).with_js_error()?;
-
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes =
+            PlatformSerializable::serialize(&StateTransition::DocumentsBatch(self.0.clone()))
+                .with_js_error()?;
         Ok(Buffer::from_bytes(&bytes))
     }
 

package/src/errors/consensus/basic/invalid_signature_public_key_security_level_error.rs

@@ -25,12 +25,12 @@ impl InvalidSignaturePublicKeySecurityLevelErrorWasm {
     }
 
     #[wasm_bindgen(js_name=getKeySecurityLevelRequirement)]
-    pub fn get_allowed_key_security_levels(&self) -> Vec<u8> {
-        self.inner
-            .allowed_key_security_levels()
-            .iter()
-            .map(|security_level| *security_level as u8)
-            .collect()
+    pub fn get_allowed_key_security_levels(&self) -> js_sys::Array {
+        let array = js_sys::Array::new();
+        for security_level in self.inner.allowed_key_security_levels() {
+            array.push(&JsValue::from(security_level as u32));
+        }
+        array
     }
 
     #[wasm_bindgen(js_name=getCode)]

package/src/identity/factory_utils.rs

@@ -3,7 +3,7 @@ use crate::identity::identity_public_key_transitions::IdentityPublicKeyWithWitne
 use crate::utils::{generic_of_js_val, to_vec_of_platform_values};
 use crate::{create_asset_lock_proof_from_wasm_instance, IdentityPublicKeyWasm};
 use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
-use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreation;
 use dpp::identity::{IdentityPublicKey, KeyID};
 use std::collections::BTreeMap;
 use wasm_bindgen::__rt::Ref;
@@ -26,7 +26,7 @@ pub fn parse_create_args(
     Ok((asset_lock_proof, public_keys))
 }
 
-type AddPublicKeys = Option<Vec<IdentityPublicKeyInCreationWithWitness>>;
+type AddPublicKeys = Option<Vec<IdentityPublicKeyInCreation>>;
 type DisablePublicKeys = Option<Vec<KeyID>>;
 
 pub fn parse_create_identity_update_transition_keys(
@@ -44,7 +44,7 @@ pub fn parse_create_identity_update_transition_keys(
                     .to_js_value()
             })?;
 
-        let keys: Vec<IdentityPublicKeyInCreationWithWitness> = add_public_keys_array
+        let keys: Vec<IdentityPublicKeyInCreation> = add_public_keys_array
             .iter()
             .map(|key| {
                 let public_key: Ref<IdentityPublicKeyWithWitnessWasm> =
@@ -55,7 +55,7 @@ pub fn parse_create_identity_update_transition_keys(
 
                 Ok(public_key.clone().into())
             })
-            .collect::<Result<Vec<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
+            .collect::<Result<Vec<IdentityPublicKeyInCreation>, JsValue>>()?;
 
         add_public_keys = Some(keys)
     }

package/src/identity/mod.rs

@@ -12,6 +12,7 @@ use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
 use dpp::identity::IdentityPublicKey;
 use dpp::identity::{Identity, KeyID};
 use dpp::metadata::Metadata;
+use dpp::serialization_traits::PlatformSerializable;
 use dpp::{Convertible, ProtocolError};
 
 use crate::identifier::IdentifierWrapper;
@@ -212,8 +213,9 @@ impl IdentityWasm {
     }
 
     #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self) -> Vec<u8> {
-        self.0.to_cbor_buffer().unwrap()
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes = PlatformSerializable::serialize(&self.0.clone()).with_js_error()?;
+        Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen]

package/src/identity/state_transition/identity_create_transition/identity_create_transition.rs

@@ -18,17 +18,17 @@ use crate::{
 };
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
-use crate::errors::from_dpp_err;
-use dpp::state_transition::StateTransitionConvert;
+use dpp::state_transition::StateTransition;
 
 use crate::utils::{generic_of_js_val, ToSerdeJSONExt, WithJsError};
 use dpp::identity::KeyType;
 use dpp::platform_value::string_encoding::Encoding;
 use dpp::platform_value::{string_encoding, BinaryData};
+use dpp::serialization_traits::PlatformSerializable;
 use dpp::{
     identity::state_transition::{
         asset_lock_proof::AssetLockProof, identity_create_transition::IdentityCreateTransition,
-        identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness,
+        identity_public_key_transitions::IdentityPublicKeyInCreation,
     },
     state_transition::StateTransitionLike,
 };
@@ -104,7 +104,7 @@ impl IdentityCreateTransitionWasm {
                     )?;
                 Ok(public_key.clone().into())
             })
-            .collect::<Result<Vec<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
+            .collect::<Result<Vec<IdentityPublicKeyInCreation>, JsValue>>()?;
 
         self.0.set_public_keys(public_keys);
 
@@ -123,7 +123,7 @@ impl IdentityCreateTransitionWasm {
                     )?;
                 Ok(public_key.clone().into())
             })
-            .collect::<Result<Vec<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
+            .collect::<Result<Vec<IdentityPublicKeyInCreation>, JsValue>>()?;
 
         self.0.add_public_keys(&mut public_keys);
 
@@ -135,7 +135,7 @@ impl IdentityCreateTransitionWasm {
         self.0
             .get_public_keys()
             .iter()
-            .map(IdentityPublicKeyInCreationWithWitness::to_owned)
+            .map(IdentityPublicKeyInCreation::to_owned)
             .map(IdentityPublicKeyWithWitnessWasm::from)
             .map(JsValue::from)
             .collect()
@@ -228,19 +228,11 @@ impl IdentityCreateTransitionWasm {
     }
 
     #[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(&StateTransition::IdentityCreate(self.0.clone()))
+                .with_js_error()?;
+        Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=toJSON)]

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

@@ -1,5 +1,5 @@
 use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
-use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreation;
 use dpp::{
     identifier::Identifier,
     identity::state_transition::identity_create_transition::IdentityCreateTransition,
@@ -20,7 +20,7 @@ pub struct ToObject {
     pub protocol_version: u32,
     pub identity_id: Identifier,
     pub asset_lock_proof: AssetLockProof,
-    pub public_keys: Vec<IdentityPublicKeyInCreationWithWitness>,
+    pub public_keys: Vec<IdentityPublicKeyInCreation>,
     pub signature: Option<Vec<u8>>,
 }
 

package/src/identity/state_transition/identity_public_key_transitions.rs

@@ -1,7 +1,7 @@
 //todo: move this file to transition
 use dpp::dashcore::anyhow;
 use dpp::document::document_transition::document_base_transition::JsonValue;
-use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreation;
 use dpp::platform_value::BinaryData;
 use dpp::Convertible;
 pub use serde::{Deserialize, Serialize};
@@ -20,7 +20,7 @@ struct ToObjectOptions {
 
 #[wasm_bindgen(js_name=IdentityPublicKeyWithWitness)]
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct IdentityPublicKeyWithWitnessWasm(IdentityPublicKeyInCreationWithWitness);
+pub struct IdentityPublicKeyWithWitnessWasm(IdentityPublicKeyInCreation);
 
 #[wasm_bindgen(js_class = IdentityPublicKeyWithWitness)]
 impl IdentityPublicKeyWithWitnessWasm {
@@ -29,7 +29,7 @@ impl IdentityPublicKeyWithWitnessWasm {
         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 = IdentityPublicKeyInCreationWithWitness::from_json_object(value).with_js_error()?;
+        let pk = IdentityPublicKeyInCreation::from_json_object(value).with_js_error()?;
 
         Ok(IdentityPublicKeyWithWitnessWasm(pk))
     }
@@ -174,21 +174,21 @@ impl IdentityPublicKeyWithWitnessWasm {
 }
 
 impl IdentityPublicKeyWithWitnessWasm {
-    pub fn into_inner(self) -> IdentityPublicKeyInCreationWithWitness {
+    pub fn into_inner(self) -> IdentityPublicKeyInCreation {
         self.0
     }
 
-    pub fn inner(&self) -> &IdentityPublicKeyInCreationWithWitness {
+    pub fn inner(&self) -> &IdentityPublicKeyInCreation {
         &self.0
     }
 
-    pub fn inner_mut(&mut self) -> &mut IdentityPublicKeyInCreationWithWitness {
+    pub fn inner_mut(&mut self) -> &mut IdentityPublicKeyInCreation {
         &mut self.0
     }
 }
 
-impl From<IdentityPublicKeyInCreationWithWitness> for IdentityPublicKeyWithWitnessWasm {
-    fn from(v: IdentityPublicKeyInCreationWithWitness) -> Self {
+impl From<IdentityPublicKeyInCreation> for IdentityPublicKeyWithWitnessWasm {
+    fn from(v: IdentityPublicKeyInCreation) -> Self {
         IdentityPublicKeyWithWitnessWasm(v)
     }
 }
@@ -200,12 +200,12 @@ impl TryFrom<JsValue> for IdentityPublicKeyWithWitnessWasm {
         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(
-            IdentityPublicKeyInCreationWithWitness::from_raw_json_object(val).with_js_error()?,
+            IdentityPublicKeyInCreation::from_raw_json_object(val).with_js_error()?,
         ))
     }
 }
 
-impl From<IdentityPublicKeyWithWitnessWasm> for IdentityPublicKeyInCreationWithWitness {
+impl From<IdentityPublicKeyWithWitnessWasm> for IdentityPublicKeyInCreation {
     fn from(pk: IdentityPublicKeyWithWitnessWasm) -> Self {
         pk.0
     }

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

@@ -19,11 +19,11 @@ use crate::{
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
 
-use crate::errors::from_dpp_err;
 use dpp::identity::KeyType;
 use dpp::platform_value::string_encoding::Encoding;
 use dpp::platform_value::{string_encoding, BinaryData};
-use dpp::state_transition::StateTransitionConvert;
+use dpp::serialization_traits::PlatformSerializable;
+use dpp::state_transition::StateTransition;
 use dpp::{
     identifier::Identifier,
     identity::state_transition::{
@@ -169,19 +169,11 @@ 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(&StateTransition::IdentityTopUp(self.0.clone()))
+                .with_js_error()?;
+        Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=toJSON)]

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()

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

@@ -16,16 +16,16 @@ use crate::{
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
 
-use crate::errors::from_dpp_err;
 use crate::utils::{generic_of_js_val, WithJsError};
 
 use dpp::consensus::ConsensusError;
-use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreation;
 use dpp::identity::{KeyID, KeyType, TimestampMillis};
 use dpp::platform_value::string_encoding::Encoding;
 use dpp::platform_value::{string_encoding, BinaryData, Value};
 use dpp::prelude::Revision;
-use dpp::state_transition::{StateTransitionConvert, StateTransitionIdentitySigned};
+use dpp::serialization_traits::PlatformSerializable;
+use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned};
 use dpp::{
     identifier::Identifier,
     identity::state_transition::identity_update_transition::identity_update_transition::IdentityUpdateTransition,
@@ -44,7 +44,7 @@ struct IdentityUpdateTransitionParams {
     protocol_version: u32,
     identity_id: Vec<u8>,
     revision: Revision,
-    add_public_keys: Option<Vec<IdentityPublicKeyInCreationWithWitness>>,
+    add_public_keys: Option<Vec<IdentityPublicKeyInCreation>>,
     disable_public_keys: Option<Vec<KeyID>>,
     public_keys_disabled_at: Option<TimestampMillis>,
 }
@@ -103,7 +103,7 @@ impl IdentityUpdateTransitionWasm {
                         )?;
                     Ok(public_key.clone().into())
                 })
-                .collect::<Result<Vec<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
+                .collect::<Result<Vec<IdentityPublicKeyInCreation>, JsValue>>()?;
         }
 
         self.0.set_public_keys_to_add(keys_to_add);
@@ -286,19 +286,11 @@ impl IdentityUpdateTransitionWasm {
     }
 
     #[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(&StateTransition::IdentityUpdate(self.0.clone()))
+                .with_js_error()?;
+        Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=toJSON)]

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

@@ -2,7 +2,7 @@ use dpp::identity::KeyID;
 use dpp::state_transition::StateTransitionIdentitySigned;
 use dpp::{
     identifier::Identifier,
-    identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness,
+    identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreation,
     identity::state_transition::identity_update_transition::identity_update_transition::IdentityUpdateTransition,
     state_transition::StateTransitionLike,
 };
@@ -23,7 +23,7 @@ pub struct ToObject {
     pub signature: Option<Vec<u8>>,
     pub signature_public_key_id: Option<KeyID>,
     pub public_keys_disabled_at: Option<u64>,
-    pub public_keys_to_add: Option<Vec<IdentityPublicKeyInCreationWithWitness>>,
+    pub public_keys_to_add: Option<Vec<IdentityPublicKeyInCreation>>,
     pub public_key_ids_to_disable: Option<Vec<KeyID>>,
     pub identity_id: Identifier,
 }

package/src/identity/state_transition/validate_public_key_signatures.rs

@@ -10,7 +10,7 @@ use dpp::identity::state_transition::validate_public_key_signatures::{
     PublicKeysSignaturesValidator, TPublicKeysSignaturesValidator,
 };
 
-use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreation;
 
 use crate::errors::from_dpp_err;
 use dpp::platform_value::Value;
@@ -44,7 +44,7 @@ impl PublicKeysSignaturesValidatorWasm {
         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()
             })

package/src/state_transition/state_transition_facade.rs

@@ -67,13 +67,9 @@ impl StateTransitionFacadeWasm {
             .try_into()
             .map_err(|_| JsValue::from_str("Invalid state transition type"))?;
 
-        // TODO: clean values of other transitions as well?
-        match state_transition_type {
-            StateTransitionType::DataContractUpdate => {
-                DataContractUpdateTransition::clean_value(&mut raw_state_transition)
-                    .map_err(PlatformValueErrorWasm::from)?;
-            }
-            _ => {}
+        if state_transition_type == StateTransitionType::DataContractUpdate {
+            DataContractUpdateTransition::clean_value(&mut raw_state_transition)
+                .map_err(PlatformValueErrorWasm::from)?;
         }
 
         let result = self

package/src/state_transition/validation/validate_state_transition_identity_signature.rs

@@ -11,6 +11,7 @@ use dpp::state_transition::state_transition_execution_context::StateTransitionEx
 use dpp::state_transition::validation::validate_state_transition_identity_signature::validate_state_transition_identity_signature;
 use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned};
 
+use crate::StateTransitionExecutionContextWasm;
 use std::sync::Arc;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;
@@ -24,12 +25,13 @@ impl StValidator {
     pub async fn validate(
         &self,
         state_transition: &mut impl StateTransitionIdentitySigned,
+        execution_context: &StateTransitionExecutionContext,
     ) -> Result<ValidationResultWasm, JsValue> {
         let result = validate_state_transition_identity_signature(
             self.state_repository.clone(),
             state_transition,
             &self.bls,
-            &StateTransitionExecutionContext::default(), // TODO(v0.24-backport): is it fine using default context here?
+            execution_context,
         )
         .await
         .with_js_error()?;
@@ -43,12 +45,14 @@ impl StValidator {
 pub async fn validate_state_transition_identity_signature_wasm(
     external_state_repository: ExternalStateRepositoryLike,
     js_state_transition: &JsValue,
+    execution_context: &StateTransitionExecutionContextWasm,
     bls_adapter: JsBlsAdapter,
 ) -> Result<ValidationResultWasm, JsValue> {
     let bls = BlsAdapter(bls_adapter);
     let state_repository = Arc::new(ExternalStateRepositoryLikeWrapper::new(
         external_state_repository,
     ));
+    let execution_context: StateTransitionExecutionContext = execution_context.to_owned().into();
 
     let validator = StValidator {
         bls,
@@ -60,13 +64,19 @@ pub async fn validate_state_transition_identity_signature_wasm(
 
     match state_transition {
         StateTransition::DataContractCreate(mut state_transition) => {
-            validator.validate(&mut state_transition).await
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
         }
         StateTransition::DataContractUpdate(mut state_transition) => {
-            validator.validate(&mut state_transition).await
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
         }
         StateTransition::DocumentsBatch(mut state_transition) => {
-            validator.validate(&mut state_transition).await
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
         }
         // TODO: We should use protocol error here, not consensus
         StateTransition::IdentityCreate(state_transition) => Err(from_consensus_error(
@@ -81,10 +91,14 @@ pub async fn validate_state_transition_identity_signature_wasm(
             )),
         )),
         StateTransition::IdentityCreditWithdrawal(mut state_transition) => {
-            validator.validate(&mut state_transition).await
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
         }
         StateTransition::IdentityUpdate(mut state_transition) => {
-            validator.validate(&mut state_transition).await
+            validator
+                .validate(&mut state_transition, &execution_context)
+                .await
         }
     }
 }