feat(wasm-dpp): state transition facade

packages/rs-dpp/src/data_contract/data_contract.rs

@@ -270,6 +270,10 @@ impl DataContract {
         self.entropy
     }
 
+    pub fn set_entropy(&mut self, entropy: [u8; 32]) {
+        self.entropy = entropy;
+    }
+
     pub fn owner_id(&self) -> &Identifier {
         &self.owner_id
     }

packages/rs-dpp/src/data_contract/data_contract_factory.rs

@@ -100,7 +100,9 @@ impl DataContractFactory {
 
         let cbor = value_to_cbor(JsonValue::Object(root_map), Some(1))?;
 
-        DataContract::from_cbor(cbor)
+        let mut data_contract = DataContract::from_cbor(cbor)?;
+        data_contract.set_entropy(entropy);
+        Ok(data_contract)
     }
 
     /// Create Data Contract from plain object

packages/rs-dpp/src/document/state_transition/documents_batch_transition/mod.rs

@@ -243,7 +243,10 @@ impl StateTransitionConvert for DocumentsBatchTransition {
     }
 
     fn signature_property_paths() -> Vec<&'static str> {
-        vec![property_names::SIGNATURE]
+        vec![
+            property_names::SIGNATURE,
+            property_names::SIGNATURE_PUBLIC_KEY_ID,
+        ]
     }
 
     fn to_json(&self, skip_signature: bool) -> Result<JsonValue, ProtocolError> {

packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_batch_transition_state.rs

@@ -1,9 +1,11 @@
 use std::convert::TryInto;
 
+use async_trait::async_trait;
 use futures::future::join_all;
 use itertools::Itertools;
 
 use crate::data_contract::errors::DataContractNotPresentError;
+use crate::validation::{AsyncDataValidator, SimpleValidationResult};
 use crate::{
     block_time_window::validate_time_in_block_time_window::validate_time_in_block_time_window,
     consensus::ConsensusError,
@@ -27,6 +29,40 @@ use super::{
     validate_documents_uniqueness_by_indices::validate_documents_uniqueness_by_indices,
 };
 
+pub struct DocumentsBatchTransitionStateValidator<SR>
+where
+    SR: StateRepositoryLike,
+{
+    state_repository: SR,
+}
+
+#[async_trait(?Send)]
+impl<SR> AsyncDataValidator for DocumentsBatchTransitionStateValidator<SR>
+where
+    SR: StateRepositoryLike,
+{
+    type Item = DocumentsBatchTransition;
+
+    async fn validate(
+        &self,
+        data: &DocumentsBatchTransition,
+    ) -> Result<SimpleValidationResult, ProtocolError> {
+        validate_document_batch_transition_state(&self.state_repository, data).await
+    }
+}
+
+impl<SR> DocumentsBatchTransitionStateValidator<SR>
+where
+    SR: StateRepositoryLike,
+{
+    pub fn new(state_repository: SR) -> DocumentsBatchTransitionStateValidator<SR>
+    where
+        SR: StateRepositoryLike,
+    {
+        DocumentsBatchTransitionStateValidator { state_repository }
+    }
+}
+
 pub async fn validate_document_batch_transition_state(
     state_repository: &impl StateRepositoryLike,
     state_transition: &DocumentsBatchTransition,

packages/rs-dpp/src/errors/errors.rs

@@ -13,7 +13,10 @@ use crate::state_transition::errors::{
     PublicKeySecurityLevelNotMetError, StateTransitionError, StateTransitionIsNotSignedError,
     WrongPublicKeyPurposeError,
 };
-use crate::{CompatibleProtocolVersionIsNotDefinedError, NonConsensusError, SerdeParsingError};
+use crate::{
+    CompatibleProtocolVersionIsNotDefinedError, DashPlatformProtocolInitError, NonConsensusError,
+    SerdeParsingError,
+};
 use platform_value::Error as ValueError;
 
 #[derive(Error, Debug)]
@@ -170,3 +173,9 @@ impl From<SerdeParsingError> for ProtocolError {
         ProtocolError::ParsingError(e.to_string())
     }
 }
+
+impl From<DashPlatformProtocolInitError> for ProtocolError {
+    fn from(e: DashPlatformProtocolInitError) -> Self {
+        ProtocolError::Generic(e.to_string())
+    }
+}

packages/rs-dpp/src/identity/state_transition/identity_create_transition/validation/state/mod.rs

@@ -2,8 +2,45 @@ use crate::consensus::state::identity::IdentityAlreadyExistsError;
 use crate::identity::state_transition::identity_create_transition::IdentityCreateTransition;
 use crate::state_repository::StateRepositoryLike;
 use crate::state_transition::StateTransitionLike;
-use crate::validation::ValidationResult;
-use crate::NonConsensusError;
+use crate::validation::{AsyncDataValidator, SimpleValidationResult, ValidationResult};
+use crate::{NonConsensusError, ProtocolError};
+use async_trait::async_trait;
+
+pub struct IdentityCreateTransitionStateValidator<SR>
+where
+    SR: StateRepositoryLike,
+{
+    state_repository: SR,
+}
+
+#[async_trait(?Send)]
+impl<SR> AsyncDataValidator for IdentityCreateTransitionStateValidator<SR>
+where
+    SR: StateRepositoryLike,
+{
+    type Item = IdentityCreateTransition;
+
+    async fn validate(
+        &self,
+        data: &IdentityCreateTransition,
+    ) -> Result<SimpleValidationResult, ProtocolError> {
+        validate_identity_create_transition_state(&self.state_repository, data)
+            .await
+            .map_err(|err| err.into())
+    }
+}
+
+impl<SR> IdentityCreateTransitionStateValidator<SR>
+where
+    SR: StateRepositoryLike,
+{
+    pub fn new(state_repository: SR) -> IdentityCreateTransitionStateValidator<SR>
+    where
+        SR: StateRepositoryLike,
+    {
+        IdentityCreateTransitionStateValidator { state_repository }
+    }
+}
 
 /// Validate that identity exists
 ///
@@ -14,8 +51,9 @@ use crate::NonConsensusError;
 /// 2. Verify ownership proof signature, as it requires special transaction to be implemented
 pub async fn validate_identity_create_transition_state(
     state_repository: &impl StateRepositoryLike,
-    state_transition: IdentityCreateTransition,
+    state_transition: &IdentityCreateTransition,
 ) -> Result<ValidationResult<()>, NonConsensusError> {
+    // TODO: refactor to return ProtocolError?
     let mut result = ValidationResult::default();
 
     let identity_id = state_transition.get_identity_id();
@@ -56,7 +94,8 @@ mod test {
             .expect_fetch_identity_balance()
             .return_once(|_, _| Ok(Some(1)));
 
-        let result = validate_identity_create_transition_state(&state_repository, transition).await;
+        let result =
+            validate_identity_create_transition_state(&state_repository, &transition).await;
         assert!(result.is_ok());
     }
 }

packages/rs-dpp/src/identity/state_transition/identity_topup_transition/validation/state/mod.rs

@@ -1,7 +1,45 @@
 use crate::identity::state_transition::identity_topup_transition::IdentityTopUpTransition;
 use crate::state_repository::StateRepositoryLike;
-use crate::validation::ValidationResult;
-use crate::NonConsensusError;
+use crate::validation::{AsyncDataValidator, SimpleValidationResult, ValidationResult};
+use crate::{NonConsensusError, ProtocolError};
+use async_trait::async_trait;
+
+pub struct IdentityTopUpTransitionStateValidator<SR>
+where
+    SR: StateRepositoryLike,
+{
+    state_repository: SR,
+}
+
+#[async_trait(?Send)]
+impl<SR> AsyncDataValidator for IdentityTopUpTransitionStateValidator<SR>
+where
+    SR: StateRepositoryLike,
+{
+    type Item = IdentityTopUpTransition;
+
+    async fn validate(
+        &self,
+        data: &IdentityTopUpTransition,
+    ) -> Result<SimpleValidationResult, ProtocolError> {
+        validate_identity_topup_transition_state(data, &self.state_repository)
+            .await
+            .map(|result| result.into())
+            .map_err(|err| err.into())
+    }
+}
+
+impl<SR> IdentityTopUpTransitionStateValidator<SR>
+where
+    SR: StateRepositoryLike,
+{
+    pub fn new(state_repository: SR) -> IdentityTopUpTransitionStateValidator<SR>
+    where
+        SR: StateRepositoryLike,
+    {
+        IdentityTopUpTransitionStateValidator { state_repository }
+    }
+}
 
 /// Validate that identity exists
 ///
@@ -11,7 +49,7 @@ use crate::NonConsensusError;
 /// 1. We need to check that outpoint exists (not now)
 /// 2. Verify ownership proof signature, as it requires special transaction to be implemented
 pub async fn validate_identity_topup_transition_state(
-    _state_transition: IdentityTopUpTransition,
+    _state_transition: &IdentityTopUpTransition,
     _state_repository: &impl StateRepositoryLike,
 ) -> Result<ValidationResult<()>, NonConsensusError> {
     Ok(ValidationResult::default())

packages/rs-dpp/src/identity/state_transition/identity_update_transition/identity_update_transition.rs

@@ -241,7 +241,10 @@ impl StateTransitionConvert for IdentityUpdateTransition {
     }
 
     fn signature_property_paths() -> Vec<&'static str> {
-        vec![property_names::SIGNATURE]
+        vec![
+            property_names::SIGNATURE,
+            property_names::SIGNATURE_PUBLIC_KEY_ID,
+        ]
     }
 
     fn to_object(&self, skip_signature: bool) -> Result<JsonValue, ProtocolError> {

packages/rs-dpp/src/state_transition/abstract_state_transition.rs

@@ -4,6 +4,8 @@ use dashcore::signer;
 use serde::Serialize;
 use serde_json::Value as JsonValue;
 
+use crate::consensus::ConsensusError;
+use crate::errors::consensus::signature::SignatureError;
 use crate::state_transition::errors::{
     InvalidIdentityPublicKeyTypeError, StateTransitionIsNotSignedError,
 };
@@ -118,11 +120,13 @@ pub trait StateTransitionLike:
             ));
         }
         let data_hash = self.hash(true)?;
