Move BankCommitmentCache to solana_runtime (#10816)

* Remove Blockstore member variable from BlockCommitmentCache

* Hoist is_confirmed_rooted() to its only caller

BlockCommitmentCache no longer depends on Blockstore

* Move BlockCommitmentCache to solana_runtime

core/src/cluster_info_vote_listener.rs

@@ -1,6 +1,5 @@
 use crate::{
     cluster_info::{ClusterInfo, GOSSIP_SLEEP_MILLIS},
-    commitment::VOTE_THRESHOLD_SIZE,
     crds_value::CrdsValueLabel,
     poh_recorder::PohRecorder,
     pubkey_references::LockedPubkeyReferences,
@@ -19,6 +18,7 @@ use solana_perf::packet::{self, Packets};
 use solana_runtime::{
     bank::Bank,
     bank_forks::BankForks,
+    commitment::VOTE_THRESHOLD_SIZE,
     epoch_stakes::{EpochAuthorizedVoters, EpochStakes},
 };
 use solana_sdk::{
@@ -600,11 +600,10 @@ impl ClusterInfoVoteListener {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::commitment::BlockCommitmentCache;
-    use solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path};
     use solana_perf::packet;
     use solana_runtime::{
         bank::Bank,
+        commitment::BlockCommitmentCache,
         genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs},
     };
     use solana_sdk::hash::Hash;
@@ -951,14 +950,10 @@ mod tests {
         let bank_forks = BankForks::new(bank);
         let bank = bank_forks.get(0).unwrap().clone();
         let vote_tracker = VoteTracker::new(&bank);
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let subscriptions = Arc::new(RpcSubscriptions::new(
             &exit,
             Arc::new(RwLock::new(bank_forks)),
-            Arc::new(RwLock::new(BlockCommitmentCache::default_with_blockstore(
+            Arc::new(RwLock::new(BlockCommitmentCache::default())),
-                blockstore,
-            ))),
         ));
 
         // Send a vote to process, should add a reference to the pubkey for that voter
@@ -1060,14 +1055,10 @@ mod tests {
         let exit = Arc::new(AtomicBool::new(false));
         let bank_forks = BankForks::new(bank);
         let bank = bank_forks.get(0).unwrap().clone();
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let subscriptions = Arc::new(RpcSubscriptions::new(
             &exit,
             Arc::new(RwLock::new(bank_forks)),
-            Arc::new(RwLock::new(BlockCommitmentCache::default_with_blockstore(
+            Arc::new(RwLock::new(BlockCommitmentCache::default())),
-                blockstore,
-            ))),
         ));
 
         // Integrity Checks

core/src/commitment_service.rs

@@ -1,11 +1,13 @@
 use crate::{
-    commitment::{BlockCommitment, BlockCommitmentCache, VOTE_THRESHOLD_SIZE},
     consensus::Stake,
     rpc_subscriptions::{CacheSlotInfo, RpcSubscriptions},
 };
 use solana_measure::measure::Measure;
 use solana_metrics::datapoint_info;
-use solana_runtime::bank::Bank;
+use solana_runtime::{
+    bank::Bank,
+    commitment::{BlockCommitment, BlockCommitmentCache, VOTE_THRESHOLD_SIZE},
+};
 use solana_sdk::clock::Slot;
 use solana_vote_program::vote_state::VoteState;
 use std::{
@@ -115,7 +117,6 @@ impl AggregateCommitmentService {
                 largest_confirmed_root,
                 aggregation_data.total_stake,
                 aggregation_data.bank,
-                block_commitment_cache.read().unwrap().blockstore.clone(),
                 aggregation_data.root,
                 aggregation_data.root,
             );

core/src/consensus.rs

@@ -1,10 +1,9 @@
 use crate::{
-    commitment::VOTE_THRESHOLD_SIZE,
     progress_map::{LockoutIntervals, ProgressMap},
     pubkey_references::PubkeyReferences,
 };
 use chrono::prelude::*;
-use solana_runtime::{bank::Bank, bank_forks::BankForks};
+use solana_runtime::{bank::Bank, bank_forks::BankForks, commitment::VOTE_THRESHOLD_SIZE};
 use solana_sdk::{
     account::Account,
     clock::{Slot, UnixTimestamp},

core/src/lib.rs

@@ -10,7 +10,6 @@ pub mod accounts_hash_verifier;
 pub mod banking_stage;
 pub mod broadcast_stage;
 pub mod cluster_info_vote_listener;
-pub mod commitment;
 pub mod commitment_service;
 mod deprecated;
 pub mod shred_fetch_stage;

core/src/repair_service.rs

@@ -4,7 +4,6 @@ use crate::{
     cluster_info::ClusterInfo,
     cluster_info_vote_listener::VoteTracker,
     cluster_slots::ClusterSlots,
-    commitment::VOTE_THRESHOLD_SIZE,
     result::Result,
     serve_repair::{RepairType, ServeRepair, DEFAULT_NONCE},
 };
@@ -16,7 +15,7 @@ use solana_ledger::{
     blockstore::{Blockstore, CompletedSlotsReceiver, SlotMeta},
     shred::Nonce,
 };
-use solana_runtime::{bank::Bank, bank_forks::BankForks};
+use solana_runtime::{bank::Bank, bank_forks::BankForks, commitment::VOTE_THRESHOLD_SIZE};
 use solana_sdk::{clock::Slot, epoch_schedule::EpochSchedule, pubkey::Pubkey, timing::timestamp};
 use std::{
     collections::HashMap,

core/src/replay_stage.rs

@@ -6,7 +6,6 @@ use crate::{
     cluster_info::ClusterInfo,
     cluster_info_vote_listener::VoteTracker,
     cluster_slots::ClusterSlots,
-    commitment::BlockCommitmentCache,
     commitment_service::{AggregateCommitmentService, CommitmentAggregationData},
     consensus::{ComputedBankState, Stake, SwitchForkDecision, Tower, VotedStakes},
     fork_choice::{ForkChoice, SelectVoteAndResetForkResult},
@@ -28,7 +27,10 @@ use solana_ledger::{
 };
 use solana_measure::thread_mem_usage;
 use solana_metrics::inc_new_counter_info;
-use solana_runtime::{bank::Bank, bank_forks::BankForks, snapshot_package::AccountsPackageSender};
+use solana_runtime::{
+    bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache,
+    snapshot_package::AccountsPackageSender,
+};
 use solana_sdk::{
     clock::{Slot, NUM_CONSECUTIVE_LEADER_SLOTS},
     genesis_config::OperatingMode,
@@ -1770,7 +1772,6 @@ impl ReplayStage {
 pub(crate) mod tests {
     use super::*;
     use crate::{
-        commitment::BlockCommitment,
         consensus::test::{initialize_state, VoteSimulator},
         consensus::Tower,
         progress_map::ValidatorStakeInfo,
@@ -1790,7 +1791,10 @@ pub(crate) mod tests {
             SIZE_OF_COMMON_SHRED_HEADER, SIZE_OF_DATA_SHRED_HEADER, SIZE_OF_DATA_SHRED_PAYLOAD,
         },
     };
-    use solana_runtime::genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs};
+    use solana_runtime::{
+        commitment::BlockCommitment,
+        genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs},
+    };
     use solana_sdk::{
         clock::NUM_CONSECUTIVE_LEADER_SLOTS,
         genesis_config,
@@ -1879,9 +1883,7 @@ pub(crate) mod tests {
             let subscriptions = Arc::new(RpcSubscriptions::new(
                 &exit,
                 bank_forks.clone(),
-                Arc::new(RwLock::new(BlockCommitmentCache::default_with_blockstore(
+                Arc::new(RwLock::new(BlockCommitmentCache::default())),
-                    blockstore.clone(),
-                ))),
             ));
 
             // Insert shreds for slot NUM_CONSECUTIVE_LEADER_SLOTS,
@@ -2303,9 +2305,6 @@ pub(crate) mod tests {
             bank.store_account(&pubkey, &leader_vote_account);
         }
 
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
-
         let leader_pubkey = Pubkey::new_rand();
         let leader_lamports = 3;
         let genesis_config_info =
@@ -2326,9 +2325,7 @@ pub(crate) mod tests {
         )));
 
         let exit = Arc::new(AtomicBool::new(false));
-        let block_commitment_cache = Arc::new(RwLock::new(
+        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
-            BlockCommitmentCache::default_with_blockstore(blockstore),
-        ));
         let subscriptions = Arc::new(RpcSubscriptions::new(
             &exit,
             bank_forks.clone(),

core/src/rpc.rs

@@ -1,14 +1,9 @@
 //! The `rpc` module implements the Solana RPC interface.
 
 use crate::{
-    cluster_info::ClusterInfo,
+    cluster_info::ClusterInfo, contact_info::ContactInfo,
-    commitment::{BlockCommitmentArray, BlockCommitmentCache},
+    non_circulating_supply::calculate_non_circulating_supply, rpc_error::RpcCustomError,
-    contact_info::ContactInfo,
+    rpc_health::*, send_transaction_service::SendTransactionService, validator::ValidatorExit,
-    non_circulating_supply::calculate_non_circulating_supply,
-    rpc_error::RpcCustomError,
-    rpc_health::*,
-    send_transaction_service::SendTransactionService,
-    validator::ValidatorExit,
 };
 use bincode::serialize;
 use jsonrpc_core::{Error, Metadata, Result};
@@ -26,7 +21,11 @@ use solana_faucet::faucet::request_airdrop_transaction;
 use solana_ledger::{blockstore::Blockstore, blockstore_db::BlockstoreError, get_tmp_ledger_path};
 use solana_perf::packet::PACKET_DATA_SIZE;
 use solana_runtime::{
-    accounts::AccountAddressFilter, bank::Bank, bank_forks::BankForks, log_collector::LogCollector,
+    accounts::AccountAddressFilter,
+    bank::Bank,
+    bank_forks::BankForks,
+    commitment::{BlockCommitmentArray, BlockCommitmentCache},
+    log_collector::LogCollector,
 };
 use solana_sdk::{
     clock::{Epoch, Slot, UnixTimestamp},
@@ -60,6 +59,19 @@ fn new_response<T>(bank: &Bank, value: T) -> Result<RpcResponse<T>> {
     Ok(Response { context, value })
 }
 
+pub fn is_confirmed_rooted(
+    block_commitment_cache: &BlockCommitmentCache,
+    blockstore: &Blockstore,
+    slot: Slot,
+) -> bool {
+    slot <= block_commitment_cache.largest_confirmed_root()
+        && (blockstore.is_root(slot)
+            || block_commitment_cache
+                .bank()
+                .status_cache_ancestors()
+                .contains(&slot))
+}
+
 #[derive(Debug, Default, Clone)]
 pub struct JsonRpcConfig {
     pub enable_validator_exit: bool,
@@ -174,7 +186,6 @@ impl JsonRpcRequestProcessor {
                 0,
                 0,
                 bank.clone(),
-                blockstore.clone(),
                 0,
                 0,
             ))),
@@ -670,7 +681,7 @@ impl JsonRpcRequestProcessor {
         let r_block_commitment_cache = self.block_commitment_cache.read().unwrap();
 
         let confirmations = if r_block_commitment_cache.root() >= slot
-            && r_block_commitment_cache.is_confirmed_rooted(slot)
+            && is_confirmed_rooted(&r_block_commitment_cache, &self.blockstore, slot)
         {
             None
         } else {
@@ -1601,8 +1612,7 @@ pub(crate) fn create_validator_exit(exit: &Arc<AtomicBool>) -> Arc<RwLock<Option
 pub mod tests {
     use super::*;
     use crate::{
-        commitment::BlockCommitment, contact_info::ContactInfo,
+        contact_info::ContactInfo, non_circulating_supply::non_circulating_accounts,
-        non_circulating_supply::non_circulating_accounts,
         replay_stage::tests::create_test_transactions_and_populate_blockstore,
     };
     use bincode::deserialize;
@@ -1616,6 +1626,7 @@ pub mod tests {
         entry::next_entry_mut,
         genesis_utils::{create_genesis_config, GenesisConfigInfo},
     };
+    use solana_runtime::commitment::BlockCommitment;
     use solana_sdk::{
         clock::MAX_RECENT_BLOCKHASHES,
         fee_calculator::DEFAULT_BURN_PERCENT,
@@ -1688,7 +1699,6 @@ pub mod tests {
             0,
             10,
             bank.clone(),
-            blockstore.clone(),
             0,
             0,
         )));
@@ -2775,9 +2785,7 @@ pub mod tests {
         let validator_exit = create_validator_exit(&exit);
         let ledger_path = get_tmp_ledger_path!();
         let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
-        let block_commitment_cache = Arc::new(RwLock::new(
+        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
-            BlockCommitmentCache::default_with_blockstore(blockstore.clone()),
-        ));
 
         let mut io = MetaIoHandler::default();
         let rpc = RpcSolImpl;
@@ -2813,9 +2821,7 @@ pub mod tests {
         let validator_exit = create_validator_exit(&exit);
         let ledger_path = get_tmp_ledger_path!();
         let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
-        let block_commitment_cache = Arc::new(RwLock::new(
+        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
-            BlockCommitmentCache::default_with_blockstore(blockstore.clone()),
-        ));
         let bank_forks = new_bank_forks().0;
         let health = RpcHealth::stub();
 
@@ -2956,9 +2962,7 @@ pub mod tests {
         let validator_exit = create_validator_exit(&exit);
         let ledger_path = get_tmp_ledger_path!();
         let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
-        let block_commitment_cache = Arc::new(RwLock::new(
+        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
-            BlockCommitmentCache::default_with_blockstore(blockstore.clone()),
-        ));
         let cluster_info = Arc::new(ClusterInfo::default());
         let bank_forks = new_bank_forks().0;
         let request_processor = JsonRpcRequestProcessor::new(
@@ -2986,9 +2990,7 @@ pub mod tests {
         let validator_exit = create_validator_exit(&exit);
         let ledger_path = get_tmp_ledger_path!();
         let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
-        let block_commitment_cache = Arc::new(RwLock::new(
+        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
-            BlockCommitmentCache::default_with_blockstore(blockstore.clone()),
-        ));
         let mut config = JsonRpcConfig::default();
         config.enable_validator_exit = true;
         let bank_forks = new_bank_forks().0;
@@ -3076,7 +3078,6 @@ pub mod tests {
             0,
             42,
             bank_forks.read().unwrap().working_bank(),
-            blockstore.clone(),
             0,
             0,
         )));
@@ -3556,4 +3557,40 @@ pub mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_is_confirmed_rooted() {
+        let bank = Arc::new(Bank::default());
+        let ledger_path = get_tmp_ledger_path!();
+        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
+        blockstore.set_roots(&[0, 1]).unwrap();
+        // Build BlockCommitmentCache with rooted slots
+        let mut cache0 = BlockCommitment::default();
+        cache0.increase_rooted_stake(50);
+        let mut cache1 = BlockCommitment::default();
+        cache1.increase_rooted_stake(40);
+        let mut cache2 = BlockCommitment::default();
+        cache2.increase_rooted_stake(20);
+
+        let mut block_commitment = HashMap::new();
+        block_commitment.entry(1).or_insert(cache0);
+        block_commitment.entry(2).or_insert(cache1);
+        block_commitment.entry(3).or_insert(cache2);
+        let largest_confirmed_root = 1;
+        let block_commitment_cache =
+            BlockCommitmentCache::new(block_commitment, largest_confirmed_root, 50, bank, 0, 0);
+
+        assert!(is_confirmed_rooted(&block_commitment_cache, &blockstore, 0));
+        assert!(is_confirmed_rooted(&block_commitment_cache, &blockstore, 1));
+        assert!(!is_confirmed_rooted(
+            &block_commitment_cache,
+            &blockstore,
+            2
+        ));
+        assert!(!is_confirmed_rooted(
+            &block_commitment_cache,
+            &blockstore,
+            3
+        ));
+    }
 }

core/src/rpc_pubsub.rs

@@ -8,8 +8,6 @@ use solana_client::rpc_response::{
     Response as RpcResponse, RpcAccount, RpcKeyedAccount, RpcSignatureResult,
 };
 #[cfg(test)]
-use solana_ledger::blockstore::Blockstore;
-#[cfg(test)]
 use solana_runtime::bank_forks::BankForks;
 use solana_sdk::{
     clock::Slot, commitment_config::CommitmentConfig, pubkey::Pubkey, signature::Signature,
@@ -153,14 +151,9 @@ impl RpcSolPubSubImpl {
     }
 
     #[cfg(test)]
-    fn default_with_blockstore_bank_forks(
+    fn default_with_bank_forks(bank_forks: Arc<RwLock<BankForks>>) -> Self {
-        blockstore: Arc<Blockstore>,
-        bank_forks: Arc<RwLock<BankForks>>,
-    ) -> Self {
         let uid = Arc::new(atomic::AtomicUsize::default());
-        let subscriptions = Arc::new(RpcSubscriptions::default_with_blockstore_bank_forks(
+        let subscriptions = Arc::new(RpcSubscriptions::default_with_bank_forks(bank_forks));
-            blockstore, bank_forks,
-        ));
         Self { uid, subscriptions }
     }
 }
@@ -357,7 +350,6 @@ mod tests {
     use super::*;
     use crate::{
         cluster_info_vote_listener::{ClusterInfoVoteListener, VoteTracker},
-        commitment::BlockCommitmentCache,
         rpc_subscriptions::{tests::robust_poll_or_panic, CacheSlotInfo},
     };
     use crossbeam_channel::unbounded;
@@ -365,14 +357,14 @@ mod tests {
     use jsonrpc_pubsub::{PubSubHandler, Session};
     use serial_test_derive::serial;
     use solana_budget_program::{self, budget_instruction};
-    use solana_ledger::{
-        genesis_utils::{create_genesis_config, GenesisConfigInfo},
-        get_tmp_ledger_path,
-    };
     use solana_runtime::{
         bank::Bank,
         bank_forks::BankForks,
-        genesis_utils::{create_genesis_config_with_vote_accounts, ValidatorVoteKeypairs},
+        commitment::BlockCommitmentCache,
+        genesis_utils::{
+            create_genesis_config, create_genesis_config_with_vote_accounts, GenesisConfigInfo,
+            ValidatorVoteKeypairs,
+        },
     };
     use solana_sdk::{
         hash::Hash,
@@ -424,15 +416,11 @@ mod tests {
         let bank = Bank::new(&genesis_config);
         let blockhash = bank.last_blockhash();
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let rpc = RpcSolPubSubImpl {
             subscriptions: Arc::new(RpcSubscriptions::new(
                 &Arc::new(AtomicBool::new(false)),
                 bank_forks.clone(),
-                Arc::new(RwLock::new(
+                Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests())),
-                    BlockCommitmentCache::new_for_tests_with_blockstore(blockstore),
-                )),
             )),
             uid: Arc::new(atomic::AtomicUsize::default()),
         };
@@ -475,13 +463,11 @@ mod tests {
         let bank = Bank::new(&genesis_config);
         let blockhash = bank.last_blockhash();
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
 
         let session = create_session();
 
         let mut io = PubSubHandler::default();
-        let rpc = RpcSolPubSubImpl::default_with_blockstore_bank_forks(blockstore, bank_forks);
+        let rpc = RpcSolPubSubImpl::default_with_bank_forks(bank_forks);
         io.extend_with(rpc.to_delegate());
 
         let tx = system_transaction::transfer(&alice, &bob_pubkey, 20, blockhash);
@@ -535,20 +521,15 @@ mod tests {
         let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
         let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
         bank_forks.write().unwrap().insert(bank1);
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
 
         let rpc = RpcSolPubSubImpl {
             subscriptions: Arc::new(RpcSubscriptions::new(
                 &Arc::new(AtomicBool::new(false)),
                 bank_forks.clone(),
-                Arc::new(RwLock::new(
+                Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests_with_bank(
-                    BlockCommitmentCache::new_for_tests_with_blockstore_bank(
+                    bank_forks.read().unwrap().get(1).unwrap().clone(),
-                        blockstore,
+                    1,
-                        bank_forks.read().unwrap().get(1).unwrap().clone(),
+                ))),
-                        1,
-                    ),
-                )),
             )),
             uid: Arc::new(atomic::AtomicUsize::default()),
         };
@@ -636,13 +617,11 @@ mod tests {
     fn test_account_unsubscribe() {
         let bob_pubkey = Pubkey::new_rand();
         let session = create_session();
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
         let bank_forks = Arc::new(RwLock::new(BankForks::new(Bank::new(&genesis_config))));
 
         let mut io = PubSubHandler::default();
-        let rpc = RpcSolPubSubImpl::default_with_blockstore_bank_forks(blockstore, bank_forks);
+        let rpc = RpcSolPubSubImpl::default_with_bank_forks(bank_forks);
 
         io.extend_with(rpc.to_delegate());
 
@@ -682,21 +661,14 @@ mod tests {
         let bank = Bank::new(&genesis_config);
         let blockhash = bank.last_blockhash();
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let bob = Keypair::new();
 
-        let mut rpc = RpcSolPubSubImpl::default_with_blockstore_bank_forks(
+        let mut rpc = RpcSolPubSubImpl::default_with_bank_forks(bank_forks.clone());
-            blockstore.clone(),
-            bank_forks.clone(),
-        );
         let exit = Arc::new(AtomicBool::new(false));
         let subscriptions = RpcSubscriptions::new(
             &exit,
             bank_forks.clone(),
-            Arc::new(RwLock::new(
+            Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests())),
-                BlockCommitmentCache::new_for_tests_with_blockstore(blockstore),
-            )),
         );
         rpc.subscriptions = Arc::new(subscriptions);
         let session = create_session();
@@ -736,18 +708,11 @@ mod tests {
         let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
         let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
         bank_forks.write().unwrap().insert(bank1);
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let bob = Keypair::new();
 
-        let mut rpc = RpcSolPubSubImpl::default_with_blockstore_bank_forks(
+        let mut rpc = RpcSolPubSubImpl::default_with_bank_forks(bank_forks.clone());
-            blockstore.clone(),
-            bank_forks.clone(),
-        );
         let exit = Arc::new(AtomicBool::new(false));
-        let block_commitment_cache = Arc::new(RwLock::new(
+        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests()));
-            BlockCommitmentCache::new_for_tests_with_blockstore(blockstore),
-        ));
 
         let subscriptions =
             RpcSubscriptions::new(&exit, bank_forks.clone(), block_commitment_cache);
@@ -804,12 +769,10 @@ mod tests {
     #[test]
     #[serial]
     fn test_slot_subscribe() {
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
         let bank = Bank::new(&genesis_config);
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-        let rpc = RpcSolPubSubImpl::default_with_blockstore_bank_forks(blockstore, bank_forks);
+        let rpc = RpcSolPubSubImpl::default_with_bank_forks(bank_forks);
         let session = create_session();
         let (subscriber, _id_receiver, receiver) = Subscriber::new_test("slotNotification");
         rpc.slot_subscribe(session, subscriber);
@@ -834,12 +797,10 @@ mod tests {
     #[test]
     #[serial]
     fn test_slot_unsubscribe() {
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
         let bank = Bank::new(&genesis_config);
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-        let rpc = RpcSolPubSubImpl::default_with_blockstore_bank_forks(blockstore, bank_forks);
+        let rpc = RpcSolPubSubImpl::default_with_bank_forks(bank_forks);
         let session = create_session();
         let (subscriber, _id_receiver, receiver) = Subscriber::new_test("slotNotification");
         rpc.slot_subscribe(session, subscriber);
@@ -872,11 +833,7 @@ mod tests {
     #[test]
     #[serial]
     fn test_vote_subscribe() {
-        let ledger_path = get_tmp_ledger_path!();
+        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests()));
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
-        let block_commitment_cache = Arc::new(RwLock::new(
-            BlockCommitmentCache::new_for_tests_with_blockstore(blockstore.clone()),
-        ));
 
         let validator_voting_keypairs: Vec<_> = (0..10)
             .map(|_| ValidatorVoteKeypairs::new(Keypair::new(), Keypair::new(), Keypair::new()))
@@ -890,8 +847,7 @@ mod tests {
         let bank_forks = Arc::new(RwLock::new(bank_forks));
 
         // Setup RPC
-        let mut rpc =
+        let mut rpc = RpcSolPubSubImpl::default_with_bank_forks(bank_forks.clone());
-            RpcSolPubSubImpl::default_with_blockstore_bank_forks(blockstore, bank_forks.clone());
         let session = create_session();
         let (subscriber, _id_receiver, receiver) = Subscriber::new_test("voteNotification");
 
@@ -940,12 +896,10 @@ mod tests {
     #[test]
     #[serial]
     fn test_vote_unsubscribe() {
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
         let bank = Bank::new(&genesis_config);
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
-        let rpc = RpcSolPubSubImpl::default_with_blockstore_bank_forks(blockstore, bank_forks);
+        let rpc = RpcSolPubSubImpl::default_with_bank_forks(bank_forks);
         let session = create_session();
         let (subscriber, _id_receiver, _) = Subscriber::new_test("voteNotification");
         rpc.vote_subscribe(session, subscriber);

core/src/rpc_pubsub_service.rs

@@ -72,13 +72,12 @@ impl PubSubService {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::commitment::BlockCommitmentCache;
+    use solana_runtime::{
-    use solana_ledger::{
+        bank::Bank,
-        blockstore::Blockstore,
+        bank_forks::BankForks,
+        commitment::BlockCommitmentCache,
         genesis_utils::{create_genesis_config, GenesisConfigInfo},
-        get_tmp_ledger_path,
     };
-    use solana_runtime::{bank::Bank, bank_forks::BankForks};
     use std::{
         net::{IpAddr, Ipv4Addr},
         sync::RwLock,
@@ -88,17 +87,13 @@ mod tests {
     fn test_pubsub_new() {
         let pubsub_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);
         let exit = Arc::new(AtomicBool::new(false));
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
         let bank = Bank::new(&genesis_config);
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
         let subscriptions = Arc::new(RpcSubscriptions::new(
             &exit,
             bank_forks,
-            Arc::new(RwLock::new(
+            Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests())),
-                BlockCommitmentCache::new_for_tests_with_blockstore(blockstore),
-            )),
         ));
         let pubsub_service = PubSubService::new(&subscriptions, pubsub_addr, &exit);
         let thread = pubsub_service.thread_hdl.thread();

core/src/rpc_service.rs

@@ -1,7 +1,7 @@
 //! The `rpc_service` module implements the Solana JSON RPC service.
 
 use crate::{
-    cluster_info::ClusterInfo, commitment::BlockCommitmentCache, rpc::*, rpc_health::*,
+    cluster_info::ClusterInfo, rpc::*, rpc_health::*,
     send_transaction_service::SendTransactionService, validator::ValidatorExit,
 };
 use jsonrpc_core::MetaIoHandler;
@@ -13,6 +13,7 @@ use regex::Regex;
 use solana_ledger::blockstore::Blockstore;
 use solana_runtime::{
     bank_forks::{BankForks, SnapshotConfig},
+    commitment::BlockCommitmentCache,
     snapshot_utils,
 };
 use solana_sdk::{hash::Hash, native_token::lamports_to_sol, pubkey::Pubkey};
@@ -378,9 +379,7 @@ mod tests {
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
         let ledger_path = get_tmp_ledger_path!();
         let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
-        let block_commitment_cache = Arc::new(RwLock::new(
+        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
-            BlockCommitmentCache::default_with_blockstore(blockstore.clone()),
-        ));
         let mut rpc_service = JsonRpcService::new(
             rpc_addr,
             JsonRpcConfig::default(),

core/src/rpc_subscriptions.rs

@@ -1,6 +1,5 @@
 //! The `pubsub` module implements a threaded subscription service on client RPC request
 
-use crate::commitment::BlockCommitmentCache;
 use core::hash::Hash;
 use jsonrpc_core::futures::Future;
 use jsonrpc_pubsub::{
@@ -11,8 +10,7 @@ use serde::Serialize;
 use solana_client::rpc_response::{
     Response, RpcAccount, RpcKeyedAccount, RpcResponseContext, RpcSignatureResult,
 };
-use solana_ledger::blockstore::Blockstore;
+use solana_runtime::{bank::Bank, bank_forks::BankForks, commitment::BlockCommitmentCache};
-use solana_runtime::{bank::Bank, bank_forks::BankForks};
 use solana_sdk::{
     account::Account,
     clock::{Slot, UnixTimestamp},
@@ -375,16 +373,11 @@ impl RpcSubscriptions {
         }
     }
 
-    pub fn default_with_blockstore_bank_forks(
+    pub fn default_with_bank_forks(bank_forks: Arc<RwLock<BankForks>>) -> Self {
-        blockstore: Arc<Blockstore>,
-        bank_forks: Arc<RwLock<BankForks>>,
-    ) -> Self {
         Self::new(
             &Arc::new(AtomicBool::new(false)),
             bank_forks,
-            Arc::new(RwLock::new(BlockCommitmentCache::default_with_blockstore(
+            Arc::new(RwLock::new(BlockCommitmentCache::default())),
-                blockstore,
-            ))),
         )
     }
 
@@ -899,14 +892,12 @@ impl RpcSubscriptions {
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
-    use crate::commitment::BlockCommitment;
     use jsonrpc_core::futures::{self, stream::Stream};
     use jsonrpc_pubsub::typed::Subscriber;
     use serial_test_derive::serial;
-    use solana_ledger::{
+    use solana_runtime::{
-        blockstore::Blockstore,
+        commitment::BlockCommitment,
         genesis_utils::{create_genesis_config, GenesisConfigInfo},
-        get_tmp_ledger_path,
     };
     use solana_sdk::{
         signature::{Keypair, Signer},
@@ -948,8 +939,6 @@ pub(crate) mod tests {
             mint_keypair,
             ..
         } = create_genesis_config(100);
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let bank = Bank::new(&genesis_config);
         let blockhash = bank.last_blockhash();
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
@@ -965,13 +954,10 @@ pub(crate) mod tests {
         let subscriptions = RpcSubscriptions::new(
             &exit,
             bank_forks.clone(),
-            Arc::new(RwLock::new(
+            Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests_with_bank(
-                BlockCommitmentCache::new_for_tests_with_blockstore_bank(
+                bank_forks.read().unwrap().get(1).unwrap().clone(),
-                    blockstore,
+                1,
-                    bank_forks.read().unwrap().get(1).unwrap().clone(),
+            ))),
-                    1,
-                ),
-            )),
         );
         subscriptions.add_account_subscription(
             alice.pubkey(),
@@ -1042,8 +1028,6 @@ pub(crate) mod tests {
             mint_keypair,
             ..
         } = create_genesis_config(100);
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let bank = Bank::new(&genesis_config);
         let blockhash = bank.last_blockhash();
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
@@ -1071,9 +1055,7 @@ pub(crate) mod tests {
         let subscriptions = RpcSubscriptions::new(
             &exit,
             bank_forks,
-            Arc::new(RwLock::new(
+            Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests())),
-                BlockCommitmentCache::new_for_tests_with_blockstore(blockstore),
-            )),
         );
         subscriptions.add_program_subscription(
             solana_budget_program::id(),
@@ -1130,8 +1112,6 @@ pub(crate) mod tests {
             mint_keypair,
             ..
         } = create_genesis_config(100);
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let bank = Bank::new(&genesis_config);
         let blockhash = bank.last_blockhash();
         let mut bank_forks = BankForks::new(bank);
@@ -1171,7 +1151,7 @@ pub(crate) mod tests {
         block_commitment.entry(0).or_insert(cache0);
         block_commitment.entry(1).or_insert(cache1);
         let block_commitment_cache =
-            BlockCommitmentCache::new(block_commitment, 0, 10, bank1, blockstore, 0, 0);
+            BlockCommitmentCache::new(block_commitment, 0, 10, bank1, 0, 0);
 
         let exit = Arc::new(AtomicBool::new(false));
         let subscriptions = RpcSubscriptions::new(
@@ -1286,17 +1266,13 @@ pub(crate) mod tests {
             Subscriber::new_test("slotNotification");
         let sub_id = SubscriptionId::Number(0 as u64);
         let exit = Arc::new(AtomicBool::new(false));
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
         let bank = Bank::new(&genesis_config);
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
         let subscriptions = RpcSubscriptions::new(
             &exit,
             bank_forks,
-            Arc::new(RwLock::new(
+            Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests())),
-                BlockCommitmentCache::new_for_tests_with_blockstore(blockstore),
-            )),
         );
         subscriptions.add_slot_subscription(sub_id.clone(), subscriber);
 
@@ -1338,17 +1314,13 @@ pub(crate) mod tests {
             Subscriber::new_test("rootNotification");
         let sub_id = SubscriptionId::Number(0 as u64);
         let exit = Arc::new(AtomicBool::new(false));
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
         let bank = Bank::new(&genesis_config);
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
         let subscriptions = RpcSubscriptions::new(
             &exit,
             bank_forks,
-            Arc::new(RwLock::new(
+            Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests())),
-                BlockCommitmentCache::new_for_tests_with_blockstore(blockstore),
-            )),
         );
         subscriptions.add_root_subscription(sub_id.clone(), subscriber);
 
@@ -1436,8 +1408,6 @@ pub(crate) mod tests {
             mint_keypair,
             ..
         } = create_genesis_config(100);
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let bank = Bank::new(&genesis_config);
         let blockhash = bank.last_blockhash();
         let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
@@ -1456,13 +1426,10 @@ pub(crate) mod tests {
         let subscriptions = RpcSubscriptions::new(
             &exit,
             bank_forks.clone(),
-            Arc::new(RwLock::new(
+            Arc::new(RwLock::new(BlockCommitmentCache::new_for_tests_with_bank(
-                BlockCommitmentCache::new_for_tests_with_blockstore_bank(
+                bank_forks.read().unwrap().get(1).unwrap().clone(),
-                    blockstore,
+                1,
-                    bank_forks.read().unwrap().get(1).unwrap().clone(),
+            ))),
-                    1,
-                ),
-            )),
         );
         let sub_id0 = SubscriptionId::Number(0 as u64);
         subscriptions.add_account_subscription(

core/src/tvu.rs

@@ -8,7 +8,6 @@ use crate::{
     cluster_info::ClusterInfo,
     cluster_info_vote_listener::VoteTracker,
     cluster_slots::ClusterSlots,
-    commitment::BlockCommitmentCache,
     ledger_cleanup_service::LedgerCleanupService,
     poh_recorder::PohRecorder,
     replay_stage::{ReplayStage, ReplayStageConfig},
@@ -25,7 +24,10 @@ use solana_ledger::{
     blockstore_processor::TransactionStatusSender,
     leader_schedule_cache::LeaderScheduleCache,
 };
-use solana_runtime::{bank_forks::BankForks, snapshot_package::AccountsPackageSender};
+use solana_runtime::{
+    bank_forks::BankForks, commitment::BlockCommitmentCache,
+    snapshot_package::AccountsPackageSender,
+};
 use solana_sdk::{
     pubkey::Pubkey,
     signature::{Keypair, Signer},
@@ -277,9 +279,7 @@ pub mod tests {
             create_test_recorder(&bank, &blockstore, None);
         let vote_keypair = Keypair::new();
         let leader_schedule_cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
-        let block_commitment_cache = Arc::new(RwLock::new(
+        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
-            BlockCommitmentCache::default_with_blockstore(blockstore.clone()),
-        ));
         let (retransmit_slots_sender, _retransmit_slots_receiver) = unbounded();
         let bank_forks = Arc::new(RwLock::new(bank_forks));
         let tvu = Tvu::new(

core/src/validator.rs

@@ -4,7 +4,6 @@ use crate::{
     broadcast_stage::BroadcastStageType,
     cluster_info::{ClusterInfo, Node},
     cluster_info_vote_listener::VoteTracker,
-    commitment::BlockCommitmentCache,
     contact_info::ContactInfo,
     gossip_service::{discover_cluster, GossipService},
     poh_recorder::{PohRecorder, GRACE_TICKS_FACTOR, MAX_GRACE_SLOTS},
@@ -35,6 +34,7 @@ use solana_metrics::datapoint_info;
 use solana_runtime::{
     bank::Bank,
     bank_forks::{BankForks, SnapshotConfig},
+    commitment::BlockCommitmentCache,
     hardened_unpack::{open_genesis_config, MAX_GENESIS_ARCHIVE_UNPACKED_SIZE},
 };
 use solana_sdk::{
@@ -242,9 +242,7 @@ impl Validator {
 
         let cluster_info = Arc::new(ClusterInfo::new(node.info.clone(), keypair.clone()));
         let blockstore = Arc::new(blockstore);
-        let block_commitment_cache = Arc::new(RwLock::new(
+        let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
-            BlockCommitmentCache::default_with_blockstore(blockstore.clone()),
-        ));
 
         let subscriptions = Arc::new(RpcSubscriptions::new(
             &exit,

core/tests/client.rs

@@ -3,15 +3,15 @@ use solana_client::{
     rpc_client::RpcClient,
 };
 use solana_core::{
-    commitment::BlockCommitmentCache, rpc_pubsub_service::PubSubService,
+    rpc_pubsub_service::PubSubService, rpc_subscriptions::RpcSubscriptions,
-    rpc_subscriptions::RpcSubscriptions, validator::TestValidator,
+    validator::TestValidator,
 };
-use solana_ledger::{
+use solana_runtime::{
-    blockstore::Blockstore,
+    bank::Bank,
+    bank_forks::BankForks,
+    commitment::BlockCommitmentCache,
     genesis_utils::{create_genesis_config, GenesisConfigInfo},
-    get_tmp_ledger_path,
 };
-use solana_runtime::{bank::Bank, bank_forks::BankForks};
 use solana_sdk::{
     commitment_config::CommitmentConfig, pubkey::Pubkey, rpc_port, signature::Signer,
     system_transaction,
@@ -91,17 +91,13 @@ fn test_slot_subscription() {
         rpc_port::DEFAULT_RPC_PUBSUB_PORT,
     );
     let exit = Arc::new(AtomicBool::new(false));
-    let ledger_path = get_tmp_ledger_path!();
-    let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
     let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
     let bank = Bank::new(&genesis_config);
     let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
     let subscriptions = Arc::new(RpcSubscriptions::new(
         &exit,
         bank_forks,
-        Arc::new(RwLock::new(BlockCommitmentCache::default_with_blockstore(
+        Arc::new(RwLock::new(BlockCommitmentCache::default())),
-            blockstore,
-        ))),
     ));
     let pubsub_service = PubSubService::new(&subscriptions, pubsub_addr, &exit);
     std::thread::sleep(Duration::from_millis(400));

runtime/src/commitment.rs

@@ -1,5 +1,4 @@
-use solana_ledger::blockstore::Blockstore;
+use crate::bank::Bank;
-use solana_runtime::bank::Bank;
 use solana_sdk::clock::Slot;
 use solana_vote_program::vote_state::MAX_LOCKOUT_HISTORY;
 use std::{collections::HashMap, sync::Arc};
@@ -32,18 +31,17 @@ impl BlockCommitment {
         self.commitment[MAX_LOCKOUT_HISTORY]
     }
 
-    #[cfg(test)]
+    pub fn new(commitment: BlockCommitmentArray) -> Self {
-    pub(crate) fn new(commitment: BlockCommitmentArray) -> Self {
         Self { commitment }
     }
 }
 
+#[derive(Default)]
 pub struct BlockCommitmentCache {
     block_commitment: HashMap<Slot, BlockCommitment>,
     largest_confirmed_root: Slot,
     total_stake: u64,
     bank: Arc<Bank>,
-    pub blockstore: Arc<Blockstore>,
     root: Slot,
     pub highest_confirmed_slot: Slot,
 }
@@ -68,7 +66,6 @@ impl BlockCommitmentCache {
         largest_confirmed_root: Slot,
         total_stake: u64,
         bank: Arc<Bank>,
-        blockstore: Arc<Blockstore>,
         root: Slot,
         highest_confirmed_slot: Slot,
     ) -> Self {
@@ -77,24 +74,11 @@ impl BlockCommitmentCache {
             largest_confirmed_root,
             total_stake,
             bank,
-            blockstore,
             root,
             highest_confirmed_slot,
         }
     }
 
-    pub fn default_with_blockstore(blockstore: Arc<Blockstore>) -> Self {
-        Self {
-            block_commitment: HashMap::default(),
-            largest_confirmed_root: Slot::default(),
-            total_stake: u64::default(),
-            bank: Arc::new(Bank::default()),
-            blockstore,
-            root: Slot::default(),
-            highest_confirmed_slot: Slot::default(),
-        }
-    }
-
     pub fn get_block_commitment(&self, slot: Slot) -> Option<&BlockCommitment> {
         self.block_commitment.get(&slot)
     }
@@ -159,37 +143,21 @@ impl BlockCommitmentCache {
         })
     }
 
-    pub fn is_confirmed_rooted(&self, slot: Slot) -> bool {
+    pub fn new_for_tests() -> Self {
-        slot <= self.largest_confirmed_root()
-            && (self.blockstore.is_root(slot) || self.bank.status_cache_ancestors().contains(&slot))
-    }
-
-    #[cfg(test)]
-    pub fn new_for_tests_with_blockstore(blockstore: Arc<Blockstore>) -> Self {
         let mut block_commitment: HashMap<Slot, BlockCommitment> = HashMap::new();
         block_commitment.insert(0, BlockCommitment::default());
         Self {
             block_commitment,
-            blockstore,
             total_stake: 42,
-            largest_confirmed_root: Slot::default(),
+            ..Self::default()
-            bank: Arc::new(Bank::default()),
-            root: Slot::default(),
-            highest_confirmed_slot: Slot::default(),
         }
     }
 
-    #[cfg(test)]
+    pub fn new_for_tests_with_bank(bank: Arc<Bank>, root: Slot) -> Self {
-    pub fn new_for_tests_with_blockstore_bank(
-        blockstore: Arc<Blockstore>,
-        bank: Arc<Bank>,
-        root: Slot,
-    ) -> Self {
         let mut block_commitment: HashMap<Slot, BlockCommitment> = HashMap::new();
         block_commitment.insert(0, BlockCommitment::default());
         Self {
             block_commitment,
-            blockstore,
             total_stake: 42,
             largest_confirmed_root: root,
             bank,
@@ -198,7 +166,7 @@ impl BlockCommitmentCache {
         }
     }
 
-    pub(crate) fn set_largest_confirmed_root(&mut self, root: Slot) {
+    pub fn set_largest_confirmed_root(&mut self, root: Slot) {
         self.largest_confirmed_root = root;
     }
 }
@@ -206,7 +174,6 @@ impl BlockCommitmentCache {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use solana_ledger::get_tmp_ledger_path;
     use solana_sdk::{genesis_config::GenesisConfig, pubkey::Pubkey};
 
     #[test]
@@ -222,8 +189,6 @@ mod tests {
     #[test]
     fn test_get_confirmations() {
         let bank = Arc::new(Bank::default());
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         // Build BlockCommitmentCache with votes at depths 0 and 1 for 2 slots
         let mut cache0 = BlockCommitment::default();
         cache0.increase_confirmation_stake(1, 5);
@@ -241,8 +206,7 @@ mod tests {
         block_commitment.entry(0).or_insert(cache0);
         block_commitment.entry(1).or_insert(cache1);
         block_commitment.entry(2).or_insert(cache2);
-        let block_commitment_cache =
+        let block_commitment_cache = BlockCommitmentCache::new(block_commitment, 0, 50, bank, 0, 0);
-            BlockCommitmentCache::new(block_commitment, 0, 50, bank, blockstore, 0, 0);
 
         assert_eq!(block_commitment_cache.get_confirmation_count(0), Some(2));
         assert_eq!(block_commitment_cache.get_confirmation_count(1), Some(1));
@@ -250,47 +214,10 @@ mod tests {
         assert_eq!(block_commitment_cache.get_confirmation_count(3), None,);
     }
 
-    #[test]
-    fn test_is_confirmed_rooted() {
-        let bank = Arc::new(Bank::default());
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
-        blockstore.set_roots(&[0, 1]).unwrap();
-        // Build BlockCommitmentCache with rooted slots
-        let mut cache0 = BlockCommitment::default();
-        cache0.increase_rooted_stake(50);
-        let mut cache1 = BlockCommitment::default();
-        cache1.increase_rooted_stake(40);
-        let mut cache2 = BlockCommitment::default();
-        cache2.increase_rooted_stake(20);
-
-        let mut block_commitment = HashMap::new();
-        block_commitment.entry(1).or_insert(cache0);
-        block_commitment.entry(2).or_insert(cache1);
-        block_commitment.entry(3).or_insert(cache2);
-        let largest_confirmed_root = 1;
-        let block_commitment_cache = BlockCommitmentCache::new(
-            block_commitment,
-            largest_confirmed_root,
-            50,
-            bank,
-            blockstore,
-            0,
-            0,
-        );
-
-        assert!(block_commitment_cache.is_confirmed_rooted(0));
-        assert!(block_commitment_cache.is_confirmed_rooted(1));
-        assert!(!block_commitment_cache.is_confirmed_rooted(2));
-        assert!(!block_commitment_cache.is_confirmed_rooted(3));
-    }
-
     #[test]
     fn test_highest_confirmed_slot() {
         let bank = Arc::new(Bank::new(&GenesisConfig::default()));
         let bank_slot_5 = Arc::new(Bank::new_from_parent(&bank, &Pubkey::default(), 5));
-        let ledger_path = get_tmp_ledger_path!();
-        let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
         let total_stake = 50;
 
         // Build cache with confirmation_count 2 given total_stake
@@ -312,15 +239,8 @@ mod tests {
         block_commitment.entry(1).or_insert_with(|| cache0.clone()); // Slot 1, conf 2
         block_commitment.entry(2).or_insert_with(|| cache1.clone()); // Slot 2, conf 1
         block_commitment.entry(3).or_insert_with(|| cache2.clone()); // Slot 3, conf 0
-        let block_commitment_cache = BlockCommitmentCache::new(
+        let block_commitment_cache =
-            block_commitment,
+            BlockCommitmentCache::new(block_commitment, 0, total_stake, bank_slot_5.clone(), 0, 0);
-            0,
-            total_stake,
-            bank_slot_5.clone(),
-            blockstore.clone(),
-            0,
-            0,
-        );
 
         assert_eq!(block_commitment_cache.calculate_highest_confirmed_slot(), 2);
 
@@ -329,15 +249,8 @@ mod tests {
         block_commitment.entry(1).or_insert_with(|| cache1.clone()); // Slot 1, conf 1
         block_commitment.entry(2).or_insert_with(|| cache1.clone()); // Slot 2, conf 1
         block_commitment.entry(3).or_insert_with(|| cache2.clone()); // Slot 3, conf 0
-        let block_commitment_cache = BlockCommitmentCache::new(
+        let block_commitment_cache =
-            block_commitment,
+            BlockCommitmentCache::new(block_commitment, 0, total_stake, bank_slot_5.clone(), 0, 0);
-            0,
-            total_stake,
-            bank_slot_5.clone(),
-            blockstore.clone(),
-            0,
-            0,
-        );
 
         assert_eq!(block_commitment_cache.calculate_highest_confirmed_slot(), 2);
 
@@ -346,15 +259,8 @@ mod tests {
         block_commitment.entry(1).or_insert_with(|| cache1.clone()); // Slot 1, conf 1
         block_commitment.entry(3).or_insert(cache1); // Slot 3, conf 1
         block_commitment.entry(5).or_insert_with(|| cache2.clone()); // Slot 5, conf 0
-        let block_commitment_cache = BlockCommitmentCache::new(
+        let block_commitment_cache =
-            block_commitment,
+            BlockCommitmentCache::new(block_commitment, 0, total_stake, bank_slot_5.clone(), 0, 0);
-            0,
-            total_stake,
-            bank_slot_5.clone(),
-            blockstore.clone(),
-            0,
-            0,
-        );
 
         assert_eq!(block_commitment_cache.calculate_highest_confirmed_slot(), 3);
 
@@ -363,15 +269,8 @@ mod tests {
         block_commitment.entry(1).or_insert(cache0); // Slot 1, conf 2
         block_commitment.entry(2).or_insert_with(|| cache2.clone()); // Slot 2, conf 0
         block_commitment.entry(3).or_insert_with(|| cache2.clone()); // Slot 3, conf 0
-        let block_commitment_cache = BlockCommitmentCache::new(
+        let block_commitment_cache =
-            block_commitment,
+            BlockCommitmentCache::new(block_commitment, 0, total_stake, bank_slot_5.clone(), 0, 0);
-            0,
-            total_stake,
-            bank_slot_5.clone(),
-            blockstore.clone(),
-            0,
-            0,
-        );
 
         assert_eq!(block_commitment_cache.calculate_highest_confirmed_slot(), 1);
 
@@ -380,15 +279,8 @@ mod tests {
         block_commitment.entry(1).or_insert_with(|| cache2.clone()); // Slot 1, conf 0
         block_commitment.entry(2).or_insert_with(|| cache2.clone()); // Slot 2, conf 0
         block_commitment.entry(3).or_insert(cache2); // Slot 3, conf 0
-        let block_commitment_cache = BlockCommitmentCache::new(
+        let block_commitment_cache =
-            block_commitment,
+            BlockCommitmentCache::new(block_commitment, 0, total_stake, bank_slot_5, 0, 0);
-            0,
-            total_stake,
-            bank_slot_5,
-            blockstore,
-            0,
-            0,
-        );
 
         assert_eq!(block_commitment_cache.calculate_highest_confirmed_slot(), 0);
     }

runtime/src/lib.rs

@@ -8,6 +8,7 @@ pub mod bank_forks;
 mod blockhash_queue;
 pub mod bloom;
 pub mod builtin_programs;
+pub mod commitment;
 pub mod epoch_stakes;
 pub mod genesis_utils;
 pub mod hardened_unpack;