fix: context: hydrate programs & sysvars every time (#153)

Author: buffalojoec

harness/src/lib.rs

@@ -1155,6 +1155,7 @@ impl Mollusk {
         MolluskContext {
             mollusk: self,
             account_store: Rc::new(RefCell::new(account_store)),
+            hydrate_store: true, // <-- Default
         }
     }
 }
@@ -1179,22 +1180,42 @@ impl Mollusk {
 pub struct MolluskContext<AS: AccountStore> {
     pub mollusk: Mollusk,
     pub account_store: Rc<RefCell<AS>>,
+    pub hydrate_store: bool,
 }
 
 impl<AS: AccountStore> MolluskContext<AS> {
     fn load_accounts_for_instructions<'a>(
         &self,
         instructions: impl Iterator<Item = &'a Instruction>,
     ) -> Vec<(Pubkey, Account)> {
-        let mut seen = HashSet::new();
         let mut accounts = Vec::new();
+
+        // If hydration is enabled, add sysvars and program accounts regardless
+        // of whether or not they exist already.
+        if self.hydrate_store {
+            self.mollusk
+                .program_cache
+                .get_all_keyed_program_accounts()
+                .into_iter()
+                .chain(self.mollusk.sysvars.get_all_keyed_sysvar_accounts())
+                .for_each(|(pubkey, account)| {
+                    accounts.push((pubkey, account));
+                });
+        }
+
+        // Regardless of hydration, only add an account if the caller hasn't
+        // already loaded it into the store.
+        let mut seen = HashSet::new();
         let store = self.account_store.borrow();
         instructions.for_each(|instruction| {
             instruction
                 .accounts
                 .iter()
                 .for_each(|AccountMeta { pubkey, .. }| {
                     if seen.insert(*pubkey) {
+                        // First try to load theirs, then see if it's a sysvar,
+                        // then see if it's a cached program, then apply the
+                        // default.
                         let account = store.get_account(pubkey).unwrap_or_else(|| {
                             self.mollusk
                                 .sysvars

harness/src/sysvar.rs

@@ -127,6 +127,18 @@ impl Sysvars {
         self.sysvar_account(&self.stake_history)
     }
 
+    pub(crate) fn get_all_keyed_sysvar_accounts(&self) -> Vec<(Pubkey, Account)> {
+        vec![
+            self.keyed_account_for_clock_sysvar(),
+            self.keyed_account_for_epoch_rewards_sysvar(),
+            self.keyed_account_for_epoch_schedule_sysvar(),
+            self.keyed_account_for_last_restart_slot_sysvar(),
+            self.keyed_account_for_rent_sysvar(),
+            self.keyed_account_for_slot_hashes_sysvar(),
+            self.keyed_account_for_stake_history_sysvar(),
+        ]
+    }
+
     /// Warp the test environment to a slot by updating sysvars.
     pub fn warp_to_slot(&mut self, slot: Slot) {
         let slot_delta = slot.saturating_sub(self.clock.slot);