fix: sdk should ignore transient fields when verifying proofs (#2000)

packages/rs-dpp/src/document/document_methods/is_equal_ignoring_timestamps/v0/mod.rs

@@ -1,5 +1,7 @@
 use crate::document::document_methods::DocumentGetRawForDocumentTypeV0;
 use crate::document::DocumentV0Getters;
+use platform_value::Value;
+use std::collections::BTreeMap;
 
 pub trait DocumentIsEqualIgnoringTimestampsV0:
     DocumentV0Getters + DocumentGetRawForDocumentTypeV0
@@ -11,10 +13,31 @@ pub trait DocumentIsEqualIgnoringTimestampsV0:
     ///     created_at/updated_at
     ///     created_at_block_height/updated_at_block_height
     ///     created_at_core_block_height/updated_at_core_block_height
-    fn is_equal_ignoring_time_based_fields_v0(&self, rhs: &Self) -> bool {
+    fn is_equal_ignoring_time_based_fields_v0(
+        &self,
+        rhs: &Self,
+        also_ignore_fields: Option<Vec<&str>>,
+    ) -> bool {
+        fn filtered_properties<'a>(
+            properties: &'a BTreeMap<String, Value>,
+            ignore_fields: &Vec<&str>,
+        ) -> BTreeMap<&'a String, &'a Value> {
+            properties
+                .iter()
+                .filter(|(key, _)| !ignore_fields.contains(&key.as_str()))
+                .collect()
+        }
+
+        let properties_equal = if let Some(fields) = &also_ignore_fields {
+            filtered_properties(self.properties(), fields)
+                == filtered_properties(rhs.properties(), fields)
+        } else {
+            self.properties() == rhs.properties()
+        };
+
         self.id() == rhs.id()
             && self.owner_id() == rhs.owner_id()
-            && self.properties() == rhs.properties()
+            && properties_equal
             && self.revision() == rhs.revision()
     }
 }

packages/rs-dpp/src/document/document_methods/mod.rs

@@ -52,6 +52,7 @@ pub trait DocumentMethodsV0 {
     fn is_equal_ignoring_time_based_fields(
         &self,
         rhs: &Self,
+        also_ignore_fields: Option<Vec<&str>>,
         platform_version: &PlatformVersion,
     ) -> Result<bool, ProtocolError>;
 }

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

@@ -183,6 +183,7 @@ impl DocumentMethodsV0 for Document {
     fn is_equal_ignoring_time_based_fields(
         &self,
         rhs: &Self,
+        also_ignore_fields: Option<Vec<&str>>,
         platform_version: &PlatformVersion,
     ) -> Result<bool, ProtocolError> {
         match (self, rhs) {
@@ -193,7 +194,8 @@ impl DocumentMethodsV0 for Document {
                     .document_method_versions
                     .is_equal_ignoring_timestamps
                 {
-                    0 => Ok(document_v0.is_equal_ignoring_time_based_fields_v0(rhs_v0)),
+                    0 => Ok(document_v0
+                        .is_equal_ignoring_time_based_fields_v0(rhs_v0, also_ignore_fields)),
                     version => Err(ProtocolError::UnknownVersionMismatch {
                         method: "DocumentMethodV0::is_equal_ignoring_time_based_fields".to_string(),
                         known_versions: vec![0],

packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/documents_batch/mod.rs

@@ -5833,10 +5833,20 @@ mod tests {
                 .expect("expected to get back documents")
                 .documents_owned();
 
+            let transient_fields = domain
+                .transient_fields()
+                .iter()
+                .map(|a| a.as_str())
+                .collect();
+
             assert!(documents
                 .get(0)
                 .expect("expected a document")
-                .is_equal_ignoring_time_based_fields(&document_3, platform_version)
+                .is_equal_ignoring_time_based_fields(
+                    &document_3,
+                    Some(transient_fields),
+                    platform_version
+                )
                 .expect("expected to run is equal"));
 
             let drive_query = DriveDocumentQuery {

packages/rs-drive/src/verify/state_transition/verify_state_transition_was_executed_with_proof/v0/mod.rs

@@ -165,8 +165,15 @@ impl Drive {
                             platform_version,
                         )?;
 
+                        let transient_fields = document_type
+                            .transient_fields()
+                            .iter()
+                            .map(|a| a.as_str())
+                            .collect();
+
                         if !document.is_equal_ignoring_time_based_fields(
                             &expected_document,
+                            Some(transient_fields),
                             platform_version,
                         )? {
                             return Err(Error::Proof(ProofError::IncorrectProof(format!("proof of state transition execution did not contain expected document (time fields were not checked) after create with id {}", create_transition.base().id()))));
@@ -192,8 +199,15 @@ impl Drive {
                             platform_version,
                         )?;
 
+                        let transient_fields = document_type
+                            .transient_fields()
+                            .iter()
+                            .map(|a| a.as_str())
+                            .collect();
+
                         if !document.is_equal_ignoring_time_based_fields(
                             &expected_document,
+                            Some(transient_fields),
                             platform_version,
                         )? {
                             return Err(Error::Proof(ProofError::IncorrectProof(format!("proof of state transition execution did not contain expected document (time fields were not checked) after replace with id {}", replace_transition.base().id()))));