refactor(rs-dpp): bring error type to one format

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

@@ -10,6 +10,7 @@ use platform_value::Value;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
 
+use crate::consensus::basic::document::InvalidDocumentTypeError;
 use crate::data_contract::contract_config;
 use crate::data_contract::contract_config::{
     ContractConfig, DEFAULT_CONTRACT_CAN_BE_DELETED, DEFAULT_CONTRACT_DOCUMENTS_KEEPS_HISTORY,
@@ -18,7 +19,7 @@ use crate::data_contract::contract_config::{
 };
 
 use crate::data_contract::get_binary_properties_from_schema::get_binary_properties;
-use crate::util::cbor_value::{CborBTreeMapHelper, CborCanonicalMap};
+use crate::util::cbor_value::CborCanonicalMap;
 use crate::util::deserializer;
 use crate::util::deserializer::SplitProtocolVersionOutcome;
 use crate::util::json_value::{JsonValueExt, ReplaceWith};
@@ -319,21 +320,21 @@ impl DataContract {
             .documents
             .get(doc_type)
             .ok_or(ProtocolError::DataContractError(
-                DataContractError::InvalidDocumentTypeError {
-                    doc_type: doc_type.to_owned(),
-                    data_contract: self.clone(),
-                },
+                DataContractError::InvalidDocumentTypeError(InvalidDocumentTypeError::new(
+                    doc_type.to_owned(),
+                    self.id.clone(),
+                )),
             ))?;
         Ok(document)
     }
 
     pub fn get_document_schema_ref(&self, doc_type: &str) -> Result<String, ProtocolError> {
         if !self.is_document_defined(doc_type) {
             return Err(ProtocolError::DataContractError(
-                DataContractError::InvalidDocumentTypeError {
-                    doc_type: doc_type.to_owned(),
-                    data_contract: self.clone(),
-                },
+                DataContractError::InvalidDocumentTypeError(InvalidDocumentTypeError::new(
+                    doc_type.to_owned(),
+                    self.id.clone(),
+                )),
             ));
         };
 
@@ -354,10 +355,10 @@ impl DataContract {
     ) -> Result<&BTreeMap<String, JsonValue>, ProtocolError> {
         self.get_optional_binary_properties(doc_type)?
             .ok_or(ProtocolError::DataContractError(
-                DataContractError::InvalidDocumentTypeError {
-                    doc_type: doc_type.to_owned(),
-                    data_contract: self.clone(),
-                },
+                DataContractError::InvalidDocumentTypeError(InvalidDocumentTypeError::new(
+                    doc_type.to_owned(),
+                    self.id.clone(),
+                )),
             ))
     }
 

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

@@ -4,6 +4,7 @@ use std::sync::Arc;
 
 use data_contract::state_transition::property_names as st_prop;
 
+use crate::data_contract::errors::InvalidDataContractError;
 use crate::data_contract::property_names;
 use crate::util::serializer::value_to_cbor;
 use crate::{
@@ -114,10 +115,9 @@ impl DataContractFactory {
             let result = self.validate_data_contract.validate(&raw_data_contract)?;
 
             if !result.is_valid() {
-                return Err(ProtocolError::InvalidDataContractError {
-                    errors: result.errors,
-                    raw_data_contract,
-                });
+                return Err(ProtocolError::InvalidDataContractError(
+                    InvalidDataContractError::new(result.errors, raw_data_contract),
+                ));
             }
         }
         DataContract::from_raw_object(raw_data_contract)

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

@@ -8,7 +8,6 @@ use super::{
 use crate::data_contract::document_type::{property_names, ArrayFieldType};
 use crate::data_contract::errors::{DataContractError, StructureError};
 
-use crate::util::cbor_value::CborBTreeMapHelper;
 use crate::ProtocolError;
 use platform_value::btreemap_extensions::BTreeValueMapHelper;
 use platform_value::Value;

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

@@ -1,3 +1,4 @@
+use crate::consensus::basic::document::InvalidDocumentTypeError;
 use thiserror::Error;
 
 use crate::data_contract::DataContract;
@@ -14,11 +15,8 @@ pub enum DataContractError {
         raw_data_contract: DataContract,
     },
 
-    #[error("Data Contract doesn't define document with type {doc_type}")]
-    InvalidDocumentTypeError {
-        doc_type: String,
-        data_contract: DataContract,
-    },
+    #[error(transparent)]
+    InvalidDocumentTypeError(InvalidDocumentTypeError),
 
     #[error("missing required key: {0}")]
     MissingRequiredKey(&'static str),

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

@@ -0,0 +1,26 @@
+use thiserror::Error;
+
+use crate::identifier::Identifier;
+use crate::ProtocolError;
+
+#[derive(Error, Debug, Clone, PartialEq, Eq)]
+#[error("Data Contract is not present")]
+pub struct DataContractNotPresentError {
+    data_contract_id: Identifier,
+}
+
+impl DataContractNotPresentError {
+    pub fn new(data_contract_id: Identifier) -> Self {
+        Self { data_contract_id }
+    }
+
+    pub fn data_contract_id(&self) -> Identifier {
+        self.data_contract_id.clone()
+    }
+}
+
+impl From<DataContractNotPresentError> for ProtocolError {
+    fn from(err: DataContractNotPresentError) -> Self {
+        Self::DataContractNotPresentError(err)
+    }
+}

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

@@ -0,0 +1,26 @@
+use thiserror::Error;
+
+use crate::identifier::Identifier;
+use crate::ProtocolError;
+
+#[derive(Error, Debug, Clone, PartialEq, Eq)]
+#[error("Identity is not present")]
+pub struct IdentityNotPresentError {
+    id: Identifier,
+}
+
+impl IdentityNotPresentError {
+    pub fn new(id: Identifier) -> Self {
+        Self { id }
+    }
+
+    pub fn id(&self) -> Identifier {
+        self.id.clone()
+    }
+}
+
+impl From<IdentityNotPresentError> for ProtocolError {
+    fn from(err: IdentityNotPresentError) -> Self {
+        Self::IdentityNotPresentError(err)
+    }
+}

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

@@ -0,0 +1,34 @@
+use crate::consensus::ConsensusError;
+use thiserror::Error;
+
+use crate::document::document_transition::document_base_transition::JsonValue;
+use crate::ProtocolError;
+
+#[derive(Error, Debug)]
+#[error("Invalid Data Contract: {errors:?}")]
+pub struct InvalidDataContractError {
+    pub errors: Vec<ConsensusError>,
+    raw_data_contract: JsonValue,
+}
+
+impl InvalidDataContractError {
+    pub fn new(errors: Vec<ConsensusError>, raw_data_contract: JsonValue) -> Self {
+        Self {
+            errors,
+            raw_data_contract,
+        }
+    }
+
+    pub fn errors(&self) -> &[ConsensusError] {
+        &self.errors
+    }
+    pub fn raw_data_contract(&self) -> JsonValue {
+        self.raw_data_contract.clone()
+    }
+}
+
+impl From<InvalidDataContractError> for ProtocolError {
+    fn from(err: InvalidDataContractError) -> Self {
+        Self::InvalidDataContractError(err)
+    }
+}

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

@@ -0,0 +1,33 @@
+use thiserror::Error;
+
+use crate::data_contract::DataContract;
+use crate::ProtocolError;
+
+#[derive(Error, Debug, Clone, PartialEq)]
+#[error("Data Contract doesn't define document with type {doc_type}")]
+pub struct InvalidDocumentTypeError {
+    doc_type: String,
+    data_contract: DataContract,
+}
+
+impl InvalidDocumentTypeError {
+    pub fn new(doc_type: String, data_contract: DataContract) -> Self {
+        Self {
+            doc_type,
+            data_contract,
+        }
+    }
+
+    pub fn doc_type(&self) -> String {
+        self.doc_type.clone()
+    }
+    pub fn data_contract(&self) -> DataContract {
+        self.data_contract.clone()
+    }
+}
+
+impl From<InvalidDocumentTypeError> for ProtocolError {
+    fn from(err: InvalidDocumentTypeError) -> Self {
+        Self::InvalidDocumentTypeError(err)
+    }
+}

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

@@ -1,5 +1,13 @@
 mod contract;
+mod data_contract_not_present_error;
+mod identity_not_present_error;
+mod invalid_data_contract_error;
+mod invalid_document_type_error;
 mod structure;
 
 pub use contract::DataContractError;
+pub use data_contract_not_present_error::*;
+pub use identity_not_present_error::*;
+pub use invalid_data_contract_error::*;
+pub use invalid_document_type_error::*;
 pub use structure::StructureError;

packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs

@@ -5,6 +5,8 @@ use anyhow::anyhow;
 use lazy_static::lazy_static;
 use serde_json::Value;
 
+use crate::consensus::basic::data_contract::InvalidDataContractIdError;
+use crate::consensus::basic::decode::ProtocolVersionParsingError;
 use crate::{
     consensus::{basic::BasicError, ConsensusError},
     data_contract::{generate_data_contract_id, state_transition::property_names},
@@ -16,7 +18,6 @@ use crate::{
     util::json_value::JsonValueExt,
     validation::{
         DataValidator, DataValidatorWithContext, JsonSchemaValidator, SimpleValidationResult,
-        ValidationResult,
     },
     version::ProtocolVersionValidator,
     ProtocolError,
@@ -87,7 +88,9 @@ fn validate_data_contract_create_transition_basic(
         Ok(v) => v,
         Err(parsing_error) => {
             return Ok(SimpleValidationResult::new(Some(vec![
-                ConsensusError::ProtocolVersionParsingError { parsing_error },
+                ConsensusError::ProtocolVersionParsingError(ProtocolVersionParsingError::new(
+                    parsing_error,
+                )),
             ])))
         }
     };
@@ -113,10 +116,9 @@ fn validate_data_contract_create_transition_basic(
 
     let mut validation_result = SimpleValidationResult::default();
     if generated_id != raw_data_contract_id {
-        validation_result.add_error(BasicError::InvalidDataContractIdError {
-            expected_id: generated_id,
-            invalid_id: raw_data_contract_id,
-        })
+        validation_result.add_error(BasicError::InvalidDataContractIdError(
+            InvalidDataContractIdError::new(generated_id, raw_data_contract_id),
+        ))
     }
 
     Ok(validation_result)

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

@@ -1,12 +1,12 @@
 use std::convert::{TryFrom, TryInto};
 
-use anyhow::anyhow;
-use anyhow::Context;
-use json_patch::PatchOperation;
-use lazy_static::lazy_static;
-use serde_json::{json, Value as JsonValue};
-use std::sync::Arc;
-
+use crate::consensus::basic::data_contract::{
+    DataContractImmutablePropertiesUpdateError, IncompatibleDataContractSchemaError,
+};
+use crate::consensus::basic::decode::ProtocolVersionParsingError;
+use crate::consensus::basic::invalid_data_contract_version_error::InvalidDataContractVersionError;
+use crate::consensus::ConsensusError;
+use crate::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
 use crate::{
     consensus::basic::BasicError,
     data_contract::{
@@ -20,10 +20,12 @@ use crate::{
     version::ProtocolVersionValidator,
     DashPlatformProtocolInitError, ProtocolError,
 };
-use crate::{
-    consensus::ConsensusError,
-    state_transition::state_transition_execution_context::StateTransitionExecutionContext,
-};
+use anyhow::anyhow;
+use anyhow::Context;
+use json_patch::PatchOperation;
+use lazy_static::lazy_static;
+use serde_json::{json, Value as JsonValue};
+use std::sync::Arc;
 
 use super::schema_compatibility_validator::validate_schema_compatibility;
 use super::schema_compatibility_validator::DiffVAlidatorError;
@@ -83,7 +85,9 @@ where
             Ok(v) => v,
             Err(parsing_error) => {
                 return Ok(SimpleValidationResult::new(Some(vec![
-                    ConsensusError::ProtocolVersionParsingError { parsing_error },
+                    ConsensusError::ProtocolVersionParsingError(ProtocolVersionParsingError::new(
+                        parsing_error,
+                    )),
                 ])))
             }
         };
@@ -127,10 +131,9 @@ where
         let new_version = raw_data_contract.get_u64(contract_property_names::VERSION)? as u32;
         let old_version = existing_data_contract.version;
         if (new_version - old_version) != 1 {
-            validation_result.add_error(BasicError::InvalidDataContractVersionError {
-                expected_version: old_version + 1,
-                version: new_version,
-            })
+            validation_result.add_error(BasicError::InvalidDataContractVersionError(
+                InvalidDataContractVersionError::new(old_version + 1, new_version),
+            ))
         }
         let raw_existing_data_contract = existing_data_contract.to_object(false)?;
 
@@ -170,10 +173,12 @@ where
 
         for diff in base_data_contract_diff.0.iter() {
             let (operation, property_name) = get_operation_and_property_name(diff);
-            validation_result.add_error(BasicError::DataContractImmutablePropertiesUpdateError {
-                operation: operation.to_owned(),
-                field_path: property_name.to_owned(),
-            })
+            validation_result.add_error(BasicError::DataContractImmutablePropertiesUpdateError(
+                DataContractImmutablePropertiesUpdateError::new(
+                    operation.to_owned(),
+                    property_name.to_owned(),
+                ),
+            ))
         }
         if !validation_result.is_valid() {
             return Ok(validation_result);
@@ -191,13 +196,15 @@ where
                 Err(DiffVAlidatorError::SchemaCompatibilityError { diffs }) => {
                     let (operation_name, property_name) =
                         get_operation_and_property_name(&diffs[0]);
-                    validation_result.add_error(BasicError::IncompatibleDataContractSchemaError {
-                        data_contract_id: existing_data_contract.id,
-                        operation: operation_name.to_owned(),
-                        field_path: property_name.to_owned(),
-                        old_schema: document_schema.clone(),
-                        new_schema: new_document_schema.clone(),
-                    });
+                    validation_result.add_error(BasicError::IncompatibleDataContractSchemaError(
+                        IncompatibleDataContractSchemaError::new(
+                            existing_data_contract.id.clone(),
+                            operation_name.to_owned(),
+                            property_name.to_owned(),
+                            document_schema.clone(),
+                            new_document_schema.clone(),
+                        ),
+                    ));
                 }
                 Err(DiffVAlidatorError::DataStructureError(e)) => {
                     return Err(ProtocolError::ParsingError(e.to_string()))