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

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_invalid_result_error.rs

@@ -3,6 +3,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::data_trigger::data_trigger_invalid_result_error::DataTriggerInvalidResultError;
 use dpp::consensus::ConsensusError;
+use dpp::identifier::Identifier;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DataTriggerInvalidResultError)]
@@ -42,8 +43,56 @@ impl DataTriggerInvalidResultErrorWasm {
     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()))
     }
 }
+
+#[wasm_bindgen(js_name=DataTriggerActionInvalidResultError)]
+pub struct DataTriggerActionInvalidResultErrorWasm {
+    data_contract_id: Identifier,
+    document_transition_id: Identifier,
+    owner_id: Option<Identifier>,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DataTriggerActionInvalidResultError)]
+impl DataTriggerActionInvalidResultErrorWasm {
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> Buffer {
+        Buffer::from_bytes(self.data_contract_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getDocumentTransitionId)]
+    pub fn document_transition_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_transition_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn owner_id(&self) -> Option<Buffer> {
+        let owner_id = self.owner_id.as_ref()?;
+        Some(Buffer::from_bytes(owner_id.as_bytes()))
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DataTriggerActionInvalidResultErrorWasm {
+    pub fn new(
+        data_contract_id: Identifier,
+        document_transition_id: Identifier,
+        owner_id: Option<Identifier>,
+        code: u32,
+    ) -> Self {
+        Self {
+            data_contract_id,
+            document_transition_id,
+            owner_id,
+            code,
+        }
+    }
+}

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

@@ -36,7 +36,7 @@ impl DocumentAlreadyPresentErrorWasm {
     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/document_not_found_error.rs

@@ -36,7 +36,7 @@ impl DocumentNotFoundErrorWasm {
     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/document_owner_id_mismatch_error.rs

@@ -46,7 +46,7 @@ impl DocumentOwnerIdMismatchErrorWasm {
     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/document_timestamp_window_violation_error.rs

@@ -24,7 +24,7 @@ impl DocumentTimestampWindowViolationErrorWasm {
 
     #[wasm_bindgen(js_name=getTimestampName)]
     pub fn timestamp_name(&self) -> String {
-        self.inner.timestamp_name().to_string()
+        self.inner.timestamp_name()
     }
 
     #[wasm_bindgen(js_name=getTimestamp)]
@@ -62,7 +62,7 @@ impl DocumentTimestampWindowViolationErrorWasm {
     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/document_timestamps_mismatch_error.rs

@@ -35,7 +35,7 @@ impl DocumentTimestampsMismatchErrorWasm {
     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/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::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<IdentityPublicKeyWithWitness>>;
+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<IdentityPublicKeyWithWitness> = 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<IdentityPublicKeyWithWitness>, JsValue>>()?;
+            .collect::<Result<Vec<IdentityPublicKeyInCreation>, 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

@@ -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_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/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,22 +14,21 @@ use crate::{
         ChainAssetLockProofWasm, InstantAssetLockProofWasm,
     },
     identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm,
-    state_transition::StateTransitionExecutionContextWasm,
     with_js_error,
 };
 
 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::IdentityPublicKeyWithWitness,
+        identity_public_key_transitions::IdentityPublicKeyInCreation,
     },
     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<IdentityPublicKeyInCreation>, 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<IdentityPublicKeyInCreation>, 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(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_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)]
@@ -319,16 +311,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::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<IdentityPublicKeyWithWitness>,
+    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::IdentityPublicKeyWithWitness;
+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(IdentityPublicKeyWithWitness);
+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 = IdentityPublicKeyWithWitness::from_json_object(value).with_js_error()?;
+        let pk = IdentityPublicKeyInCreation::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) -> IdentityPublicKeyInCreation {
         self.0
     }
 
-    pub fn inner(&self) -> &IdentityPublicKeyWithWitness {
+    pub fn inner(&self) -> &IdentityPublicKeyInCreation {
         &self.0
     }
 
-    pub fn inner_mut(&mut self) -> &mut IdentityPublicKeyWithWitness {
+    pub fn inner_mut(&mut self) -> &mut IdentityPublicKeyInCreation {
         &mut self.0
     }
 }
 
-impl From<IdentityPublicKeyWithWitness> for IdentityPublicKeyWithWitnessWasm {
-    fn from(v: IdentityPublicKeyWithWitness) -> 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(
-            IdentityPublicKeyWithWitness::from_raw_json_object(val).with_js_error()?,
+            IdentityPublicKeyInCreation::from_raw_json_object(val).with_js_error()?,
         ))
     }
 }
 
-impl From<IdentityPublicKeyWithWitnessWasm> for IdentityPublicKeyWithWitness {
+impl From<IdentityPublicKeyWithWitnessWasm> for IdentityPublicKeyInCreation {
     fn from(pk: IdentityPublicKeyWithWitnessWasm) -> Self {
         pk.0
     }