@dashevo/wasm-dpp 0.24.0-dev.33 → 0.25.0-dev.10

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

@@ -5,13 +5,14 @@ use wasm_bindgen::prelude::*;
 
 use crate::{
     state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
-    IdentityTopUpTransitionWasm,
+    IdentityTopUpTransitionWasm, StateTransitionExecutionContextWasm,
 };
 
 #[wasm_bindgen(js_name=applyIdentityTopUpTransition)]
 pub async fn apply_identity_topup_transition_wasm(
     state_repository: ExternalStateRepositoryLike,
     state_transition: &IdentityTopUpTransitionWasm,
+    execution_context: &StateTransitionExecutionContextWasm,
 ) -> Result<(), JsValue> {
     let wrapped_state_repository =
         Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
@@ -23,7 +24,10 @@ pub async fn apply_identity_topup_transition_wasm(
         ApplyIdentityTopUpTransition::new(wrapped_state_repository, Arc::new(tx_output_fetcher));
 
     instance
-        .apply(&state_transition.to_owned().into())
+        .apply(
+            &state_transition.to_owned().into(),
+            &execution_context.to_owned().into(),
+        )
         .await
         .map_err(|e| JsValue::from_str(&e.to_string()))?;
 

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

@@ -14,17 +14,16 @@ use crate::{
     identity::state_transition::asset_lock_proof::{
         ChainAssetLockProofWasm, InstantAssetLockProofWasm,
     },
-    state_transition::StateTransitionExecutionContextWasm,
     with_js_error,
 };
 
 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::{
@@ -170,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_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)]
@@ -262,16 +253,6 @@ impl IdentityTopUpTransitionWasm {
         self.0.is_identity_state_transition()
     }
 
-    #[wasm_bindgen(js_name=setExecutionContext)]
-    pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) {
-        self.0.set_execution_context(context.into())
-    }
-
-    #[wasm_bindgen(js_name=getExecutionContext)]
-    pub fn get_execution_context(&mut self) -> StateTransitionExecutionContextWasm {
-        self.0.get_execution_context().into()
-    }
-
     #[wasm_bindgen(js_name=signByPrivateKey)]
     pub fn sign_by_private_key(
         &mut self,

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

@@ -1,7 +1,7 @@
 use crate::errors::from_dpp_err;
 use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
 use crate::validation::ValidationResultWasm;
-use crate::IdentityTopUpTransitionWasm;
+use crate::{IdentityTopUpTransitionWasm, StateTransitionExecutionContextWasm};
 use dpp::identity::state_transition::identity_topup_transition::validation::state::validate_identity_topup_transition_state;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsValue;
@@ -24,10 +24,12 @@ impl IdentityTopUpTransitionStateValidator {
     pub async fn validate(
         &self,
         state_transition: &IdentityTopUpTransitionWasm,
+        execution_context: &StateTransitionExecutionContextWasm,
     ) -> Result<ValidationResultWasm, JsValue> {
         let validation_result = validate_identity_topup_transition_state(
             &self.state_repository,
             &state_transition.to_owned().into(),
+            &execution_context.to_owned().into(),
         )
         .await
         .map_err(|e| from_dpp_err(e.into()))?;

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

@@ -3,19 +3,21 @@ use wasm_bindgen::prelude::*;
 
 use crate::{
     state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
-    IdentityUpdateTransitionWasm,
+    IdentityUpdateTransitionWasm, StateTransitionExecutionContextWasm,
 };
 
 #[wasm_bindgen(js_name=applyIdentityUpdateTransition)]
 pub async fn apply_identity_update_transition_wasm(
     state_repository: ExternalStateRepositoryLike,
     state_transition: &IdentityUpdateTransitionWasm,
+    execution_context: &StateTransitionExecutionContextWasm,
 ) -> Result<(), JsValue> {
     let wrapped_state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
 
     apply_identity_update_transition(
         &wrapped_state_repository,
         &state_transition.to_owned().into(),
+        &execution_context.to_owned().into(),
     )
     .await
     .map_err(|e| JsValue::from_str(&e.to_string()))?;

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::IdentityPublicKeyWithWitness;
+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: IdentityPublicKeyWithWitness =
+                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

@@ -11,24 +11,21 @@ use crate::identifier::IdentifierWrapper;
 use crate::{
     buffer::Buffer, errors::RustConversionError,
     identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm,
-    identity::IdentityPublicKeyWasm, state_transition::StateTransitionExecutionContextWasm,
-    with_js_error,
+    identity::IdentityPublicKeyWasm, with_js_error,
 };
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
 
-use crate::errors::from_dpp_err;
 use crate::utils::{generic_of_js_val, WithJsError};
 
-use dpp::consensus::ConsensusError::SignatureError as ConsensusSignatureErrorVariant;
-
 use dpp::consensus::ConsensusError;
-use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitness;
+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,
@@ -47,7 +44,7 @@ struct IdentityUpdateTransitionParams {
     protocol_version: u32,
     identity_id: Vec<u8>,
     revision: Revision,
-    add_public_keys: Option<Vec<IdentityPublicKeyWithWitness>>,
+    add_public_keys: Option<Vec<IdentityPublicKeyInCreation>>,
     disable_public_keys: Option<Vec<KeyID>>,
     public_keys_disabled_at: Option<TimestampMillis>,
 }
@@ -106,7 +103,7 @@ impl IdentityUpdateTransitionWasm {
                         )?;
                     Ok(public_key.clone().into())
                 })
-                .collect::<Result<Vec<IdentityPublicKeyWithWitness>, JsValue>>()?;
+                .collect::<Result<Vec<IdentityPublicKeyInCreation>, JsValue>>()?;
         }
 
         self.0.set_public_keys_to_add(keys_to_add);
@@ -289,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_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)]
@@ -420,16 +409,6 @@ impl IdentityUpdateTransitionWasm {
         self.0.is_identity_state_transition()
     }
 
