harness: add rent-exemption account check (#112)

Author: buffalojoec

harness/src/lib.rs

@@ -387,7 +387,7 @@ use {
     crate::{
         compile_accounts::CompiledAccounts,
         program::ProgramCache,
-        result::{Check, Config, InstructionResult},
+        result::{Check, CheckContext, Config, InstructionResult},
         sysvar::Sysvars,
     },
     agave_feature_set::FeatureSet,
@@ -457,6 +457,12 @@ impl Default for Mollusk {
     }
 }
 
+impl CheckContext for Mollusk {
+    fn is_rent_exempt(&self, lamports: u64, space: usize) -> bool {
+        self.sysvars.rent.is_exempt(lamports, space)
+    }
+}
+
 impl Mollusk {
     /// Create a new Mollusk instance containing the provided program.
     ///
@@ -681,7 +687,7 @@ impl Mollusk {
         #[cfg(any(feature = "fuzz", feature = "fuzz-fd"))]
         fuzz::generate_fixtures_from_mollusk_test(self, instruction, accounts, &result);
 
-        result.run_checks_with_config(checks, &self.config);
+        result.run_checks(checks, &self.config, self);
         result
     }
 

harness/src/result.rs

@@ -5,6 +5,7 @@ use {
     solana_instruction::error::InstructionError,
     solana_program_error::ProgramError,
     solana_pubkey::Pubkey,
+    solana_rent::Rent,
 };
 
 macro_rules! compare {
@@ -122,6 +123,19 @@ impl Default for Config {
     }
 }
 
+/// A trait for providing context to the checks.
+///
+/// Developers who run checks on standalone results, rather than passing checks
+/// directly to methods like `Mollusk::process_and_validate_instruction`, may
+/// wish to customize the context in which the checks are run. For example,
+/// one may wish to evaluate resulting account lamports with a custom `Rent`
+/// configuration. This trait allows such customization.
+pub trait CheckContext {
+    fn is_rent_exempt(&self, lamports: u64, space: usize) -> bool {
+        Rent::default().is_exempt(lamports, space)
+    }
+}
+
 impl InstructionResult {
     /// Get an account from the resulting accounts by its pubkey.
     pub fn get_account(&self, pubkey: &Pubkey) -> Option<&Account> {
@@ -131,8 +145,17 @@ impl InstructionResult {
             .map(|(_, a)| a)
     }
 
-    /// Perform checks on the instruction result.
-    pub fn run_checks_with_config(&self, checks: &[Check], config: &Config) -> bool {
+    /// Perform checks on the instruction result with a custom context.
+    /// See `CheckContext` for more details.
+    ///
+    /// Note: `Mollusk` implements `CheckContext`, in case you don't want to
+    /// define a custom context.
+    pub fn run_checks<C: CheckContext>(
+        &self,
+        checks: &[Check],
+        config: &Config,
+        context: &C,
+    ) -> bool {
         let c = config;
         let mut pass = true;
         for check in checks {
@@ -199,6 +222,17 @@ impl InstructionResult {
                                     resulting_account == &Account::default(),
                                 );
                             }
+                            AccountStateCheck::RentExempt => {
+                                pass &= compare!(
+                                    c,
+                                    "account_rent_exempt",
+                                    true,
+                                    context.is_rent_exempt(
+                                        resulting_account.lamports,
+                                        resulting_account.data.len()
+                                    ),
+                                );
+                            }
                         }
                     }
                     if let Some((offset, check_data_slice)) = account.check_data_slice {
@@ -225,17 +259,6 @@ impl InstructionResult {
         pass
     }
 
-    /// Perform checks on the instruction result, panicking on any mismatches.
-    pub fn run_checks(&self, checks: &[Check]) {
-        self.run_checks_with_config(
-            checks,
-            &Config {
-                panic: true,
-                verbose: true,
-            },
-        );
-    }
-
     pub(crate) fn absorb(&mut self, other: Self) {
         self.compute_units_consumed += other.compute_units_consumed;
         self.execution_time += other.execution_time;
@@ -484,6 +507,7 @@ impl<'a> Check<'a> {
 
 enum AccountStateCheck {
     Closed,
+    RentExempt,
 }
 
 struct AccountCheck<'a> {
@@ -548,6 +572,11 @@ impl<'a> AccountCheckBuilder<'a> {
         self
     }
 
+    pub fn rent_exempt(mut self) -> Self {
+        self.check.check_state = Some(AccountStateCheck::RentExempt);
+        self
+    }
+
     pub fn space(mut self, space: usize) -> Self {
         self.check.check_space = Some(space);
         self

harness/tests/bpf_program.rs

@@ -1,13 +1,14 @@
 use {
     mollusk_svm::{
         program::{create_program_account_loader_v3, keyed_account_for_system_program},
-        result::Check,
+        result::{Check, CheckContext},
         Mollusk,
     },
     solana_account::Account,
     solana_instruction::{error::InstructionError, AccountMeta, Instruction},
     solana_program_error::ProgramError,
     solana_pubkey::Pubkey,
+    solana_rent::Rent,
     solana_system_interface::error::SystemError,
 };
 
@@ -401,3 +402,61 @@ fn test_account_dedupe() {
         );
     }
 }
+
+#[test]
+fn test_account_checks_rent_exemption() {
+    std::env::set_var("SBF_OUT_DIR", "../target/deploy");
+
+    let program_id = Pubkey::new_unique();
+
+    let mut mollusk = Mollusk::new(&program_id, "test_program_primary");
+    mollusk.config.panic = false; // Don't panic, so we can evaluate failing checks.
+
+    let key = Pubkey::new_unique();
+
+    let data_len = 8;
+    let data = vec![4; data_len];
+
+    let rent_exempt_lamports = mollusk.sysvars.rent.minimum_balance(data_len);
+    let not_rent_exempt_lamports = rent_exempt_lamports - 1;
+
+    struct TestCheckContext<'a> {
+        rent: &'a Rent,
+    }
+
+    impl CheckContext for TestCheckContext<'_> {
+        fn is_rent_exempt(&self, lamports: u64, space: usize) -> bool {
+            self.rent.is_exempt(lamports, space)
+        }
+    }
+
+    let get_result = |lamports: u64| {
+        mollusk
+            .process_and_validate_instruction(
+                &Instruction::new_with_bytes(
+                    program_id,
+                    &{
+                        let mut instruction_data = vec![1]; // `WriteData`
+                        instruction_data.extend_from_slice(&data);
+                        instruction_data
+                    },
+                    vec![AccountMeta::new(key, true)],
+                ),
+                &[(key, Account::new(lamports, data_len, &program_id))],
+                &[Check::success()], // It should still pass.
+            )
+            .run_checks(
+                &[Check::account(&key).rent_exempt().build()],
+                &mollusk.config,
+                &TestCheckContext {
+                    rent: &mollusk.sysvars.rent,
+                },
+            )
+    };
+
+    // Fail not rent exempt.
+    assert!(!get_result(not_rent_exempt_lamports));
+
+    // Success rent exempt.
+    assert!(get_result(rent_exempt_lamports));
+}