From dd642c4cfe7bef65ca844f1a6edb138fbc9ed58c Mon Sep 17 00:00:00 2001 From: pauldelucia Date: Tue, 8 Apr 2025 19:39:12 +0700 Subject: [PATCH 1/6] feat: contract descriptions --- .../rs-dpp/src/data_contract/accessors/mod.rs | 21 ++ .../src/data_contract/accessors/v1/mod.rs | 9 + .../token_configuration/v0/mod.rs | 3 + .../serialized_version/v1/mod.rs | 7 + .../src/data_contract/v1/accessors/mod.rs | 15 ++ .../src/data_contract/v1/data_contract.rs | 3 + .../src/data_contract/v1/serialization/mod.rs | 3 + .../batch/tests/document/creation.rs | 4 +- .../contract/insert/add_description/mod.rs | 134 +++++++++++++ .../contract/insert/add_description/v0/mod.rs | 180 ++++++++++++++++++ .../insert/add_new_keywords/v0/mod.rs | 2 +- .../contract/insert/insert_contract/v1/mod.rs | 12 ++ .../rs-drive/src/drive/contract/insert/mod.rs | 2 + .../group/prove/prove_action_infos/v0/mod.rs | 2 + .../prove/prove_action_signers/v0/mod.rs | 3 + .../group/prove/prove_group_info/v0/mod.rs | 2 + .../group/prove/prove_group_infos/v0/mod.rs | 2 + .../prove_identities_token_balances/v0/mod.rs | 3 + .../prove_identity_token_balances/v0/mod.rs | 3 + .../prove_identities_token_infos/v0/mod.rs | 3 + .../info/prove_identity_token_infos/v0/mod.rs | 2 + .../status/prove_token_statuses/v0/mod.rs | 1 + .../v0/mod.rs | 2 + .../schema/v1/search-contract-documents.json | 48 ++++- packages/search-contract/src/v1/mod.rs | 12 +- 25 files changed, 471 insertions(+), 7 deletions(-) create mode 100644 packages/rs-drive/src/drive/contract/insert/add_description/mod.rs create mode 100644 packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs diff --git a/packages/rs-dpp/src/data_contract/accessors/mod.rs b/packages/rs-dpp/src/data_contract/accessors/mod.rs index 846b6752282..8557931c81e 100644 --- a/packages/rs-dpp/src/data_contract/accessors/mod.rs +++ b/packages/rs-dpp/src/data_contract/accessors/mod.rs @@ -284,6 +284,20 @@ impl DataContractV1Getters for DataContract { } } + fn description(&self) -> Option<&String> { + match self { + DataContract::V0(_) => None, + DataContract::V1(v1) => v1.description.as_ref(), + } + } + + fn description_mut(&mut self) -> Option<&mut String> { + match self { + DataContract::V0(_) => None, + DataContract::V1(v1) => v1.description.as_mut(), + } + } + /// Returns the timestamp in milliseconds when the contract was created. fn created_at(&self) -> Option { match self { @@ -422,4 +436,11 @@ impl DataContractV1Setters for DataContract { v1.keywords = keywords; } } + + /// Sets the description for the contract. + fn set_description(&mut self, description: Option) { + if let DataContract::V1(v1) = self { + v1.description = description; + } + } } diff --git a/packages/rs-dpp/src/data_contract/accessors/v1/mod.rs b/packages/rs-dpp/src/data_contract/accessors/v1/mod.rs index b798c6e1f53..82a32be1b5f 100644 --- a/packages/rs-dpp/src/data_contract/accessors/v1/mod.rs +++ b/packages/rs-dpp/src/data_contract/accessors/v1/mod.rs @@ -69,6 +69,12 @@ pub trait DataContractV1Getters: DataContractV0Getters { /// Returns a mutable reference to the keywords for the contract. fn keywords_mut(&mut self) -> Option<&mut Vec>; + + /// Returns the description for the contract. + fn description(&self) -> Option<&String>; + + /// Returns a mutable reference to the description for the contract. + fn description_mut(&mut self) -> Option<&mut String>; } pub trait DataContractV1Setters: DataContractV0Setters { @@ -104,4 +110,7 @@ pub trait DataContractV1Setters: DataContractV0Setters { /// Sets the keywords for the contract. fn set_keywords(&mut self, keywords: Vec); + + /// Sets the description for the contract. + fn set_description(&mut self, description: Option); } diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/mod.rs index 62cb3ba138b..4f56f36926f 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/mod.rs @@ -57,6 +57,8 @@ pub struct TokenConfigurationV0 { pub main_control_group: Option, #[serde(default)] pub main_control_group_can_be_modified: AuthorizedActionTakers, + #[serde(default)] + pub description: Option, } // Default function for `keeps_history` @@ -265,6 +267,7 @@ impl TokenConfigurationV0 { .into(), main_control_group: None, main_control_group_can_be_modified: AuthorizedActionTakers::NoOne, + description: None, } } diff --git a/packages/rs-dpp/src/data_contract/serialized_version/v1/mod.rs b/packages/rs-dpp/src/data_contract/serialized_version/v1/mod.rs index b79927dd307..c9144dfa7c7 100644 --- a/packages/rs-dpp/src/data_contract/serialized_version/v1/mod.rs +++ b/packages/rs-dpp/src/data_contract/serialized_version/v1/mod.rs @@ -63,6 +63,10 @@ pub struct DataContractInSerializationFormatV1 { /// The contract's keywords for searching #[serde(default)] pub keywords: Vec, + + /// The contract's description + #[serde(default)] + pub description: Option, } fn deserialize_u16_group_map<'de, D>( @@ -129,6 +133,7 @@ impl From for DataContractInSerializationFormatV1 { groups: Default::default(), tokens: Default::default(), keywords: Default::default(), + description: None, } } DataContract::V1(v1) => { @@ -148,6 +153,7 @@ impl From for DataContractInSerializationFormatV1 { groups, tokens, keywords, + description, } = v1; DataContractInSerializationFormatV1 { @@ -169,6 +175,7 @@ impl From for DataContractInSerializationFormatV1 { groups, tokens, keywords, + description, } } } diff --git a/packages/rs-dpp/src/data_contract/v1/accessors/mod.rs b/packages/rs-dpp/src/data_contract/v1/accessors/mod.rs index f5991b3d72f..72bdb5069c4 100644 --- a/packages/rs-dpp/src/data_contract/v1/accessors/mod.rs +++ b/packages/rs-dpp/src/data_contract/v1/accessors/mod.rs @@ -234,6 +234,16 @@ impl DataContractV1Getters for DataContractV1 { fn keywords_mut(&mut self) -> Option<&mut Vec> { Some(&mut self.keywords) } + + /// Returns the description of the contract. + fn description(&self) -> Option<&String> { + self.description.as_ref() + } + + /// Returns a mutable reference to the description of the contract. + fn description_mut(&mut self) -> Option<&mut String> { + self.description.as_mut() + } } impl DataContractV1Setters for DataContractV1 { @@ -287,4 +297,9 @@ impl DataContractV1Setters for DataContractV1 { fn set_keywords(&mut self, keywords: Vec) { self.keywords = keywords; } + + /// Sets the description for the contract. + fn set_description(&mut self, description: Option) { + self.description = description; + } } diff --git a/packages/rs-dpp/src/data_contract/v1/data_contract.rs b/packages/rs-dpp/src/data_contract/v1/data_contract.rs index 19d2e7b9325..37318e70ca5 100644 --- a/packages/rs-dpp/src/data_contract/v1/data_contract.rs +++ b/packages/rs-dpp/src/data_contract/v1/data_contract.rs @@ -110,4 +110,7 @@ pub struct DataContractV1 { /// The contract's keywords for searching pub keywords: Vec, + + /// The contract's description + pub description: Option, } diff --git a/packages/rs-dpp/src/data_contract/v1/serialization/mod.rs b/packages/rs-dpp/src/data_contract/v1/serialization/mod.rs index 05e40710b7b..332cf574d2a 100644 --- a/packages/rs-dpp/src/data_contract/v1/serialization/mod.rs +++ b/packages/rs-dpp/src/data_contract/v1/serialization/mod.rs @@ -112,6 +112,7 @@ impl DataContractV1 { groups: Default::default(), tokens: Default::default(), keywords: Default::default(), + description: None, }; Ok(data_contract) @@ -139,6 +140,7 @@ impl DataContractV1 { groups, tokens, keywords, + description, } = data_contract_data; let document_types = DocumentType::create_document_types_from_document_schemas( @@ -168,6 +170,7 @@ impl DataContractV1 { groups, tokens, keywords, + description, }; Ok(data_contract) diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/creation.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/creation.rs index 422bd9c960b..a48f9eb433e 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/creation.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/creation.rs @@ -2504,8 +2504,8 @@ mod creation_tests { // Get the document type from the search contract. let doc_type = search_contract - .document_type_for_name("contract") - .expect("expected to find 'contract' in Search contract"); + .document_type_for_name("contractKeywords") + .expect("expected to find 'contractKeywords' in Search contract"); // Verify that the document type has the restrictive creation mode assert_eq!( diff --git a/packages/rs-drive/src/drive/contract/insert/add_description/mod.rs b/packages/rs-drive/src/drive/contract/insert/add_description/mod.rs new file mode 100644 index 00000000000..9931b56defb --- /dev/null +++ b/packages/rs-drive/src/drive/contract/insert/add_description/mod.rs @@ -0,0 +1,134 @@ +use crate::drive::Drive; +use crate::error::drive::DriveError; +use crate::error::Error; +use crate::fees::op::LowLevelDriveOperation; +use dpp::block::block_info::BlockInfo; +use dpp::fee::fee_result::FeeResult; +use dpp::version::PlatformVersion; + +use dpp::prelude::Identifier; +use grovedb::batch::KeyInfoPath; +use grovedb::{EstimatedLayerInformation, TransactionArg}; +use std::collections::HashMap; + +mod v0; + +impl Drive { + /// Adds contract description to the state. + pub fn add_new_contract_description( + &self, + contract_id: Identifier, + owner_id: Identifier, + description: &String, + block_info: &BlockInfo, + apply: bool, + transaction: TransactionArg, + platform_version: &PlatformVersion, + ) -> Result { + match platform_version + .drive + .methods + .contract + .insert + .insert_contract + { + 0 => Err(Error::Drive(DriveError::NotSupported( + "Contract descriptions are not supported in this version", + ))), + 1 => self.add_new_contract_description_v0( + contract_id, + owner_id, + description, + block_info, + apply, + transaction, + platform_version, + ), + version => Err(Error::Drive(DriveError::UnknownVersionMismatch { + method: "add_new_contract_description".to_string(), + known_versions: vec![0, 1], + received: version, + })), + } + } + + /// Adds contract description creation operations to drive operations + pub fn add_new_contract_description_add_to_operations( + &self, + contract_id: Identifier, + owner_id: Identifier, + description: &String, + block_info: &BlockInfo, + apply: bool, + transaction: TransactionArg, + drive_operations: &mut Vec, + platform_version: &PlatformVersion, + ) -> Result<(), Error> { + match platform_version + .drive + .methods + .contract + .insert + .insert_contract + { + 0 => Err(Error::Drive(DriveError::NotSupported( + "Contract descriptions are not supported in this version", + ))), + 1 => self.add_new_contract_description_add_to_operations_v0( + contract_id, + owner_id, + description, + block_info, + apply, + transaction, + drive_operations, + platform_version, + ), + version => Err(Error::Drive(DriveError::UnknownVersionMismatch { + method: "add_new_contract_description_add_to_operations".to_string(), + known_versions: vec![0, 1], + received: version, + })), + } + } + + /// The operations needed to create a description + pub fn add_new_contract_description_operations( + &self, + contract_id: Identifier, + owner_id: Identifier, + description: &String, + block_info: &BlockInfo, + estimated_costs_only_with_layer_info: &mut Option< + HashMap, + >, + transaction: TransactionArg, + platform_version: &PlatformVersion, + ) -> Result, Error> { + match platform_version + .drive + .methods + .contract + .insert + .insert_contract + { + 0 => Err(Error::Drive(DriveError::NotSupported( + "Contract descriptions are not supported in this version", + ))), + 1 => self.add_new_contract_description_operations_v0( + contract_id, + owner_id, + description, + block_info, + estimated_costs_only_with_layer_info, + transaction, + platform_version, + ), + version => Err(Error::Drive(DriveError::UnknownVersionMismatch { + method: "add_new_contract_description_operations".to_string(), + known_versions: vec![0, 1], + received: version, + })), + } + } +} diff --git a/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs b/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs new file mode 100644 index 00000000000..b2e64ac3bfc --- /dev/null +++ b/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs @@ -0,0 +1,180 @@ +use crate::drive::Drive; +use crate::error::Error; +use crate::fees::op::LowLevelDriveOperation; +use crate::util::object_size_info::DocumentInfo::DocumentOwnedInfo; +use crate::util::object_size_info::{DocumentAndContractInfo, OwnedDocumentInfo}; +use dpp::block::block_info::BlockInfo; +use dpp::data_contract::accessors::v0::DataContractV0Getters; +use dpp::document::{Document, DocumentV0}; +use dpp::fee::fee_result::FeeResult; +use dpp::identifier::Identifier; +use grovedb::batch::KeyInfoPath; +use grovedb::{EstimatedLayerInformation, TransactionArg}; +use platform_version::version::PlatformVersion; +use std::collections::{BTreeMap, HashMap}; + +impl Drive { + /// Adds a contract description by inserting a new description subtree structure to the `Identities` subtree. + pub(super) fn add_new_contract_description_v0( + &self, + contract_id: Identifier, + owner_id: Identifier, + description: &String, + block_info: &BlockInfo, + apply: bool, + transaction: TransactionArg, + platform_version: &PlatformVersion, + ) -> Result { + let mut drive_operations: Vec = vec![]; + self.add_new_contract_description_add_to_operations_v0( + contract_id, + owner_id, + description, + block_info, + apply, + transaction, + &mut drive_operations, + platform_version, + )?; + let fees = Drive::calculate_fee( + None, + Some(drive_operations), + &block_info.epoch, + self.config.epochs_per_era, + platform_version, + None, + )?; + Ok(fees) + } + + /// Adds contract description creation operations to drive operations + pub(super) fn add_new_contract_description_add_to_operations_v0( + &self, + contract_id: Identifier, + owner_id: Identifier, + description: &String, + block_info: &BlockInfo, + apply: bool, + transaction: TransactionArg, + drive_operations: &mut Vec, + platform_version: &PlatformVersion, + ) -> Result<(), Error> { + let mut estimated_costs_only_with_layer_info = if apply { + None::> + } else { + Some(HashMap::new()) + }; + + let batch_operations = self.add_new_contract_description_operations( + contract_id, + owner_id, + description, + block_info, + &mut estimated_costs_only_with_layer_info, + transaction, + platform_version, + )?; + + self.apply_batch_low_level_drive_operations( + estimated_costs_only_with_layer_info, + transaction, + batch_operations, + drive_operations, + &platform_version.drive, + ) + } + + /// The operations needed to create a description + pub(super) fn add_new_contract_description_operations_v0( + &self, + contract_id: Identifier, + owner_id: Identifier, + description: &String, + block_info: &BlockInfo, + estimated_costs_only_with_layer_info: &mut Option< + HashMap, + >, + transaction: TransactionArg, + platform_version: &PlatformVersion, + ) -> Result, Error> { + let contract = self.cache.system_data_contracts.load_search(); + let document_type = contract.document_type_for_name("longDescription")?; + + let mut operations: Vec = vec![]; + + let document = self.build_contract_long_description_document_owned_v0( + contract_id, + owner_id, + description, + block_info, + )?; + + let ops = self.add_document_for_contract_operations( + DocumentAndContractInfo { + owned_document_info: OwnedDocumentInfo { + document_info: DocumentOwnedInfo((document, None)), + owner_id: Some(owner_id.to_buffer()), + }, + contract: &contract, + document_type, + }, + true, + block_info, + &mut None, + estimated_costs_only_with_layer_info, + transaction, + platform_version, + )?; + + operations.extend(ops); + + Ok(operations) + } + + pub(super) fn build_contract_long_description_document_owned_v0( + &self, + contract_id: Identifier, + owner_id: Identifier, + description: &String, + block_info: &BlockInfo, + ) -> Result { + // Fetch the identity nonce for the owner or use 1 + let owner_nonce = + match self.fetch_identity_nonce(owner_id.into(), true, None, PlatformVersion::latest()) + { + Ok(maybe_nonce) => maybe_nonce.unwrap_or(1), + Err(e) => return Err(e), + }; + + let document_id = Document::generate_document_id_v0( + &contract_id, + &owner_id, + "longDescription", + &owner_nonce.to_be_bytes(), + ); + + let properties = BTreeMap::from([ + ("contractId".to_string(), contract_id.into()), + ("description".to_string(), description.into()), + ]); + + let document: Document = DocumentV0 { + id: document_id, + owner_id, + properties, + revision: None, + created_at: Some(block_info.time_ms), + updated_at: None, + transferred_at: None, + created_at_block_height: Some(block_info.height), + updated_at_block_height: None, + transferred_at_block_height: None, + created_at_core_block_height: None, + updated_at_core_block_height: None, + transferred_at_core_block_height: None, + } + .into(); + + Ok(document) + } +} diff --git a/packages/rs-drive/src/drive/contract/insert/add_new_keywords/v0/mod.rs b/packages/rs-drive/src/drive/contract/insert/add_new_keywords/v0/mod.rs index 57c16d09351..d7dcbcb9de2 100644 --- a/packages/rs-drive/src/drive/contract/insert/add_new_keywords/v0/mod.rs +++ b/packages/rs-drive/src/drive/contract/insert/add_new_keywords/v0/mod.rs @@ -98,7 +98,7 @@ impl Drive { platform_version: &PlatformVersion, ) -> Result, Error> { let contract = self.cache.system_data_contracts.load_search(); - let document_type = contract.document_type_for_name("contract")?; + let document_type = contract.document_type_for_name("contractKeywords")?; let mut operations: Vec = vec![]; diff --git a/packages/rs-drive/src/drive/contract/insert/insert_contract/v1/mod.rs b/packages/rs-drive/src/drive/contract/insert/insert_contract/v1/mod.rs index 59a30e76062..1ed48c28095 100644 --- a/packages/rs-drive/src/drive/contract/insert/insert_contract/v1/mod.rs +++ b/packages/rs-drive/src/drive/contract/insert/insert_contract/v1/mod.rs @@ -319,6 +319,18 @@ impl Drive { )?); } + if let Some(description) = contract.description() { + batch_operations.extend(self.add_new_contract_description_operations( + contract.id(), + contract.owner_id(), + description, + block_info, + estimated_costs_only_with_layer_info, + transaction, + platform_version, + )?); + } + Ok(batch_operations) } } diff --git a/packages/rs-drive/src/drive/contract/insert/mod.rs b/packages/rs-drive/src/drive/contract/insert/mod.rs index ea57897be76..5822e243119 100644 --- a/packages/rs-drive/src/drive/contract/insert/mod.rs +++ b/packages/rs-drive/src/drive/contract/insert/mod.rs @@ -1,4 +1,6 @@ mod add_contract_to_storage; #[allow(clippy::too_many_arguments)] +mod add_description; +#[allow(clippy::too_many_arguments)] mod add_new_keywords; mod insert_contract; diff --git a/packages/rs-drive/src/drive/group/prove/prove_action_infos/v0/mod.rs b/packages/rs-drive/src/drive/group/prove/prove_action_infos/v0/mod.rs index cd66e430e60..b909d49d093 100644 --- a/packages/rs-drive/src/drive/group/prove/prove_action_infos/v0/mod.rs +++ b/packages/rs-drive/src/drive/group/prove/prove_action_infos/v0/mod.rs @@ -154,6 +154,7 @@ mod tests { ), ]), keywords: Vec::new(), + description: None, }); drive @@ -382,6 +383,7 @@ mod tests { ), ]), keywords: Vec::new(), + description: None, }); drive diff --git a/packages/rs-drive/src/drive/group/prove/prove_action_signers/v0/mod.rs b/packages/rs-drive/src/drive/group/prove/prove_action_signers/v0/mod.rs index 5527662be18..c8602ac7dd4 100644 --- a/packages/rs-drive/src/drive/group/prove/prove_action_signers/v0/mod.rs +++ b/packages/rs-drive/src/drive/group/prove/prove_action_signers/v0/mod.rs @@ -149,6 +149,7 @@ mod tests { ), ]), keywords: Vec::new(), + description: None, }); drive @@ -318,6 +319,7 @@ mod tests { )]), tokens: BTreeMap::new(), keywords: Vec::new(), + description: None, }); drive @@ -412,6 +414,7 @@ mod tests { )]), tokens: BTreeMap::new(), keywords: Vec::new(), + description: None, }); drive diff --git a/packages/rs-drive/src/drive/group/prove/prove_group_info/v0/mod.rs b/packages/rs-drive/src/drive/group/prove/prove_group_info/v0/mod.rs index 93772e6c4b7..bab7fbe6036 100644 --- a/packages/rs-drive/src/drive/group/prove/prove_group_info/v0/mod.rs +++ b/packages/rs-drive/src/drive/group/prove/prove_group_info/v0/mod.rs @@ -107,6 +107,7 @@ mod tests { )]), tokens: Default::default(), keywords: Vec::new(), + description: None, }); let contract_id = contract.id(); @@ -177,6 +178,7 @@ mod tests { groups: Default::default(), tokens: Default::default(), keywords: Vec::new(), + description: None, }); let contract_id = contract.id(); diff --git a/packages/rs-drive/src/drive/group/prove/prove_group_infos/v0/mod.rs b/packages/rs-drive/src/drive/group/prove/prove_group_infos/v0/mod.rs index 3b53aae4b05..68b20c7b812 100644 --- a/packages/rs-drive/src/drive/group/prove/prove_group_infos/v0/mod.rs +++ b/packages/rs-drive/src/drive/group/prove/prove_group_infos/v0/mod.rs @@ -135,6 +135,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let contract_id = contract.id(); @@ -280,6 +281,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let contract_id = contract.id(); diff --git a/packages/rs-drive/src/drive/tokens/balance/prove_identities_token_balances/v0/mod.rs b/packages/rs-drive/src/drive/tokens/balance/prove_identities_token_balances/v0/mod.rs index 5138aa8845d..b2a7667a713 100644 --- a/packages/rs-drive/src/drive/tokens/balance/prove_identities_token_balances/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/balance/prove_identities_token_balances/v0/mod.rs @@ -98,6 +98,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); drive @@ -199,6 +200,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); drive @@ -291,6 +293,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); drive diff --git a/packages/rs-drive/src/drive/tokens/balance/prove_identity_token_balances/v0/mod.rs b/packages/rs-drive/src/drive/tokens/balance/prove_identity_token_balances/v0/mod.rs index d0069901b8e..354251fe180 100644 --- a/packages/rs-drive/src/drive/tokens/balance/prove_identity_token_balances/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/balance/prove_identity_token_balances/v0/mod.rs @@ -103,6 +103,7 @@ mod tests { ), ]), keywords: Vec::new(), + description: None, }); let token_id_1 = contract.token_id(0).expect("expected token at position 0"); @@ -264,6 +265,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); @@ -352,6 +354,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); diff --git a/packages/rs-drive/src/drive/tokens/info/prove_identities_token_infos/v0/mod.rs b/packages/rs-drive/src/drive/tokens/info/prove_identities_token_infos/v0/mod.rs index 43e1886b2f2..edc445f0df3 100644 --- a/packages/rs-drive/src/drive/tokens/info/prove_identities_token_infos/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/info/prove_identities_token_infos/v0/mod.rs @@ -98,6 +98,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); drive @@ -199,6 +200,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); drive @@ -289,6 +291,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); drive diff --git a/packages/rs-drive/src/drive/tokens/info/prove_identity_token_infos/v0/mod.rs b/packages/rs-drive/src/drive/tokens/info/prove_identity_token_infos/v0/mod.rs index 0a4ad4e064f..18e1a3e920f 100644 --- a/packages/rs-drive/src/drive/tokens/info/prove_identity_token_infos/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/info/prove_identity_token_infos/v0/mod.rs @@ -106,6 +106,7 @@ mod tests { ), ]), keywords: Vec::new(), + description: None, }); let token_id_1 = contract.token_id(0).expect("expected token at position 0"); @@ -254,6 +255,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); diff --git a/packages/rs-drive/src/drive/tokens/status/prove_token_statuses/v0/mod.rs b/packages/rs-drive/src/drive/tokens/status/prove_token_statuses/v0/mod.rs index b4cbfd2a850..c7f6d5afdc8 100644 --- a/packages/rs-drive/src/drive/tokens/status/prove_token_statuses/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/status/prove_token_statuses/v0/mod.rs @@ -95,6 +95,7 @@ mod tests { ), ]), keywords: Vec::new(), + description: None, }); let token_id_1 = contract.token_id(0).expect("expected token at position 0"); diff --git a/packages/rs-drive/src/drive/tokens/system/prove_token_total_supply_and_aggregated_identity_balances/v0/mod.rs b/packages/rs-drive/src/drive/tokens/system/prove_token_total_supply_and_aggregated_identity_balances/v0/mod.rs index 83061d04d78..5d1858139bd 100644 --- a/packages/rs-drive/src/drive/tokens/system/prove_token_total_supply_and_aggregated_identity_balances/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/system/prove_token_total_supply_and_aggregated_identity_balances/v0/mod.rs @@ -89,6 +89,7 @@ mod tests { TokenConfiguration::V0(TokenConfigurationV0::default_most_restrictive()), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); @@ -215,6 +216,7 @@ mod tests { ), )]), keywords: Vec::new(), + description: None, }); let token_id = contract.token_id(0).expect("expected token at position 0"); diff --git a/packages/search-contract/schema/v1/search-contract-documents.json b/packages/search-contract/schema/v1/search-contract-documents.json index 2f7be903882..4c602704cf8 100644 --- a/packages/search-contract/schema/v1/search-contract-documents.json +++ b/packages/search-contract/schema/v1/search-contract-documents.json @@ -1,9 +1,8 @@ { - "contract": { + "contractKeywords": { "type": "object", "documentsMutable": false, "canBeDeleted": false, - "referenceType": "contract", "creationRestrictionMode": 2, "indices": [ { @@ -29,6 +28,12 @@ "maxItems": 32, "position": 1, "contentMediaType": "application/x.dash.dpp.identifier" + }, + "shortDescription": { + "type": "string", + "minLength": 3, + "maxLength": 100, + "position": 2 } }, "required": [ @@ -36,5 +41,44 @@ "keyword" ], "additionalProperties": false + }, + "longDescription": { + "type": "object", + "documentsMutable": true, + "canBeDeleted": false, + "creationRestrictionMode": 2, + "indices": [ + { + "name": "byContractId", + "properties": [ + { + "contractId": "asc" + } + ], + "unique": true + } + ], + "properties": { + "contractId": { + "type": "array", + "byteArray": true, + "minItems": 32, + "maxItems": 32, + "position": 0, + "contentMediaType": "application/x.dash.dpp.identifier" + }, + "description": { + "type": "string", + "minLength": 3, + "maxLength": 10000, + "position": 1 + } + }, + "required": [ + "contractId", + "description" + ], + "description": "Long description of the contract. This document type is mutable by contract owner but creation is not allowed. Creation occurs automatically on DataContractCreate", + "additionalProperties": false } } \ No newline at end of file diff --git a/packages/search-contract/src/v1/mod.rs b/packages/search-contract/src/v1/mod.rs index c237ea3343d..058d22531f1 100644 --- a/packages/search-contract/src/v1/mod.rs +++ b/packages/search-contract/src/v1/mod.rs @@ -2,13 +2,21 @@ use crate::Error; use serde_json::Value; pub mod document_types { - pub mod contract { - pub const NAME: &str = "contract"; + pub mod contract_keywords { + pub const NAME: &str = "contractKeywords"; pub mod properties { pub const KEY_INDEX: &str = "byKeyword"; } } + + pub mod long_description { + pub const NAME: &str = "longDescription"; + + pub mod properties { + pub const KEY_INDEX: &str = "byContractId"; + } + } } pub fn load_documents_schemas() -> Result { From a170cd3374b13db8bae5fa1980c2f0a2825ca5e9 Mon Sep 17 00:00:00 2001 From: pauldelucia Date: Wed, 9 Apr 2025 16:15:35 +0700 Subject: [PATCH 2/6] finalize draft and add tests --- .../data_contract/serialized_version/mod.rs | 7 + .../src/errors/consensus/basic/basic_error.rs | 7 +- .../invalid_description_length_error.rs | 44 +++ .../consensus/basic/data_contract/mod.rs | 2 + packages/rs-dpp/src/errors/consensus/codes.rs | 1 + .../create_genesis_state/test/tokens.rs | 2 + .../advanced_structure/v0/mod.rs | 25 +- .../data_contract_create/mod.rs | 365 ++++++++++++++++++ .../contract/insert/add_description/v0/mod.rs | 55 ++- .../insert/add_new_keywords/v0/mod.rs | 2 +- .../schema/v1/search-contract-documents.json | 43 ++- packages/search-contract/src/v1/mod.rs | 12 +- .../src/errors/consensus/consensus_error.rs | 5 +- 13 files changed, 548 insertions(+), 22 deletions(-) create mode 100644 packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_description_length_error.rs diff --git a/packages/rs-dpp/src/data_contract/serialized_version/mod.rs b/packages/rs-dpp/src/data_contract/serialized_version/mod.rs index cfc34db8115..71cdd23526b 100644 --- a/packages/rs-dpp/src/data_contract/serialized_version/mod.rs +++ b/packages/rs-dpp/src/data_contract/serialized_version/mod.rs @@ -106,6 +106,13 @@ impl DataContractInSerializationFormat { } } + pub fn description(&self) -> &Option { + match self { + DataContractInSerializationFormat::V0(_) => &None, + DataContractInSerializationFormat::V1(v1) => &v1.description, + } + } + pub fn eq_without_auto_fields(&self, other: &Self) -> bool { match (self, other) { ( diff --git a/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs b/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs index d727e14f865..b1743acfa86 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs @@ -76,8 +76,8 @@ use crate::consensus::basic::{ use crate::consensus::ConsensusError; use super::data_contract::{ - DuplicateKeywordsError, InvalidKeywordEncodingError, InvalidKeywordLengthError, - TooManyKeywordsError, + DuplicateKeywordsError, InvalidDescriptionLengthError, InvalidKeywordEncodingError, + InvalidKeywordLengthError, TooManyKeywordsError, }; use crate::consensus::basic::group::GroupActionNotAllowedOnTransitionError; use crate::consensus::basic::overflow_error::OverflowError; @@ -531,6 +531,9 @@ pub enum BasicError { #[error(transparent)] InvalidKeywordEncodingError(InvalidKeywordEncodingError), + + #[error(transparent)] + InvalidDescriptionLengthError(InvalidDescriptionLengthError), } impl From for ConsensusError { diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_description_length_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_description_length_error.rs new file mode 100644 index 00000000000..7d8c04788a5 --- /dev/null +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_description_length_error.rs @@ -0,0 +1,44 @@ +use crate::consensus::basic::BasicError; +use crate::consensus::ConsensusError; +use crate::errors::ProtocolError; +use bincode::{Decode, Encode}; +use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use thiserror::Error; + +#[derive( + Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, +)] +#[error("Data contract {} has description with invalid length: '{}'. Valid length is between 3 and 100 characters.", contract_id, description.len())] +#[platform_serialize(unversioned)] +pub struct InvalidDescriptionLengthError { + /* + + DO NOT CHANGE ORDER OF FIELDS WITHOUT INTRODUCING OF NEW VERSION + + */ + contract_id: String, + description: String, +} + +impl InvalidDescriptionLengthError { + pub fn new(contract_id: String, description: String) -> Self { + Self { + contract_id, + description, + } + } + + pub fn contract_id(&self) -> &str { + &self.contract_id + } + + pub fn description(&self) -> &str { + &self.description + } +} + +impl From for ConsensusError { + fn from(err: InvalidDescriptionLengthError) -> Self { + Self::BasicError(BasicError::InvalidDescriptionLengthError(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 index c0610a52f0d..56ea0690eca 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/mod.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/mod.rs @@ -22,6 +22,7 @@ mod incompatible_re2_pattern_error; mod invalid_compound_index_error; mod invalid_data_contract_id_error; mod invalid_data_contract_version_error; +mod invalid_description_length_error; mod invalid_document_type_name_error; mod invalid_document_type_required_security_level; mod invalid_index_property_type_error; @@ -81,6 +82,7 @@ pub use group_non_unilateral_member_power_has_less_than_required_power_error::*; pub use group_position_does_not_exist_error::*; pub use group_total_power_has_less_than_required_power_error::*; pub use incompatible_document_type_schema_error::*; +pub use invalid_description_length_error::*; pub use invalid_document_type_name_error::*; pub use invalid_keyword_encoding_error::*; pub use invalid_keyword_length_error::*; diff --git a/packages/rs-dpp/src/errors/consensus/codes.rs b/packages/rs-dpp/src/errors/consensus/codes.rs index aeef3882fcd..e974c30e5bc 100644 --- a/packages/rs-dpp/src/errors/consensus/codes.rs +++ b/packages/rs-dpp/src/errors/consensus/codes.rs @@ -110,6 +110,7 @@ impl ErrorWithCode for BasicError { Self::DuplicateKeywordsError(_) => 10263, Self::InvalidKeywordLengthError(_) => 10264, Self::InvalidKeywordEncodingError(_) => 10265, + Self::InvalidDescriptionLengthError(_) => 10266, // Group Errors: 10350-10399 Self::GroupPositionDoesNotExistError(_) => 10350, diff --git a/packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/test/tokens.rs b/packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/test/tokens.rs index 6eef53767ff..56298b1ce80 100644 --- a/packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/test/tokens.rs +++ b/packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/test/tokens.rs @@ -224,6 +224,7 @@ impl Platform { emergency_action_rules: ChangeControlRulesV0::default().into(), main_control_group: None, main_control_group_can_be_modified: Default::default(), + description: Some("some token description".to_string()), }); let tokens = [ @@ -249,6 +250,7 @@ impl Platform { groups, tokens, keywords: vec!["key1".into(), "key2".into()], + description: Some("some contract description".to_string()), }); self.drive.apply_contract( diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/data_contract_create/advanced_structure/v0/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/data_contract_create/advanced_structure/v0/mod.rs index 665b162e751..85aa0655e39 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/data_contract_create/advanced_structure/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/data_contract_create/advanced_structure/v0/mod.rs @@ -5,7 +5,9 @@ use crate::execution::types::execution_operation::ValidationOperation; use crate::execution::types::state_transition_execution_context::{ StateTransitionExecutionContext, StateTransitionExecutionContextMethodsV0, }; -use dpp::consensus::basic::data_contract::{DuplicateKeywordsError, InvalidKeywordLengthError}; +use dpp::consensus::basic::data_contract::{ + DuplicateKeywordsError, InvalidDescriptionLengthError, InvalidKeywordLengthError, +}; use dpp::consensus::basic::data_contract::{ InvalidDataContractIdError, InvalidDataContractVersionError, InvalidTokenBaseSupplyError, NonContiguousContractTokenPositionsError, @@ -226,6 +228,27 @@ impl DataContractCreatedStateTransitionAdvancedStructureValidationV0 } } + // Validate the description is between 3 and 100 characters + if let Some(description) = self.data_contract().description() { + if !(description.len() >= 3 && description.len() <= 100) { + let bump_action = StateTransitionAction::BumpIdentityNonceAction( + BumpIdentityNonceAction::from_borrowed_data_contract_create_transition(self), + ); + + return Ok(ConsensusValidationResult::new_with_data_and_errors( + bump_action, + vec![ConsensusError::BasicError( + BasicError::InvalidDescriptionLengthError( + InvalidDescriptionLengthError::new( + self.data_contract().id().to_string(Encoding::Base58), + description.to_string(), + ), + ), + )], + )); + } + } + Ok(ConsensusValidationResult::default()) } } diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/data_contract_create/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/data_contract_create/mod.rs index 9aa0193e912..8c5a168089a 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/data_contract_create/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/data_contract_create/mod.rs @@ -2452,7 +2452,12 @@ mod tests { use super::*; use dpp::{ data_contract::conversion::value::v0::DataContractValueConversionMethodsV0, + data_contracts::SystemDataContract, document::DocumentV0Getters, platform_value::string_encoding::Encoding, + system_data_contracts::load_system_data_contract, + }; + use drive::{ + drive::document::query::QueryDocumentsOutcomeV0Methods, query::DriveDocumentQuery, }; #[test] @@ -2956,6 +2961,366 @@ mod tests { assert_eq!(keywords[0], "key1"); assert_eq!(keywords[1], "key2"); assert_eq!(keywords[2], "key3"); + + // Now check the Search Contract has the keyword documents + let search_contract = + load_system_data_contract(SystemDataContract::Search, PlatformVersion::latest()) + .expect("expected to load search contract"); + let document_type = search_contract + .document_type_for_name("contractKeywords") + .expect("expected to get document type"); + + let drive_query = + DriveDocumentQuery::all_items_query(&search_contract, document_type, None); + + let documents_result = platform + .drive + .query_documents(drive_query, None, false, None, None) + .expect("expected to query documents"); + + let documents = documents_result.documents(); + + assert_eq!(documents.len(), 3); + + let mut valid_keywords_for_verification = vec!["key1", "key2", "key3"]; + for document in documents { + let keyword = document + .get("keyword") + .expect("expected to get keyword") + .as_str() + .expect("expected to get string"); + + assert!(valid_keywords_for_verification.contains(&keyword)); + assert_eq!( + document + .get("contractId") + .expect("expected to get data contract id") + .clone() + .into_identifier() + .expect("expected to get identifier") + .to_string(Encoding::Base58), + data_contract_id_str + ); + valid_keywords_for_verification.retain(|&x| x != keyword); + } + } + } + + mod descriptions { + use dpp::{ + data_contract::conversion::value::v0::DataContractValueConversionMethodsV0, + data_contracts::SystemDataContract, document::DocumentV0Getters, + platform_value::string_encoding::Encoding, + system_data_contracts::load_system_data_contract, + }; + use drive::{ + drive::document::query::QueryDocumentsOutcomeV0Methods, query::DriveDocumentQuery, + }; + + use super::*; + + /// Returns a `DataContract` value that already contains at least one keyword + fn base_contract_value_with_keyword(platform_version: &PlatformVersion) -> Value { + let data_contract = json_document_to_contract_with_ids( + // Re‑use the same fixture you already have; it doesn’t need + // to contain a description field – we mutate it below. + "tests/supporting_files/contract/keyword_test/keyword_base_contract.json", + None, + None, + false, + platform_version, + ) + .expect("expected to load contract"); + + let mut contract_value = data_contract + .to_value(PlatformVersion::latest()) + .expect("to_value failed"); + + // Ensure the `keywords` array is not empty so that Drive will attempt + // to create the description documents. + contract_value["keywords"] = Value::Array(vec![Value::Text("key1".to_string())]); + + contract_value + } + + #[test] + fn test_data_contract_creation_fails_with_description_too_short() { + let platform_version = PlatformVersion::latest(); + let mut platform = TestPlatformBuilder::new() + .build_with_mock_rpc() + .set_genesis_state(); + + let platform_state = platform.state.load(); + let (identity, signer, key) = setup_identity(&mut platform, 958, dash_to_credits!(0.1)); + + // --- mutate the contract --- + let mut contract_value = base_contract_value_with_keyword(platform_version); + contract_value["description"] = Value::Text("hi".to_string()); // < 3 chars + + let data_contract_invalid = + DataContract::from_value(contract_value, true, platform_version) + .expect("failed to create DataContract from Value"); + + let transition = DataContractCreateTransition::new_from_data_contract( + data_contract_invalid, + 1, + &identity.into_partial_identity_info(), + key.id(), + &signer, + platform_version, + None, + ) + .expect("expected to create transition"); + + let serialized = transition + .serialize_to_bytes() + .expect("expected to serialize"); + + let tx = platform.drive.grove.start_transaction(); + let processing_result = platform + .platform + .process_raw_state_transitions( + &[serialized], + &platform_state, + &BlockInfo::default(), + &tx, + platform_version, + false, + None, + ) + .expect("expected processing"); + + assert_matches!( + processing_result.execution_results().as_slice(), + [StateTransitionExecutionResult::PaidConsensusError( + ConsensusError::BasicError(BasicError::InvalidDescriptionLengthError(_)), + _ + )] + ); + } + + #[test] + fn test_data_contract_creation_fails_with_description_too_long() { + let platform_version = PlatformVersion::latest(); + let mut platform = TestPlatformBuilder::new() + .build_with_mock_rpc() + .set_genesis_state(); + + let platform_state = platform.state.load(); + let (identity, signer, key) = setup_identity(&mut platform, 958, dash_to_credits!(0.1)); + + let mut contract_value = base_contract_value_with_keyword(platform_version); + // 101 chars – valid for the contract (max 10 000) but exceeds the + // 100‑char limit of the autogenerated **shortDescription** document. + let too_long = "x".repeat(101); + contract_value["description"] = Value::Text(too_long); + + let data_contract_invalid = + DataContract::from_value(contract_value, true, platform_version) + .expect("failed to create DataContract"); + + let transition = DataContractCreateTransition::new_from_data_contract( + data_contract_invalid, + 1, + &identity.into_partial_identity_info(), + key.id(), + &signer, + platform_version, + None, + ) + .expect("expected to create transition"); + + let serialized = transition + .serialize_to_bytes() + .expect("expected to serialize"); + + let tx = platform.drive.grove.start_transaction(); + let processing_result = platform + .platform + .process_raw_state_transitions( + &[serialized], + &platform_state, + &BlockInfo::default(), + &tx, + platform_version, + false, + None, + ) + .expect("expected processing"); + + assert_matches!( + processing_result.execution_results().as_slice(), + [StateTransitionExecutionResult::PaidConsensusError( + ConsensusError::BasicError(BasicError::InvalidDescriptionLengthError(_)), + _ + )] + ); + } + + #[test] + fn test_data_contract_creation_succeeds_with_valid_description() { + let platform_version = PlatformVersion::latest(); + let mut platform = TestPlatformBuilder::new() + .build_with_mock_rpc() + .set_genesis_state(); + + let platform_state = platform.state.load(); + let (identity, signer, key) = setup_identity(&mut platform, 958, dash_to_credits!(0.1)); + + let mut contract_value = base_contract_value_with_keyword(platform_version); + contract_value["description"] = + Value::Text("A perfectly valid description.".to_string()); + + let data_contract_valid = + DataContract::from_value(contract_value, true, platform_version) + .expect("failed to create DataContract"); + + let transition = DataContractCreateTransition::new_from_data_contract( + data_contract_valid, + 1, + &identity.into_partial_identity_info(), + key.id(), + &signer, + platform_version, + None, + ) + .expect("expected to create transition"); + + let serialized = transition + .serialize_to_bytes() + .expect("expected to serialize"); + + let tx = platform.drive.grove.start_transaction(); + let processing_result = platform + .platform + .process_raw_state_transitions( + &[serialized], + &platform_state, + &BlockInfo::default(), + &tx, + platform_version, + false, + None, + ) + .expect("expected processing"); + + assert_matches!( + processing_result.execution_results().as_slice(), + [StateTransitionExecutionResult::SuccessfulExecution(_, _)] + ); + + // Commit so we can query the state afterwards + platform + .drive + .grove + .commit_transaction(tx) + .unwrap() + .expect("expected commit"); + + // ---- Verify description persisted in the contract ---- + let unique_identifiers = transition.unique_identifiers(); + let unique_identifier = unique_identifiers + .first() + .expect("expected at least one unique identifier"); + let data_contract_id_str = unique_identifier + .as_str() + .split('-') + .last() + .expect("split contract id"); + let data_contract_id = Identifier::from_string(data_contract_id_str, Encoding::Base58) + .expect("identifier"); + + let contract = platform + .drive + .fetch_contract(data_contract_id.into(), None, None, None, platform_version) + .value + .expect("expected contract") + .expect("contract exists"); + + let desc = contract + .contract + .description() + .expect("description should exist"); + + assert_eq!(desc, "A perfectly valid description."); + + // Now check the Search Contract has the short and full description documents + let search_contract = + load_system_data_contract(SystemDataContract::Search, PlatformVersion::latest()) + .expect("expected to load search contract"); + let short_description_document_type = search_contract + .document_type_for_name("shortDescription") + .expect("expected to get document type"); + let full_description_document_type = search_contract + .document_type_for_name("fullDescription") + .expect("expected to get document type"); + + let drive_query_short_description = DriveDocumentQuery::all_items_query( + &search_contract, + short_description_document_type, + None, + ); + + let short_description_documents_result = platform + .drive + .query_documents(drive_query_short_description, None, false, None, None) + .expect("expected to query documents"); + + let short_description_documents = short_description_documents_result.documents(); + + assert_eq!(short_description_documents.len(), 1); + let short_description_document = short_description_documents + .first() + .expect("expected to get first document"); + let short_description = short_description_document + .get("description") + .expect("expected to get description") + .as_str() + .expect("expected to get string"); + assert_eq!(short_description, "A perfectly valid description."); + assert_eq!( + short_description_document + .get("contractId") + .expect("expected to get data contract id") + .clone() + .into_identifier() + .expect("expected to get identifier") + .to_string(Encoding::Base58), + data_contract_id_str + ); + + let drive_query_full_description = DriveDocumentQuery::all_items_query( + &search_contract, + full_description_document_type, + None, + ); + let full_description_documents_result = platform + .drive + .query_documents(drive_query_full_description, None, false, None, None) + .expect("expected to query documents"); + + let full_description_documents = full_description_documents_result.documents(); + + assert_eq!(full_description_documents.len(), 1); + let full_description_document = full_description_documents + .first() + .expect("expected to get first document"); + let full_description = full_description_document + .get("description") + .expect("expected to get description") + .as_str() + .expect("expected to get string"); + assert_eq!(full_description, "A perfectly valid description."); + assert_eq!( + full_description_document + .get("contractId") + .expect("expected to get data contract id") + .clone() + .into_identifier() + .expect("expected to get identifier") + .to_string(Encoding::Base58), + data_contract_id_str + ); } } } diff --git a/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs b/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs index b2e64ac3bfc..84b714a92b3 100644 --- a/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs +++ b/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs @@ -97,26 +97,53 @@ impl Drive { transaction: TransactionArg, platform_version: &PlatformVersion, ) -> Result, Error> { + let mut operations: Vec = vec![]; + let contract = self.cache.system_data_contracts.load_search(); - let document_type = contract.document_type_for_name("longDescription")?; - let mut operations: Vec = vec![]; + let short_description_document_type = + contract.document_type_for_name("shortDescription")?; + let full_description_document_type = contract.document_type_for_name("fullDescription")?; - let document = self.build_contract_long_description_document_owned_v0( + let short_description_document = self.build_contract_description_document_owned_v0( contract_id, owner_id, description, + false, + block_info, + )?; + let full_description_document = self.build_contract_description_document_owned_v0( + contract_id, + owner_id, + description, + true, block_info, )?; - let ops = self.add_document_for_contract_operations( + let short_description_ops = self.add_document_for_contract_operations( DocumentAndContractInfo { owned_document_info: OwnedDocumentInfo { - document_info: DocumentOwnedInfo((document, None)), + document_info: DocumentOwnedInfo((short_description_document, None)), owner_id: Some(owner_id.to_buffer()), }, contract: &contract, - document_type, + document_type: short_description_document_type, + }, + true, + block_info, + &mut None, + estimated_costs_only_with_layer_info, + transaction, + platform_version, + )?; + let full_description_ops = self.add_document_for_contract_operations( + DocumentAndContractInfo { + owned_document_info: OwnedDocumentInfo { + document_info: DocumentOwnedInfo((full_description_document, None)), + owner_id: Some(owner_id.to_buffer()), + }, + contract: &contract, + document_type: full_description_document_type, }, true, block_info, @@ -126,19 +153,20 @@ impl Drive { platform_version, )?; - operations.extend(ops); + operations.extend(short_description_ops); + operations.extend(full_description_ops); Ok(operations) } - pub(super) fn build_contract_long_description_document_owned_v0( + pub(super) fn build_contract_description_document_owned_v0( &self, contract_id: Identifier, owner_id: Identifier, description: &String, + full_description: bool, block_info: &BlockInfo, ) -> Result { - // Fetch the identity nonce for the owner or use 1 let owner_nonce = match self.fetch_identity_nonce(owner_id.into(), true, None, PlatformVersion::latest()) { @@ -146,10 +174,17 @@ impl Drive { Err(e) => return Err(e), }; + let document_type_name; + if full_description { + document_type_name = "fullDescription".to_string(); + } else { + document_type_name = "shortDescription".to_string(); + } + let document_id = Document::generate_document_id_v0( &contract_id, &owner_id, - "longDescription", + &document_type_name, &owner_nonce.to_be_bytes(), ); diff --git a/packages/rs-drive/src/drive/contract/insert/add_new_keywords/v0/mod.rs b/packages/rs-drive/src/drive/contract/insert/add_new_keywords/v0/mod.rs index d7dcbcb9de2..a7daf634932 100644 --- a/packages/rs-drive/src/drive/contract/insert/add_new_keywords/v0/mod.rs +++ b/packages/rs-drive/src/drive/contract/insert/add_new_keywords/v0/mod.rs @@ -145,7 +145,7 @@ impl Drive { let document_id = Document::generate_document_id_v0( &contract_id, &owner_id, - "contract", + "contractKeywords", keyword_index.to_be_bytes().as_slice(), ); diff --git a/packages/search-contract/schema/v1/search-contract-documents.json b/packages/search-contract/schema/v1/search-contract-documents.json index 4c602704cf8..444c1297f69 100644 --- a/packages/search-contract/schema/v1/search-contract-documents.json +++ b/packages/search-contract/schema/v1/search-contract-documents.json @@ -28,21 +28,54 @@ "maxItems": 32, "position": 1, "contentMediaType": "application/x.dash.dpp.identifier" + } + }, + "required": [ + "contractId", + "keyword" + ], + "additionalProperties": false + }, + "shortDescription": { + "type": "object", + "documentsMutable": false, + "canBeDeleted": false, + "creationRestrictionMode": 2, + "indices": [ + { + "name": "byContractId", + "properties": [ + { + "contractId": "asc" + } + ], + "unique": true + } + ], + "properties": { + "contractId": { + "type": "array", + "byteArray": true, + "minItems": 32, + "maxItems": 32, + "position": 0, + "contentMediaType": "application/x.dash.dpp.identifier" }, - "shortDescription": { + "description": { "type": "string", "minLength": 3, "maxLength": 100, - "position": 2 + "position": 1 } }, "required": [ "contractId", - "keyword" + "description" ], + "description": "Short description of the contract. This document type is immutable and creation is not allowed. Creation occurs automatically internally on DataContractCreate and mirrors the contract's description field.", "additionalProperties": false }, - "longDescription": { + "fullDescription": { "type": "object", "documentsMutable": true, "canBeDeleted": false, @@ -78,7 +111,7 @@ "contractId", "description" ], - "description": "Long description of the contract. This document type is mutable by contract owner but creation is not allowed. Creation occurs automatically on DataContractCreate", + "description": "Full description of the contract. This document type is mutable by contract owner but creation is not allowed. Creation occurs automatically internally on DataContractCreate and mirrors the contract's description field initially.", "additionalProperties": false } } \ No newline at end of file diff --git a/packages/search-contract/src/v1/mod.rs b/packages/search-contract/src/v1/mod.rs index 058d22531f1..200a4523c97 100644 --- a/packages/search-contract/src/v1/mod.rs +++ b/packages/search-contract/src/v1/mod.rs @@ -10,8 +10,16 @@ pub mod document_types { } } - pub mod long_description { - pub const NAME: &str = "longDescription"; + pub mod short_description { + pub const NAME: &str = "shortDescription"; + + pub mod properties { + pub const KEY_INDEX: &str = "byContractId"; + } + } + + pub mod full_description { + pub const NAME: &str = "fullDescription"; pub mod properties { pub const KEY_INDEX: &str = "byContractId"; diff --git a/packages/wasm-dpp/src/errors/consensus/consensus_error.rs b/packages/wasm-dpp/src/errors/consensus/consensus_error.rs index 244b233fc66..f609620bd63 100644 --- a/packages/wasm-dpp/src/errors/consensus/consensus_error.rs +++ b/packages/wasm-dpp/src/errors/consensus/consensus_error.rs @@ -61,7 +61,7 @@ use dpp::consensus::state::data_trigger::DataTriggerError::{ DataTriggerConditionError, DataTriggerExecutionError, DataTriggerInvalidResultError, }; use wasm_bindgen::{JsError, JsValue}; -use dpp::consensus::basic::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError, DataContractTokenConfigurationUpdateError, DuplicateKeywordsError, GroupExceedsMaxMembersError, GroupMemberHasPowerOfZeroError, GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError, GroupPositionDoesNotExistError, GroupTotalPowerLessThanRequiredError, InvalidDocumentTypeRequiredSecurityLevelError, InvalidKeywordEncodingError, InvalidKeywordLengthError, InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError, InvalidTokenDistributionFunctionIncoherenceError, InvalidTokenDistributionFunctionInvalidParameterError, InvalidTokenDistributionFunctionInvalidParameterTupleError, NonContiguousContractGroupPositionsError, NonContiguousContractTokenPositionsError, TokenPaymentByBurningOnlyAllowedOnInternalTokenError, TooManyKeywordsError, UnknownDocumentActionTokenEffectError, UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError, UnknownTransferableTypeError}; +use dpp::consensus::basic::data_contract::{ContestedUniqueIndexOnMutableDocumentTypeError, ContestedUniqueIndexWithUniqueIndexError, DataContractTokenConfigurationUpdateError, DuplicateKeywordsError, GroupExceedsMaxMembersError, GroupMemberHasPowerOfZeroError, GroupMemberHasPowerOverLimitError, GroupNonUnilateralMemberPowerHasLessThanRequiredPowerError, GroupPositionDoesNotExistError, GroupTotalPowerLessThanRequiredError, InvalidDescriptionLengthError, InvalidDocumentTypeRequiredSecurityLevelError, InvalidKeywordEncodingError, InvalidKeywordLengthError, InvalidTokenBaseSupplyError, InvalidTokenDistributionFunctionDivideByZeroError, InvalidTokenDistributionFunctionIncoherenceError, InvalidTokenDistributionFunctionInvalidParameterError, InvalidTokenDistributionFunctionInvalidParameterTupleError, NonContiguousContractGroupPositionsError, NonContiguousContractTokenPositionsError, TokenPaymentByBurningOnlyAllowedOnInternalTokenError, TooManyKeywordsError, UnknownDocumentActionTokenEffectError, UnknownDocumentCreationRestrictionModeError, UnknownGasFeesPaidByError, UnknownSecurityLevelError, UnknownStorageKeyRequirementsError, UnknownTradeModeError, UnknownTransferableTypeError}; use dpp::consensus::basic::document::{ContestedDocumentsTemporarilyNotAllowedError, DocumentCreationNotAllowedError, DocumentFieldMaxSizeExceededError, MaxDocumentsTransitionsExceededError, MissingPositionsInDocumentTypePropertiesError}; use dpp::consensus::basic::group::GroupActionNotAllowedOnTransitionError; use dpp::consensus::basic::identity::{DataContractBoundsNotPresentError, DisablingKeyIdAlsoBeingAddedInSameTransitionError, InvalidIdentityCreditWithdrawalTransitionAmountError, InvalidIdentityUpdateTransitionDisableKeysError, InvalidIdentityUpdateTransitionEmptyError, TooManyMasterPublicKeyError, WithdrawalOutputScriptNotAllowedWhenSigningWithOwnerKeyError}; @@ -773,6 +773,9 @@ fn from_basic_error(basic_error: &BasicError) -> JsValue { BasicError::InvalidKeywordEncodingError(e) => { generic_consensus_error!(InvalidKeywordEncodingError, e).into() } + BasicError::InvalidDescriptionLengthError(e) => { + generic_consensus_error!(InvalidDescriptionLengthError, e).into() + } } } From 6bb6653a3f22efe5c357283480b73dca9bcb323e Mon Sep 17 00:00:00 2001 From: pauldelucia Date: Wed, 9 Apr 2025 18:25:47 +0700 Subject: [PATCH 3/6] generate sdk test vectors and fix unit test hashes and fees --- .../src/execution/check_tx/v0/mod.rs | 10 +-- .../batch/tests/document/creation.rs | 2 +- .../rs-drive/tests/deterministic_root_hash.rs | 2 +- packages/rs-drive/tests/query_tests.rs | 60 +++++++++--------- .../rs-drive/tests/query_tests_history.rs | 8 +-- ...cec7d11a37410433366315d1103f81859344b.json | Bin 0 -> 60302 bytes ...a9664c6f3704dadf217d5b236f608cb4dc8a1.json | Bin 60322 -> 0 bytes ...71733fb6ad13495beb7ca1b6a6c4ceb30e0f7.json | Bin 218933 -> 218972 bytes ...f8339ad60debd43b3f430bd12d51eac268936.json | 1 + ...a891ce226199229e3031f71994d14dd32f088.json | 1 - ...e8920dea81c3f44b9549c238dcb82cccc9923.json | Bin 0 -> 60287 bytes ...4eacbb5ffa75f6cb27d3ee8a17b185852f102.json | Bin 60358 -> 0 bytes ...71733fb6ad13495beb7ca1b6a6c4ceb30e0f7.json | Bin 218969 -> 218957 bytes ...f8339ad60debd43b3f430bd12d51eac268936.json | 1 + ...a891ce226199229e3031f71994d14dd32f088.json | 1 - ...cec7d11a37410433366315d1103f81859344b.json | Bin 0 -> 60341 bytes ...10a8556ecf1145e99c87071cc8998a97d7ccb.json | Bin 0 -> 60467 bytes ...a9664c6f3704dadf217d5b236f608cb4dc8a1.json | Bin 60316 -> 0 bytes ...337e03233ad6fd5c394dd4e6033f39e9447e8.json | Bin 60442 -> 0 bytes ...71733fb6ad13495beb7ca1b6a6c4ceb30e0f7.json | Bin 218927 -> 219011 bytes ...f8339ad60debd43b3f430bd12d51eac268936.json | 1 + ...a891ce226199229e3031f71994d14dd32f088.json | 1 - ...501c1ba166a2dd8f6efb31b0289dc011da983.json | Bin 29015 -> 29024 bytes ...f8339ad60debd43b3f430bd12d51eac268936.json | 1 + ...a891ce226199229e3031f71994d14dd32f088.json | 1 - ...086bcaf743e2fa8f6b8b143deb29b5265e971.json | Bin 55048 -> 0 bytes ...7ff33d2448d30f2527374349b9f507b44c5c1.json | Bin 0 -> 55034 bytes ...71733fb6ad13495beb7ca1b6a6c4ceb30e0f7.json | Bin 218927 -> 218957 bytes ...f8339ad60debd43b3f430bd12d51eac268936.json | 1 + ...a891ce226199229e3031f71994d14dd32f088.json | 1 - ...71733fb6ad13495beb7ca1b6a6c4ceb30e0f7.json | Bin 218957 -> 219023 bytes ...f8339ad60debd43b3f430bd12d51eac268936.json | 1 + ...a891ce226199229e3031f71994d14dd32f088.json | 1 - ...48c03122daf7ab2e77108f4bf44af1ad15eae.json | Bin 29045 -> 29036 bytes ...f8339ad60debd43b3f430bd12d51eac268936.json | 1 + ...a891ce226199229e3031f71994d14dd32f088.json | 1 - ...067bd9ccc29eca3092a5664a5a9ba3bb7e967.json | Bin 225261 -> 225321 bytes ...f8339ad60debd43b3f430bd12d51eac268936.json | 1 + ...a891ce226199229e3031f71994d14dd32f088.json | 1 - 39 files changed, 49 insertions(+), 49 deletions(-) create mode 100644 packages/rs-sdk/tests/vectors/document_list_document_query/msg_DocumentQuery_2a42b0afe6c6f58b02d8152142acec7d11a37410433366315d1103f81859344b.json delete mode 100644 packages/rs-sdk/tests/vectors/document_list_document_query/msg_DocumentQuery_9064a0dc37a9f6f767159a4325ba9664c6f3704dadf217d5b236f608cb4dc8a1.json create mode 100644 packages/rs-sdk/tests/vectors/document_list_document_query/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json delete mode 100644 packages/rs-sdk/tests/vectors/document_list_document_query/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json create mode 100644 packages/rs-sdk/tests/vectors/document_list_drive_query/msg_DocumentQuery_2fd2f7aebe5686d4e4179323b49e8920dea81c3f44b9549c238dcb82cccc9923.json delete mode 100644 packages/rs-sdk/tests/vectors/document_list_drive_query/msg_DocumentQuery_c4bb9b2e03829c0926d347692bc4eacbb5ffa75f6cb27d3ee8a17b185852f102.json create mode 100644 packages/rs-sdk/tests/vectors/document_list_drive_query/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json delete mode 100644 packages/rs-sdk/tests/vectors/document_list_drive_query/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json create mode 100644 packages/rs-sdk/tests/vectors/document_read/msg_DocumentQuery_2a42b0afe6c6f58b02d8152142acec7d11a37410433366315d1103f81859344b.json create mode 100644 packages/rs-sdk/tests/vectors/document_read/msg_DocumentQuery_4816e45a0ba02d69c291f23322410a8556ecf1145e99c87071cc8998a97d7ccb.json delete mode 100644 packages/rs-sdk/tests/vectors/document_read/msg_DocumentQuery_9064a0dc37a9f6f767159a4325ba9664c6f3704dadf217d5b236f608cb4dc8a1.json delete mode 100644 packages/rs-sdk/tests/vectors/document_read/msg_DocumentQuery_9267cfc8e7a6f302a2a7d179bc9337e03233ad6fd5c394dd4e6033f39e9447e8.json create mode 100644 packages/rs-sdk/tests/vectors/document_read/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json delete mode 100644 packages/rs-sdk/tests/vectors/document_read/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json create mode 100644 packages/rs-sdk/tests/vectors/document_read_no_contract/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json delete mode 100644 packages/rs-sdk/tests/vectors/document_read_no_contract/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json delete mode 100644 packages/rs-sdk/tests/vectors/document_read_no_document/msg_DocumentQuery_96c4914304501c97094650f1da1086bcaf743e2fa8f6b8b143deb29b5265e971.json create mode 100644 packages/rs-sdk/tests/vectors/document_read_no_document/msg_DocumentQuery_f531f69255dae40cef880290c177ff33d2448d30f2527374349b9f507b44c5c1.json create mode 100644 packages/rs-sdk/tests/vectors/document_read_no_document/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json delete mode 100644 packages/rs-sdk/tests/vectors/document_read_no_document/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json create mode 100644 packages/rs-sdk/tests/vectors/test_data_contract_read/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json delete mode 100644 packages/rs-sdk/tests/vectors/test_data_contract_read/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json create mode 100644 packages/rs-sdk/tests/vectors/test_data_contract_read_not_found/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json delete mode 100644 packages/rs-sdk/tests/vectors/test_data_contract_read_not_found/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json create mode 100644 packages/rs-sdk/tests/vectors/test_data_contracts_1_ok_1_nx/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json delete mode 100644 packages/rs-sdk/tests/vectors/test_data_contracts_1_ok_1_nx/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json diff --git a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs index d84943877b5..3e794714efd 100644 --- a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs @@ -630,7 +630,7 @@ mod tests { ) .expect("expected to process state transition"); - assert_eq!(processing_result.aggregated_fees().processing_fee, 2488810); + assert_eq!(processing_result.aggregated_fees().processing_fee, 2489210); let check_result = platform .check_tx( @@ -1141,7 +1141,7 @@ mod tests { // The processing fees should be twice as much as a fee multiplier of 0, // since a fee multiplier of 100 means 100% more of 1 (gives 2) - assert_eq!(processing_result.aggregated_fees().processing_fee, 4977620); + assert_eq!(processing_result.aggregated_fees().processing_fee, 4978420); let check_result = platform .check_tx( @@ -1613,7 +1613,7 @@ mod tests { ) .expect("expected to process state transition"); - assert_eq!(processing_result.aggregated_fees().processing_fee, 2488810); + assert_eq!(processing_result.aggregated_fees().processing_fee, 2489210); platform .drive @@ -1699,7 +1699,7 @@ mod tests { assert_eq!( update_processing_result.aggregated_fees().processing_fee, - 2503570 + 2504030 ); let check_result = platform @@ -2069,7 +2069,7 @@ mod tests { ) .expect("expected to process state transition"); - assert_eq!(processing_result.aggregated_fees().processing_fee, 2488810); + assert_eq!(processing_result.aggregated_fees().processing_fee, 2489210); platform .drive diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/creation.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/creation.rs index a48f9eb433e..0b3fb36f414 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/creation.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/creation.rs @@ -2599,7 +2599,7 @@ mod creation_tests { format!( "Document Creation on {}:{} is not allowed because of the document type's creation restriction mode No Creation Allowed", search_contract.id().to_string(Encoding::Base58), - "contract" + "contractKeywords" ), "Mismatch in error message" ); diff --git a/packages/rs-drive/tests/deterministic_root_hash.rs b/packages/rs-drive/tests/deterministic_root_hash.rs index 35b3d7e7b57..760ed03f3c9 100644 --- a/packages/rs-drive/tests/deterministic_root_hash.rs +++ b/packages/rs-drive/tests/deterministic_root_hash.rs @@ -302,7 +302,7 @@ mod tests { // We expect a different app hash because data contract is not serialized the same way let expected_app_hash = match platform_version.protocol_version { 0..=8 => "1b80f4a9f00597b3f1ddca904b3cee67576868adcdd802c0a3f91e14209bb402", - _ => "aa29a0d3dcdcb1dc1b446830931762e0b9c2e2d97d6f426f8dbe4e0eda8e6130", + _ => "76e3af331ff60aea3006671d048ce16871369da4ec562bdc9966837bb49ee92c", }; assert_eq!( diff --git a/packages/rs-drive/tests/query_tests.rs b/packages/rs-drive/tests/query_tests.rs index 8353aeecb0b..ac6c5d96250 100644 --- a/packages/rs-drive/tests/query_tests.rs +++ b/packages/rs-drive/tests/query_tests.rs @@ -2509,8 +2509,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 163, 83, 211, 88, 187, 57, 197, 189, 189, 39, 40, 150, 102, 186, 188, 111, 200, 230, - 134, 21, 72, 136, 135, 92, 102, 206, 72, 43, 127, 87, 26, 82, + 53, 9, 163, 92, 116, 134, 17, 186, 21, 68, 156, 162, 47, 181, 214, 162, 253, 4, 246, 8, + 41, 187, 151, 152, 216, 164, 206, 110, 230, 176, 124, 225, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -3823,8 +3823,8 @@ mod tests { assert_eq!( root_hash.as_slice(), vec![ - 243, 205, 195, 230, 73, 41, 217, 87, 42, 205, 142, 71, 144, 29, 239, 97, 174, 131, - 226, 122, 190, 78, 58, 99, 94, 106, 233, 185, 194, 198, 246, 205 + 144, 154, 147, 246, 236, 57, 41, 67, 21, 26, 212, 158, 68, 159, 206, 26, 158, 50, + 252, 62, 143, 176, 149, 50, 19, 226, 239, 65, 112, 243, 225, 64 ], ); } @@ -3974,8 +3974,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 163, 83, 211, 88, 187, 57, 197, 189, 189, 39, 40, 150, 102, 186, 188, 111, 200, 230, - 134, 21, 72, 136, 135, 92, 102, 206, 72, 43, 127, 87, 26, 82, + 53, 9, 163, 92, 116, 134, 17, 186, 21, 68, 156, 162, 47, 181, 214, 162, 253, 4, 246, 8, + 41, 187, 151, 152, 216, 164, 206, 110, 230, 176, 124, 225, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -4426,8 +4426,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 138, 110, 99, 80, 216, 232, 45, 246, 159, 207, 139, 253, 210, 64, 32, 114, 102, 107, - 21, 120, 163, 19, 189, 99, 109, 95, 56, 217, 134, 206, 160, 215, + 75, 38, 164, 96, 117, 46, 13, 23, 183, 41, 83, 163, 112, 55, 172, 37, 186, 36, 223, 39, + 106, 201, 46, 222, 167, 79, 236, 122, 12, 210, 29, 123, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -4549,8 +4549,8 @@ mod tests { // Make sure the state is deterministic let expected_app_hash = vec![ - 163, 83, 211, 88, 187, 57, 197, 189, 189, 39, 40, 150, 102, 186, 188, 111, 200, 230, - 134, 21, 72, 136, 135, 92, 102, 206, 72, 43, 127, 87, 26, 82, + 53, 9, 163, 92, 116, 134, 17, 186, 21, 68, 156, 162, 47, 181, 214, 162, 253, 4, 246, 8, + 41, 187, 151, 152, 216, 164, 206, 110, 230, 176, 124, 225, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -5347,8 +5347,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 252, 254, 89, 190, 119, 227, 29, 62, 78, 216, 77, 35, 178, 115, 23, 145, 237, 234, 159, - 60, 9, 83, 51, 174, 88, 255, 12, 116, 106, 202, 232, 29, + 235, 23, 161, 209, 153, 68, 160, 57, 151, 170, 19, 99, 64, 48, 5, 114, 233, 154, 77, + 65, 104, 102, 128, 181, 159, 124, 54, 108, 229, 88, 185, 134, ]; assert_eq!(root_hash.as_slice(), expected_app_hash,); @@ -5443,8 +5443,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 252, 254, 89, 190, 119, 227, 29, 62, 78, 216, 77, 35, 178, 115, 23, 145, 237, 234, 159, - 60, 9, 83, 51, 174, 88, 255, 12, 116, 106, 202, 232, 29, + 235, 23, 161, 209, 153, 68, 160, 57, 151, 170, 19, 99, 64, 48, 5, 114, 233, 154, 77, + 65, 104, 102, 128, 181, 159, 124, 54, 108, 229, 88, 185, 134, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -5539,8 +5539,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 252, 254, 89, 190, 119, 227, 29, 62, 78, 216, 77, 35, 178, 115, 23, 145, 237, 234, 159, - 60, 9, 83, 51, 174, 88, 255, 12, 116, 106, 202, 232, 29, + 235, 23, 161, 209, 153, 68, 160, 57, 151, 170, 19, 99, 64, 48, 5, 114, 233, 154, 77, + 65, 104, 102, 128, 181, 159, 124, 54, 108, 229, 88, 185, 134, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -5635,8 +5635,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 252, 254, 89, 190, 119, 227, 29, 62, 78, 216, 77, 35, 178, 115, 23, 145, 237, 234, 159, - 60, 9, 83, 51, 174, 88, 255, 12, 116, 106, 202, 232, 29, + 235, 23, 161, 209, 153, 68, 160, 57, 151, 170, 19, 99, 64, 48, 5, 114, 233, 154, 77, + 65, 104, 102, 128, 181, 159, 124, 54, 108, 229, 88, 185, 134, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -5831,8 +5831,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 89, 74, 31, 85, 116, 81, 139, 178, 90, 11, 123, 172, 93, 187, 25, 125, 35, 201, 210, - 64, 40, 43, 40, 68, 230, 228, 168, 46, 63, 219, 98, 240, + 233, 90, 110, 8, 43, 137, 139, 242, 8, 152, 175, 246, 177, 73, 49, 137, 61, 142, 2, 49, + 158, 134, 13, 222, 60, 223, 139, 41, 66, 131, 135, 38, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -6038,8 +6038,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 89, 74, 31, 85, 116, 81, 139, 178, 90, 11, 123, 172, 93, 187, 25, 125, 35, 201, 210, - 64, 40, 43, 40, 68, 230, 228, 168, 46, 63, 219, 98, 240, + 233, 90, 110, 8, 43, 137, 139, 242, 8, 152, 175, 246, 177, 73, 49, 137, 61, 142, 2, 49, + 158, 134, 13, 222, 60, 223, 139, 41, 66, 131, 135, 38, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -6248,8 +6248,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 89, 74, 31, 85, 116, 81, 139, 178, 90, 11, 123, 172, 93, 187, 25, 125, 35, 201, 210, - 64, 40, 43, 40, 68, 230, 228, 168, 46, 63, 219, 98, 240, + 233, 90, 110, 8, 43, 137, 139, 242, 8, 152, 175, 246, 177, 73, 49, 137, 61, 142, 2, 49, + 158, 134, 13, 222, 60, 223, 139, 41, 66, 131, 135, 38, ]; assert_eq!(root_hash.as_slice(), expected_app_hash,); @@ -6462,8 +6462,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 244, 130, 169, 10, 90, 218, 48, 147, 73, 95, 89, 174, 234, 151, 228, 21, 155, 188, 165, - 185, 121, 77, 221, 236, 82, 228, 82, 133, 102, 214, 251, 40, + 112, 166, 177, 100, 209, 55, 7, 42, 111, 43, 77, 15, 40, 149, 26, 219, 121, 244, 83, 5, + 102, 253, 66, 122, 99, 217, 33, 173, 135, 17, 174, 115, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -6542,8 +6542,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 244, 130, 169, 10, 90, 218, 48, 147, 73, 95, 89, 174, 234, 151, 228, 21, 155, 188, 165, - 185, 121, 77, 221, 236, 82, 228, 82, 133, 102, 214, 251, 40, + 112, 166, 177, 100, 209, 55, 7, 42, 111, 43, 77, 15, 40, 149, 26, 219, 121, 244, 83, 5, + 102, 253, 66, 122, 99, 217, 33, 173, 135, 17, 174, 115, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); @@ -6643,8 +6643,8 @@ mod tests { .expect("there is always a root hash"); let expected_app_hash = vec![ - 244, 130, 169, 10, 90, 218, 48, 147, 73, 95, 89, 174, 234, 151, 228, 21, 155, 188, 165, - 185, 121, 77, 221, 236, 82, 228, 82, 133, 102, 214, 251, 40, + 112, 166, 177, 100, 209, 55, 7, 42, 111, 43, 77, 15, 40, 149, 26, 219, 121, 244, 83, 5, + 102, 253, 66, 122, 99, 217, 33, 173, 135, 17, 174, 115, ]; assert_eq!(root_hash.as_slice(), expected_app_hash); diff --git a/packages/rs-drive/tests/query_tests_history.rs b/packages/rs-drive/tests/query_tests_history.rs index cb72796f888..3229c6fbbcd 100644 --- a/packages/rs-drive/tests/query_tests_history.rs +++ b/packages/rs-drive/tests/query_tests_history.rs @@ -1666,8 +1666,8 @@ fn test_query_historical_latest_platform_version() { assert_eq!( root_hash.as_slice(), vec![ - 198, 240, 42, 199, 134, 177, 186, 144, 191, 122, 14, 217, 209, 140, 131, 144, 63, 232, - 141, 193, 177, 136, 200, 150, 42, 110, 151, 216, 85, 161, 78, 44 + 161, 240, 182, 38, 13, 26, 246, 165, 76, 67, 252, 39, 203, 128, 225, 233, 70, 76, 30, + 228, 64, 40, 59, 240, 240, 135, 215, 135, 146, 2, 128, 65 ] ); @@ -3032,8 +3032,8 @@ fn test_query_historical_latest_platform_version() { assert_eq!( root_hash.as_slice(), vec![ - 244, 221, 68, 246, 214, 152, 18, 222, 186, 119, 187, 173, 119, 184, 146, 5, 27, 145, - 125, 63, 233, 17, 138, 99, 99, 177, 83, 145, 4, 8, 124, 155 + 82, 200, 76, 76, 113, 4, 94, 39, 105, 206, 63, 185, 209, 222, 13, 161, 194, 209, 156, + 251, 133, 192, 38, 65, 93, 196, 214, 198, 52, 196, 37, 208 ] ); } diff --git a/packages/rs-sdk/tests/vectors/document_list_document_query/msg_DocumentQuery_2a42b0afe6c6f58b02d8152142acec7d11a37410433366315d1103f81859344b.json b/packages/rs-sdk/tests/vectors/document_list_document_query/msg_DocumentQuery_2a42b0afe6c6f58b02d8152142acec7d11a37410433366315d1103f81859344b.json new file mode 100644 index 0000000000000000000000000000000000000000..9adca368205e1fa61ebc0a52a7b0daff6522a8f9 GIT binary patch literal 60302 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®r`dVB7&!{{omO+6FXrjl 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 diff --git a/packages/rs-sdk/tests/vectors/document_list_document_query/msg_GetDataContractRequest_e87a2e6acef76975c30eb7272da71733fb6ad13495beb7ca1b6a6c4ceb30e0f7.json b/packages/rs-sdk/tests/vectors/document_list_document_query/msg_GetDataContractRequest_e87a2e6acef76975c30eb7272da71733fb6ad13495beb7ca1b6a6c4ceb30e0f7.json index 78b6e2613b4d273230b522ffce68d8579f539098..d7eb96c1aa9e2b7f863e7a24a961d64eade237b4 100644 GIT binary patch delta 2888 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 Hr?v0@EMyjZ diff --git a/packages/rs-sdk/tests/vectors/document_list_document_query/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json b/packages/rs-sdk/tests/vectors/document_list_document_query/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json new file mode 100644 index 00000000000..e18b2a7deac --- /dev/null +++ b/packages/rs-sdk/tests/vectors/document_list_document_query/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json @@ -0,0 +1 @@ +b751df5b612ece651a4d290fa95fab328d5b186b84fc88b103bb45cdf6d3815620b74daa0d72067d74ea86da595c6a59 \ No newline at end of file diff --git a/packages/rs-sdk/tests/vectors/document_list_document_query/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json b/packages/rs-sdk/tests/vectors/document_list_document_query/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json deleted file mode 100644 index 5992d970292..00000000000 --- a/packages/rs-sdk/tests/vectors/document_list_document_query/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json +++ /dev/null @@ -1 +0,0 @@ -b4d9b2ac8940208c9b5a4182518b6792b89c7e08caa3f6b83a1f81526346d2be47f9c1d9c2b26a9d73103c8c2e525dd0 \ No newline at end of file diff --git a/packages/rs-sdk/tests/vectors/document_list_drive_query/msg_DocumentQuery_2fd2f7aebe5686d4e4179323b49e8920dea81c3f44b9549c238dcb82cccc9923.json b/packages/rs-sdk/tests/vectors/document_list_drive_query/msg_DocumentQuery_2fd2f7aebe5686d4e4179323b49e8920dea81c3f44b9549c238dcb82cccc9923.json new file mode 100644 index 0000000000000000000000000000000000000000..6ee022e9e57cfb4f41155da10c34fee246cd0ef1 GIT binary patch literal 60287 zcmeI4ZF3t}a)tBRzhVldDkZfb1Mo!>ollZwuN7Onj^%7pkrdSs7?QAn85jU1(T@Im z&bfC0%m5%c&uEp3cjT#zkKuj=l}fh=-cVPeUtv_U!VW-g+l+NxXg#y@Vm^u?p~PqW+S%tyaw!)N&-JI`i6T}`vO7PavK*^ec_YtZ}UC&l|bn>`D-_iy=ciS>MN zkxf#C)LX3W?kuD8B0TrQNI4-oEGFs5Tw8t;J}dDmW3Q(*aJE@e#X?U-?0kNf%?z9- zmmUR@>(MZKUJSQBS70=>Q=I;sDJhl#*J7i5I2weYy$liaGD*c;|J2FTNtixOX9Dw2 z`sr~#{60O+#+9YQ$my(@X0yd;Yehd@2f;u2zfSI?92>$P!rD(mz`TRaP3MD7#VXGz z5%t^n-;Ik#8?RZZw({$BOuTOAG9UeNX(Q^v56_hJi)?2XQAlB1`s^%OTx7}G;ACt@BqGToDg1CWPeiZm zL!vk1Y(CdVX`USPlEFo4ah4J%|Co-)NjjchXzn7B8{I^XbhW*Rouv6N+50E&lP761 zNfq>2E_x^Liba-`I3$boZ8lG)<8+WEiy}E6y~~o~auLllm1>?><4|K$9m*ByN2P#C zEb1ZYSOZ>U=}hj#RNTnpKo*)2vusezhV%X9whr~KJgE8fy7JT7zY4;gni*A3I{`KA zQvFb9FG|UnFJ`0seAD&m4)X1tyk7Ef??goGbszLUu0MHwZ*!5!DE~go&leZk{ct0; zlk~&t*@Ml8(_%i_P18-1Mm>ql+)uLo^Zn%hlj8LLew7n77HnnUr$y%C=e@U+y?na& zYcIy9_CX~|wa<6Ns$o1T)gaJsBWbJgaQ>(;O2?cvI6rQKOXj&E6=VXSpM- ze2RLQJB!~*u+?NqCiat8o#Iuet3O7sIw4zMb;f!(%R)8|llP;=g`W0SPy2eO-6mS~ zJXH=~6qDk7mQF7cF)AIrU4nGlJH5ZjmwSU^;!ejY@%(bWNKUgvT}C?giq@hiK%;!^ z%(WIy%K0~1dIL*hDXf*N)(Ld)e^vtiNjbD3*`202bg+?o8=QHZoJr`c>xz9c3>7+Y zOR&Uhn9eVnWz>!$|A|qnr;XI6_QBq(SNm%rsy*6~Vih@R8_G?k+6v`%6jdYFeEt8C zd;!o~voBL_XR}%os=Q|(bWTylSQ15Il1-+IE9dAyCmiK`s`pcM1n<->L^^$9nkIkN zsVOLc4}YOAaDS16CSO{XFL&PDcYafb&oUL_Z1y4z2dHa!n$BkF)n=$puNK+k@L*^E zsJi!Tkxkql9&YBIa`xJ1m9lqqbIRK0=$7rCsA)6yBmJDxtSuYY9&a(zdzb%@yR zbLzoTH&N+kHlI~`ja|VEi{Bj3Fyw}y#^=`uHrl`LDK=_ocpQ4oeDORRj#3{pU4zo; zbUYe_O8Czo_MJ5Q!|Al_+|<#}Hh2*h+E9deJoexqsj8fA|Abk((0iTo)HN5XtVtZW zxT*r@1=sCf_-TU|ipmewBiV*)oeHInH>Re;VQ8|_aczar<5t_v>a@=M@-$}jkC*EB z|GFH~NuhZEV!6Tg;vu}tw)M0q##x#-K;S2zQ;Kk`Nru_kNIg#S{z784mW`EH^O(=c zo)Ebz^6X#Y(Op0L-X82qhvfl-I>{uPUPR zUE5Uv?p08`ojH|>52_Gv9|TvBBr}5^jbF*X?^yzeV{FSY?lIRcZ5ZCUiFzBhl-EqY z$a%TpUuTmrwdcE!OqHX6j>F+LYIEt%y$H$harGiaVYzoXRr$%bKVM$h%(kD!!&lX( zt@Fn<54T#W+PJ0OhvHRxvXuAQhbt&z+O7gsJwXO9MzQ^_hFV98C@H@A%lQh>EXHWHU zZ!#JV$LdVN8Dzd+xz+eSTx$Fwxxaru`9tONYW$OMn#hZAA{iICt|G1Ay6ZST43{0g z|L{RKN#~`;43pEV@XTMA)#c*_1)|zn68u|`d zN3bwZ7dJYk>q2F?tPU$4uh6M!@#@ZU-ue>quXCd~SEG^*zg6kn)PUNBMU`)st{pu@ zTq(vetk>w?q?!dv;o7a=iptd@Tg`}?iB*$2JB+D5zoq5r+}!STZfJFU=4;YFZk}&8 zx{{~GrEav6`9->SaQqlT-!B!$FuWUaXAfr)zbDw@m4oLmX75oZ?miSzMs@*FU!Dh z+_`x(1t3gV>C7AVWp4rll$WtZ3>n{fuQO!!W-v~5Tv@N$3F80e^lJObc%;iCZ68|M z&U~Tk=F-J4K7R2JU;Nhj^V`msFZ&0&2k&)tzVhp++wVWp&wc&r_s4p#Uw!|qK}X%= zM;=$7RGoUH=QoX7jqRP3+dSx=Jk;A>_@f_wYOun39hqr!ZD!A|*z5;uBfM6xdwl3m zjy!hhYFwfE`%(8qMg?Evq9@1U6D=7`bRcA=H&To=&ck~)-ustNZZYTRqv>^m~1x_YeH0 zNdWtOTWbi+80}tK?jIF28_T^y*1bC>o>~B$`q&YA@sV%ltZ?Qbxy3MzH3Sk z_!7mSIU=^Ih41o$@XEXBbwgHG;ETmh2qF;eIEk&JDk@4xorsN6DNfO>=2PfkdvU9} zR$^uBP*h_XY3#B?q$1OJyekz6sn=Hv&|=C1VpXV|&AqTyTAu)2G8|#2SfTNu&NDC6 z$&f8d$D6|)lZb3#Iw9#G^ka~TcxZ8Cwi1)dQRA>PH)RQ`AmR)fufZfT<`@dQ(opN8 zWNhIA3O=;QE-QJ7PB4H$h4S}qJS}p951eHSCqJJZ#wIdo&NELmj?la$M z^$#s2s|c__x2S_goWN(q)$CDTLF^14WxE_9q;m5^9JfhISX4bV7&_jjzoNW?`fr9n zxLY)q-i4H4jc=YxCWglIDF|*eM2sSc8*W5eRT)y4(BigVCl0c{r^p3D4`h-Cw@@3| zLrtQN+Y9-QunWF05-PT&sc^WU8aP(S3o(SqW;CgJsyeDtWn$|y@gaKAaJ z?6syKnW6~}Q^|tR0(8wHa5z?|qu|{m%2p3X_Ru@q7**JoyFGxK;~YmohSEw&28zj-cErr;zl~6i1l2UnUV%Gwsqso#-xt67FJm zAmLps;9BpTxN5r=u27(K2#8W*jf`c|)EqZ3TOn|V<@Edkdkt4`)F_2oN zEoi3GY(g%G7?d7jAkCx3h0=K~Swl$#QM12dAaNmb1C@Kzk8VNpnqGv)q@Yzpa1#c~ zYs7FP9zkzRlE_%5X@Y}0j`u}LB=s!GZu(y@38DxQti#;ijbs^Wqm7KWL2oOmAJq6$Y%ZcYzMY=U)kxeYxK0|VBGQPzCqIMlHg z+%Ww}Y&G6f2m?J{q(zP^BVeEAB!Y&OJfVichY#7o}BX3nLPs z1o}fH+6hJMi7ueRWZ+s94oY~HKhi)tuxg5E=E@Ngu5uTIh}a$p-@F!Ryo47eNQ;9B z@uCEsAY!k>t2xyj-spStSji+3sB#OaBq%}b0tuAum*c3^3U0z%YLCkk3=y**-kez0 zP<#Y|LPT8f7BC|mRl+^r7ZESa3IRdxf9y5ko=rlUiHCv*hUShT0)kx68VT~NxCargPC%~170UdU^*zTtq%;3@Qb zVHhX_K>};+pi0||775P`Ib9csU44)$$NY(tPRf2+etLzrlkyT`T z2|Cf|(s8OGk&w+Dkx3*_8f?R0!lDH6`Xo@cUsjRRhp^Tz0B&fHl^lkM*?)J&to%~| z<-ZZM^@&*_AV?c*Vi2t98PnqlQO)hfxm+d!C7xWSCc%8k@<0-NVsfS3V)((X?@(>lH z7NpV?lH+z<JO6wlN-$>_LMSNtr~zQtF*wiKxUI@1=speVM<3(ErZ>Q zi7j79d5z;S;!rLO2bmJbGphngDDJWfC#=FtDvNO^gf}9H?J=jwl(+@riM^m(5UQh) ze%`^55-2Q`Y|a{zIF3wwHE%mLo}S&{<&sU(7EqVstmbV13Y5DM5?CxOjpOgkqL~un z2_h3Iq2C)@6ffYXHZ}ZVLH(W!|ZlJM5JvIURZr%c(LQH2#nH1 zgHiur7vc-$$lru=sy{)oa<>dy8u3=MnEud&La8B_Nk8LyL9$!pk-ruk)korj>@g5f z4COUGi3>ZrOAB9Q80io+7?BV=E(D3!5kW>Ofv#OhD*Yd%UaWn%{PDt}@Un10nR0?C z!bEm#4@vVf2T7|?hL_%k$rr-LXc*QLs#^4Ni8Q)2H6q*;J{Klb2oTm#L+pZNjR5UD z)hwhTN(zZ>iz!5(4FoJ4?%5y~4i`ZrMi}LV6PBMA9buZ|l#0^B7Kji%bhwnWq%Co{ z~>+c^T6O;SxnWjYiEL{3{pw9$k0B937Bh4%(!pa|S8 zNabDVH}9f4ELDzebGe8>5G?G4QUewgs|PxaP~Hl0l;B#Q1lDk?b*HHmWTZJ9C8;0} zTPT%%p$NhnSMr4VLUE+yBaVcMOsUjP!vw_Q7F{50w@EE>9Cj%dHv+ey@o;r;PG0bfbVXtZvGRa=Ia9m;q zi;n9ia-@a62@&2=GplIZ6TKjgM ztGvEUB1K2*YYIz4A|nVj+b<14sA)V=Li@|xdnyQaM6!eEA+HH=-a?MUTH`I?6wD|B zpN)|th*63valvXs*0((fIIT~Tv<>}WQ(=3gPE;`AY0-f~?SXWLq-rDv+XA+o3K8Ol zI~L-yU7+beT1U!NjrSBpR}H2a0bO>6qKuPz~S&xt2CY<=xl;m$ZHl@CA`Ev%~q2z#MG5x6}VlFH+$ zh>7Y@CsCk0Sd5~iQfd%swc~PxAcA=dE2-Bffi>K)@;a4*i~ycTQb8WJP%8UE5rjv0 zgAOIs;i5Rw@exNt#m}A{EwT?uG+Ey~hq4w)?un={-POvif2nNyUof*i-_^=qcRMoM zpSZ*jNiSndNNXt|+2mBZtCbCSZVkDsl|(`vE?WEO_|IJ{Q7YXHuH+F@p}WxCg{~5T zYU#Wq(%)A!$Sn%u20GoNmDynAU_9v%d5mS3opf~PL%%6gD~pbJ!4cU83?p9OK~PnR zo$uZ1tG~K~U{|4WaDM+;fU?-9OQjgeGWzv_w}=V`&#=f5H281EYdg|Bssv?32{hOj zAh2ru?tDZ6xf@(9Rd><2i$*m9)%SPY_}xbX6)ZIP^HsN#ZvVEs{gZ}&Z9~Pnf2dy% z^{cO6{#oyPC*6}{{c+Si@ss%WP+$H&@^=a+8hM)mkr?jn(IJi$VxJo5m&-B+;SzgA z`)L@KQvy3y~IiLBs1n!M`%*Dby+< zPRqM;3hkmCK~+wL7p;#53vNP>h#J-eVvNlM^zlyp!dUKl$rW4u1*rAXj&DY{2gQ78%dk!qxMd^lELE?#4j=6@Wxb;N^LgPtdmJpCB zj=y$6EP`h^yAY(ZdB^D3QesfK2v&Kc<|oDI2nny?rU)`dNnt3X5Z1Dv7C6;+G(|2D zlS~X)7L5Yj!o)y21LU9=%<20)V17#G7637j4~D|Pg}^QqDtU)pkQ&2 zQ<|%d$IB54A0(B%AS5(tTO=&(NQDJzBpfTrj;^O}`?iE!fcYyLe^uizW_ns$YYUL@ z#Y|JO=xd!vnyFt}>BL_rJ&fP?_+m|$YVrG?PyFgf6oK5O@ih^VriXN*#EK|3&k%Dl zyqZrbiGl=6Tk!Lz4I`~5tK!N)l2J6U9xs`ux}ai%rl^<^FKiMDsiH)IhIEQ3<6Ynx z#&F0m;)|!W*hLyj>W!?zN}{h$&=%_3h`6cGLnMq;Z!RDPLNCNy`HR{Yp+K-MO*&9T yx#j;uB*pLgzpKz!nLTh_^p2Hpf$U`X-?neCqkrIvx5LaG4{9HkKj@FwAO9CY>+F*N literal 0 HcmV?d00001 diff --git a/packages/rs-sdk/tests/vectors/document_list_drive_query/msg_DocumentQuery_c4bb9b2e03829c0926d347692bc4eacbb5ffa75f6cb27d3ee8a17b185852f102.json b/packages/rs-sdk/tests/vectors/document_list_drive_query/msg_DocumentQuery_c4bb9b2e03829c0926d347692bc4eacbb5ffa75f6cb27d3ee8a17b185852f102.json deleted file mode 100644 index 4890cb0a83921eb49ba1b3b268934309ff20fee3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 60358 zcmeI4TXP#%c7^loU(tn9m695g0eF!_=Si~cv0`h+v7AXNlA>w?O%fK+4FjMg+N1wI zYn{^ox&e^ruVtlXQglHUh(4FS*IN5>4ru@OMUr#|={$YYFY@^`?aw=3Cco)JeSGh{ zn2yu=n|IlCHY{>I==3^!@!4?TAOHAYKfZYUmv5f`{NEoQeLMM&Z_+>g`}1F({N>^E zCl}AZJ3gD9{O8v%W>1b^9QD5LFJ@|=^WnvEm)rNz(|(#i$)0ATY@T_~^K>-Jq7iyH z&C)@UkFGZ!yv?%7?AzgNUQ9P14vPNOILqg=?=-3$^i}Ep)9gIG8X1N9PRlvZujc95 zDBB!ApI)sDTMqxKV*ZXf)9jb4;WV2)8_2fd{QB#>KfRvJ1^tuaDj#Hn?=t(6UyVi; z0P1s|X1nLihQDTmXZbw4$fiGCPqLX7wef-3k0rq?(tG76#rr&)J`23}cKoy8de*

