@dashevo/wasm-dpp 0.24.0-dev.29 → 0.25.0-dev.1

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

@@ -11,8 +11,7 @@ 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};
@@ -20,10 +19,8 @@ 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::IdentityPublicKeyInCreationWithWitness;
 use dpp::identity::{KeyID, KeyType, TimestampMillis};
 use dpp::platform_value::string_encoding::Encoding;
 use dpp::platform_value::{string_encoding, BinaryData, Value};
@@ -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<IdentityPublicKeyInCreationWithWitness>>,
     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<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
         }
 
         self.0.set_public_keys_to_add(keys_to_add);
@@ -298,7 +295,7 @@ impl IdentityUpdateTransitionWasm {
 
         let buffer = self
             .0
-            .to_buffer(opts.skip_signature.unwrap_or(false))
+            .to_cbor_buffer(opts.skip_signature.unwrap_or(false))
             .map_err(from_dpp_err)?;
 
         Ok(Buffer::from_bytes(&buffer).into())
@@ -420,16 +417,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::IdentityPublicKeyInCreationWithWitness,
     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<IdentityPublicKeyInCreationWithWitness>>,
     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::IdentityPublicKeyInCreationWithWitness;
 
 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: IdentityPublicKeyInCreationWithWitness =
                     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,7 +63,7 @@ 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"))?;
 
@@ -73,7 +71,7 @@ impl StateTransitionFacadeWasm {
         match state_transition_type {
             StateTransitionType::DataContractUpdate => {
                 DataContractUpdateTransition::clean_value(&mut raw_state_transition)
-                    .map_err(|e| PlatformValueErrorWasm::from(e))?;
+                    .map_err(PlatformValueErrorWasm::from)?;
             }
             _ => {}
         }
@@ -116,6 +114,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 +127,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 +154,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 +181,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 +190,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 +201,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 +210,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 +221,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 +230,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,10 @@ 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 std::sync::Arc;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;
@@ -28,6 +29,7 @@ impl StValidator {
             self.state_repository.clone(),
             state_transition,
             &self.bls,
+            &StateTransitionExecutionContext::default(), // TODO(v0.24-backport): is it fine using default context here?
         )
         .await
         .with_js_error()?;

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> {

package/src/validation/validation_result.rs

@@ -3,19 +3,19 @@ use crate::{
     errors::consensus::consensus_error::from_consensus_error_ref,
     utils::{consensus_errors_from_buffers, WithJsError},
 };
-use dpp::{consensus::ConsensusError, validation::ValidationResult};
+use dpp::{consensus::ConsensusError, validation::ConsensusValidationResult};
 use js_sys::{JsString, Uint8Array};
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=ValidationResult)]
 #[derive(Debug)]
-pub struct ValidationResultWasm(ValidationResult<JsValue>);
+pub struct ValidationResultWasm(ConsensusValidationResult<JsValue>);
 
-impl<T> From<ValidationResult<T>> for ValidationResultWasm
+impl<T> From<ConsensusValidationResult<T>> for ValidationResultWasm
 where
     T: Into<JsValue> + Clone,
 {
-    fn from(validation_result: ValidationResult<T>) -> Self {
+    fn from(validation_result: ConsensusValidationResult<T>) -> Self {
         ValidationResultWasm(validation_result.map(Into::into))
     }
 }
@@ -27,10 +27,12 @@ impl ValidationResultWasm {
         if let Some(errors) = errors_option {
             let consensus_errors: Vec<ConsensusError> = consensus_errors_from_buffers(errors)?;
 
-            return Ok(Self(ValidationResult::new_with_errors(consensus_errors)));
+            return Ok(Self(ConsensusValidationResult::new_with_errors(
+                consensus_errors,
+            )));
         }
 
-        Ok(Self(ValidationResult::new_with_errors(vec![])))
+        Ok(Self(ConsensusValidationResult::new_with_errors(vec![])))
     }
 
     /// This is just a test method - doesn't need to be in the resulted binding. Please
@@ -57,7 +59,10 @@ impl ValidationResultWasm {
 
     #[wasm_bindgen(js_name=getData)]
     pub fn get_data(&self) -> JsValue {
-        self.0.data().unwrap_or(&JsValue::undefined()).to_owned()
+        self.0
+            .data_as_borrowed()
+            .unwrap_or(&JsValue::undefined())
+            .to_owned()
     }
 
     #[wasm_bindgen(js_name=getFirstError)]

package/test/integration/dataContract/validation/validateDataContractFactory.spec.js

@@ -17,7 +17,6 @@ describe('validateDataContractFactory', () => {
   let UniqueIndicesLimitReachedError;
   let SystemPropertyIndexAlreadyPresentError;
   let InvalidIndexPropertyTypeError;
-  let InvalidCompoundIndexError;
   let InvalidIndexedPropertyConstraintError;
   let InvalidJsonSchemaRefError;
 
@@ -32,7 +31,6 @@ describe('validateDataContractFactory', () => {
       UniqueIndicesLimitReachedError,
       SystemPropertyIndexAlreadyPresentError,
       InvalidIndexPropertyTypeError,
-      InvalidCompoundIndexError,
       InvalidIndexedPropertyConstraintError,
       InvalidJsonSchemaRefError,
     } = await loadWasmDpp());
@@ -1929,21 +1927,6 @@ describe('validateDataContractFactory', () => {
         expect(error.getDocumentType()).to.deep.equal('indexedDocument');
         expect(error.getIndexName()).to.equal('index1');
       });
-
-      it('should return invalid result if unique compound index contains both required and optional properties', async () => {
-        const rawDataContract = dataContract.toObject();
-        rawDataContract.documents.optionalUniqueIndexedDocument.required.splice(-1);
-
-        const result = await validateDataContract(rawDataContract);
-
-        expectValidationError(result, InvalidCompoundIndexError);
-
-        const [error] = result.getErrors();
-
-        expect(error.getCode()).to.equal(1010);
-        expect(error.getIndexName()).to.equal('index2');
-        expect(error.getDocumentType()).to.equal('optionalUniqueIndexedDocument');
-      });
     });
   });
 

package/test/integration/document/stateTransition/DocumentsBatchTransition/DocumentBatchTransition.spec.js

@@ -78,7 +78,11 @@ describe('DocumentBatchTransition', () => {
 
       // Nice document has medium security level
       expect(stateTransitionFixture.getKeySecurityLevelRequirement())
-        .to.be.equal(IdentityPublicKey.SECURITY_LEVELS.MEDIUM);
+        .to.deep.equal([
+          IdentityPublicKey.SECURITY_LEVELS.CRITICAL,
+          IdentityPublicKey.SECURITY_LEVELS.HIGH,
+          IdentityPublicKey.SECURITY_LEVELS.MEDIUM,
+        ]);
 
       stateTransitionFixture = documentFactory.createStateTransition({
         create: [mediumSecurityDocumentFixture, masterSecurityDocumentFixture],
@@ -88,7 +92,7 @@ describe('DocumentBatchTransition', () => {
 
       // Should be the highest security level out of MEDIUM and MASTER
       expect(stateTransitionFixture.getKeySecurityLevelRequirement())
-        .to.be.equal(IdentityPublicKey.SECURITY_LEVELS.MASTER);
+        .to.deep.equal([IdentityPublicKey.SECURITY_LEVELS.MASTER]);
     });
 
     it('should return default security level if no document has a security level defined - Rust', () => {
@@ -100,7 +104,10 @@ describe('DocumentBatchTransition', () => {
 
       // Should be the default level, which is HIGH
       expect(stateTransitionFixture.getKeySecurityLevelRequirement())
-        .to.be.equal(IdentityPublicKey.SECURITY_LEVELS.HIGH);
+        .to.deep.equal([
+          IdentityPublicKey.SECURITY_LEVELS.CRITICAL,
+          IdentityPublicKey.SECURITY_LEVELS.HIGH,
+        ]);
     });
   });
 });

package/test/integration/identity/stateTransition/IdentityUpdateTransition/validation/state/validateIdentityUpdateTransitionStateFactory.spec.js

@@ -63,8 +63,9 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
     stateRepositoryMock.fetchLatestPlatformBlockTime = this.sinonSandbox.stub();
     stateRepositoryMock.fetchLatestPlatformBlockTime.resolves(blockTime);
 
+    executionContext = new StateTransitionExecutionContext();
     const validator = new IdentityUpdateTransitionStateValidator(stateRepositoryMock, blsAdapter);
-    validateIdentityUpdateTransitionState = (st) => validator.validate(st);
+    validateIdentityUpdateTransitionState = (st) => validator.validate(st, executionContext);
 
     stateTransition = await getIdentityUpdateTransitionFixture();
 
@@ -72,10 +73,6 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
     stateTransition.setPublicKeyIdsToDisable(undefined);
     stateTransition.setPublicKeysDisabledAt(undefined);
 
-    executionContext = new StateTransitionExecutionContext();
-
-    stateTransition.setExecutionContext(executionContext);
-
     const privateKey = '9b67f852093bc61cea0eeca38599dbfba0de28574d2ed9b99d10d33dc1bde7b2';
 
     await stateTransition.signByPrivateKey(
@@ -275,10 +272,10 @@ describe('validateIdentityUpdateTransitionStateFactory', () => {
     // Make code that executes after dry run check to fail
     stateRepositoryMock.fetchLatestPlatformBlockTime.resolves({});
 
-    stateTransition.getExecutionContext().enableDryRun();
+    executionContext.enableDryRun();
     const result = await validateIdentityUpdateTransitionState(stateTransition);
 
-    stateTransition.getExecutionContext().disableDryRun();
+    executionContext.disableDryRun();
 
     expect(result.isValid()).to.be.true();