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

package/src/errors/consensus/state/document/duplicate_unique_index_error.rs

@@ -46,7 +46,7 @@ impl DuplicateUniqueIndexErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/document/invalid_document_revision_error.rs

@@ -42,7 +42,7 @@ impl InvalidDocumentRevisionErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/identity/duplicated_identity_public_key_id_state_error.rs

@@ -43,7 +43,7 @@ impl DuplicatedIdentityPublicKeyIdStateErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/identity/duplicated_identity_public_key_state_error.rs

@@ -40,7 +40,7 @@ impl DuplicatedIdentityPublicKeyStateErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/identity/identity_already_exists_error.rs

@@ -36,7 +36,7 @@ impl IdentityAlreadyExistsErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/identity/identity_public_key_disabled_at_window_violation_error.rs

@@ -51,7 +51,7 @@ impl IdentityPublicKeyDisabledAtWindowViolationErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/identity/identity_public_key_is_disabled_error.rs

@@ -37,7 +37,7 @@ impl IdentityPublicKeyIsDisabledErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/identity/identity_public_key_is_read_only_error.rs

@@ -42,7 +42,7 @@ impl IdentityPublicKeyIsReadOnlyErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/identity/invalid_identity_public_key_id_error.rs

@@ -37,7 +37,7 @@ impl InvalidIdentityPublicKeyIdErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/identity/invalid_identity_revision_error.rs

@@ -43,7 +43,7 @@ impl InvalidIdentityRevisionErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/identity/max_identity_public_key_limit_reached_error.rs

@@ -37,7 +37,7 @@ impl MaxIdentityPublicKeyLimitReachedErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/consensus/state/identity/missing_identity_public_key_ids_error.rs

@@ -0,0 +1,26 @@
+use dpp::consensus::state::identity::missing_identity_public_key_ids_error::MissingIdentityPublicKeyIdsError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=MissingIdentityPublicKeyIdsError)]
+pub struct MissingIdentityPublicKeyIdsErrorWasm {
+    inner: MissingIdentityPublicKeyIdsError,
+}
+
+impl From<&MissingIdentityPublicKeyIdsError> for MissingIdentityPublicKeyIdsErrorWasm {
+    fn from(e: &MissingIdentityPublicKeyIdsError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=MissingIdentityPublicKeyIdsError)]
+impl MissingIdentityPublicKeyIdsErrorWasm {
+    #[wasm_bindgen(js_name=getDuplicatedIds)]
+    pub fn duplicated_ids(&self) -> js_sys::Array {
+        // TODO: key ids probably should be u32
+        self.inner
+            .ids()
+            .iter()
+            .map(|id| JsValue::from(*id))
+            .collect()
+    }
+}

package/src/errors/consensus/state/identity/mod.rs

@@ -7,6 +7,7 @@ mod identity_public_key_is_read_only_error;
 mod invalid_identity_public_key_id_error;
 mod invalid_identity_revision_error;
 mod max_identity_public_key_limit_reached_error;
+mod missing_identity_public_key_ids_error;
 
 pub use duplicated_identity_public_key_id_state_error::*;
 pub use duplicated_identity_public_key_state_error::*;
@@ -17,3 +18,4 @@ pub use identity_public_key_is_read_only_error::*;
 pub use invalid_identity_public_key_id_error::*;
 pub use invalid_identity_revision_error::*;
 pub use max_identity_public_key_limit_reached_error::*;
+pub use missing_identity_public_key_ids_error::*;

package/src/errors/consensus/value_error.rs

@@ -37,7 +37,7 @@ impl ValueErrorWasm {
     pub fn serialize(&self) -> Result<Buffer, JsError> {
         let bytes = ConsensusError::from(self.inner.clone())
             .serialize()
-            .map_err(|e| JsError::from(e))?;
+            .map_err(JsError::from)?;
 
         Ok(Buffer::from_bytes(bytes.as_slice()))
     }

package/src/errors/from.rs

@@ -1,4 +1,3 @@
-use dpp::consensus::basic::value_error::ValueError;
 use dpp::DashPlatformProtocolInitError;
 use wasm_bindgen::JsValue;
 

package/src/generate_temporary_ecdsa_private_key.rs

@@ -1,10 +1,6 @@
-use crate::buffer::Buffer;
 use dpp::dashcore::secp256k1::rand::thread_rng;
-use dpp::dashcore::secp256k1::Secp256k1;
-use dpp::dashcore::{
-    secp256k1::SecretKey, InstantLock, Network, OutPoint, PrivateKey, Script, Transaction, TxIn,
-    TxOut, Txid,
-};
+
+use dpp::dashcore::{secp256k1::SecretKey, Network, PrivateKey};
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;
 

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::IdentityPublicKeyWithWitness;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
 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<IdentityPublicKeyWithWitness>>;
+type AddPublicKeys = Option<Vec<IdentityPublicKeyInCreationWithWitness>>;
 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<IdentityPublicKeyWithWitness> = add_public_keys_array
+        let keys: Vec<IdentityPublicKeyInCreationWithWitness> = 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<IdentityPublicKeyWithWitness>, JsValue>>()?;
+            .collect::<Result<Vec<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
 
         add_public_keys = Some(keys)
     }

