From 09b867a221a3a6a195418bb393ff0d286391abfa Mon Sep 17 00:00:00 2001 From: Konstantin Shuplenkov Date: Mon, 6 Feb 2023 23:39:42 +0700 Subject: [PATCH 01/11] WIP --- .../rs-dpp/src/data_contract/data_contract.rs | 25 +- .../data_contract/data_contract_factory.rs | 8 +- .../src/data_contract/errors/contract.rs | 8 +- .../errors/data_contract_not_present_error.rs | 26 ++ .../errors/identity_not_present_error.rs | 26 ++ .../errors/invalid_data_contract_error.rs | 33 +++ .../errors/invalid_document_type_error.rs | 33 +++ .../rs-dpp/src/data_contract/errors/mod.rs | 8 + ...e_data_contract_create_transition_basic.rs | 8 +- ...e_data_contract_update_transition_basic.rs | 50 ++-- ...alidate_indices_are_backward_compatible.rs | 44 ++-- ...e_data_contract_update_transition_state.rs | 8 +- ...gnature_public_key_security_level_error.rs | 25 ++ .../errors/missing_data_contract_id_error.rs | 28 ++ .../state_transition/errors/mod.rs | 7 + .../errors/public_key_is_disabled_error.rs | 26 ++ .../src/data_contract/state_transition/mod.rs | 1 + .../validation/data_contract_validator.rs | 106 ++++---- .../validation/multi_validator.rs | 13 +- .../validate_data_contract_max_depth.rs | 19 +- .../src/decode_protocol_entity_factory.rs | 6 +- .../rs-dpp/src/document/document_factory.rs | 8 +- packages/rs-dpp/src/document/document_stub.rs | 7 +- .../rs-dpp/src/document/document_validator.rs | 11 +- .../fetch_and_validate_data_contract.rs | 8 +- ...lidate_documents_batch_transition_basic.rs | 47 ++-- .../validate_partial_compound_indices.rs | 11 +- ...lidate_documents_batch_transition_state.rs | 7 +- .../consensus/abstract_consensus_error.rs | 54 ++-- .../consensus/basic/abstract_basic_error.rs | 243 +++++++----------- ...ta_contract_have_new_unique_index_error.rs | 33 +++ ...tract_immutable_properties_update_error.rs | 33 +++ ...t_invalid_index_definition_update_error.rs | 33 +++ ...a_contract_unique_indices_changed_error.rs | 33 +++ .../data_contract/duplicate_index_error.rs | 34 +++ .../duplicate_index_name_error.rs | 33 +++ ...incompatible_data_contract_schema_error.rs | 56 ++++ .../incompatible_re2_pattern_error.rs | 39 +++ .../invalid_compound_index_error.rs | 36 +++ .../invalid_data_contract_id_error.rs | 32 +++ .../invalid_index_property_type_error.rs | 48 ++++ ...valid_indexed_property_constraint_error.rs | 54 ++++ .../invalid_json_schema_ref_error.rs | 25 ++ .../consensus/basic/data_contract/mod.rs | 34 +++ ...em_property_index_already_present_error.rs | 38 +++ .../undefined_index_property_error.rs | 38 +++ .../unique_indices_limit_reached_error.rs | 32 +++ .../src/errors/consensus/basic/decode/mod.rs | 2 + .../decode/protocol_version_parsing_error.rs | 21 ++ ...ate_document_transitions_with_ids_error.rs | 25 ++ ...document_transitions_with_indices_error.rs | 28 ++ .../inconsistent_compound_index_data_error.rs | 35 +++ ...nvalid_document_transition_action_error.rs | 25 ++ .../invalid_document_transition_id_error.rs | 38 +++ .../document/invalid_document_type_error.rs | 34 +++ .../errors/consensus/basic/document/mod.rs | 13 + .../invalid_identity_key_signature_error.rs | 26 ++ .../errors/consensus/basic/identity/mod.rs | 2 + .../invalid_data_contract_version_error.rs | 33 +++ .../basic/invalid_identifier_error.rs | 33 +++ .../rs-dpp/src/errors/consensus/basic/mod.rs | 16 +- .../invalid_state_transition_type_error.rs | 25 ++ .../consensus/basic/state_transition/mod.rs | 5 + ...tate_transition_max_size_exceeded_error.rs | 32 +++ .../signature/identity_not_found_error.rs | 27 ++ .../invalid_identity_public_key_type_error.rs | 27 ++ ...gnature_public_key_security_level_error.rs | 39 +++ .../signature/missing_public_key_error.rs | 26 ++ .../src/errors/consensus/signature/mod.rs | 64 ++--- .../signature/public_key_is_disabled_error.rs | 27 ++ ...public_key_security_level_not_met_error.rs | 37 +++ .../wrong_public_key_purpose_error.rs | 34 +++ packages/rs-dpp/src/errors/dpp_init_error.rs | 4 +- packages/rs-dpp/src/errors/errors.rs | 74 +++--- .../rs-dpp/src/errors/non_consensus_error.rs | 12 +- ...tity_credit_withdrawal_transition_state.rs | 7 +- .../apply_identity_update_transition.rs | 7 +- ...lidate_identity_update_transition_state.rs | 8 +- .../validate_public_key_signatures.rs | 12 +- .../abstract_state_transition.rs | 33 +-- ...stract_state_transition_identity_signed.rs | 112 ++++---- .../invalid_identity_public_key_type_error.rs | 26 ++ .../invalid_signature_public_key_error.rs | 26 ++ .../rs-dpp/src/state_transition/errors/mod.rs | 13 + .../errors/public_key_mismatch_error.rs | 26 ++ ...public_key_security_level_not_met_error.rs | 36 +++ .../state_transition_is_not_signed_error.rs | 26 ++ .../errors/wrong_public_key_purpose_error.rs | 33 +++ packages/rs-dpp/src/state_transition/mod.rs | 1 + .../state_transition_factory.rs | 14 +- .../validate_state_transition_fee.rs | 13 +- ...ate_state_transition_identity_signature.rs | 122 +++++---- ...validate_state_transition_key_signature.rs | 7 +- .../validation/validator_transaction_basic.rs | 16 +- packages/rs-dpp/src/util/deserializer.rs | 13 +- 95 files changed, 2258 insertions(+), 592 deletions(-) create mode 100644 packages/rs-dpp/src/data_contract/errors/data_contract_not_present_error.rs create mode 100644 packages/rs-dpp/src/data_contract/errors/identity_not_present_error.rs create mode 100644 packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs create mode 100644 packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs create mode 100644 packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs create mode 100644 packages/rs-dpp/src/data_contract/state_transition/errors/missing_data_contract_id_error.rs create mode 100644 packages/rs-dpp/src/data_contract/state_transition/errors/mod.rs create mode 100644 packages/rs-dpp/src/data_contract/state_transition/errors/public_key_is_disabled_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_re2_pattern_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/mod.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/decode/mod.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/document/mod.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/invalid_data_contract_version_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/state_transition/mod.rs create mode 100644 packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/signature/identity_not_found_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/signature/invalid_identity_public_key_type_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_security_level_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/signature/public_key_is_disabled_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/signature/public_key_security_level_not_met_error.rs create mode 100644 packages/rs-dpp/src/errors/consensus/signature/wrong_public_key_purpose_error.rs create mode 100644 packages/rs-dpp/src/state_transition/errors/invalid_identity_public_key_type_error.rs create mode 100644 packages/rs-dpp/src/state_transition/errors/invalid_signature_public_key_error.rs create mode 100644 packages/rs-dpp/src/state_transition/errors/mod.rs create mode 100644 packages/rs-dpp/src/state_transition/errors/public_key_mismatch_error.rs create mode 100644 packages/rs-dpp/src/state_transition/errors/public_key_security_level_not_met_error.rs create mode 100644 packages/rs-dpp/src/state_transition/errors/state_transition_is_not_signed_error.rs create mode 100644 packages/rs-dpp/src/state_transition/errors/wrong_public_key_purpose_error.rs diff --git a/packages/rs-dpp/src/data_contract/data_contract.rs b/packages/rs-dpp/src/data_contract/data_contract.rs index 6ba436b5070..d5131d6efd7 100644 --- a/packages/rs-dpp/src/data_contract/data_contract.rs +++ b/packages/rs-dpp/src/data_contract/data_contract.rs @@ -8,6 +8,7 @@ use itertools::{Either, Itertools}; 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, @@ -334,10 +335,10 @@ 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.clone().id, + )), ))?; Ok(document) } @@ -345,10 +346,10 @@ impl DataContract { pub fn get_document_schema_ref(&self, doc_type: &str) -> Result { 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.clone().id, + )), )); }; @@ -369,10 +370,10 @@ impl DataContract { ) -> Result<&BTreeMap, 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.clone().id, + )), )) } diff --git a/packages/rs-dpp/src/data_contract/data_contract_factory.rs b/packages/rs-dpp/src/data_contract/data_contract_factory.rs index 07095e90f36..44fc9f19198 100644 --- a/packages/rs-dpp/src/data_contract/data_contract_factory.rs +++ b/packages/rs-dpp/src/data_contract/data_contract_factory.rs @@ -3,6 +3,7 @@ use serde_json::{json, Number, Value as JsonValue}; use data_contract::state_transition::property_names as st_prop; +use crate::data_contract::errors::DataContractError::InvalidDataContractError; use crate::{ data_contract::{self, generate_data_contract_id}, decode_protocol_entity_factory::DecodeProtocolEntity, @@ -103,10 +104,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) diff --git a/packages/rs-dpp/src/data_contract/errors/contract.rs b/packages/rs-dpp/src/data_contract/errors/contract.rs index ec8f3529ea0..670ae1f45b6 100644 --- a/packages/rs-dpp/src/data_contract/errors/contract.rs +++ b/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), diff --git a/packages/rs-dpp/src/data_contract/errors/data_contract_not_present_error.rs b/packages/rs-dpp/src/data_contract/errors/data_contract_not_present_error.rs new file mode 100644 index 00000000000..21729ed8df4 --- /dev/null +++ b/packages/rs-dpp/src/data_contract/errors/data_contract_not_present_error.rs @@ -0,0 +1,26 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identifier::Identifier; + +#[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 for ConsensusError { + fn from(err: DataContractNotPresentError) -> Self { + Self::DataContractNotPresentError(err) + } +} diff --git a/packages/rs-dpp/src/data_contract/errors/identity_not_present_error.rs b/packages/rs-dpp/src/data_contract/errors/identity_not_present_error.rs new file mode 100644 index 00000000000..ee0479e3f2b --- /dev/null +++ b/packages/rs-dpp/src/data_contract/errors/identity_not_present_error.rs @@ -0,0 +1,26 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identifier::Identifier; + +#[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 for ConsensusError { + fn from(err: IdentityNotPresentError) -> Self { + Self::IdentityNotPresentError(err) + } +} diff --git a/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs b/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs new file mode 100644 index 00000000000..f49a15283b9 --- /dev/null +++ b/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs @@ -0,0 +1,33 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::document::document_transition::document_base_transition::JsonValue; + +#[derive(Error, Debug)] +#[error("Invalid Data Contract: {errors:?}")] +pub struct InvalidDataContractError { + errors: Vec, + raw_data_contract: JsonValue, +} + +impl InvalidDataContractError { + pub fn new(errors: Vec, raw_data_contract: JsonValue) -> Self { + Self { + errors, + raw_data_contract, + } + } + + pub fn errors(&self) -> Vec { + self.errors.clone() + } + pub fn raw_data_contract(&self) -> JsonValue { + self.raw_data_contract.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidDataContractError) -> Self { + Self::InvalidDataContractError(err) + } +} diff --git a/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs b/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs new file mode 100644 index 00000000000..b49cdd76f2f --- /dev/null +++ b/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs @@ -0,0 +1,33 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::data_contract::DataContract; + +#[derive(Error, Debug, Clone, PartialEq)] +#[error("Data Contract doesn't define document with type {doc_type}")] +pub struct InvalidDataContractError { + doc_type: String, + data_contract: DataContract, +} + +impl InvalidDataContractError { + 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 for ConsensusError { + fn from(err: InvalidDataContractError) -> Self { + Self::InvalidDataContractError(err) + } +} diff --git a/packages/rs-dpp/src/data_contract/errors/mod.rs b/packages/rs-dpp/src/data_contract/errors/mod.rs index 89a3e42ffc7..9cdd4235b5f 100644 --- a/packages/rs-dpp/src/data_contract/errors/mod.rs +++ b/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; diff --git a/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs b/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs index 44d0577bd13..52cf82316ce 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs @@ -4,6 +4,7 @@ use anyhow::anyhow; use lazy_static::lazy_static; use serde_json::Value; +use crate::consensus::basic::data_contract::InvalidDataContractIdError; use crate::{ consensus::basic::BasicError, data_contract::{generate_data_contract_id, state_transition::property_names}, @@ -101,10 +102,9 @@ pub 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) diff --git a/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs b/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs index 7a8378f98bf..4efdbe0f7b8 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs @@ -1,12 +1,9 @@ use std::convert::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::invalid_data_contract_version_error::InvalidDataContractVersionError; use crate::state_transition::state_transition_execution_context::StateTransitionExecutionContext; use crate::{ consensus::basic::BasicError, @@ -21,6 +18,12 @@ use crate::{ version::ProtocolVersionValidator, DashPlatformProtocolInitError, ProtocolError, }; +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; @@ -116,10 +119,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)?; @@ -154,10 +156,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); @@ -188,13 +192,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.clone(), - 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())) diff --git a/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible.rs b/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible.rs index a8e17b3a569..847fcbf015b 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible.rs @@ -1,6 +1,10 @@ use std::collections::HashSet; use std::collections::{BTreeMap, HashMap}; +use crate::consensus::basic::data_contract::{ + DataContractHaveNewUniqueIndexError, DataContractInvalidIndexDefinitionUpdateError, + DataContractUniqueIndicesChangedError, +}; use crate::consensus::basic::BasicError; use crate::data_contract::document_type::IndexProperty; use crate::util::json_schema::Index; @@ -65,10 +69,12 @@ pub fn validate_indices_are_backward_compatible<'a>( let maybe_changed_unique_existing_index = get_changed_old_unique_index(&existing_schema_indices, &name_new_index_map); if let Some(changed_index) = maybe_changed_unique_existing_index { - result.add_error(BasicError::DataContractUniqueIndicesChangedError { - document_type: document_type.to_owned(), - index_name: changed_index.name.clone(), - }); + result.add_error(BasicError::DataContractUniqueIndicesChangedError( + DataContractUniqueIndicesChangedError::new( + document_type.to_owned(), + changed_index.name.clone(), + ), + )); } let maybe_wrongly_updated_index = get_wrongly_updated_non_unique_index( @@ -77,19 +83,23 @@ pub fn validate_indices_are_backward_compatible<'a>( existing_schema, ); if let Some(index) = maybe_wrongly_updated_index { - result.add_error(BasicError::DataContractInvalidIndexDefinitionUpdateError { - document_type: document_type.to_owned(), - index_name: index.name.clone(), - }) + result.add_error(BasicError::DataContractInvalidIndexDefinitionUpdateError( + DataContractInvalidIndexDefinitionUpdateError::new( + document_type.to_owned(), + index.name.clone(), + ), + )) } let maybe_new_unique_index = get_new_unique_index(&existing_schema_indices, name_new_index_map.values())?; if let Some(index) = maybe_new_unique_index { - result.add_error(BasicError::DataContractHaveNewUniqueIndexError { - document_type: document_type.to_owned(), - index_name: index.name.clone(), - }) + result.add_error(BasicError::DataContractHaveNewUniqueIndexError( + DataContractHaveNewUniqueIndexError::new( + document_type.to_owned(), + index.name.clone(), + ), + )) } let maybe_wrongly_constructed_new_index = get_wrongly_constructed_new_index( existing_schema_indices.iter(), @@ -97,10 +107,12 @@ pub fn validate_indices_are_backward_compatible<'a>( added_properties.copied(), )?; if let Some(index) = maybe_wrongly_constructed_new_index { - result.add_error(BasicError::DataContractInvalidIndexDefinitionUpdateError { - document_type: document_type.to_owned(), - index_name: index.name.clone(), - }) + result.add_error(BasicError::DataContractInvalidIndexDefinitionUpdateError( + DataContractInvalidIndexDefinitionUpdateError::new( + document_type.to_owned(), + index.name.clone(), + ), + )) } } diff --git a/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/state/validate_data_contract_update_transition_state.rs b/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/state/validate_data_contract_update_transition_state.rs index bf63ef09233..9c414882712 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/state/validate_data_contract_update_transition_state.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/state/validate_data_contract_update_transition_state.rs @@ -3,6 +3,7 @@ use std::convert::TryInto; use anyhow::Result; use async_trait::async_trait; +use crate::consensus::basic::invalid_data_contract_version_error::InvalidDataContractVersionError; use crate::{ data_contract::{state_transition::DataContractUpdateTransition, DataContract}, errors::consensus::basic::BasicError, @@ -80,10 +81,9 @@ pub async fn validate_data_contract_update_transition_state( let new_version = state_transition.data_contract.version; if new_version < old_version || new_version - old_version != 1 { - let err = BasicError::InvalidDataContractVersionError { - expected_version: old_version + 1, - version: new_version, - }; + let err = BasicError::InvalidDataContractVersionError( + InvalidDataContractVersionError::new(old_version + 1, new_version), + ); result.add_error(err); } diff --git a/packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs b/packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs new file mode 100644 index 00000000000..5cf440c4e16 --- /dev/null +++ b/packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs @@ -0,0 +1,25 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid State Transition type {transition_type}")] +pub struct InvalidStateTransitionTypeError { + transition_type: u8, +} + +impl InvalidStateTransitionTypeError { + pub fn new(transition_type: u8) -> Self { + Self { transition_type } + } + + pub fn transition_type(&self) -> u8 { + self.transition_type + } +} + +impl From for ConsensusError { + fn from(err: InvalidStateTransitionTypeError) -> Self { + Self::InvalidStateTransitionTypeError(err) + } +} diff --git a/packages/rs-dpp/src/data_contract/state_transition/errors/missing_data_contract_id_error.rs b/packages/rs-dpp/src/data_contract/state_transition/errors/missing_data_contract_id_error.rs new file mode 100644 index 00000000000..dec21bdf761 --- /dev/null +++ b/packages/rs-dpp/src/data_contract/state_transition/errors/missing_data_contract_id_error.rs @@ -0,0 +1,28 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::document::document_transition::document_base_transition::JsonValue; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("$dataContractId is not present")] +pub struct MissingDataContractIdError { + raw_document_transition: JsonValue, +} + +impl MissingDataContractIdError { + pub fn new(raw_document_transition: JsonValue) -> Self { + Self { + raw_document_transition, + } + } + + pub fn raw_document_transition(&self) -> JsonValue { + self.raw_document_transition.clone() + } +} + +impl From for ConsensusError { + fn from(err: MissingDataContractIdError) -> Self { + Self::MissingDataContractIdError(err) + } +} diff --git a/packages/rs-dpp/src/data_contract/state_transition/errors/mod.rs b/packages/rs-dpp/src/data_contract/state_transition/errors/mod.rs new file mode 100644 index 00000000000..82c7c21b94c --- /dev/null +++ b/packages/rs-dpp/src/data_contract/state_transition/errors/mod.rs @@ -0,0 +1,7 @@ +mod invalid_signature_public_key_security_level_error; +mod missing_data_contract_id_error; +mod public_key_is_disabled_error; + +pub use invalid_signature_public_key_security_level_error::*; +pub use missing_data_contract_id_error::*; +pub use public_key_is_disabled_error::*; diff --git a/packages/rs-dpp/src/data_contract/state_transition/errors/public_key_is_disabled_error.rs b/packages/rs-dpp/src/data_contract/state_transition/errors/public_key_is_disabled_error.rs new file mode 100644 index 00000000000..6486f439d85 --- /dev/null +++ b/packages/rs-dpp/src/data_contract/state_transition/errors/public_key_is_disabled_error.rs @@ -0,0 +1,26 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identity::IdentityPublicKey; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Public key is disabled")] +pub struct PublicKeyIsDisabledError { + public_key: IdentityPublicKey, +} + +impl PublicKeyIsDisabledError { + pub fn new(public_key: IdentityPublicKey) -> Self { + Self { public_key } + } + + pub fn public_key(&self) -> IdentityPublicKey { + self.public_key.clone() + } +} + +impl From for ConsensusError { + fn from(err: PublicKeyIsDisabledError) -> Self { + Self::PublicKeyIsDisabledError(err) + } +} diff --git a/packages/rs-dpp/src/data_contract/state_transition/mod.rs b/packages/rs-dpp/src/data_contract/state_transition/mod.rs index 6b75a4d569b..a08c435e710 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/mod.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/mod.rs @@ -3,6 +3,7 @@ pub use data_contract_update_transition::*; pub mod data_contract_create_transition; pub mod data_contract_update_transition; +pub mod errors; pub(crate) mod property_names { pub const SIGNATURE_PUBLIC_KEY_ID: &str = "signaturePublicKeyId"; diff --git a/packages/rs-dpp/src/data_contract/validation/data_contract_validator.rs b/packages/rs-dpp/src/data_contract/validation/data_contract_validator.rs index 0e72de70702..6c011e1a3f6 100644 --- a/packages/rs-dpp/src/data_contract/validation/data_contract_validator.rs +++ b/packages/rs-dpp/src/data_contract/validation/data_contract_validator.rs @@ -6,6 +6,12 @@ use lazy_static::lazy_static; use log::trace; use serde_json::Value as JsonValue; +use crate::consensus::basic::data_contract::{ + DuplicateIndexError, DuplicateIndexNameError, InvalidCompoundIndexError, + InvalidIndexPropertyTypeError, InvalidIndexedPropertyConstraintError, + SystemPropertyIndexAlreadyPresentError, UndefinedIndexPropertyError, + UniqueIndicesLimitReachedError, +}; use crate::{ consensus::basic::{BasicError, IndexError}, data_contract::{ @@ -230,10 +236,10 @@ fn validate_index_definitions( if !all_are_required && !all_are_not_required { result.add_error(BasicError::IndexError( - IndexError::InvalidCompoundIndexError { - document_type: document_type.to_owned(), - index_definition: index_definition.clone(), - }, + IndexError::InvalidCompoundIndexError(InvalidCompoundIndexError::new( + document_type.to_owned(), + index_definition.clone(), + )), )); } @@ -241,10 +247,9 @@ fn validate_index_definitions( let indices_fingerprint = serde_json::to_string(&index_definition.properties) .expect("fingerprint creation shouldn't fail"); if indices_fingerprints.contains(&indices_fingerprint) { - result.add_error(BasicError::IndexError(IndexError::DuplicateIndexError { - document_type: document_type.to_owned(), - index_definition: index_definition.clone(), - })); + result.add_error(BasicError::IndexError(IndexError::DuplicateIndexError( + DuplicateIndexError::new(document_type.to_owned(), index_definition.clone()), + ))); } indices_fingerprints.push(indices_fingerprint) } @@ -289,12 +294,12 @@ fn validate_property_definition( if !invalid_property_type.is_empty() { result.add_error(BasicError::IndexError( - IndexError::InvalidIndexPropertyTypeError { - document_type: document_type.to_owned(), - index_definition: index_definition.clone(), - property_name: property_name.to_owned(), - property_type: invalid_property_type.clone(), - }, + IndexError::InvalidIndexPropertyTypeError(InvalidIndexPropertyTypeError::new( + document_type.to_owned(), + index_definition.clone(), + property_name.to_owned(), + invalid_property_type.clone(), + )), )); } @@ -336,13 +341,15 @@ fn validate_property_definition( if max_items.is_none() || max_items.unwrap() > max_limit as u64 { result.add_error(BasicError::IndexError( - IndexError::InvalidIndexedPropertyConstraintError { - document_type: document_type.to_owned(), - index_definition: index_definition.clone(), - property_name: property_name.to_owned(), - constraint_name: String::from("maxItems"), - reason: format!("should be less or equal {}", max_limit), - }, + IndexError::InvalidIndexedPropertyConstraintError( + InvalidIndexedPropertyConstraintError::new( + document_type.to_owned(), + index_definition.clone(), + property_name.to_owned(), + String::from("maxItems"), + format!("should be less or equal {}", max_limit), + ), + ), )); } } @@ -352,16 +359,18 @@ fn validate_property_definition( if max_length.is_none() || max_length.unwrap() > MAX_INDEXED_STRING_PROPERTY_LENGTH as u64 { result.add_error(BasicError::IndexError( - IndexError::InvalidIndexedPropertyConstraintError { - document_type: document_type.to_owned(), - index_definition: index_definition.clone(), - property_name: property_name.to_owned(), - constraint_name: String::from("maxLength"), - reason: format!( - "should be less or equal than {}", - MAX_INDEXED_STRING_PROPERTY_LENGTH + IndexError::InvalidIndexedPropertyConstraintError( + InvalidIndexedPropertyConstraintError::new( + document_type.to_owned(), + index_definition.clone(), + property_name.to_owned(), + String::from("maxLength"), + format!( + "should be less or equal than {}", + MAX_INDEXED_STRING_PROPERTY_LENGTH + ), ), - }, + ), )) } } @@ -379,11 +388,11 @@ fn validate_not_defined_properties( for (property_name, definition) in properties { if definition.is_none() { result.add_error(BasicError::IndexError( - IndexError::UndefinedIndexPropertyError { - document_type: document_type.to_owned(), - index_definition: index_definition.clone(), - property_name: property_name.to_owned().to_owned(), - }, + IndexError::UndefinedIndexPropertyError(UndefinedIndexPropertyError::new( + document_type.to_owned(), + index_definition.clone(), + property_name.to_owned().to_owned(), + )), )) } } @@ -397,10 +406,9 @@ fn validate_index_naming_duplicates( ) -> ValidationResult<()> { let mut result = ValidationResult::default(); for duplicate_index in indices.iter().map(|i| &i.name).duplicates() { - result.add_error(BasicError::DuplicateIndexNameError { - document_type: document_type.to_owned(), - duplicate_index_name: duplicate_index.to_owned(), - }) + result.add_error(BasicError::DuplicateIndexNameError( + DuplicateIndexNameError::new(document_type.to_owned(), duplicate_index.to_owned()), + )) } result } @@ -410,10 +418,10 @@ fn validate_max_unique_indices(indices: &[Index], document_type: &str) -> Valida let mut result = ValidationResult::default(); if indices.iter().filter(|i| i.unique).count() > UNIQUE_INDEX_LIMIT { result.add_error(BasicError::IndexError( - IndexError::UniqueIndicesLimitReachedError { - document_type: document_type.to_owned(), - index_limit: UNIQUE_INDEX_LIMIT, - }, + IndexError::UniqueIndicesLimitReachedError(UniqueIndicesLimitReachedError::new( + document_type.to_owned(), + UNIQUE_INDEX_LIMIT, + )), )) } @@ -430,11 +438,13 @@ fn validate_no_system_indices( for property in index_definition.properties.iter() { if NOT_ALLOWED_SYSTEM_PROPERTIES.contains(&property.name.as_str()) { result.add_error(BasicError::IndexError( - IndexError::SystemPropertyIndexAlreadyPresentError { - property_name: property.name.to_owned(), - document_type: document_type.to_owned(), - index_definition: index_definition.clone(), - }, + IndexError::SystemPropertyIndexAlreadyPresentError( + SystemPropertyIndexAlreadyPresentError::new( + document_type.to_owned(), + index_definition.clone(), + property.name.to_owned(), + ), + ), )); } } diff --git a/packages/rs-dpp/src/data_contract/validation/multi_validator.rs b/packages/rs-dpp/src/data_contract/validation/multi_validator.rs index 5d864cf305e..e2be23e7d8e 100644 --- a/packages/rs-dpp/src/data_contract/validation/multi_validator.rs +++ b/packages/rs-dpp/src/data_contract/validation/multi_validator.rs @@ -1,6 +1,7 @@ use regex::Regex; use serde_json::Value as JsonValue; +use crate::consensus::basic::data_contract::IncompatibleRe2PatternError; use crate::{ consensus::{basic::BasicError, ConsensusError}, validation::ValidationResult, @@ -58,11 +59,13 @@ pub fn pattern_is_valid_regex_validator( if key == "pattern" { if let Some(pattern) = value.as_str() { if let Err(err) = Regex::new(pattern) { - result.add_error(ConsensusError::IncompatibleRe2PatternError { - pattern: String::from(pattern), - path: path.to_string(), - message: err.to_string(), - }); + result.add_error(ConsensusError::IncompatibleRe2PatternError( + IncompatibleRe2PatternError::new( + String::from(pattern), + path.to_string(), + err.to_string(), + ), + )); } } } diff --git a/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs b/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs index 1e6a5b27ce0..1c60cd9d2f4 100644 --- a/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs +++ b/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs @@ -3,6 +3,7 @@ use std::collections::BTreeSet; use anyhow::bail; use serde_json::Value as JsonValue; +use crate::consensus::basic::data_contract::InvalidJsonSchemaRefError; use crate::{ consensus::basic::BasicError, util::json_value::JsonValueExt, validation::ValidationResult, }; @@ -42,15 +43,21 @@ fn calc_max_depth(json_value: &JsonValue) -> Result { if property_name == "$ref" { if let Some(uri) = v.as_str() { let resolved = resolve_uri(json_value, uri).map_err(|e| { - BasicError::InvalidJsonSchemaRefError { - ref_error: format!("invalid ref '{}': {}", uri, e), - } + BasicError::InvalidJsonSchemaRefError( + InvalidJsonSchemaRefError::new(format!( + "invalid ref '{}': {}", + uri, e + )), + ) })?; if visited.contains(&(resolved as *const JsonValue)) { - return Err(BasicError::InvalidJsonSchemaRefError { - ref_error: format!("the ref '{}' contains cycles", uri), - }); + return Err(BasicError::InvalidJsonSchemaRefError( + InvalidJsonSchemaRefError::new(format!( + "the ref '{}' contains cycles", + uri + )), + )); } visited.insert(resolved as *const JsonValue); diff --git a/packages/rs-dpp/src/decode_protocol_entity_factory.rs b/packages/rs-dpp/src/decode_protocol_entity_factory.rs index 5c521a7c8dd..ef1a88a988c 100644 --- a/packages/rs-dpp/src/decode_protocol_entity_factory.rs +++ b/packages/rs-dpp/src/decode_protocol_entity_factory.rs @@ -1,14 +1,10 @@ use anyhow::anyhow; use ciborium::value::Value as CborValue; -use integer_encoding::VarInt; use serde_json::Value as JsonValue; use crate::util::deserializer; use crate::util::deserializer::SplitProtocolVersionOutcome; -use crate::{ - errors::consensus::ConsensusError, errors::ProtocolError, - util::deserializer::get_protocol_version, -}; +use crate::{errors::consensus::ConsensusError, errors::ProtocolError}; #[derive(Default, Clone, Copy)] pub struct DecodeProtocolEntity {} diff --git a/packages/rs-dpp/src/document/document_factory.rs b/packages/rs-dpp/src/document/document_factory.rs index b4c4b91af89..aa89804c96e 100644 --- a/packages/rs-dpp/src/document/document_factory.rs +++ b/packages/rs-dpp/src/document/document_factory.rs @@ -4,6 +4,7 @@ use itertools::Itertools; use serde::{Deserialize, Serialize}; use serde_json::{json, Value as JsonValue}; +use crate::consensus::basic::document::InvalidDocumentTypeError; use crate::{ data_contract::{errors::DataContractError, DataContract}, decode_protocol_entity_factory::DecodeProtocolEntity, @@ -95,10 +96,9 @@ where data: JsonValue, ) -> Result { if !data_contract.is_document_defined(&document_type) { - return Err(DataContractError::InvalidDocumentTypeError { - doc_type: document_type, - data_contract, - } + return Err(DataContractError::InvalidDocumentTypeError( + InvalidDocumentTypeError::new(document_type, data_contract.id), + ) .into()); } diff --git a/packages/rs-dpp/src/document/document_stub.rs b/packages/rs-dpp/src/document/document_stub.rs index 12d263c7b15..bac6c0c374f 100644 --- a/packages/rs-dpp/src/document/document_stub.rs +++ b/packages/rs-dpp/src/document/document_stub.rs @@ -37,9 +37,8 @@ use std::convert::{TryFrom, TryInto}; use std::fmt; use std::io::{BufReader, Read}; -use byteorder::{BigEndian, WriteBytesExt}; use ciborium::value::Value; -use integer_encoding::{VarInt, VarIntWriter}; +use integer_encoding::VarIntWriter; use crate::data_contract::{DataContract, DriveContractExt}; use serde::{Deserialize, Serialize}; @@ -48,8 +47,8 @@ use crate::data_contract::document_type::document_type::PROTOCOL_VERSION; use crate::data_contract::document_type::DocumentType; use crate::data_contract::errors::{DataContractError, StructureError}; use crate::data_contract::extra::common::{ - bytes_for_system_value_from_tree_map, check_protocol_version, check_protocol_version_bytes, - get_key_from_cbor_map, reduced_value_string_representation, + bytes_for_system_value_from_tree_map, check_protocol_version_bytes, get_key_from_cbor_map, + reduced_value_string_representation, }; use crate::util::deserializer; use crate::util::deserializer::SplitProtocolVersionOutcome; diff --git a/packages/rs-dpp/src/document/document_validator.rs b/packages/rs-dpp/src/document/document_validator.rs index 236f378b242..fb08992c2f4 100644 --- a/packages/rs-dpp/src/document/document_validator.rs +++ b/packages/rs-dpp/src/document/document_validator.rs @@ -4,6 +4,7 @@ use anyhow::anyhow; use lazy_static::lazy_static; use serde_json::Value as JsonValue; +use crate::consensus::basic::document::InvalidDocumentTypeError; use crate::{ consensus::basic::BasicError, data_contract::{ @@ -56,10 +57,12 @@ impl DocumentValidator { })?; if !data_contract.is_document_defined(document_type) { - result.add_error(BasicError::InvalidDocumentTypeError { - document_type: document_type.to_owned(), - data_contract_id: data_contract.id.to_owned(), - }); + result.add_error(BasicError::InvalidDocumentTypeError( + InvalidDocumentTypeError::new( + document_type.to_owned(), + data_contract.id.to_owned(), + ), + )); return Ok(result); } diff --git a/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs b/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs index fd40405dedd..a80f528f6f9 100644 --- a/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs +++ b/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs @@ -2,6 +2,7 @@ use std::{convert::TryInto, sync::Arc}; use serde_json::Value; +use crate::consensus::basic::invalid_identifier_error::InvalidIdentifierError; use crate::{ consensus::{basic::BasicError, ConsensusError}, data_contract::DataContract, @@ -60,10 +61,9 @@ pub async fn fetch_and_validate_data_contract( Err(e) => { let id_base58 = bs58::encode(id_bytes).into_string(); let consensus_error = - ConsensusError::BasicError(Box::new(BasicError::InvalidIdentifierError { - identifier_name: id_base58, - error: e.to_string(), - })); + ConsensusError::BasicError(Box::new(BasicError::InvalidIdentifierError( + InvalidIdentifierError::new(id_base58, e.to_string()), + ))); validation_result.add_error(consensus_error); return Ok(validation_result); } diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs index 2f52d09914f..cde8f759f24 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs @@ -3,6 +3,12 @@ use std::{ convert::{TryFrom, TryInto}, }; +use crate::consensus::basic::document::{ + DuplicateDocumentTransitionsWithIdsError, DuplicateDocumentTransitionsWithIndicesError, + InvalidDocumentTransitionActionError, InvalidDocumentTransitionIdError, + InvalidDocumentTypeError, +}; +use crate::consensus::basic::invalid_identifier_error::InvalidIdentifierError; use crate::document::validation::basic::find_duplicates_by_id::find_duplicates_by_id; use crate::{ consensus::basic::BasicError, @@ -101,10 +107,9 @@ pub async fn validate_documents_batch_transition_basic( let identifier = match Identifier::from_bytes(&data_contract_id_bytes) { Ok(identifier) => identifier, Err(e) => { - result.add_error(BasicError::InvalidIdentifierError { - identifier_name: String::from("$dataContractId"), - error: e.to_string(), - }); + result.add_error(BasicError::InvalidIdentifierError( + InvalidIdentifierError::new(String::from("$dataContractId"), e.to_string()), + )); continue; } }; @@ -216,10 +221,12 @@ fn validate_raw_transitions<'a>( Ok(document_type) => { if !data_contract.is_document_defined(document_type) { - result.add_error(BasicError::InvalidDocumentTypeError { - document_type: document_type.to_string(), - data_contract_id: data_contract.id().clone(), - }); + result.add_error(BasicError::InvalidDocumentTypeError( + InvalidDocumentTypeError::new( + document_type.to_string(), + data_contract.id().clone(), + ), + )); return Ok(result); } document_type @@ -237,9 +244,9 @@ fn validate_raw_transitions<'a>( let action = match Action::try_from(document_action as u8) { Ok(action) => action, Err(_) => { - result.add_error(BasicError::InvalidDocumentTransitionActionError { - action: document_action.to_string(), - }); + result.add_error(BasicError::InvalidDocumentTransitionActionError( + InvalidDocumentTransitionActionError::new(document_action.to_string()), + )); return Ok(result); } }; @@ -271,10 +278,12 @@ fn validate_raw_transitions<'a>( generate_document_id(data_contract.id(), owner_id, document_type, &entropy); if generated_document_id != document_id { - result.add_error(BasicError::InvalidDocumentTransitionIdError { - expected_id: generated_document_id, - invalid_id: document_id, - }) + result.add_error(BasicError::InvalidDocumentTransitionIdError( + InvalidDocumentTransitionIdError::new( + generated_document_id, + document_id, + ), + )) } } } @@ -303,7 +312,9 @@ fn validate_raw_transitions<'a>( Ok((doc_type, id)) }) .collect::)>, anyhow::Error>>()?; - result.add_error(BasicError::DuplicateDocumentTransitionsWithIdsError { references }); + result.add_error(BasicError::DuplicateDocumentTransitionsWithIdsError( + DuplicateDocumentTransitionsWithIdsError::new(references), + )); } let duplicate_transitions_by_indices = @@ -317,7 +328,9 @@ fn validate_raw_transitions<'a>( Ok((doc_type, id)) }) .collect::)>, anyhow::Error>>()?; - result.add_error(BasicError::DuplicateDocumentTransitionsWithIndicesError { references }); + result.add_error(BasicError::DuplicateDocumentTransitionsWithIndicesError( + DuplicateDocumentTransitionsWithIndicesError::new(references), + )); } let validation_result = validate_partial_compound_indices( diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_partial_compound_indices.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_partial_compound_indices.rs index 36607a32895..a0dfa9b5bfd 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_partial_compound_indices.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_partial_compound_indices.rs @@ -2,6 +2,7 @@ use std::borrow::Borrow; use serde_json::Value as JsonValue; +use crate::consensus::basic::document::InconsistentCompoundIndexDataError; use crate::{ consensus::basic::BasicError, data_contract::DataContract, @@ -48,10 +49,12 @@ pub fn validate_indices( let properties = index.properties.iter().map(|property| &property.name); if !are_all_properties_defined_or_undefined(properties.clone(), raw_transition) { - validation_result.add_error(BasicError::InconsistentCompoundIndexDataError { - index_properties: properties.map(ToOwned::to_owned).collect(), - document_type: document_type.to_string(), - }) + validation_result.add_error(BasicError::InconsistentCompoundIndexDataError( + InconsistentCompoundIndexDataError::new( + properties.map(ToOwned::to_owned).collect(), + document_type.to_string(), + ), + )) } } diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_batch_transition_state.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_batch_transition_state.rs index c3077785839..a64ec1234b0 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_batch_transition_state.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_batch_transition_state.rs @@ -5,6 +5,7 @@ use futures::future::join_all; use itertools::Itertools; use serde::{Deserialize, Serialize}; +use crate::data_contract::errors::DataContractNotPresentError; use crate::{ block_time_window::validate_time_in_block_time_window::validate_time_in_block_time_window, consensus::ConsensusError, @@ -84,8 +85,10 @@ pub async fn validate_document_transitions( .map(TryInto::try_into) .transpose() .map_err(Into::into)? - .ok_or_else(|| ProtocolError::DataContractNotPresentError { - data_contract_id: data_contract_id.clone(), + .ok_or_else(|| { + ProtocolError::DataContractNotPresentError(DataContractNotPresentError::new( + data_contract_id.clone(), + )) })?; execution_context.add_operations(tmp_execution_context.get_operations()); diff --git a/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs b/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs index 83652786526..3b9bc45a43a 100644 --- a/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs +++ b/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs @@ -2,6 +2,8 @@ use jsonschema::ValidationError; use thiserror::Error; use crate::codes::ErrorWithCode; +use crate::consensus::basic::data_contract::IncompatibleRe2PatternError; +use crate::consensus::basic::decode::ProtocolVersionParsingError; use crate::consensus::basic::identity::{ DuplicatedIdentityPublicKeyError, DuplicatedIdentityPublicKeyIdError, IdentityAssetLockProofLockedTransactionMismatchError, @@ -32,41 +34,41 @@ use super::signature::SignatureError; #[derive(Error, Debug)] //#[cfg_attr(test, derive(Clone))] pub enum ConsensusError { - #[error("{0}")] + #[error(transparent)] JsonSchemaError(JsonSchemaError), - #[error("{0}")] + #[error(transparent)] UnsupportedProtocolVersionError(UnsupportedProtocolVersionError), - #[error("{0}")] + #[error(transparent)] IncompatibleProtocolVersionError(IncompatibleProtocolVersionError), - #[error("{0}")] + #[error(transparent)] DuplicatedIdentityPublicKeyBasicIdError(DuplicatedIdentityPublicKeyIdError), - #[error("{0}")] + #[error(transparent)] InvalidIdentityPublicKeyDataError(InvalidIdentityPublicKeyDataError), - #[error("{0}")] + #[error(transparent)] InvalidIdentityPublicKeySecurityLevelError(InvalidIdentityPublicKeySecurityLevelError), - #[error("{0}")] + #[error(transparent)] DuplicatedIdentityPublicKeyBasicError(DuplicatedIdentityPublicKeyError), - #[error("{0}")] + #[error(transparent)] MissingMasterPublicKeyError(MissingMasterPublicKeyError), - #[error("{0}")] + #[error(transparent)] IdentityAssetLockTransactionOutPointAlreadyExistsError( IdentityAssetLockTransactionOutPointAlreadyExistsError, ), - #[error("{0}")] + #[error(transparent)] InvalidIdentityAssetLockTransactionOutputError(InvalidIdentityAssetLockTransactionOutputError), - #[error("{0}")] + #[error(transparent)] InvalidAssetLockTransactionOutputReturnSize(InvalidAssetLockTransactionOutputReturnSizeError), - #[error("{0}")] + #[error(transparent)] IdentityAssetLockTransactionOutputNotFoundError( IdentityAssetLockTransactionOutputNotFoundError, ), - #[error("{0}")] + #[error(transparent)] InvalidIdentityAssetLockTransactionError(InvalidIdentityAssetLockTransactionError), - #[error("{0}")] + #[error(transparent)] InvalidInstantAssetLockProofError(InvalidInstantAssetLockProofError), - #[error("{0}")] + #[error(transparent)] InvalidInstantAssetLockProofSignatureError(InvalidInstantAssetLockProofSignatureError), - #[error("{0}")] + #[error(transparent)] IdentityAssetLockProofLockedTransactionMismatchError( IdentityAssetLockProofLockedTransactionMismatchError, ), @@ -77,12 +79,12 @@ pub enum ConsensusError { #[error(transparent)] InvalidAssetLockProofTransactionHeightError(InvalidAssetLockProofTransactionHeightError), - #[error("{0}")] + #[error(transparent)] InvalidIdentityCreditWithdrawalTransitionCoreFeeError( InvalidIdentityCreditWithdrawalTransitionCoreFeeError, ), - #[error("{0}")] + #[error(transparent)] InvalidIdentityCreditWithdrawalTransitionOutputScriptError( InvalidIdentityCreditWithdrawalTransitionOutputScriptError, ), @@ -96,17 +98,13 @@ pub enum ConsensusError { #[error("Parsing of serialized object failed due to: {parsing_error}")] SerializedObjectParsingError { parsing_error: anyhow::Error }, - #[error("Can't read protocol version from serialized object: {parsing_error}")] - ProtocolVersionParsingError { parsing_error: anyhow::Error }, + #[error(transparent)] + ProtocolVersionParsingError(ProtocolVersionParsingError), - #[error("Pattern '{pattern}' at '{path}' is not not compatible with Re2: {message}")] - IncompatibleRe2PatternError { - pattern: String, - path: String, - message: String, - }, + #[error(transparent)] + IncompatibleRe2PatternError(IncompatibleRe2PatternError), - #[error("{0}")] + #[error(transparent)] IdentityInsufficientBalanceError(IdentityInsufficientBalanceError), #[error(transparent)] @@ -119,7 +117,7 @@ pub enum ConsensusError { FeeError(FeeError), #[cfg(test)] - #[cfg_attr(test, error("{0}"))] + #[cfg_attr(test, error(transparent))] TestConsensusError(TestConsensusError), } diff --git a/packages/rs-dpp/src/errors/consensus/basic/abstract_basic_error.rs b/packages/rs-dpp/src/errors/consensus/basic/abstract_basic_error.rs index ca52aa8191a..51d6650ba53 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/abstract_basic_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/abstract_basic_error.rs @@ -1,36 +1,47 @@ -use serde_json::Value as JsonValue; use thiserror::Error; -use crate::{identity::KeyID, prelude::*, util::json_schema::Index}; +use crate::consensus::basic::data_contract::{ + DataContractHaveNewUniqueIndexError, DataContractImmutablePropertiesUpdateError, + DataContractInvalidIndexDefinitionUpdateError, DataContractUniqueIndicesChangedError, + DuplicateIndexError, DuplicateIndexNameError, IncompatibleDataContractSchemaError, + InvalidCompoundIndexError, InvalidDataContractIdError, InvalidIndexPropertyTypeError, + InvalidIndexedPropertyConstraintError, InvalidJsonSchemaRefError, + SystemPropertyIndexAlreadyPresentError, UndefinedIndexPropertyError, + UniqueIndicesLimitReachedError, +}; +use crate::consensus::basic::document::{ + DuplicateDocumentTransitionsWithIdsError, DuplicateDocumentTransitionsWithIndicesError, + InconsistentCompoundIndexDataError, InvalidDocumentTransitionActionError, + InvalidDocumentTransitionIdError, InvalidDocumentTypeError, +}; +use crate::consensus::basic::identity::InvalidIdentityKeySignatureError; +use crate::consensus::basic::invalid_data_contract_version_error::InvalidDataContractVersionError; +use crate::consensus::basic::invalid_identifier_error::InvalidIdentifierError; +use crate::consensus::basic::state_transition::{ + InvalidStateTransitionTypeError, StateTransitionMaxSizeExceededError, +}; +use crate::prelude::*; #[derive(Error, Debug)] pub enum BasicError { #[error("Data Contract {data_contract_id} is not present")] DataContractNotPresent { data_contract_id: Identifier }, - #[error("Data Contract version must be {expected_version}, go {version}")] - InvalidDataContractVersionError { expected_version: u32, version: u32 }, + #[error(transparent)] + InvalidDataContractVersionError(InvalidDataContractVersionError), #[error("JSON Schema depth is greater than {0}")] DataContractMaxDepthExceedError(usize), // Document - #[error( - "Data Contract {data_contract_id} doesn't define document with the type {document_type}" - )] - InvalidDocumentTypeError { - document_type: String, - data_contract_id: Identifier, - }, + #[error(transparent)] + InvalidDocumentTypeError(InvalidDocumentTypeError), - #[error("Duplicate index name '{duplicate_index_name}' defined in '{document_type}' document")] - DuplicateIndexNameError { - document_type: String, - duplicate_index_name: String, - }, + #[error(transparent)] + DuplicateIndexNameError(DuplicateIndexNameError), - #[error("Invalid JSON Schema $ref: {ref_error}")] - InvalidJsonSchemaRefError { ref_error: String }, + #[error(transparent)] + InvalidJsonSchemaRefError(InvalidJsonSchemaRefError), #[error(transparent)] IndexError(IndexError), @@ -38,14 +49,8 @@ pub enum BasicError { #[error("{0}")] JsonSchemaCompilationError(String), - #[error( - "Unique compound index properties {:?} are partially set for {document_type}", - index_properties - )] - InconsistentCompoundIndexDataError { - index_properties: Vec, - document_type: String, - }, + #[error(transparent)] + InconsistentCompoundIndexDataError(InconsistentCompoundIndexDataError), #[error("$type is not present")] MissingDocumentTransitionTypeError, @@ -56,97 +61,53 @@ pub enum BasicError { #[error("$action is not present")] MissingDocumentTransitionActionError, - #[error("Document transition action {} is not supported", action)] - InvalidDocumentTransitionActionError { action: String }, + #[error(transparent)] + InvalidDocumentTransitionActionError(InvalidDocumentTransitionActionError), - #[error( - "Invalid document transition id {}, expected {}", - invalid_id, - expected_id - )] - InvalidDocumentTransitionIdError { - expected_id: Identifier, - invalid_id: Identifier, - }, + #[error(transparent)] + InvalidDocumentTransitionIdError(InvalidDocumentTransitionIdError), - #[error("Document transitions with duplicate IDs {:?}", references)] - DuplicateDocumentTransitionsWithIdsError { references: Vec<(String, Vec)> }, + #[error(transparent)] + DuplicateDocumentTransitionsWithIdsError(DuplicateDocumentTransitionsWithIdsError), - #[error( - "Document transitions with duplicate unique properties: {:?}", - references - )] - DuplicateDocumentTransitionsWithIndicesError { references: Vec<(String, Vec)> }, + #[error(transparent)] + DuplicateDocumentTransitionsWithIndicesError(DuplicateDocumentTransitionsWithIndicesError), #[error("$dataContractId is not present")] MissingDataContractIdError, - #[error("Invalid {}: {}", identifier_name, error)] - InvalidIdentifierError { - identifier_name: String, - error: String, - }, - - #[error("Document with type {document_type} has updated unique index named '{index_name}'. Change of unique indices is not allowed")] - DataContractUniqueIndicesChangedError { - document_type: String, - index_name: String, - }, - - #[error("Document with type {document_type} has badly constructed index '{index_name}'. Existing properties in the indices should be defined in the beginning of it. ")] - DataContractInvalidIndexDefinitionUpdateError { - document_type: String, - index_name: String, - }, - - #[error("Document with type {document_type} has a new unique index named '{index_name}'. Adding unique indices during Data Contract update is not allowed.")] - DataContractHaveNewUniqueIndexError { - document_type: String, - index_name: String, - }, - - #[error("Identity {identity_id} not found")] - IdentityNotFoundError { identity_id: Identifier }, + #[error(transparent)] + InvalidIdentifierError(InvalidIdentifierError), + + #[error(transparent)] + DataContractUniqueIndicesChangedError(DataContractUniqueIndicesChangedError), + + #[error(transparent)] + DataContractInvalidIndexDefinitionUpdateError(DataContractInvalidIndexDefinitionUpdateError), + + #[error(transparent)] + DataContractHaveNewUniqueIndexError(DataContractHaveNewUniqueIndexError), #[error("State transition type is not present")] MissingStateTransitionTypeError, - #[error("Invalid State Transition type {transition_type}")] - InvalidStateTransitionTypeError { transition_type: u8 }, - - #[error( - "State transition size {actual_size_kbytes} KB is more than maximum {max_size_kbytes} KB" - )] - StateTransitionMaxSizeExceededError { - actual_size_kbytes: usize, - max_size_kbytes: usize, - }, - - #[error("Only $defs, version and documents fields are allowed to be updated. Forbidden operation '{operation}' on '{field_path}'")] - DataContractImmutablePropertiesUpdateError { - operation: String, - field_path: String, - }, - - #[error( - "Data Contract updated schema is not backward compatible with one defined in Data Contract wid id {data_contract_id}. Field: '{field_path}', Operation: '{operation}'" - )] - IncompatibleDataContractSchemaError { - data_contract_id: Identifier, - operation: String, - field_path: String, - old_schema: JsonValue, - new_schema: JsonValue, - }, - - #[error("Identity key {public_key_id} has invalid signature")] - InvalidIdentityKeySignatureError { public_key_id: KeyID }, - - #[error("Data Contract Id must be {}, got {}", bs58::encode(expected_id).into_string(), bs58::encode(invalid_id).into_string())] - InvalidDataContractIdError { - expected_id: Vec, - invalid_id: Vec, - }, + #[error(transparent)] + InvalidStateTransitionTypeError(InvalidStateTransitionTypeError), + + #[error(transparent)] + StateTransitionMaxSizeExceededError(StateTransitionMaxSizeExceededError), + + #[error(transparent)] + DataContractImmutablePropertiesUpdateError(DataContractImmutablePropertiesUpdateError), + + #[error(transparent)] + IncompatibleDataContractSchemaError(IncompatibleDataContractSchemaError), + + #[error(transparent)] + InvalidIdentityKeySignatureError(InvalidIdentityKeySignatureError), + + #[error(transparent)] + InvalidDataContractIdError(InvalidDataContractIdError), } impl From for BasicError { @@ -157,54 +118,24 @@ impl From for BasicError { #[derive(Error, Debug)] pub enum IndexError { - #[error("'{document_type}' document has more than '{index_limit}' unique indexes")] - UniqueIndicesLimitReachedError { - document_type: String, - index_limit: usize, - }, - - #[error("System property '{property_name}' is already indexed and can't be used in other indices for '{document_type}' document")] - SystemPropertyIndexAlreadyPresentError { - document_type: String, - index_definition: Index, - property_name: String, - }, - - #[error("'{property_name}' property is not defined in the '{document_type}' document")] - UndefinedIndexPropertyError { - document_type: String, - index_definition: Index, - property_name: String, - }, - - #[error("'{property_name}' property ofr '{document_type}' document has an invalid type '{property_type}' and cannot be use as an index")] - InvalidIndexPropertyTypeError { - document_type: String, - index_definition: Index, - property_name: String, - property_type: String, - }, - - #[error("Indexed property '{property_name}' for '{document_type}' document has an invalid constraint '{constraint_name}', reason: '{reason}'")] - InvalidIndexedPropertyConstraintError { - document_type: String, - index_definition: Index, - property_name: String, - constraint_name: String, - reason: String, - }, - - #[error( - "All or none of unique compound properties must be set for '{document_type}' document" - )] - InvalidCompoundIndexError { - document_type: String, - index_definition: Index, - }, - - #[error("Duplicate index definition for '{document_type} document")] - DuplicateIndexError { - document_type: String, - index_definition: Index, - }, + #[error(transparent)] + UniqueIndicesLimitReachedError(UniqueIndicesLimitReachedError), + + #[error(transparent)] + SystemPropertyIndexAlreadyPresentError(SystemPropertyIndexAlreadyPresentError), + + #[error(transparent)] + UndefinedIndexPropertyError(UndefinedIndexPropertyError), + + #[error(transparent)] + InvalidIndexPropertyTypeError(InvalidIndexPropertyTypeError), + + #[error(transparent)] + InvalidIndexedPropertyConstraintError(InvalidIndexedPropertyConstraintError), + + #[error(transparent)] + InvalidCompoundIndexError(InvalidCompoundIndexError), + + #[error(transparent)] + DuplicateIndexError(DuplicateIndexError), } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs new file mode 100644 index 00000000000..0a84103f91f --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs @@ -0,0 +1,33 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Document with type {document_type} has a new unique index named '{index_name}'. Adding unique indices during Data Contract update is not allowed.")] +pub struct DataContractHaveNewUniqueIndexError { + document_type: String, + index_name: String, +} + +impl DataContractHaveNewUniqueIndexError { + pub fn new(document_type: String, index_name: String) -> Self { + Self { + document_type, + index_name, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + + pub fn index_name(&self) -> String { + self.index_name.clone() + } +} + +impl From for ConsensusError { + fn from(err: DataContractHaveNewUniqueIndexError) -> Self { + Self::DataContractHaveNewUniqueIndexError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs new file mode 100644 index 00000000000..4c2e49886b6 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs @@ -0,0 +1,33 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Only $defs, version and documents fields are allowed to be updated. Forbidden operation '{operation}' on '{field_path}'")] +pub struct DataContractImmutablePropertiesUpdateError { + operation: String, + field_path: String, +} + +impl DataContractImmutablePropertiesUpdateError { + pub fn new(operation: String, field_path: String) -> Self { + Self { + operation, + field_path, + } + } + + pub fn operation(&self) -> String { + self.operation.clone() + } + + pub fn field_path(&self) -> String { + self.field_path.clone() + } +} + +impl From for ConsensusError { + fn from(err: DataContractImmutablePropertiesUpdateError) -> Self { + Self::DataContractImmutablePropertiesUpdateError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs new file mode 100644 index 00000000000..9159c2d5ab3 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs @@ -0,0 +1,33 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Document with type {document_type} has badly constructed index '{index_name}'. Existing properties in the indices should be defined in the beginning of it.")] +pub struct DataContractInvalidIndexDefinitionUpdateError { + document_type: String, + index_name: String, +} + +impl DataContractInvalidIndexDefinitionUpdateError { + pub fn new(document_type: String, index_name: String) -> Self { + Self { + document_type, + index_name, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + + pub fn index_name(&self) -> String { + self.index_name.clone() + } +} + +impl From for ConsensusError { + fn from(err: DataContractInvalidIndexDefinitionUpdateError) -> Self { + Self::DataContractInvalidIndexDefinitionUpdateError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs new file mode 100644 index 00000000000..f142d420c4d --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs @@ -0,0 +1,33 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Document with type {document_type} has updated unique index named '{index_name}'. Change of unique indices is not allowed")] +pub struct DataContractUniqueIndicesChangedError { + document_type: String, + index_name: String, +} + +impl DataContractUniqueIndicesChangedError { + pub fn new(document_type: String, index_name: String) -> Self { + Self { + document_type, + index_name, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + + pub fn index_name(&self) -> String { + self.index_name.clone() + } +} + +impl From for ConsensusError { + fn from(err: DataContractUniqueIndicesChangedError) -> Self { + Self::DataContractUniqueIndicesChangedError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs new file mode 100644 index 00000000000..ef5f818c6b0 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs @@ -0,0 +1,34 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::data_contract::document_type::Index; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Duplicate index definition for '{document_type} document")] +pub struct DuplicateIndexError { + document_type: String, + index_definition: Index, +} + +impl DuplicateIndexError { + pub fn new(document_type: String, index_definition: Index) -> Self { + Self { + document_type, + index_definition, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + + pub fn index_definition(&self) -> Index { + self.index_definition.clone() + } +} + +impl From for ConsensusError { + fn from(err: DuplicateIndexError) -> Self { + Self::DuplicateIndexError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs new file mode 100644 index 00000000000..3584efa1e12 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs @@ -0,0 +1,33 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Duplicate index name '{duplicate_index_name}' defined in '{document_type}' document")] +pub struct DuplicateIndexNameError { + document_type: String, + duplicate_index_name: String, +} + +impl DuplicateIndexNameError { + pub fn new(document_type: String, duplicate_index_name: String) -> Self { + Self { + document_type, + duplicate_index_name, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + + pub fn duplicate_index_name(&self) -> String { + self.duplicate_index_name.clone() + } +} + +impl From for ConsensusError { + fn from(err: DuplicateIndexNameError) -> Self { + Self::DuplicateIndexNameError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs new file mode 100644 index 00000000000..d08454d2372 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs @@ -0,0 +1,56 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::document::document_transition::document_base_transition::JsonValue; +use crate::identifier::Identifier; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Data Contract updated schema is not backward compatible with one defined in Data Contract wid id {data_contract_id}. Field: '{field_path}', Operation: '{operation}'" +)] +pub struct IncompatibleDataContractSchemaError { + data_contract_id: Identifier, + operation: String, + field_path: String, + old_schema: JsonValue, + new_schema: JsonValue, +} + +impl IncompatibleDataContractSchemaError { + pub fn new( + data_contract_id: Identifier, + operation: String, + field_path: String, + old_schema: JsonValue, + new_schema: JsonValue, + ) -> Self { + Self { + data_contract_id, + operation, + field_path, + old_schema, + new_schema, + } + } + + pub fn data_contract_id(&self) -> Identifier { + self.data_contract_id.clone() + } + pub fn operation(&self) -> String { + self.operation.clone() + } + pub fn field_path(&self) -> String { + self.field_path.clone() + } + pub fn old_schema(&self) -> JsonValue { + self.old_schema.clone() + } + pub fn new_schema(&self) -> JsonValue { + self.new_schema.clone() + } +} + +impl From for ConsensusError { + fn from(err: IncompatibleDataContractSchemaError) -> Self { + Self::IncompatibleDataContractSchemaError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_re2_pattern_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_re2_pattern_error.rs new file mode 100644 index 00000000000..de6a38e254c --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_re2_pattern_error.rs @@ -0,0 +1,39 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Pattern '{pattern}' at '{path}' is not not compatible with Re2: {message}")] +pub struct IncompatibleRe2PatternError { + pattern: String, + path: String, + message: String, +} + +impl IncompatibleRe2PatternError { + pub fn new(pattern: String, path: String, message: String) -> Self { + Self { + pattern, + path, + message, + } + } + + pub fn pattern(&self) -> String { + self.pattern.clone() + } + + pub fn path(&self) -> String { + self.path.clone() + } + + pub fn message(&self) -> String { + self.message.clone() + } +} + +impl From for ConsensusError { + fn from(err: IncompatibleRe2PatternError) -> Self { + Self::IncompatibleRe2PatternError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs new file mode 100644 index 00000000000..ded7d9baf64 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs @@ -0,0 +1,36 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::data_contract::document_type::Index; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("All or none of unique compound properties must be set for '{document_type}' document")] +pub struct InvalidCompoundIndexError { + document_type: String, + index_definition: Index, +} + +impl InvalidCompoundIndexError { + pub fn new( + document_type: String, + index_definition: Index, + ) -> Self { + Self { + document_type, + index_definition, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + pub fn index_definition(&self) -> Index { + self.index_definition.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidCompoundIndexError) -> Self { + Self::InvalidCompoundIndexError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs new file mode 100644 index 00000000000..e8d2f71dc0a --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs @@ -0,0 +1,32 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Data Contract Id must be {}, got {}", bs58::encode(expected_id).into_string(), bs58::encode(invalid_id).into_string())] +pub struct InvalidDataContractIdError { + expected_id: Vec, + invalid_id: Vec, +} + +impl InvalidDataContractIdError { + pub fn new(expected_id: Vec, invalid_id: Vec) -> Self { + Self { + expected_id, + invalid_id, + } + } + + pub fn expected_id(&self) -> Vec { + self.expected_id.clone() + } + pub fn invalid_id(&self) -> Vec { + self.invalid_id.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidDataContractIdError) -> Self { + Self::InvalidDataContractIdError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs new file mode 100644 index 00000000000..6d4d345843d --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs @@ -0,0 +1,48 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::data_contract::document_type::Index; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("'{property_name}' property of '{document_type}' document has an invalid type '{property_type}' and cannot be use as an index")] +pub struct InvalidIndexPropertyTypeError { + document_type: String, + index_definition: Index, + property_name: String, + property_type: String, +} + +impl InvalidIndexPropertyTypeError { + pub fn new( + document_type: String, + index_definition: Index, + property_name: String, + property_type: String, + ) -> Self { + Self { + document_type, + index_definition, + property_name, + property_type, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + pub fn index_definition(&self) -> Index { + self.index_definition.clone() + } + pub fn property_name(&self) -> String { + self.property_name.clone() + } + pub fn property_type(&self) -> String { + self.property_type.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidIndexPropertyTypeError) -> Self { + Self::UndefinedIndexPropertyError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs new file mode 100644 index 00000000000..1e9d2e0ae8c --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs @@ -0,0 +1,54 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::data_contract::document_type::Index; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Indexed property '{property_name}' for '{document_type}' document has an invalid constraint '{constraint_name}', reason: '{reason}'")] +pub struct InvalidIndexedPropertyConstraintError { + document_type: String, + index_definition: Index, + property_name: String, + constraint_name: String, + reason: String, +} + +impl InvalidIndexedPropertyConstraintError { + pub fn new( + document_type: String, + index_definition: Index, + property_name: String, + constraint_name: String, + reason: String, + ) -> Self { + Self { + document_type, + index_definition, + property_name, + constraint_name, + reason, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + pub fn index_definition(&self) -> Index { + self.index_definition.clone() + } + pub fn property_name(&self) -> String { + self.property_name.clone() + } + pub fn constraint_name(&self) -> String { + self.constraint_name.clone() + } + pub fn reason(&self) -> String { + self.reason.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidIndexedPropertyConstraintError) -> Self { + Self::InvalidIndexedPropertyConstraintError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs new file mode 100644 index 00000000000..5874e2fb9c6 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs @@ -0,0 +1,25 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid JSON Schema $ref: {ref_error}")] +pub struct InvalidJsonSchemaRefError { + ref_error: String, +} + +impl InvalidJsonSchemaRefError { + pub fn new(ref_error: String) -> Self { + Self { ref_error } + } + + pub fn ref_error(&self) -> String { + self.ref_error.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidJsonSchemaRefError) -> Self { + Self::InvalidJsonSchemaRefError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/mod.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/mod.rs new file mode 100644 index 00000000000..b654b75be26 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/mod.rs @@ -0,0 +1,34 @@ +mod data_contract_have_new_unique_index_error; +mod data_contract_immutable_properties_update_error; +mod data_contract_invalid_index_definition_update_error; +mod data_contract_unique_indices_changed_error; +mod duplicate_index_error; +mod duplicate_index_name_error; +mod incompatible_data_contract_schema_error; +mod incompatible_re2_pattern_error; +mod invalid_compound_index_error; +mod invalid_data_contract_id_error; +mod invalid_index_property_type_error; +mod invalid_indexed_property_constraint_error; +mod invalid_json_schema_ref_error; +mod system_property_index_already_present_error; +mod undefined_index_property_error; +mod unique_indices_limit_reached_error; + +pub use data_contract_have_new_unique_index_error::*; +pub use data_contract_immutable_properties_update_error::*; +pub use data_contract_invalid_index_definition_update_error::*; +pub use data_contract_unique_indices_changed_error::*; +pub use duplicate_index_error::*; +pub use duplicate_index_name_error::*; +pub use incompatible_data_contract_schema_error::*; +pub use incompatible_re2_pattern_error::*; +pub use invalid_compound_index_error::*; +pub use invalid_data_contract_id_error::*; +pub use invalid_index_property_type_error::*; +pub use invalid_indexed_property_constraint_error::*; +pub use invalid_json_schema_ref_error::*; +pub use invalid_json_schema_ref_error::*; +pub use system_property_index_already_present_error::*; +pub use undefined_index_property_error::*; +pub use unique_indices_limit_reached_error::*; diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs new file mode 100644 index 00000000000..987117630cd --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs @@ -0,0 +1,38 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::data_contract::document_type::Index; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("System property '{property_name}' is already indexed and can't be used in other indices for '{document_type}' document")] +pub struct SystemPropertyIndexAlreadyPresentError { + document_type: String, + index_definition: Index, + property_name: String, +} + +impl SystemPropertyIndexAlreadyPresentError { + pub fn new(document_type: String, index_definition: Index, property_name: String) -> Self { + Self { + document_type, + index_definition, + property_name, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + pub fn index_definition(&self) -> Index { + self.index_definition.clone() + } + pub fn property_name(&self) -> String { + self.property_name.clone() + } +} + +impl From for ConsensusError { + fn from(err: SystemPropertyIndexAlreadyPresentError) -> Self { + Self::SystemPropertyIndexAlreadyPresentError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs new file mode 100644 index 00000000000..2a16627456a --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs @@ -0,0 +1,38 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::data_contract::document_type::Index; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("'{property_name}' property is not defined in the '{document_type}' document")] +pub struct UndefinedIndexPropertyError { + document_type: String, + index_definition: Index, + property_name: String, +} + +impl UndefinedIndexPropertyError { + pub fn new(document_type: String, index_definition: Index, property_name: String) -> Self { + Self { + document_type, + index_definition, + property_name, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + pub fn index_definition(&self) -> Index { + self.index_definition.clone() + } + pub fn property_name(&self) -> String { + self.property_name.clone() + } +} + +impl From for ConsensusError { + fn from(err: UndefinedIndexPropertyError) -> Self { + Self::UndefinedIndexPropertyError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs new file mode 100644 index 00000000000..c9cf7938d6b --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs @@ -0,0 +1,32 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("'{document_type}' document has more than '{index_limit}' unique indexes")] +pub struct UniqueIndicesLimitReachedError { + document_type: String, + index_limit: usize, +} + +impl UniqueIndicesLimitReachedError { + pub fn new(document_type: String, index_limit: usize) -> Self { + Self { + document_type, + index_limit, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + pub fn index_limit(&self) -> usize { + self.index_limit + } +} + +impl From for ConsensusError { + fn from(err: UniqueIndicesLimitReachedError) -> Self { + Self::UniqueIndicesLimitReachedError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/decode/mod.rs b/packages/rs-dpp/src/errors/consensus/basic/decode/mod.rs new file mode 100644 index 00000000000..2032dac6bbd --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/decode/mod.rs @@ -0,0 +1,2 @@ +mod protocol_version_parsing_error; +pub use protocol_version_parsing_error::*; diff --git a/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs b/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs new file mode 100644 index 00000000000..d6a7ed11212 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs @@ -0,0 +1,21 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug)] +#[error("Can't read protocol version from serialized object: {parsing_error}")] +pub struct ProtocolVersionParsingError { + parsing_error: anyhow::Error, +} + +impl ProtocolVersionParsingError { + pub fn new(parsing_error: anyhow::Error) -> Self { + Self { parsing_error } + } +} + +impl From for ConsensusError { + fn from(err: ProtocolVersionParsingError) -> Self { + Self::ProtocolVersionParsingError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs new file mode 100644 index 00000000000..37e2ca92954 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs @@ -0,0 +1,25 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Document transitions with duplicate IDs {:?}", references)] +pub struct DuplicateDocumentTransitionsWithIdsError { + references: Vec<(String, Vec)>, +} + +impl DuplicateDocumentTransitionsWithIdsError { + pub fn new(references: Vec<(String, Vec)>) -> Self { + Self { references } + } + + pub fn references(&self) -> Vec<(String, Vec)> { + self.references.clone() + } +} + +impl From for ConsensusError { + fn from(err: DuplicateDocumentTransitionsWithIdsError) -> Self { + Self::DuplicateDocumentTransitionsWithIdsError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs new file mode 100644 index 00000000000..9236d7e1267 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs @@ -0,0 +1,28 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error( + "Document transitions with duplicate unique properties: {:?}", + references +)] +pub struct DuplicateDocumentTransitionsWithIndicesError { + references: Vec<(String, Vec)>, +} + +impl DuplicateDocumentTransitionsWithIndicesError { + pub fn new(references: Vec<(String, Vec)>) -> Self { + Self { references } + } + + pub fn references(&self) -> Vec<(String, Vec)> { + self.references.clone() + } +} + +impl From for ConsensusError { + fn from(err: DuplicateDocumentTransitionsWithIndicesError) -> Self { + Self::DuplicateDocumentTransitionsWithIndicesError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs new file mode 100644 index 00000000000..dd8e97dd918 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs @@ -0,0 +1,35 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error( + "Unique compound index properties {:?} are partially set for {document_type}", + index_properties +)] +pub struct InconsistentCompoundIndexDataError { + index_properties: Vec, + document_type: String, +} + +impl InconsistentCompoundIndexDataError { + pub fn new(index_properties: Vec, document_type: String) -> Self { + Self { + index_properties, + document_type, + } + } + + pub fn index_properties(&self) -> Vec { + self.index_properties.clone() + } + pub fn document_type(&self) -> String { + self.document_type.clone() + } +} + +impl From for ConsensusError { + fn from(err: InconsistentCompoundIndexDataError) -> Self { + Self::InconsistentCompoundIndexDataError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs new file mode 100644 index 00000000000..188e3e2837e --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs @@ -0,0 +1,25 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Document transition action {} is not supported", action)] +pub struct InvalidDocumentTransitionActionError { + action: String, +} + +impl InvalidDocumentTransitionActionError { + pub fn new(action: String) -> Self { + Self { action } + } + + pub fn action(&self) -> String { + self.action.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidDocumentTransitionActionError) -> Self { + Self::InvalidDocumentTransitionActionError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs new file mode 100644 index 00000000000..25e1e604957 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs @@ -0,0 +1,38 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identifier::Identifier; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error( + "Invalid document transition id {}, expected {}", + invalid_id, + expected_id +)] +pub struct InvalidDocumentTransitionIdError { + expected_id: Identifier, + invalid_id: Identifier, +} + +impl InvalidDocumentTransitionIdError { + pub fn new(expected_id: Identifier, invalid_id: Identifier) -> Self { + Self { + expected_id, + invalid_id, + } + } + + pub fn expected_id(&self) -> Identifier { + self.expected_id.clone() + } + + pub fn invalid_id(&self) -> Identifier { + self.invalid_id.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidDocumentTransitionIdError) -> Self { + Self::InvalidDocumentTransitionIdError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs new file mode 100644 index 00000000000..5b473da338a --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs @@ -0,0 +1,34 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identifier::Identifier; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Data Contract {data_contract_id} doesn't define document with the type {document_type}")] +pub struct InvalidDocumentTypeError { + document_type: String, + data_contract_id: Identifier, +} + +impl InvalidDocumentTypeError { + pub fn new(document_type: String, data_contract_id: Identifier) -> Self { + Self { + document_type, + data_contract_id, + } + } + + pub fn document_type(&self) -> String { + self.document_type.clone() + } + + pub fn data_contract_id(&self) -> Identifier { + self.data_contract_id.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidDocumentTypeError) -> Self { + Self::InvalidDocumentTypeError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/mod.rs b/packages/rs-dpp/src/errors/consensus/basic/document/mod.rs new file mode 100644 index 00000000000..15f2d90bd90 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/document/mod.rs @@ -0,0 +1,13 @@ +mod duplicate_document_transitions_with_ids_error; +mod duplicate_document_transitions_with_indices_error; +mod inconsistent_compound_index_data_error; +mod invalid_document_transition_action_error; +mod invalid_document_transition_id_error; +mod invalid_document_type_error; + +pub use duplicate_document_transitions_with_ids_error::*; +pub use duplicate_document_transitions_with_indices_error::*; +pub use inconsistent_compound_index_data_error::*; +pub use invalid_document_transition_action_error::*; +pub use invalid_document_transition_id_error::*; +pub use invalid_document_type_error::*; diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs new file mode 100644 index 00000000000..ca8b1293881 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs @@ -0,0 +1,26 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identity::KeyID; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Identity key {public_key_id} has invalid signature")] +pub struct InvalidIdentityKeySignatureError { + public_key_id: KeyID, +} + +impl InvalidIdentityKeySignatureError { + pub fn new(public_key_id: KeyID) -> Self { + Self { public_key_id } + } + + pub fn public_key_id(&self) -> KeyID { + self.public_key_id.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidIdentityKeySignatureError) -> Self { + Self::InvalidIdentityKeySignatureError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs index 80d65e7a8ac..e010b763130 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/mod.rs @@ -12,6 +12,7 @@ pub use invalid_credit_withdrawal_transition_core_fee_error::*; pub use invalid_credit_withdrawal_transition_output_script_error::*; pub use invalid_identity_asset_lock_transaction_error::*; pub use invalid_identity_asset_lock_transaction_output_error::*; +pub use invalid_identity_key_signature_error::*; pub use invalid_identity_public_key_data_error::*; pub use invalid_identity_public_key_security_level_error::*; pub use invalid_instant_asset_lock_proof_error::*; @@ -32,6 +33,7 @@ mod invalid_credit_withdrawal_transition_core_fee_error; mod invalid_credit_withdrawal_transition_output_script_error; mod invalid_identity_asset_lock_transaction_error; mod invalid_identity_asset_lock_transaction_output_error; +mod invalid_identity_key_signature_error; mod invalid_identity_public_key_data_error; mod invalid_identity_public_key_security_level_error; mod invalid_instant_asset_lock_proof_error; diff --git a/packages/rs-dpp/src/errors/consensus/basic/invalid_data_contract_version_error.rs b/packages/rs-dpp/src/errors/consensus/basic/invalid_data_contract_version_error.rs new file mode 100644 index 00000000000..16b21013d30 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/invalid_data_contract_version_error.rs @@ -0,0 +1,33 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Data Contract version must be {expected_version}, go {version}")] +pub struct InvalidDataContractVersionError { + expected_version: u32, + version: u32, +} + +impl InvalidDataContractVersionError { + pub fn new(expected_version: u32, version: u32) -> Self { + Self { + expected_version, + version, + } + } + + pub fn expected_version(&self) -> u32 { + self.expected_version + } + + pub fn version(&self) -> u32 { + self.version + } +} + +impl From for ConsensusError { + fn from(err: InvalidDataContractVersionError) -> Self { + Self::InvalidDataContractVersionError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs b/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs new file mode 100644 index 00000000000..b458b2a9d8f --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs @@ -0,0 +1,33 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid {}: {}", identifier_name, error)] +pub struct InvalidIdentifierError { + identifier_name: String, + error: String, +} + +impl InvalidIdentifierError { + pub fn new(identifier_name: String, error: String) -> Self { + Self { + identifier_name, + error, + } + } + + pub fn identifier_name(&self) -> String { + self.identifier_name.clone() + } + + pub fn error(&self) -> String { + self.error.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidIdentifierError) -> Self { + Self::InvalidIdentifierError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/mod.rs b/packages/rs-dpp/src/errors/consensus/basic/mod.rs index 252f6d0943e..f9d16f0a3a6 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/mod.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/mod.rs @@ -5,11 +5,17 @@ pub use json_schema_error::*; pub use test_consensus_error::*; pub use unsupported_protocol_version_error::*; +pub mod data_contract; +pub mod decode; +pub mod document; pub mod identity; -mod incompatible_protocol_version_error; -mod json_schema_error; +pub mod incompatible_protocol_version_error; +pub mod json_schema_error; #[cfg(test)] -mod test_consensus_error; -mod unsupported_protocol_version_error; +pub mod test_consensus_error; +pub mod unsupported_protocol_version_error; -mod abstract_basic_error; +pub mod abstract_basic_error; +pub mod invalid_data_contract_version_error; +pub mod invalid_identifier_error; +pub mod state_transition; diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs new file mode 100644 index 00000000000..5cf440c4e16 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs @@ -0,0 +1,25 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid State Transition type {transition_type}")] +pub struct InvalidStateTransitionTypeError { + transition_type: u8, +} + +impl InvalidStateTransitionTypeError { + pub fn new(transition_type: u8) -> Self { + Self { transition_type } + } + + pub fn transition_type(&self) -> u8 { + self.transition_type + } +} + +impl From for ConsensusError { + fn from(err: InvalidStateTransitionTypeError) -> Self { + Self::InvalidStateTransitionTypeError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/mod.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/mod.rs new file mode 100644 index 00000000000..eccba51d965 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/mod.rs @@ -0,0 +1,5 @@ +mod invalid_state_transition_type_error; +mod state_transition_max_size_exceeded_error; + +pub use invalid_state_transition_type_error::*; +pub use state_transition_max_size_exceeded_error::*; diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs new file mode 100644 index 00000000000..596d442959f --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs @@ -0,0 +1,32 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("State transition size {actual_size_kbytes} KB is more than maximum {max_size_kbytes} KB")] +pub struct StateTransitionMaxSizeExceededError { + actual_size_kbytes: usize, + max_size_kbytes: usize, +} + +impl StateTransitionMaxSizeExceededError { + pub fn new(actual_size_kbytes: usize, max_size_kbytes: usize) -> Self { + Self { + actual_size_kbytes, + max_size_kbytes, + } + } + + pub fn actual_size_kbytes(&self) -> usize { + self.actual_size_kbytes + } + pub fn max_size_kbytes(&self) -> usize { + self.max_size_kbytes + } +} + +impl From for ConsensusError { + fn from(err: StateTransitionMaxSizeExceededError) -> Self { + Self::StateTransitionMaxSizeExceededError(err) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/signature/identity_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/signature/identity_not_found_error.rs new file mode 100644 index 00000000000..18613962366 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/signature/identity_not_found_error.rs @@ -0,0 +1,27 @@ +use thiserror::Error; + +use crate::consensus::signature::SignatureError; +use crate::consensus::ConsensusError; +use crate::identifier::Identifier; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Identity {identity_id} not found")] +pub struct IdentityNotFoundError { + identity_id: Identifier, +} + +impl IdentityNotFoundError { + pub fn new(identity_id: Identifier) -> Self { + Self { identity_id } + } + + pub fn identity_id(&self) -> Identifier { + self.identity_id.clone() + } +} + +impl From for ConsensusError { + fn from(err: IdentityNotFoundError) -> Self { + Self::SignatureError(SignatureError::IdentityNotFoundError(err)) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/signature/invalid_identity_public_key_type_error.rs b/packages/rs-dpp/src/errors/consensus/signature/invalid_identity_public_key_type_error.rs new file mode 100644 index 00000000000..cbd77b97495 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/signature/invalid_identity_public_key_type_error.rs @@ -0,0 +1,27 @@ +use thiserror::Error; + +use crate::consensus::signature::SignatureError; +use crate::consensus::ConsensusError; +use crate::identity::KeyType; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Unsupported signature type {public_key_type}. Please use ECDSA (0), BLS (1) or ECDSA_HASH160 (2) keys to sign the state transition")] +pub struct InvalidIdentityPublicKeyTypeError { + public_key_type: KeyType, +} + +impl InvalidIdentityPublicKeyTypeError { + pub fn new(public_key_type: KeyType) -> Self { + Self { public_key_type } + } + + pub fn public_key_type(&self) -> KeyType { + self.public_key_type.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidIdentityPublicKeyTypeError) -> Self { + Self::SignatureError(SignatureError::InvalidIdentityPublicKeyTypeError(err)) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_security_level_error.rs b/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_security_level_error.rs new file mode 100644 index 00000000000..cf155a36d76 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_security_level_error.rs @@ -0,0 +1,39 @@ +use thiserror::Error; + +use crate::consensus::signature::SignatureError; +use crate::consensus::ConsensusError; +use crate::identity::SecurityLevel; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid public key security level {public_key_security_level}. The state transition requires {required_key_security_level}")] +pub struct InvalidSignaturePublicKeySecurityLevelError { + public_key_security_level: SecurityLevel, + required_key_security_level: SecurityLevel, +} + +impl InvalidSignaturePublicKeySecurityLevelError { + pub fn new( + public_key_security_level: SecurityLevel, + required_key_security_level: SecurityLevel, + ) -> Self { + Self { + public_key_security_level, + required_key_security_level, + } + } + + pub fn public_key_security_level(&self) -> SecurityLevel { + self.public_key_security_level.clone() + } + pub fn required_key_security_level(&self) -> SecurityLevel { + self.required_key_security_level.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidSignaturePublicKeySecurityLevelError) -> Self { + Self::SignatureError(SignatureError::InvalidSignaturePublicKeySecurityLevelError( + err, + )) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs b/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs new file mode 100644 index 00000000000..004231bd747 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs @@ -0,0 +1,26 @@ +use thiserror::Error; + +use crate::consensus::signature::SignatureError; +use crate::consensus::ConsensusError; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Public key {public_key_id} doesn't exist")] +pub struct MissingPublicKeyError { + public_key_id: u64, +} + +impl MissingPublicKeyError { + pub fn new(public_key_id: u64) -> Self { + Self { public_key_id } + } + + pub fn public_key_id(&self) -> u64 { + self.public_key_id + } +} + +impl From for ConsensusError { + fn from(err: MissingPublicKeyError) -> Self { + Self::SignatureError(SignatureError::MissingPublicKeyError(err)) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/signature/mod.rs b/packages/rs-dpp/src/errors/consensus/signature/mod.rs index 76b20f640a1..db3f3895781 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/mod.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/mod.rs @@ -1,42 +1,44 @@ +mod identity_not_found_error; +mod invalid_identity_public_key_type_error; +mod invalid_signature_public_key_security_level_error; +mod missing_public_key_error; +mod public_key_is_disabled_error; +mod public_key_security_level_not_met_error; +mod wrong_public_key_purpose_error; + use thiserror::Error; -use crate::{ - identity::{KeyID, KeyType, Purpose, SecurityLevel}, - prelude::Identifier, -}; +pub use crate::consensus::signature::identity_not_found_error::IdentityNotFoundError; +pub use crate::consensus::signature::invalid_identity_public_key_type_error::InvalidIdentityPublicKeyTypeError; +pub use crate::consensus::signature::invalid_signature_public_key_security_level_error::InvalidSignaturePublicKeySecurityLevelError; +pub use crate::consensus::signature::missing_public_key_error::MissingPublicKeyError; +pub use crate::consensus::signature::public_key_is_disabled_error::PublicKeyIsDisabledError; +pub use crate::consensus::signature::public_key_security_level_not_met_error::PublicKeySecurityLevelNotMetError; +pub use crate::consensus::signature::wrong_public_key_purpose_error::WrongPublicKeyPurposeError; #[derive(Error, Debug)] pub enum SignatureError { - #[error("Public key {public_key_id} doesn't exist")] - MissingPublicKeyError { public_key_id: u64 }, + #[error(transparent)] + MissingPublicKeyError(MissingPublicKeyError), - #[error("Unsupported signature type {public_key_type}. Please use ECDSA (0), BLS (1) or ECDSA_HASH160 (2) keys to sign the state transition")] - InvalidIdentityPublicKeyTypeError { public_key_type: KeyType }, + #[error(transparent)] + InvalidIdentityPublicKeyTypeError(InvalidIdentityPublicKeyTypeError), #[error("Invalid State Transition signature")] InvalidStateTransitionSignatureError, - #[error("Identity {identity_id} not found")] - IdentityNotFoundError { identity_id: Identifier }, - - #[error("Invalid public key security level {public_key_security_level}. The state transition requires {required_key_security_level}")] - InvalidSignaturePublicKeySecurityLevelError { - public_key_security_level: SecurityLevel, - required_key_security_level: SecurityLevel, - }, - - #[error("Identity key {public_key_id} is disabled")] - PublicKeyIsDisabledError { public_key_id: KeyID }, - - #[error("Invalid security level {public_key_security_level}. This state transition requires at least {required_security_level}")] - PublicKeySecurityLevelNotMetError { - public_key_security_level: SecurityLevel, - required_security_level: SecurityLevel, - }, - - #[error("Invalid identity key purpose {public_key_purpose}. This state transition requires {key_purpose_requirement}")] - WrongPublicKeyPurposeError { - public_key_purpose: Purpose, - key_purpose_requirement: Purpose, - }, + #[error(transparent)] + IdentityNotFoundError(IdentityNotFoundError), + + #[error(transparent)] + InvalidSignaturePublicKeySecurityLevelError(InvalidSignaturePublicKeySecurityLevelError), + + #[error(transparent)] + PublicKeyIsDisabledError(PublicKeyIsDisabledError), + + #[error(transparent)] + PublicKeySecurityLevelNotMetError(PublicKeySecurityLevelNotMetError), + + #[error(transparent)] + WrongPublicKeyPurposeError(WrongPublicKeyPurposeError), } diff --git a/packages/rs-dpp/src/errors/consensus/signature/public_key_is_disabled_error.rs b/packages/rs-dpp/src/errors/consensus/signature/public_key_is_disabled_error.rs new file mode 100644 index 00000000000..067d3975492 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/signature/public_key_is_disabled_error.rs @@ -0,0 +1,27 @@ +use thiserror::Error; + +use crate::consensus::signature::SignatureError; +use crate::consensus::ConsensusError; +use crate::identity::KeyID; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Identity key {public_key_id} is disabled")] +pub struct PublicKeyIsDisabledError { + public_key_id: KeyID, +} + +impl PublicKeyIsDisabledError { + pub fn new(public_key_id: KeyID) -> Self { + Self { public_key_id } + } + + pub fn public_key_id(&self) -> KeyID { + self.public_key_id.clone() + } +} + +impl From for ConsensusError { + fn from(err: PublicKeyIsDisabledError) -> Self { + Self::SignatureError(SignatureError::PublicKeyIsDisabledError(err)) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/signature/public_key_security_level_not_met_error.rs b/packages/rs-dpp/src/errors/consensus/signature/public_key_security_level_not_met_error.rs new file mode 100644 index 00000000000..d959065038f --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/signature/public_key_security_level_not_met_error.rs @@ -0,0 +1,37 @@ +use thiserror::Error; + +use crate::consensus::signature::SignatureError; +use crate::consensus::ConsensusError; +use crate::identity::SecurityLevel; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid security level {public_key_security_level}. This state transition requires at least {required_security_level}")] +pub struct PublicKeySecurityLevelNotMetError { + public_key_security_level: SecurityLevel, + required_security_level: SecurityLevel, +} + +impl PublicKeySecurityLevelNotMetError { + pub fn new( + public_key_security_level: SecurityLevel, + required_security_level: SecurityLevel, + ) -> Self { + Self { + public_key_security_level, + required_security_level, + } + } + + pub fn public_key_security_level(&self) -> SecurityLevel { + self.public_key_security_level.clone() + } + pub fn required_security_level(&self) -> SecurityLevel { + self.required_security_level.clone() + } +} + +impl From for ConsensusError { + fn from(err: PublicKeySecurityLevelNotMetError) -> Self { + Self::SignatureError(SignatureError::PublicKeySecurityLevelNotMetError(err)) + } +} diff --git a/packages/rs-dpp/src/errors/consensus/signature/wrong_public_key_purpose_error.rs b/packages/rs-dpp/src/errors/consensus/signature/wrong_public_key_purpose_error.rs new file mode 100644 index 00000000000..c825fcb31ca --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/signature/wrong_public_key_purpose_error.rs @@ -0,0 +1,34 @@ +use thiserror::Error; + +use crate::consensus::signature::SignatureError; +use crate::consensus::ConsensusError; +use crate::identity::Purpose; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid identity key purpose {public_key_purpose}. This state transition requires {key_purpose_requirement}")] +pub struct WrongPublicKeyPurposeError { + public_key_purpose: Purpose, + key_purpose_requirement: Purpose, +} + +impl WrongPublicKeyPurposeError { + pub fn new(public_key_purpose: Purpose, key_purpose_requirement: Purpose) -> Self { + Self { + public_key_purpose, + key_purpose_requirement, + } + } + + pub fn public_key_purpose(&self) -> Purpose { + self.public_key_purpose.clone() + } + pub fn key_purpose_requirement(&self) -> Purpose { + self.key_purpose_requirement.clone() + } +} + +impl From for ConsensusError { + fn from(err: WrongPublicKeyPurposeError) -> Self { + Self::SignatureError(SignatureError::WrongPublicKeyPurposeError(err)) + } +} diff --git a/packages/rs-dpp/src/errors/dpp_init_error.rs b/packages/rs-dpp/src/errors/dpp_init_error.rs index a7bce37cb8a..68e1e7cbd11 100644 --- a/packages/rs-dpp/src/errors/dpp_init_error.rs +++ b/packages/rs-dpp/src/errors/dpp_init_error.rs @@ -5,9 +5,9 @@ use thiserror::Error; #[derive(Error, Debug)] pub enum DashPlatformProtocolInitError { - #[error("{0}")] + #[error(transparent)] SchemaDeserializationError(serde_json::Error), - #[error("{0}")] + #[error(transparent)] ValidationError(ValidationError<'static>), #[error("Loaded Schema is invalid: {0}")] InvalidSchemaError(&'static str), diff --git a/packages/rs-dpp/src/errors/errors.rs b/packages/rs-dpp/src/errors/errors.rs index 6454e99db7b..aa57677170e 100644 --- a/packages/rs-dpp/src/errors/errors.rs +++ b/packages/rs-dpp/src/errors/errors.rs @@ -1,12 +1,17 @@ use serde_json::Value as JsonValue; use thiserror::Error; +use crate::consensus::signature::InvalidSignaturePublicKeySecurityLevelError; use crate::consensus::ConsensusError; use crate::data_contract::errors::*; +use crate::data_contract::state_transition::errors::MissingDataContractIdError; +use crate::data_contract::state_transition::errors::PublicKeyIsDisabledError; use crate::document::errors::*; -use crate::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel}; -use crate::prelude::Identifier; -use crate::state_transition::StateTransition; +use crate::identity::{Purpose, SecurityLevel}; +use crate::state_transition::errors::{ + InvalidIdentityPublicKeyTypeError, InvalidSignaturePublicKeyError, PublicKeyMismatchError, + PublicKeySecurityLevelNotMetError, StateTransitionIsNotSignedError, WrongPublicKeyPurposeError, +}; use crate::{CompatibleProtocolVersionIsNotDefinedError, NonConsensusError, SerdeParsingError}; #[derive(Error, Debug)] @@ -53,27 +58,18 @@ pub enum ProtocolError { Generic(String), // State Transition Errors - #[error("Invalid signature type")] - InvalidIdentityPublicKeyTypeError { public_key_type: KeyType }, - #[error("State Transition is not signed")] - StateTransitionIsNotIsSignedError { state_transition: StateTransition }, - #[error( - "Invalid key security level: {public_key_security_level}. The state transition requires at least: {required_security_level}" - )] - PublicKeySecurityLevelNotMetError { - public_key_security_level: SecurityLevel, - required_security_level: SecurityLevel, - }, - #[error("Invalid identity key purpose {public_key_purpose}. This state transition requires {key_purpose_requirement}")] - WrongPublicKeyPurposeError { - public_key_purpose: Purpose, - key_purpose_requirement: Purpose, - }, - #[error("Public key mismatched")] - PublicKeyMismatchError { public_key: IdentityPublicKey }, - - #[error("Invalid signature public key")] - InvalidSignaturePublicKeyError { public_key: Vec }, + #[error(transparent)] + InvalidIdentityPublicKeyTypeError(InvalidIdentityPublicKeyTypeError), + #[error(transparent)] + StateTransitionIsNotSignedError(StateTransitionIsNotSignedError), + #[error(transparent)] + PublicKeySecurityLevelNotMetError(PublicKeySecurityLevelNotMetError), + #[error(transparent)] + WrongPublicKeyPurposeError(WrongPublicKeyPurposeError), + #[error(transparent)] + PublicKeyMismatchError(PublicKeyMismatchError), + #[error(transparent)] + InvalidSignaturePublicKeyError(InvalidSignaturePublicKeyError), // TODO decide if it should be a string #[error("Non-Consensus error: {0}")] @@ -86,32 +82,26 @@ pub enum ProtocolError { #[error("Data Contract already exists")] DataContractAlreadyExistsError, - #[error("Invalid Data Contract: {errors:?}")] - InvalidDataContractError { - errors: Vec, - raw_data_contract: JsonValue, - }, + #[error(transparent)] + InvalidDataContractError(InvalidDataContractError), - #[error("Data Contract is not present")] - DataContractNotPresentError { data_contract_id: Identifier }, + #[error(transparent)] + DataContractNotPresentError(DataContractNotPresentError), - #[error("Invalid public key security level {public_key_security_level}. This state transition requires {required_security_level}")] - InvalidSignaturePublicKeySecurityLevelError { - public_key_security_level: SecurityLevel, - required_security_level: SecurityLevel, - }, + #[error(transparent)] + InvalidSignaturePublicKeySecurityLevelError(InvalidSignaturePublicKeySecurityLevelError), #[error("State Transition type is not present")] InvalidStateTransitionTypeError, - #[error("$dataContractId is not present")] - MissingDataContractIdError { raw_document_transition: JsonValue }, + #[error(transparent)] + MissingDataContractIdError(MissingDataContractIdError), - #[error("Public key is disabled")] - PublicKeyIsDisabledError { public_key: IdentityPublicKey }, + #[error(transparent)] + PublicKeyIsDisabledError(PublicKeyIsDisabledError), - #[error("Identity is not present")] - IdentityNotPresentError { id: Identifier }, + #[error(transparent)] + IdentityNotPresentError(IdentityNotPresentError), } impl From for ProtocolError { diff --git a/packages/rs-dpp/src/errors/non_consensus_error.rs b/packages/rs-dpp/src/errors/non_consensus_error.rs index 44ad0a627d1..87e84c0645f 100644 --- a/packages/rs-dpp/src/errors/non_consensus_error.rs +++ b/packages/rs-dpp/src/errors/non_consensus_error.rs @@ -8,17 +8,17 @@ use crate::{ pub enum NonConsensusError { #[error("Unexpected serde parsing error: {0:#}")] SerdeParsingError(SerdeParsingError), - #[error("{0}")] + #[error(transparent)] CompatibleProtocolVersionIsNotDefinedError(CompatibleProtocolVersionIsNotDefinedError), - #[error("{0}")] + #[error(transparent)] SerdeJsonError(String), - #[error("{0}")] + #[error(transparent)] InvalidVectorSizeError(InvalidVectorSizeError), - #[error("{0}")] + #[error(transparent)] StateRepositoryFetchError(String), - #[error("{0}")] + #[error(transparent)] IdentifierCreateError(String), - #[error("{0}")] + #[error(transparent)] IdentityPublicKeyCreateError(String), /// When dynamic `Value` is validated it requires some specific properties to properly work diff --git a/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs b/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs index 47ffc48f528..97e77a72169 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs @@ -3,6 +3,7 @@ use std::sync::Arc; use anyhow::Result; +use crate::consensus::signature::{IdentityNotFoundError, SignatureError}; use crate::{ consensus::basic::{identity::IdentityInsufficientBalanceError, BasicError}, identity::state_transition::identity_credit_withdrawal_transition::IdentityCreditWithdrawalTransition, @@ -47,9 +48,9 @@ where let existing_identity = match maybe_existing_identity { None => { - let err = BasicError::IdentityNotFoundError { - identity_id: state_transition.identity_id.clone(), - }; + let err = SignatureError::IdentityNotFoundError(IdentityNotFoundError::new( + state_transition.identity_id.clone(), + )); result.add_error(err); diff --git a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs index bb436958c00..7c98ab93a1c 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs @@ -1,6 +1,7 @@ use std::convert::TryInto; use std::sync::Arc; +use crate::consensus::signature::{IdentityNotFoundError, SignatureError}; use crate::{ consensus::{basic::BasicError, ConsensusError}, identity::get_biggest_possible_identity, @@ -101,7 +102,7 @@ pub async fn apply_identity_update_transition( } fn identity_not_found_error(identity_id: Identifier) -> ProtocolError { - ProtocolError::AbstractConsensusError(Box::new(ConsensusError::BasicError(Box::new( - BasicError::IdentityNotFoundError { identity_id }, - )))) + ProtocolError::AbstractConsensusError(Box::new(ConsensusError::SignatureError( + SignatureError::IdentityNotFoundError(IdentityNotFoundError::new(identity_id)), + ))) } diff --git a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/validate_identity_update_transition_state.rs b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/validate_identity_update_transition_state.rs index 75ffaef5837..d87f81e1968 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/validate_identity_update_transition_state.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/validate_identity_update_transition_state.rs @@ -3,9 +3,9 @@ use serde_json::Value; use std::convert::TryInto; use std::sync::Arc; +use crate::consensus::signature::{IdentityNotFoundError, SignatureError}; use crate::{ block_time_window::validate_time_in_block_time_window::validate_time_in_block_time_window, - consensus::basic::BasicError, identity::validation::{RequiredPurposeAndSecurityLevelValidator, TPublicKeysValidator}, state_repository::StateRepositoryLike, state_transition::StateTransitionLike, @@ -56,9 +56,9 @@ where let stored_identity = match maybe_stored_identity { None => { - validation_result.add_error(BasicError::IdentityNotFoundError { - identity_id: state_transition.get_identity_id().to_owned(), - }); + validation_result.add_error(SignatureError::IdentityNotFoundError( + IdentityNotFoundError::new(state_transition.get_identity_id().to_owned()), + )); return Ok(validation_result); } Some(identity) => identity, diff --git a/packages/rs-dpp/src/identity/state_transition/validate_public_key_signatures.rs b/packages/rs-dpp/src/identity/state_transition/validate_public_key_signatures.rs index 21e4bba5892..1e94932a349 100644 --- a/packages/rs-dpp/src/identity/state_transition/validate_public_key_signatures.rs +++ b/packages/rs-dpp/src/identity/state_transition/validate_public_key_signatures.rs @@ -1,5 +1,7 @@ use serde_json::Value; +use crate::consensus::basic::identity::InvalidIdentityKeySignatureError; +use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; use crate::{ consensus::{basic::BasicError, ConsensusError}, object_names, @@ -94,9 +96,9 @@ pub fn validate_public_key_signatures<'a, T: BlsModule>( let maybe_invalid_public_key = find_invalid_public_key(&mut state_transition, identity_public_keys, bls); if let Some(invalid_key) = maybe_invalid_public_key { - validation_result.add_error(BasicError::InvalidIdentityKeySignatureError { - public_key_id: invalid_key.get_id(), - }) + validation_result.add_error(BasicError::InvalidIdentityKeySignatureError( + InvalidIdentityKeySignatureError::new(invalid_key.get_id()), + )) } Ok(validation_result) @@ -104,7 +106,9 @@ pub fn validate_public_key_signatures<'a, T: BlsModule>( fn invalid_state_transition_type_error(transition_type: u8) -> ProtocolError { ProtocolError::AbstractConsensusError(Box::new(ConsensusError::BasicError(Box::new( - BasicError::InvalidStateTransitionTypeError { transition_type }, + BasicError::InvalidStateTransitionTypeError(InvalidStateTransitionTypeError::new( + transition_type, + )), )))) } diff --git a/packages/rs-dpp/src/state_transition/abstract_state_transition.rs b/packages/rs-dpp/src/state_transition/abstract_state_transition.rs index f021bfe5bbb..aeb6fe80bb2 100644 --- a/packages/rs-dpp/src/state_transition/abstract_state_transition.rs +++ b/packages/rs-dpp/src/state_transition/abstract_state_transition.rs @@ -4,6 +4,9 @@ use dashcore::signer; use serde::Serialize; use serde_json::Value as JsonValue; +use crate::state_transition::errors::{ + InvalidIdentityPublicKeyTypeError, StateTransitionIsNotSignedError, +}; use crate::{ identity::KeyType, prelude::ProtocolError, @@ -76,9 +79,9 @@ pub trait StateTransitionLike: // https://github.com/dashevo/platform/blob/6b02b26e5cd3a7c877c5fdfe40c4a4385a8dda15/packages/js-dpp/lib/stateTransition/AbstractStateTransition.js#L187 // is to return the error for the BIP13_SCRIPT_HASH KeyType::BIP13_SCRIPT_HASH => { - return Err(ProtocolError::InvalidIdentityPublicKeyTypeError { - public_key_type: key_type, - }) + return Err(ProtocolError::InvalidIdentityPublicKeyTypeError( + InvalidIdentityPublicKeyTypeError::new(key_type), + )) } }; Ok(()) @@ -96,9 +99,9 @@ pub trait StateTransitionLike: self.verify_ecdsa_hash_160_signature_by_public_key_hash(public_key) } KeyType::BLS12_381 => self.verify_bls_signature_by_public_key(public_key, bls), - KeyType::BIP13_SCRIPT_HASH => { - Err(ProtocolError::InvalidIdentityPublicKeyTypeError { public_key_type }) - } + KeyType::BIP13_SCRIPT_HASH => Err(ProtocolError::InvalidIdentityPublicKeyTypeError( + InvalidIdentityPublicKeyTypeError::new(public_key_type), + )), } } @@ -107,9 +110,9 @@ pub trait StateTransitionLike: public_key_hash: &[u8], ) -> Result<(), ProtocolError> { if self.get_signature().is_empty() { - return Err(ProtocolError::StateTransitionIsNotIsSignedError { - state_transition: self.clone().into(), - }); + return Err(ProtocolError::StateTransitionIsNotSignedError( + StateTransitionIsNotSignedError::new(self.clone().into()), + )); } let data_hash = self.hash(true)?; Ok(signer::verify_hash_signature( @@ -122,9 +125,9 @@ pub trait StateTransitionLike: /// Verifies an ECDSA signature with the public key fn verify_ecdsa_signature_by_public_key(&self, public_key: &[u8]) -> Result<(), ProtocolError> { if self.get_signature().is_empty() { - return Err(ProtocolError::StateTransitionIsNotIsSignedError { - state_transition: self.clone().into(), - }); + return Err(ProtocolError::StateTransitionIsNotSignedError( + StateTransitionIsNotSignedError::new(self.clone().into()), + )); } let data = self.to_buffer(true)?; Ok(signer::verify_data_signature( @@ -141,9 +144,9 @@ pub trait StateTransitionLike: bls: &T, ) -> Result<(), ProtocolError> { if self.get_signature().is_empty() { - return Err(ProtocolError::StateTransitionIsNotIsSignedError { - state_transition: self.clone().into(), - }); + return Err(ProtocolError::StateTransitionIsNotSignedError( + StateTransitionIsNotSignedError::new(self.clone().into()), + )); } let data = self.to_buffer(true)?; diff --git a/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs b/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs index f42e4a490f1..51a52e3c071 100644 --- a/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs +++ b/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs @@ -1,6 +1,12 @@ use anyhow::anyhow; use dashcore::secp256k1::{PublicKey as RawPublicKey, SecretKey as RawSecretKey}; +use crate::consensus::signature::InvalidSignaturePublicKeySecurityLevelError; +use crate::data_contract::state_transition::errors::PublicKeyIsDisabledError; +use crate::state_transition::errors::{ + InvalidIdentityPublicKeyTypeError, InvalidSignaturePublicKeyError, PublicKeyMismatchError, + PublicKeySecurityLevelNotMetError, StateTransitionIsNotSignedError, WrongPublicKeyPurposeError, +}; use crate::{ identity::{IdentityPublicKey, KeyID, KeyType, Purpose, SecurityLevel}, prelude::*, @@ -36,9 +42,11 @@ where // the compressed key stored in the identity if public_key_compressed.to_vec() != identity_public_key.get_data() { - return Err(ProtocolError::InvalidSignaturePublicKeyError { - public_key: identity_public_key.get_data().to_owned(), - }); + return Err(ProtocolError::InvalidSignaturePublicKeyError( + InvalidSignaturePublicKeyError::new( + identity_public_key.get_data().to_owned(), + ), + )); } self.sign_by_private_key(private_key, identity_public_key.get_type(), bls) @@ -48,9 +56,11 @@ where let pub_key_hash = ripemd160_sha256(&public_key_compressed); if pub_key_hash != identity_public_key.get_data() { - return Err(ProtocolError::InvalidSignaturePublicKeyError { - public_key: identity_public_key.get_data().to_owned(), - }); + return Err(ProtocolError::InvalidSignaturePublicKeyError( + InvalidSignaturePublicKeyError::new( + identity_public_key.get_data().to_owned(), + ), + )); } self.sign_by_private_key(private_key, identity_public_key.get_type(), bls) } @@ -58,9 +68,11 @@ where let public_key = bls.private_key_to_public_key(private_key)?; if public_key != identity_public_key.get_data() { - return Err(ProtocolError::InvalidSignaturePublicKeyError { - public_key: identity_public_key.get_data().to_owned(), - }); + return Err(ProtocolError::InvalidSignaturePublicKeyError( + InvalidSignaturePublicKeyError::new( + identity_public_key.get_data().to_owned(), + ), + )); } self.sign_by_private_key(private_key, identity_public_key.get_type(), bls) } @@ -68,9 +80,9 @@ where // the default behavior from // https://github.com/dashevo/platform/blob/6b02b26e5cd3a7c877c5fdfe40c4a4385a8dda15/packages/js-dpp/lib/stateTransition/AbstractStateTransitionIdentitySigned.js#L108 // is to return the error for the BIP13_SCRIPT_HASH - KeyType::BIP13_SCRIPT_HASH => Err(ProtocolError::InvalidIdentityPublicKeyTypeError { - public_key_type: identity_public_key.get_type(), - }), + KeyType::BIP13_SCRIPT_HASH => Err(ProtocolError::InvalidIdentityPublicKeyTypeError( + InvalidIdentityPublicKeyTypeError::new(identity_public_key.get_type()), + )), } } @@ -83,15 +95,15 @@ where let signature = self.get_signature(); if signature.is_empty() { - return Err(ProtocolError::StateTransitionIsNotIsSignedError { - state_transition: self.clone().into(), - }); + return Err(ProtocolError::StateTransitionIsNotSignedError( + StateTransitionIsNotSignedError::new(self.clone().into()), + )); } if self.get_signature_public_key_id() != Some(public_key.get_id()) { - return Err(ProtocolError::PublicKeyMismatchError { - public_key: public_key.clone(), - }); + return Err(ProtocolError::PublicKeyMismatchError( + PublicKeyMismatchError::new(public_key.clone()), + )); } let public_key_bytes = public_key.get_data(); @@ -119,25 +131,28 @@ where // a MASTER key if public_key.is_master() && self.get_security_level_requirement() != SecurityLevel::MASTER { - return Err(ProtocolError::InvalidSignaturePublicKeySecurityLevelError { - public_key_security_level: public_key.get_security_level(), - required_security_level: self.get_security_level_requirement(), - }); + return Err(ProtocolError::InvalidSignaturePublicKeySecurityLevelError( + InvalidSignaturePublicKeySecurityLevelError::new( + public_key.get_security_level(), + self.get_security_level_requirement(), + ), + )); } // Otherwise, key security level should be less than MASTER but more or equal than required if self.get_security_level_requirement() < public_key.get_security_level() { - return Err(ProtocolError::PublicKeySecurityLevelNotMetError { - public_key_security_level: public_key.get_security_level(), - required_security_level: self.get_security_level_requirement(), - }); + return Err(ProtocolError::PublicKeySecurityLevelNotMetError( + PublicKeySecurityLevelNotMetError::new( + public_key.get_security_level(), + self.get_security_level_requirement(), + ), + )); } if public_key.get_purpose() != Purpose::AUTHENTICATION { - return Err(ProtocolError::WrongPublicKeyPurposeError { - public_key_purpose: public_key.get_purpose(), - key_purpose_requirement: Purpose::AUTHENTICATION, - }); + return Err(ProtocolError::WrongPublicKeyPurposeError( + WrongPublicKeyPurposeError::new(public_key.get_purpose(), Purpose::AUTHENTICATION), + )); } Ok(()) } @@ -147,9 +162,9 @@ where public_key: &IdentityPublicKey, ) -> Result<(), ProtocolError> { if public_key.get_disabled_at().is_some() { - return Err(ProtocolError::PublicKeyIsDisabledError { - public_key: public_key.to_owned(), - }); + return Err(ProtocolError::PublicKeyIsDisabledError( + PublicKeyIsDisabledError::new(public_key.to_owned()), + )); } Ok(()) } @@ -460,10 +475,9 @@ mod test { .sign(&keys.identity_public_key, &keys.ec_private, &bls) .unwrap_err(); match sign_error { - ProtocolError::PublicKeySecurityLevelNotMetError { - public_key_security_level: sec_level, - required_security_level: req_sec_level, - } => { + ProtocolError::PublicKeySecurityLevelNotMetError( + PublicKeySecurityLevelNotMetError::new(sec_level, req_sec_level), + ) => { assert_eq!(SecurityLevel::MEDIUM, sec_level); assert_eq!(SecurityLevel::HIGH, req_sec_level); } @@ -484,10 +498,10 @@ mod test { .sign(&keys.identity_public_key, &keys.ec_private, &bls) .unwrap_err(); match sign_error { - ProtocolError::WrongPublicKeyPurposeError { - public_key_purpose: purpose, - key_purpose_requirement: req_purpose, - } => { + ProtocolError::WrongPublicKeyPurposeError(WrongPublicKeyPurposeError::new( + purpose, + req_purpose, + )) => { assert_eq!(Purpose::ENCRYPTION, purpose); assert_eq!(Purpose::AUTHENTICATION, req_purpose); } @@ -519,7 +533,7 @@ mod test { .verify_signature(&keys.identity_public_key, &bls) .unwrap_err(); match verify_error { - ProtocolError::StateTransitionIsNotIsSignedError { .. } => {} + ProtocolError::StateTransitionIsNotSignedError { .. } => {} error => { panic!("invalid error type: {}", error) } @@ -538,7 +552,7 @@ mod test { .verify_signature(&keys.identity_public_key, &bls) .unwrap_err(); match verify_error { - ProtocolError::StateTransitionIsNotIsSignedError { .. } => {} + ProtocolError::StateTransitionIsNotSignedError { .. } => {} error => { panic!("invalid error type: {}", error) } @@ -596,11 +610,13 @@ mod test { assert!(matches!( result, - ProtocolError::InvalidSignaturePublicKeySecurityLevelError { public_key_security_level, required_security_level } if - { - public_key_security_level == SecurityLevel::MASTER && - required_security_level == SecurityLevel::HIGH - } + ProtocolError::InvalidSignaturePublicKeySecurityLevelError( + InvalidSignaturePublicKeySecurityLevelError { + public_key_security_level, + required_key_security_level + }) + if public_key_security_level == SecurityLevel::MASTER && + required_key_security_level == SecurityLevel::HIGH )) } } diff --git a/packages/rs-dpp/src/state_transition/errors/invalid_identity_public_key_type_error.rs b/packages/rs-dpp/src/state_transition/errors/invalid_identity_public_key_type_error.rs new file mode 100644 index 00000000000..703e7c67bc2 --- /dev/null +++ b/packages/rs-dpp/src/state_transition/errors/invalid_identity_public_key_type_error.rs @@ -0,0 +1,26 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identity::KeyType; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid signature type")] +pub struct InvalidIdentityPublicKeyTypeError { + public_key_type: KeyType, +} + +impl InvalidIdentityPublicKeyTypeError { + pub fn new(public_key_type: KeyType) -> Self { + Self { public_key_type } + } + + pub fn public_key_type(&self) -> KeyType { + self.public_key_type.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidIdentityPublicKeyTypeError) -> Self { + Self::InvalidIdentityPublicKeyTypeError(err) + } +} diff --git a/packages/rs-dpp/src/state_transition/errors/invalid_signature_public_key_error.rs b/packages/rs-dpp/src/state_transition/errors/invalid_signature_public_key_error.rs new file mode 100644 index 00000000000..7c7ff8ffd07 --- /dev/null +++ b/packages/rs-dpp/src/state_transition/errors/invalid_signature_public_key_error.rs @@ -0,0 +1,26 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identity::SecurityLevel; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid signature public key")] +pub struct InvalidSignaturePublicKeyError { + public_key: Vec, +} + +impl InvalidSignaturePublicKeyError { + pub fn new(public_key: Vec) -> Self { + Self { public_key } + } + + pub fn public_key(&self) -> Vec { + self.public_key.clone() + } +} + +impl From for ConsensusError { + fn from(err: InvalidSignaturePublicKeyError) -> Self { + Self::InvalidSignaturePublicKeyError(err) + } +} diff --git a/packages/rs-dpp/src/state_transition/errors/mod.rs b/packages/rs-dpp/src/state_transition/errors/mod.rs new file mode 100644 index 00000000000..ab7d02480ad --- /dev/null +++ b/packages/rs-dpp/src/state_transition/errors/mod.rs @@ -0,0 +1,13 @@ +mod invalid_identity_public_key_type_error; +mod invalid_signature_public_key_error; +mod public_key_mismatch_error; +mod public_key_security_level_not_met_error; +mod state_transition_is_not_signed_error; +mod wrong_public_key_purpose_error; + +pub use invalid_identity_public_key_type_error::*; +pub use invalid_signature_public_key_error::*; +pub use public_key_mismatch_error::*; +pub use public_key_security_level_not_met_error::*; +pub use state_transition_is_not_signed_error::*; +pub use wrong_public_key_purpose_error::*; diff --git a/packages/rs-dpp/src/state_transition/errors/public_key_mismatch_error.rs b/packages/rs-dpp/src/state_transition/errors/public_key_mismatch_error.rs new file mode 100644 index 00000000000..ec32c20164e --- /dev/null +++ b/packages/rs-dpp/src/state_transition/errors/public_key_mismatch_error.rs @@ -0,0 +1,26 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identity::IdentityPublicKey; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Public key mismatched")] +pub struct PublicKeyMismatchError { + public_key: IdentityPublicKey, +} + +impl PublicKeyMismatchError { + pub fn new(public_key: IdentityPublicKey) -> Self { + Self { public_key } + } + + pub fn public_key(&self) -> IdentityPublicKey { + self.public_key.clone() + } +} + +impl From for ConsensusError { + fn from(err: PublicKeyMismatchError) -> Self { + Self::PublicKeyMismatchError(err) + } +} diff --git a/packages/rs-dpp/src/state_transition/errors/public_key_security_level_not_met_error.rs b/packages/rs-dpp/src/state_transition/errors/public_key_security_level_not_met_error.rs new file mode 100644 index 00000000000..d0ca0781c70 --- /dev/null +++ b/packages/rs-dpp/src/state_transition/errors/public_key_security_level_not_met_error.rs @@ -0,0 +1,36 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identity::SecurityLevel; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid key security level: {public_key_security_level}. The state transition requires at least: {required_security_level}")] +pub struct PublicKeySecurityLevelNotMetError { + public_key_security_level: SecurityLevel, + required_security_level: SecurityLevel, +} + +impl PublicKeySecurityLevelNotMetError { + pub fn new( + public_key_security_level: SecurityLevel, + required_security_level: SecurityLevel, + ) -> Self { + Self { + public_key_security_level, + required_security_level, + } + } + + pub fn public_key_security_level(&self) -> SecurityLevel { + self.public_key_security_level.clone() + } + pub fn required_security_level(&self) -> SecurityLevel { + self.required_security_level.clone() + } +} + +impl From for ConsensusError { + fn from(err: PublicKeySecurityLevelNotMetError) -> Self { + Self::PublicKeySecurityLevelNotMetError(err) + } +} diff --git a/packages/rs-dpp/src/state_transition/errors/state_transition_is_not_signed_error.rs b/packages/rs-dpp/src/state_transition/errors/state_transition_is_not_signed_error.rs new file mode 100644 index 00000000000..eee01d9ac40 --- /dev/null +++ b/packages/rs-dpp/src/state_transition/errors/state_transition_is_not_signed_error.rs @@ -0,0 +1,26 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::state_transition::StateTransition; + +#[derive(Error, Debug, Clone)] +#[error("State Transition is not signed")] +pub struct StateTransitionIsNotSignedError { + state_transition: StateTransition, +} + +impl StateTransitionIsNotSignedError { + pub fn new(state_transition: StateTransition) -> Self { + Self { state_transition } + } + + pub fn state_transition(&self) -> StateTransition { + self.state_transition.clone() + } +} + +impl From for ConsensusError { + fn from(err: StateTransitionIsNotSignedError) -> Self { + Self::StateTransitionIsNotSignedError(err) + } +} diff --git a/packages/rs-dpp/src/state_transition/errors/wrong_public_key_purpose_error.rs b/packages/rs-dpp/src/state_transition/errors/wrong_public_key_purpose_error.rs new file mode 100644 index 00000000000..769093905f8 --- /dev/null +++ b/packages/rs-dpp/src/state_transition/errors/wrong_public_key_purpose_error.rs @@ -0,0 +1,33 @@ +use thiserror::Error; + +use crate::consensus::ConsensusError; +use crate::identity::Purpose; + +#[derive(Error, Debug, Clone, PartialEq, Eq)] +#[error("Invalid identity key purpose {public_key_purpose}. This state transition requires {key_purpose_requirement}")] +pub struct WrongPublicKeyPurposeError { + public_key_purpose: Purpose, + key_purpose_requirement: Purpose, +} + +impl WrongPublicKeyPurposeError { + pub fn new(public_key_purpose: Purpose, key_purpose_requirement: Purpose) -> Self { + Self { + public_key_purpose, + key_purpose_requirement, + } + } + + pub fn public_key_purpose(&self) -> Purpose { + self.public_key_purpose.clone() + } + pub fn key_purpose_requirement(&self) -> Purpose { + self.key_purpose_requirement.clone() + } +} + +impl From for ConsensusError { + fn from(err: WrongPublicKeyPurposeError) -> Self { + Self::WrongPublicKeyPurposeError(err) + } +} diff --git a/packages/rs-dpp/src/state_transition/mod.rs b/packages/rs-dpp/src/state_transition/mod.rs index 0954f625643..2bfecce8310 100644 --- a/packages/rs-dpp/src/state_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/mod.rs @@ -29,6 +29,7 @@ pub mod validation; pub mod fee; pub mod state_transition_execution_context; +pub mod errors; mod example; macro_rules! call_method { ($state_transition:expr, $method:ident, $args:tt ) => { diff --git a/packages/rs-dpp/src/state_transition/state_transition_factory.rs b/packages/rs-dpp/src/state_transition/state_transition_factory.rs index 302ae333285..a40917e63d1 100644 --- a/packages/rs-dpp/src/state_transition/state_transition_factory.rs +++ b/packages/rs-dpp/src/state_transition/state_transition_factory.rs @@ -1,6 +1,8 @@ use anyhow::anyhow; use std::convert::{TryFrom, TryInto}; +use crate::data_contract::errors::DataContractNotPresentError; +use crate::data_contract::state_transition::errors::MissingDataContractIdError; use crate::{ consensus::{basic::BasicError, ConsensusError}, data_contract::{ @@ -84,9 +86,9 @@ async fn fetch_data_contracts_for_document_transition( let mut data_contracts = vec![]; for transition in raw_document_transitions { let data_contract_id_bytes = transition.get_bytes("$dataContractId").map_err(|_| { - ProtocolError::MissingDataContractIdError { - raw_document_transition: transition.to_owned(), - } + ProtocolError::MissingDataContractIdError(MissingDataContractIdError::new( + transition.to_owned(), + )) })?; let data_contract_id = Identifier::from_bytes(&data_contract_id_bytes)?; @@ -96,7 +98,11 @@ async fn fetch_data_contracts_for_document_transition( .map(TryInto::try_into) .transpose() .map_err(Into::into)? - .ok_or_else(|| ProtocolError::DataContractNotPresentError { data_contract_id })?; + .ok_or_else(|| { + ProtocolError::DataContractNotPresentError(DataContractNotPresentError::new( + data_contract_id, + )) + })?; data_contracts.push(data_contract); } diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs index b9fcdf39e90..04578fb12df 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs @@ -1,6 +1,7 @@ use anyhow::Context; use std::convert::TryInto; +use crate::data_contract::errors::IdentityNotPresentError; use crate::{ consensus::fee::FeeError, identity::{ @@ -73,8 +74,10 @@ where .map(TryInto::try_into) .transpose() .map_err(Into::into)? - .ok_or_else(|| ProtocolError::IdentityNotPresentError { - id: identity_id.clone(), + .ok_or_else(|| { + ProtocolError::IdentityNotPresentError(IdentityNotPresentError::new( + identity_id.clone(), + )) })?; if execution_context.is_dry_run() { @@ -141,8 +144,10 @@ where .map(TryInto::try_into) .transpose() .map_err(Into::into)? - .ok_or_else(|| ProtocolError::IdentityNotPresentError { - id: identity_id.clone(), + .ok_or_else(|| { + ProtocolError::IdentityNotPresentError(IdentityNotPresentError::new( + identity_id.clone(), + )) })?; Ok(identity.get_balance()) diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs index dd8b86675b2..b89a1e26282 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs @@ -3,6 +3,11 @@ use std::{collections::HashSet, convert::TryInto}; use anyhow::Context; use lazy_static::lazy_static; +use crate::consensus::signature::{ + IdentityNotFoundError, InvalidIdentityPublicKeyTypeError, + InvalidSignaturePublicKeySecurityLevelError, MissingPublicKeyError, PublicKeyIsDisabledError, + PublicKeySecurityLevelNotMetError, +}; use crate::{ consensus::{signature::SignatureError, ConsensusError}, identity::KeyType, @@ -54,9 +59,9 @@ pub async fn validate_state_transition_identity_signature( let identity = match maybe_identity { Some(identity) => identity, None => { - validation_result.add_error(SignatureError::IdentityNotFoundError { - identity_id: state_transition.get_owner_id().to_owned(), - }); + validation_result.add_error(SignatureError::IdentityNotFoundError( + IdentityNotFoundError::new(state_transition.get_owner_id().to_owned()), + )); return Ok(validation_result); } }; @@ -69,18 +74,18 @@ pub async fn validate_state_transition_identity_signature( let public_key = match maybe_public_key { None => { - validation_result.add_error(SignatureError::MissingPublicKeyError { - public_key_id: signature_public_key_id, - }); + validation_result.add_error(SignatureError::MissingPublicKeyError( + MissingPublicKeyError::new(signature_public_key_id), + )); return Ok(validation_result); } Some(pk) => pk, }; if !SUPPORTED_KEY_TYPES.contains(&public_key.get_type()) { - validation_result.add_error(SignatureError::InvalidIdentityPublicKeyTypeError { - public_key_type: public_key.get_type(), - }); + validation_result.add_error(SignatureError::InvalidIdentityPublicKeyTypeError( + InvalidIdentityPublicKeyTypeError::new(public_key.get_type()), + )); return Ok(validation_result); } @@ -108,34 +113,44 @@ fn convert_to_consensus_signature_error( error: ProtocolError, ) -> Result { match error { - ProtocolError::InvalidSignaturePublicKeySecurityLevelError { - public_key_security_level, - required_security_level, - } => Ok(ConsensusError::SignatureError( - SignatureError::InvalidSignaturePublicKeySecurityLevelError { + ProtocolError::InvalidSignaturePublicKeySecurityLevelError( + InvalidSignaturePublicKeySecurityLevelError::new( public_key_security_level, - required_key_security_level: required_security_level, - }, + required_security_level, + ), + ) => Ok(ConsensusError::SignatureError( + SignatureError::InvalidSignaturePublicKeySecurityLevelError( + InvalidSignaturePublicKeySecurityLevelError::new( + public_key_security_level, + required_security_level, + ), + ), )), - ProtocolError::PublicKeySecurityLevelNotMetError { - public_key_security_level, - required_security_level, - } => Ok(ConsensusError::SignatureError( - SignatureError::PublicKeySecurityLevelNotMetError { + ProtocolError::PublicKeySecurityLevelNotMetError( + PublicKeySecurityLevelNotMetError::new( public_key_security_level, required_security_level, - }, + ), + ) => Ok(ConsensusError::SignatureError( + SignatureError::PublicKeySecurityLevelNotMetError( + PublicKeySecurityLevelNotMetError::new( + public_key_security_level, + required_security_level, + ), + ), )), - ProtocolError::PublicKeyIsDisabledError { public_key } => Ok( - ConsensusError::SignatureError(SignatureError::PublicKeyIsDisabledError { - public_key_id: public_key.get_id(), - }), + ProtocolError::PublicKeyIsDisabledError(PublicKeyIsDisabledError::new(public_key)) => Ok( + ConsensusError::SignatureError(SignatureError::PublicKeyIsDisabledError( + PublicKeyIsDisabledError::new(public_key.get_id()), + )), ), - ProtocolError::InvalidIdentityPublicKeyTypeError { public_key_type } => { - Ok(ConsensusError::SignatureError( - SignatureError::InvalidIdentityPublicKeyTypeError { public_key_type }, - )) - } + ProtocolError::InvalidIdentityPublicKeyTypeError( + InvalidIdentityPublicKeyTypeError::new(public_key_type), + ) => Ok(ConsensusError::SignatureError( + SignatureError::InvalidIdentityPublicKeyTypeError( + InvalidIdentityPublicKeyTypeError::new(public_key_type), + ), + )), ProtocolError::Error(_) => Err(error), _ => Ok(ConsensusError::SignatureError( SignatureError::InvalidStateTransitionSignatureError, @@ -146,6 +161,7 @@ fn convert_to_consensus_signature_error( #[cfg(test)] mod test { use super::*; + use crate::state_transition::errors::WrongPublicKeyPurposeError; use crate::{ document::DocumentsBatchTransition, identity::{KeyID, Purpose, SecurityLevel}, @@ -162,6 +178,7 @@ mod test { NativeBlsModule, }; use serde::{Deserialize, Serialize}; + #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] struct ExampleStateTransition { @@ -234,32 +251,35 @@ mod test { if let Some(error_num) = self.return_error { match error_num { 0 => { - return Err(ProtocolError::PublicKeyMismatchError { - public_key: public_key.clone(), - }) + return Err(ProtocolError::PublicKeyMismatchError( + PublicKeyMismatchError::new(public_key.clone()), + )) } 1 => { - return Err(ProtocolError::InvalidSignaturePublicKeySecurityLevelError { - public_key_security_level: SecurityLevel::CRITICAL, - required_security_level: SecurityLevel::MASTER, - }) + return Err(ProtocolError::InvalidSignaturePublicKeySecurityLevelError( + InvalidSignaturePublicKeySecurityLevelError::new( + SecurityLevel::CRITICAL, + SecurityLevel::MASTER, + ), + )) } 2 => { - return Err(ProtocolError::PublicKeySecurityLevelNotMetError { - public_key_security_level: SecurityLevel::CRITICAL, - required_security_level: SecurityLevel::HIGH, - }) + return Err(ProtocolError::PublicKeySecurityLevelNotMetError( + PublicKeySecurityLevelNotMetError::new( + SecurityLevel::CRITICAL, + SecurityLevel::HIGH, + ), + )) } 3 => { - return Err(ProtocolError::PublicKeyIsDisabledError { - public_key: public_key.clone(), - }) + return Err(ProtocolError::PublicKeyIsDisabledError( + PublicKeyIsDisabledError::new(public_key.clone()), + )) } 4 => { - return Err(ProtocolError::WrongPublicKeyPurposeError { - public_key_purpose: Purpose::WITHDRAW, - key_purpose_requirement: Purpose::DECRYPTION, - }) + return Err(ProtocolError::WrongPublicKeyPurposeError( + WrongPublicKeyPurposeError::new(Purpose::WITHDRAW, Purpose::DECRYPTION), + )) } _ => {} } @@ -342,7 +362,7 @@ mod test { let signature_error = get_signature_error_from_result(&result, 0); assert!( - matches!(signature_error, SignatureError::IdentityNotFoundError { identity_id } if { + matches!(signature_error, SignatureError::IdentityNotFoundError(IdentityNotFoundError::new(identity_id)) if { identity_id == identity.get_id() }) ); @@ -374,7 +394,7 @@ mod test { let signature_error = get_signature_error_from_result(&result, 0); assert!( - matches!(signature_error, SignatureError::MissingPublicKeyError { public_key_id } if { + matches!(signature_error, SignatureError::MissingPublicKeyError(MissingPublicKeyError::new(public_key_id)) if { *public_key_id == 12332 }) ); diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_key_signature.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_key_signature.rs index 88585ea2462..0311a23d288 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_key_signature.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_key_signature.rs @@ -4,6 +4,7 @@ use anyhow::{bail, Context}; use async_trait::async_trait; use dashcore::signer::verify_hash_signature; +use crate::consensus::signature::IdentityNotFoundError; use crate::{ consensus::signature::SignatureError, identity::{ @@ -82,9 +83,9 @@ pub async fn validate_state_transition_key_signature( execution_context.add_operations(tmp_execution_context.get_operations()); if identity.is_none() { - result.add_error(SignatureError::IdentityNotFoundError { - identity_id: target_identity_id.clone(), - }); + result.add_error(SignatureError::IdentityNotFoundError( + IdentityNotFoundError::new(target_identity_id.clone()), + )); return Ok(result); } } diff --git a/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs b/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs index a5864525737..4ca8c7ec9a2 100644 --- a/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs +++ b/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs @@ -5,6 +5,9 @@ use async_trait::async_trait; use mockall::{automock, predicate::*}; use serde_json::Value as JsonValue; +use crate::consensus::basic::state_transition::{ + InvalidStateTransitionTypeError, StateTransitionMaxSizeExceededError, +}; use crate::{ consensus::basic::BasicError, state_repository::StateRepositoryLike, @@ -32,9 +35,9 @@ async fn validate_state_transition_basic( let state_transition_type = match StateTransitionType::try_from(raw_transition_type) { Err(_) => { - result.add_error(BasicError::InvalidStateTransitionTypeError { - transition_type: raw_transition_type, - }); + result.add_error(BasicError::InvalidStateTransitionTypeError( + InvalidStateTransitionTypeError::new(raw_transition_type), + )); return Ok(result); } Ok(transition_type) => transition_type, @@ -54,10 +57,9 @@ async fn validate_state_transition_basic( payload, }) = state_transition.to_buffer(false) { - result.add_error(BasicError::StateTransitionMaxSizeExceededError { - actual_size_kbytes: payload.len() / 1024, - max_size_kbytes, - }); + result.add_error(BasicError::StateTransitionMaxSizeExceededError( + StateTransitionMaxSizeExceededError::new(payload.len() / 1024, max_size_kbytes), + )); } Ok(result) diff --git a/packages/rs-dpp/src/util/deserializer.rs b/packages/rs-dpp/src/util/deserializer.rs index 8cfb591a6d7..4138c07e8f6 100644 --- a/packages/rs-dpp/src/util/deserializer.rs +++ b/packages/rs-dpp/src/util/deserializer.rs @@ -4,6 +4,7 @@ use anyhow::anyhow; use integer_encoding::VarInt; use serde_json::{Map, Number, Value as JsonValue}; +use crate::consensus::basic::decode::ProtocolVersionParsingError; use crate::data_contract::errors::StructureError; use crate::data_contract::extra::common::check_protocol_version; use crate::{errors::consensus::ConsensusError, errors::ProtocolError}; @@ -27,9 +28,9 @@ pub type ProtocolVersion = u32; pub fn get_protocol_version(version_bytes: &[u8]) -> Result { u32::decode_var(version_bytes) .ok_or_else(|| { - ConsensusError::ProtocolVersionParsingError { - parsing_error: anyhow!("length could not be decoded as a varint"), - } + ConsensusError::ProtocolVersionParsingError(ProtocolVersionParsingError::new(anyhow!( + "length could not be decoded as a varint" + ))) .into() }) .map(|(protocol_version, _size)| protocol_version) @@ -50,9 +51,9 @@ pub fn split_protocol_version( ) -> Result { let (protocol_version, protocol_version_size) = u32::decode_var(message_bytes).ok_or(ProtocolError::AbstractConsensusError(Box::new( - ConsensusError::ProtocolVersionParsingError { - parsing_error: anyhow!("length could not be decoded as a varint"), - }, + ConsensusError::ProtocolVersionParsingError(ProtocolVersionParsingError::new(anyhow!( + "length could not be decoded as a varint" + ))), )))?; let (_, main_message_bytes) = message_bytes.split_at(protocol_version_size); From 7e986713e5abf10dc90af3367398d0e5183f6803 Mon Sep 17 00:00:00 2001 From: Konstantin Shuplenkov Date: Tue, 7 Feb 2023 01:04:13 +0700 Subject: [PATCH 02/11] WIP --- packages/rs-dpp/src/data_contract/data_contract_factory.rs | 2 +- .../errors/data_contract_not_present_error.rs | 4 ++-- .../src/data_contract/errors/identity_not_present_error.rs | 4 ++-- .../data_contract/errors/invalid_data_contract_error.rs | 5 +++-- .../data_contract/errors/invalid_document_type_error.rs | 4 ++-- .../invalid_signature_public_key_security_level_error.rs | 5 ++--- .../errors/missing_data_contract_id_error.rs | 4 ++-- .../errors/public_key_is_disabled_error.rs | 4 ++-- .../src/errors/consensus/abstract_consensus_error.rs | 2 +- .../data_contract_have_new_unique_index_error.rs | 5 ++--- .../basic/data_contract/invalid_data_contract_id_error.rs | 5 ++--- .../system_property_index_already_present_error.rs | 4 ++-- .../basic/data_contract/undefined_index_property_error.rs | 4 ++-- .../data_contract/unique_indices_limit_reached_error.rs | 5 ++--- .../duplicate_document_transitions_with_ids_error.rs | 5 ++--- .../duplicate_document_transitions_with_indices_error.rs | 5 ++--- .../document/inconsistent_compound_index_data_error.rs | 5 ++--- .../document/invalid_document_transition_action_error.rs | 5 ++--- .../basic/document/invalid_document_transition_id_error.rs | 7 +++---- .../basic/document/invalid_document_type_error.rs | 4 ++-- .../basic/identity/invalid_identity_key_signature_error.rs | 4 ++-- .../consensus/basic/invalid_data_contract_version_error.rs | 5 ++--- .../src/errors/consensus/basic/invalid_identifier_error.rs | 5 ++--- .../invalid_state_transition_type_error.rs | 4 ++-- .../state_transition_max_size_exceeded_error.rs | 5 ++--- .../errors/invalid_identity_public_key_type_error.rs | 4 ++-- .../errors/invalid_signature_public_key_error.rs | 6 ++---- .../state_transition/errors/public_key_mismatch_error.rs | 4 ++-- .../errors/public_key_security_level_not_met_error.rs | 4 ++-- .../errors/state_transition_is_not_signed_error.rs | 4 ++-- .../errors/wrong_public_key_purpose_error.rs | 4 ++-- 31 files changed, 62 insertions(+), 75 deletions(-) diff --git a/packages/rs-dpp/src/data_contract/data_contract_factory.rs b/packages/rs-dpp/src/data_contract/data_contract_factory.rs index 44fc9f19198..bb93493db26 100644 --- a/packages/rs-dpp/src/data_contract/data_contract_factory.rs +++ b/packages/rs-dpp/src/data_contract/data_contract_factory.rs @@ -3,7 +3,7 @@ use serde_json::{json, Number, Value as JsonValue}; use data_contract::state_transition::property_names as st_prop; -use crate::data_contract::errors::DataContractError::InvalidDataContractError; +use crate::data_contract::errors::InvalidDataContractError; use crate::{ data_contract::{self, generate_data_contract_id}, decode_protocol_entity_factory::DecodeProtocolEntity, diff --git a/packages/rs-dpp/src/data_contract/errors/data_contract_not_present_error.rs b/packages/rs-dpp/src/data_contract/errors/data_contract_not_present_error.rs index 21729ed8df4..1e590d832c3 100644 --- a/packages/rs-dpp/src/data_contract/errors/data_contract_not_present_error.rs +++ b/packages/rs-dpp/src/data_contract/errors/data_contract_not_present_error.rs @@ -1,7 +1,7 @@ use thiserror::Error; -use crate::consensus::ConsensusError; use crate::identifier::Identifier; +use crate::ProtocolError; #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Data Contract is not present")] @@ -19,7 +19,7 @@ impl DataContractNotPresentError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: DataContractNotPresentError) -> Self { Self::DataContractNotPresentError(err) } diff --git a/packages/rs-dpp/src/data_contract/errors/identity_not_present_error.rs b/packages/rs-dpp/src/data_contract/errors/identity_not_present_error.rs index ee0479e3f2b..1870dbcbb69 100644 --- a/packages/rs-dpp/src/data_contract/errors/identity_not_present_error.rs +++ b/packages/rs-dpp/src/data_contract/errors/identity_not_present_error.rs @@ -1,7 +1,7 @@ use thiserror::Error; -use crate::consensus::ConsensusError; use crate::identifier::Identifier; +use crate::ProtocolError; #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Identity is not present")] @@ -19,7 +19,7 @@ impl IdentityNotPresentError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: IdentityNotPresentError) -> Self { Self::IdentityNotPresentError(err) } diff --git a/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs b/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs index f49a15283b9..31a2f212e42 100644 --- a/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs +++ b/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs @@ -1,7 +1,8 @@ +use crate::consensus::ConsensusError; use thiserror::Error; -use crate::consensus::ConsensusError; use crate::document::document_transition::document_base_transition::JsonValue; +use crate::ProtocolError; #[derive(Error, Debug)] #[error("Invalid Data Contract: {errors:?}")] @@ -26,7 +27,7 @@ impl InvalidDataContractError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: InvalidDataContractError) -> Self { Self::InvalidDataContractError(err) } diff --git a/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs b/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs index b49cdd76f2f..7a9f7e1dd85 100644 --- a/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs +++ b/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs @@ -1,7 +1,7 @@ use thiserror::Error; -use crate::consensus::ConsensusError; use crate::data_contract::DataContract; +use crate::ProtocolError; #[derive(Error, Debug, Clone, PartialEq)] #[error("Data Contract doesn't define document with type {doc_type}")] @@ -26,7 +26,7 @@ impl InvalidDataContractError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: InvalidDataContractError) -> Self { Self::InvalidDataContractError(err) } diff --git a/packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs b/packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs index 5cf440c4e16..e490bfbfa5e 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs @@ -1,7 +1,6 @@ +use crate::ProtocolError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Invalid State Transition type {transition_type}")] pub struct InvalidStateTransitionTypeError { @@ -18,7 +17,7 @@ impl InvalidStateTransitionTypeError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: InvalidStateTransitionTypeError) -> Self { Self::InvalidStateTransitionTypeError(err) } diff --git a/packages/rs-dpp/src/data_contract/state_transition/errors/missing_data_contract_id_error.rs b/packages/rs-dpp/src/data_contract/state_transition/errors/missing_data_contract_id_error.rs index dec21bdf761..1962ea3c8bd 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/errors/missing_data_contract_id_error.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/errors/missing_data_contract_id_error.rs @@ -1,6 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; use crate::document::document_transition::document_base_transition::JsonValue; #[derive(Error, Debug, Clone, PartialEq, Eq)] @@ -21,7 +21,7 @@ impl MissingDataContractIdError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: MissingDataContractIdError) -> Self { Self::MissingDataContractIdError(err) } diff --git a/packages/rs-dpp/src/data_contract/state_transition/errors/public_key_is_disabled_error.rs b/packages/rs-dpp/src/data_contract/state_transition/errors/public_key_is_disabled_error.rs index 6486f439d85..f0e63ce7479 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/errors/public_key_is_disabled_error.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/errors/public_key_is_disabled_error.rs @@ -1,7 +1,7 @@ use thiserror::Error; -use crate::consensus::ConsensusError; use crate::identity::IdentityPublicKey; +use crate::ProtocolError; #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Public key is disabled")] @@ -19,7 +19,7 @@ impl PublicKeyIsDisabledError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: PublicKeyIsDisabledError) -> Self { Self::PublicKeyIsDisabledError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs b/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs index 3b9bc45a43a..d7ab7ad6166 100644 --- a/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs +++ b/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs @@ -31,7 +31,7 @@ use super::basic::identity::{ use super::fee::FeeError; use super::signature::SignatureError; -#[derive(Error, Debug)] +#[derive(Error, Debug, Clone)] //#[cfg_attr(test, derive(Clone))] pub enum ConsensusError { #[error(transparent)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs index 0a84103f91f..47ab025815a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs @@ -1,7 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Document with type {document_type} has a new unique index named '{index_name}'. Adding unique indices during Data Contract update is not allowed.")] pub struct DataContractHaveNewUniqueIndexError { @@ -26,7 +25,7 @@ impl DataContractHaveNewUniqueIndexError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: DataContractHaveNewUniqueIndexError) -> Self { Self::DataContractHaveNewUniqueIndexError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs index e8d2f71dc0a..b13b25d0f70 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs @@ -1,7 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Data Contract Id must be {}, got {}", bs58::encode(expected_id).into_string(), bs58::encode(invalid_id).into_string())] pub struct InvalidDataContractIdError { @@ -25,7 +24,7 @@ impl InvalidDataContractIdError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: InvalidDataContractIdError) -> Self { Self::InvalidDataContractIdError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs index 987117630cd..4c907abef41 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs @@ -1,6 +1,6 @@ +use crate::consensus::basic::IndexError; use thiserror::Error; -use crate::consensus::ConsensusError; use crate::data_contract::document_type::Index; #[derive(Error, Debug, Clone, PartialEq, Eq)] @@ -31,7 +31,7 @@ impl SystemPropertyIndexAlreadyPresentError { } } -impl From for ConsensusError { +impl From for IndexError { fn from(err: SystemPropertyIndexAlreadyPresentError) -> Self { Self::SystemPropertyIndexAlreadyPresentError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs index 2a16627456a..6cf928abc05 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs @@ -1,6 +1,6 @@ +use crate::consensus::basic::IndexError; use thiserror::Error; -use crate::consensus::ConsensusError; use crate::data_contract::document_type::Index; #[derive(Error, Debug, Clone, PartialEq, Eq)] @@ -31,7 +31,7 @@ impl UndefinedIndexPropertyError { } } -impl From for ConsensusError { +impl From for IndexError { fn from(err: UndefinedIndexPropertyError) -> Self { Self::UndefinedIndexPropertyError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs index c9cf7938d6b..99eb097031a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs @@ -1,7 +1,6 @@ +use crate::consensus::basic::IndexError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("'{document_type}' document has more than '{index_limit}' unique indexes")] pub struct UniqueIndicesLimitReachedError { @@ -25,7 +24,7 @@ impl UniqueIndicesLimitReachedError { } } -impl From for ConsensusError { +impl From for IndexError { fn from(err: UniqueIndicesLimitReachedError) -> Self { Self::UniqueIndicesLimitReachedError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs index 37e2ca92954..7b2b684362f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs @@ -1,7 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Document transitions with duplicate IDs {:?}", references)] pub struct DuplicateDocumentTransitionsWithIdsError { @@ -18,7 +17,7 @@ impl DuplicateDocumentTransitionsWithIdsError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: DuplicateDocumentTransitionsWithIdsError) -> Self { Self::DuplicateDocumentTransitionsWithIdsError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs index 9236d7e1267..43996e1b714 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs @@ -1,7 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error( "Document transitions with duplicate unique properties: {:?}", @@ -21,7 +20,7 @@ impl DuplicateDocumentTransitionsWithIndicesError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: DuplicateDocumentTransitionsWithIndicesError) -> Self { Self::DuplicateDocumentTransitionsWithIndicesError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs index dd8e97dd918..c2550884183 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs @@ -1,7 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error( "Unique compound index properties {:?} are partially set for {document_type}", @@ -28,7 +27,7 @@ impl InconsistentCompoundIndexDataError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: InconsistentCompoundIndexDataError) -> Self { Self::InconsistentCompoundIndexDataError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs index 188e3e2837e..5a47ade3059 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs @@ -1,7 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Document transition action {} is not supported", action)] pub struct InvalidDocumentTransitionActionError { @@ -18,7 +17,7 @@ impl InvalidDocumentTransitionActionError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: InvalidDocumentTransitionActionError) -> Self { Self::InvalidDocumentTransitionActionError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs index 25e1e604957..e4a49c8236d 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs @@ -1,7 +1,6 @@ -use thiserror::Error; - -use crate::consensus::ConsensusError; +use crate::consensus::basic::BasicError; use crate::identifier::Identifier; +use thiserror::Error; #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error( @@ -31,7 +30,7 @@ impl InvalidDocumentTransitionIdError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: InvalidDocumentTransitionIdError) -> Self { Self::InvalidDocumentTransitionIdError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs index 5b473da338a..585d3e5a318 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs @@ -1,6 +1,6 @@ use thiserror::Error; -use crate::consensus::ConsensusError; +use crate::data_contract::errors::DataContractError; use crate::identifier::Identifier; #[derive(Error, Debug, Clone, PartialEq, Eq)] @@ -27,7 +27,7 @@ impl InvalidDocumentTypeError { } } -impl From for ConsensusError { +impl From for DataContractError { fn from(err: InvalidDocumentTypeError) -> Self { Self::InvalidDocumentTypeError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs index ca8b1293881..a38e93bd09a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs @@ -1,6 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; use crate::identity::KeyID; #[derive(Error, Debug, Clone, PartialEq, Eq)] @@ -19,7 +19,7 @@ impl InvalidIdentityKeySignatureError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: InvalidIdentityKeySignatureError) -> Self { Self::InvalidIdentityKeySignatureError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/invalid_data_contract_version_error.rs b/packages/rs-dpp/src/errors/consensus/basic/invalid_data_contract_version_error.rs index 16b21013d30..427a480eeec 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/invalid_data_contract_version_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/invalid_data_contract_version_error.rs @@ -1,7 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Data Contract version must be {expected_version}, go {version}")] pub struct InvalidDataContractVersionError { @@ -26,7 +25,7 @@ impl InvalidDataContractVersionError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: InvalidDataContractVersionError) -> Self { Self::InvalidDataContractVersionError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs b/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs index b458b2a9d8f..cb1dba57de3 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs @@ -1,7 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Invalid {}: {}", identifier_name, error)] pub struct InvalidIdentifierError { @@ -26,7 +25,7 @@ impl InvalidIdentifierError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: InvalidIdentifierError) -> Self { Self::InvalidIdentifierError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs index 5cf440c4e16..dd0784d4bfd 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs @@ -1,6 +1,6 @@ use thiserror::Error; -use crate::consensus::ConsensusError; +use crate::ProtocolError; #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Invalid State Transition type {transition_type}")] @@ -18,7 +18,7 @@ impl InvalidStateTransitionTypeError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: InvalidStateTransitionTypeError) -> Self { Self::InvalidStateTransitionTypeError(err) } diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs index 596d442959f..40aac4b25ff 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs @@ -1,7 +1,6 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::ConsensusError; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("State transition size {actual_size_kbytes} KB is more than maximum {max_size_kbytes} KB")] pub struct StateTransitionMaxSizeExceededError { @@ -25,7 +24,7 @@ impl StateTransitionMaxSizeExceededError { } } -impl From for ConsensusError { +impl From for BasicError { fn from(err: StateTransitionMaxSizeExceededError) -> Self { Self::StateTransitionMaxSizeExceededError(err) } diff --git a/packages/rs-dpp/src/state_transition/errors/invalid_identity_public_key_type_error.rs b/packages/rs-dpp/src/state_transition/errors/invalid_identity_public_key_type_error.rs index 703e7c67bc2..33dd2468da5 100644 --- a/packages/rs-dpp/src/state_transition/errors/invalid_identity_public_key_type_error.rs +++ b/packages/rs-dpp/src/state_transition/errors/invalid_identity_public_key_type_error.rs @@ -1,7 +1,7 @@ use thiserror::Error; -use crate::consensus::ConsensusError; use crate::identity::KeyType; +use crate::ProtocolError; #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Invalid signature type")] @@ -19,7 +19,7 @@ impl InvalidIdentityPublicKeyTypeError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: InvalidIdentityPublicKeyTypeError) -> Self { Self::InvalidIdentityPublicKeyTypeError(err) } diff --git a/packages/rs-dpp/src/state_transition/errors/invalid_signature_public_key_error.rs b/packages/rs-dpp/src/state_transition/errors/invalid_signature_public_key_error.rs index 7c7ff8ffd07..9a4a60027d0 100644 --- a/packages/rs-dpp/src/state_transition/errors/invalid_signature_public_key_error.rs +++ b/packages/rs-dpp/src/state_transition/errors/invalid_signature_public_key_error.rs @@ -1,8 +1,6 @@ +use crate::ProtocolError; use thiserror::Error; -use crate::consensus::ConsensusError; -use crate::identity::SecurityLevel; - #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Invalid signature public key")] pub struct InvalidSignaturePublicKeyError { @@ -19,7 +17,7 @@ impl InvalidSignaturePublicKeyError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: InvalidSignaturePublicKeyError) -> Self { Self::InvalidSignaturePublicKeyError(err) } diff --git a/packages/rs-dpp/src/state_transition/errors/public_key_mismatch_error.rs b/packages/rs-dpp/src/state_transition/errors/public_key_mismatch_error.rs index ec32c20164e..7716e98a963 100644 --- a/packages/rs-dpp/src/state_transition/errors/public_key_mismatch_error.rs +++ b/packages/rs-dpp/src/state_transition/errors/public_key_mismatch_error.rs @@ -1,7 +1,7 @@ use thiserror::Error; -use crate::consensus::ConsensusError; use crate::identity::IdentityPublicKey; +use crate::ProtocolError; #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Public key mismatched")] @@ -19,7 +19,7 @@ impl PublicKeyMismatchError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: PublicKeyMismatchError) -> Self { Self::PublicKeyMismatchError(err) } diff --git a/packages/rs-dpp/src/state_transition/errors/public_key_security_level_not_met_error.rs b/packages/rs-dpp/src/state_transition/errors/public_key_security_level_not_met_error.rs index d0ca0781c70..c69caff4026 100644 --- a/packages/rs-dpp/src/state_transition/errors/public_key_security_level_not_met_error.rs +++ b/packages/rs-dpp/src/state_transition/errors/public_key_security_level_not_met_error.rs @@ -1,7 +1,7 @@ use thiserror::Error; -use crate::consensus::ConsensusError; use crate::identity::SecurityLevel; +use crate::ProtocolError; #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Invalid key security level: {public_key_security_level}. The state transition requires at least: {required_security_level}")] @@ -29,7 +29,7 @@ impl PublicKeySecurityLevelNotMetError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: PublicKeySecurityLevelNotMetError) -> Self { Self::PublicKeySecurityLevelNotMetError(err) } diff --git a/packages/rs-dpp/src/state_transition/errors/state_transition_is_not_signed_error.rs b/packages/rs-dpp/src/state_transition/errors/state_transition_is_not_signed_error.rs index eee01d9ac40..cc126cdb956 100644 --- a/packages/rs-dpp/src/state_transition/errors/state_transition_is_not_signed_error.rs +++ b/packages/rs-dpp/src/state_transition/errors/state_transition_is_not_signed_error.rs @@ -1,7 +1,7 @@ use thiserror::Error; -use crate::consensus::ConsensusError; use crate::state_transition::StateTransition; +use crate::ProtocolError; #[derive(Error, Debug, Clone)] #[error("State Transition is not signed")] @@ -19,7 +19,7 @@ impl StateTransitionIsNotSignedError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: StateTransitionIsNotSignedError) -> Self { Self::StateTransitionIsNotSignedError(err) } diff --git a/packages/rs-dpp/src/state_transition/errors/wrong_public_key_purpose_error.rs b/packages/rs-dpp/src/state_transition/errors/wrong_public_key_purpose_error.rs index 769093905f8..12f05a3f437 100644 --- a/packages/rs-dpp/src/state_transition/errors/wrong_public_key_purpose_error.rs +++ b/packages/rs-dpp/src/state_transition/errors/wrong_public_key_purpose_error.rs @@ -1,7 +1,7 @@ use thiserror::Error; -use crate::consensus::ConsensusError; use crate::identity::Purpose; +use crate::ProtocolError; #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Invalid identity key purpose {public_key_purpose}. This state transition requires {key_purpose_requirement}")] @@ -26,7 +26,7 @@ impl WrongPublicKeyPurposeError { } } -impl From for ConsensusError { +impl From for ProtocolError { fn from(err: WrongPublicKeyPurposeError) -> Self { Self::WrongPublicKeyPurposeError(err) } From 5e2740d2aefa0044a7a0025265b351167c47151f Mon Sep 17 00:00:00 2001 From: Anton Suprunchuk Date: Thu, 23 Feb 2023 20:51:54 +0700 Subject: [PATCH 03/11] resolve conflicts and run fmt --- .../src/data_contract/data_contract_factory.rs | 2 +- .../errors/invalid_document_type_error.rs | 10 +++++----- ...ata_contract_immutable_properties_update_error.rs | 2 +- .../basic/data_contract/duplicate_index_error.rs | 2 +- .../data_contract/invalid_compound_index_error.rs | 5 +---- .../consensus/signature/missing_public_key_error.rs | 7 ++++--- packages/rs-dpp/src/errors/errors.rs | 5 +++-- ...te_identity_credit_withdrawal_transition_state.rs | 4 +--- .../apply_identity_update_transition.rs | 8 +------- .../validate_public_key_signatures.rs | 7 ++++--- .../abstract_state_transition_identity_signed.rs | 12 +++--------- 11 files changed, 25 insertions(+), 39 deletions(-) diff --git a/packages/rs-dpp/src/data_contract/data_contract_factory.rs b/packages/rs-dpp/src/data_contract/data_contract_factory.rs index 85b54bf4ecf..a3f0baccb07 100644 --- a/packages/rs-dpp/src/data_contract/data_contract_factory.rs +++ b/packages/rs-dpp/src/data_contract/data_contract_factory.rs @@ -4,9 +4,9 @@ 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::data_contract::errors::InvalidDataContractError; use crate::{ data_contract::{self, generate_data_contract_id}, decode_protocol_entity_factory::DecodeProtocolEntity, diff --git a/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs b/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs index 7a9f7e1dd85..8f63b56ea7a 100644 --- a/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs +++ b/packages/rs-dpp/src/data_contract/errors/invalid_document_type_error.rs @@ -5,12 +5,12 @@ use crate::ProtocolError; #[derive(Error, Debug, Clone, PartialEq)] #[error("Data Contract doesn't define document with type {doc_type}")] -pub struct InvalidDataContractError { +pub struct InvalidDocumentTypeError { doc_type: String, data_contract: DataContract, } -impl InvalidDataContractError { +impl InvalidDocumentTypeError { pub fn new(doc_type: String, data_contract: DataContract) -> Self { Self { doc_type, @@ -26,8 +26,8 @@ impl InvalidDataContractError { } } -impl From for ProtocolError { - fn from(err: InvalidDataContractError) -> Self { - Self::InvalidDataContractError(err) +impl From for ProtocolError { + fn from(err: InvalidDocumentTypeError) -> Self { + Self::InvalidDocumentTypeError(err) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs index 4c2e49886b6..c032a69d3ff 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs @@ -20,7 +20,7 @@ impl DataContractImmutablePropertiesUpdateError { pub fn operation(&self) -> String { self.operation.clone() } - + pub fn field_path(&self) -> String { self.field_path.clone() } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs index ef5f818c6b0..ac014ec34db 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs @@ -21,7 +21,7 @@ impl DuplicateIndexError { pub fn document_type(&self) -> String { self.document_type.clone() } - + pub fn index_definition(&self) -> Index { self.index_definition.clone() } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs index ded7d9baf64..8e6f2012e8d 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs @@ -11,10 +11,7 @@ pub struct InvalidCompoundIndexError { } impl InvalidCompoundIndexError { - pub fn new( - document_type: String, - index_definition: Index, - ) -> Self { + pub fn new(document_type: String, index_definition: Index) -> Self { Self { document_type, index_definition, diff --git a/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs b/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs index 004231bd747..abe13ad9a46 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs @@ -2,19 +2,20 @@ use thiserror::Error; use crate::consensus::signature::SignatureError; use crate::consensus::ConsensusError; +use crate::identity::KeyID; #[derive(Error, Debug, Clone, PartialEq, Eq)] #[error("Public key {public_key_id} doesn't exist")] pub struct MissingPublicKeyError { - public_key_id: u64, + public_key_id: KeyID, } impl MissingPublicKeyError { - pub fn new(public_key_id: u64) -> Self { + pub fn new(public_key_id: KeyID) -> Self { Self { public_key_id } } - pub fn public_key_id(&self) -> u64 { + pub fn public_key_id(&self) -> KeyID { self.public_key_id } } diff --git a/packages/rs-dpp/src/errors/errors.rs b/packages/rs-dpp/src/errors/errors.rs index c17205e9ea1..44f6c46de1a 100644 --- a/packages/rs-dpp/src/errors/errors.rs +++ b/packages/rs-dpp/src/errors/errors.rs @@ -87,6 +87,9 @@ pub enum ProtocolError { #[error(transparent)] InvalidDataContractError(InvalidDataContractError), + #[error(transparent)] + InvalidDocumentTypeError(InvalidDocumentTypeError), + #[error(transparent)] DataContractNotPresentError(DataContractNotPresentError), @@ -104,8 +107,6 @@ pub enum ProtocolError { #[error(transparent)] IdentityNotPresentError(IdentityNotPresentError), - #[error("Identity is not present")] - IdentityNotPresentError { id: Identifier }, /// Error #[error("overflow error: {0}")] diff --git a/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs b/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs index 7673b18c4e7..61b9866c551 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs @@ -48,9 +48,7 @@ where .map_err(|e| NonConsensusError::StateRepositoryFetchError(e.to_string()))?; let Some(existing_identity) = maybe_existing_identity else { - let err = BasicError::IdentityNotFoundError { - identity_id: state_transition.identity_id, - }; + let err = IdentityNotFoundError::new(state_transition.identity_id); result.add_error(err); diff --git a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs index 3092c03b363..2a7ea590d25 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs @@ -1,8 +1,8 @@ use anyhow::anyhow; use std::sync::Arc; -use crate::identity::IdentityPublicKey; use crate::consensus::signature::{IdentityNotFoundError, SignatureError}; +use crate::identity::IdentityPublicKey; use crate::{ state_repository::StateRepositoryLike, state_transition::StateTransitionLike, ProtocolError, }; @@ -73,9 +73,3 @@ pub async fn apply_identity_update_transition( Ok(()) } - -fn identity_not_found_error(identity_id: Identifier) -> ProtocolError { - ProtocolError::AbstractConsensusError(Box::new(ConsensusError::SignatureError( - SignatureError::IdentityNotFoundError(IdentityNotFoundError::new(identity_id)), - ))) -} diff --git a/packages/rs-dpp/src/identity/state_transition/validate_public_key_signatures.rs b/packages/rs-dpp/src/identity/state_transition/validate_public_key_signatures.rs index 839664c2c2e..07ada1f637f 100644 --- a/packages/rs-dpp/src/identity/state_transition/validate_public_key_signatures.rs +++ b/packages/rs-dpp/src/identity/state_transition/validate_public_key_signatures.rs @@ -2,6 +2,7 @@ use serde_json::Value; use crate::consensus::basic::identity::InvalidIdentityKeySignatureError; use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; +use crate::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransition; use crate::{ consensus::{basic::BasicError, ConsensusError}, object_names, @@ -95,9 +96,9 @@ pub fn validate_public_key_signatures<'a, T: BlsModule>( let maybe_invalid_public_key_transition = find_invalid_public_key(&mut state_transition, add_public_key_transitions, bls); if let Some(invalid_key_transition) = maybe_invalid_public_key_transition { - validation_result.add_error(BasicError::InvalidIdentityKeySignatureError { - public_key_id: invalid_key_transition.id, - }) + validation_result.add_error(BasicError::InvalidIdentityKeySignatureError( + InvalidIdentityKeySignatureError::new(invalid_key_transition.id), + )) } Ok(validation_result) diff --git a/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs b/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs index bd99f129a09..28ae55f4c4e 100644 --- a/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs +++ b/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs @@ -43,9 +43,7 @@ where if public_key_compressed.to_vec() != identity_public_key.data { return Err(ProtocolError::InvalidSignaturePublicKeyError( - InvalidSignaturePublicKeyError::new( - identity_public_key.data.to_owned(), - ), + InvalidSignaturePublicKeyError::new(identity_public_key.data.to_owned()), )); } @@ -57,9 +55,7 @@ where if pub_key_hash != identity_public_key.data { return Err(ProtocolError::InvalidSignaturePublicKeyError( - InvalidSignaturePublicKeyError::new( - identity_public_key.data.to_owned(), - ), + InvalidSignaturePublicKeyError::new(identity_public_key.data.to_owned()), )); } self.sign_by_private_key(private_key, identity_public_key.key_type, bls) @@ -69,9 +65,7 @@ where if public_key != identity_public_key.data { return Err(ProtocolError::InvalidSignaturePublicKeyError( - InvalidSignaturePublicKeyError::new( - identity_public_key.data.to_owned(), - ), + InvalidSignaturePublicKeyError::new(identity_public_key.data.to_owned()), )); } self.sign_by_private_key(private_key, identity_public_key.key_type, bls) From 7cea3189a654dd8581e49246147bd627e2776256 Mon Sep 17 00:00:00 2001 From: Anton Suprunchuk Date: Thu, 23 Feb 2023 22:01:33 +0700 Subject: [PATCH 04/11] fix some errors --- packages/rs-dpp/src/data_contract/data_contract.rs | 6 +++--- .../rs-dpp/src/document/fetch_and_validate_data_contract.rs | 3 ++- .../basic/validate_documents_batch_transition_basic.rs | 3 ++- packages/rs-dpp/src/errors/codes.rs | 1 - .../src/errors/consensus/basic/abstract_basic_error.rs | 5 +++-- packages/rs-dpp/src/errors/errors.rs | 6 +++--- .../rs-dpp/src/state_transition/state_transition_factory.rs | 3 ++- .../validation/validate_state_transition_fee.rs | 4 +++- 8 files changed, 18 insertions(+), 13 deletions(-) diff --git a/packages/rs-dpp/src/data_contract/data_contract.rs b/packages/rs-dpp/src/data_contract/data_contract.rs index 6f6e198fa31..91204812423 100644 --- a/packages/rs-dpp/src/data_contract/data_contract.rs +++ b/packages/rs-dpp/src/data_contract/data_contract.rs @@ -337,7 +337,7 @@ impl DataContract { .ok_or(ProtocolError::DataContractError( DataContractError::InvalidDocumentTypeError(InvalidDocumentTypeError::new( doc_type.to_owned(), - self.clone().id, + self.id.clone(), )), ))?; Ok(document) @@ -348,7 +348,7 @@ impl DataContract { return Err(ProtocolError::DataContractError( DataContractError::InvalidDocumentTypeError(InvalidDocumentTypeError::new( doc_type.to_owned(), - self.clone().id, + self.id.clone(), )), )); }; @@ -372,7 +372,7 @@ impl DataContract { .ok_or(ProtocolError::DataContractError( DataContractError::InvalidDocumentTypeError(InvalidDocumentTypeError::new( doc_type.to_owned(), - self.clone().id, + self.id.clone(), )), )) } diff --git a/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs b/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs index a80f528f6f9..bf1f4238f89 100644 --- a/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs +++ b/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs @@ -13,6 +13,7 @@ use crate::{ validation::ValidationResult, ProtocolError, }; +use crate::data_contract::state_transition::errors::MissingDataContractIdError; use super::property_names; @@ -50,7 +51,7 @@ pub async fn fetch_and_validate_data_contract( id_bytes } else { validation_result.add_error(ConsensusError::BasicError(Box::new( - BasicError::MissingDataContractIdError, + BasicError::MissingDataContractIdError(MissingDataContractIdError::new(raw_document.clone())), ))); return Ok(validation_result); }; diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs index cae9af6df8c..038fccd3963 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs @@ -30,6 +30,7 @@ use crate::{ use anyhow::anyhow; use lazy_static::lazy_static; use serde_json::Value as JsonValue; +use crate::data_contract::state_transition::errors::MissingDataContractIdError; use super::{ find_duplicates_by_indices::find_duplicates_by_indices, @@ -98,7 +99,7 @@ pub async fn validate_documents_batch_transition_basic( for raw_document_transition in raw_document_transitions { let data_contract_id_bytes = match raw_document_transition.get_bytes("$dataContractId") { Err(_) => { - result.add_error(BasicError::MissingDataContractIdError); + result.add_error(BasicError::MissingDataContractIdError(MissingDataContractIdError::new(raw_document_transition.clone()))); continue; } Ok(id) => id, diff --git a/packages/rs-dpp/src/errors/codes.rs b/packages/rs-dpp/src/errors/codes.rs index d7db9ded82e..a94c36f1e53 100644 --- a/packages/rs-dpp/src/errors/codes.rs +++ b/packages/rs-dpp/src/errors/codes.rs @@ -130,7 +130,6 @@ impl ErrorWithCode for BasicError { Self::DataContractHaveNewUniqueIndexError { .. } => 0, Self::DataContractInvalidIndexDefinitionUpdateError { .. } => 0, Self::IndexError(ref e) => e.get_code(), - Self::IdentityNotFoundError { .. } => 2000, Self::InvalidDataContractIdError { .. } => 1011, // State Transition diff --git a/packages/rs-dpp/src/errors/consensus/basic/abstract_basic_error.rs b/packages/rs-dpp/src/errors/consensus/basic/abstract_basic_error.rs index 51d6650ba53..27884e8b2f3 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/abstract_basic_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/abstract_basic_error.rs @@ -20,6 +20,7 @@ use crate::consensus::basic::invalid_identifier_error::InvalidIdentifierError; use crate::consensus::basic::state_transition::{ InvalidStateTransitionTypeError, StateTransitionMaxSizeExceededError, }; +use crate::data_contract::state_transition::errors::MissingDataContractIdError; use crate::prelude::*; #[derive(Error, Debug)] @@ -73,8 +74,8 @@ pub enum BasicError { #[error(transparent)] DuplicateDocumentTransitionsWithIndicesError(DuplicateDocumentTransitionsWithIndicesError), - #[error("$dataContractId is not present")] - MissingDataContractIdError, + #[error(transparent)] + MissingDataContractIdError(MissingDataContractIdError), #[error(transparent)] InvalidIdentifierError(InvalidIdentifierError), diff --git a/packages/rs-dpp/src/errors/errors.rs b/packages/rs-dpp/src/errors/errors.rs index 44f6c46de1a..908ef5ea34c 100644 --- a/packages/rs-dpp/src/errors/errors.rs +++ b/packages/rs-dpp/src/errors/errors.rs @@ -4,7 +4,7 @@ use thiserror::Error; use crate::consensus::signature::InvalidSignaturePublicKeySecurityLevelError; use crate::consensus::ConsensusError; use crate::data_contract::errors::*; -use crate::data_contract::state_transition::errors::MissingDataContractIdError; +use crate::data_contract::state_transition::errors::{InvalidStateTransitionTypeError, MissingDataContractIdError}; use crate::data_contract::state_transition::errors::PublicKeyIsDisabledError; use crate::document::errors::*; use crate::identity::{Purpose, SecurityLevel}; @@ -96,8 +96,8 @@ pub enum ProtocolError { #[error(transparent)] InvalidSignaturePublicKeySecurityLevelError(InvalidSignaturePublicKeySecurityLevelError), - #[error("State Transition type is not present")] - InvalidStateTransitionTypeError, + #[error(transparent)] + InvalidStateTransitionTypeError(InvalidStateTransitionTypeError), #[error(transparent)] MissingDataContractIdError(MissingDataContractIdError), diff --git a/packages/rs-dpp/src/state_transition/state_transition_factory.rs b/packages/rs-dpp/src/state_transition/state_transition_factory.rs index a40917e63d1..98b1f3f76a2 100644 --- a/packages/rs-dpp/src/state_transition/state_transition_factory.rs +++ b/packages/rs-dpp/src/state_transition/state_transition_factory.rs @@ -21,6 +21,7 @@ use crate::{ ProtocolError, }; use serde_json::Value as JsonValue; +use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; use super::{ state_transition_execution_context::StateTransitionExecutionContext, StateTransition, @@ -74,7 +75,7 @@ pub async fn create_state_transition( Ok(StateTransition::DocumentsBatch(documents_batch_transition)) } // TODO!! add basic validation - StateTransitionType::IdentityUpdate => Err(ProtocolError::InvalidStateTransitionTypeError), + StateTransitionType::IdentityUpdate => Err(ProtocolError::InvalidStateTransitionTypeError(InvalidStateTransitionTypeError::new(transition_type as u8))), } } diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs index 04578fb12df..b7865d4f136 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs @@ -14,6 +14,8 @@ use crate::{ ProtocolError, }; use std::sync::Arc; +use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; +use crate::state_transition::StateTransitionType; pub struct StateTransitionFeeValidator { state_repository: Arc, @@ -115,7 +117,7 @@ where balance } StateTransition::IdentityCreditWithdrawal(_) => { - return Err(ProtocolError::InvalidStateTransitionTypeError); + return Err(ProtocolError::InvalidStateTransitionTypeError(InvalidStateTransitionTypeError::new(StateTransitionType::IdentityCreditWithdrawal as u8))); } }; From 0a1bc1cc84af2e1171ad885a6d4db66c7656c32c Mon Sep 17 00:00:00 2001 From: Anton Suprunchuk Date: Sat, 25 Feb 2023 16:53:32 +0700 Subject: [PATCH 05/11] fix the rest of the compilation errors --- .../errors/invalid_data_contract_error.rs | 6 +- ...gnature_public_key_security_level_error.rs | 24 -- .../state_transition/errors/mod.rs | 2 - ...lidate_documents_batch_transition_state.rs | 2 +- packages/rs-dpp/src/errors/codes.rs | 2 +- .../consensus/abstract_consensus_error.rs | 2 +- ...tract_immutable_properties_update_error.rs | 3 +- ...t_invalid_index_definition_update_error.rs | 3 +- ...a_contract_unique_indices_changed_error.rs | 3 +- .../data_contract/duplicate_index_error.rs | 3 +- .../duplicate_index_name_error.rs | 3 +- ...incompatible_data_contract_schema_error.rs | 3 +- .../invalid_compound_index_error.rs | 3 +- .../invalid_index_property_type_error.rs | 3 +- ...valid_indexed_property_constraint_error.rs | 3 +- .../invalid_json_schema_ref_error.rs | 3 +- .../decode/protocol_version_parsing_error.rs | 2 +- packages/rs-dpp/src/errors/errors.rs | 4 +- .../rs-dpp/src/errors/non_consensus_error.rs | 8 +- ...tity_credit_withdrawal_transition_state.rs | 4 +- .../apply_identity_update_transition.rs | 1 - .../state_transition_factory.rs | 6 +- ...ate_state_transition_identity_signature.rs | 32 +- .../errors/invalid_document_type.rs | 12 +- .../wasm-dpp/src/data_contract/errors/mod.rs | 9 +- .../data_contract_factory.rs | 4 +- .../missing_data_contract_id_error.rs | 13 +- .../wasm-dpp/src/errors/consensus_error.rs | 400 ++++++++---------- .../wasm-dpp/src/errors/protocol_error.rs | 8 +- packages/wasm-dpp/src/identifier/mod.rs | 2 +- 30 files changed, 249 insertions(+), 324 deletions(-) delete mode 100644 packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs diff --git a/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs b/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs index 31a2f212e42..6482309ac96 100644 --- a/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs +++ b/packages/rs-dpp/src/data_contract/errors/invalid_data_contract_error.rs @@ -7,7 +7,7 @@ use crate::ProtocolError; #[derive(Error, Debug)] #[error("Invalid Data Contract: {errors:?}")] pub struct InvalidDataContractError { - errors: Vec, + pub errors: Vec, raw_data_contract: JsonValue, } @@ -19,8 +19,8 @@ impl InvalidDataContractError { } } - pub fn errors(&self) -> Vec { - self.errors.clone() + pub fn errors(&self) -> &[ConsensusError] { + &self.errors } pub fn raw_data_contract(&self) -> JsonValue { self.raw_data_contract.clone() diff --git a/packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs b/packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs deleted file mode 100644 index e490bfbfa5e..00000000000 --- a/packages/rs-dpp/src/data_contract/state_transition/errors/invalid_signature_public_key_security_level_error.rs +++ /dev/null @@ -1,24 +0,0 @@ -use crate::ProtocolError; -use thiserror::Error; - -#[derive(Error, Debug, Clone, PartialEq, Eq)] -#[error("Invalid State Transition type {transition_type}")] -pub struct InvalidStateTransitionTypeError { - transition_type: u8, -} - -impl InvalidStateTransitionTypeError { - pub fn new(transition_type: u8) -> Self { - Self { transition_type } - } - - pub fn transition_type(&self) -> u8 { - self.transition_type - } -} - -impl From for ProtocolError { - fn from(err: InvalidStateTransitionTypeError) -> Self { - Self::InvalidStateTransitionTypeError(err) - } -} diff --git a/packages/rs-dpp/src/data_contract/state_transition/errors/mod.rs b/packages/rs-dpp/src/data_contract/state_transition/errors/mod.rs index 82c7c21b94c..61ac29290ae 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/errors/mod.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/errors/mod.rs @@ -1,7 +1,5 @@ -mod invalid_signature_public_key_security_level_error; mod missing_data_contract_id_error; mod public_key_is_disabled_error; -pub use invalid_signature_public_key_security_level_error::*; pub use missing_data_contract_id_error::*; pub use public_key_is_disabled_error::*; diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_batch_transition_state.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_batch_transition_state.rs index 4a2396538b7..f763ae23805 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_batch_transition_state.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/state/validate_documents_batch_transition_state.rs @@ -261,7 +261,7 @@ fn check_revision( result.add_error(ConsensusError::StateError(Box::new( StateError::InvalidDocumentRevisionError { document_id: document_transition.base().id.clone(), - current_revision: fetched_document.revision, + current_revision: fetched_document.revision as Revision, }, ))) } diff --git a/packages/rs-dpp/src/errors/codes.rs b/packages/rs-dpp/src/errors/codes.rs index a94c36f1e53..65a6c763704 100644 --- a/packages/rs-dpp/src/errors/codes.rs +++ b/packages/rs-dpp/src/errors/codes.rs @@ -112,7 +112,7 @@ impl ErrorWithCode for BasicError { Self::DuplicateDocumentTransitionsWithIdsError { .. } => 1019, Self::DuplicateDocumentTransitionsWithIndicesError { .. } => 1020, - Self::MissingDataContractIdError => 1025, + Self::MissingDataContractIdError { .. } => 1025, Self::InvalidIdentifierError { .. } => 1006, // Data contract diff --git a/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs b/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs index 15baf3a6a6b..0cf072fa401 100644 --- a/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs +++ b/packages/rs-dpp/src/errors/consensus/abstract_consensus_error.rs @@ -32,7 +32,7 @@ use super::basic::identity::{ use super::fee::FeeError; use super::signature::SignatureError; -#[derive(Error, Debug, Clone)] +#[derive(Error, Debug)] //#[cfg_attr(test, derive(Clone))] pub enum ConsensusError { #[error(transparent)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs index c032a69d3ff..b2fd60b5790 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs @@ -1,4 +1,5 @@ use thiserror::Error; +use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; @@ -28,6 +29,6 @@ impl DataContractImmutablePropertiesUpdateError { impl From for ConsensusError { fn from(err: DataContractImmutablePropertiesUpdateError) -> Self { - Self::DataContractImmutablePropertiesUpdateError(err) + Self::BasicError(Box::new(BasicError::DataContractImmutablePropertiesUpdateError(err))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs index 9159c2d5ab3..45e5bb593c9 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs @@ -1,4 +1,5 @@ use thiserror::Error; +use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; @@ -28,6 +29,6 @@ impl DataContractInvalidIndexDefinitionUpdateError { impl From for ConsensusError { fn from(err: DataContractInvalidIndexDefinitionUpdateError) -> Self { - Self::DataContractInvalidIndexDefinitionUpdateError(err) + Self::BasicError(Box::new(BasicError::DataContractInvalidIndexDefinitionUpdateError(err))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs index f142d420c4d..5343fecf2ad 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs @@ -1,4 +1,5 @@ use thiserror::Error; +use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; @@ -28,6 +29,6 @@ impl DataContractUniqueIndicesChangedError { impl From for ConsensusError { fn from(err: DataContractUniqueIndicesChangedError) -> Self { - Self::DataContractUniqueIndicesChangedError(err) + Self::BasicError(Box::new(BasicError::DataContractUniqueIndicesChangedError(err))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs index ac014ec34db..cb5466aa4c8 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs @@ -1,4 +1,5 @@ use thiserror::Error; +use crate::consensus::basic::{BasicError, IndexError}; use crate::consensus::ConsensusError; use crate::data_contract::document_type::Index; @@ -29,6 +30,6 @@ impl DuplicateIndexError { impl From for ConsensusError { fn from(err: DuplicateIndexError) -> Self { - Self::DuplicateIndexError(err) + Self::BasicError(Box::new(BasicError::IndexError(IndexError::DuplicateIndexError(err)))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs index 3584efa1e12..dea3e2f1fed 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs @@ -1,4 +1,5 @@ use thiserror::Error; +use crate::consensus::basic::{BasicError}; use crate::consensus::ConsensusError; @@ -28,6 +29,6 @@ impl DuplicateIndexNameError { impl From for ConsensusError { fn from(err: DuplicateIndexNameError) -> Self { - Self::DuplicateIndexNameError(err) + Self::BasicError(Box::new(BasicError::DuplicateIndexNameError(err))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs index d08454d2372..282aa5cbe85 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs @@ -1,4 +1,5 @@ use thiserror::Error; +use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::document::document_transition::document_base_transition::JsonValue; @@ -51,6 +52,6 @@ impl IncompatibleDataContractSchemaError { impl From for ConsensusError { fn from(err: IncompatibleDataContractSchemaError) -> Self { - Self::IncompatibleDataContractSchemaError(err) + Self::BasicError(Box::new(BasicError::IncompatibleDataContractSchemaError(err))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs index 8e6f2012e8d..fe94ca77dee 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs @@ -1,4 +1,5 @@ use thiserror::Error; +use crate::consensus::basic::{BasicError, IndexError}; use crate::consensus::ConsensusError; use crate::data_contract::document_type::Index; @@ -28,6 +29,6 @@ impl InvalidCompoundIndexError { impl From for ConsensusError { fn from(err: InvalidCompoundIndexError) -> Self { - Self::InvalidCompoundIndexError(err) + Self::BasicError(Box::new(BasicError::IndexError(IndexError::InvalidCompoundIndexError(err)))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs index 6d4d345843d..ace21f7d235 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs @@ -1,4 +1,5 @@ use thiserror::Error; +use crate::consensus::basic::{BasicError, IndexError}; use crate::consensus::ConsensusError; use crate::data_contract::document_type::Index; @@ -43,6 +44,6 @@ impl InvalidIndexPropertyTypeError { impl From for ConsensusError { fn from(err: InvalidIndexPropertyTypeError) -> Self { - Self::UndefinedIndexPropertyError(err) + Self::BasicError(Box::new(BasicError::IndexError(IndexError::InvalidIndexPropertyTypeError(err)))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs index 1e9d2e0ae8c..e8de479a827 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs @@ -1,4 +1,5 @@ use thiserror::Error; +use crate::consensus::basic::{BasicError, IndexError}; use crate::consensus::ConsensusError; use crate::data_contract::document_type::Index; @@ -49,6 +50,6 @@ impl InvalidIndexedPropertyConstraintError { impl From for ConsensusError { fn from(err: InvalidIndexedPropertyConstraintError) -> Self { - Self::InvalidIndexedPropertyConstraintError(err) + Self::BasicError(Box::new(BasicError::IndexError(IndexError::InvalidIndexedPropertyConstraintError(err)))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs index 5874e2fb9c6..678e5a3f761 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs @@ -1,4 +1,5 @@ use thiserror::Error; +use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; @@ -20,6 +21,6 @@ impl InvalidJsonSchemaRefError { impl From for ConsensusError { fn from(err: InvalidJsonSchemaRefError) -> Self { - Self::InvalidJsonSchemaRefError(err) + Self::BasicError(Box::new(BasicError::InvalidJsonSchemaRefError(err))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs b/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs index d6a7ed11212..0a5e22b9a67 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs @@ -5,7 +5,7 @@ use crate::consensus::ConsensusError; #[derive(Error, Debug)] #[error("Can't read protocol version from serialized object: {parsing_error}")] pub struct ProtocolVersionParsingError { - parsing_error: anyhow::Error, + pub parsing_error: anyhow::Error, } impl ProtocolVersionParsingError { diff --git a/packages/rs-dpp/src/errors/errors.rs b/packages/rs-dpp/src/errors/errors.rs index 908ef5ea34c..a93571fd661 100644 --- a/packages/rs-dpp/src/errors/errors.rs +++ b/packages/rs-dpp/src/errors/errors.rs @@ -4,15 +4,15 @@ use thiserror::Error; use crate::consensus::signature::InvalidSignaturePublicKeySecurityLevelError; use crate::consensus::ConsensusError; use crate::data_contract::errors::*; -use crate::data_contract::state_transition::errors::{InvalidStateTransitionTypeError, MissingDataContractIdError}; +use crate::data_contract::state_transition::errors::{MissingDataContractIdError}; use crate::data_contract::state_transition::errors::PublicKeyIsDisabledError; use crate::document::errors::*; -use crate::identity::{Purpose, SecurityLevel}; use crate::state_transition::errors::{ InvalidIdentityPublicKeyTypeError, InvalidSignaturePublicKeyError, PublicKeyMismatchError, PublicKeySecurityLevelNotMetError, StateTransitionIsNotSignedError, WrongPublicKeyPurposeError, }; use crate::{CompatibleProtocolVersionIsNotDefinedError, NonConsensusError, SerdeParsingError}; +use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; #[derive(Error, Debug)] pub enum ProtocolError { diff --git a/packages/rs-dpp/src/errors/non_consensus_error.rs b/packages/rs-dpp/src/errors/non_consensus_error.rs index 87e84c0645f..c39b280ea67 100644 --- a/packages/rs-dpp/src/errors/non_consensus_error.rs +++ b/packages/rs-dpp/src/errors/non_consensus_error.rs @@ -10,15 +10,15 @@ pub enum NonConsensusError { SerdeParsingError(SerdeParsingError), #[error(transparent)] CompatibleProtocolVersionIsNotDefinedError(CompatibleProtocolVersionIsNotDefinedError), - #[error(transparent)] + #[error("SerdeJsonError: {0}")] SerdeJsonError(String), #[error(transparent)] InvalidVectorSizeError(InvalidVectorSizeError), - #[error(transparent)] + #[error("StateRepositoryFetchError: {0}")] StateRepositoryFetchError(String), - #[error(transparent)] + #[error("IdentifierCreateError: {0}")] IdentifierCreateError(String), - #[error(transparent)] + #[error("IdentityPublicKeyCreateError: {0}")] IdentityPublicKeyCreateError(String), /// When dynamic `Value` is validated it requires some specific properties to properly work diff --git a/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs b/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs index 61b9866c551..7f2d59aa73d 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs @@ -3,9 +3,9 @@ use std::sync::Arc; use anyhow::Result; -use crate::consensus::signature::{IdentityNotFoundError, SignatureError}; +use crate::consensus::signature::{IdentityNotFoundError}; use crate::{ - consensus::basic::{identity::IdentityInsufficientBalanceError, BasicError}, + consensus::basic::{identity::IdentityInsufficientBalanceError}, identity::state_transition::identity_credit_withdrawal_transition::IdentityCreditWithdrawalTransition, state_repository::StateRepositoryLike, state_transition::StateTransitionLike, diff --git a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs index 2a7ea590d25..02ca1c58993 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_update_transition/apply_identity_update_transition.rs @@ -1,7 +1,6 @@ use anyhow::anyhow; use std::sync::Arc; -use crate::consensus::signature::{IdentityNotFoundError, SignatureError}; use crate::identity::IdentityPublicKey; use crate::{ state_repository::StateRepositoryLike, state_transition::StateTransitionLike, ProtocolError, diff --git a/packages/rs-dpp/src/state_transition/state_transition_factory.rs b/packages/rs-dpp/src/state_transition/state_transition_factory.rs index 98b1f3f76a2..2d40064c604 100644 --- a/packages/rs-dpp/src/state_transition/state_transition_factory.rs +++ b/packages/rs-dpp/src/state_transition/state_transition_factory.rs @@ -114,11 +114,11 @@ async fn fetch_data_contracts_for_document_transition( pub fn try_get_transition_type( raw_state_transition: &JsonValue, ) -> Result { - let transition_number = raw_state_transition + let transition_type = raw_state_transition .get_u64("type") .map_err(|_| missing_state_transition_error())?; - StateTransitionType::try_from(transition_number as u8) - .map_err(|_| ProtocolError::InvalidStateTransitionTypeError) + StateTransitionType::try_from(transition_type as u8) + .map_err(|_| ProtocolError::InvalidStateTransitionTypeError(InvalidStateTransitionTypeError::new(transition_type as u8))) } fn missing_state_transition_error() -> ProtocolError { diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs index 7c6fc55cfa2..459dae12df6 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs @@ -5,7 +5,7 @@ use lazy_static::lazy_static; use crate::consensus::signature::{ IdentityNotFoundError, InvalidIdentityPublicKeyTypeError, - InvalidSignaturePublicKeySecurityLevelError, MissingPublicKeyError, PublicKeyIsDisabledError, + MissingPublicKeyError, PublicKeyIsDisabledError, PublicKeySecurityLevelNotMetError, }; use crate::{ @@ -113,42 +113,28 @@ fn convert_to_consensus_signature_error( error: ProtocolError, ) -> Result { match error { - ProtocolError::InvalidSignaturePublicKeySecurityLevelError( - InvalidSignaturePublicKeySecurityLevelError::new( - public_key_security_level, - required_security_level, - ), - ) => Ok(ConsensusError::SignatureError( + ProtocolError::InvalidSignaturePublicKeySecurityLevelError(err) => Ok(ConsensusError::SignatureError( SignatureError::InvalidSignaturePublicKeySecurityLevelError( - InvalidSignaturePublicKeySecurityLevelError::new( - public_key_security_level, - required_security_level, - ), + err, ), )), ProtocolError::PublicKeySecurityLevelNotMetError( - PublicKeySecurityLevelNotMetError::new( - public_key_security_level, - required_security_level, - ), + err, ) => Ok(ConsensusError::SignatureError( SignatureError::PublicKeySecurityLevelNotMetError( - PublicKeySecurityLevelNotMetError::new( - public_key_security_level, - required_security_level, - ), + PublicKeySecurityLevelNotMetError::new(err.public_key_security_level(), err.required_security_level()), ), )), - ProtocolError::PublicKeyIsDisabledError(PublicKeyIsDisabledError::new(public_key)) => Ok( + ProtocolError::PublicKeyIsDisabledError(err) => Ok( ConsensusError::SignatureError(SignatureError::PublicKeyIsDisabledError( - PublicKeyIsDisabledError::new(public_key.get_id()), + PublicKeyIsDisabledError::new(err.public_key().id) )), ), ProtocolError::InvalidIdentityPublicKeyTypeError( - InvalidIdentityPublicKeyTypeError::new(public_key_type), + err, ) => Ok(ConsensusError::SignatureError( SignatureError::InvalidIdentityPublicKeyTypeError( - InvalidIdentityPublicKeyTypeError::new(public_key_type), + InvalidIdentityPublicKeyTypeError::new(err.public_key_type()), ), )), ProtocolError::Error(_) => Err(error), diff --git a/packages/wasm-dpp/src/data_contract/errors/invalid_document_type.rs b/packages/wasm-dpp/src/data_contract/errors/invalid_document_type.rs index d7855a06fb7..fa1cc261876 100644 --- a/packages/wasm-dpp/src/data_contract/errors/invalid_document_type.rs +++ b/packages/wasm-dpp/src/data_contract/errors/invalid_document_type.rs @@ -1,7 +1,7 @@ use thiserror::Error; use wasm_bindgen::prelude::*; -use crate::DataContractWasm; +use crate::identifier::IdentifierWrapper; #[wasm_bindgen] #[derive(Error, Debug)] @@ -9,16 +9,16 @@ use crate::DataContractWasm; pub struct InvalidDocumentTypeInDataContractError { // we have to store it as JsValue as the errors of 'class' Consensus are of different types doc_type: String, - data_contract: DataContractWasm, + data_contract_id: IdentifierWrapper, } #[wasm_bindgen] impl InvalidDocumentTypeInDataContractError { #[wasm_bindgen(constructor)] - pub fn new(doc_type: String, data_contract: DataContractWasm) -> Self { + pub fn new(doc_type: String, data_contract_id: IdentifierWrapper) -> Self { InvalidDocumentTypeInDataContractError { doc_type, - data_contract, + data_contract_id, } } #[wasm_bindgen(js_name = "getType")] @@ -27,7 +27,7 @@ impl InvalidDocumentTypeInDataContractError { } #[wasm_bindgen(js_name = "getDataContract")] - pub fn get_data_contract(&self) -> DataContractWasm { - self.data_contract.clone() + pub fn get_data_contract_id(&self) -> IdentifierWrapper { + self.data_contract_id.clone() } } diff --git a/packages/wasm-dpp/src/data_contract/errors/mod.rs b/packages/wasm-dpp/src/data_contract/errors/mod.rs index aef56e812d7..dd2e5783772 100644 --- a/packages/wasm-dpp/src/data_contract/errors/mod.rs +++ b/packages/wasm-dpp/src/data_contract/errors/mod.rs @@ -19,12 +19,9 @@ pub fn from_data_contract_to_js_error(e: DataContractError) -> JsValue { .expect("statically known structure should be a valid JSON"), ) .into(), - DataContractError::InvalidDocumentTypeError { - doc_type, - data_contract, - } => invalid_document_type::InvalidDocumentTypeInDataContractError::new( - doc_type, - data_contract.into(), + DataContractError::InvalidDocumentTypeError(err) => invalid_document_type::InvalidDocumentTypeInDataContractError::new( + err.document_type(), + err.data_contract_id().into(), ) .into(), _ => todo!(), diff --git a/packages/wasm-dpp/src/data_contract_factory/data_contract_factory.rs b/packages/wasm-dpp/src/data_contract_factory/data_contract_factory.rs index baa24a4795f..b713a7c5099 100644 --- a/packages/wasm-dpp/src/data_contract_factory/data_contract_factory.rs +++ b/packages/wasm-dpp/src/data_contract_factory/data_contract_factory.rs @@ -139,8 +139,8 @@ impl DataContractFactoryWasm { .await; match result { Ok(data_contract) => Ok(data_contract.into()), - Err(dpp::ProtocolError::InvalidDataContractError { errors, .. }) => { - Err(InvalidDataContractError::new(errors, object).into()) + Err(dpp::ProtocolError::InvalidDataContractError(err)) => { + Err(InvalidDataContractError::new(err.errors, object).into()) } Err(other) => Err(from_dpp_err(other)), } diff --git a/packages/wasm-dpp/src/errors/consensus/basic/document/missing_data_contract_id_error.rs b/packages/wasm-dpp/src/errors/consensus/basic/document/missing_data_contract_id_error.rs index 9836f455f4b..cb55f5167fe 100644 --- a/packages/wasm-dpp/src/errors/consensus/basic/document/missing_data_contract_id_error.rs +++ b/packages/wasm-dpp/src/errors/consensus/basic/document/missing_data_contract_id_error.rs @@ -1,13 +1,16 @@ +use serde::Serialize; use wasm_bindgen::prelude::*; +use dpp::document::document_transition::document_base_transition::JsonValue; #[wasm_bindgen(js_name=MissingDataContractIdError)] pub struct MissingDataContractIdErrorWasm { + raw_document_transition: JsonValue, code: u32, } impl MissingDataContractIdErrorWasm { - pub fn new(code: u32) -> Self { - MissingDataContractIdErrorWasm { code } + pub fn new(raw_document_transition: JsonValue, code: u32) -> Self { + MissingDataContractIdErrorWasm { raw_document_transition, code } } } @@ -17,4 +20,10 @@ impl MissingDataContractIdErrorWasm { pub fn get_code(&self) -> u32 { self.code } + + #[wasm_bindgen(js_name=rawDocumentTransition)] + pub fn raw_document_transition(&self) -> wasm_bindgen::JsValue { + let serializer = serde_wasm_bindgen::Serializer::json_compatible(); + self.raw_document_transition.serialize(&serializer).expect("implements Serialize") + } } diff --git a/packages/wasm-dpp/src/errors/consensus_error.rs b/packages/wasm-dpp/src/errors/consensus_error.rs index 0365ce06671..2742217d0ef 100644 --- a/packages/wasm-dpp/src/errors/consensus_error.rs +++ b/packages/wasm-dpp/src/errors/consensus_error.rs @@ -171,21 +171,17 @@ pub fn from_consensus_error_ref(e: &DPPConsensusError) -> JsValue { ) .into() } - DPPConsensusError::ProtocolVersionParsingError { parsing_error } => { + DPPConsensusError::ProtocolVersionParsingError(err) => { ProtocolVersionParsingErrorWasm::new( - wasm_bindgen::JsError::new(parsing_error.to_string().as_ref()), + wasm_bindgen::JsError::new(err.parsing_error.to_string().as_ref()), code, ) .into() } - DPPConsensusError::IncompatibleRe2PatternError { - pattern, - path, - message, - } => IncompatibleRe2PatternErrorWasm::new( - pattern.clone(), - path.clone(), - message.clone(), + DPPConsensusError::IncompatibleRe2PatternError(err) => IncompatibleRe2PatternErrorWasm::new( + err.pattern(), + err.path(), + err.message(), code, ) .into(), @@ -344,116 +340,96 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue { BasicError::DataContractNotPresent { data_contract_id } => { DataContractNotPresentErrorWasm::new(*data_contract_id, code).into() } - BasicError::InvalidDataContractVersionError { - expected_version, - version, - } => InvalidDataContractVersionErrorWasm::new(*expected_version, *version, code).into(), + BasicError::InvalidDataContractVersionError(err) => { + InvalidDataContractVersionErrorWasm::new(err.expected_version(), err.version(), code) + .into() + } BasicError::DataContractMaxDepthExceedError(depth) => { DataContractMaxDepthExceedErrorWasm::new(*depth, code).into() } - BasicError::InvalidDocumentTypeError { - document_type, - data_contract_id, - } => { - InvalidDocumentTypeErrorWasm::new(document_type.clone(), *data_contract_id, code).into() - } - BasicError::DuplicateIndexNameError { - document_type, - duplicate_index_name, - } => DuplicateIndexNameErrorWasm::new( - document_type.clone(), - duplicate_index_name.clone(), - code, - ) - .into(), - BasicError::InvalidJsonSchemaRefError { ref_error } => { - InvalidJsonSchemaRefErrorWasm::new(ref_error.clone(), code).into() + BasicError::InvalidDocumentTypeError(err) => { + InvalidDocumentTypeErrorWasm::new(err.document_type(), err.data_contract_id(), code) + .into() + } + BasicError::DuplicateIndexNameError(err) => { + DuplicateIndexNameErrorWasm::new(err.document_type(), err.duplicate_index_name(), code) + .into() + } + BasicError::InvalidJsonSchemaRefError(err) => { + InvalidJsonSchemaRefErrorWasm::new(err.ref_error(), code).into() } BasicError::IndexError(index_error) => match index_error { - dpp::consensus::basic::IndexError::UniqueIndicesLimitReachedError { - document_type, - index_limit, - } => UniqueIndicesLimitReachedErrorWasm::new(document_type.clone(), *index_limit, code) - .into(), - dpp::consensus::basic::IndexError::SystemPropertyIndexAlreadyPresentError { - document_type, - index_definition, - property_name, - } => SystemPropertyIndexAlreadyPresentErrorWasm::new( - document_type.clone(), - index_definition.clone(), - property_name.clone(), - code, - ) - .into(), - dpp::consensus::basic::IndexError::UndefinedIndexPropertyError { - document_type, - index_definition, - property_name, - } => UndefinedIndexPropertyErrorWasm::new( - document_type.clone(), - index_definition.clone(), - property_name.clone(), - code, - ) - .into(), - dpp::consensus::basic::IndexError::InvalidIndexPropertyTypeError { - document_type, - index_definition, - property_name, - property_type, - } => InvalidIndexPropertyTypeErrorWasm::new( - document_type.clone(), - index_definition.clone(), - property_name.clone(), - property_type.clone(), - code, - ) - .into(), - dpp::consensus::basic::IndexError::InvalidIndexedPropertyConstraintError { - document_type, - index_definition, - property_name, - constraint_name, - reason, - } => InvalidIndexedPropertyConstraintErrorWasm::new( - document_type.clone(), - index_definition.clone(), - property_name.clone(), - constraint_name.clone(), - reason.clone(), - code, - ) - .into(), - dpp::consensus::basic::IndexError::InvalidCompoundIndexError { - document_type, - index_definition, - } => InvalidCompoundIndexErrorWasm::new( - document_type.clone(), - index_definition.clone(), - code, - ) - .into(), - dpp::consensus::basic::IndexError::DuplicateIndexError { - document_type, - index_definition, - } => { - DuplicateIndexErrorWasm::new(document_type.clone(), index_definition.clone(), code) + dpp::consensus::basic::IndexError::UniqueIndicesLimitReachedError(err) => { + UniqueIndicesLimitReachedErrorWasm::new( + err.document_type(), + err.index_limit(), + code, + ) + .into() + } + dpp::consensus::basic::IndexError::SystemPropertyIndexAlreadyPresentError(err) => { + SystemPropertyIndexAlreadyPresentErrorWasm::new( + err.document_type(), + err.index_definition(), + err.property_name(), + code, + ) + .into() + } + dpp::consensus::basic::IndexError::UndefinedIndexPropertyError(err) => { + UndefinedIndexPropertyErrorWasm::new( + err.document_type(), + err.index_definition(), + err.property_name(), + code, + ) + .into() + } + dpp::consensus::basic::IndexError::InvalidIndexPropertyTypeError(err) => { + InvalidIndexPropertyTypeErrorWasm::new( + err.document_type(), + err.index_definition(), + err.property_name(), + err.property_type(), + code, + ) + .into() + } + dpp::consensus::basic::IndexError::InvalidIndexedPropertyConstraintError(err) => { + InvalidIndexedPropertyConstraintErrorWasm::new( + err.document_type(), + err.index_definition(), + err.property_name(), + err.constraint_name(), + err.reason(), + code, + ) + .into() + } + dpp::consensus::basic::IndexError::InvalidCompoundIndexError(err) => { + InvalidCompoundIndexErrorWasm::new( + err.document_type(), + err.index_definition(), + code, + ) + .into() + } + dpp::consensus::basic::IndexError::DuplicateIndexError(err) => { + DuplicateIndexErrorWasm::new(err.document_type(), err.index_definition(), code) .into() } }, BasicError::JsonSchemaCompilationError(error) => { JsonSchemaCompilationErrorWasm::new(error.clone(), code).into() } - BasicError::InconsistentCompoundIndexDataError { - index_properties, - document_type, - } => InconsistentCompoundIndexDataErrorWasm::new( - index_properties.clone(), - document_type.clone(), - code, - ) - .into(), + BasicError::InconsistentCompoundIndexDataError(err) => { + InconsistentCompoundIndexDataErrorWasm::new( + err.index_properties(), + err.document_type(), + code, + ) + .into() + } BasicError::MissingDocumentTransitionTypeError => { MissingDocumentTransitionTypeErrorWasm::new(code).into() } @@ -462,101 +438,86 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue { MissingDocumentTransitionActionErrorWasm::new(code).into() } - BasicError::InvalidDocumentTransitionActionError { action } => { - InvalidDocumentTransitionActionErrorWasm::new(action.clone(), code).into() - } - BasicError::InvalidDocumentTransitionIdError { - expected_id, - invalid_id, - } => InvalidDocumentTransitionIdErrorWasm::new(*expected_id, *invalid_id, code).into(), - BasicError::DuplicateDocumentTransitionsWithIndicesError { references } => { - DuplicateDocumentTransitionsWithIndicesErrorWasm::new(references.clone(), code).into() - } - BasicError::DuplicateDocumentTransitionsWithIdsError { references } => { - DuplicateDocumentTransitionsWithIdsErrorWasm::new(references.clone(), code).into() - } - BasicError::MissingDataContractIdError => MissingDataContractIdErrorWasm::new(code).into(), - BasicError::InvalidIdentifierError { - identifier_name, - error, - } => InvalidIdentifierErrorWasm::new(identifier_name.clone(), error.clone(), code).into(), - BasicError::DataContractUniqueIndicesChangedError { - document_type, - index_name, - } => DataContractUniqueIndicesChangedErrorWasm::new( - document_type.clone(), - index_name.clone(), - code, - ) - .into(), - BasicError::DataContractInvalidIndexDefinitionUpdateError { - document_type, - index_name, - } => DataContractInvalidIndexDefinitionUpdateErrorWasm::new( - document_type.clone(), - index_name.clone(), - code, - ) - .into(), - BasicError::DataContractHaveNewUniqueIndexError { - document_type, - index_name, - } => DataContractHaveNewUniqueIndexErrorWasm::new( - document_type.clone(), - index_name.clone(), - code, - ) - .into(), - BasicError::IdentityNotFoundError { identity_id } => { - IdentityNotFoundErrorWasm::new(*identity_id, code).into() + BasicError::InvalidDocumentTransitionActionError(err) => { + InvalidDocumentTransitionActionErrorWasm::new(err.action(), code).into() + } + BasicError::InvalidDocumentTransitionIdError(err) => { + InvalidDocumentTransitionIdErrorWasm::new(err.expected_id(), err.invalid_id(), code) + .into() + } + BasicError::DuplicateDocumentTransitionsWithIndicesError(err) => { + DuplicateDocumentTransitionsWithIndicesErrorWasm::new(err.references(), code).into() + } + BasicError::DuplicateDocumentTransitionsWithIdsError(err) => { + DuplicateDocumentTransitionsWithIdsErrorWasm::new(err.references(), code).into() + } + BasicError::MissingDataContractIdError(err) => MissingDataContractIdErrorWasm::new(err.raw_document_transition(), code).into(), + BasicError::InvalidIdentifierError(err) => { + InvalidIdentifierErrorWasm::new(err.identifier_name(), err.error(), code).into() + } + BasicError::DataContractUniqueIndicesChangedError(err) => { + DataContractUniqueIndicesChangedErrorWasm::new( + err.document_type(), + err.index_name(), + code, + ) + .into() + } + BasicError::DataContractInvalidIndexDefinitionUpdateError(err) => { + DataContractInvalidIndexDefinitionUpdateErrorWasm::new( + err.document_type(), + err.index_name(), + code, + ) + .into() + } + BasicError::DataContractHaveNewUniqueIndexError(err) => { + DataContractHaveNewUniqueIndexErrorWasm::new( + err.document_type(), + err.index_name(), + code, + ) + .into() } BasicError::MissingStateTransitionTypeError => { MissingStateTransitionTypeErrorWasm::new(code).into() } - BasicError::InvalidStateTransitionTypeError { transition_type } => { - InvalidStateTransitionTypeErrorWasm::new(*transition_type, code).into() + BasicError::InvalidStateTransitionTypeError(err) => { + InvalidStateTransitionTypeErrorWasm::new(err.transition_type(), code).into() } - BasicError::StateTransitionMaxSizeExceededError { - actual_size_kbytes, - max_size_kbytes, - } => StateTransitionMaxSizeExceededErrorWasm::new( - *actual_size_kbytes, - *max_size_kbytes, - code, - ) - .into(), - BasicError::DataContractImmutablePropertiesUpdateError { - operation, - field_path, - } => DataContractImmutablePropertiesUpdateErrorWasm::new( - operation.clone(), - field_path.clone(), - code, - ) - .into(), - BasicError::IncompatibleDataContractSchemaError { - data_contract_id, - operation, - field_path, - old_schema, - new_schema, - } => IncompatibleDataContractSchemaErrorWasm::new( - *data_contract_id, - operation.clone(), - field_path.clone(), - old_schema.clone(), - new_schema.clone(), - code, - ) - .into(), - BasicError::InvalidIdentityKeySignatureError { public_key_id } => { - InvalidIdentityKeySignatureErrorWasm::new(*public_key_id, code).into() + BasicError::StateTransitionMaxSizeExceededError(err) => { + StateTransitionMaxSizeExceededErrorWasm::new( + err.actual_size_kbytes(), + err.max_size_kbytes(), + code, + ) + .into() + } + BasicError::DataContractImmutablePropertiesUpdateError(err) => { + DataContractImmutablePropertiesUpdateErrorWasm::new( + err.operation(), + err.field_path(), + code, + ) + .into() + } + BasicError::IncompatibleDataContractSchemaError(err) => { + IncompatibleDataContractSchemaErrorWasm::new( + err.data_contract_id(), + err.operation(), + err.field_path(), + err.old_schema(), + err.new_schema(), + code, + ) + .into() + } + BasicError::InvalidIdentityKeySignatureError(err) => { + InvalidIdentityKeySignatureErrorWasm::new(err.public_key_id(), code).into() + } + BasicError::InvalidDataContractIdError(err) => { + InvalidDataContractIdErrorWasm::new(err.expected_id(), err.invalid_id(), code).into() } - BasicError::InvalidDataContractIdError { - expected_id, - invalid_id, - } => InvalidDataContractIdErrorWasm::new(expected_id.clone(), invalid_id.clone(), code) - .into(), } } @@ -564,44 +525,35 @@ fn from_signature_error(signature_error: &SignatureError) -> JsValue { let code = signature_error.get_code(); match signature_error.deref() { - SignatureError::MissingPublicKeyError { public_key_id } => { - MissingPublicKeyErrorWasm::new(*public_key_id, code).into() + SignatureError::MissingPublicKeyError(err) => { + MissingPublicKeyErrorWasm::new(err.public_key_id(), code).into() } - SignatureError::InvalidIdentityPublicKeyTypeError { public_key_type } => { - InvalidIdentityPublicKeyTypeErrorWasm::new(*public_key_type, code).into() + SignatureError::InvalidIdentityPublicKeyTypeError(err) => { + InvalidIdentityPublicKeyTypeErrorWasm::new(err.public_key_type(), code).into() } SignatureError::InvalidStateTransitionSignatureError => { InvalidStateTransitionSignatureErrorWasm::new(code).into() } - SignatureError::IdentityNotFoundError { identity_id } => { - IdentityNotFoundErrorWasm::new(*identity_id, code).into() + SignatureError::IdentityNotFoundError(err) => { + IdentityNotFoundErrorWasm::new(err.identity_id(), code).into() } - SignatureError::InvalidSignaturePublicKeySecurityLevelError { - public_key_security_level, - required_key_security_level, - } => InvalidSignaturePublicKeySecurityLevelErrorWasm::new( - *public_key_security_level, - *required_key_security_level, + SignatureError::InvalidSignaturePublicKeySecurityLevelError(err) => InvalidSignaturePublicKeySecurityLevelErrorWasm::new( + err.public_key_security_level(), + err.required_key_security_level(), code, ) .into(), - SignatureError::PublicKeyIsDisabledError { public_key_id } => { - PublicKeyIsDisabledErrorWasm::new(*public_key_id, code).into() - } - SignatureError::PublicKeySecurityLevelNotMetError { - public_key_security_level, - required_security_level, - } => PublicKeySecurityLevelNotMetErrorWasm::new( - *public_key_security_level, - *required_security_level, + SignatureError::PublicKeyIsDisabledError(err) => { + PublicKeyIsDisabledErrorWasm::new(err.public_key_id(), code).into() + } + SignatureError::PublicKeySecurityLevelNotMetError(err) => PublicKeySecurityLevelNotMetErrorWasm::new( + err.public_key_security_level(), + err.required_security_level(), code, ) .into(), - SignatureError::WrongPublicKeyPurposeError { - public_key_purpose, - key_purpose_requirement, - } => { - WrongPublicKeyPurposeErrorWasm::new(*public_key_purpose, *key_purpose_requirement, code) + SignatureError::WrongPublicKeyPurposeError(err) => { + WrongPublicKeyPurposeErrorWasm::new(err.public_key_purpose(), err.key_purpose_requirement(), code) .into() } } diff --git a/packages/wasm-dpp/src/errors/protocol_error.rs b/packages/wasm-dpp/src/errors/protocol_error.rs index 9417799df1c..6a0b72d3ad8 100644 --- a/packages/wasm-dpp/src/errors/protocol_error.rs +++ b/packages/wasm-dpp/src/errors/protocol_error.rs @@ -8,13 +8,11 @@ pub fn from_protocol_error(protocol_error: dpp::ProtocolError) -> JsValue { dpp::ProtocolError::AbstractConsensusError(consensus_error) => { from_consensus_error(*consensus_error) } - dpp::ProtocolError::InvalidDataContractError { - errors, - raw_data_contract, - } => { + dpp::ProtocolError::InvalidDataContractError(err) => { + let raw_data_contract = err.raw_data_contract(); let protocol = serde_wasm_bindgen::to_value(&raw_data_contract); protocol.map_or_else(JsValue::from, |raw_contract| { - InvalidDataContractError::new(errors, raw_contract).into() + InvalidDataContractError::new(err.errors, raw_contract).into() }) } dpp::ProtocolError::Error(anyhow_error) => { diff --git a/packages/wasm-dpp/src/identifier/mod.rs b/packages/wasm-dpp/src/identifier/mod.rs index 8b1c960f3c7..b0c07cea541 100644 --- a/packages/wasm-dpp/src/identifier/mod.rs +++ b/packages/wasm-dpp/src/identifier/mod.rs @@ -27,7 +27,7 @@ extern "C" { fn log(a: &str); } -#[derive(Clone)] +#[derive(Clone, Debug)] #[wasm_bindgen(js_name=Identifier, inspectable)] pub struct IdentifierWrapper { wrapped: identifier::Identifier, From 6b424891eb9003c120ddff5fa8eb938939834fd7 Mon Sep 17 00:00:00 2001 From: Anton Suprunchuk Date: Sat, 25 Feb 2023 17:04:32 +0700 Subject: [PATCH 06/11] resolve merge conflicts --- .../validate_data_contract_create_transition_basic.rs | 3 ++- .../validate_state_transition_key_signature.rs | 9 ++++++--- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs b/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs index 0daf3462d3e..e95c1efafa4 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs @@ -22,6 +22,7 @@ use crate::{ version::ProtocolVersionValidator, ProtocolError, }; +use crate::consensus::basic::decode::ProtocolVersionParsingError; lazy_static! { static ref DATA_CONTRACT_CREATE_SCHEMA: Value = serde_json::from_str(include_str!( @@ -88,7 +89,7 @@ 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)), ]))) } }; diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_key_signature.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_key_signature.rs index 80d87c61ab9..1b1d424cbd7 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_key_signature.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_key_signature.rs @@ -5,6 +5,7 @@ use async_trait::async_trait; use dashcore::signer::verify_hash_signature; use crate::consensus::signature::IdentityNotFoundError; +use crate::consensus::ConsensusError; use crate::{ consensus::signature::SignatureError, identity::{ @@ -83,9 +84,11 @@ pub async fn validate_state_transition_key_signature( execution_context.add_operations(tmp_execution_context.get_operations()); if balance.is_none() { - result.add_error(SignatureError::IdentityNotFoundError { - identity_id: *target_identity_id, - }); + result.add_error(ConsensusError::SignatureError( + SignatureError::IdentityNotFoundError(IdentityNotFoundError::new( + *target_identity_id, + )), + )); return Ok(result); } } From d585512c3e35665fcf8f8efd82a74c653ee4ae82 Mon Sep 17 00:00:00 2001 From: Anton Suprunchuk Date: Sat, 25 Feb 2023 18:03:42 +0700 Subject: [PATCH 07/11] reformat --- ...e_data_contract_create_transition_basic.rs | 6 ++- .../fetch_and_validate_data_contract.rs | 6 ++- ...lidate_documents_batch_transition_basic.rs | 6 ++- ...tract_immutable_properties_update_error.rs | 6 ++- ...t_invalid_index_definition_update_error.rs | 6 ++- ...a_contract_unique_indices_changed_error.rs | 6 ++- .../data_contract/duplicate_index_error.rs | 6 ++- .../duplicate_index_name_error.rs | 2 +- ...incompatible_data_contract_schema_error.rs | 6 ++- .../invalid_compound_index_error.rs | 6 ++- .../invalid_index_property_type_error.rs | 6 ++- ...valid_indexed_property_constraint_error.rs | 6 ++- .../invalid_json_schema_ref_error.rs | 2 +- packages/rs-dpp/src/errors/errors.rs | 4 +- ...tity_credit_withdrawal_transition_state.rs | 10 ++-- .../state_transition_factory.rs | 13 +++-- .../validate_state_transition_fee.rs | 10 ++-- ...ate_state_transition_identity_signature.rs | 46 +++++++++--------- .../wasm-dpp/src/data_contract/errors/mod.rs | 12 +++-- .../missing_data_contract_id_error.rs | 11 +++-- .../wasm-dpp/src/errors/consensus_error.rs | 47 ++++++++++--------- 21 files changed, 131 insertions(+), 92 deletions(-) diff --git a/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs b/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs index e95c1efafa4..31d9800df75 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs @@ -6,6 +6,7 @@ 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}, @@ -22,7 +23,6 @@ use crate::{ version::ProtocolVersionValidator, ProtocolError, }; -use crate::consensus::basic::decode::ProtocolVersionParsingError; lazy_static! { static ref DATA_CONTRACT_CREATE_SCHEMA: Value = serde_json::from_str(include_str!( @@ -89,7 +89,9 @@ fn validate_data_contract_create_transition_basic( Ok(v) => v, Err(parsing_error) => { return Ok(SimpleValidationResult::new(Some(vec![ - ConsensusError::ProtocolVersionParsingError(ProtocolVersionParsingError::new(parsing_error)), + ConsensusError::ProtocolVersionParsingError(ProtocolVersionParsingError::new( + parsing_error, + )), ]))) } }; diff --git a/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs b/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs index bf1f4238f89..3dfe464eefb 100644 --- a/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs +++ b/packages/rs-dpp/src/document/fetch_and_validate_data_contract.rs @@ -3,6 +3,7 @@ use std::{convert::TryInto, sync::Arc}; use serde_json::Value; use crate::consensus::basic::invalid_identifier_error::InvalidIdentifierError; +use crate::data_contract::state_transition::errors::MissingDataContractIdError; use crate::{ consensus::{basic::BasicError, ConsensusError}, data_contract::DataContract, @@ -13,7 +14,6 @@ use crate::{ validation::ValidationResult, ProtocolError, }; -use crate::data_contract::state_transition::errors::MissingDataContractIdError; use super::property_names; @@ -51,7 +51,9 @@ pub async fn fetch_and_validate_data_contract( id_bytes } else { validation_result.add_error(ConsensusError::BasicError(Box::new( - BasicError::MissingDataContractIdError(MissingDataContractIdError::new(raw_document.clone())), + BasicError::MissingDataContractIdError(MissingDataContractIdError::new( + raw_document.clone(), + )), ))); return Ok(validation_result); }; diff --git a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs index 038fccd3963..dc9a9946428 100644 --- a/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs +++ b/packages/rs-dpp/src/document/state_transition/documents_batch_transition/validation/basic/validate_documents_batch_transition_basic.rs @@ -9,6 +9,7 @@ use crate::consensus::basic::document::{ InvalidDocumentTypeError, }; use crate::consensus::basic::invalid_identifier_error::InvalidIdentifierError; +use crate::data_contract::state_transition::errors::MissingDataContractIdError; use crate::document::validation::basic::find_duplicates_by_id::find_duplicates_by_id; use crate::{ consensus::basic::BasicError, @@ -30,7 +31,6 @@ use crate::{ use anyhow::anyhow; use lazy_static::lazy_static; use serde_json::Value as JsonValue; -use crate::data_contract::state_transition::errors::MissingDataContractIdError; use super::{ find_duplicates_by_indices::find_duplicates_by_indices, @@ -99,7 +99,9 @@ pub async fn validate_documents_batch_transition_basic( for raw_document_transition in raw_document_transitions { let data_contract_id_bytes = match raw_document_transition.get_bytes("$dataContractId") { Err(_) => { - result.add_error(BasicError::MissingDataContractIdError(MissingDataContractIdError::new(raw_document_transition.clone()))); + result.add_error(BasicError::MissingDataContractIdError( + MissingDataContractIdError::new(raw_document_transition.clone()), + )); continue; } Ok(id) => id, diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs index b2fd60b5790..6a8d6b1ba56 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs @@ -1,5 +1,5 @@ -use thiserror::Error; use crate::consensus::basic::BasicError; +use thiserror::Error; use crate::consensus::ConsensusError; @@ -29,6 +29,8 @@ impl DataContractImmutablePropertiesUpdateError { impl From for ConsensusError { fn from(err: DataContractImmutablePropertiesUpdateError) -> Self { - Self::BasicError(Box::new(BasicError::DataContractImmutablePropertiesUpdateError(err))) + Self::BasicError(Box::new( + BasicError::DataContractImmutablePropertiesUpdateError(err), + )) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs index 45e5bb593c9..ba572bb89b4 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs @@ -1,5 +1,5 @@ -use thiserror::Error; use crate::consensus::basic::BasicError; +use thiserror::Error; use crate::consensus::ConsensusError; @@ -29,6 +29,8 @@ impl DataContractInvalidIndexDefinitionUpdateError { impl From for ConsensusError { fn from(err: DataContractInvalidIndexDefinitionUpdateError) -> Self { - Self::BasicError(Box::new(BasicError::DataContractInvalidIndexDefinitionUpdateError(err))) + Self::BasicError(Box::new( + BasicError::DataContractInvalidIndexDefinitionUpdateError(err), + )) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs index 5343fecf2ad..ae4bea0a8bf 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs @@ -1,5 +1,5 @@ -use thiserror::Error; use crate::consensus::basic::BasicError; +use thiserror::Error; use crate::consensus::ConsensusError; @@ -29,6 +29,8 @@ impl DataContractUniqueIndicesChangedError { impl From for ConsensusError { fn from(err: DataContractUniqueIndicesChangedError) -> Self { - Self::BasicError(Box::new(BasicError::DataContractUniqueIndicesChangedError(err))) + Self::BasicError(Box::new(BasicError::DataContractUniqueIndicesChangedError( + err, + ))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs index cb5466aa4c8..0ddca58f5e7 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs @@ -1,5 +1,5 @@ -use thiserror::Error; use crate::consensus::basic::{BasicError, IndexError}; +use thiserror::Error; use crate::consensus::ConsensusError; use crate::data_contract::document_type::Index; @@ -30,6 +30,8 @@ impl DuplicateIndexError { impl From for ConsensusError { fn from(err: DuplicateIndexError) -> Self { - Self::BasicError(Box::new(BasicError::IndexError(IndexError::DuplicateIndexError(err)))) + Self::BasicError(Box::new(BasicError::IndexError( + IndexError::DuplicateIndexError(err), + ))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs index dea3e2f1fed..851a5e3f340 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs @@ -1,5 +1,5 @@ +use crate::consensus::basic::BasicError; use thiserror::Error; -use crate::consensus::basic::{BasicError}; use crate::consensus::ConsensusError; diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs index 282aa5cbe85..41a12ba18ae 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs @@ -1,5 +1,5 @@ -use thiserror::Error; use crate::consensus::basic::BasicError; +use thiserror::Error; use crate::consensus::ConsensusError; use crate::document::document_transition::document_base_transition::JsonValue; @@ -52,6 +52,8 @@ impl IncompatibleDataContractSchemaError { impl From for ConsensusError { fn from(err: IncompatibleDataContractSchemaError) -> Self { - Self::BasicError(Box::new(BasicError::IncompatibleDataContractSchemaError(err))) + Self::BasicError(Box::new(BasicError::IncompatibleDataContractSchemaError( + err, + ))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs index fe94ca77dee..0767c86661c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs @@ -1,5 +1,5 @@ -use thiserror::Error; use crate::consensus::basic::{BasicError, IndexError}; +use thiserror::Error; use crate::consensus::ConsensusError; use crate::data_contract::document_type::Index; @@ -29,6 +29,8 @@ impl InvalidCompoundIndexError { impl From for ConsensusError { fn from(err: InvalidCompoundIndexError) -> Self { - Self::BasicError(Box::new(BasicError::IndexError(IndexError::InvalidCompoundIndexError(err)))) + Self::BasicError(Box::new(BasicError::IndexError( + IndexError::InvalidCompoundIndexError(err), + ))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs index ace21f7d235..c9d07f41c7f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs @@ -1,5 +1,5 @@ -use thiserror::Error; use crate::consensus::basic::{BasicError, IndexError}; +use thiserror::Error; use crate::consensus::ConsensusError; use crate::data_contract::document_type::Index; @@ -44,6 +44,8 @@ impl InvalidIndexPropertyTypeError { impl From for ConsensusError { fn from(err: InvalidIndexPropertyTypeError) -> Self { - Self::BasicError(Box::new(BasicError::IndexError(IndexError::InvalidIndexPropertyTypeError(err)))) + Self::BasicError(Box::new(BasicError::IndexError( + IndexError::InvalidIndexPropertyTypeError(err), + ))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs index e8de479a827..4ca69727d52 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs @@ -1,5 +1,5 @@ -use thiserror::Error; use crate::consensus::basic::{BasicError, IndexError}; +use thiserror::Error; use crate::consensus::ConsensusError; use crate::data_contract::document_type::Index; @@ -50,6 +50,8 @@ impl InvalidIndexedPropertyConstraintError { impl From for ConsensusError { fn from(err: InvalidIndexedPropertyConstraintError) -> Self { - Self::BasicError(Box::new(BasicError::IndexError(IndexError::InvalidIndexedPropertyConstraintError(err)))) + Self::BasicError(Box::new(BasicError::IndexError( + IndexError::InvalidIndexedPropertyConstraintError(err), + ))) } } diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs index 678e5a3f761..8120f7a425c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs @@ -1,5 +1,5 @@ -use thiserror::Error; use crate::consensus::basic::BasicError; +use thiserror::Error; use crate::consensus::ConsensusError; diff --git a/packages/rs-dpp/src/errors/errors.rs b/packages/rs-dpp/src/errors/errors.rs index fc43e3a8687..f7316a58b18 100644 --- a/packages/rs-dpp/src/errors/errors.rs +++ b/packages/rs-dpp/src/errors/errors.rs @@ -1,10 +1,11 @@ use serde_json::Value as JsonValue; use thiserror::Error; +use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; use crate::consensus::signature::InvalidSignaturePublicKeySecurityLevelError; use crate::consensus::ConsensusError; use crate::data_contract::errors::*; -use crate::data_contract::state_transition::errors::{MissingDataContractIdError}; +use crate::data_contract::state_transition::errors::MissingDataContractIdError; use crate::data_contract::state_transition::errors::PublicKeyIsDisabledError; use crate::document::errors::*; use crate::state_transition::errors::{ @@ -12,7 +13,6 @@ use crate::state_transition::errors::{ PublicKeySecurityLevelNotMetError, StateTransitionIsNotSignedError, WrongPublicKeyPurposeError, }; use crate::{CompatibleProtocolVersionIsNotDefinedError, NonConsensusError, SerdeParsingError}; -use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; use platform_value::Error as ValueError; #[derive(Error, Debug)] diff --git a/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs b/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs index 7f2d59aa73d..0dfa0ca7f41 100644 --- a/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs +++ b/packages/rs-dpp/src/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_transition_state.rs @@ -3,14 +3,12 @@ use std::sync::Arc; use anyhow::Result; -use crate::consensus::signature::{IdentityNotFoundError}; +use crate::consensus::signature::IdentityNotFoundError; use crate::{ - consensus::basic::{identity::IdentityInsufficientBalanceError}, + consensus::basic::identity::IdentityInsufficientBalanceError, identity::state_transition::identity_credit_withdrawal_transition::IdentityCreditWithdrawalTransition, - state_repository::StateRepositoryLike, - state_transition::StateTransitionLike, - validation::ValidationResult, - NonConsensusError, StateError, + state_repository::StateRepositoryLike, state_transition::StateTransitionLike, + validation::ValidationResult, NonConsensusError, StateError, }; pub struct IdentityCreditWithdrawalTransitionValidator diff --git a/packages/rs-dpp/src/state_transition/state_transition_factory.rs b/packages/rs-dpp/src/state_transition/state_transition_factory.rs index 2d40064c604..8dbb8985da9 100644 --- a/packages/rs-dpp/src/state_transition/state_transition_factory.rs +++ b/packages/rs-dpp/src/state_transition/state_transition_factory.rs @@ -1,6 +1,7 @@ use anyhow::anyhow; use std::convert::{TryFrom, TryInto}; +use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; use crate::data_contract::errors::DataContractNotPresentError; use crate::data_contract::state_transition::errors::MissingDataContractIdError; use crate::{ @@ -21,7 +22,6 @@ use crate::{ ProtocolError, }; use serde_json::Value as JsonValue; -use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; use super::{ state_transition_execution_context::StateTransitionExecutionContext, StateTransition, @@ -75,7 +75,9 @@ pub async fn create_state_transition( Ok(StateTransition::DocumentsBatch(documents_batch_transition)) } // TODO!! add basic validation - StateTransitionType::IdentityUpdate => Err(ProtocolError::InvalidStateTransitionTypeError(InvalidStateTransitionTypeError::new(transition_type as u8))), + StateTransitionType::IdentityUpdate => Err(ProtocolError::InvalidStateTransitionTypeError( + InvalidStateTransitionTypeError::new(transition_type as u8), + )), } } @@ -117,8 +119,11 @@ pub fn try_get_transition_type( let transition_type = raw_state_transition .get_u64("type") .map_err(|_| missing_state_transition_error())?; - StateTransitionType::try_from(transition_type as u8) - .map_err(|_| ProtocolError::InvalidStateTransitionTypeError(InvalidStateTransitionTypeError::new(transition_type as u8))) + StateTransitionType::try_from(transition_type as u8).map_err(|_| { + ProtocolError::InvalidStateTransitionTypeError(InvalidStateTransitionTypeError::new( + transition_type as u8, + )) + }) } fn missing_state_transition_error() -> ProtocolError { diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs index b7865d4f136..92f5c3b8af2 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs @@ -1,7 +1,9 @@ use anyhow::Context; use std::convert::TryInto; +use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; use crate::data_contract::errors::IdentityNotPresentError; +use crate::state_transition::StateTransitionType; use crate::{ consensus::fee::FeeError, identity::{ @@ -14,8 +16,6 @@ use crate::{ ProtocolError, }; use std::sync::Arc; -use crate::consensus::basic::state_transition::InvalidStateTransitionTypeError; -use crate::state_transition::StateTransitionType; pub struct StateTransitionFeeValidator { state_repository: Arc, @@ -117,7 +117,11 @@ where balance } StateTransition::IdentityCreditWithdrawal(_) => { - return Err(ProtocolError::InvalidStateTransitionTypeError(InvalidStateTransitionTypeError::new(StateTransitionType::IdentityCreditWithdrawal as u8))); + return Err(ProtocolError::InvalidStateTransitionTypeError( + InvalidStateTransitionTypeError::new( + StateTransitionType::IdentityCreditWithdrawal as u8, + ), + )); } }; diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs index 459dae12df6..6862cdf3348 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs @@ -4,9 +4,8 @@ use anyhow::Context; use lazy_static::lazy_static; use crate::consensus::signature::{ - IdentityNotFoundError, InvalidIdentityPublicKeyTypeError, - MissingPublicKeyError, PublicKeyIsDisabledError, - PublicKeySecurityLevelNotMetError, + IdentityNotFoundError, InvalidIdentityPublicKeyTypeError, MissingPublicKeyError, + PublicKeyIsDisabledError, PublicKeySecurityLevelNotMetError, }; use crate::{ consensus::{signature::SignatureError, ConsensusError}, @@ -113,30 +112,29 @@ fn convert_to_consensus_signature_error( error: ProtocolError, ) -> Result { match error { - ProtocolError::InvalidSignaturePublicKeySecurityLevelError(err) => Ok(ConsensusError::SignatureError( - SignatureError::InvalidSignaturePublicKeySecurityLevelError( - err, - ), - )), - ProtocolError::PublicKeySecurityLevelNotMetError( - err, - ) => Ok(ConsensusError::SignatureError( - SignatureError::PublicKeySecurityLevelNotMetError( - PublicKeySecurityLevelNotMetError::new(err.public_key_security_level(), err.required_security_level()), - ), - )), - ProtocolError::PublicKeyIsDisabledError(err) => Ok( - ConsensusError::SignatureError(SignatureError::PublicKeyIsDisabledError( - PublicKeyIsDisabledError::new(err.public_key().id) + ProtocolError::InvalidSignaturePublicKeySecurityLevelError(err) => { + Ok(ConsensusError::SignatureError( + SignatureError::InvalidSignaturePublicKeySecurityLevelError(err), + )) + } + ProtocolError::PublicKeySecurityLevelNotMetError(err) => Ok( + ConsensusError::SignatureError(SignatureError::PublicKeySecurityLevelNotMetError( + PublicKeySecurityLevelNotMetError::new( + err.public_key_security_level(), + err.required_security_level(), + ), )), ), - ProtocolError::InvalidIdentityPublicKeyTypeError( - err, - ) => Ok(ConsensusError::SignatureError( - SignatureError::InvalidIdentityPublicKeyTypeError( - InvalidIdentityPublicKeyTypeError::new(err.public_key_type()), - ), + ProtocolError::PublicKeyIsDisabledError(err) => Ok(ConsensusError::SignatureError( + SignatureError::PublicKeyIsDisabledError(PublicKeyIsDisabledError::new( + err.public_key().id, + )), )), + ProtocolError::InvalidIdentityPublicKeyTypeError(err) => Ok( + ConsensusError::SignatureError(SignatureError::InvalidIdentityPublicKeyTypeError( + InvalidIdentityPublicKeyTypeError::new(err.public_key_type()), + )), + ), ProtocolError::Error(_) => Err(error), _ => Ok(ConsensusError::SignatureError( SignatureError::InvalidStateTransitionSignatureError, diff --git a/packages/wasm-dpp/src/data_contract/errors/mod.rs b/packages/wasm-dpp/src/data_contract/errors/mod.rs index dd2e5783772..23b427f5d7f 100644 --- a/packages/wasm-dpp/src/data_contract/errors/mod.rs +++ b/packages/wasm-dpp/src/data_contract/errors/mod.rs @@ -19,11 +19,13 @@ pub fn from_data_contract_to_js_error(e: DataContractError) -> JsValue { .expect("statically known structure should be a valid JSON"), ) .into(), - DataContractError::InvalidDocumentTypeError(err) => invalid_document_type::InvalidDocumentTypeInDataContractError::new( - err.document_type(), - err.data_contract_id().into(), - ) - .into(), + DataContractError::InvalidDocumentTypeError(err) => { + invalid_document_type::InvalidDocumentTypeInDataContractError::new( + err.document_type(), + err.data_contract_id().into(), + ) + .into() + } _ => todo!(), } } diff --git a/packages/wasm-dpp/src/errors/consensus/basic/document/missing_data_contract_id_error.rs b/packages/wasm-dpp/src/errors/consensus/basic/document/missing_data_contract_id_error.rs index cb55f5167fe..8b252552119 100644 --- a/packages/wasm-dpp/src/errors/consensus/basic/document/missing_data_contract_id_error.rs +++ b/packages/wasm-dpp/src/errors/consensus/basic/document/missing_data_contract_id_error.rs @@ -1,6 +1,6 @@ +use dpp::document::document_transition::document_base_transition::JsonValue; use serde::Serialize; use wasm_bindgen::prelude::*; -use dpp::document::document_transition::document_base_transition::JsonValue; #[wasm_bindgen(js_name=MissingDataContractIdError)] pub struct MissingDataContractIdErrorWasm { @@ -10,7 +10,10 @@ pub struct MissingDataContractIdErrorWasm { impl MissingDataContractIdErrorWasm { pub fn new(raw_document_transition: JsonValue, code: u32) -> Self { - MissingDataContractIdErrorWasm { raw_document_transition, code } + MissingDataContractIdErrorWasm { + raw_document_transition, + code, + } } } @@ -24,6 +27,8 @@ impl MissingDataContractIdErrorWasm { #[wasm_bindgen(js_name=rawDocumentTransition)] pub fn raw_document_transition(&self) -> wasm_bindgen::JsValue { let serializer = serde_wasm_bindgen::Serializer::json_compatible(); - self.raw_document_transition.serialize(&serializer).expect("implements Serialize") + self.raw_document_transition + .serialize(&serializer) + .expect("implements Serialize") } } diff --git a/packages/wasm-dpp/src/errors/consensus_error.rs b/packages/wasm-dpp/src/errors/consensus_error.rs index 2742217d0ef..96a5ff88cb5 100644 --- a/packages/wasm-dpp/src/errors/consensus_error.rs +++ b/packages/wasm-dpp/src/errors/consensus_error.rs @@ -178,13 +178,10 @@ pub fn from_consensus_error_ref(e: &DPPConsensusError) -> JsValue { ) .into() } - DPPConsensusError::IncompatibleRe2PatternError(err) => IncompatibleRe2PatternErrorWasm::new( - err.pattern(), - err.path(), - err.message(), - code, - ) - .into(), + DPPConsensusError::IncompatibleRe2PatternError(err) => { + IncompatibleRe2PatternErrorWasm::new(err.pattern(), err.path(), err.message(), code) + .into() + } DPPConsensusError::FeeError(e) => match e { dpp::consensus::fee::FeeError::BalanceIsNotEnoughError { balance, fee } => { BalanceIsNotEnoughErrorWasm::new(*balance, *fee, code).into() @@ -451,7 +448,9 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue { BasicError::DuplicateDocumentTransitionsWithIdsError(err) => { DuplicateDocumentTransitionsWithIdsErrorWasm::new(err.references(), code).into() } - BasicError::MissingDataContractIdError(err) => MissingDataContractIdErrorWasm::new(err.raw_document_transition(), code).into(), + BasicError::MissingDataContractIdError(err) => { + MissingDataContractIdErrorWasm::new(err.raw_document_transition(), code).into() + } BasicError::InvalidIdentifierError(err) => { InvalidIdentifierErrorWasm::new(err.identifier_name(), err.error(), code).into() } @@ -537,25 +536,31 @@ fn from_signature_error(signature_error: &SignatureError) -> JsValue { SignatureError::IdentityNotFoundError(err) => { IdentityNotFoundErrorWasm::new(err.identity_id(), code).into() } - SignatureError::InvalidSignaturePublicKeySecurityLevelError(err) => InvalidSignaturePublicKeySecurityLevelErrorWasm::new( - err.public_key_security_level(), - err.required_key_security_level(), - code, - ) - .into(), + SignatureError::InvalidSignaturePublicKeySecurityLevelError(err) => { + InvalidSignaturePublicKeySecurityLevelErrorWasm::new( + err.public_key_security_level(), + err.required_key_security_level(), + code, + ) + .into() + } SignatureError::PublicKeyIsDisabledError(err) => { PublicKeyIsDisabledErrorWasm::new(err.public_key_id(), code).into() } - SignatureError::PublicKeySecurityLevelNotMetError(err) => PublicKeySecurityLevelNotMetErrorWasm::new( - err.public_key_security_level(), - err.required_security_level(), + SignatureError::PublicKeySecurityLevelNotMetError(err) => { + PublicKeySecurityLevelNotMetErrorWasm::new( + err.public_key_security_level(), + err.required_security_level(), + code, + ) + .into() + } + SignatureError::WrongPublicKeyPurposeError(err) => WrongPublicKeyPurposeErrorWasm::new( + err.public_key_purpose(), + err.key_purpose_requirement(), code, ) .into(), - SignatureError::WrongPublicKeyPurposeError(err) => { - WrongPublicKeyPurposeErrorWasm::new(err.public_key_purpose(), err.key_purpose_requirement(), code) - .into() - } } } From cd4ccaf07b212d8a05f2aa894a8065cccf6dffc9 Mon Sep 17 00:00:00 2001 From: Anton Suprunchuk Date: Wed, 1 Mar 2023 16:47:36 +0700 Subject: [PATCH 08/11] fix all compilation and test errors --- .../rs-dpp/src/data_contract/data_contract.rs | 2 +- .../document_type/document_type.rs | 1 - ...e_data_contract_create_transition_basic.rs | 1 - .../validation/multi_validator.rs | 46 ++-- .../validate_data_contract_max_depth.rs | 53 +++-- packages/rs-dpp/src/document/document_stub.rs | 1 - ...stract_state_transition_identity_signed.rs | 32 ++- .../state_transition_factory.rs | 19 +- .../validate_state_transition_fee.rs | 11 +- ...ate_state_transition_identity_signature.rs | 34 +-- .../validation/validator_transaction_basic.rs | 34 +-- ...a_contract_update_transition_basic_spec.rs | 15 +- ...te_indices_are_backward_compatible_spec.rs | 76 ++++--- .../data_contract_validator_spec.rs | 214 +++++++++--------- ...e_documents_batch_transition_state_spec.rs | 11 +- .../validate_partial_compound_indices_spec.rs | 13 +- ...e_identity_credit_withdrawal_state_spec.rs | 19 +- 17 files changed, 326 insertions(+), 256 deletions(-) diff --git a/packages/rs-dpp/src/data_contract/data_contract.rs b/packages/rs-dpp/src/data_contract/data_contract.rs index b9077060780..7fd5d51ca51 100644 --- a/packages/rs-dpp/src/data_contract/data_contract.rs +++ b/packages/rs-dpp/src/data_contract/data_contract.rs @@ -19,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}; diff --git a/packages/rs-dpp/src/data_contract/document_type/document_type.rs b/packages/rs-dpp/src/data_contract/document_type/document_type.rs index 92a7c94c99e..b58ffdcbc18 100644 --- a/packages/rs-dpp/src/data_contract/document_type/document_type.rs +++ b/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; diff --git a/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs b/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs index 31d9800df75..3b9942153e4 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/data_contract_create_transition/validation/state/validate_data_contract_create_transition_basic.rs @@ -18,7 +18,6 @@ use crate::{ util::json_value::JsonValueExt, validation::{ DataValidator, DataValidatorWithContext, JsonSchemaValidator, SimpleValidationResult, - ValidationResult, }, version::ProtocolVersionValidator, ProtocolError, diff --git a/packages/rs-dpp/src/data_contract/validation/multi_validator.rs b/packages/rs-dpp/src/data_contract/validation/multi_validator.rs index e2be23e7d8e..1a3f2505c34 100644 --- a/packages/rs-dpp/src/data_contract/validation/multi_validator.rs +++ b/packages/rs-dpp/src/data_contract/validation/multi_validator.rs @@ -172,13 +172,14 @@ mod test { let result = validate(&schema, &[pattern_is_valid_regex_validator]); let consensus_error = result.errors.get(0).expect("the error should be returned"); - assert!( - matches!(consensus_error, ConsensusError::IncompatibleRe2PatternError {pattern, path, ..} - if path == "/properties/bar" && - pattern == "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$" && - consensus_error.code() == 1009 - ) - ); + match consensus_error { + ConsensusError::IncompatibleRe2PatternError(err) => { + assert_eq!(err.path(), "/properties/bar".to_string()); + assert_eq!(err.pattern(), "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string()); + assert_eq!(consensus_error.code(), 1009); + } + _ => panic!("Expected error to be IncompatibleRe2PatternError") + } } #[test] @@ -196,13 +197,15 @@ mod test { let result = validate(&schema, &[pattern_is_valid_regex_validator]); let consensus_error = result.errors.get(0).expect("the error should be returned"); - assert!( - matches!(consensus_error, ConsensusError::IncompatibleRe2PatternError {pattern, path, ..} - if path == "/properties/arrayOfObject/items/properties/simple" && - pattern == "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$" && - consensus_error.code() == 1009 - ) - ); + + match consensus_error { + ConsensusError::IncompatibleRe2PatternError(err) => { + assert_eq!(err.path(), "/properties/arrayOfObject/items/properties/simple".to_string()); + assert_eq!(err.pattern(), "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string()); + assert_eq!(consensus_error.code(), 1009); + } + _ => panic!("Expected error to be IncompatibleRe2PatternError") + } } #[test] @@ -214,13 +217,14 @@ mod test { let result = validate(&schema, &[pattern_is_valid_regex_validator]); let consensus_error = result.errors.get(0).expect("the error should be returned"); - assert!( - matches!(consensus_error, ConsensusError::IncompatibleRe2PatternError {pattern, path, ..} - if path == "/properties/arrayOfObjects/items/[0]/properties/simple" && - pattern == "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$" && - consensus_error.code() == 1009 - ) - ); + match consensus_error { + ConsensusError::IncompatibleRe2PatternError(err) => { + assert_eq!(err.path(), "/properties/arrayOfObjects/items/[0]/properties/simple".to_string()); + assert_eq!(err.pattern(), "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string()); + assert_eq!(consensus_error.code(), 1009); + } + _ => panic!("Expected error to be IncompatibleRe2PatternError") + } } fn get_document_schema() -> JsonValue { diff --git a/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs b/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs index 1c60cd9d2f4..a64e02f6d5b 100644 --- a/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs +++ b/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs @@ -132,10 +132,9 @@ mod test { } ); let result = calc_max_depth(&schema); - assert!(matches!( - result, - Err(BasicError::InvalidJsonSchemaRefError { ref_error }) if ref_error == "the ref '#/$defs/object' contains cycles" - )); + + let err = get_ref_error(result); + assert_eq!(err.ref_error(), "the ref '#/$defs/object' contains cycles".to_string()); } #[test] @@ -188,11 +187,14 @@ mod test { } ); let result = calc_max_depth(&schema); - println!("the result is {:#?}", result); - assert!(matches!( - result, - Err(BasicError::InvalidJsonSchemaRefError { ref_error }) if ref_error.starts_with("invalid ref '#/$defs/object'") - )); + + let err = get_ref_error(result); + assert!(err.ref_error().starts_with("invalid ref '#/$defs/object'")); + // println!("the result is {:#?}", result); + // assert!(matches!( + // result, + // Err(BasicError::InvalidJsonSchemaRefError { ref_error }) if ref_error.starts_with("invalid ref '#/$defs/object'") + // )); } #[test] @@ -215,10 +217,14 @@ mod test { } ); let result = calc_max_depth(&schema); - assert!(matches!( - result, - Err(BasicError::InvalidJsonSchemaRefError { ref_error }) if ref_error == "invalid ref 'https://json-schema.org/some': only local references are allowed" - )); + + let err = get_ref_error(result); + assert_eq!(err.ref_error(), "invalid ref 'https://json-schema.org/some': only local references are allowed".to_string()); + + // assert!(matches!( + // result, + // Err(BasicError::InvalidJsonSchemaRefError { ref_error }) if ref_error == "invalid ref 'https://json-schema.org/some': only local references are allowed" + // )); } #[test] @@ -241,10 +247,9 @@ mod test { } ); let result = calc_max_depth(&schema); - assert!(matches!( - result, - Err(BasicError::InvalidJsonSchemaRefError { ref_error }) if ref_error == "invalid ref '': only local references are allowed" - )); + + let err = get_ref_error(result); + assert_eq!(err.ref_error(), "invalid ref '': only local references are allowed".to_string()); } #[test] @@ -288,4 +293,18 @@ mod test { }); assert!(matches!(calc_max_depth(&schema), Ok(4))); } + + pub fn get_ref_error(result: Result) -> InvalidJsonSchemaRefError { + match result { + Ok(_) => panic!("expected to have validation error"), + Err(e) => { + match e { + BasicError::InvalidJsonSchemaRefError(err) => { + err + }, + _ => panic!("expected error to be a InvalidJsonSchemaRefError") + } + } + } + } } diff --git a/packages/rs-dpp/src/document/document_stub.rs b/packages/rs-dpp/src/document/document_stub.rs index e3742906deb..d060cfdee10 100644 --- a/packages/rs-dpp/src/document/document_stub.rs +++ b/packages/rs-dpp/src/document/document_stub.rs @@ -54,7 +54,6 @@ use crate::ProtocolError; use crate::document::document_transition::INITIAL_REVISION; use crate::document::property_names; use crate::prelude::*; -use crate::util::cbor_value::CborBTreeMapHelper; use anyhow::{anyhow, bail}; use platform_value::btreemap_extensions::BTreeValueMapHelper; use platform_value::Value; diff --git a/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs b/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs index 28ae55f4c4e..1192a1a7240 100644 --- a/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs +++ b/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs @@ -469,10 +469,10 @@ mod test { .unwrap_err(); match sign_error { ProtocolError::PublicKeySecurityLevelNotMetError( - PublicKeySecurityLevelNotMetError::new(sec_level, req_sec_level), + err ) => { - assert_eq!(SecurityLevel::MEDIUM, sec_level); - assert_eq!(SecurityLevel::HIGH, req_sec_level); + assert_eq!(SecurityLevel::MEDIUM, err.public_key_security_level()); + assert_eq!(SecurityLevel::HIGH, err.required_security_level()); } error => { panic!("invalid error type: {}", error) @@ -491,12 +491,9 @@ mod test { .sign(&keys.identity_public_key, &keys.ec_private, &bls) .unwrap_err(); match sign_error { - ProtocolError::WrongPublicKeyPurposeError(WrongPublicKeyPurposeError::new( - purpose, - req_purpose, - )) => { - assert_eq!(Purpose::ENCRYPTION, purpose); - assert_eq!(Purpose::AUTHENTICATION, req_purpose); + ProtocolError::WrongPublicKeyPurposeError(err) => { + assert_eq!(Purpose::ENCRYPTION, err.public_key_purpose()); + assert_eq!(Purpose::AUTHENTICATION, err.key_purpose_requirement()); } error => { panic!("invalid error type: {}", error) @@ -600,15 +597,12 @@ mod test { .sign(&keys.identity_public_key, &keys.bls_private, &bls) .expect_err("the protocol error should be returned"); - assert!(matches!( - result, - ProtocolError::InvalidSignaturePublicKeySecurityLevelError( - InvalidSignaturePublicKeySecurityLevelError { - public_key_security_level, - required_key_security_level - }) - if public_key_security_level == SecurityLevel::MASTER && - required_key_security_level == SecurityLevel::HIGH - )) + match result { + ProtocolError::InvalidSignaturePublicKeySecurityLevelError(err) => { + assert_eq!(err.public_key_security_level(), SecurityLevel::MASTER); + assert_eq!(err.required_key_security_level(), SecurityLevel::HIGH); + }, + error => panic!("expected InvalidSignaturePublicKeySecurityLevelError, got {}", error) + } } } diff --git a/packages/rs-dpp/src/state_transition/state_transition_factory.rs b/packages/rs-dpp/src/state_transition/state_transition_factory.rs index 8dbb8985da9..04811f9dc0c 100644 --- a/packages/rs-dpp/src/state_transition/state_transition_factory.rs +++ b/packages/rs-dpp/src/state_transition/state_transition_factory.rs @@ -238,9 +238,20 @@ mod test { }); let result = create_state_transition(&state_repostiory_mock, raw_state_transition).await; - assert!(matches!( - result, - Err(ProtocolError::InvalidStateTransitionTypeError) - )); + let err = get_protocol_error(result); + + match err { + ProtocolError::InvalidStateTransitionTypeError(err) => { + assert_eq!(err.transition_type(), 154); + } + _ => panic!("expected InvalidStateTransitionTypeError, got {}", err) + } + } + + pub fn get_protocol_error(result: Result) -> ProtocolError { + match result { + Ok(_) => panic!("expected to get ProtocolError, got valid result"), + Err(e) => e + } } } diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs index 92f5c3b8af2..8e6b19bcf7c 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs @@ -394,9 +394,12 @@ mod test { .validate(&transition.into()) .await .expect_err("error should be returned"); - assert!(matches!( - result, - ProtocolError::InvalidStateTransitionTypeError - )) + + match result { + ProtocolError::InvalidStateTransitionTypeError(err) => { + assert_eq!(err.transition_type(), 6); + } + _ => panic!("expected InvalidStateTransitionTypeError, got {}", result) + } } } diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs index 6862cdf3348..b16b2e77280 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs @@ -3,10 +3,7 @@ use std::{collections::HashSet, convert::TryInto}; use anyhow::Context; use lazy_static::lazy_static; -use crate::consensus::signature::{ - IdentityNotFoundError, InvalidIdentityPublicKeyTypeError, MissingPublicKeyError, - PublicKeyIsDisabledError, PublicKeySecurityLevelNotMetError, -}; +use crate::consensus::signature::{IdentityNotFoundError, InvalidIdentityPublicKeyTypeError, MissingPublicKeyError, PublicKeyIsDisabledError, PublicKeySecurityLevelNotMetError}; use crate::{ consensus::{signature::SignatureError, ConsensusError}, identity::KeyType, @@ -145,7 +142,7 @@ fn convert_to_consensus_signature_error( #[cfg(test)] mod test { use super::*; - use crate::state_transition::errors::WrongPublicKeyPurposeError; + use crate::state_transition::errors::{PublicKeyMismatchError, WrongPublicKeyPurposeError}; use crate::{ document::DocumentsBatchTransition, identity::{KeyID, Purpose, SecurityLevel}, @@ -162,6 +159,7 @@ mod test { NativeBlsModule, }; use serde::{Deserialize, Serialize}; + use crate::consensus::signature::InvalidSignaturePublicKeySecurityLevelError; #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -249,7 +247,7 @@ mod test { } 2 => { return Err(ProtocolError::PublicKeySecurityLevelNotMetError( - PublicKeySecurityLevelNotMetError::new( + crate::state_transition::errors::PublicKeySecurityLevelNotMetError::new( SecurityLevel::CRITICAL, SecurityLevel::HIGH, ), @@ -257,7 +255,7 @@ mod test { } 3 => { return Err(ProtocolError::PublicKeyIsDisabledError( - PublicKeyIsDisabledError::new(public_key.clone()), + crate::data_contract::state_transition::errors::PublicKeyIsDisabledError::new(public_key.clone()), )) } 4 => { @@ -345,11 +343,12 @@ mod test { .expect("the validation result should be returned"); let signature_error = get_signature_error_from_result(&result, 0); - assert!( - matches!(signature_error, SignatureError::IdentityNotFoundError(IdentityNotFoundError::new(identity_id)) if { - identity_id == identity.get_id() - }) - ); + match signature_error { + SignatureError::IdentityNotFoundError(err) => { + assert_eq!(err.identity_id(), identity.get_id().clone()) + }, + error => panic!("expected IdentityNotFoundError, got {}", error) + } } #[tokio::test] @@ -377,11 +376,12 @@ mod test { .expect("the validation result should be returned"); let signature_error = get_signature_error_from_result(&result, 0); - assert!( - matches!(signature_error, SignatureError::MissingPublicKeyError(MissingPublicKeyError::new(public_key_id)) if { - *public_key_id == 12332 - }) - ); + match signature_error { + SignatureError::MissingPublicKeyError(err) => { + assert_eq!(err.public_key_id(), 12332) + }, + error => panic!("expected MissingPublicKeyError, got {}", error) + } } #[tokio::test] diff --git a/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs b/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs index 3be87ee0f8a..fa40a06276a 100644 --- a/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs +++ b/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs @@ -193,10 +193,12 @@ mod test { .expect("the validation result should be returned"); let basic_error = get_basic_error_from_result(&result, 0); - assert!(matches!( - basic_error, - BasicError::InvalidStateTransitionTypeError { transition_type } if { transition_type == &123} - )); + match basic_error { + BasicError::InvalidStateTransitionTypeError(err) => { + assert_eq!(err.transition_type(), 123) + }, + _ => panic!("Expected InvalidStateTransitionTypeError, got {}", basic_error) + } } #[tokio::test] @@ -221,10 +223,12 @@ mod test { .expect("the validation result should be returned"); let basic_error = get_basic_error_from_result(&result, 0); - assert!(matches!( - basic_error, - BasicError::InvalidStateTransitionTypeError { transition_type } if { transition_type == &123} - )); + match basic_error { + BasicError::InvalidStateTransitionTypeError(err) => { + assert_eq!(err.transition_type(), 123) + }, + _ => panic!("Expected InvalidStateTransitionTypeError, got {}", basic_error) + } } #[tokio::test] @@ -256,13 +260,13 @@ mod test { let basic_error = get_basic_error_from_result(&result, 0); - assert!(matches!( - basic_error, - BasicError::StateTransitionMaxSizeExceededError { actual_size_kbytes, max_size_kbytes} if { - *actual_size_kbytes == 53 && - *max_size_kbytes == 16 - } - )); + match basic_error { + BasicError::StateTransitionMaxSizeExceededError(err) => { + assert_eq!(err.actual_size_kbytes(), 53); + assert_eq!(err.max_size_kbytes(), 16); + }, + _ => panic!("Expected StateTransitionMaxSizeExceededError, got {}", basic_error) + } } #[tokio::test] diff --git a/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic_spec.rs b/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic_spec.rs index 0fe3170d973..10aebdf9ceb 100644 --- a/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic_spec.rs +++ b/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic_spec.rs @@ -355,13 +355,14 @@ async fn should_have_existing_documents_schema_backward_compatible() { .expect("validation result should be returned"); let basic_error = get_basic_error_from_result(&result, 0); - assert!(matches!( - basic_error, - BasicError::IncompatibleDataContractSchemaError { operation, field_path, ..} if { - operation == "add" && - field_path == "/required/1" - } - )); + + match basic_error { + BasicError::IncompatibleDataContractSchemaError(err) => { + assert_eq!(err.operation(), "add".to_string()); + assert_eq!(err.field_path(), "/required/1".to_string()); + }, + _ => panic!("Expected IncompatibleDataContractSchemaError, got {}", basic_error) + } } #[tokio::test] diff --git a/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible_spec.rs b/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible_spec.rs index af4fa45a2ca..58fa4aa6081 100644 --- a/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible_spec.rs +++ b/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible_spec.rs @@ -96,10 +96,14 @@ fn should_return_invalid_result_if_some_of_unique_indices_have_changed() { assert_eq!(1053, result.errors()[0].code()); let basic_error = get_basic_error(&result, 0); - matches!(basic_error, BasicError::DataContractUniqueIndicesChangedError { document_type, index_name }if { - document_type == "indexedDocument" && - index_name == "index1" - }); + + match basic_error { + BasicError::DataContractUniqueIndicesChangedError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.index_name(), "index1".to_string()); + }, + _ => panic!("Expected DataContractUniqueIndicesChangedError, got {}", basic_error) + } } #[test] @@ -123,10 +127,14 @@ fn should_return_invalid_result_if_non_unique_index_update_failed_due_to_changed assert_eq!(0, result.errors()[0].code()); let basic_error = get_basic_error(&result, 0); - matches!(basic_error, BasicError::DataContractInvalidIndexDefinitionUpdateError { document_type, index_name }if { - document_type == "indexedDocument" && - index_name == "index3" - }); + + match basic_error { + BasicError::DataContractInvalidIndexDefinitionUpdateError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.index_name(), "index3".to_string()); + }, + _ => panic!("Expected DataContractInvalidIndexDefinitionUpdateError, got {}", basic_error) + } } #[test] @@ -151,10 +159,13 @@ fn should_return_invalid_result_if_already_indexed_properties_are_added_to_exist assert_eq!(0, result.errors()[0].code()); let basic_error = get_basic_error(&result, 0); - matches!(basic_error, BasicError::DataContractInvalidIndexDefinitionUpdateError { document_type, index_name }if { - document_type == "indexedDocument" && - index_name == "index3" - }); + match basic_error { + BasicError::DataContractInvalidIndexDefinitionUpdateError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.index_name(), "index3".to_string()); + }, + _ => panic!("Expected DataContractInvalidIndexDefinitionUpdateError, got {}", basic_error) + } } #[test] @@ -186,12 +197,16 @@ fn should_return_invalid_result_if_one_of_new_indices_contains_old_properties_in assert_eq!(0, result.errors()[0].code()); let basic_error = get_basic_error(&result, 0); + // the JS-version imports DataContractInvalidIndexDefinitionUpdateError as DataContractHaveNewIndexWithOldPropertiesError as // we should decide if we want to have a separate error called DataContractInvalidIndexDefinitionUpdateError - matches!(basic_error, BasicError::DataContractInvalidIndexDefinitionUpdateError { document_type, index_name }if { - document_type == "indexedDocument" && - index_name == "index_other" - }); + match basic_error { + BasicError::DataContractInvalidIndexDefinitionUpdateError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.index_name(), "index_other".to_string()); + }, + _ => panic!("Expected DataContractInvalidIndexDefinitionUpdateError, got {}", basic_error) + } } #[test] @@ -222,10 +237,14 @@ fn should_return_invalid_result_if_one_of_new_indices_is_unique() { assert_eq!(0, result.errors()[0].code()); let basic_error = get_basic_error(&result, 0); - matches!(basic_error, BasicError::DataContractHaveNewUniqueIndexError { document_type, index_name }if { - document_type == "indexedDocument" && - index_name == "index_other" - }); + + match basic_error { + BasicError::DataContractHaveNewUniqueIndexError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.index_name(), "index_other".to_string()); + }, + _ => panic!("Expected DataContractHaveNewUniqueIndexError, got {}", basic_error) + } } #[test] @@ -284,13 +303,12 @@ fn should_return_invalid_result_if_non_unique_index_added_for_non_indexed_proper assert_eq!(result.errors()[0].code(), 0); let basic_error = get_basic_error(&result, 0); - assert!(matches!( - basic_error, - BasicError::DataContractInvalidIndexDefinitionUpdateError { - document_type, - index_name, - } if { - document_type == "indexedDocument" && - index_name == "index1337" - })); + + match basic_error { + BasicError::DataContractInvalidIndexDefinitionUpdateError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.index_name(), "index1337".to_string()); + }, + _ => panic!("Expected DataContractInvalidIndexDefinitionUpdateError, got {}", basic_error) + } } diff --git a/packages/rs-dpp/src/tests/data_contract/validation/data_contract_validator_spec.rs b/packages/rs-dpp/src/tests/data_contract/validation/data_contract_validator_spec.rs index 27b535c687f..6c0278a2aed 100644 --- a/packages/rs-dpp/src/tests/data_contract/validation/data_contract_validator_spec.rs +++ b/packages/rs-dpp/src/tests/data_contract/validation/data_contract_validator_spec.rs @@ -1346,13 +1346,14 @@ mod documents { .expect("the error in result should exist"); assert_eq!(1009, pattern_error.get_code()); - assert!( - matches!(pattern_error, ConsensusError::IncompatibleRe2PatternError { path, pattern, .. } - if { - path == "/documents/indexedDocument/properties/something" && - pattern == "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$" - }) - ); + + match pattern_error { + ConsensusError::IncompatibleRe2PatternError(err) => { + assert_eq!(err.path(),"/documents/indexedDocument/properties/something".to_string()); + assert_eq!(err.pattern(),"^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string()); + }, + _ => panic!("Expected IncompatibleRe2PatternError, got {:?}", pattern_error) + } } } @@ -1600,10 +1601,12 @@ mod indices { .expect("the validation error should be returned"); let index_error = get_index_error(validation_error); - assert_eq!(1008, index_error.get_code()); - assert!( - matches!(index_error, IndexError::DuplicateIndexError { document_type, .. } if document_type == "indexedDocument") - ); + match index_error { + IndexError::DuplicateIndexError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + }, + _ => panic!("Expected DuplicateIndexError, got {}", index_error) + } } #[test] @@ -1635,13 +1638,13 @@ mod indices { let basic_error = get_basic_error(validation_error); assert_eq!(1048, basic_error.get_code()); - assert!( - matches!(basic_error, BasicError::DuplicateIndexNameError { document_type, duplicate_index_name } - if { - document_type == "indexedDocument" && - duplicate_index_name == "index1" - }) - ); + match basic_error { + BasicError::DuplicateIndexNameError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.duplicate_index_name(), "index1".to_string()) + }, + _ => panic!("Expected DuplicateIndexNameError, got {}", basic_error) + } } #[test] @@ -1956,13 +1959,14 @@ mod indices { let index_error = get_index_error(error); assert_eq!(1017, index_error.get_code()); - assert!( - matches!(index_error, IndexError::UniqueIndicesLimitReachedError { document_type, index_limit } - if { - document_type == "indexedDocument" && - index_limit == &3 - }) - ); + match index_error { + IndexError::UniqueIndicesLimitReachedError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.index_limit(), 3); + // assert_eq!(err.property_type(), "array".to_string()); + }, + _ => panic!("Expected UniqueIndicesLimitReachedError, got {}", index_error) + } } #[test] @@ -1994,13 +1998,13 @@ mod indices { let index_error = get_index_error(error); assert_eq!(1015, index_error.get_code()); - assert!( - matches!(index_error, IndexError::SystemPropertyIndexAlreadyPresentError { document_type, property_name, .. } - if { - document_type == "indexedDocument" && - property_name == "$id" - }) - ); + match index_error { + IndexError::SystemPropertyIndexAlreadyPresentError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.property_name(), "$id".to_string()); + }, + _ => panic!("Expected SystemPropertyIndexAlreadyPresentError, got {}", index_error) + } } #[test] @@ -2026,13 +2030,13 @@ mod indices { let index_error = get_index_error(error); assert_eq!(1016, index_error.get_code()); - assert!( - matches!(index_error, IndexError::UndefinedIndexPropertyError { document_type, property_name, .. } - if { - document_type == "indexedDocument" && - property_name == "missingProperty" - }) - ); + match index_error { + IndexError::UndefinedIndexPropertyError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.property_name(), "missingProperty".to_string()); + }, + _ => panic!("Expected UndefinedIndexPropertyError, got {}", index_error) + } } #[test] @@ -2073,14 +2077,14 @@ mod indices { let index_error = get_index_error(error); assert_eq!(1013, index_error.get_code()); - assert!( - matches!(index_error, IndexError::InvalidIndexPropertyTypeError { document_type, property_name, property_type, ..} - if { - document_type == "indexedDocument" && - property_name == "objectProperty" && - property_type == "object" - }) - ); + match index_error { + IndexError::InvalidIndexPropertyTypeError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.property_name(), "objectProperty".to_string()); + assert_eq!(err.property_type(), "object".to_string()); + }, + _ => panic!("Expected InvalidIndexPropertyTypeError, got {}", index_error) + } } #[test] @@ -2125,14 +2129,14 @@ mod indices { let index_error = get_index_error(error); assert_eq!(1013, index_error.get_code()); - assert!( - matches!(index_error, IndexError::InvalidIndexPropertyTypeError { document_type, property_name, property_type, ..} - if { - document_type == "indexedArray" && - property_name == "mentions" && - property_type == "array" - }) - ); + match index_error { + IndexError::InvalidIndexPropertyTypeError(err) => { + assert_eq!(err.document_type(), "indexedArray".to_string()); + assert_eq!(err.property_name(), "mentions".to_string()); + assert_eq!(err.property_type(), "array".to_string()); + }, + _ => panic!("Expected InvalidIndexPropertyTypeError, got {}", index_error) + } } // This section is originally commented out @@ -2332,14 +2336,14 @@ mod indices { let index_error = get_index_error(error); assert_eq!(1013, index_error.get_code()); - assert!( - matches!(index_error, IndexError::InvalidIndexPropertyTypeError { document_type, property_name, property_type, ..} - if { - document_type == "indexedDocument" && - property_name == "arrayProperty" && - property_type == "array" - }) - ); + match index_error { + IndexError::InvalidIndexPropertyTypeError(err) => { + assert_eq!(err.document_type(), "indexedDocument".to_string()); + assert_eq!(err.property_name(), "arrayProperty"); + assert_eq!(err.property_type(), "array".to_string()); + }, + _ => panic!("Expected InvalidIndexPropertyTypeError, got {}", index_error) + } } #[test] @@ -2364,12 +2368,12 @@ mod indices { let index_error = get_index_error(error); assert_eq!(1010, index_error.get_code()); - assert!( - matches!(index_error, IndexError::InvalidCompoundIndexError { document_type, ..} - if { - document_type == "optionalUniqueIndexedDocument" - }) - ); + match index_error { + IndexError::InvalidCompoundIndexError(err) => { + assert_eq!(err.document_type(), "optionalUniqueIndexedDocument".to_string()); + }, + _ => panic!("Expected InvalidCompoundIndexError, got {}", index_error) + } } #[test] @@ -2457,12 +2461,12 @@ mod indices { let index_error = get_index_error(&result.errors()[0]); assert_eq!(1016, index_error.get_code()); - assert!( - matches!(index_error, IndexError::UndefinedIndexPropertyError { property_name, ..} - if { - property_name == invalid_name - }) - ); + match index_error { + IndexError::UndefinedIndexPropertyError(err) => { + assert_eq!(err.property_name(), invalid_name.to_string()); + }, + _ => panic!("Expected UndefinedIndexPropertyError, got {}", index_error) + } } } @@ -2738,12 +2742,12 @@ fn should_return_invalid_result_with_circular_ref_pointer() { let basic_error = get_basic_error(validation_error); assert_eq!(1014, validation_error.get_code()); - assert!( - matches!(basic_error, BasicError::InvalidJsonSchemaRefError { ref_error} - if { - ref_error == "the ref '#/$defs/object' contains cycles" - }) - ); + match basic_error { + BasicError::InvalidJsonSchemaRefError(err) => { + assert_eq!(err.ref_error(), "the ref '#/$defs/object' contains cycles".to_string()); + }, + _ => panic!("Expected InvalidJsonSchemaRefError, got {}", basic_error) + } } #[test] @@ -2769,14 +2773,14 @@ fn should_return_invalid_result_if_indexed_string_property_missing_max_length_co let index_error = get_index_error(validation_error); assert_eq!(1012, index_error.get_code()); - assert!( - matches!(index_error, IndexError::InvalidIndexedPropertyConstraintError { property_name, constraint_name, reason, ..} - if { - property_name == "firstName" && - constraint_name == "maxLength" && - reason == "should be less or equal than 63" - }) - ); + match index_error { + IndexError::InvalidIndexedPropertyConstraintError(err) => { + assert_eq!(err.property_name(), "firstName".to_string()); + assert_eq!(err.constraint_name(), "maxLength".to_string()); + assert_eq!(err.reason(), "should be less or equal than 63".to_string()); + }, + _ => panic!("Expected InvalidIndexedPropertyConstraintError, got {}", index_error) + } } mod indexed_array { @@ -2870,14 +2874,14 @@ mod indexed_array { let index_error = get_index_error(validation_error); assert_eq!(1012, index_error.get_code()); - assert!( - matches!(index_error, IndexError::InvalidIndexedPropertyConstraintError { property_name, constraint_name, reason, ..} - if { - property_name == "byteArrayField" && - constraint_name == "maxItems" && - reason == "should be less or equal 255" - }) - ); + match index_error { + IndexError::InvalidIndexedPropertyConstraintError(err) => { + assert_eq!(err.property_name(), "byteArrayField".to_string()); + assert_eq!(err.constraint_name(), "maxItems".to_string()); + assert_eq!(err.reason(), "should be less or equal 255".to_string()); + }, + _ => panic!("Expected InvalidIndexedPropertyConstraintError, got {}", index_error) + } } #[test] @@ -2901,14 +2905,14 @@ mod indexed_array { let index_error = get_index_error(validation_error); assert_eq!(1012, index_error.get_code()); - assert!( - matches!(index_error, IndexError::InvalidIndexedPropertyConstraintError { property_name, constraint_name, reason, ..} - if { - property_name == "byteArrayField" && - constraint_name == "maxItems" && - reason == "should be less or equal 255" - }) - ); + match index_error { + IndexError::InvalidIndexedPropertyConstraintError(err) => { + assert_eq!(err.property_name(), "byteArrayField".to_string()); + assert_eq!(err.constraint_name(), "maxItems".to_string()); + assert_eq!(err.reason(), "should be less or equal 255".to_string()); + }, + _ => panic!("Expected InvalidIndexedPropertyConstraintError, got {}", index_error) + } } } diff --git a/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_documents_batch_transition_state_spec.rs b/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_documents_batch_transition_state_spec.rs index 7fa966561db..8145707f90e 100644 --- a/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_documents_batch_transition_state_spec.rs +++ b/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_documents_batch_transition_state_spec.rs @@ -139,11 +139,12 @@ async fn should_throw_error_if_data_contract_was_not_found() { .await .expect_err("protocol error expected"); - assert!(matches!( - error, - ProtocolError::DataContractNotPresentError { data_contract_id } if - data_contract_id == data_contract.id - )); + match error { + ProtocolError::DataContractNotPresentError(err) => { + assert_eq!(err.data_contract_id(), data_contract.id); + }, + _ => panic!("Expected DataContractNotPresentError, got {}", error) + } } #[tokio::test] diff --git a/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_partial_compound_indices_spec.rs b/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_partial_compound_indices_spec.rs index 0fdd71fd171..f4cf48cb334 100644 --- a/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_partial_compound_indices_spec.rs +++ b/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_partial_compound_indices_spec.rs @@ -59,12 +59,13 @@ fn should_return_invalid_result_if_compound_index_contains_not_all_fields() { assert!(!result.is_valid()); assert_eq!(1021, result.errors[0].code()); - assert!( - matches!(basic_error, BasicError::InconsistentCompoundIndexDataError { index_properties, document_type } if { - document_type == "optionalUniqueIndexedDocument" && - index_properties == &vec!["$ownerId".to_string(), "firstName".to_string(), "lastName".to_string()] - }) - ) + match basic_error { + BasicError::InconsistentCompoundIndexDataError(err) => { + assert_eq!(err.document_type(), "optionalUniqueIndexedDocument".to_string()); + assert_eq!(err.index_properties(), vec!["$ownerId".to_string(), "firstName".to_string(), "lastName".to_string()]); + }, + _ => panic!("Expected InconsistentCompoundIndexDataError, got {}", basic_error) + } } #[test] diff --git a/packages/rs-dpp/src/tests/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_state_spec.rs b/packages/rs-dpp/src/tests/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_state_spec.rs index 599215919c6..9236ba2a446 100644 --- a/packages/rs-dpp/src/tests/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_state_spec.rs +++ b/packages/rs-dpp/src/tests/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_state_spec.rs @@ -34,6 +34,7 @@ mod validate_identity_credit_withdrawal_transition_state_factory { use crate::assert_consensus_errors; use crate::consensus::ConsensusError; + use crate::consensus::signature::SignatureError; use crate::prelude::{Identifier, Identity}; use super::*; @@ -55,11 +56,23 @@ mod validate_identity_credit_withdrawal_transition_state_factory { .await .unwrap(); - assert_consensus_errors!(result, ConsensusError::BasicError, 1); - - let error = result.first_error().unwrap(); + let errors = result.errors(); + assert_eq!(errors.len(), 1); + let error = errors.first().unwrap(); assert_eq!(error.code(), 2000); + + match error { + ConsensusError::SignatureError(err) => { + match err { + SignatureError::IdentityNotFoundError(e) => { + assert_eq!(e.identity_id(), Identifier::default()); + }, + e => panic!("expected IdentityNotFoundError, got {}", e) + } + }, + e => panic!("expected IdentityNotFoundError, got {:?}", e) + } } #[tokio::test] From 7c961edef05f78985a3e806d5b62bd500931d283 Mon Sep 17 00:00:00 2001 From: Anton Suprunchuk Date: Wed, 1 Mar 2023 16:49:16 +0700 Subject: [PATCH 09/11] reformat --- .../rs-dpp/src/data_contract/data_contract.rs | 2 +- .../validation/multi_validator.rs | 32 ++++-- .../validate_data_contract_max_depth.rs | 28 +++-- ...stract_state_transition_identity_signed.rs | 11 +- .../state_transition_factory.rs | 4 +- .../validate_state_transition_fee.rs | 2 +- ...ate_state_transition_identity_signature.rs | 15 ++- .../validation/validator_transaction_basic.rs | 21 +++- ...a_contract_update_transition_basic_spec.rs | 7 +- ...te_indices_are_backward_compatible_spec.rs | 42 +++++-- .../data_contract_validator_spec.rs | 107 ++++++++++++------ ...e_documents_batch_transition_state_spec.rs | 4 +- .../validate_partial_compound_indices_spec.rs | 21 +++- ...e_identity_credit_withdrawal_state_spec.rs | 14 +-- 14 files changed, 207 insertions(+), 103 deletions(-) diff --git a/packages/rs-dpp/src/data_contract/data_contract.rs b/packages/rs-dpp/src/data_contract/data_contract.rs index 7fd5d51ca51..3d00fbd2791 100644 --- a/packages/rs-dpp/src/data_contract/data_contract.rs +++ b/packages/rs-dpp/src/data_contract/data_contract.rs @@ -19,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::{CborCanonicalMap}; +use crate::util::cbor_value::CborCanonicalMap; use crate::util::deserializer; use crate::util::deserializer::SplitProtocolVersionOutcome; use crate::util::json_value::{JsonValueExt, ReplaceWith}; diff --git a/packages/rs-dpp/src/data_contract/validation/multi_validator.rs b/packages/rs-dpp/src/data_contract/validation/multi_validator.rs index 1a3f2505c34..c0584ac25d1 100644 --- a/packages/rs-dpp/src/data_contract/validation/multi_validator.rs +++ b/packages/rs-dpp/src/data_contract/validation/multi_validator.rs @@ -175,10 +175,13 @@ mod test { match consensus_error { ConsensusError::IncompatibleRe2PatternError(err) => { assert_eq!(err.path(), "/properties/bar".to_string()); - assert_eq!(err.pattern(), "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string()); + assert_eq!( + err.pattern(), + "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string() + ); assert_eq!(consensus_error.code(), 1009); } - _ => panic!("Expected error to be IncompatibleRe2PatternError") + _ => panic!("Expected error to be IncompatibleRe2PatternError"), } } @@ -197,14 +200,19 @@ mod test { let result = validate(&schema, &[pattern_is_valid_regex_validator]); let consensus_error = result.errors.get(0).expect("the error should be returned"); - match consensus_error { ConsensusError::IncompatibleRe2PatternError(err) => { - assert_eq!(err.path(), "/properties/arrayOfObject/items/properties/simple".to_string()); - assert_eq!(err.pattern(), "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string()); + assert_eq!( + err.path(), + "/properties/arrayOfObject/items/properties/simple".to_string() + ); + assert_eq!( + err.pattern(), + "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string() + ); assert_eq!(consensus_error.code(), 1009); } - _ => panic!("Expected error to be IncompatibleRe2PatternError") + _ => panic!("Expected error to be IncompatibleRe2PatternError"), } } @@ -219,11 +227,17 @@ mod test { match consensus_error { ConsensusError::IncompatibleRe2PatternError(err) => { - assert_eq!(err.path(), "/properties/arrayOfObjects/items/[0]/properties/simple".to_string()); - assert_eq!(err.pattern(), "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string()); + assert_eq!( + err.path(), + "/properties/arrayOfObjects/items/[0]/properties/simple".to_string() + ); + assert_eq!( + err.pattern(), + "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string() + ); assert_eq!(consensus_error.code(), 1009); } - _ => panic!("Expected error to be IncompatibleRe2PatternError") + _ => panic!("Expected error to be IncompatibleRe2PatternError"), } } diff --git a/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs b/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs index a64e02f6d5b..9784faa9a0d 100644 --- a/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs +++ b/packages/rs-dpp/src/data_contract/validation/validate_data_contract_max_depth.rs @@ -134,7 +134,10 @@ mod test { let result = calc_max_depth(&schema); let err = get_ref_error(result); - assert_eq!(err.ref_error(), "the ref '#/$defs/object' contains cycles".to_string()); + assert_eq!( + err.ref_error(), + "the ref '#/$defs/object' contains cycles".to_string() + ); } #[test] @@ -219,7 +222,11 @@ mod test { let result = calc_max_depth(&schema); let err = get_ref_error(result); - assert_eq!(err.ref_error(), "invalid ref 'https://json-schema.org/some': only local references are allowed".to_string()); + assert_eq!( + err.ref_error(), + "invalid ref 'https://json-schema.org/some': only local references are allowed" + .to_string() + ); // assert!(matches!( // result, @@ -249,7 +256,10 @@ mod test { let result = calc_max_depth(&schema); let err = get_ref_error(result); - assert_eq!(err.ref_error(), "invalid ref '': only local references are allowed".to_string()); + assert_eq!( + err.ref_error(), + "invalid ref '': only local references are allowed".to_string() + ); } #[test] @@ -297,14 +307,10 @@ mod test { pub fn get_ref_error(result: Result) -> InvalidJsonSchemaRefError { match result { Ok(_) => panic!("expected to have validation error"), - Err(e) => { - match e { - BasicError::InvalidJsonSchemaRefError(err) => { - err - }, - _ => panic!("expected error to be a InvalidJsonSchemaRefError") - } - } + Err(e) => match e { + BasicError::InvalidJsonSchemaRefError(err) => err, + _ => panic!("expected error to be a InvalidJsonSchemaRefError"), + }, } } } diff --git a/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs b/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs index 1192a1a7240..77c85d3a2ab 100644 --- a/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs +++ b/packages/rs-dpp/src/state_transition/abstract_state_transition_identity_signed.rs @@ -468,9 +468,7 @@ mod test { .sign(&keys.identity_public_key, &keys.ec_private, &bls) .unwrap_err(); match sign_error { - ProtocolError::PublicKeySecurityLevelNotMetError( - err - ) => { + ProtocolError::PublicKeySecurityLevelNotMetError(err) => { assert_eq!(SecurityLevel::MEDIUM, err.public_key_security_level()); assert_eq!(SecurityLevel::HIGH, err.required_security_level()); } @@ -601,8 +599,11 @@ mod test { ProtocolError::InvalidSignaturePublicKeySecurityLevelError(err) => { assert_eq!(err.public_key_security_level(), SecurityLevel::MASTER); assert_eq!(err.required_key_security_level(), SecurityLevel::HIGH); - }, - error => panic!("expected InvalidSignaturePublicKeySecurityLevelError, got {}", error) + } + error => panic!( + "expected InvalidSignaturePublicKeySecurityLevelError, got {}", + error + ), } } } diff --git a/packages/rs-dpp/src/state_transition/state_transition_factory.rs b/packages/rs-dpp/src/state_transition/state_transition_factory.rs index 04811f9dc0c..5bd3efefedd 100644 --- a/packages/rs-dpp/src/state_transition/state_transition_factory.rs +++ b/packages/rs-dpp/src/state_transition/state_transition_factory.rs @@ -244,14 +244,14 @@ mod test { ProtocolError::InvalidStateTransitionTypeError(err) => { assert_eq!(err.transition_type(), 154); } - _ => panic!("expected InvalidStateTransitionTypeError, got {}", err) + _ => panic!("expected InvalidStateTransitionTypeError, got {}", err), } } pub fn get_protocol_error(result: Result) -> ProtocolError { match result { Ok(_) => panic!("expected to get ProtocolError, got valid result"), - Err(e) => e + Err(e) => e, } } } diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs index 8e6b19bcf7c..1b77b2183cc 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_fee.rs @@ -399,7 +399,7 @@ mod test { ProtocolError::InvalidStateTransitionTypeError(err) => { assert_eq!(err.transition_type(), 6); } - _ => panic!("expected InvalidStateTransitionTypeError, got {}", result) + _ => panic!("expected InvalidStateTransitionTypeError, got {}", result), } } } diff --git a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs index b16b2e77280..cb414c28c99 100644 --- a/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs +++ b/packages/rs-dpp/src/state_transition/validation/validate_state_transition_identity_signature.rs @@ -3,7 +3,10 @@ use std::{collections::HashSet, convert::TryInto}; use anyhow::Context; use lazy_static::lazy_static; -use crate::consensus::signature::{IdentityNotFoundError, InvalidIdentityPublicKeyTypeError, MissingPublicKeyError, PublicKeyIsDisabledError, PublicKeySecurityLevelNotMetError}; +use crate::consensus::signature::{ + IdentityNotFoundError, InvalidIdentityPublicKeyTypeError, MissingPublicKeyError, + PublicKeyIsDisabledError, PublicKeySecurityLevelNotMetError, +}; use crate::{ consensus::{signature::SignatureError, ConsensusError}, identity::KeyType, @@ -142,6 +145,7 @@ fn convert_to_consensus_signature_error( #[cfg(test)] mod test { use super::*; + use crate::consensus::signature::InvalidSignaturePublicKeySecurityLevelError; use crate::state_transition::errors::{PublicKeyMismatchError, WrongPublicKeyPurposeError}; use crate::{ document::DocumentsBatchTransition, @@ -159,7 +163,6 @@ mod test { NativeBlsModule, }; use serde::{Deserialize, Serialize}; - use crate::consensus::signature::InvalidSignaturePublicKeySecurityLevelError; #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] @@ -346,8 +349,8 @@ mod test { match signature_error { SignatureError::IdentityNotFoundError(err) => { assert_eq!(err.identity_id(), identity.get_id().clone()) - }, - error => panic!("expected IdentityNotFoundError, got {}", error) + } + error => panic!("expected IdentityNotFoundError, got {}", error), } } @@ -379,8 +382,8 @@ mod test { match signature_error { SignatureError::MissingPublicKeyError(err) => { assert_eq!(err.public_key_id(), 12332) - }, - error => panic!("expected MissingPublicKeyError, got {}", error) + } + error => panic!("expected MissingPublicKeyError, got {}", error), } } diff --git a/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs b/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs index fa40a06276a..987cf117f54 100644 --- a/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs +++ b/packages/rs-dpp/src/state_transition/validation/validator_transaction_basic.rs @@ -196,8 +196,11 @@ mod test { match basic_error { BasicError::InvalidStateTransitionTypeError(err) => { assert_eq!(err.transition_type(), 123) - }, - _ => panic!("Expected InvalidStateTransitionTypeError, got {}", basic_error) + } + _ => panic!( + "Expected InvalidStateTransitionTypeError, got {}", + basic_error + ), } } @@ -226,8 +229,11 @@ mod test { match basic_error { BasicError::InvalidStateTransitionTypeError(err) => { assert_eq!(err.transition_type(), 123) - }, - _ => panic!("Expected InvalidStateTransitionTypeError, got {}", basic_error) + } + _ => panic!( + "Expected InvalidStateTransitionTypeError, got {}", + basic_error + ), } } @@ -264,8 +270,11 @@ mod test { BasicError::StateTransitionMaxSizeExceededError(err) => { assert_eq!(err.actual_size_kbytes(), 53); assert_eq!(err.max_size_kbytes(), 16); - }, - _ => panic!("Expected StateTransitionMaxSizeExceededError, got {}", basic_error) + } + _ => panic!( + "Expected StateTransitionMaxSizeExceededError, got {}", + basic_error + ), } } diff --git a/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic_spec.rs b/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic_spec.rs index 10aebdf9ceb..1430e206468 100644 --- a/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic_spec.rs +++ b/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic_spec.rs @@ -360,8 +360,11 @@ async fn should_have_existing_documents_schema_backward_compatible() { BasicError::IncompatibleDataContractSchemaError(err) => { assert_eq!(err.operation(), "add".to_string()); assert_eq!(err.field_path(), "/required/1".to_string()); - }, - _ => panic!("Expected IncompatibleDataContractSchemaError, got {}", basic_error) + } + _ => panic!( + "Expected IncompatibleDataContractSchemaError, got {}", + basic_error + ), } } diff --git a/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible_spec.rs b/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible_spec.rs index 58fa4aa6081..f1ec29de4d4 100644 --- a/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible_spec.rs +++ b/packages/rs-dpp/src/tests/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_indices_are_backward_compatible_spec.rs @@ -101,8 +101,11 @@ fn should_return_invalid_result_if_some_of_unique_indices_have_changed() { BasicError::DataContractUniqueIndicesChangedError(err) => { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.index_name(), "index1".to_string()); - }, - _ => panic!("Expected DataContractUniqueIndicesChangedError, got {}", basic_error) + } + _ => panic!( + "Expected DataContractUniqueIndicesChangedError, got {}", + basic_error + ), } } @@ -132,8 +135,11 @@ fn should_return_invalid_result_if_non_unique_index_update_failed_due_to_changed BasicError::DataContractInvalidIndexDefinitionUpdateError(err) => { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.index_name(), "index3".to_string()); - }, - _ => panic!("Expected DataContractInvalidIndexDefinitionUpdateError, got {}", basic_error) + } + _ => panic!( + "Expected DataContractInvalidIndexDefinitionUpdateError, got {}", + basic_error + ), } } @@ -163,8 +169,11 @@ fn should_return_invalid_result_if_already_indexed_properties_are_added_to_exist BasicError::DataContractInvalidIndexDefinitionUpdateError(err) => { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.index_name(), "index3".to_string()); - }, - _ => panic!("Expected DataContractInvalidIndexDefinitionUpdateError, got {}", basic_error) + } + _ => panic!( + "Expected DataContractInvalidIndexDefinitionUpdateError, got {}", + basic_error + ), } } @@ -204,8 +213,11 @@ fn should_return_invalid_result_if_one_of_new_indices_contains_old_properties_in BasicError::DataContractInvalidIndexDefinitionUpdateError(err) => { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.index_name(), "index_other".to_string()); - }, - _ => panic!("Expected DataContractInvalidIndexDefinitionUpdateError, got {}", basic_error) + } + _ => panic!( + "Expected DataContractInvalidIndexDefinitionUpdateError, got {}", + basic_error + ), } } @@ -242,8 +254,11 @@ fn should_return_invalid_result_if_one_of_new_indices_is_unique() { BasicError::DataContractHaveNewUniqueIndexError(err) => { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.index_name(), "index_other".to_string()); - }, - _ => panic!("Expected DataContractHaveNewUniqueIndexError, got {}", basic_error) + } + _ => panic!( + "Expected DataContractHaveNewUniqueIndexError, got {}", + basic_error + ), } } @@ -308,7 +323,10 @@ fn should_return_invalid_result_if_non_unique_index_added_for_non_indexed_proper BasicError::DataContractInvalidIndexDefinitionUpdateError(err) => { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.index_name(), "index1337".to_string()); - }, - _ => panic!("Expected DataContractInvalidIndexDefinitionUpdateError, got {}", basic_error) + } + _ => panic!( + "Expected DataContractInvalidIndexDefinitionUpdateError, got {}", + basic_error + ), } } diff --git a/packages/rs-dpp/src/tests/data_contract/validation/data_contract_validator_spec.rs b/packages/rs-dpp/src/tests/data_contract/validation/data_contract_validator_spec.rs index 6c0278a2aed..d8c7c211e78 100644 --- a/packages/rs-dpp/src/tests/data_contract/validation/data_contract_validator_spec.rs +++ b/packages/rs-dpp/src/tests/data_contract/validation/data_contract_validator_spec.rs @@ -1349,10 +1349,19 @@ mod documents { match pattern_error { ConsensusError::IncompatibleRe2PatternError(err) => { - assert_eq!(err.path(),"/documents/indexedDocument/properties/something".to_string()); - assert_eq!(err.pattern(),"^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string()); - }, - _ => panic!("Expected IncompatibleRe2PatternError, got {:?}", pattern_error) + assert_eq!( + err.path(), + "/documents/indexedDocument/properties/something".to_string() + ); + assert_eq!( + err.pattern(), + "^((?!-|_)[a-zA-Z0-9-_]{0,62}[a-zA-Z0-9])$".to_string() + ); + } + _ => panic!( + "Expected IncompatibleRe2PatternError, got {:?}", + pattern_error + ), } } } @@ -1604,8 +1613,8 @@ mod indices { match index_error { IndexError::DuplicateIndexError(err) => { assert_eq!(err.document_type(), "indexedDocument".to_string()); - }, - _ => panic!("Expected DuplicateIndexError, got {}", index_error) + } + _ => panic!("Expected DuplicateIndexError, got {}", index_error), } } @@ -1642,8 +1651,8 @@ mod indices { BasicError::DuplicateIndexNameError(err) => { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.duplicate_index_name(), "index1".to_string()) - }, - _ => panic!("Expected DuplicateIndexNameError, got {}", basic_error) + } + _ => panic!("Expected DuplicateIndexNameError, got {}", basic_error), } } @@ -1964,8 +1973,11 @@ mod indices { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.index_limit(), 3); // assert_eq!(err.property_type(), "array".to_string()); - }, - _ => panic!("Expected UniqueIndicesLimitReachedError, got {}", index_error) + } + _ => panic!( + "Expected UniqueIndicesLimitReachedError, got {}", + index_error + ), } } @@ -2002,8 +2014,11 @@ mod indices { IndexError::SystemPropertyIndexAlreadyPresentError(err) => { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.property_name(), "$id".to_string()); - }, - _ => panic!("Expected SystemPropertyIndexAlreadyPresentError, got {}", index_error) + } + _ => panic!( + "Expected SystemPropertyIndexAlreadyPresentError, got {}", + index_error + ), } } @@ -2034,8 +2049,8 @@ mod indices { IndexError::UndefinedIndexPropertyError(err) => { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.property_name(), "missingProperty".to_string()); - }, - _ => panic!("Expected UndefinedIndexPropertyError, got {}", index_error) + } + _ => panic!("Expected UndefinedIndexPropertyError, got {}", index_error), } } @@ -2082,8 +2097,11 @@ mod indices { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.property_name(), "objectProperty".to_string()); assert_eq!(err.property_type(), "object".to_string()); - }, - _ => panic!("Expected InvalidIndexPropertyTypeError, got {}", index_error) + } + _ => panic!( + "Expected InvalidIndexPropertyTypeError, got {}", + index_error + ), } } @@ -2134,8 +2152,11 @@ mod indices { assert_eq!(err.document_type(), "indexedArray".to_string()); assert_eq!(err.property_name(), "mentions".to_string()); assert_eq!(err.property_type(), "array".to_string()); - }, - _ => panic!("Expected InvalidIndexPropertyTypeError, got {}", index_error) + } + _ => panic!( + "Expected InvalidIndexPropertyTypeError, got {}", + index_error + ), } } @@ -2341,8 +2362,11 @@ mod indices { assert_eq!(err.document_type(), "indexedDocument".to_string()); assert_eq!(err.property_name(), "arrayProperty"); assert_eq!(err.property_type(), "array".to_string()); - }, - _ => panic!("Expected InvalidIndexPropertyTypeError, got {}", index_error) + } + _ => panic!( + "Expected InvalidIndexPropertyTypeError, got {}", + index_error + ), } } @@ -2370,9 +2394,12 @@ mod indices { assert_eq!(1010, index_error.get_code()); match index_error { IndexError::InvalidCompoundIndexError(err) => { - assert_eq!(err.document_type(), "optionalUniqueIndexedDocument".to_string()); - }, - _ => panic!("Expected InvalidCompoundIndexError, got {}", index_error) + assert_eq!( + err.document_type(), + "optionalUniqueIndexedDocument".to_string() + ); + } + _ => panic!("Expected InvalidCompoundIndexError, got {}", index_error), } } @@ -2464,8 +2491,8 @@ mod indices { match index_error { IndexError::UndefinedIndexPropertyError(err) => { assert_eq!(err.property_name(), invalid_name.to_string()); - }, - _ => panic!("Expected UndefinedIndexPropertyError, got {}", index_error) + } + _ => panic!("Expected UndefinedIndexPropertyError, got {}", index_error), } } } @@ -2744,9 +2771,12 @@ fn should_return_invalid_result_with_circular_ref_pointer() { assert_eq!(1014, validation_error.get_code()); match basic_error { BasicError::InvalidJsonSchemaRefError(err) => { - assert_eq!(err.ref_error(), "the ref '#/$defs/object' contains cycles".to_string()); - }, - _ => panic!("Expected InvalidJsonSchemaRefError, got {}", basic_error) + assert_eq!( + err.ref_error(), + "the ref '#/$defs/object' contains cycles".to_string() + ); + } + _ => panic!("Expected InvalidJsonSchemaRefError, got {}", basic_error), } } @@ -2778,8 +2808,11 @@ fn should_return_invalid_result_if_indexed_string_property_missing_max_length_co assert_eq!(err.property_name(), "firstName".to_string()); assert_eq!(err.constraint_name(), "maxLength".to_string()); assert_eq!(err.reason(), "should be less or equal than 63".to_string()); - }, - _ => panic!("Expected InvalidIndexedPropertyConstraintError, got {}", index_error) + } + _ => panic!( + "Expected InvalidIndexedPropertyConstraintError, got {}", + index_error + ), } } @@ -2879,8 +2912,11 @@ mod indexed_array { assert_eq!(err.property_name(), "byteArrayField".to_string()); assert_eq!(err.constraint_name(), "maxItems".to_string()); assert_eq!(err.reason(), "should be less or equal 255".to_string()); - }, - _ => panic!("Expected InvalidIndexedPropertyConstraintError, got {}", index_error) + } + _ => panic!( + "Expected InvalidIndexedPropertyConstraintError, got {}", + index_error + ), } } @@ -2910,8 +2946,11 @@ mod indexed_array { assert_eq!(err.property_name(), "byteArrayField".to_string()); assert_eq!(err.constraint_name(), "maxItems".to_string()); assert_eq!(err.reason(), "should be less or equal 255".to_string()); - }, - _ => panic!("Expected InvalidIndexedPropertyConstraintError, got {}", index_error) + } + _ => panic!( + "Expected InvalidIndexedPropertyConstraintError, got {}", + index_error + ), } } } diff --git a/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_documents_batch_transition_state_spec.rs b/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_documents_batch_transition_state_spec.rs index 8145707f90e..acb4d6f3648 100644 --- a/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_documents_batch_transition_state_spec.rs +++ b/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_documents_batch_transition_state_spec.rs @@ -142,8 +142,8 @@ async fn should_throw_error_if_data_contract_was_not_found() { match error { ProtocolError::DataContractNotPresentError(err) => { assert_eq!(err.data_contract_id(), data_contract.id); - }, - _ => panic!("Expected DataContractNotPresentError, got {}", error) + } + _ => panic!("Expected DataContractNotPresentError, got {}", error), } } diff --git a/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_partial_compound_indices_spec.rs b/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_partial_compound_indices_spec.rs index f4cf48cb334..6aaba2771ea 100644 --- a/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_partial_compound_indices_spec.rs +++ b/packages/rs-dpp/src/tests/document/state_transitions/validation/validate_partial_compound_indices_spec.rs @@ -61,10 +61,23 @@ fn should_return_invalid_result_if_compound_index_contains_not_all_fields() { assert_eq!(1021, result.errors[0].code()); match basic_error { BasicError::InconsistentCompoundIndexDataError(err) => { - assert_eq!(err.document_type(), "optionalUniqueIndexedDocument".to_string()); - assert_eq!(err.index_properties(), vec!["$ownerId".to_string(), "firstName".to_string(), "lastName".to_string()]); - }, - _ => panic!("Expected InconsistentCompoundIndexDataError, got {}", basic_error) + assert_eq!( + err.document_type(), + "optionalUniqueIndexedDocument".to_string() + ); + assert_eq!( + err.index_properties(), + vec![ + "$ownerId".to_string(), + "firstName".to_string(), + "lastName".to_string() + ] + ); + } + _ => panic!( + "Expected InconsistentCompoundIndexDataError, got {}", + basic_error + ), } } diff --git a/packages/rs-dpp/src/tests/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_state_spec.rs b/packages/rs-dpp/src/tests/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_state_spec.rs index 9236ba2a446..ebce1b8479b 100644 --- a/packages/rs-dpp/src/tests/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_state_spec.rs +++ b/packages/rs-dpp/src/tests/identity/state_transition/identity_credit_withdrawal_transition/validation/state/validate_identity_credit_withdrawal_state_spec.rs @@ -33,8 +33,8 @@ mod validate_identity_credit_withdrawal_transition_state_factory { use anyhow::Error; use crate::assert_consensus_errors; - use crate::consensus::ConsensusError; use crate::consensus::signature::SignatureError; + use crate::consensus::ConsensusError; use crate::prelude::{Identifier, Identity}; use super::*; @@ -63,15 +63,13 @@ mod validate_identity_credit_withdrawal_transition_state_factory { assert_eq!(error.code(), 2000); match error { - ConsensusError::SignatureError(err) => { - match err { - SignatureError::IdentityNotFoundError(e) => { - assert_eq!(e.identity_id(), Identifier::default()); - }, - e => panic!("expected IdentityNotFoundError, got {}", e) + ConsensusError::SignatureError(err) => match err { + SignatureError::IdentityNotFoundError(e) => { + assert_eq!(e.identity_id(), Identifier::default()); } + e => panic!("expected IdentityNotFoundError, got {}", e), }, - e => panic!("expected IdentityNotFoundError, got {:?}", e) + e => panic!("expected IdentityNotFoundError, got {:?}", e), } } From bb8b8522b11325b89ea1dc047ab78f9f96b9fa80 Mon Sep 17 00:00:00 2001 From: shuplenkov Date: Tue, 7 Mar 2023 20:45:20 +0700 Subject: [PATCH 10/11] chore: merge with 0.24 --- .../basic/validate_data_contract_update_transition_basic.rs | 4 ++-- packages/wasm-dpp/src/errors/from.rs | 5 +++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs b/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs index 5d680dd9c87..87c6430feef 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs @@ -26,8 +26,8 @@ use serde_json::{json, Value as JsonValue}; use std::sync::Arc; use crate::{ consensus::ConsensusError, - state_transition::state_transition_execution_context::StateTransitionExecutionContext, }; +use crate::consensus::basic::decode::ProtocolVersionParsingError; use super::schema_compatibility_validator::validate_schema_compatibility; use super::schema_compatibility_validator::DiffVAlidatorError; @@ -87,7 +87,7 @@ where Ok(v) => v, Err(parsing_error) => { return Ok(SimpleValidationResult::new(Some(vec![ - ConsensusError::ProtocolVersionParsingError { parsing_error }, + ConsensusError::ProtocolVersionParsingError(ProtocolVersionParsingError::new(parsing_error)), ]))) } }; diff --git a/packages/wasm-dpp/src/errors/from.rs b/packages/wasm-dpp/src/errors/from.rs index c913db2d259..99caa715899 100644 --- a/packages/wasm-dpp/src/errors/from.rs +++ b/packages/wasm-dpp/src/errors/from.rs @@ -1,4 +1,5 @@ use wasm_bindgen::JsValue; +use dpp::data_contract::errors::DataContractNotPresentError; use dpp::errors::ProtocolError; @@ -25,8 +26,8 @@ pub fn from_dpp_err(pe: ProtocolError) -> JsValue { ) .into(), - ProtocolError::DataContractNotPresentError { data_contract_id } => { - DataContractNotPresentNotConsensusErrorWasm::new(data_contract_id).into() + ProtocolError::DataContractNotPresentError(err) => { + DataContractNotPresentNotConsensusErrorWasm::new(err.data_contract_id()).into() } _ => JsValue::from_str(&format!("Error conversion not implemented: {pe:#}",)), } From 610c54de2d63f48f0953e12bd9b4b87a524906a4 Mon Sep 17 00:00:00 2001 From: shuplenkov Date: Tue, 7 Mar 2023 21:01:04 +0700 Subject: [PATCH 11/11] chore: cargo fmt --- .../validate_data_contract_update_transition_basic.rs | 10 +++++----- packages/wasm-dpp/src/errors/from.rs | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs b/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs index 87c6430feef..e7a37e4b683 100644 --- a/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs +++ b/packages/rs-dpp/src/data_contract/state_transition/data_contract_update_transition/validation/basic/validate_data_contract_update_transition_basic.rs @@ -3,7 +3,9 @@ use std::convert::{TryFrom, TryInto}; 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, @@ -24,10 +26,6 @@ use json_patch::PatchOperation; use lazy_static::lazy_static; use serde_json::{json, Value as JsonValue}; use std::sync::Arc; -use crate::{ - consensus::ConsensusError, -}; -use crate::consensus::basic::decode::ProtocolVersionParsingError; use super::schema_compatibility_validator::validate_schema_compatibility; use super::schema_compatibility_validator::DiffVAlidatorError; @@ -87,7 +85,9 @@ where Ok(v) => v, Err(parsing_error) => { return Ok(SimpleValidationResult::new(Some(vec![ - ConsensusError::ProtocolVersionParsingError(ProtocolVersionParsingError::new(parsing_error)), + ConsensusError::ProtocolVersionParsingError(ProtocolVersionParsingError::new( + parsing_error, + )), ]))) } }; diff --git a/packages/wasm-dpp/src/errors/from.rs b/packages/wasm-dpp/src/errors/from.rs index 99caa715899..46ccf56f41e 100644 --- a/packages/wasm-dpp/src/errors/from.rs +++ b/packages/wasm-dpp/src/errors/from.rs @@ -1,5 +1,5 @@ -use wasm_bindgen::JsValue; use dpp::data_contract::errors::DataContractNotPresentError; +use wasm_bindgen::JsValue; use dpp::errors::ProtocolError;