-        Ok(signer::verify_hash_signature(
-            &data_hash,
-            self.get_signature(),
-            public_key_hash,
-        )?)
+        signer::verify_hash_signature(&data_hash, self.get_signature(), public_key_hash).or_else(
+            |_| {
+                Err(ProtocolError::from(ConsensusError::SignatureError(
+                    SignatureError::InvalidStateTransitionSignatureError,
+                )))
+            },
+        )
     }
 
     /// Verifies an ECDSA signature with the public key
@@ -133,11 +137,12 @@ pub trait StateTransitionLike:
             ));
         }
         let data = self.to_buffer(true)?;
-        Ok(signer::verify_data_signature(
-            &data,
-            self.get_signature(),
-            public_key,
-        )?)
+
+        signer::verify_data_signature(&data, self.get_signature(), public_key).or_else(|_| {
+            Err(ProtocolError::from(ConsensusError::SignatureError(
+                SignatureError::InvalidStateTransitionSignatureError,
+            )))
+        })
     }
 
     /// Verifies a BLS signature with the public key
@@ -156,6 +161,11 @@ pub trait StateTransitionLike:
 
         bls.verify_signature(self.get_signature(), &data, public_key)
             .map(|_| ())
+            .or_else(|_| {
+                Err(ProtocolError::from(ConsensusError::SignatureError(
+                    SignatureError::InvalidStateTransitionSignatureError,
+                )))
+            })
     }
 
     /// returns true if state transition is a document state transition

packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs

@@ -77,7 +77,11 @@ where
             KeyType::BIP13_SCRIPT_HASH => Err(ProtocolError::InvalidIdentityPublicKeyTypeError(
                 InvalidIdentityPublicKeyTypeError::new(identity_public_key.key_type),
             )),
-        }
+        }?;
+
+        self.set_signature_public_key_id(identity_public_key.id);
+
+        Ok(())
     }
 
     fn verify_signature(

packages/rs-dpp/src/state_transition/mod.rs

@@ -17,7 +17,9 @@ use crate::identity::state_transition::identity_update_transition::identity_upda
 
 mod abstract_state_transition;
 mod abstract_state_transition_identity_signed;
+mod state_transition_facade;
 mod state_transition_factory;
+pub use state_transition_facade::*;
 pub use state_transition_factory::*;
 
 use self::state_transition_execution_context::StateTransitionExecutionContext;