package/src/identity/identity_public_key/key_type.rs

@@ -8,6 +8,7 @@ pub enum KeyTypeWasm {
     BLS12_381 = 1,
     ECDSA_HASH160 = 2,
     BIP13_SCRIPT_HASH = 3,
+    EDDSA_25519_HASH160 = 4,
 }
 
 impl From<KeyType> for KeyTypeWasm {
@@ -17,6 +18,7 @@ impl From<KeyType> for KeyTypeWasm {
             KeyType::BLS12_381 => Self::BLS12_381,
             KeyType::ECDSA_HASH160 => Self::ECDSA_HASH160,
             KeyType::BIP13_SCRIPT_HASH => Self::BIP13_SCRIPT_HASH,
+            KeyType::EDDSA_25519_HASH160 => Self::EDDSA_25519_HASH160,
         }
     }
 }

package/src/identity/identity_public_key/purpose.rs

@@ -9,7 +9,12 @@ pub enum PurposeWasm {
     ENCRYPTION = 1,
     /// this key cannot be used for signing documents
     DECRYPTION = 2,
+    /// this key cannot be used for signing documents
     WITHDRAW = 3,
+    /// this key cannot be used for signing documents
+    SYSTEM = 4,
+    /// this key cannot be used for signing documents
+    VOTING = 5,
 }
 
 impl From<Purpose> for PurposeWasm {
@@ -19,6 +24,8 @@ impl From<Purpose> for PurposeWasm {
             Purpose::ENCRYPTION => PurposeWasm::ENCRYPTION,
             Purpose::DECRYPTION => PurposeWasm::DECRYPTION,
             Purpose::WITHDRAW => PurposeWasm::WITHDRAW,
+            Purpose::SYSTEM => PurposeWasm::SYSTEM,
+            Purpose::VOTING => PurposeWasm::VOTING,
         }
     }
 }

package/src/identity/mod.rs

@@ -213,7 +213,7 @@ impl IdentityWasm {
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Vec<u8> {
-        self.0.to_buffer().unwrap()
+        self.0.to_cbor_buffer().unwrap()
     }
 
     #[wasm_bindgen]

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

@@ -4,13 +4,14 @@ use wasm_bindgen::prelude::*;
 
 use crate::{
     state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
-    IdentityCreateTransitionWasm,
+    IdentityCreateTransitionWasm, StateTransitionExecutionContextWasm,
 };
 
 #[wasm_bindgen(js_name=applyIdentityCreateTransition)]
 pub async fn apply_identity_create_transition_wasm(
     state_repository: ExternalStateRepositoryLike,
     state_transition: &IdentityCreateTransitionWasm,
+    execution_context: &StateTransitionExecutionContextWasm,
 ) -> Result<(), JsValue> {
     let wrapped_state_repository =
         Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
@@ -18,7 +19,10 @@ pub async fn apply_identity_create_transition_wasm(
     let instance = ApplyIdentityCreateTransition::new(wrapped_state_repository);
 
     instance
-        .apply_identity_create_transition(&state_transition.to_owned().into())
+        .apply_identity_create_transition(
+            &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_create_transition/identity_create_transition.rs

@@ -14,7 +14,6 @@ use crate::{
         ChainAssetLockProofWasm, InstantAssetLockProofWasm,
     },
     identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm,
-    state_transition::StateTransitionExecutionContextWasm,
     with_js_error,
 };
 
@@ -29,7 +28,7 @@ use dpp::platform_value::{string_encoding, BinaryData};
 use dpp::{
     identity::state_transition::{
         asset_lock_proof::AssetLockProof, identity_create_transition::IdentityCreateTransition,
-        identity_public_key_transitions::IdentityPublicKeyWithWitness,
+        identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness,
     },
     state_transition::StateTransitionLike,
 };
@@ -56,8 +55,9 @@ impl IdentityCreateTransitionWasm {
     pub fn new(raw_parameters: JsValue) -> Result<IdentityCreateTransitionWasm, JsValue> {
         let mut raw_state_transition = raw_parameters.with_serde_to_platform_value()?;
         IdentityCreateTransition::clean_value(&mut raw_state_transition).with_js_error()?;
-        let identity_create_transition = IdentityCreateTransition::new(raw_state_transition)
-            .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
+        let identity_create_transition =
+            IdentityCreateTransition::from_raw_object(raw_state_transition)
+                .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
 
         Ok(identity_create_transition.into())
     }
@@ -104,7 +104,7 @@ impl IdentityCreateTransitionWasm {
                     )?;
                 Ok(public_key.clone().into())
             })
-            .collect::<Result<Vec<IdentityPublicKeyWithWitness>, JsValue>>()?;
+            .collect::<Result<Vec<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
 
         self.0.set_public_keys(public_keys);
 
@@ -123,7 +123,7 @@ impl IdentityCreateTransitionWasm {
                     )?;
                 Ok(public_key.clone().into())
             })
