Supports rehashing with accounts lt hash (solana-labs#3186)

runtime/src/bank.rs

@@ -2928,6 +2928,11 @@ impl Bank {
 
             // freeze is a one-way trip, idempotent
             self.freeze_started.store(true, Relaxed);
+            if self.is_accounts_lt_hash_enabled() {
+                // updating the accounts lt hash must happen *outside* of hash_internal_state() so
+                // that rehash() can be called and *not* modify self.accounts_lt_hash.
+                self.update_accounts_lt_hash();
+            }
             *hash = self.hash_internal_state();
             self.rc.accounts.accounts_db.mark_slot_frozen(self.slot());
         }
@@ -5454,10 +5459,6 @@ impl Bank {
             hash = hashv(&[hash.as_ref(), epoch_accounts_hash.as_ref().as_ref()]);
         };
 
-        let accounts_lt_hash_checksum = self
-            .is_accounts_lt_hash_enabled()
-            .then(|| self.update_accounts_lt_hash());
-
         let buf = self
             .hard_forks
             .read()
@@ -5517,8 +5518,9 @@ impl Bank {
             } else {
                 "".to_string()
             },
-            if let Some(accounts_lt_hash_checksum) = accounts_lt_hash_checksum {
-                format!(", accounts_lt_hash checksum: {accounts_lt_hash_checksum}")
+            if self.is_accounts_lt_hash_enabled() {
+                let checksum = self.accounts_lt_hash.lock().unwrap().0.checksum();
+                format!(", accounts_lt_hash checksum: {checksum}")
             } else {
                 String::new()
             },

runtime/src/bank/accounts_lt_hash.rs

@@ -2,7 +2,7 @@ use {
     super::Bank,
     rayon::prelude::*,
     solana_accounts_db::accounts_db::AccountsDb,
-    solana_lattice_hash::lt_hash::{Checksum as LtChecksum, LtHash},
+    solana_lattice_hash::lt_hash::LtHash,
     solana_measure::{meas_dur, measure::Measure},
     solana_sdk::{
         account::{accounts_equal, AccountSharedData},
@@ -29,12 +29,11 @@ impl Bank {
     /// - mix in its current state
     ///
     /// Since this function is non-idempotent, it should only be called once per bank.
-    pub fn update_accounts_lt_hash(&self) -> LtChecksum {
+    pub fn update_accounts_lt_hash(&self) {
         debug_assert!(self.is_accounts_lt_hash_enabled());
         let delta_lt_hash = self.calculate_delta_lt_hash();
         let mut accounts_lt_hash = self.accounts_lt_hash.lock().unwrap();
         accounts_lt_hash.0.mix_in(&delta_lt_hash);
-        accounts_lt_hash.0.checksum()
     }
 
     /// Calculates the lt hash *of only this slot*

runtime/src/snapshot_bank_utils.rs

@@ -930,19 +930,7 @@ fn bank_to_full_snapshot_archive_with(
         .accounts_db
         .set_latest_full_snapshot_slot(bank.slot());
     bank.squash(); // Bank may not be a root
-
-    // Rehashing is not currently supported when the accounts lt hash is enabled.
-    // This is because rehashing will *re-mix-in* all the accounts stored in this bank into the
-    // accounts lt hash!  This is incorrect, as the accounts lt hash would change, even if the bank
-    // was *not* manually modified by the caller.
-    // We can re-allow rehasing if we change the Bank to hold its parent's accounts lt hash plus a
-    // *delta* accounts lt hash, and then Bank::hash_internal_state() will only recalculate the
-    // delta accounts lt hash.
-    // Another option is to consider if manual modification should even be allowed in the first
-    // place. Disallowing it would solve these issues.
-    if !bank.is_accounts_lt_hash_enabled() {
-        bank.rehash(); // Bank accounts may have been manually modified by the caller
-    }
+    bank.rehash(); // Bank may have been manually modified by the caller
     bank.force_flush_accounts_cache();
     bank.clean_accounts();
     let calculated_accounts_hash =
@@ -1005,11 +993,7 @@ pub fn bank_to_incremental_snapshot_archive(
         .accounts_db
         .set_latest_full_snapshot_slot(full_snapshot_slot);
     bank.squash(); // Bank may not be a root
-
-    // See the comment in bank_to_full_snapshot_archive() when calling rehash()
-    if !bank.is_accounts_lt_hash_enabled() {
-        bank.rehash(); // Bank accounts may have been manually modified by the caller
-    }
+    bank.rehash(); // Bank may have been manually modified by the caller
     bank.force_flush_accounts_cache();
     bank.clean_accounts();
     let calculated_incremental_accounts_hash =