test(drive): add comprehensive tests for verify module (#3233)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: QuantumExplorer

packages/rs-drive/src/verify/address_funds/verify_address_funds_branch_query/mod.rs

@@ -59,3 +59,32 @@ impl Drive {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use platform_version::version::PlatformVersion;
+
+    #[test]
+    fn test_verify_address_funds_branch_query_unknown_version_mismatch() {
+        let mut platform_version = PlatformVersion::latest().clone();
+        platform_version
+            .drive
+            .methods
+            .verify
+            .address_funds
+            .verify_address_funds_branch_query = 255;
+
+        let result =
+            Drive::verify_address_funds_branch_query(&[], vec![], 0, [0u8; 32], &platform_version);
+
+        assert!(
+            matches!(
+                result,
+                Err(Error::Drive(DriveError::UnknownVersionMismatch { .. }))
+            ),
+            "expected UnknownVersionMismatch, got {:?}",
+            result,
+        );
+    }
+}

packages/rs-drive/src/verify/address_funds/verify_address_funds_trunk_query/mod.rs

@@ -48,3 +48,31 @@ impl Drive {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use platform_version::version::PlatformVersion;
+
+    #[test]
+    fn test_verify_address_funds_trunk_query_unknown_version_mismatch() {
+        let mut platform_version = PlatformVersion::latest().clone();
+        platform_version
+            .drive
+            .methods
+            .verify
+            .address_funds
+            .verify_address_funds_trunk_query = 255;
+
+        let result = Drive::verify_address_funds_trunk_query(&[], &platform_version);
+
+        assert!(
+            matches!(
+                result,
+                Err(Error::Drive(DriveError::UnknownVersionMismatch { .. }))
+            ),
+            "expected UnknownVersionMismatch, got {:?}",
+            result,
+        );
+    }
+}

packages/rs-drive/src/verify/address_funds/verify_address_info/mod.rs

@@ -60,3 +60,34 @@ impl Drive {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use dpp::address_funds::PlatformAddress;
+    use dpp::version::PlatformVersion;
+
+    #[test]
+    fn test_verify_address_info_unknown_version_mismatch() {
+        let mut platform_version = PlatformVersion::latest().clone();
+        platform_version
+            .drive
+            .methods
+            .verify
+            .address_funds
+            .verify_address_info = 255;
+
+        let address = PlatformAddress::P2pkh([0u8; 20]);
+
+        let result = Drive::verify_address_info(&[], &address, false, &platform_version);
+
+        assert!(
+            matches!(
+                result,
+                Err(Error::Drive(DriveError::UnknownVersionMismatch { .. }))
+            ),
+            "expected UnknownVersionMismatch, got {:?}",
+            result,
+        );
+    }
+}

packages/rs-drive/src/verify/address_funds/verify_address_info/v0/mod.rs

@@ -66,3 +66,83 @@ impl Drive {
         Ok((root_hash, balance_info))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::util::batch::drive_op_batch::{AddressFundsOperationType, DriveOperation};
+    use crate::util::test_helpers::setup::setup_drive_with_initial_state_structure;
+    use dpp::block::block_info::BlockInfo;
+    use dpp::fee::Credits;
+    use dpp::prelude::AddressNonce;
+
+    const ADDRESS_1: PlatformAddress = PlatformAddress::P2pkh([10; 20]);
+    const ADDRESS_1_NONCE: AddressNonce = 5;
+    const ADDRESS_1_BALANCE: Credits = 1_000_000;
+    const UNKNOWN_ADDRESS: PlatformAddress = PlatformAddress::P2pkh([200; 20]);
+
+    fn setup_address(drive: &Drive, platform_version: &PlatformVersion) {
+        let operations = vec![DriveOperation::AddressFundsOperation(
+            AddressFundsOperationType::SetBalanceToAddress {
+                address: ADDRESS_1,
+                nonce: ADDRESS_1_NONCE,
+                balance: ADDRESS_1_BALANCE,
+            },
+        )];
+
+        drive
+            .apply_drive_operations(
+                operations,
+                true,
+                &BlockInfo::default(),
+                None,
+                platform_version,
+                None,
+            )
+            .expect("expected to apply operations");
+    }
+
+    #[test]
+    fn should_prove_and_verify_single_address_info() {
+        let drive = setup_drive_with_initial_state_structure(None);
+        let platform_version = PlatformVersion::latest();
+
+        setup_address(&drive, platform_version);
+
+        // Prove single address
+        let proof = drive
+            .prove_balance_and_nonce(&ADDRESS_1, None, platform_version)
+            .expect("should prove address");
+
+        // Verify the proof
+        let (root_hash, result) =
+            Drive::verify_address_info(proof.as_slice(), &ADDRESS_1, false, platform_version)
+                .expect("should verify proof");
+
+        assert!(!root_hash.is_empty(), "root hash should not be empty");
+        let (nonce, balance) = result.expect("should have value");
+        assert_eq!(nonce, ADDRESS_1_NONCE);
+        assert_eq!(balance, ADDRESS_1_BALANCE);
+    }
+
+    #[test]
+    fn should_prove_and_verify_absent_address_info() {
+        let drive = setup_drive_with_initial_state_structure(None);
+        let platform_version = PlatformVersion::latest();
+
+        setup_address(&drive, platform_version);
+
+        // Prove unknown address
+        let proof = drive
+            .prove_balance_and_nonce(&UNKNOWN_ADDRESS, None, platform_version)
+            .expect("should prove unknown address");
+
+        // Verify the proof
+        let (root_hash, result) =
+            Drive::verify_address_info(proof.as_slice(), &UNKNOWN_ADDRESS, false, platform_version)
+                .expect("should verify proof");
+
+        assert!(!root_hash.is_empty(), "root hash should not be empty");
+        assert!(result.is_none(), "unknown address should be absent");
+    }
+}

packages/rs-drive/src/verify/address_funds/verify_addresses_infos/mod.rs

@@ -67,3 +67,37 @@ impl Drive {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use dpp::address_funds::PlatformAddress;
+    use dpp::version::PlatformVersion;
+
+    #[test]
+    fn test_verify_addresses_infos_unknown_version_mismatch() {
+        let mut platform_version = PlatformVersion::latest().clone();
+        platform_version
+            .drive
+            .methods
+            .verify
+            .address_funds
+            .verify_addresses_infos = 255;
+
+        let addresses: Vec<PlatformAddress> = vec![];
+
+        let result = Drive::verify_addresses_infos::<
+            std::slice::Iter<PlatformAddress>,
+            Vec<(PlatformAddress, Option<(AddressNonce, Credits)>)>,
+        >(&[], addresses.iter(), false, &platform_version);
+
+        assert!(
+            matches!(
+                result,
+                Err(Error::Drive(DriveError::UnknownVersionMismatch { .. }))
+            ),
+            "expected UnknownVersionMismatch, got {:?}",
+            result,
+        );
+    }
+}

packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/mod.rs

@@ -61,3 +61,32 @@ impl Drive {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use dpp::version::PlatformVersion;
+
+    #[test]
+    fn test_verify_compacted_address_balance_changes_unknown_version_mismatch() {
+        let mut platform_version = PlatformVersion::latest().clone();
+        platform_version
+            .drive
+            .methods
+            .verify
+            .address_funds
+            .verify_compacted_address_balance_changes = 255;
+
+        let result =
+            Drive::verify_compacted_address_balance_changes(&[], 0, None, &platform_version);
+
+        assert!(
+            matches!(
+                result,
+                Err(Error::Drive(DriveError::UnknownVersionMismatch { .. }))
+            ),
+            "expected UnknownVersionMismatch, got {:?}",
+            result,
+        );
+    }
+}

packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/v0/mod.rs

@@ -201,7 +201,102 @@ impl Drive {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::util::test_helpers::setup::setup_drive_with_initial_state_structure;
+    use dpp::address_funds::PlatformAddress;
+    use dpp::balances::credits::CreditOperation;
     use platform_version::version::PlatformVersion;
+    use std::collections::BTreeMap;
+
+    #[test]
+    fn should_prove_and_verify_compacted_address_balance_changes_roundtrip() {
+        let drive = setup_drive_with_initial_state_structure(None);
+        let platform_version = PlatformVersion::latest();
+
+        let address_1 = PlatformAddress::P2pkh([10; 20]);
+        let address_2 = PlatformAddress::P2sh([11; 20]);
+
+        // Store enough blocks of changes to trigger compaction
+        // The compaction threshold is controlled by platform_version
+        // We insert many blocks to ensure compaction happens
+        let max_blocks = platform_version
+            .drive
+            .methods
+            .saved_block_transactions
+            .max_blocks_before_compaction as u64;
+
+        for block_height in 1u64..=(max_blocks + 1) {
+            let mut changes = BTreeMap::new();
+            changes.insert(
+                address_1,
+                CreditOperation::AddToCredits(block_height * 1000),
+            );
+            if block_height % 2 == 0 {
+                changes.insert(address_2, CreditOperation::AddToCredits(block_height * 500));
+            }
+            drive
+                .store_address_balances_for_block(
+                    &changes,
+                    block_height,
+                    block_height * 1000,
+                    None,
+                    platform_version,
+                )
+                .expect("should store balances");
+        }
+
+        // Prove compacted changes from block 1
+        let proof = drive
+            .prove_compacted_address_balance_changes(1, None, None, platform_version)
+            .expect("should prove compacted address balance changes");
+
+        // Verify the proof
+        let (root_hash, compacted_changes) = Drive::verify_compacted_address_balance_changes(
+            proof.as_slice(),
+            1,
+            None,
+            platform_version,
+        )
+        .expect("should verify proof");
+
+        assert!(!root_hash.is_empty(), "root hash should not be empty");
+        // We should have at least one compacted entry
+        assert!(
+            !compacted_changes.is_empty(),
+            "should have at least one compacted entry"
+        );
+
+        // All entries should have valid block ranges
+        for (start, end, changes) in &compacted_changes {
+            assert!(*start <= *end, "start should be <= end");
+            assert!(!changes.is_empty(), "each entry should have changes");
+        }
+    }
+
+    #[test]
+    fn should_prove_and_verify_empty_compacted_address_balance_changes() {
+        let drive = setup_drive_with_initial_state_structure(None);
+        let platform_version = PlatformVersion::latest();
+
+        // Prove compacted changes from block 100 with no data stored
+        let proof = drive
+            .prove_compacted_address_balance_changes(100, None, None, platform_version)
+            .expect("should prove empty compacted changes");
+
+        // Verify the proof
+        let (root_hash, compacted_changes) = Drive::verify_compacted_address_balance_changes(
+            proof.as_slice(),
+            100,
+            None,
+            platform_version,
+        )
+        .expect("should verify proof");
+
+        assert!(!root_hash.is_empty(), "root hash should not be empty");
+        assert!(
+            compacted_changes.is_empty(),
+            "should have no compacted entries when no data stored"
+        );
+    }
 
     #[test]
     fn test_verify_compacted_address_balance_changes_proof() {
@@ -247,7 +342,7 @@ mod tests {
         let start_block_height = 329u64;
         let platform_version = PlatformVersion::latest();
 
-        let result = Drive::verify_compacted_address_balance_changes_v0(
+        let result = Drive::verify_compacted_address_balance_changes(
             &proof,
             start_block_height,
             None,

packages/rs-drive/src/verify/address_funds/verify_recent_address_balance_changes/mod.rs

@@ -59,3 +59,32 @@ impl Drive {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use dpp::version::PlatformVersion;
+
+    #[test]
+    fn test_verify_recent_address_balance_changes_unknown_version_mismatch() {
+        let mut platform_version = PlatformVersion::latest().clone();
+        platform_version
+            .drive
+            .methods
+            .verify
+            .address_funds
+            .verify_recent_address_balance_changes = 255;
+
+        let result =
+            Drive::verify_recent_address_balance_changes(&[], 0, None, false, &platform_version);
+
+        assert!(
+            matches!(
+                result,
+                Err(Error::Drive(DriveError::UnknownVersionMismatch { .. }))
+            ),
+            "expected UnknownVersionMismatch, got {:?}",
+            result,
+        );
+    }
+}