dRilAQzca{^i;ymXXn|}#A$Nr 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 delta 3065 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 diff --git a/packages/rs-sdk/tests/vectors/document_read/msg_DocumentQuery_9267cfc8e7a6f302a2a7d179bc9337e03233ad6fd5c394dd4e6033f39e9447e8.json b/packages/rs-sdk/tests/vectors/document_read/msg_DocumentQuery_9267cfc8e7a6f302a2a7d179bc9337e03233ad6fd5c394dd4e6033f39e9447e8.json deleted file mode 100644 index f83ccb50780049b144ba750801f5100f2a707859..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 60442 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 K9-r)ScK#1P{zvNo delta 3027 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 literal 29015 zcmeI5L2esI5Jj`rDGaT-;7Fuw`Vu*S;a#*a0>puncq8cU{;#V=4ISC+*O9UkK-;9) zJyrGV*RPtPJiNPj^XBsF?U%nkeg5O}{hPbITV8!=@9^$+^ZNApap;(S zd;s_I&o7_9-Uj%;zx;FC-n`G>_ZRmUzg*m1{`&jn`wz?2^=8>_uCLl-w^^2VdA;Oc zp6~NKe->V6(QdPU$GX!^>#e)I|Fc!cwcA5CbF(?T&C_lBXKAknj_`P#xQV;Cxg`|b zzIk+lV_k2`tsQG0LaigL|K4p5ajL~y2R-cDPjblSB0$7V3faa zWXy84|FMUJj~yT&U>E{nR;+xgfKI7+iX`ym{qvRe-9e~`V>)_a!_=ONb+W!Qap3ij zYh`5zG869D;^O~V@~@BoVvECTv_T%9T`6G|@(pD)zNH+qTdIzQmA5{S1a9E!2urM# z38GG2M52bRu-HVw;wFUSCh#iMk}lbdPXvO}N7siPBal$nz(qO?+cDAl&$w3!Ay&rM z_b8-Nk@Sfq{-iamWUVGH+N?1_Ad2eAwaQ(@&8EBQq0V@ASss>ehPoOqDeU76q$t$E z4OaucDhEX&$Df)OhjWxkPdUS4gA4>vus5l9Ay0%bj1Qh9UQ@z^9CU+Xp7LtWL`gRSLl3RY!2i%mMRcxLuX0V-Y@{fB{OP=p@25MsAvmjM=3lWt{2 ziY>W_SBgPq3D>3BhOx;vWWDlme{bdAFiuVM3-RNGsD#X|#vRcrs$)!iuR`sGI7rd5m5u zwj}9_ka5ZIgea1C>yjy0G{Nu?HIQQ%QOGMfqb zGqSQ}!i06wJenm(jA~|28T-4WsBiSw_>;W_8~f; zS9NAQgDs_DfSs8k7K}(D6fM`PGm6FGUQjg+ z1%FzFj$2_%a$&KRYK&JBTZ%}=PMecbL-^K8wpgkg698qaFa6hOCQ)aLOnR|voLXp3 zGGb!Kg#4Vk2(QGX0#Qk1i-l{vMMkM4Z;9Gw+_ZqiOYW3J$E7HVvCP}|jPE*N#I+ubX&;@PFw5Ane9Fix(@khxi z1d#HWEj;YBnZO5g-F^eS9J5wPqM5j;VyQ5_Dh*ZOiHRMrOcXtd%B7f4!jkpUD|ls1 z7?g-Qz#5?FiALuMIS&P_njHLy)$3yTG=cSDxbiB)g9^EZnPHa-RhNhm!w3#0l54Z2 zfDN6VwP(?s_(ShH-iWl?7?zgDJ1?qcWowJz(iv1%Q@a*F(+uN`62;1o=$sR^oV}o@P>md+ zmKF0LEKOLrdh8~TeT$97il;sGFg!3A_qjO;Heab{R(5F3fs^trn>0zdC*rXVeLNvPGhbi3u^6j-mgi z{V{i`TxW5juz?H@6>vix++MqCQs&f8N*UY>LzKYE0h{Azi(z0_8?&VXap}nMRp~{| zRJyATnJr+Iq+8jPpBNmiJnMC@lui4bhEHX-xzM%x;*?R?@(nC}ugJ+4;54}QOdP+#$8WRvJTvS70G||$1VoSVIog*ex6s^-Zjgv*& zNuv6t6|4zhZSGP{3fQ@RW>D&+l`U{o((2w;Rp7=e=-PU-IL!!Fasoqk%$AZJ6?=!* z@Pybi8d}E;ym-~v{;VzV$G@(?*Oy)K9bWmCto27g%NkNS)J H^YQ*0RQ_wV diff --git a/packages/rs-sdk/tests/vectors/document_read_no_contract/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json b/packages/rs-sdk/tests/vectors/document_read_no_contract/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json new file mode 100644 index 00000000000..e18b2a7deac --- /dev/null +++ b/packages/rs-sdk/tests/vectors/document_read_no_contract/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json @@ -0,0 +1 @@ +b751df5b612ece651a4d290fa95fab328d5b186b84fc88b103bb45cdf6d3815620b74daa0d72067d74ea86da595c6a59 \ No newline at end of file diff --git a/packages/rs-sdk/tests/vectors/document_read_no_contract/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json b/packages/rs-sdk/tests/vectors/document_read_no_contract/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json deleted file mode 100644 index 5992d970292..00000000000 --- a/packages/rs-sdk/tests/vectors/document_read_no_contract/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json +++ /dev/null @@ -1 +0,0 @@ -b4d9b2ac8940208c9b5a4182518b6792b89c7e08caa3f6b83a1f81526346d2be47f9c1d9c2b26a9d73103c8c2e525dd0 \ No newline at end of file diff --git a/packages/rs-sdk/tests/vectors/document_read_no_document/msg_DocumentQuery_96c4914304501c97094650f1da1086bcaf743e2fa8f6b8b143deb29b5265e971.json b/packages/rs-sdk/tests/vectors/document_read_no_document/msg_DocumentQuery_96c4914304501c97094650f1da1086bcaf743e2fa8f6b8b143deb29b5265e971.json deleted file mode 100644 index af500c51b1e5c23affc04929ff8c9afd5940c2ee..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 55048 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 diff --git a/packages/rs-sdk/tests/vectors/document_read_no_document/msg_DocumentQuery_f531f69255dae40cef880290c177ff33d2448d30f2527374349b9f507b44c5c1.json b/packages/rs-sdk/tests/vectors/document_read_no_document/msg_DocumentQuery_f531f69255dae40cef880290c177ff33d2448d30f2527374349b9f507b44c5c1.json new file mode 100644 index 0000000000000000000000000000000000000000..aa4d00e5ac00342bbe43f436e0d4e3b4b13c0bb0 GIT binary patch literal 55034 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�ZyUEMCWK`rkx8JeL&{*neLJqCL`kn*6e#G64I|+# z5h0-45vdU|%u|%gP>@U&Y8Vv^Sm-RP#H2PdslrHj;@GxORyjgSihDo;A5~)KlwK&d zEvSxuJ<$5Zo(KfS4qj}?B(#ME0f`%3UyF-@M046C1?7gutFRNsMlVoOc#1Y6zIzJQ z5FvFqe8|C(#s}H&cp_tz(W<=YvL~<_ zv7$@_B2D%pzL1QIe$*FDA<|(6LPptrw1s#s9UxO2E8&Qwqcx7i{Zju)ZS@q$$rj3B zP^dV=a#?QCg7!#qWfj5QUPA=UdBR4+p%*FyQQL|3I!EC6=64>(PD(A&yXnI9A-G=J44bk`%TF-efyOP^G;EVXUoEwi2v8Sd5|xjTh~0=HG4n`;C9C>FF9wKhG#s;nx~@(+GC`*7Ha+^+zk6o$2kv_#=>S+jP?we+2rx z--C>Ya*sk7q^*$?@fIvXNYvAYNqSI~l_P{D+QP5K-I%#fGSKOyq(wy3l#qnXDxzx+ zthPXbjgAoCy^HdkbgnM02oB=4xkP}lB}&tVnHot>>8+>|x*9dwwa|VdnuJh*sF@h> z*Uy*{tauA<#63D*+(S{KKNnJ@_FKCa1Wvle$uv9Z zWlqL-GJ%r`os3Y6X?=hX^jbEpu>TO%e?zL9kr-ZB@sdF;pStvms*sXT`G-8qqsb3! z{^u3b;ljswB3I>6F>TZQIZi1Rp%tGtQrBfyE!8IkHwb-#K5G-4Y_lTV*lD>q_f|(h zXEGigxQUxTv8i{ROWQAcG*D;rU)JML^6n@f8Z{lY(sZxoalF^C`LPX_LxnGWE}E7o zc@ge!v0R#HuAsHA`aHP9PzUIIRmjC=BcNQpO)Z|_B^{Qa$?bv%V`hWCYVRt`;kawL zoJ$yX>7awuQk*=Qf?Gd=nuY^If8m0LAD<(hzh-Ddd|-x%Sc5N8jxBkv^% zpC4Uig>R%v~B%Y)75OBUDbhG85{H1ibNKQ{0C4V5{YGd6QMai+hZalM9U$-*-1a zD|d(dqW}RN=+MO|L<$!0o7F~|$}b8Q^8rvI>8pz_H~C!pJ+dv&$_Wci+q)x_f$%nbjl8waJR%3xWs zHVrCBA`2yyRv3`DxjuY!jT1pAw&X@5 zjrP7F{ZsyK8lLQl8N;K!+w2i|Y|H>sE+3r>_Qj8Yhl6?Zmh2!<&l^!5ETEs9y$Z9F zKM(l^^n2dO@@UQqN0NUwZ&XYZ${!Is&1a0#t_LZ%8zi~{n}WUml#<;Zm#e`LNpmVZ zm8GF8Md^xM`<@waVG&m4%9O`%MZp7(e`4Gm$z3ozEES&WXp`GL-g}QxL;^WZ>(DWANry<9D39Ze|`I*!h!zoyN$(PV?KpQC&pdps-S^O^1r0=l1{&_%4f$ zTJOqn#B!Sp9R|!iLSNK6bU5EkU-_s}b%Gm<(RFV7+N~B8L^g%6QY4GpK3=s zeGMUm?ZaL}h4~}jLnDkYl4d#{<%6g6Frqpb)TjT*$MCWOZKzxO6a8#niVOXSRsKC+ z6_7hyx~JjG07L%fazu{#MUD_kIWBz}hTPf=GaH&=)1_I80VrxgNGeRZo^&+jf4E=J zp2gbiq{qwNCLfEUkIG;pvc0H|0K>q5qhzqPRnJEJz`eM!!pBf?0&Q_mAg7>SDMSQ2 z7Ax|oAtxY=MErO=dRc5eE|87kvo=ZPDIlgf&7=Ruypc_Xv{VRvYL*AyD5^^0su>O= z6PHdQMtN*i3?{H+8F;0sto)K6lXsA%`b9`v5}h z!Z0mo1hhWYVsTWfUyeFcL$zDlCrbMQ>g#Z)6}#n#p<5$&U4s{6(2CHh$~v9hhZ$=w JpXjxI{2#?3KF0t6 delta 2962 zcmYjTX>3&271mok6Tp_86dO4-*k&LAFxG zEmZ<0w2i26V)?Wj6=<2NZMp_VaZ42zd#Ec?+EmzORRqCpTB$!`IxVPFNI<`P?~L6) zv%GhgbH4L^-#LFeT6FAaQF_u01y1a7C!nh8D!OBCH+(X_SWVxwzPu#r#N$pJuN&lN zJR#S`@lecdc-;OVjMwUbsdM2`j|a zKQhF~MTau;ZJJ)}@$ly?o72K_b{Rr0F5r(oHY1!oW%~5bbuJAzhj}Pz zxzs-p;>+g@kNX=en~GZ1X?(oH5_BW%;pi}puXX8@kWZg3jPc+#Q=O+ScX=#k$u%~W zyx>w%M2A4*oq{LZ5#Y|K<#B4eVe`Z#)92oH!#yxz#JK;QAxN~rBSAkn8RIU2LI6dsZL)I7=fb1);{Pho{~8DSLwAjUuDgOxt_W!KfC9;( zl9eGk*Bnu}Q&&{b$Pz)7zYw$N@k`w(M)DKGrqk0tf7Ge(q>>tByx2A4F?yyqMm<+! zv}K`7*^YwISF08pI9LNPQY)w{>~psVk{xfsZU9ErLeSqF4}7v|e7Q%-cKbl1kq-y- zIuXb_MgC$zGYbRWeH4UKY{fwiPyWGN#gh$&Vk4Ce2yV5E+)dpQn{;V{k~IN^W18%l zi;9_ica7z0vbd`~>Om}$i*J|BNx|i7i%gF;Rz#I#h?^Z1>+p0PZ_5JBS)S4z05(`{ zf5*dx*`Et4D-$&AX?l;9tC|D&shCgCUG?Nj9+Xn+J&&gkPP&>U8OEB+oKWXC&AH%Q z2sT6&QJ0E+$&wIXdd-aT;1oF0`!k#0?2};h)8>MM$H zdKz0K&C=U8(2b@qP`Ve=Fadu5Ss_gZ0UrtT{bdN}81BpN)xhM9k&Y}95T~x^$dUvf z3XsS!RF`VhWahWat*!j-Ww1i3l-_t$3nsrmq56Gz2@^!NXq^7fM?p_6w*4R zx@Ag~S*e-n8J(}uyxqyz~fy8il z8cy_~8QI&v>5cwP#&7yJncWxi!hp;*N}KES_t#beX|x|WBP{<#SlZd%eoW3o&2&K|Hf*-V6@In5|66*zR z30qfN2~HnGznH8*%aQ_xp~>3omc=*QLD1P+FI%J39-^)LT-x6j@X{|CF`8@zDM65Q z-1@0n8(9O4FF;F@DpA@4erG+OU-^s`PFX+YAfJa*_F>=b``BFNW9buY$9VWFVik2m% zU~^wD*n|cQ%R@)@lo=IJwq7*@3-bX@&0EI1o2;)BN}vvhauLM4ur%2(nrA?-99KQ+ zYmDID1bx+qqzWa(o}lC=kDF!?eRriTJys?dqF1Zx=)?;6-M<69zxXj70jd$A&C3yr za^UYGKp;)~*J|x8JDs3U6}jAW2fBL+f=bVL%Gx>dEWA)!I^C?ttwq{`Av*Zl783=j z$?05Gud7rj8c+9v06tQx9L0gj)SQVQZINyn=8e!^&i*{2gR@!_x)E!4sg-EZSh-Jq zHEIPNdc>njWQ>Lm7w-^!z7@B0ZOaWAQqloEya(#a!QTy%!lDJZW7PVTLXxmN39}r4 z0+J1;FQO_#&(HVN7^6sEk@Tp;iK^*GHTN}5mLb5bfQ4zoL#bwPFZhyfaJl|j1p414xwjY#IGKj8_pZlCS9!v$&(9kL z{EaK%b$(J*-}v&r$~1ZIHy zKG0crYj&H@@d-0R<2mCQD-Vd?%A3z(IkwvTUIJAT6s`4b---KlX2DXO-MzT=D1Wft G+Vel|pBuLT diff --git a/packages/rs-sdk/tests/vectors/document_read_no_document/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json b/packages/rs-sdk/tests/vectors/document_read_no_document/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json new file mode 100644 index 00000000000..e18b2a7deac --- /dev/null +++ b/packages/rs-sdk/tests/vectors/document_read_no_document/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json @@ -0,0 +1 @@ +b751df5b612ece651a4d290fa95fab328d5b186b84fc88b103bb45cdf6d3815620b74daa0d72067d74ea86da595c6a59 \ No newline at end of file diff --git a/packages/rs-sdk/tests/vectors/document_read_no_document/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json b/packages/rs-sdk/tests/vectors/document_read_no_document/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json deleted file mode 100644 index 5992d970292..00000000000 --- a/packages/rs-sdk/tests/vectors/document_read_no_document/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json +++ /dev/null @@ -1 +0,0 @@ -b4d9b2ac8940208c9b5a4182518b6792b89c7e08caa3f6b83a1f81526346d2be47f9c1d9c2b26a9d73103c8c2e525dd0 \ No newline at end of file diff --git a/packages/rs-sdk/tests/vectors/test_data_contract_read/msg_GetDataContractRequest_e87a2e6acef76975c30eb7272da71733fb6ad13495beb7ca1b6a6c4ceb30e0f7.json b/packages/rs-sdk/tests/vectors/test_data_contract_read/msg_GetDataContractRequest_e87a2e6acef76975c30eb7272da71733fb6ad13495beb7ca1b6a6c4ceb30e0f7.json index 4ca3e6ba6603a850b66ab825624349eb7b1fa43e..6487de69be4444043802f1cb8b55c438fae16f92 100644 GIT binary patch delta 3175 zcmY*ce{fV+6`uFr=4}EbSyF9cC1DfV0O7rT_r15fA!#8?Q^+O|vygxtlu25&6K8B> zP^se&5@m!bR-5jzoYFcZ)*0H43ei}jnKD__DKmm(ouTSb32UXDI&I2!oPo9$>N)rB zX38H)cJI6I-gCb5ecw6x%Zc*GPnJ()byHZ;7R!gFE9>F9KB&3yt7Ib_G`?Er@q<{i z6Y$!RZ!9X?ur&h#qM^v}5e}hqiKTPX3 zM?D;X$H4z%OHXy=LMoA83|*eYC@Yd_xdUmGXBJa^VPu!a6O|eZQ;{xGt&r zcy5#7a^VK>^wO1yGe|$*y;pdG$KGjVpe$8`1j0oIQLH8|LrP3QWHIZH| zaWb*-w60Rn)6cb4*wF2IST#cz{G%~2gA^T&3w!^_0 zO|xOVEr_4Hmrha0$P^}@tG``?tQ|lxT|jb#kj(6)NIqYuBGh8|?m7zU{(Fg6nOZ## z1OF6I9d;KmOP`@2b2V|?)MkjZV?wG%08v2l=fEKkeo*JaiaP}~M|R`IIPo;MRiHUW zWk~D_z?s_>TD?gb6F%h7#aTN_bx{i^7ZYf?s}Zd1B@U0=bgBN5|JNEK_+*O=)5K>S zLzV&M_99*K^SZ#ghc$K5S*8`|pCj^7ZSk#X%_`DEK>kJ)hqv7d5#~FIQPZUYznq|# zNmKY=pU&(*M(SZq_j{BOQzCT5$AQ1;CzKtHNaU9-`{Sy z@O4kcC8K1CsH#ixr5+0~5ggd_jQ|e(i>~}&J5^vHsdNtKm)LZPkN0e%yhGberoIC5 zE1ys$$K~u!%VRt3ZosK9*aT!%fyN@fv@%&aT#V2eC(O0 z!sl<$87T)kDOXBSbJ1l7ppwFxlgfjRZM4#@0StGLPC`FZ`r2J9B%x^&Z(OipfmAIA zj@R$}cydjqOpPA@h6sP;106^e6qy6gd;yC)*8M55SO1X)smBDSPUvw=bm{|i zTSSI6kaZ!vm59l{u~!Ga{Xr?GWfyc0Q+JYyPyGAV{rMpeL;umPPbDtu9fk~?B6W!) zQrZXdLx=K1+Eji>e{F`+W1Y~CQtE<0@s<7Lb!@rcA^RbRNna0Oii*ajbAuY>GhNM4 z`9_nJ!?n9Kd%?u;y%s71tE8G51P%{Ueu@oQO*K0)1=!4zvRnnYxuE=B1v9+ zrJZ=aDx~~4)5$hLG`&sNn%7Py9}3cqDqx<9rPOnpVp`Rf|GjKc#=$O$9fYAKqQ&aO`HlbqR-UBa36?QcgSm_c074;4c zcS6=U(M&EL9w4qZM;x4`DUIa;or|2}z6aMCedI zbnro)2v8v3-!bVG;**5=X&>?81y2%%q-F7~G-s93yPugSU9dcRqdJcyIM_nPt9;ai zBWE2vv6!xxL*WZ63m-mQ=0d;8wBwBR8}RiDFx#5IbOsw`b6v`q#ap#KY+;dE((Qq}7*;|@Hx!}#w10XXoM AbN~PV delta 3082 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 literal 29045 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 G@BaZpTyaF`h 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 NWx@0{zWA(t>c1S~!$<%C diff --git a/packages/rs-sdk/tests/vectors/test_data_contracts_1_ok_1_nx/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json b/packages/rs-sdk/tests/vectors/test_data_contracts_1_ok_1_nx/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json new file mode 100644 index 00000000000..e18b2a7deac --- /dev/null +++ b/packages/rs-sdk/tests/vectors/test_data_contracts_1_ok_1_nx/quorum_pubkey-106-3603d12872604475619be7ad682f8339ad60debd43b3f430bd12d51eac268936.json @@ -0,0 +1 @@ +b751df5b612ece651a4d290fa95fab328d5b186b84fc88b103bb45cdf6d3815620b74daa0d72067d74ea86da595c6a59 \ No newline at end of file diff --git a/packages/rs-sdk/tests/vectors/test_data_contracts_1_ok_1_nx/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json b/packages/rs-sdk/tests/vectors/test_data_contracts_1_ok_1_nx/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json deleted file mode 100644 index 5992d970292..00000000000 --- a/packages/rs-sdk/tests/vectors/test_data_contracts_1_ok_1_nx/quorum_pubkey-106-6b957c585f866e7d826afcd92d1a891ce226199229e3031f71994d14dd32f088.json +++ /dev/null @@ -1 +0,0 @@ -b4d9b2ac8940208c9b5a4182518b6792b89c7e08caa3f6b83a1f81526346d2be47f9c1d9c2b26a9d73103c8c2e525dd0 \ No newline at end of file From 4f25cf45cd33a9d285818357a2ff1e96d996bbb6 Mon Sep 17 00:00:00 2001 From: pauldelucia Date: Wed, 9 Apr 2025 18:54:24 +0700 Subject: [PATCH 4/6] fix linting --- .../src/drive/contract/insert/add_description/v0/mod.rs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs b/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs index 84b714a92b3..855724c9c8b 100644 --- a/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs +++ b/packages/rs-drive/src/drive/contract/insert/add_description/v0/mod.rs @@ -174,12 +174,11 @@ impl Drive { Err(e) => return Err(e), }; - let document_type_name; - if full_description { - document_type_name = "fullDescription".to_string(); + let document_type_name = if full_description { + "fullDescription".to_string() } else { - document_type_name = "shortDescription".to_string(); - } + "shortDescription".to_string() + }; let document_id = Document::generate_document_id_v0( &contract_id, From b64cd5dee3c5517ed0d92b0d46e8662e307f4f69 Mon Sep 17 00:00:00 2001 From: pauldelucia Date: Wed, 9 Apr 2025 21:31:41 +0700 Subject: [PATCH 5/6] fix create genesis state --- .../create_genesis_state/test/tokens.rs | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/test/tokens.rs b/packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/test/tokens.rs index 56298b1ce80..5b5aab870f6 100644 --- a/packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/test/tokens.rs +++ b/packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/test/tokens.rs @@ -224,9 +224,18 @@ impl Platform { emergency_action_rules: ChangeControlRulesV0::default().into(), main_control_group: None, main_control_group_can_be_modified: Default::default(), - description: Some("some token description".to_string()), + description: Some("Some token description".to_string()), }); + token_configuration.conventions.localizations.insert( + "en".to_string(), + TokenConfigurationLocalization::V0(TokenConfigurationLocalizationV0 { + should_capitalize, + singular_form: "cat".to_string(), + plural_form: "cats".to_string(), + }), + ); + let tokens = [ (0, token_configuration.clone()), (1, token_configuration.clone()), @@ -249,8 +258,8 @@ impl Platform { updated_at_epoch: None, groups, tokens, - keywords: vec!["key1".into(), "key2".into()], - description: Some("some contract description".to_string()), + keywords: vec!["cat".into(), "white".into()], + description: Some("Some contract description".to_string()), }); self.drive.apply_contract( From 309332dc9927741758295034f79211e9a1c35d62 Mon Sep 17 00:00:00 2001 From: pauldelucia Date: Wed, 9 Apr 2025 21:40:34 +0700 Subject: [PATCH 6/6] feat: add description accessors --- .../token_configuration/accessors/mod.rs | 14 ++++++++++++++ .../token_configuration/accessors/v0/mod.rs | 16 +++++++++++++++- .../token_configuration/v0/accessors.rs | 10 ++++++++++ 3 files changed, 39 insertions(+), 1 deletion(-) diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/accessors/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/accessors/mod.rs index 662ab19373f..31bc9009da0 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/accessors/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/accessors/mod.rs @@ -142,6 +142,13 @@ impl TokenConfigurationV0Getters for TokenConfiguration { TokenConfiguration::V0(v0) => v0.all_used_group_positions(), } } + + /// Returns the token description. + fn description(&self) -> &Option { + match self { + TokenConfiguration::V0(v0) => v0.description(), + } + } } /// Implementing TokenConfigurationV0Setters for TokenConfiguration @@ -240,4 +247,11 @@ impl TokenConfigurationV0Setters for TokenConfiguration { TokenConfiguration::V0(v0) => v0.set_main_control_group_can_be_modified(action_takers), } } + + /// Sets the token description. + fn set_description(&mut self, description: Option) { + match self { + TokenConfiguration::V0(v0) => v0.set_description(description), + } + } } diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/accessors/v0/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/accessors/v0/mod.rs index 59fa3d34b6c..093d4622ea9 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/accessors/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/accessors/v0/mod.rs @@ -14,13 +14,17 @@ pub trait TokenConfigurationV0Getters { /// Returns a mutable reference to the conventions. fn conventions_mut(&mut self) -> &mut TokenConfigurationConvention; + /// Returns the new tokens destination identity rules. fn conventions_change_rules(&self) -> &ChangeControlRules; /// Returns the base supply. fn base_supply(&self) -> TokenAmount; - /// Returns the base supply. + + /// Returns the KeepsHistory rules. fn keeps_history(&self) -> &TokenKeepsHistoryRules; + + /// Returns if we start as paused. fn start_as_paused(&self) -> bool; /// Returns the maximum supply. @@ -46,8 +50,10 @@ pub trait TokenConfigurationV0Getters { /// Returns the unfreeze rules. fn unfreeze_rules(&self) -> &ChangeControlRules; + /// Returns the destroy frozen funds rules. fn destroy_frozen_funds_rules(&self) -> &ChangeControlRules; + /// Returns the emergency action rules. fn emergency_action_rules(&self) -> &ChangeControlRules; @@ -59,6 +65,9 @@ pub trait TokenConfigurationV0Getters { /// Returns all group positions used in the token configuration fn all_used_group_positions(&self) -> BTreeSet; + + /// Returns the token description. + fn description(&self) -> &Option; } /// Accessor trait for setters of `TokenConfigurationV0` @@ -92,8 +101,10 @@ pub trait TokenConfigurationV0Setters { /// Sets the unfreeze rules. fn set_unfreeze_rules(&mut self, rules: ChangeControlRules); + /// Sets the `destroy frozen funds` rules. fn set_destroy_frozen_funds_rules(&mut self, rules: ChangeControlRules); + /// Sets the emergency action rules. fn set_emergency_action_rules(&mut self, rules: ChangeControlRules); @@ -102,4 +113,7 @@ pub trait TokenConfigurationV0Setters { /// Sets the main control group can be modified. fn set_main_control_group_can_be_modified(&mut self, action_takers: AuthorizedActionTakers); + + /// Sets the token description. + fn set_description(&mut self, description: Option); } diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/accessors.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/accessors.rs index 2e7c1353ad4..889df4e4d0a 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/accessors.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/accessors.rs @@ -149,6 +149,11 @@ impl TokenConfigurationV0Getters for TokenConfigurationV0 { group_positions } + + /// Returns the token description. + fn description(&self) -> &Option { + &self.description + } } /// Implementing `TokenConfigurationV0Setters` for `TokenConfigurationV0` @@ -220,4 +225,9 @@ impl TokenConfigurationV0Setters for TokenConfigurationV0 { fn set_main_control_group_can_be_modified(&mut self, action_takers: AuthorizedActionTakers) { self.main_control_group_can_be_modified = action_takers; } + + /// Sets the token description. + fn set_description(&mut self, description: Option) { + self.description = description; + } }