feat(wasm-dpp): integration tests validate data contract update transition

packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs

@@ -1,4 +1,4 @@
-use std::convert::TryInto;
+use std::convert::{TryFrom, TryInto};
 
 use anyhow::anyhow;
 use anyhow::Context;
@@ -7,7 +7,6 @@ use lazy_static::lazy_static;
 use serde_json::{json, Value as JsonValue};
 use std::sync::Arc;
 
-use crate::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
 use crate::{
     consensus::basic::BasicError,
     data_contract::{
@@ -21,6 +20,10 @@ use crate::{
     version::ProtocolVersionValidator,
     DashPlatformProtocolInitError, ProtocolError,
 };
+use crate::{
+    consensus::ConsensusError,
+    state_transition::state_transition_execution_context::StateTransitionExecutionContext,
+};
 
 use super::schema_compatibility_validator::validate_schema_compatibility;
 use super::schema_compatibility_validator::DiffVAlidatorError;
@@ -73,9 +76,18 @@ where
             return Ok(result);
         }
 
-        let protocol_version = raw_state_transition
+        let protocol_version = match raw_state_transition
             .get_u64(property_names::PROTOCOL_VERSION)
-            .with_context(|| "invalid protocol version")? as u32;
+            .and_then(|x| u32::try_from(x).map_err(Into::into))
+        {
+            Ok(v) => v,
+            Err(parsing_error) => {
+                return Ok(SimpleValidationResult::new(Some(vec![
+                    ConsensusError::ProtocolVersionParsingError { parsing_error },
+                ])))
+            }
+        };
+
         let result = self.protocol_version_validator.validate(protocol_version)?;
         if !result.is_valid() {
             return Ok(result);
@@ -123,7 +135,10 @@ where
         let raw_existing_data_contract = existing_data_contract.to_object(false)?;
 
         let mut old_base_data_contract = raw_existing_data_contract;
-        old_base_data_contract.remove(contract_property_names::DEFINITIONS)?;
+
+        old_base_data_contract
+            .remove(contract_property_names::DEFINITIONS)
+            .ok();
         old_base_data_contract.remove(contract_property_names::DOCUMENTS)?;
         old_base_data_contract.remove(contract_property_names::VERSION)?;
 
@@ -136,7 +151,9 @@ where
         )?;
 
         let mut new_base_data_contract = raw_data_contract.clone();
-        new_base_data_contract.remove(contract_property_names::DEFINITIONS)?;
+        new_base_data_contract
+            .remove(contract_property_names::DEFINITIONS)
+            .ok();
         new_base_data_contract.remove(contract_property_names::DOCUMENTS)?;
         new_base_data_contract.remove(contract_property_names::VERSION)?;
 
@@ -162,19 +179,6 @@ where
             return Ok(validation_result);
         }
 
-        // check indices are not changes
-        let new_documents = raw_data_contract
-            .get_value("documents")?
-            .as_object()
-            .ok_or_else(|| anyhow!("the 'documents' property is not an array"))?;
-        let result = validate_indices_are_backward_compatible(
-            existing_data_contract.documents(),
-            new_documents,
-        )?;
-        if !result.is_valid() {
-            return Ok(result);
-        }
-
         // Schema should be backward compatible
         let old_schema = existing_data_contract.documents();
         let new_schema = raw_data_contract.get_value("documents")?;
@@ -201,6 +205,23 @@ where
             }
         }
 
+        if !validation_result.is_valid() {
+            return Ok(validation_result);
+        }
+
+        // check indices are not changed
+        let new_documents = raw_data_contract
+            .get_value("documents")?
+            .as_object()
+            .ok_or_else(|| anyhow!("the 'documents' property is not an array"))?;
+        let result = validate_indices_are_backward_compatible(
+            existing_data_contract.documents(),
+            new_documents,
+        )?;
+        if !result.is_valid() {
+            return Ok(result);
+        }
+
         Ok(validation_result)
     }
 }

packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic_spec.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use test_case::test_case;
 
 use crate::{
-    consensus::basic::BasicError,
+    consensus::{basic::BasicError, ConsensusError},
     data_contract::state_transition::{
         data_contract_update_transition::validation::basic::DataContractUpdateTransitionBasicValidator,
         property_names, DataContractUpdateTransition,
@@ -143,8 +143,12 @@ async fn protocol_version_should_be_valid() {
     let result = validator
         .validate(&raw_state_transition, &Default::default())
         .await
-        .expect_err("err should be returned");
-    assert_eq!("invalid protocol version", result.to_string())
+        .expect("validation result should be returned");
+
+    assert!(matches!(
+        result.errors.iter().next(),
+        Some(ConsensusError::ProtocolVersionParsingError { .. })
+    ));
 }
 
 #[tokio::test]

packages/wasm-dpp/src/data_contract/state_transition/data_contract_update_transition/mod.rs

@@ -1,6 +1,8 @@
 mod apply;
 mod validation;
 
+use std::collections::HashMap;
+
 pub use apply::*;
 pub use validation::*;
 
@@ -15,8 +17,10 @@ use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
 use crate::{
-    buffer::Buffer, errors::from_dpp_err, identifier::IdentifierWrapper, with_js_error,
-    DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
+    buffer::Buffer,
+    errors::{from_dpp_err, protocol_error::from_protocol_error},
+    identifier::IdentifierWrapper,
+    with_js_error, DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
 };
 
 #[derive(Clone)]
@@ -38,15 +42,14 @@ impl From<DataContractUpdateTransitionWasm> for DataContractUpdateTransition {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct DataContractUpdateTransitionParameters {
-    protocol_version: u32,
     #[serde(skip_serializing_if = "Option::is_none", default)]
     data_contract: Option<DataContractParameters>,
     #[serde(skip_serializing_if = "Option::is_none", default)]
     entropy: Option<Vec<u8>>,
     #[serde(skip_serializing_if = "Option::is_none", default)]
-    signature_public_key_id: Option<KeyID>,
-    #[serde(skip_serializing_if = "Option::is_none", default)]
     signature: Option<Vec<u8>>,
+    #[serde(flatten)]
+    extra: HashMap<String, serde_json::Value>,
 }
 
 #[wasm_bindgen(js_class=DataContractUpdateTransition)]
@@ -144,4 +147,15 @@ impl DataContractUpdateTransitionWasm {
             .map_err(from_dpp_err)?;
         Ok(Buffer::from_bytes(&bytes))
     }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, skip_signature: Option<bool>) -> Result<JsValue, JsValue> {
+        let serde_object = self
+            .0
+            .to_object(skip_signature.unwrap_or(false))
+            .map_err(from_protocol_error)?;
+        serde_object
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .map_err(|e| e.into())
+    }
 }

packages/wasm-dpp/src/data_contract/state_transition/data_contract_update_transition/validation.rs

@@ -1,16 +1,23 @@
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, sync::Arc};
 
-use dpp::data_contract::state_transition::data_contract_update_transition::validation::{
-    basic::validate_indices_are_backward_compatible as dpp_validate_indices_are_backward_compatible,
-    state::validate_data_contract_update_transition_state::validate_data_contract_update_transition_state as dpp_validate_data_contract_update_transition_state,
+use dpp::{
+    data_contract::state_transition::data_contract_update_transition::validation::{
+        basic::{
+            validate_indices_are_backward_compatible as dpp_validate_indices_are_backward_compatible,
+            DataContractUpdateTransitionBasicValidator,
+        },
+        state::validate_data_contract_update_transition_state::validate_data_contract_update_transition_state as dpp_validate_data_contract_update_transition_state,
+    },
+    version::ProtocolVersionValidator,
 };
 use wasm_bindgen::prelude::*;
 
 use crate::{
+    data_contract::state_transition::data_contract_update_transition::DataContractUpdateTransitionParameters,
     errors::{from_dpp_err, protocol_error::from_protocol_error},
     state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
     validation::ValidationResultWasm,
-    DataContractUpdateTransitionWasm,
+    DataContractUpdateTransitionWasm, StateTransitionExecutionContextWasm,
 };
 
 #[wasm_bindgen(js_name=validateDataContractUpdateTransitionState)]
@@ -47,3 +54,28 @@ pub fn validate_indices_are_backward_compatible(
 
     Ok(result.map(|_| JsValue::undefined()).into())
 }
+
+#[wasm_bindgen(js_name=validateDataContractUpdateTransitionBasic)]
+pub async fn validate_data_contract_update_transition_basic(
+    state_repository: ExternalStateRepositoryLike,
+    raw_parameters: JsValue,
+    execution_context: &StateTransitionExecutionContextWasm,
+) -> Result<ValidationResultWasm, JsError> {
+    let parameters: DataContractUpdateTransitionParameters =
+        serde_wasm_bindgen::from_value(raw_parameters)?;
+
+    let validator: DataContractUpdateTransitionBasicValidator<ExternalStateRepositoryLikeWrapper> =
+        DataContractUpdateTransitionBasicValidator::new(
+            Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository)),
+            Arc::new(ProtocolVersionValidator::default()),
+        )?;
+
+    let validation_result = validator
+        .validate(
+            &serde_json::to_value(&parameters)?,
+            &execution_context.into(),
+        )
+        .await?;
+
+    Ok(validation_result.map(|_| JsValue::undefined()).into())
+}