-            .collect::<Result<Vec<IdentityPublicKeyWithWitness>, JsValue>>()?;
+            .collect::<Result<Vec<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
 
         self.0.add_public_keys(&mut public_keys);
 
@@ -135,7 +135,7 @@ impl IdentityCreateTransitionWasm {
         self.0
             .get_public_keys()
             .iter()
-            .map(IdentityPublicKeyWithWitness::to_owned)
+            .map(IdentityPublicKeyInCreationWithWitness::to_owned)
             .map(IdentityPublicKeyWithWitnessWasm::from)
             .map(JsValue::from)
             .collect()
@@ -237,7 +237,7 @@ impl IdentityCreateTransitionWasm {
 
         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())
@@ -319,16 +319,6 @@ impl IdentityCreateTransitionWasm {
         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_create_transition/identity_create_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::IdentityCreateTransitionWasm;
+use crate::{IdentityCreateTransitionWasm, StateTransitionExecutionContextWasm};
 use dpp::identity::state_transition::identity_create_transition::validation::state::validate_identity_create_transition_state;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsValue;
@@ -24,10 +24,12 @@ impl IdentityCreateTransitionStateValidator {
     pub async fn validate(
         &self,
         state_transition: &IdentityCreateTransitionWasm,
+        execution_context: &StateTransitionExecutionContextWasm,
     ) -> Result<ValidationResultWasm, JsValue> {
         let validation_result = validate_identity_create_transition_state(
             &self.state_repository,
             &state_transition.to_owned().into(),
+            &execution_context.to_owned().into(),
         )
         .await
         .map_err(from_dpp_err)?;

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::IdentityPublicKeyWithWitness;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
 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<IdentityPublicKeyWithWitness>,
+    pub public_keys: Vec<IdentityPublicKeyInCreationWithWitness>,
     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::IdentityPublicKeyWithWitness;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
 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(IdentityPublicKeyWithWitness);
+pub struct IdentityPublicKeyWithWitnessWasm(IdentityPublicKeyInCreationWithWitness);
 
 #[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 = IdentityPublicKeyWithWitness::from_json_object(value).with_js_error()?;
+        let pk = IdentityPublicKeyInCreationWithWitness::from_json_object(value).with_js_error()?;
 
         Ok(IdentityPublicKeyWithWitnessWasm(pk))
     }
@@ -116,7 +116,7 @@ impl IdentityPublicKeyWithWitnessWasm {
 
     #[wasm_bindgen(js_name=hash)]
     pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
-        self.0.hash().with_js_error()
+        self.0.hash_as_vec().with_js_error()
     }
 
     #[wasm_bindgen(js_name=isMaster)]
@@ -174,21 +174,21 @@ impl IdentityPublicKeyWithWitnessWasm {
 }
 
 impl IdentityPublicKeyWithWitnessWasm {
-    pub fn into_inner(self) -> IdentityPublicKeyWithWitness {
+    pub fn into_inner(self) -> IdentityPublicKeyInCreationWithWitness {
         self.0
     }
 
-    pub fn inner(&self) -> &IdentityPublicKeyWithWitness {
+    pub fn inner(&self) -> &IdentityPublicKeyInCreationWithWitness {
         &self.0
     }
 
-    pub fn inner_mut(&mut self) -> &mut IdentityPublicKeyWithWitness {
+    pub fn inner_mut(&mut self) -> &mut IdentityPublicKeyInCreationWithWitness {
         &mut self.0
     }
 }
 
-impl From<IdentityPublicKeyWithWitness> for IdentityPublicKeyWithWitnessWasm {
-    fn from(v: IdentityPublicKeyWithWitness) -> Self {
+impl From<IdentityPublicKeyInCreationWithWitness> for IdentityPublicKeyWithWitnessWasm {
+    fn from(v: IdentityPublicKeyInCreationWithWitness) -> 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(
-            IdentityPublicKeyWithWitness::from_raw_json_object(val).with_js_error()?,
+            IdentityPublicKeyInCreationWithWitness::from_raw_json_object(val).with_js_error()?,
         ))
     }
 }
 
-impl From<IdentityPublicKeyWithWitnessWasm> for IdentityPublicKeyWithWitness {
+impl From<IdentityPublicKeyWithWitnessWasm> for IdentityPublicKeyInCreationWithWitness {
     fn from(pk: IdentityPublicKeyWithWitnessWasm) -> Self {
         pk.0
     }

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,7 +14,6 @@ use crate::{
     identity::state_transition::asset_lock_proof::{
         ChainAssetLockProofWasm, InstantAssetLockProofWasm,
     },
-    state_transition::StateTransitionExecutionContextWasm,
     with_js_error,
 };
 
@@ -179,7 +178,7 @@ impl IdentityTopUpTransitionWasm {
 
         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())
@@ -262,16 +261,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::IdentityPublicKeyInCreationWithWitness;
 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: IdentityPublicKeyInCreationWithWitness =
                     IdentityPublicKeyWithWitnessWasm::new(raw_key)?.into();
 
                 parsed_key.to_raw_object(false).with_js_error()