test(drive): add comprehensive tests for state_transition_action module (#3229)

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

Author: QuantumExplorer

packages/rs-drive-proof-verifier/src/proof.rs

@@ -2458,9 +2458,12 @@ impl FromProof<platform::GetMostRecentShieldedAnchorRequest> for MostRecentShiel
         let proof = response.proof().or(Err(Error::NoProofInResult))?;
         let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;
 
-        let (root_hash, maybe_anchor) =
-            Drive::verify_most_recent_shielded_anchor(&proof.grovedb_proof, false, platform_version)
-                .map_drive_error(proof, mtd)?;
+        let (root_hash, maybe_anchor) = Drive::verify_most_recent_shielded_anchor(
+            &proof.grovedb_proof,
+            false,
+            platform_version,
+        )
+        .map_drive_error(proof, mtd)?;
 
         verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;
 
@@ -2576,11 +2579,12 @@ impl FromProof<platform::GetShieldedNullifiersRequest> for ShieldedNullifierStat
                 statuses
                     .into_iter()
                     .map(|(nullifier, is_spent)| {
-                        let nullifier: [u8; 32] = nullifier.try_into().map_err(|_| {
-                            Error::ResultEncodingError {
-                                error: "nullifier from Drive proof is not 32 bytes".to_string(),
-                            }
-                        })?;
+                        let nullifier: [u8; 32] =
+                            nullifier
+                                .try_into()
+                                .map_err(|_| Error::ResultEncodingError {
+                                    error: "nullifier from Drive proof is not 32 bytes".to_string(),
+                                })?;
                         Ok(ShieldedNullifierStatus {
                             nullifier,
                             is_spent,

packages/rs-drive/src/state_transition_action/action_convert_to_operations/address_funds/address_credit_withdrawal_transition.rs

@@ -82,3 +82,161 @@ impl DriveHighLevelOperationConverter for AddressCreditWithdrawalTransitionActio
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::state_transition_action::address_funds::address_credit_withdrawal::v0::AddressCreditWithdrawalTransitionActionV0;
+    use dpp::address_funds::PlatformAddress;
+    use dpp::block::epoch::Epoch;
+    use dpp::document::{Document, DocumentV0};
+    use dpp::prelude::Identifier;
+    use dpp::version::PlatformVersion;
+    use std::collections::BTreeMap;
+
+    fn make_document() -> Document {
+        Document::V0(DocumentV0 {
+            id: Identifier::from([0x11; 32]),
+            owner_id: Identifier::from([0x22; 32]),
+            properties: Default::default(),
+            revision: Some(1),
+            created_at: None,
+            updated_at: None,
+            transferred_at: None,
+            created_at_block_height: None,
+            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,
+            creator_id: None,
+        })
+    }
+
+    fn make_action_with_output() -> AddressCreditWithdrawalTransitionAction {
+        let addr_a = PlatformAddress::P2pkh([0xAA; 20]);
+        let addr_b = PlatformAddress::P2sh([0xCC; 20]);
+
+        let mut inputs = BTreeMap::new();
+        inputs.insert(addr_a, (5_u32, 10000_u64));
+
+        AddressCreditWithdrawalTransitionAction::V0(AddressCreditWithdrawalTransitionActionV0 {
+            inputs_with_remaining_balance: inputs,
+            output: Some((addr_b, 2000)),
+            fee_strategy: vec![],
+            user_fee_increase: 0,
+            prepared_withdrawal_document: make_document(),
+            amount: 8000,
+        })
+    }
+
+    fn make_action_no_output() -> AddressCreditWithdrawalTransitionAction {
+        let addr_a = PlatformAddress::P2pkh([0xAA; 20]);
+
+        let mut inputs = BTreeMap::new();
+        inputs.insert(addr_a, (5_u32, 2000_u64));
+
+        AddressCreditWithdrawalTransitionAction::V0(AddressCreditWithdrawalTransitionActionV0 {
+            inputs_with_remaining_balance: inputs,
+            output: None,
+            fee_strategy: vec![],
+            user_fee_increase: 0,
+            prepared_withdrawal_document: make_document(),
+            amount: 8000,
+        })
+    }
+
+    #[test]
+    fn test_with_output_produces_correct_operation_count() {
+        let action = make_action_with_output();
+        let epoch = Epoch::new(0).unwrap();
+        let platform_version = PlatformVersion::latest();
+
+        let ops = action
+            .into_high_level_drive_operations(&epoch, platform_version)
+            .expect("expected operations");
+
+        // SetBalanceToAddress (1 input) + AddBalanceToAddress (output)
+        // + AddWithdrawalDocument + RemoveFromSystemCredits
+        assert_eq!(ops.len(), 4);
+    }
+
+    #[test]
+    fn test_without_output_produces_correct_operation_count() {
+        let action = make_action_no_output();
+        let epoch = Epoch::new(0).unwrap();
+        let platform_version = PlatformVersion::latest();
+
+        let ops = action
+            .into_high_level_drive_operations(&epoch, platform_version)
+            .expect("expected operations");
+
+        // SetBalanceToAddress (1 input) + AddWithdrawalDocument + RemoveFromSystemCredits
+        assert_eq!(ops.len(), 3);
+    }
+
+    #[test]
+    fn test_input_balances_are_set() {
+        let action = make_action_with_output();
+        let epoch = Epoch::new(0).unwrap();
+        let platform_version = PlatformVersion::latest();
+
+        let ops = action
+            .into_high_level_drive_operations(&epoch, platform_version)
+            .expect("expected operations");
+
+        match &ops[0] {
+            AddressFundsOperation(AddressFundsOperationType::SetBalanceToAddress {
+                address,
+                nonce,
+                balance,
+            }) => {
+                assert_eq!(*address, PlatformAddress::P2pkh([0xAA; 20]));
+                assert_eq!(*nonce, 5);
+                assert_eq!(*balance, 10000);
+            }
+            other => panic!("expected SetBalanceToAddress, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn test_system_credits_removal_matches_amount() {
+        let action = make_action_with_output();
+        let epoch = Epoch::new(0).unwrap();
+        let platform_version = PlatformVersion::latest();
+
+        let ops = action
+            .into_high_level_drive_operations(&epoch, platform_version)
+            .expect("expected operations");
+
+        let last = ops.last().unwrap();
+        match last {
+            SystemOperation(SystemOperationType::RemoveFromSystemCredits { amount }) => {
+                assert_eq!(*amount, 8000);
+            }
+            other => panic!("expected RemoveFromSystemCredits, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn test_has_withdrawal_document_operation() {
+        let action = make_action_with_output();
+        let epoch = Epoch::new(0).unwrap();
+        let platform_version = PlatformVersion::latest();
+
+        let ops = action
+            .into_high_level_drive_operations(&epoch, platform_version)
+            .expect("expected operations");
+
+        let has_withdrawal_doc = ops.iter().any(|op| {
+            matches!(
+                op,
+                DocumentOperation(DocumentOperationType::AddWithdrawalDocument { .. })
+            )
+        });
+        assert!(
+            has_withdrawal_doc,
+            "expected AddWithdrawalDocument operation"
+        );
+    }
+}

packages/rs-drive/src/state_transition_action/action_convert_to_operations/address_funds/address_funding_from_asset_lock_transition.rs

@@ -89,3 +89,139 @@ impl DriveHighLevelOperationConverter for AddressFundingFromAssetLockTransitionA
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::state_transition_action::address_funds::address_funding_from_asset_lock::v0::AddressFundingFromAssetLockTransitionActionV0;
+    use dpp::address_funds::PlatformAddress;
+    use dpp::asset_lock::reduced_asset_lock_value::AssetLockValue;
+    use dpp::block::epoch::Epoch;
+    use dpp::platform_value::Bytes36;
+    use dpp::state_transition::signable_bytes_hasher::SignableBytesHasher;
+    use dpp::version::PlatformVersion;
+    use std::collections::BTreeMap;
+
+    fn make_asset_lock_value(remaining: u64) -> AssetLockValue {
+        AssetLockValue::new(
+            remaining + 1000,
+            vec![0xDE, 0xAD],
+            remaining,
+            vec![],
+            PlatformVersion::latest(),
+        )
+        .expect("should create AssetLockValue")
+    }
+
+    fn make_action() -> AddressFundingFromAssetLockTransitionAction {
+        let addr_input = PlatformAddress::P2pkh([0xAA; 20]);
+        let addr_explicit = PlatformAddress::P2pkh([0xBB; 20]);
+        let addr_remainder = PlatformAddress::P2sh([0xCC; 20]);
+
+        let mut inputs = BTreeMap::new();
+        inputs.insert(addr_input, (1_u32, 2000_u64));
+
+        let mut outputs = BTreeMap::new();
+        outputs.insert(addr_explicit, Some(3000_u64));
+        outputs.insert(addr_remainder, None);
+
+        AddressFundingFromAssetLockTransitionAction::V0(
+            AddressFundingFromAssetLockTransitionActionV0 {
+                signable_bytes_hasher: SignableBytesHasher::Bytes(vec![0xFF; 8]),
+                asset_lock_value_to_be_consumed: make_asset_lock_value(5000),
+                asset_lock_outpoint: Bytes36([0xDD; 36]),
+                inputs_with_remaining_balance: inputs,
+                outputs,
+                input_contributions_total: 2000,
+                fee_strategy: vec![],
+                user_fee_increase: 0,
+            },
+        )
+    }
+
+    #[test]
+    fn test_produces_system_input_and_output_operations() {
+        let action = make_action();
+        let epoch = Epoch::new(0).unwrap();
+        let platform_version = PlatformVersion::latest();
+
+        let ops = action
+            .into_high_level_drive_operations(&epoch, platform_version)
+            .expect("expected operations");
+
+        // AddToSystemCredits + AddUsedAssetLock + SetBalanceToAddress (1 input)
+        // + AddBalanceToAddress (explicit) + AddBalanceToAddress (remainder)
+        assert_eq!(ops.len(), 5);
+    }
+
+    #[test]
+    fn test_first_op_is_add_to_system_credits() {
+        let action = make_action();
+        let epoch = Epoch::new(0).unwrap();
+        let platform_version = PlatformVersion::latest();
+
+        let ops = action
+            .into_high_level_drive_operations(&epoch, platform_version)
+            .expect("expected operations");
+
+        match &ops[0] {
+            DriveOperation::SystemOperation(SystemOperationType::AddToSystemCredits { amount }) => {
+                assert_eq!(*amount, 5000); // remaining asset lock value
+            }
+            other => panic!("expected AddToSystemCredits, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn test_second_op_is_add_used_asset_lock() {
+        let action = make_action();
+        let epoch = Epoch::new(0).unwrap();
+        let platform_version = PlatformVersion::latest();
+
+        let ops = action
+            .into_high_level_drive_operations(&epoch, platform_version)
+            .expect("expected operations");
+
+        match &ops[1] {
+            DriveOperation::SystemOperation(SystemOperationType::AddUsedAssetLock {
+                asset_lock_outpoint,
+                asset_lock_value,
+            }) => {
+                assert_eq!(*asset_lock_outpoint, Bytes36([0xDD; 36]));
+                // remaining should be 0 after consumption
+                use dpp::asset_lock::reduced_asset_lock_value::AssetLockValueGettersV0;
+                assert_eq!(asset_lock_value.remaining_credit_value(), 0);
+            }
+            other => panic!("expected AddUsedAssetLock, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn test_no_inputs_produces_only_system_and_output_ops() {
+        let addr_output = PlatformAddress::P2pkh([0xBB; 20]);
+        let mut outputs = BTreeMap::new();
+        outputs.insert(addr_output, Some(5000_u64));
+
+        let action = AddressFundingFromAssetLockTransitionAction::V0(
+            AddressFundingFromAssetLockTransitionActionV0 {
+                signable_bytes_hasher: SignableBytesHasher::Bytes(vec![]),
+                asset_lock_value_to_be_consumed: make_asset_lock_value(5000),
+                asset_lock_outpoint: Bytes36([0xDD; 36]),
+                inputs_with_remaining_balance: BTreeMap::new(),
+                outputs,
+                input_contributions_total: 0,
+                fee_strategy: vec![],
+                user_fee_increase: 0,
+            },
+        );
+        let epoch = Epoch::new(0).unwrap();
+        let platform_version = PlatformVersion::latest();
+
+        let ops = action
+            .into_high_level_drive_operations(&epoch, platform_version)
+            .expect("expected operations");
+
+        // AddToSystemCredits + AddUsedAssetLock + AddBalanceToAddress
+        assert_eq!(ops.len(), 3);
+    }
+}