fix(gc): tests after gc implementation.

client/src/rpc_request.rs

@@ -281,7 +281,7 @@ pub enum TokenAccountsFilter {
 mod tests {
     use super::*;
     use crate::rpc_config::RpcTokenAccountsFilter;
-    use solana_sdk::commitment_config::CommitmentConfig;
+    use solana_sdk::commitment_config::{CommitmentConfig, CommitmentLevel};
 
     #[test]
     fn test_build_request_json() {

core/src/accounts_hash_verifier.rs

@@ -219,6 +219,9 @@ mod tests {
     use super::*;
     use crate::cluster_info::make_accounts_hashes_message;
     use crate::contact_info::ContactInfo;
+    use solana_ledger::genesis_utils::create_genesis_config;
+    use solana_ledger::genesis_utils::GenesisConfigInfo;
+    use solana_runtime::bank::Bank;
     use solana_runtime::bank_forks::ArchiveFormat;
     use solana_runtime::snapshot_utils::SnapshotVersion;
     use solana_sdk::{
@@ -270,6 +273,10 @@ mod tests {
         let cluster_info = ClusterInfo::new_with_invalid_keypair(contact_info);
         let cluster_info = Arc::new(cluster_info);
 
+        let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
+        // Create bank
+        let bank = Arc::new(Bank::new(&genesis_config));
+
         let trusted_validators = HashSet::new();
         let exit = Arc::new(AtomicBool::new(false));
         let mut hashes = vec![];
@@ -288,6 +295,7 @@ mod tests {
                 evm_root: evm_state::empty_trie_hash(),
                 evm_db: evm_state::storage::Storage::create_temporary()
                     .expect("Unable to create temporary EVM state storage"),
+                bank: bank.clone(),
             };
 
             AccountsHashVerifier::process_accounts_package(

core/src/snapshot_packager_service.rs

@@ -73,6 +73,9 @@ impl SnapshotPackagerService {
 mod tests {
     use super::*;
     use bincode::serialize_into;
+    use solana_ledger::genesis_utils::create_genesis_config;
+    use solana_ledger::genesis_utils::GenesisConfigInfo;
+    use solana_runtime::bank::Bank;
     use solana_runtime::{
         accounts_db::AccountStorageEntry,
         bank::BankSlotDelta,
@@ -154,6 +157,12 @@ mod tests {
             fs::hard_link(&snapshots_path, &link_path).unwrap();
         }
 
+        let GenesisConfigInfo {
+            genesis_config, ..
+        } = create_genesis_config(10_000);
+        // Create bank
+        let bank = Arc::new(Bank::new(&genesis_config));
+
         // Create a packageable snapshot
         let output_tar_path = snapshot_utils::get_snapshot_archive_path(
             snapshot_package_output_path,
@@ -173,6 +182,7 @@ mod tests {
             evm_state::empty_trie_hash(),
             evm_state::storage::Storage::create_temporary()
                 .expect("Unable to create temporary EVM state storage"),
+            bank,
         );
 
         // Make tarball from packageable snapshot

core/src/tvu.rs

@@ -426,6 +426,7 @@ pub mod tests {
             None,
             None,
             None,
+            None,
             Arc::new(VoteTracker::new(&bank)),
             retransmit_slots_sender,
             gossip_verified_vote_hash_receiver,

core/tests/snapshots.rs

@@ -245,7 +245,7 @@ mod tests {
             .pop()
             .expect("no snapshots found in path");
         let snapshot_package = snapshot_utils::package_snapshot(
-            last_bank,
+            last_bank.clone(),
             &last_slot_snapshot_path,
             snapshot_path,
             last_bank.src.slot_deltas(&last_bank.src.roots()),
@@ -376,8 +376,9 @@ mod tests {
                 }
             };
 
+            bank_forks.insert(bank);
             snapshot_utils::snapshot_bank(
-                &bank,
+                bank_forks[slot].clone(),
                 vec![],
                 package_sender,
                 snapshot_path,
@@ -388,7 +389,6 @@ mod tests {
             )
             .unwrap();
 
-            bank_forks.insert(bank);
             if slot == saved_slot as u64 {
                 // Find the relevant snapshot storages
                 let snapshot_storage_files: HashSet<_> = bank_forks[slot]

evm-utils/evm-state/src/state.rs

@@ -705,7 +705,7 @@ impl Default for Incomming {
 }
 impl Default for EvmBackend<Incomming> {
     fn default() -> Self {
-        let kvs = KVS::create_temporary().expect("Unable to create temporary storage");
+        let kvs = KVS::create_temporary_gc().expect("Unable to create temporary storage");
         let state = Incomming::default();
         EvmBackend { state, kvs }
     }

evm-utils/evm-state/src/storage/mod.rs

@@ -428,8 +428,6 @@ impl Storage {
         }
 
         let mut cleaner = RootCleanup::new(&self, cleanup_roots);
-        //TODO: This cleanup can be removed after debuggin memort leak in snapshot.
-        cleaner.cleanup_empty_counters()?;
         cleaner.cleanup()
     }
 
@@ -478,29 +476,6 @@ impl<'a> RootCleanup<'a> {
         }
     }
 
-    pub fn cleanup_empty_counters(&self) -> Result<()> {
-        const REPORT_EACH_N: usize = 500;
-        debug!("Cleaning up empty counters");
-        let mut num_counters = 0;
-        let reference_counter_cf = self.storage.cf::<ReferenceCounter>();
-        for (k, v) in self
-            .storage
-            .db
-            .iterator_cf(reference_counter_cf, IteratorMode::Start)
-        {
-            if &*v == &[0; 8] {
-                num_counters += 1;
-                self.storage.db.delete_cf(reference_counter_cf, &k)?;
-                if num_counters % REPORT_EACH_N == 0 {
-                    info!("Removed {} counters", num_counters);
-                }
-            }
-        }
-
-        debug!("Removed {} counters total.", num_counters);
-        Ok(())
-    }
-
     pub fn cleanup(&mut self) -> Result<()> {
         const MAX_ELEMS: usize = 200;
         while !self.elems.is_empty() {

evm-utils/programs/evm_loader/src/lib.rs

@@ -215,7 +215,7 @@ pub fn evm_transfer(
     let tx = evm::UnsignedTransaction {
         nonce,
         gas_price: 1.into(),
-        gas_limit: 30000.into(),
+        gas_limit: 21000.into(),
         action: evm::TransactionAction::Call(to),
         value,
         input: vec![],

runtime/src/bank.rs

@@ -4432,6 +4432,11 @@ impl Bank {
             );
         }
         self.feature_builtins = Arc::new(builtins.feature_builtins);
+        self.evm_state
+            .write()
+            .expect("poisoned state")
+            .reregister_slot(self.slot())
+            .expect("cannot register slot");
 
         self.apply_feature_activations(true);
     }
@@ -8987,15 +8992,17 @@ pub(crate) mod tests {
 
         let mut rng = evm_state::rand::thread_rng();
         let sender = evm_state::SecretKey::new(&mut rng);
+        let sender_addr = sender.to_address();
+        let init_balance = 10000000.into();
         {
             // force changing evm_state account
             let mut evm_state = bank0.evm_state.write().unwrap();
             match &mut *evm_state {
                 evm_state::EvmState::Incomming(i) => {
                     i.set_initial(vec![(
-                        sender.to_address(),
+                        sender_addr,
                         evm_state::MemoryAccount {
-                            balance: 10000000.into(),
+                            balance: init_balance,
                             ..Default::default()
                         },
                     )]);
@@ -9008,15 +9015,31 @@ pub(crate) mod tests {
                 .unwrap();
         }
         let pubkey: evm_state::H160 = H256::random().into();
+        {
+            let evm_state = bank0.evm_state.read().unwrap();
+            assert_eq!(
+                evm_state.get_account_state(sender_addr).unwrap().balance,
+                init_balance
+            );
+        }
         info!("transfer 1 {} mint: {}", pubkey, mint_keypair.pubkey());
         bank0
             .transfer_evm(1_000, &mint_keypair, &sender, &pubkey)
             .unwrap();
 
         let bank0_state = bank0.hash_internal_state();
         let bank0 = Arc::new(bank0);
+
         // Checkpointing should result in a new state while freezing the parent
         let bank2 = Bank::new_from_parent(&bank0, &solana_sdk::pubkey::new_rand(), 1);
+
+        {
+            let evm_state = bank2.evm_state.read().unwrap();
+            assert_eq!(
+                evm_state.get_account_state(sender_addr).unwrap().balance,
+                init_balance - 21000 - 1000
+            );
+        }
         assert_ne!(bank0_state, bank2.hash_internal_state());
         // Checkpointing should modify the checkpoint's state when freezed
         assert_ne!(bank0_state, bank0.hash_internal_state());
@@ -9039,6 +9062,81 @@ pub(crate) mod tests {
         bank2.update_accounts_hash();
         assert!(bank2.verify_bank_hash());
         assert!(bank3.verify_bank_hash());
+        drop(bank0);
+        drop(bank2);
+        let evm_state = bank3.evm_state.read().unwrap();
+        assert_eq!(
+            evm_state.get_account_state(sender_addr).unwrap().balance,
+            init_balance - 21000 - 1000
+        );
+    }
+
+    #[test]
+    fn test_bank_transfer_evm_release_lock_panic() {
+        solana_logger::setup_with("trace");
+        let (genesis_config, mint_keypair) = create_genesis_config(2_000);
+        let bank0 = Bank::new(&genesis_config);
+
+        let mut rng = evm_state::rand::thread_rng();
+        let sender = evm_state::SecretKey::new(&mut rng);
+        let sender_addr = sender.to_address();
+        let init_balance = 10000000.into();
+        {
+            // force changing evm_state account
+            let mut evm_state = bank0.evm_state.write().unwrap();
+            match &mut *evm_state {
+                evm_state::EvmState::Incomming(i) => {
+                    i.set_initial(vec![(
+                        sender_addr,
+                        evm_state::MemoryAccount {
+                            balance: init_balance,
+                            ..Default::default()
+                        },
+                    )]);
+                }
+                _ => panic!("Not exepcetd state"),
+            }
+
+            evm_state
+                .try_commit(bank0.slot(), bank0.last_blockhash().0)
+                .unwrap();
+        }
+        let pubkey: evm_state::H160 = H256::random().into();
+        {
+            let evm_state = bank0.evm_state.read().unwrap();
+            assert_eq!(
+                evm_state.get_account_state(sender_addr).unwrap().balance,
+                init_balance
+            );
+        }
+        info!("transfer 1 {} mint: {}", pubkey, mint_keypair.pubkey());
+        bank0
+            .transfer_evm(1_000, &mint_keypair, &sender, &pubkey)
+            .unwrap();
+
+        let bank0 = Arc::new(bank0);
+
+        // Checkpointing should result in a new state while freezing the parent
+        let bank2 = Bank::new_from_parent(&bank0, &solana_sdk::pubkey::new_rand(), 1);
+
+        drop(bank0);
+        {
+            let evm_state = bank2.evm_state.read().unwrap();
+            assert_eq!(
+                evm_state.get_account_state(sender_addr).unwrap().balance,
+                init_balance - 21000 - 1000
+            );
+        }
+        let evm_state = bank2.evm_state.read().unwrap().clone();
+        {
+            assert_eq!(
+                evm_state.get_account_state(sender_addr).unwrap().balance,
+                init_balance - 21000 - 1000
+            );
+        }
+        drop(bank2);
+
+        std::panic::catch_unwind(|| evm_state.get_account_state(sender_addr)).unwrap_err();
     }
 
     #[test]

runtime/src/serde_snapshot/tests.rs

@@ -156,7 +156,7 @@ fn test_accounts_serialize_style() {
 
 #[cfg(test)]
 fn test_bank_serialize_style(evm_version: EvmStateVersion) {
-    solana_logger::setup();
+    solana_logger::setup_with_default("trace");
     let (genesis_config, _) = create_genesis_config(500);
     let bank0 = Arc::new(Bank::new(&genesis_config));
     let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
@@ -196,6 +196,13 @@ fn test_bank_serialize_style(evm_version: EvmStateVersion) {
 
     let evm_state_dir = TempDir::new().unwrap();
     let evm_backup_state_path = TempDir::new().unwrap();
+    bank2
+        .evm_state
+        .read()
+        .unwrap()
+        .kvs()
+        .backup(Some(evm_backup_state_path.as_ref().to_path_buf()))
+        .unwrap();
     // Create a new set of directories for this bank's accounts
     let (_accounts_dir, dbank_paths) = get_temp_accounts_paths(4).unwrap();
     let ref_sc = StatusCacheRc::default();
@@ -261,11 +268,6 @@ fn test_accounts_serialize_newer() {
     test_accounts_serialize_style()
 }
 
-#[test]
-fn test_bank_serialize_newer() {
-    test_bank_serialize_style(EvmStateVersion::V1_4_0)
-}
-
 #[test]
 fn test_bank_serialize_newer() {
     test_bank_serialize_style(EvmStateVersion::V1_5_0)

runtime/src/snapshot_utils.rs

@@ -318,6 +318,7 @@ pub fn archive_snapshot_package(snapshot_package: &AccountsPackage) -> Result<()
         let snapshot_hardlink_dir = snapshot_tmpdir.join(slot.to_string());
 
         let evm_target = snapshot_hardlink_dir.join(EVM_STATE_DIR);
+        std::fs::create_dir_all(&evm_target)?;
         let mut evm_state_backup = Measure::start("evm-state-backup-ms");
         let backup_path = snapshot_package
             .evm_db