-    #[wasm_bindgen(js_name=setExecutionContext)]
-    pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) {
-        self.0.set_execution_context(context.into())
-    }
-
-    #[wasm_bindgen(js_name=getExecutionContext)]
-    pub fn get_execution_context(&mut self) -> StateTransitionExecutionContextWasm {
-        self.0.get_execution_context().into()
-    }
-
     #[wasm_bindgen(js_name=signByPrivateKey)]
     pub fn sign_by_private_key(
         &mut self,

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

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
 use crate::validation::ValidationResultWasm;
-use crate::{IdentityUpdateTransitionWasm};
+use crate::{IdentityUpdateTransitionWasm, StateTransitionExecutionContextWasm};
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsValue;
 use dpp::identity::state_transition::identity_update_transition::identity_update_transition::IdentityUpdateTransition;
@@ -40,12 +40,13 @@ impl IdentityUpdateTransitionStateValidatorWasm {
     pub async fn validate(
         &self,
         state_transition: &IdentityUpdateTransitionWasm,
+        execution_context: &StateTransitionExecutionContextWasm,
     ) -> Result<ValidationResultWasm, JsValue> {
         let state_transition: IdentityUpdateTransition = state_transition.to_owned().into();
 
         let validation_result = self
             .0
-            .validate(&state_transition)
+            .validate(&state_transition, &execution_context.to_owned().into())
             .await
             .map_err(|e| from_dpp_err(e.into()))?;
 

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::IdentityPublicKeyWithWitness,
+    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<IdentityPublicKeyWithWitness>>,
+    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::IdentityPublicKeyWithWitness;
+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: IdentityPublicKeyWithWitness =
+                let parsed_key: IdentityPublicKeyInCreation =
                     IdentityPublicKeyWithWitnessWasm::new(raw_key)?.into();
                 parsed_key.to_raw_object(false).with_js_error()
             })

package/src/state_repository.rs

@@ -12,6 +12,7 @@ use dpp::prelude::{Revision, TimestampMillis};
 use dpp::{
     dashcore::InstantLock,
     data_contract::DataContract,
+    platform_value,
     prelude::{Identifier, Identity},
     state_repository::{
         FetchTransactionResponse as FetchTransactionResponseDPP, StateRepositoryLike,
@@ -354,7 +355,7 @@ impl StateRepositoryLike for ExternalStateRepositoryLikeWrapper {
         &self,
         contract_id: &Identifier,
         data_contract_type: &str,
-        where_query: serde_json::Value,
+        where_query: platform_value::Value,
         execution_context: Option<&'a StateTransitionExecutionContext>,
     ) -> anyhow::Result<Vec<Self::FetchDocument>> {
         let js_documents = self
@@ -385,7 +386,7 @@ impl StateRepositoryLike for ExternalStateRepositoryLikeWrapper {
         &self,
         contract_id: &Identifier,
         data_contract_type: &str,
-        where_query: serde_json::Value,
+        where_query: platform_value::Value,
         execution_context: Option<&'a StateTransitionExecutionContext>,
     ) -> anyhow::Result<Vec<Self::FetchExtendedDocument>> {
         let js_documents = self

package/src/state_transition/fee/calculate_state_transition_fee.rs

@@ -6,17 +6,20 @@ use wasm_bindgen::prelude::*;
 
 use crate::{
     conversion::create_state_transition_from_wasm_instance, fee::fee_result::FeeResultWasm,
-    utils::WithJsError,
+    utils::WithJsError, StateTransitionExecutionContextWasm,
 };
 
 #[wasm_bindgen(js_name=calculateStateTransitionFee)]
 pub fn calculate_state_transition_fee_wasm(
     state_transition_js: &JsValue,
+    execution_context: &StateTransitionExecutionContextWasm,
 ) -> Result<FeeResultWasm, JsValue> {
     let state_transition = create_state_transition_from_wasm_instance(state_transition_js)?;
 
-    Ok(calculate_state_transition_fee(&state_transition)
-        .map_err(ProtocolError::from)
-        .with_js_error()?
-        .into())
+    Ok(
+        calculate_state_transition_fee(&state_transition, &execution_context.to_owned().into())
+            .map_err(ProtocolError::from)
+            .with_js_error()?
+            .into(),
+    )
 }

package/src/state_transition/state_transition_facade.rs

@@ -5,11 +5,10 @@ use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateReposito
 use crate::state_transition_factory::StateTransitionFactoryWasm;
 use crate::utils::{ToSerdeJSONExt, WithJsError};
 use crate::validation::ValidationResultWasm;
-use crate::with_js_error;
+use crate::{with_js_error, StateTransitionExecutionContextWasm};
 use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
 use dpp::state_transition::{
-    StateTransitionConvert, StateTransitionFacade, StateTransitionLike, StateTransitionType,
-    ValidateOptions,
+    StateTransitionConvert, StateTransitionFacade, StateTransitionType, ValidateOptions,
 };
 use dpp::version::ProtocolVersionValidator;
 use serde::Deserialize;
@@ -17,8 +16,7 @@ use serde::Deserialize;
 use crate::errors::protocol_error::from_protocol_error;
 use crate::errors::value_error::PlatformValueErrorWasm;
 use dpp::data_contract::state_transition::data_contract_update_transition::DataContractUpdateTransition;
-use dpp::document::DocumentsBatchTransition;
-use dpp::ProtocolError;
+
 use std::sync::Arc;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsValue;
@@ -65,17 +63,13 @@ impl StateTransitionFacadeWasm {
         let mut raw_state_transition = raw_state_transition.with_serde_to_platform_value()?;
         let state_transition_type: StateTransitionType = raw_state_transition
             .get_integer::<u8>("type")
-            .map_err(|e| PlatformValueErrorWasm::from(e))?
+            .map_err(PlatformValueErrorWasm::from)?
             .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(|e| PlatformValueErrorWasm::from(e))?;
-            }
-            _ => {}
+        if state_transition_type == StateTransitionType::DataContractUpdate {
+            DataContractUpdateTransition::clean_value(&mut raw_state_transition)
+                .map_err(PlatformValueErrorWasm::from)?;
         }
 
         let result = self
@@ -116,6 +110,7 @@ impl StateTransitionFacadeWasm {
     pub async fn validate(
         &self,
         raw_state_transition: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
         options: JsValue,
     ) -> Result<ValidationResultWasm, JsValue> {
         let options: ValidateOptionsWasm = if options.is_object() {
@@ -128,7 +123,8 @@ impl StateTransitionFacadeWasm {
             super::super::conversion::create_state_transition_from_wasm_instance(
                 &raw_state_transition,
             ) {
-            let execution_context = state_transition.get_execution_context().to_owned();
+            let execution_context: StateTransitionExecutionContext =
+                execution_context.to_owned().into();
             (state_transition, execution_context)
         } else {
             let state_transition_json = raw_state_transition.with_serde_to_platform_value()?;
@@ -154,25 +150,23 @@ impl StateTransitionFacadeWasm {
     pub async fn validate_basic(
         &self,
         raw_state_transition: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
     ) -> Result<ValidationResultWasm, JsValue> {
         let state_transition_json;
-        let execution_context;
 
         if let Ok(state_transition) =
             super::super::conversion::create_state_transition_from_wasm_instance(
                 &raw_state_transition,
             )
         {
-            execution_context = state_transition.get_execution_context().to_owned();
             state_transition_json = state_transition.to_cleaned_object(false).with_js_error()?;
         } else {
             state_transition_json = raw_state_transition.with_serde_to_platform_value()?;
-            execution_context = StateTransitionExecutionContext::default();
         }
 
         let validation_result = self
             .0
-            .validate_basic(&state_transition_json, &execution_context)
+            .validate_basic(&state_transition_json, &execution_context.to_owned().into())
             .await
             .with_js_error()?;
 
@@ -183,6 +177,7 @@ impl StateTransitionFacadeWasm {
     pub async fn validate_signature(
         &self,
         raw_state_transition: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
     ) -> Result<ValidationResultWasm, JsValue> {
         let state_transition =
             super::super::conversion::create_state_transition_from_wasm_instance(
@@ -191,7 +186,7 @@ impl StateTransitionFacadeWasm {
 
         let validation_result = self
             .0
-            .validate_signature(state_transition)
+            .validate_signature(state_transition, &execution_context.to_owned().into())
             .await
             .with_js_error()?;
 
@@ -202,6 +197,7 @@ impl StateTransitionFacadeWasm {
     pub async fn validate_fee(
         &self,
         raw_state_transition: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
     ) -> Result<ValidationResultWasm, JsValue> {
         let state_transition =
             super::super::conversion::create_state_transition_from_wasm_instance(
@@ -210,7 +206,7 @@ impl StateTransitionFacadeWasm {
 
         let validation_result = self
             .0
-            .validate_fee(&state_transition)
+            .validate_fee(&state_transition, &execution_context.to_owned().into())
             .await
             .with_js_error()?;
 
@@ -221,6 +217,7 @@ impl StateTransitionFacadeWasm {
     pub async fn validate_state(
         &self,
         raw_state_transition: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
     ) -> Result<ValidationResultWasm, JsValue> {
         let state_transition =
             super::super::conversion::create_state_transition_from_wasm_instance(
@@ -229,7 +226,7 @@ impl StateTransitionFacadeWasm {
 
         let validation_result = self
             .0
-            .validate_state(&state_transition)
+            .validate_state(&state_transition, &execution_context.to_owned().into())
             .await
             .with_js_error()?;
 

package/src/state_transition/validation/state_transition_fee_validator.rs

@@ -7,6 +7,7 @@ use wasm_bindgen::JsValue;
 use crate::state_transition::conversion::create_state_transition_from_wasm_instance;
 use crate::utils::WithJsError;
 use crate::validation::ValidationResultWasm;
+use crate::StateTransitionExecutionContextWasm;
 
 #[wasm_bindgen(js_name=StateTransitionFeeValidator)]
 pub struct StateTransitionFeeValidatorWasm(
@@ -26,11 +27,12 @@ impl StateTransitionFeeValidatorWasm {
     pub async fn validate(
         &self,
         state_transition: &JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
     ) -> Result<ValidationResultWasm, JsValue> {
         let st = create_state_transition_from_wasm_instance(state_transition)?;
         Ok(self
             .0
-            .validate(&st)
+            .validate(&st, &execution_context.to_owned().into())
             .await
             .map(|v| v.map(|_| JsValue::undefined()))
             .with_js_error()?

package/src/state_transition/validation/validate_state_transition_identity_signature.rs

@@ -7,9 +7,11 @@ use crate::errors::consensus::consensus_error::from_consensus_error;
 use dpp::consensus::basic::state_transition::InvalidStateTransitionTypeError;
 use dpp::consensus::basic::BasicError;
 use dpp::consensus::ConsensusError;
+use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
 use dpp::state_transition::validation::validate_state_transition_identity_signature::validate_state_transition_identity_signature;
 use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned};
-use dpp::ProtocolError;
+
+use crate::StateTransitionExecutionContextWasm;
 use std::sync::Arc;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;
@@ -23,11 +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,
+            execution_context,
         )
         .await
         .with_js_error()?;
@@ -41,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,
@@ -58,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(
@@ -79,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
         }
     }
 }

package/src/state_transition/validation/validate_state_transition_key_signature.rs

@@ -1,6 +1,7 @@
 use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
 use crate::utils::WithJsError;
 use crate::validation::ValidationResultWasm;
+use crate::StateTransitionExecutionContextWasm;
 use dpp::identity::state_transition::asset_lock_proof::{
     AssetLockPublicKeyHashFetcher, AssetLockTransactionOutputFetcher,
 };
@@ -48,13 +49,18 @@ impl StateTransitionKeySignatureValidatorWasm {
     pub async fn validate(
         &self,
         state_transition: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
     ) -> Result<ValidationResultWasm, JsValue> {
         let state_transition =
             super::super::conversion::create_state_transition_from_wasm_instance(
                 &state_transition,
             )?;
 
-        let validation_result = self.0.validate(&state_transition).await.with_js_error()?;
+        let validation_result = self
+            .0
+            .validate(&state_transition, &execution_context.to_owned().into())
+            .await
+            .with_js_error()?;
         Ok(validation_result.map(|_| JsValue::undefined()).into())
     }
 }

package/src/utils.rs

@@ -240,7 +240,7 @@ pub fn get_class_name(value: &JsValue) -> String {
 }
 
 pub fn try_to_u64(value: JsValue) -> Result<u64, anyhow::Error> {
-    let result = if value.is_bigint() {
+    if value.is_bigint() {
         js_sys::BigInt::new(&value)
             .map_err(|e| anyhow!("unable to create bigInt: {}", e.to_string()))?
             .try_into()
@@ -250,9 +250,7 @@ pub fn try_to_u64(value: JsValue) -> Result<u64, anyhow::Error> {
         convert_number_to_u64(number)
     } else {
         bail!("supported types are Number or BigInt")
-    };
-
-    result
+    }
 }
 
 pub fn convert_number_to_u64(js_number: js_sys::Number) -> Result<u64, anyhow::Error> {