gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove frozen account support

Browse Source
This commit is contained in:
Michael Vines
2021-11-28 21:55:35 -08:00
parent 09799590ac
commit ba9dfa0d22
14 changed files with 2 additions and 399 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
core/src/validator.rs
View File

@ -136,7 +136,6 @@ pub struct ValidatorConfig {
pub gossip_validators: Option<HashSet<Pubkey>>, // None = gossip with all
pub halt_on_known_validators_accounts_hash_mismatch: bool,
pub accounts_hash_fault_injection_slots: u64, // 0 = no fault injection
pub frozen_accounts: Vec<Pubkey>,
pub no_rocksdb_compaction: bool,
pub rocksdb_compaction_interval: Option<u64>,
pub rocksdb_max_compaction_jitter: Option<u64>,
@ -197,7 +196,6 @@ impl Default for ValidatorConfig {
gossip_validators: None,
halt_on_known_validators_accounts_hash_mismatch: false,
accounts_hash_fault_injection_slots: 0,
frozen_accounts: vec![],
no_rocksdb_compaction: false,
rocksdb_compaction_interval: None,
rocksdb_max_compaction_jitter: None,
@ -1276,7 +1274,6 @@ fn new_banks_from_ledger(
poh_verify,
dev_halt_at_slot: config.dev_halt_at_slot,
new_hard_forks: config.new_hard_forks.clone(),
frozen_accounts: config.frozen_accounts.clone(),
debug_keys: config.debug_keys.clone(),
account_indexes: config.account_indexes.clone(),
accounts_db_caching_enabled: config.accounts_db_caching_enabled,

4
core/tests/snapshots.rs
View File

@ -126,7 +126,6 @@ mod tests {
let bank0 = Bank::new_with_paths_for_tests(
&genesis_config_info.genesis_config,
vec![accounts_dir.path().to_path_buf()],
&[],
None,
None,
AccountSecondaryIndexes::default(),
@ -184,7 +183,6 @@ mod tests {
let (deserialized_bank, _timing) = snapshot_utils::bank_from_snapshot_archives(
account_paths,
&[],
&old_bank_forks
.snapshot_config
.as_ref()
@ -828,7 +826,6 @@ mod tests {
&snapshot_config.bank_snapshots_dir,
&snapshot_config.snapshot_archives_dir,
&[accounts_dir],
&[],
genesis_config,
None,
None,
@ -1008,7 +1005,6 @@ mod tests {
&snapshot_test_config.snapshot_config.bank_snapshots_dir,
&snapshot_test_config.snapshot_config.snapshot_archives_dir,
&[snapshot_test_config.accounts_dir.as_ref().to_path_buf()],
&[],
&snapshot_test_config.genesis_config_info.genesis_config,
None,
None,

1
ledger/src/bank_forks_utils.rs
View File

@ -169,7 +169,6 @@ fn load_from_snapshot(
&snapshot_config.bank_snapshots_dir,
&snapshot_config.snapshot_archives_dir,
&account_paths,
&process_options.frozen_accounts,
genesis_config,
process_options.debug_keys.clone(),
Some(&crate::builtins::get(process_options.bpf_jit)),

3
ledger/src/blockstore_processor.rs
View File

@ -464,7 +464,6 @@ pub struct ProcessOptions {
pub entry_callback: Option<ProcessCallback>,
pub override_num_threads: Option<usize>,
pub new_hard_forks: Option<Vec<Slot>>,
pub frozen_accounts: Vec<Pubkey>,
pub debug_keys: Option<Arc<HashSet<Pubkey>>>,
pub account_indexes: AccountSecondaryIndexes,
pub accounts_db_caching_enabled: bool,
@ -500,7 +499,6 @@ pub fn process_blockstore(
let bank0 = Bank::new_with_paths(
genesis_config,
account_paths,
&opts.frozen_accounts,
opts.debug_keys.clone(),
Some(&crate::builtins::get(opts.bpf_jit)),
opts.account_indexes.clone(),
@ -3376,7 +3374,6 @@ pub mod tests {
let bank = Bank::new_with_paths_for_tests(
genesis_config,
account_paths,
&[],
None,
None,
AccountSecondaryIndexes::default(),

1
local-cluster/src/validator_configs.rs
View File

@ -30,7 +30,6 @@ pub fn safe_clone_config(config: &ValidatorConfig) -> ValidatorConfig {
halt_on_known_validators_accounts_hash_mismatch: config
.halt_on_known_validators_accounts_hash_mismatch,
accounts_hash_fault_injection_slots: config.accounts_hash_fault_injection_slots,
frozen_accounts: config.frozen_accounts.clone(),
no_rocksdb_compaction: config.no_rocksdb_compaction,
rocksdb_compaction_interval: config.rocksdb_compaction_interval,
rocksdb_max_compaction_jitter: config.rocksdb_max_compaction_jitter,

116
local-cluster/tests/local_cluster.rs
View File

@ -1440,122 +1440,6 @@ fn test_mainnet_beta_cluster_type() {
}
}
fn generate_frozen_account_panic(mut cluster: LocalCluster, frozen_account: Arc<Keypair>) {
let client = cluster
.get_validator_client(&frozen_account.pubkey())
.unwrap();
// Check the validator is alive by poking it over RPC
trace!(
"validator slot: {}",
client
.get_slot_with_commitment(CommitmentConfig::processed())
.expect("get slot")
);
// Reset the frozen account panic signal
solana_runtime::accounts_db::FROZEN_ACCOUNT_PANIC.store(false, Ordering::Relaxed);
// Wait for the frozen account panic signal
let mut i = 0;
while !solana_runtime::accounts_db::FROZEN_ACCOUNT_PANIC.load(Ordering::Relaxed) {
// Transfer from frozen account
let (blockhash, _) = client
.get_latest_blockhash_with_commitment(CommitmentConfig::processed())
.unwrap();
client
.async_transfer(
1,
&frozen_account,
&solana_sdk::pubkey::new_rand(),
blockhash,
)
.unwrap();
sleep(Duration::from_secs(1));
i += 1;
assert!(i <= 10, "FROZEN_ACCOUNT_PANIC still false");
}
// The validator is now broken and won't shutdown properly. Avoid LocalCluster panic in Drop
// with some manual cleanup:
cluster.exit();
cluster.validators = HashMap::default();
}
#[test]
#[serial]
fn test_frozen_account_from_genesis() {
solana_logger::setup_with_default(RUST_LOG_FILTER);
let validator_identity =
Arc::new(solana_sdk::signature::keypair_from_seed(&[0u8; 32]).unwrap());
let mut config = ClusterConfig {
validator_keys: Some(vec![(validator_identity.clone(), true)]),
node_stakes: vec![100; 1],
cluster_lamports: 1_000,
validator_configs: vec![ValidatorConfig {
// Freeze the validator identity account
frozen_accounts: vec![validator_identity.pubkey()],
..ValidatorConfig::default()
}],
..ClusterConfig::default()
};
generate_frozen_account_panic(
LocalCluster::new(&mut config, SocketAddrSpace::Unspecified),
validator_identity,
);
}
#[test]
#[serial]
fn test_frozen_account_from_snapshot() {
solana_logger::setup_with_default(RUST_LOG_FILTER);
let validator_identity =
Arc::new(solana_sdk::signature::keypair_from_seed(&[0u8; 32]).unwrap());
let mut snapshot_test_config = setup_snapshot_validator_config(5, 1);
// Freeze the validator identity account
snapshot_test_config.validator_config.frozen_accounts = vec![validator_identity.pubkey()];
let mut config = ClusterConfig {
validator_keys: Some(vec![(validator_identity.clone(), true)]),
node_stakes: vec![100; 1],
cluster_lamports: 1_000,
validator_configs: make_identical_validator_configs(
&snapshot_test_config.validator_config,
1,
),
..ClusterConfig::default()
};
let mut cluster = LocalCluster::new(&mut config, SocketAddrSpace::Unspecified);
let snapshot_archives_dir = &snapshot_test_config
.validator_config
.snapshot_config
.as_ref()
.unwrap()
.snapshot_archives_dir;
trace!("Waiting for snapshot at {:?}", snapshot_archives_dir);
let full_snapshot_archive_info = cluster.wait_for_next_full_snapshot(snapshot_archives_dir);
trace!(
"Found snapshot: {}",
full_snapshot_archive_info.path().display()
);
// Restart the validator from a snapshot
let validator_info = cluster.exit_node(&validator_identity.pubkey());
cluster.restart_node(
&validator_identity.pubkey(),
validator_info,
SocketAddrSpace::Unspecified,
);
generate_frozen_account_panic(cluster, validator_identity);
}
#[test]
#[serial]
fn test_consistency_halt() {

1
replica-node/src/replica_node.rs
View File

@ -119,7 +119,6 @@ fn initialize_from_snapshot(
);
let (bank0, _) = snapshot_utils::bank_from_snapshot_archives(
&replica_config.account_paths,
&[],
&snapshot_config.bank_snapshots_dir,
&archive_info,
None,

2
runtime/benches/accounts.rs
View File

@ -47,7 +47,6 @@ fn test_accounts_create(bencher: &mut Bencher) {
let bank0 = Bank::new_with_paths_for_benches(
&genesis_config,
vec![PathBuf::from("bench_a0")],
&[],
None,
None,
AccountSecondaryIndexes::default(),
@ -68,7 +67,6 @@ fn test_accounts_squash(bencher: &mut Bencher) {
let mut prev_bank = Arc::new(Bank::new_with_paths_for_benches(
&genesis_config,
vec![PathBuf::from("bench_a1")],
&[],
None,
None,
AccountSecondaryIndexes::default(),

220
runtime/src/accounts_db.rs
View File

@ -44,7 +44,6 @@ use dashmap::{
mapref::entry::Entry::{Occupied, Vacant},
DashMap, DashSet,
};
use lazy_static::lazy_static;
use log::*;
use rand::{prelude::SliceRandom, thread_rng, Rng};
use rayon::{prelude::*, ThreadPool};
@ -57,7 +56,7 @@ use solana_sdk::{
clock::{BankId, Epoch, Slot, SlotCount},
epoch_schedule::EpochSchedule,
genesis_config::ClusterType,
hash::{Hash, Hasher},
hash::Hash,
pubkey::Pubkey,
timing::AtomicInterval,
};
@ -165,12 +164,6 @@ const ABSURD_CONSECUTIVE_FAILED_ITERATIONS: usize = 100;
type DashMapVersionHash = DashMap<Pubkey, (u64, Hash)>;
lazy_static! {
// FROZEN_ACCOUNT_PANIC is used to signal local_cluster that an AccountsDb panic has occurred,
// as |cargo test| cannot observe panics in other threads
pub static ref FROZEN_ACCOUNT_PANIC: Arc<AtomicBool> = Arc::new(AtomicBool::new(false));
}
#[derive(Debug, Clone, Copy)]
pub enum AccountShrinkThreshold {
/// Measure the total space sparseness across all candididates
@ -868,12 +861,6 @@ pub struct BankHashInfo {
pub stats: BankHashStats,
}
#[derive(Debug)]
struct FrozenAccountInfo {
pub hash: Hash, // Hash generated by hash_frozen_account_data()
pub lamports: u64, // Account balance cannot be lower than this amount
}
#[derive(Default)]
pub struct StoreAccountsTiming {
store_accounts_elapsed: u64,
@ -1008,9 +995,6 @@ pub struct AccountsDb {
/// Starting file size of appendvecs
file_size: u64,
/// Accounts that will cause a panic! if data modified or lamports decrease
frozen_accounts: HashMap<Pubkey, FrozenAccountInfo>,
/// Thread pool used for par_iter
pub thread_pool: ThreadPool,
@ -1585,7 +1569,6 @@ impl AccountsDb {
thread_pool_clean: make_min_priority_thread_pool(),
min_num_stores: num_threads,
bank_hashes: RwLock::new(bank_hashes),
frozen_accounts: HashMap::new(),
external_purge_slots_stats: PurgeStats::default(),
clean_accounts_stats: CleanAccountsStats::default(),
shrink_stats: ShrinkStats::default(),
@ -4351,21 +4334,6 @@ impl AccountsDb {
)
}
fn hash_frozen_account_data(account: &AccountSharedData) -> Hash {
let mut hasher = Hasher::default();
hasher.hash(account.data());
hasher.hash(account.owner().as_ref());
if account.executable() {
hasher.hash(&[1u8; 1]);
} else {
hasher.hash(&[0u8; 1]);
}
hasher.result()
}
fn hash_account_data(
slot: Slot,
lamports: u64,
@ -6204,58 +6172,6 @@ impl AccountsDb {
.fetch_add(measure.as_us(), Ordering::Relaxed);
}
pub(crate) fn freeze_accounts(&mut self, ancestors: &Ancestors, account_pubkeys: &[Pubkey]) {
for account_pubkey in account_pubkeys {
if let Some((account, _slot)) = self.load_without_fixed_root(ancestors, account_pubkey)
{
let frozen_account_info = FrozenAccountInfo {
hash: Self::hash_frozen_account_data(&account),
lamports: account.lamports(),
};
warn!(
"Account {} is now frozen at lamports={}, hash={}",
account_pubkey, frozen_account_info.lamports, frozen_account_info.hash
);
self.frozen_accounts
.insert(*account_pubkey, frozen_account_info);
} else {
panic!(
"Unable to freeze an account that does not exist: {}",
account_pubkey
);
}
}
}
/// Cause a panic if frozen accounts would be affected by data in `accounts`
fn assert_frozen_accounts(&self, accounts: &[(&Pubkey, &AccountSharedData)]) {
if self.frozen_accounts.is_empty() {
return;
}
for (account_pubkey, account) in accounts.iter() {
if let Some(frozen_account_info) = self.frozen_accounts.get(*account_pubkey) {
if account.lamports() < frozen_account_info.lamports {
FROZEN_ACCOUNT_PANIC.store(true, Ordering::Relaxed);
panic!(
"Frozen account {} modified. Lamports decreased from {} to {}",
account_pubkey,
frozen_account_info.lamports,
account.lamports(),
)
}
let hash = Self::hash_frozen_account_data(account);
if hash != frozen_account_info.hash {
FROZEN_ACCOUNT_PANIC.store(true, Ordering::Relaxed);
panic!(
"Frozen account {} modified. Hash changed from {} to {}",
account_pubkey, frozen_account_info.hash, hash,
)
}
}
}
}
pub fn store_cached(&self, slot: Slot, accounts: &[(&Pubkey, &AccountSharedData)]) {
self.store(slot, accounts, self.caching_enabled);
}
@ -6272,7 +6188,6 @@ impl AccountsDb {
if accounts.is_empty() {
return;
}
self.assert_frozen_accounts(accounts);
let mut stats = BankHashStats::default();
let mut total_data = 0;
@ -9674,139 +9589,6 @@ pub mod tests {
assert_eq!(ret.0.data().len(), data_len);
}
#[test]
fn test_hash_frozen_account_data() {
let account = AccountSharedData::new(1, 42, &Pubkey::default());
let hash = AccountsDb::hash_frozen_account_data(&account);
assert_ne!(hash, Hash::default()); // Better not be the default Hash
// Lamports changes to not affect the hash
let mut account_modified = account.clone();
account_modified.checked_sub_lamports(1).unwrap();
assert_eq!(
hash,
AccountsDb::hash_frozen_account_data(&account_modified)
);
// Rent epoch may changes to not affect the hash
let mut account_modified = account.clone();
account_modified.set_rent_epoch(account_modified.rent_epoch() + 1);
assert_eq!(
hash,
AccountsDb::hash_frozen_account_data(&account_modified)
);
// Account data may not be modified
let mut account_modified = account.clone();
account_modified.data_as_mut_slice()[0] = 42;
assert_ne!(
hash,
AccountsDb::hash_frozen_account_data(&account_modified)
);
// Owner may not be modified
let mut account_modified = account.clone();
account_modified
.set_owner(Pubkey::from_str("My11111111111111111111111111111111111111111").unwrap());
assert_ne!(
hash,
AccountsDb::hash_frozen_account_data(&account_modified)
);
// Executable may not be modified
let mut account_modified = account;
account_modified.set_executable(true);
assert_ne!(
hash,
AccountsDb::hash_frozen_account_data(&account_modified)
);
}
#[test]
fn test_frozen_account_lamport_increase() {
let frozen_pubkey =
Pubkey::from_str("My11111111111111111111111111111111111111111").unwrap();
let mut db = AccountsDb::new(Vec::new(), &ClusterType::Development);
let mut account = AccountSharedData::new(1, 42, &frozen_pubkey);
db.store_uncached(0, &[(&frozen_pubkey, &account)]);
let ancestors = vec![(0, 0)].into_iter().collect();
db.freeze_accounts(&ancestors, &[frozen_pubkey]);
// Store with no account changes is ok
db.store_uncached(0, &[(&frozen_pubkey, &account)]);
// Store with an increase in lamports is ok
account.set_lamports(2);
db.store_uncached(0, &[(&frozen_pubkey, &account)]);
// Store with an decrease that does not go below the frozen amount of lamports is tolerated
account.set_lamports(1);
db.store_uncached(0, &[(&frozen_pubkey, &account)]);
// A store of any value over the frozen value of '1' across different slots is also ok
account.set_lamports(3);
db.store_uncached(1, &[(&frozen_pubkey, &account)]);
account.set_lamports(2);
db.store_uncached(2, &[(&frozen_pubkey, &account)]);
account.set_lamports(1);
db.store_uncached(3, &[(&frozen_pubkey, &account)]);
}
#[test]
#[should_panic(
expected = "Frozen account My11111111111111111111111111111111111111111 modified. Lamports decreased from 1 to 0"
)]
fn test_frozen_account_lamport_decrease() {
let frozen_pubkey =
Pubkey::from_str("My11111111111111111111111111111111111111111").unwrap();
let mut db = AccountsDb::new(Vec::new(), &ClusterType::Development);
let mut account = AccountSharedData::new(1, 42, &frozen_pubkey);
db.store_uncached(0, &[(&frozen_pubkey, &account)]);
let ancestors = vec![(0, 0)].into_iter().collect();
db.freeze_accounts(&ancestors, &[frozen_pubkey]);
// Store with a decrease below the frozen amount of lamports is not ok
account.checked_sub_lamports(1).unwrap();
db.store_uncached(0, &[(&frozen_pubkey, &account)]);
}
#[test]
#[should_panic(
expected = "Unable to freeze an account that does not exist: My11111111111111111111111111111111111111111"
)]
fn test_frozen_account_nonexistent() {
let frozen_pubkey =
Pubkey::from_str("My11111111111111111111111111111111111111111").unwrap();
let mut db = AccountsDb::new(Vec::new(), &ClusterType::Development);
let ancestors = vec![(0, 0)].into_iter().collect();
db.freeze_accounts(&ancestors, &[frozen_pubkey]);
}
#[test]
#[should_panic(
expected = "Frozen account My11111111111111111111111111111111111111111 modified. Hash changed from 8wHcxDkjiwdrkPAsDnmNrF1UDGJFAtZzPQBSVweY3yRA to JdscGYB1uczVssmYuJusDD1Bfe6wpNeeho8XjcH8inN"
)]
fn test_frozen_account_data_modified() {
let frozen_pubkey =
Pubkey::from_str("My11111111111111111111111111111111111111111").unwrap();
let mut db = AccountsDb::new(Vec::new(), &ClusterType::Development);
let mut account = AccountSharedData::new(1, 42, &frozen_pubkey);
db.store_uncached(0, &[(&frozen_pubkey, &account)]);
let ancestors = vec![(0, 0)].into_iter().collect();
db.freeze_accounts(&ancestors, &[frozen_pubkey]);
account.data_as_mut_slice()[0] = 42;
db.store_uncached(0, &[(&frozen_pubkey, &account)]);
}
#[test]
fn test_stored_readable_account() {
let lamports = 1;

14
runtime/src/bank.rs
View File

@ -1065,7 +1065,6 @@ impl Bank {
Self::new_with_paths_for_tests(
genesis_config,
Vec::new(),
&[],
None,
None,
AccountSecondaryIndexes::default(),
@ -1079,7 +1078,6 @@ impl Bank {
let mut bank = Self::new_with_paths_for_tests(
genesis_config,
Vec::new(),
&[],
None,
None,
AccountSecondaryIndexes::default(),
@ -1102,7 +1100,6 @@ impl Bank {
Self::new_with_paths_for_tests(
genesis_config,
Vec::new(),
&[],
None,
None,
account_indexes,
@ -1175,7 +1172,6 @@ impl Bank {
pub fn new_with_paths_for_tests(
genesis_config: &GenesisConfig,
paths: Vec<PathBuf>,
frozen_account_pubkeys: &[Pubkey],
debug_keys: Option<Arc<HashSet<Pubkey>>>,
additional_builtins: Option<&Builtins>,
account_indexes: AccountSecondaryIndexes,
@ -1186,7 +1182,6 @@ impl Bank {
Self::new_with_paths(
genesis_config,
paths,
frozen_account_pubkeys,
debug_keys,
additional_builtins,
account_indexes,
@ -1201,7 +1196,6 @@ impl Bank {
pub fn new_with_paths_for_benches(
genesis_config: &GenesisConfig,
paths: Vec<PathBuf>,
frozen_account_pubkeys: &[Pubkey],
debug_keys: Option<Arc<HashSet<Pubkey>>>,
additional_builtins: Option<&Builtins>,
account_indexes: AccountSecondaryIndexes,
@ -1212,7 +1206,6 @@ impl Bank {
Self::new_with_paths(
genesis_config,
paths,
frozen_account_pubkeys,
debug_keys,
additional_builtins,
account_indexes,
@ -1228,7 +1221,6 @@ impl Bank {
pub fn new_with_paths(
genesis_config: &GenesisConfig,
paths: Vec<PathBuf>,
frozen_account_pubkeys: &[Pubkey],
debug_keys: Option<Arc<HashSet<Pubkey>>>,
additional_builtins: Option<&Builtins>,
account_indexes: AccountSecondaryIndexes,
@ -1259,11 +1251,6 @@ impl Bank {
debug_do_not_add_builtins,
);
// Freeze accounts after process_genesis_config creates the initial append vecs
Arc::get_mut(&mut Arc::get_mut(&mut bank.rc.accounts).unwrap().accounts_db)
.unwrap()
.freeze_accounts(&bank.ancestors, frozen_account_pubkeys);
// genesis needs stakes for all epochs up to the epoch implied by
// slot = 0 and genesis configuration
{
@ -13386,7 +13373,6 @@ pub(crate) mod tests {
let bank0 = Arc::new(Bank::new_with_paths_for_tests(
&genesis_config,
Vec::new(),
&[],
None,
Some(&builtins),
AccountSecondaryIndexes::default(),

10
runtime/src/serde_snapshot.rs
View File

@ -7,7 +7,6 @@ use {
},
accounts_index::AccountSecondaryIndexes,
accounts_update_notifier_interface::AccountsUpdateNotifier,
ancestors::Ancestors,
append_vec::{AppendVec, StoredMetaWriteVersion},
bank::{Bank, BankFieldsToDeserialize, BankRc},
blockhash_queue::BlockhashQueue,
@ -196,7 +195,6 @@ pub(crate) fn bank_from_streams<R>(
account_paths: &[PathBuf],
unpacked_append_vec_map: UnpackedAppendVecMap,
genesis_config: &GenesisConfig,
frozen_account_pubkeys: &[Pubkey],
debug_keys: Option<Arc<HashSet<Pubkey>>>,
additional_builtins: Option<&Builtins>,
account_secondary_indexes: AccountSecondaryIndexes,
@ -233,7 +231,6 @@ where
incremental_snapshot_bank_fields.unwrap_or(full_snapshot_bank_fields),
snapshot_accounts_db_fields,
genesis_config,
frozen_account_pubkeys,
account_paths,
unpacked_append_vec_map,
debug_keys,
@ -327,7 +324,6 @@ fn reconstruct_bank_from_fields<E>(
bank_fields: BankFieldsToDeserialize,
snapshot_accounts_db_fields: SnapshotAccountsDbFields<E>,
genesis_config: &GenesisConfig,
frozen_account_pubkeys: &[Pubkey],
account_paths: &[PathBuf],
unpacked_append_vec_map: UnpackedAppendVecMap,
debug_keys: Option<Arc<HashSet<Pubkey>>>,
@ -343,7 +339,7 @@ fn reconstruct_bank_from_fields<E>(
where
E: SerializableStorage + std::marker::Sync,
{
let mut accounts_db = reconstruct_accountsdb_from_fields(
let accounts_db = reconstruct_accountsdb_from_fields(
snapshot_accounts_db_fields,
account_paths,
unpacked_append_vec_map,
@ -356,10 +352,6 @@ where
accounts_db_config,
accounts_update_notifier,
)?;
accounts_db.freeze_accounts(
&Ancestors::from(&bank_fields.ancestors),
frozen_account_pubkeys,
);
let bank_rc = BankRc::new(Accounts::new_empty(accounts_db), bank_fields.slot);

1
runtime/src/serde_snapshot/tests.rs
View File

@ -241,7 +241,6 @@ fn test_bank_serialize_style(serde_style: SerdeStyle) {
&dbank_paths,
unpacked_append_vec_map,
&genesis_config,
&[],
None,
None,
AccountSecondaryIndexes::default(),

13
runtime/src/snapshot_utils.rs
View File

@ -721,7 +721,6 @@ const PARALLEL_UNTAR_READERS_DEFAULT: usize = 4;
#[allow(clippy::too_many_arguments)]
pub fn bank_from_snapshot_archives(
account_paths: &[PathBuf],
frozen_account_pubkeys: &[Pubkey],
bank_snapshots_dir: impl AsRef<Path>,
full_snapshot_archive_info: &FullSnapshotArchiveInfo,
incremental_snapshot_archive_info: Option<&IncrementalSnapshotArchiveInfo>,
@ -789,7 +788,6 @@ pub fn bank_from_snapshot_archives(
.map(|unarchive_preparation_result| {
&unarchive_preparation_result.unpacked_snapshots_dir_and_version
}),
frozen_account_pubkeys,
account_paths,
unpacked_append_vec_map,
genesis_config,
@ -836,7 +834,6 @@ pub fn bank_from_latest_snapshot_archives(
bank_snapshots_dir: impl AsRef<Path>,
snapshot_archives_dir: impl AsRef<Path>,
account_paths: &[PathBuf],
frozen_account_pubkeys: &[Pubkey],
genesis_config: &GenesisConfig,
debug_keys: Option<Arc<HashSet<Pubkey>>>,
additional_builtins: Option<&Builtins>,
@ -877,7 +874,6 @@ pub fn bank_from_latest_snapshot_archives(
let (bank, timings) = bank_from_snapshot_archives(
account_paths,
frozen_account_pubkeys,
bank_snapshots_dir.as_ref(),
&full_snapshot_archive_info,
incremental_snapshot_archive_info.as_ref(),
@ -1418,7 +1414,6 @@ fn rebuild_bank_from_snapshots(
incremental_snapshot_unpacked_snapshots_dir_and_version: Option<
&UnpackedSnapshotsDirAndVersion,
>,
frozen_account_pubkeys: &[Pubkey],
account_paths: &[PathBuf],
unpacked_append_vec_map: UnpackedAppendVecMap,
genesis_config: &GenesisConfig,
@ -1470,7 +1465,6 @@ fn rebuild_bank_from_snapshots(
account_paths,
unpacked_append_vec_map,
genesis_config,
frozen_account_pubkeys,
debug_keys,
additional_builtins,
account_secondary_indexes,
@ -2638,7 +2632,6 @@ mod tests {
let (roundtrip_bank, _) = bank_from_snapshot_archives(
&[PathBuf::from(accounts_dir.path())],
&[],
bank_snapshots_dir.path(),
&snapshot_archive_info,
None,
@ -2730,7 +2723,6 @@ mod tests {
let (roundtrip_bank, _) = bank_from_snapshot_archives(
&[PathBuf::from(accounts_dir.path())],
&[],
bank_snapshots_dir.path(),
&full_snapshot_archive_info,
None,
@ -2841,7 +2833,6 @@ mod tests {
let (roundtrip_bank, _) = bank_from_snapshot_archives(
&[PathBuf::from(accounts_dir.path())],
&[],
bank_snapshots_dir.path(),
&full_snapshot_archive_info,
Some(&incremental_snapshot_archive_info),
@ -2944,7 +2935,6 @@ mod tests {
&bank_snapshots_dir,
&snapshot_archives_dir,
&[accounts_dir.as_ref().to_path_buf()],
&[],
&genesis_config,
None,
None,
@ -3004,7 +2994,6 @@ mod tests {
let bank0 = Arc::new(Bank::new_with_paths_for_tests(
&genesis_config,
vec![accounts_dir.path().to_path_buf()],
&[],
None,
None,
AccountSecondaryIndexes::default(),
@ -3081,7 +3070,6 @@ mod tests {
.unwrap();
let (deserialized_bank, _) = bank_from_snapshot_archives(
&[accounts_dir.path().to_path_buf()],
&[],
bank_snapshots_dir.path(),
&full_snapshot_archive_info,
Some(&incremental_snapshot_archive_info),
@ -3144,7 +3132,6 @@ mod tests {
let (deserialized_bank, _) = bank_from_snapshot_archives(
&[accounts_dir.path().to_path_buf()],
&[],
bank_snapshots_dir.path(),
&full_snapshot_archive_info,
Some(&incremental_snapshot_archive_info),

12
validator/src/main.rs
View File

@ -1386,17 +1386,6 @@ pub fn main() {
.takes_value(false)
.help("Abort the validator if a bank hash mismatch is detected within known validator set"),
)
.arg(
Arg::with_name("frozen_accounts")
.long("frozen-account")
.validator(is_pubkey)
.value_name("PUBKEY")
.multiple(true)
.takes_value(true)
.help("Freeze the specified account. This will cause the validator to \
intentionally crash should any transaction modify the frozen account in any way \
other than increasing the account balance"),
)
.arg(
Arg::with_name("snapshot_archive_format")
.long("snapshot-archive-format")
@ -2252,7 +2241,6 @@ pub fn main() {
known_validators,
repair_validators,
gossip_validators,
frozen_accounts: values_t!(matches, "frozen_accounts", Pubkey).unwrap_or_default(),
no_rocksdb_compaction,
rocksdb_compaction_interval,
rocksdb_max_compaction_jitter,