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

Rename genesis block to genesis config (#6816)

Browse Source
This commit is contained in:
Justin Starry
2019-11-08 23:56:57 -05:00
committed by GitHub
parent 63425bed10
commit 9807f47d4e
79 changed files with 1104 additions and 1094 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
core/benches/banking_stage.rs
View File

@ -11,7 +11,7 @@ use rayon::prelude::*;
use solana_core::banking_stage::{create_test_recorder, BankingStage};
use solana_core::cluster_info::ClusterInfo;
use solana_core::cluster_info::Node;
use solana_core::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use solana_core::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use solana_core::packet::to_packets_chunked;
use solana_core::poh_recorder::WorkingBankEntry;
use solana_core::service::Service;
@ -20,7 +20,7 @@ use solana_ledger::blocktree_processor::process_entries;
use solana_ledger::entry::{next_hash, Entry};
use solana_perf::test_tx::test_tx;
use solana_runtime::bank::Bank;
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::genesis_config::GenesisConfig;
use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::Keypair;
@ -55,8 +55,8 @@ fn check_txs(receiver: &Arc<Receiver<WorkingBankEntry>>, ref_tx_count: usize) {
#[bench]
fn bench_consume_buffered(bencher: &mut Bencher) {
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(100_000);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(100_000);
let bank = Arc::new(Bank::new(&genesis_config));
let ledger_path = get_tmp_ledger_path!();
let my_pubkey = Pubkey::new_rand();
{
@ -139,25 +139,25 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
const PACKETS_PER_BATCH: usize = 192;
let txes = PACKETS_PER_BATCH * num_threads * CHUNKS;
let mint_total = 1_000_000_000_000;
let GenesisBlockInfo {
mut genesis_block,
let GenesisConfigInfo {
mut genesis_config,
mint_keypair,
..
} = create_genesis_block(mint_total);
} = create_genesis_config(mint_total);
// Set a high ticks_per_slot so we don't run out of ticks
// during the benchmark
genesis_block.ticks_per_slot = 10_000;
genesis_config.ticks_per_slot = 10_000;
let (verified_sender, verified_receiver) = unbounded();
let (vote_sender, vote_receiver) = unbounded();
let bank = Arc::new(Bank::new(&genesis_block));
let bank = Arc::new(Bank::new(&genesis_config));
debug!("threads: {} txs: {}", num_threads, txes);
let transactions = match tx_type {
TransactionType::Accounts => make_accounts_txs(txes, &mint_keypair, genesis_block.hash()),
TransactionType::Programs => make_programs_txs(txes, genesis_block.hash()),
TransactionType::Accounts => make_accounts_txs(txes, &mint_keypair, genesis_config.hash()),
TransactionType::Programs => make_programs_txs(txes, genesis_config.hash()),
};
// fund all the accounts
@ -166,7 +166,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
&mint_keypair,
&tx.message.account_keys[0],
mint_total / txes as u64,
genesis_block.hash(),
genesis_config.hash(),
);
let x = bank.process_transaction(&fund);
x.unwrap();
@ -262,12 +262,12 @@ fn simulate_process_entries(
randomize_txs: bool,
mint_keypair: &Keypair,
mut tx_vector: Vec<Transaction>,
genesis_block: &GenesisBlock,
genesis_config: &GenesisConfig,
keypairs: &Vec<Keypair>,
initial_lamports: u64,
num_accounts: usize,
) {
let bank = Arc::new(Bank::new(genesis_block));
let bank = Arc::new(Bank::new(genesis_config));
for i in 0..(num_accounts / 2) {
bank.transfer(initial_lamports, mint_keypair, &keypairs[i * 2].pubkey())
@ -301,11 +301,11 @@ fn bench_process_entries(randomize_txs: bool, bencher: &mut Bencher) {
// number of accounts need to be in multiple of 4 for correct
// execution of the test.
let num_accounts = entropy_multiplier * 4;
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block((num_accounts + 1) as u64 * initial_lamports);
} = create_genesis_config((num_accounts + 1) as u64 * initial_lamports);
let mut keypairs: Vec<Keypair> = vec![];
let tx_vector: Vec<Transaction> = Vec::with_capacity(num_accounts / 2);
@ -320,7 +320,7 @@ fn bench_process_entries(randomize_txs: bool, bencher: &mut Bencher) {
randomize_txs,
&mint_keypair,
tx_vector.clone(),
&genesis_block,
&genesis_config,
&keypairs,
initial_lamports,
num_accounts,

6
core/benches/retransmit_stage.rs
View File

@ -6,7 +6,7 @@ extern crate test;
use log::*;
use solana_core::cluster_info::{ClusterInfo, Node};
use solana_core::contact_info::ContactInfo;
use solana_core::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use solana_core::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use solana_core::packet::to_packets_chunked;
use solana_core::retransmit_stage::retransmitter;
use solana_ledger::bank_forks::BankForks;
@ -47,8 +47,8 @@ fn bench_retransmitter(bencher: &mut Bencher) {
let peer_sockets = Arc::new(peer_sockets);
let cluster_info = Arc::new(RwLock::new(cluster_info));
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(100_000);
let bank0 = Bank::new(&genesis_block);
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(100_000);
let bank0 = Bank::new(&genesis_config);
let bank_forks = BankForks::new(0, bank0);
let bank = bank_forks.working_bank();
let bank_forks = Arc::new(RwLock::new(bank_forks));

139
core/src/banking_stage.rs
View File

@ -973,7 +973,7 @@ pub fn create_test_recorder(
mod tests {
use super::*;
use crate::cluster_info::Node;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use crate::packet::to_packets;
use crate::poh_recorder::WorkingBank;
use crossbeam_channel::unbounded;
@ -989,8 +989,8 @@ mod tests {
#[test]
fn test_banking_stage_shutdown1() {
let genesis_block = create_genesis_block(2).genesis_block;
let bank = Arc::new(Bank::new(&genesis_block));
let genesis_config = create_genesis_config(2).genesis_config;
let bank = Arc::new(Bank::new(&genesis_config));
let (verified_sender, verified_receiver) = unbounded();
let (vote_sender, vote_receiver) = unbounded();
let ledger_path = get_tmp_ledger_path!();
@ -1020,12 +1020,12 @@ mod tests {
#[test]
fn test_banking_stage_tick() {
solana_logger::setup();
let GenesisBlockInfo {
mut genesis_block, ..
} = create_genesis_block(2);
genesis_block.ticks_per_slot = 4;
let GenesisConfigInfo {
mut genesis_config, ..
} = create_genesis_config(2);
genesis_config.ticks_per_slot = 4;
let num_extra_ticks = 2;
let bank = Arc::new(Bank::new(&genesis_block));
let bank = Arc::new(Bank::new(&genesis_config));
let start_hash = bank.last_blockhash();
let (verified_sender, verified_receiver) = unbounded();
let (vote_sender, vote_receiver) = unbounded();
@ -1059,7 +1059,7 @@ mod tests {
.map(|(_bank, (entry, _tick_height))| entry)
.collect();
trace!("done");
assert_eq!(entries.len(), genesis_block.ticks_per_slot as usize);
assert_eq!(entries.len(), genesis_config.ticks_per_slot as usize);
assert!(entries.verify(&start_hash));
assert_eq!(entries[entries.len() - 1].hash, bank.last_blockhash());
banking_stage.join().unwrap();
@ -1080,12 +1080,12 @@ mod tests {
#[test]
fn test_banking_stage_entries_only() {
solana_logger::setup();
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(10);
let bank = Arc::new(Bank::new(&genesis_block));
} = create_genesis_config(10);
let bank = Arc::new(Bank::new(&genesis_config));
let start_hash = bank.last_blockhash();
let (verified_sender, verified_receiver) = unbounded();
let (vote_sender, vote_receiver) = unbounded();
@ -1152,7 +1152,7 @@ mod tests {
drop(poh_recorder);
let mut blockhash = start_hash;
let bank = Bank::new(&genesis_block);
let bank = Bank::new(&genesis_config);
bank.process_transaction(&fund_tx).unwrap();
//receive entries + ticks
loop {
@ -1192,17 +1192,17 @@ mod tests {
// In this attack we'll demonstrate that a verifier can interpret the ledger
// differently if either the server doesn't signal the ledger to add an
// Entry OR if the verifier tries to parallelize across multiple Entries.
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(2);
} = create_genesis_config(2);
let (verified_sender, verified_receiver) = unbounded();
// Process a batch that includes a transaction that receives two lamports.
let alice = Keypair::new();
let tx =
system_transaction::transfer(&mint_keypair, &alice.pubkey(), 2, genesis_block.hash());
system_transaction::transfer(&mint_keypair, &alice.pubkey(), 2, genesis_config.hash());
let packets = to_packets(&[tx]);
let packets = packets
@ -1214,7 +1214,7 @@ mod tests {
// Process a second batch that uses the same from account, so conflicts with above TX
let tx =
system_transaction::transfer(&mint_keypair, &alice.pubkey(), 1, genesis_block.hash());
system_transaction::transfer(&mint_keypair, &alice.pubkey(), 1, genesis_config.hash());
let packets = to_packets(&[tx]);
let packets = packets
.into_iter()
@ -1228,7 +1228,7 @@ mod tests {
{
let entry_receiver = {
// start a banking_stage to eat verified receiver
let bank = Arc::new(Bank::new(&genesis_block));
let bank = Arc::new(Bank::new(&genesis_config));
let blocktree = Arc::new(
Blocktree::open(&ledger_path)
.expect("Expected to be able to open database ledger"),
@ -1267,7 +1267,7 @@ mod tests {
.map(|(_bank, (entry, _tick_height))| entry)
.collect();
let bank = Bank::new(&genesis_block);
let bank = Bank::new(&genesis_config);
for entry in &entries {
bank.process_transactions(&entry.transactions)
.iter()
@ -1284,12 +1284,12 @@ mod tests {
#[test]
fn test_bank_record_transactions() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(10_000);
let bank = Arc::new(Bank::new(&genesis_block));
} = create_genesis_config(10_000);
let bank = Arc::new(Bank::new(&genesis_config));
let working_bank = WorkingBank {
bank: bank.clone(),
min_tick_height: bank.tick_height(),
@ -1318,8 +1318,8 @@ mod tests {
let pubkey2 = Pubkey::new_rand();
let transactions = vec![
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&keypair2, &pubkey2, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&keypair2, &pubkey2, 1, genesis_config.hash()),
];
let mut results = vec![Ok(()), Ok(())];
@ -1385,11 +1385,11 @@ mod tests {
#[test]
fn test_bank_filter_transaction_indexes() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(10_000);
} = create_genesis_config(10_000);
let pubkey = Pubkey::new_rand();
let transactions = vec![
@ -1398,19 +1398,19 @@ mod tests {
&mint_keypair,
&pubkey,
1,
genesis_block.hash(),
genesis_config.hash(),
)),
Some(system_transaction::transfer(
&mint_keypair,
&pubkey,
1,
genesis_block.hash(),
genesis_config.hash(),
)),
Some(system_transaction::transfer(
&mint_keypair,
&pubkey,
1,
genesis_block.hash(),
genesis_config.hash(),
)),
None,
None,
@ -1418,33 +1418,33 @@ mod tests {
&mint_keypair,
&pubkey,
1,
genesis_block.hash(),
genesis_config.hash(),
)),
None,
Some(system_transaction::transfer(
&mint_keypair,
&pubkey,
1,
genesis_block.hash(),
genesis_config.hash(),
)),
None,
Some(system_transaction::transfer(
&mint_keypair,
&pubkey,
1,
genesis_block.hash(),
genesis_config.hash(),
)),
None,
None,
];
let filtered_transactions = vec![
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
];
assert_eq!(
@ -1466,20 +1466,20 @@ mod tests {
#[test]
fn test_bank_prepare_filter_for_pending_transaction() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(10_000);
} = create_genesis_config(10_000);
let pubkey = Pubkey::new_rand();
let transactions = vec![
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
];
assert_eq!(
@ -1608,19 +1608,19 @@ mod tests {
#[test]
fn test_bank_process_and_record_transactions() {
solana_logger::setup();
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(10_000);
let bank = Arc::new(Bank::new(&genesis_block));
} = create_genesis_config(10_000);
let bank = Arc::new(Bank::new(&genesis_config));
let pubkey = Pubkey::new_rand();
let transactions = vec![system_transaction::transfer(
&mint_keypair,
&pubkey,
1,
genesis_block.hash(),
genesis_config.hash(),
)];
let working_bank = WorkingBank {
@ -1673,7 +1673,7 @@ mod tests {
&mint_keypair,
&pubkey,
2,
genesis_block.hash(),
genesis_config.hash(),
)];
assert_matches!(
@ -1695,18 +1695,18 @@ mod tests {
#[test]
fn test_bank_process_and_record_transactions_account_in_use() {
solana_logger::setup();
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(10_000);
let bank = Arc::new(Bank::new(&genesis_block));
} = create_genesis_config(10_000);
let bank = Arc::new(Bank::new(&genesis_config));
let pubkey = Pubkey::new_rand();
let pubkey1 = Pubkey::new_rand();
let transactions = vec![
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey1, 1, genesis_block.hash()),
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash()),
system_transaction::transfer(&mint_keypair, &pubkey1, 1, genesis_config.hash()),
];
let working_bank = WorkingBank {
@ -1786,17 +1786,20 @@ mod tests {
#[test]
fn test_process_transactions_returns_unprocessed_txs() {
solana_logger::setup();
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(10_000);
let bank = Arc::new(Bank::new(&genesis_block));
} = create_genesis_config(10_000);
let bank = Arc::new(Bank::new(&genesis_config));
let pubkey = Pubkey::new_rand();
let transactions =
vec![system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_block.hash(),); 3];
vec![
system_transaction::transfer(&mint_keypair, &pubkey, 1, genesis_config.hash(),);
3
];
let ledger_path = get_tmp_ledger_path!();
{

14
core/src/blockstream_service.rs
View File

@ -101,7 +101,7 @@ impl Service for BlockstreamService {
#[cfg(test)]
mod test {
use super::*;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use bincode::{deserialize, serialize};
use chrono::{DateTime, FixedOffset};
use serde_json::Value;
@ -118,13 +118,13 @@ mod test {
let ticks_per_slot = 5;
let leader_pubkey = Pubkey::new_rand();
// Set up genesis block and blocktree
let GenesisBlockInfo {
mut genesis_block, ..
} = create_genesis_block(1000);
genesis_block.ticks_per_slot = ticks_per_slot;
// Set up genesis config and blocktree
let GenesisConfigInfo {
mut genesis_config, ..
} = create_genesis_config(1000);
genesis_config.ticks_per_slot = ticks_per_slot;
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_block);
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
let blocktree = Blocktree::open(&ledger_path).unwrap();
// Set up blockstream

6
core/src/broadcast_stage.rs
View File

@ -192,7 +192,7 @@ impl Service for BroadcastStage {
mod test {
use super::*;
use crate::cluster_info::{ClusterInfo, Node};
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use crate::service::Service;
use solana_ledger::blocktree::{get_tmp_ledger_path, Blocktree};
use solana_ledger::entry::create_ticks;
@ -235,8 +235,8 @@ mod test {
let exit_sender = Arc::new(AtomicBool::new(false));
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(10_000);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
let bank = Arc::new(Bank::new(&genesis_config));
let leader_keypair = cluster_info.read().unwrap().keypair.clone();
// Start up the broadcast stage

26
core/src/broadcast_stage/broadcast_utils.rs
View File

@ -76,37 +76,37 @@ pub(super) fn recv_slot_entries(receiver: &Receiver<WorkingBankEntry>) -> Result
#[cfg(test)]
mod tests {
use super::*;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use solana_sdk::genesis_block::GenesisBlock;
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use solana_sdk::genesis_config::GenesisConfig;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::system_transaction;
use solana_sdk::transaction::Transaction;
use std::sync::mpsc::channel;
fn setup_test() -> (GenesisBlock, Arc<Bank>, Transaction) {
let GenesisBlockInfo {
genesis_block,
fn setup_test() -> (GenesisConfig, Arc<Bank>, Transaction) {
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(2);
let bank0 = Arc::new(Bank::new(&genesis_block));
} = create_genesis_config(2);
let bank0 = Arc::new(Bank::new(&genesis_config));
let tx = system_transaction::transfer(
&mint_keypair,
&Pubkey::new_rand(),
1,
genesis_block.hash(),
genesis_config.hash(),
);
(genesis_block, bank0, tx)
(genesis_config, bank0, tx)
}
#[test]
fn test_recv_slot_entries_1() {
let (genesis_block, bank0, tx) = setup_test();
let (genesis_config, bank0, tx) = setup_test();
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
let (s, r) = channel();
let mut last_hash = genesis_block.hash();
let mut last_hash = genesis_config.hash();
assert!(bank1.max_tick_height() > 1);
let entries: Vec<_> = (1..bank1.max_tick_height() + 1)
@ -131,13 +131,13 @@ mod tests {
#[test]
fn test_recv_slot_entries_2() {
let (genesis_block, bank0, tx) = setup_test();
let (genesis_config, bank0, tx) = setup_test();
let bank1 = Arc::new(Bank::new_from_parent(&bank0, &Pubkey::default(), 1));
let bank2 = Arc::new(Bank::new_from_parent(&bank1, &Pubkey::default(), 2));
let (s, r) = channel();
let mut last_hash = genesis_block.hash();
let mut last_hash = genesis_config.hash();
assert!(bank1.max_tick_height() > 1);
// Simulate slot 2 interrupting slot 1's transmission
let expected_last_height = bank1.max_tick_height();

24
core/src/broadcast_stage/standard_broadcast_run.rs
View File

@ -298,7 +298,7 @@ impl BroadcastRun for StandardBroadcastRun {
mod test {
use super::*;
use crate::cluster_info::{ClusterInfo, Node};
use crate::genesis_utils::create_genesis_block;
use crate::genesis_utils::create_genesis_config;
use solana_ledger::{
blocktree::{get_tmp_ledger_path, Blocktree},
entry::create_ticks,
@ -307,7 +307,7 @@ mod test {
use solana_runtime::bank::Bank;
use solana_sdk::{
clock::Slot,
genesis_block::GenesisBlock,
genesis_config::GenesisConfig,
signature::{Keypair, KeypairUtil},
};
use std::sync::{Arc, RwLock};
@ -317,7 +317,7 @@ mod test {
num_shreds_per_slot: Slot,
) -> (
Arc<Blocktree>,
GenesisBlock,
GenesisConfig,
Arc<RwLock<ClusterInfo>>,
Arc<Bank>,
Arc<Keypair>,
@ -335,12 +335,12 @@ mod test {
leader_info.info.clone(),
)));
let socket = UdpSocket::bind("0.0.0.0:0").unwrap();
let mut genesis_block = create_genesis_block(10_000).genesis_block;
genesis_block.ticks_per_slot = max_ticks_per_n_shreds(num_shreds_per_slot) + 1;
let bank0 = Arc::new(Bank::new(&genesis_block));
let mut genesis_config = create_genesis_config(10_000).genesis_config;
genesis_config.ticks_per_slot = max_ticks_per_n_shreds(num_shreds_per_slot) + 1;
let bank0 = Arc::new(Bank::new(&genesis_config));
(
blocktree,
genesis_block,
genesis_config,
cluster_info,
bank0,
leader_keypair,
@ -384,11 +384,11 @@ mod test {
fn test_slot_interrupt() {
// Setup
let num_shreds_per_slot = 2;
let (blocktree, genesis_block, cluster_info, bank0, leader_keypair, socket) =
let (blocktree, genesis_config, cluster_info, bank0, leader_keypair, socket) =
setup(num_shreds_per_slot);
// Insert 1 less than the number of ticks needed to finish the slot
let ticks0 = create_ticks(genesis_block.ticks_per_slot - 1, 0, genesis_block.hash());
let ticks0 = create_ticks(genesis_config.ticks_per_slot - 1, 0, genesis_config.hash());
let receive_results = ReceiveResults {
entries: ticks0.clone(),
time_elapsed: Duration::new(3, 0),
@ -426,7 +426,7 @@ mod test {
// Interrupting the slot should cause the unfinished_slot and stats to reset
let num_shreds = 1;
assert!(num_shreds < num_shreds_per_slot);
let ticks1 = create_ticks(max_ticks_per_n_shreds(num_shreds), 0, genesis_block.hash());
let ticks1 = create_ticks(max_ticks_per_n_shreds(num_shreds), 0, genesis_config.hash());
let receive_results = ReceiveResults {
entries: ticks1.clone(),
time_elapsed: Duration::new(2, 0),
@ -461,11 +461,11 @@ mod test {
fn test_slot_finish() {
// Setup
let num_shreds_per_slot = 2;
let (blocktree, genesis_block, cluster_info, bank0, leader_keypair, socket) =
let (blocktree, genesis_config, cluster_info, bank0, leader_keypair, socket) =
setup(num_shreds_per_slot);
// Insert complete slot of ticks needed to finish the slot
let ticks = create_ticks(genesis_block.ticks_per_slot, 0, genesis_block.hash());
let ticks = create_ticks(genesis_config.ticks_per_slot, 0, genesis_config.hash());
let receive_results = ReceiveResults {
entries: ticks.clone(),
time_elapsed: Duration::new(3, 0),

12
core/src/commitment.rs
View File

@ -243,7 +243,7 @@ impl Service for AggregateCommitmentService {
#[cfg(test)]
mod tests {
use super::*;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use solana_sdk::pubkey::Pubkey;
use solana_stake_api::stake_state;
use solana_vote_api::vote_state;
@ -431,9 +431,9 @@ mod tests {
#[test]
fn test_aggregate_commitment_validity() {
let ancestors = vec![3, 4, 5, 7, 9, 10, 11];
let GenesisBlockInfo {
mut genesis_block, ..
} = create_genesis_block(10_000);
let GenesisConfigInfo {
mut genesis_config, ..
} = create_genesis_config(10_000);
let sk1 = Pubkey::new_rand();
let pk1 = Pubkey::new_rand();
@ -444,7 +444,7 @@ mod tests {
let mut vote_account2 = vote_state::create_account(&pk2, &Pubkey::new_rand(), 0, 50);
let stake_account2 = stake_state::create_account(&sk2, &pk2, &vote_account2, 50);
genesis_block.accounts.extend(vec![
genesis_config.accounts.extend(vec![
(pk1, vote_account1.clone()),
(sk1, stake_account1),
(pk2, vote_account2.clone()),
@ -452,7 +452,7 @@ mod tests {
]);
// Create bank
let bank = Arc::new(Bank::new(&genesis_block));
let bank = Arc::new(Bank::new(&genesis_config));
let mut vote_state1 = VoteState::from(&vote_account1).unwrap();
vote_state1.process_slot_vote_unchecked(3);

68
core/src/poh_recorder.rs
View File

@ -468,7 +468,7 @@ impl PohRecorder {
#[cfg(test)]
mod tests {
use super::*;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use solana_ledger::blocktree::{get_tmp_ledger_path, Blocktree};
use solana_perf::test_tx::test_tx;
use solana_sdk::clock::DEFAULT_TICKS_PER_SLOT;
@ -561,8 +561,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, _entry_receiver) = PohRecorder::new(
0,
@ -595,8 +595,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, entry_receiver) = PohRecorder::new(
0,
@ -644,8 +644,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, entry_receiver) = PohRecorder::new(
0,
@ -691,8 +691,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, entry_receiver) = PohRecorder::new(
0,
@ -729,8 +729,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, _entry_receiver) = PohRecorder::new(
0,
@ -769,8 +769,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, entry_receiver) = PohRecorder::new(
0,
@ -815,8 +815,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, entry_receiver) = PohRecorder::new(
0,
@ -859,8 +859,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, entry_receiver) = PohRecorder::new(
0,
@ -983,8 +983,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let (mut poh_recorder, _entry_receiver) = PohRecorder::new(
0,
Hash::default(),
@ -1014,8 +1014,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let (sender, receiver) = sync_channel(1);
let (mut poh_recorder, _entry_receiver) = PohRecorder::new_with_clear_signal(
0,
@ -1044,11 +1044,11 @@ mod tests {
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let ticks_per_slot = 5;
let GenesisBlockInfo {
mut genesis_block, ..
} = create_genesis_block(2);
genesis_block.ticks_per_slot = ticks_per_slot;
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo {
mut genesis_config, ..
} = create_genesis_config(2);
genesis_config.ticks_per_slot = ticks_per_slot;
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, _entry_receiver) = PohRecorder::new(
@ -1096,8 +1096,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, _entry_receiver) = PohRecorder::new(
0,
@ -1216,8 +1216,8 @@ mod tests {
{
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let (mut poh_recorder, _entry_receiver) = PohRecorder::new(
0,
@ -1283,9 +1283,9 @@ mod tests {
// test that virtual ticks are flushed into a newly set bank asap
let blocktree =
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger");
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let genesis_blockhash = bank.last_blockhash();
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let genesis_hash = bank.last_blockhash();
let (mut poh_recorder, _entry_receiver) = PohRecorder::new(
0,
@ -1305,7 +1305,7 @@ mod tests {
poh_recorder.tick();
}
poh_recorder.set_bank(&bank.clone());
assert!(!bank.check_hash_age(&genesis_blockhash, 1));
assert!(!bank.check_hash_age(&genesis_hash, 1));
}
}

6
core/src/poh_service.rs
View File

@ -109,7 +109,7 @@ impl Service for PohService {
#[cfg(test)]
mod tests {
use super::*;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use crate::poh_recorder::WorkingBank;
use crate::result::Result;
use solana_ledger::blocktree::{get_tmp_ledger_path, Blocktree};
@ -122,8 +122,8 @@ mod tests {
#[test]
fn test_poh_service() {
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(2);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new(&genesis_config));
let prev_hash = bank.last_blockhash();
let ledger_path = get_tmp_ledger_path!();
{

46
core/src/replay_stage.rs
View File

@ -940,7 +940,7 @@ impl Service for ReplayStage {
mod test {
use super::*;
use crate::commitment::BlockCommitment;
use crate::genesis_utils::{create_genesis_block, create_genesis_block_with_leader};
use crate::genesis_utils::{create_genesis_config, create_genesis_config_with_leader};
use crate::replay_stage::ReplayStage;
use solana_ledger::blocktree::make_slot_entries;
use solana_ledger::blocktree::{entries_to_test_shreds, get_tmp_ledger_path, BlocktreeError};
@ -949,7 +949,7 @@ mod test {
CodingShredHeader, DataShredHeader, Shred, ShredCommonHeader, DATA_COMPLETE_SHRED,
SIZE_OF_COMMON_SHRED_HEADER, SIZE_OF_DATA_SHRED_HEADER, SIZE_OF_DATA_SHRED_PAYLOAD,
};
use solana_runtime::genesis_utils::GenesisBlockInfo;
use solana_runtime::genesis_utils::GenesisConfigInfo;
use solana_sdk::hash::{hash, Hash};
use solana_sdk::packet::PACKET_DATA_SIZE;
use solana_sdk::signature::{Keypair, KeypairUtil};
@ -967,8 +967,8 @@ mod test {
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger"),
);
let genesis_block = create_genesis_block(10_000).genesis_block;
let bank0 = Bank::new(&genesis_block);
let genesis_config = create_genesis_config(10_000).genesis_config;
let bank0 = Bank::new(&genesis_config);
let leader_schedule_cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank0));
let mut bank_forks = BankForks::new(0, bank0);
bank_forks.working_bank().freeze();
@ -1002,8 +1002,8 @@ mod test {
#[test]
fn test_handle_new_root() {
let genesis_block = create_genesis_block(10_000).genesis_block;
let bank0 = Bank::new(&genesis_block);
let genesis_config = create_genesis_config(10_000).genesis_config;
let bank0 = Bank::new(&genesis_config);
let bank_forks = Arc::new(RwLock::new(BankForks::new(0, bank0)));
let mut progress = HashMap::new();
progress.insert(5, ForkProgress::new(0, Hash::default()));
@ -1221,13 +1221,13 @@ mod test {
let blocktree = Arc::new(
Blocktree::open(&ledger_path).expect("Expected to be able to open database ledger"),
);
let GenesisBlockInfo {
mut genesis_block,
let GenesisConfigInfo {
mut genesis_config,
mint_keypair,
..
} = create_genesis_block(1000);
genesis_block.poh_config.hashes_per_tick = Some(2);
let bank0 = Arc::new(Bank::new(&genesis_block));
} = create_genesis_config(1000);
genesis_config.poh_config.hashes_per_tick = Some(2);
let bank0 = Arc::new(Bank::new(&genesis_config));
let mut progress = HashMap::new();
let last_blockhash = bank0.last_blockhash();
progress.insert(bank0.slot(), ForkProgress::new(0, last_blockhash));
@ -1268,14 +1268,14 @@ mod test {
let leader_pubkey = Pubkey::new_rand();
let leader_lamports = 3;
let genesis_block_info =
create_genesis_block_with_leader(50, &leader_pubkey, leader_lamports);
let mut genesis_block = genesis_block_info.genesis_block;
let leader_voting_pubkey = genesis_block_info.voting_keypair.pubkey();
genesis_block.epoch_schedule.warmup = false;
genesis_block.ticks_per_slot = 4;
let bank0 = Bank::new(&genesis_block);
for _ in 0..genesis_block.ticks_per_slot {
let genesis_config_info =
create_genesis_config_with_leader(50, &leader_pubkey, leader_lamports);
let mut genesis_config = genesis_config_info.genesis_config;
let leader_voting_pubkey = genesis_config_info.voting_keypair.pubkey();
genesis_config.epoch_schedule.warmup = false;
genesis_config.ticks_per_slot = 4;
let bank0 = Bank::new(&genesis_config);
for _ in 0..genesis_config.ticks_per_slot {
bank0.register_tick(&Hash::default());
}
bank0.freeze();
@ -1297,8 +1297,8 @@ mod test {
.is_none());
let bank1 = Bank::new_from_parent(&arc_bank0, &Pubkey::default(), arc_bank0.slot() + 1);
let _res = bank1.transfer(10, &genesis_block_info.mint_keypair, &Pubkey::new_rand());
for _ in 0..genesis_block.ticks_per_slot {
let _res = bank1.transfer(10, &genesis_config_info.mint_keypair, &Pubkey::new_rand());
for _ in 0..genesis_config.ticks_per_slot {
bank1.register_tick(&Hash::default());
}
bank1.freeze();
@ -1308,8 +1308,8 @@ mod test {
ReplayStage::update_commitment_cache(arc_bank1.clone(), leader_lamports, &lockouts_sender);
let bank2 = Bank::new_from_parent(&arc_bank1, &Pubkey::default(), arc_bank1.slot() + 1);
let _res = bank2.transfer(10, &genesis_block_info.mint_keypair, &Pubkey::new_rand());
for _ in 0..genesis_block.ticks_per_slot {
let _res = bank2.transfer(10, &genesis_config_info.mint_keypair, &Pubkey::new_rand());
for _ in 0..genesis_config.ticks_per_slot {
bank2.register_tick(&Hash::default());
}
bank2.freeze();

8
core/src/retransmit_stage.rs
View File

@ -274,7 +274,7 @@ impl Service for RetransmitStage {
mod tests {
use super::*;
use crate::contact_info::ContactInfo;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use crate::packet::{self, Meta, Packet, Packets};
use solana_ledger::blocktree::create_new_tmp_ledger;
use solana_ledger::blocktree_processor::{process_blocktree, ProcessOptions};
@ -283,15 +283,15 @@ mod tests {
#[test]
fn test_skip_repair() {
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(123);
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_block);
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(123);
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
let blocktree = Blocktree::open(&ledger_path).unwrap();
let opts = ProcessOptions {
full_leader_cache: true,
..ProcessOptions::default()
};
let (bank_forks, _, cached_leader_schedule) =
process_blocktree(&genesis_block, &blocktree, None, opts).unwrap();
process_blocktree(&genesis_config, &blocktree, None, opts).unwrap();
let leader_schedule_cache = Arc::new(cached_leader_schedule);
let bank_forks = Arc::new(RwLock::new(bank_forks));

32
core/src/rpc.rs
View File

@ -129,7 +129,7 @@ impl JsonRpcRequestProcessor {
}
pub fn get_epoch_schedule(&self) -> Result<EpochSchedule> {
// Since epoch schedule data comes from the genesis block, any commitment level should be
// Since epoch schedule data comes from the genesis config, any commitment level should be
// fine
Ok(*self.bank(None).epoch_schedule())
}
@ -278,7 +278,7 @@ fn verify_signature(input: &str) -> Result<Signature> {
pub struct Meta {
pub request_processor: Arc<RwLock<JsonRpcRequestProcessor>>,
pub cluster_info: Arc<RwLock<ClusterInfo>>,
pub genesis_blockhash: Hash,
pub genesis_hash: Hash,
}
impl Metadata for Meta {}
@ -372,8 +372,8 @@ pub trait RpcSol {
block: u64,
) -> Result<(Option<BlockCommitment>, u64)>;
#[rpc(meta, name = "getGenesisBlockhash")]
fn get_genesis_blockhash(&self, meta: Self::Metadata) -> Result<String>;
#[rpc(meta, name = "getGenesisHash")]
fn get_genesis_hash(&self, meta: Self::Metadata) -> Result<String>;
#[rpc(meta, name = "getLeaderSchedule")]
fn get_leader_schedule(
@ -647,9 +647,9 @@ impl RpcSol for RpcSolImpl {
.get_block_commitment(block))
}
fn get_genesis_blockhash(&self, meta: Self::Metadata) -> Result<String> {
debug!("get_genesis_blockhash rpc request received");
Ok(meta.genesis_blockhash.to_string())
fn get_genesis_hash(&self, meta: Self::Metadata) -> Result<String> {
debug!("get_genesis_hash rpc request received");
Ok(meta.genesis_hash.to_string())
}
fn get_leader_schedule(
@ -928,7 +928,7 @@ pub mod tests {
use super::*;
use crate::{
contact_info::ContactInfo,
genesis_utils::{create_genesis_block, GenesisBlockInfo},
genesis_utils::{create_genesis_config, GenesisConfigInfo},
};
use jsonrpc_core::{MetaIoHandler, Output, Response, Value};
use solana_sdk::{
@ -1009,7 +1009,7 @@ pub mod tests {
let meta = Meta {
request_processor,
cluster_info,
genesis_blockhash: Hash::default(),
genesis_hash: Hash::default(),
};
RpcHandler {
io,
@ -1463,7 +1463,7 @@ pub mod tests {
cluster_info: Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(
ContactInfo::default(),
))),
genesis_blockhash: Hash::default(),
genesis_hash: Hash::default(),
};
let req =
@ -1515,16 +1515,16 @@ pub mod tests {
}
fn new_bank_forks() -> (Arc<RwLock<BankForks>>, Keypair) {
let GenesisBlockInfo {
mut genesis_block,
let GenesisConfigInfo {
mut genesis_config,
mint_keypair,
..
} = create_genesis_block(TEST_MINT_LAMPORTS);
} = create_genesis_config(TEST_MINT_LAMPORTS);
genesis_block.rent.lamports_per_byte_year = 50;
genesis_block.rent.exemption_threshold = 2.0;
genesis_config.rent.lamports_per_byte_year = 50;
genesis_config.rent.exemption_threshold = 2.0;
let bank = Bank::new(&genesis_block);
let bank = Bank::new(&genesis_config);
(
Arc::new(RwLock::new(BankForks::new(bank.slot(), bank))),
mint_keypair,

44
core/src/rpc_pubsub.rs
View File

@ -241,7 +241,7 @@ impl RpcSolPubSub for RpcSolPubSubImpl {
#[cfg(test)]
mod tests {
use super::*;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use jsonrpc_core::futures::sync::mpsc;
use jsonrpc_core::Response;
use jsonrpc_pubsub::{PubSubHandler, Session};
@ -280,14 +280,14 @@ mod tests {
#[test]
fn test_signature_subscribe() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair: alice,
..
} = create_genesis_block(10_000);
} = create_genesis_config(10_000);
let bob = Keypair::new();
let bob_pubkey = bob.pubkey();
let bank = Bank::new(&genesis_block);
let bank = Bank::new(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(0, bank)));
@ -317,13 +317,13 @@ mod tests {
#[test]
fn test_signature_unsubscribe() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair: alice,
..
} = create_genesis_block(10_000);
} = create_genesis_config(10_000);
let bob_pubkey = Pubkey::new_rand();
let bank = Bank::new(&genesis_block);
let bank = Bank::new(&genesis_config);
let arc_bank = Arc::new(bank);
let blockhash = arc_bank.last_blockhash();
@ -363,14 +363,14 @@ mod tests {
#[test]
fn test_account_subscribe() {
let GenesisBlockInfo {
mut genesis_block,
let GenesisConfigInfo {
mut genesis_config,
mint_keypair: alice,
..
} = create_genesis_block(10_000);
} = create_genesis_config(10_000);
// This test depends on the budget program
genesis_block
genesis_config
.native_instruction_processors
.push(solana_budget_program!());
@ -379,7 +379,7 @@ mod tests {
let contract_funds = Keypair::new();
let contract_state = Keypair::new();
let budget_program_id = solana_budget_api::id();
let bank = Bank::new(&genesis_block);
let bank = Bank::new(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(0, bank)));
@ -504,12 +504,12 @@ mod tests {
#[test]
#[should_panic]
fn test_account_confirmations_not_fulfilled() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair: alice,
..
} = create_genesis_block(10_000);
let bank = Bank::new(&genesis_block);
} = create_genesis_config(10_000);
let bank = Bank::new(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(0, bank)));
let bob = Keypair::new();
@ -533,12 +533,12 @@ mod tests {
#[test]
fn test_account_confirmations() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair: alice,
..
} = create_genesis_block(10_000);
let bank = Bank::new(&genesis_block);
} = create_genesis_config(10_000);
let bank = Bank::new(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(0, bank)));
let bob = Keypair::new();

14
core/src/rpc_service.rs
View File

@ -94,7 +94,7 @@ impl JsonRpcService {
bank_forks: Arc<RwLock<BankForks>>,
block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
ledger_path: &Path,
genesis_blockhash: Hash,
genesis_hash: Hash,
validator_exit: &Arc<RwLock<Option<ValidatorExit>>>,
) -> Self {
info!("rpc bound to {:?}", rpc_addr);
@ -123,7 +123,7 @@ impl JsonRpcService {
ServerBuilder::with_meta_extractor(io, move |_req: &hyper::Request<hyper::Body>| Meta {
request_processor: request_processor_.clone(),
cluster_info: cluster_info.clone(),
genesis_blockhash
genesis_hash
}).threads(4)
.cors(DomainsValidation::AllowOnly(vec![
AccessControlAllowOrigin::Any,
@ -175,7 +175,7 @@ impl Service for JsonRpcService {
mod tests {
use super::*;
use crate::contact_info::ContactInfo;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use crate::rpc::tests::create_validator_exit;
use solana_runtime::bank::Bank;
use solana_sdk::signature::KeypairUtil;
@ -184,14 +184,14 @@ mod tests {
#[test]
fn test_rpc_new() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(10_000);
} = create_genesis_config(10_000);
let exit = Arc::new(AtomicBool::new(false));
let validator_exit = create_validator_exit(&exit);
let bank = Bank::new(&genesis_block);
let bank = Bank::new(&genesis_config);
let cluster_info = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(
ContactInfo::default(),
)));

26
core/src/rpc_subscriptions.rs
View File

@ -296,7 +296,7 @@ impl RpcSubscriptions {
#[cfg(test)]
mod tests {
use super::*;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use jsonrpc_pubsub::typed::Subscriber;
use solana_budget_api;
use solana_sdk::signature::{Keypair, KeypairUtil};
@ -305,12 +305,12 @@ mod tests {
#[test]
fn test_check_account_subscribe() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(100);
let bank = Bank::new(&genesis_block);
} = create_genesis_config(100);
let bank = Bank::new(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(0, bank)));
let alice = Keypair::new();
@ -360,12 +360,12 @@ mod tests {
#[test]
fn test_check_program_subscribe() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(100);
let bank = Bank::new(&genesis_block);
} = create_genesis_config(100);
let bank = Bank::new(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(0, bank)));
let alice = Keypair::new();
@ -414,12 +414,12 @@ mod tests {
}
#[test]
fn test_check_signature_subscribe() {
let GenesisBlockInfo {
genesis_block,
let GenesisConfigInfo {
genesis_config,
mint_keypair,
..
} = create_genesis_block(100);
let bank = Bank::new(&genesis_block);
} = create_genesis_config(100);
let bank = Bank::new(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(0, bank)));
let alice = Keypair::new();

4
core/src/sigverify_shreds.rs
View File

@ -82,7 +82,7 @@ impl SigVerifier for ShredSigVerifier {
#[cfg(test)]
pub mod tests {
use super::*;
use crate::genesis_utils::create_genesis_block_with_leader;
use crate::genesis_utils::create_genesis_config_with_leader;
use crate::packet::Packet;
use solana_ledger::shred::{Shred, Shredder};
use solana_runtime::bank::Bank;
@ -131,7 +131,7 @@ pub mod tests {
let leader_keypair = Arc::new(Keypair::new());
let leader_pubkey = leader_keypair.pubkey();
let bank =
Bank::new(&create_genesis_block_with_leader(100, &leader_pubkey, 10).genesis_block);
Bank::new(&create_genesis_config_with_leader(100, &leader_pubkey, 10).genesis_config);
let cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
let bf = Arc::new(RwLock::new(BankForks::new(0, bank)));
let verifier = ShredSigVerifier::new(bf, cache);

6
core/src/storage_stage.rs
View File

@ -650,7 +650,7 @@ pub fn test_cluster_info(id: &Pubkey) -> Arc<RwLock<ClusterInfo>> {
#[cfg(test)]
mod tests {
use super::*;
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use crate::service::Service;
use rayon::prelude::*;
use solana_runtime::bank::Bank;
@ -668,8 +668,8 @@ mod tests {
let exit = Arc::new(AtomicBool::new(false));
let cluster_info = test_cluster_info(&keypair.pubkey());
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(1000);
let bank = Arc::new(Bank::new(&genesis_block));
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(1000);
let bank = Arc::new(Bank::new(&genesis_config));
let bank_forks = Arc::new(RwLock::new(BankForks::new_from_banks(
&[bank.clone()],
vec![0],

8
core/src/tvu.rs
View File

@ -235,7 +235,7 @@ pub mod tests {
use super::*;
use crate::banking_stage::create_test_recorder;
use crate::cluster_info::{ClusterInfo, Node};
use crate::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use solana_ledger::blocktree::create_new_tmp_ledger;
use solana_runtime::bank::Bank;
use std::sync::atomic::Ordering;
@ -248,16 +248,16 @@ pub mod tests {
let target1 = Node::new_localhost_with_pubkey(&target1_keypair.pubkey());
let starting_balance = 10_000;
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(starting_balance);
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(starting_balance);
let bank_forks = BankForks::new(0, Bank::new(&genesis_block));
let bank_forks = BankForks::new(0, Bank::new(&genesis_config));
//start cluster_info1
let mut cluster_info1 = ClusterInfo::new_with_invalid_keypair(target1.info.clone());
cluster_info1.insert_info(leader.info.clone());
let cref1 = Arc::new(RwLock::new(cluster_info1));
let (blocktree_path, _) = create_new_tmp_ledger!(&genesis_block);
let (blocktree_path, _) = create_new_tmp_ledger!(&genesis_config);
let (blocktree, l_receiver, completed_slots_receiver) =
Blocktree::open_with_signal(&blocktree_path)
.expect("Expected to successfully open ledger");

69
core/src/validator.rs
View File

@ -28,7 +28,7 @@ use solana_ledger::{
use solana_metrics::datapoint_info;
use solana_sdk::{
clock::{Slot, DEFAULT_SLOTS_PER_TURN},
genesis_block::GenesisBlock,
genesis_config::GenesisConfig,
hash::Hash,
poh_config::PohConfig,
pubkey::Pubkey,
@ -50,7 +50,7 @@ use std::{
pub struct ValidatorConfig {
pub dev_sigverify_disabled: bool,
pub dev_halt_at_slot: Option<Slot>,
pub expected_genesis_blockhash: Option<Hash>,
pub expected_genesis_hash: Option<Hash>,
pub voting_disabled: bool,
pub blockstream_unix_socket: Option<PathBuf>,
pub storage_slots_per_turn: u64,
@ -66,7 +66,7 @@ impl Default for ValidatorConfig {
Self {
dev_sigverify_disabled: false,
dev_halt_at_slot: None,
expected_genesis_blockhash: None,
expected_genesis_hash: None,
voting_disabled: false,
blockstream_unix_socket: None,
storage_slots_per_turn: DEFAULT_SLOTS_PER_TURN,
@ -158,7 +158,7 @@ impl Validator {
info!("creating bank...");
let (
genesis_blockhash,
genesis_hash,
bank_forks,
bank_forks_info,
blocktree,
@ -167,7 +167,7 @@ impl Validator {
leader_schedule_cache,
poh_config,
) = new_banks_from_blocktree(
config.expected_genesis_blockhash,
config.expected_genesis_hash,
ledger_path,
config.account_paths.clone(),
config.snapshot_config.clone(),
@ -210,7 +210,7 @@ impl Validator {
bank_forks.clone(),
block_commitment_cache.clone(),
ledger_path,
genesis_blockhash,
genesis_hash,
&validator_exit,
))
};
@ -409,7 +409,7 @@ impl Validator {
}
pub fn new_banks_from_blocktree(
expected_genesis_blockhash: Option<Hash>,
expected_genesis_hash: Option<Hash>,
blocktree_path: &Path,
account_paths: Option<String>,
snapshot_config: Option<SnapshotConfig>,
@ -425,16 +425,14 @@ pub fn new_banks_from_blocktree(
LeaderScheduleCache,
PohConfig,
) {
let genesis_block = GenesisBlock::load(blocktree_path).expect("Failed to load genesis block");
let genesis_blockhash = genesis_block.hash();
info!("genesis blockhash: {}", genesis_blockhash);
let genesis_config =
GenesisConfig::load(blocktree_path).expect("Failed to load genesis config");
let genesis_hash = genesis_config.hash();
info!("genesis hash: {}", genesis_hash);
if let Some(expected_genesis_blockhash) = expected_genesis_blockhash {
if genesis_blockhash != expected_genesis_blockhash {
error!(
"genesis blockhash mismatch: expected {}",
expected_genesis_blockhash
);
if let Some(expected_genesis_hash) = expected_genesis_hash {
if genesis_hash != expected_genesis_hash {
error!("genesis hash mismatch: expected {}", expected_genesis_hash);
error!(
"Delete the ledger directory to continue: {:?}",
blocktree_path
@ -453,7 +451,7 @@ pub fn new_banks_from_blocktree(
};
let (mut bank_forks, bank_forks_info, leader_schedule_cache) = bank_forks_utils::load(
&genesis_block,
&genesis_config,
&blocktree,
account_paths,
snapshot_config.as_ref(),
@ -467,14 +465,14 @@ pub fn new_banks_from_blocktree(
bank_forks.set_snapshot_config(snapshot_config);
(
genesis_blockhash,
genesis_hash,
bank_forks,
bank_forks_info,
blocktree,
ledger_signal_receiver,
completed_slots_receiver,
leader_schedule_cache,
genesis_block.poh_config,
genesis_config.poh_config,
)
}
@ -501,26 +499,26 @@ impl Service for Validator {
}
pub fn new_validator_for_tests() -> (Validator, ContactInfo, Keypair, PathBuf) {
use crate::genesis_utils::{create_genesis_block_with_leader, GenesisBlockInfo};
use crate::genesis_utils::{create_genesis_config_with_leader, GenesisConfigInfo};
use solana_ledger::blocktree::create_new_tmp_ledger;
let node_keypair = Arc::new(Keypair::new());
let node = Node::new_localhost_with_pubkey(&node_keypair.pubkey());
let contact_info = node.info.clone();
let GenesisBlockInfo {
mut genesis_block,
let GenesisConfigInfo {
mut genesis_config,
mint_keypair,
voting_keypair,
} = create_genesis_block_with_leader(10_000, &contact_info.id, 42);
genesis_block
} = create_genesis_config_with_leader(10_000, &contact_info.id, 42);
genesis_config
.native_instruction_processors
.push(solana_budget_program!());
genesis_block.rent.lamports_per_byte_year = 1;
genesis_block.rent.exemption_threshold = 1.0;
genesis_config.rent.lamports_per_byte_year = 1;
genesis_config.rent.exemption_threshold = 1.0;
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_block);
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
let leader_voting_keypair = Arc::new(voting_keypair);
let storage_keypair = Arc::new(Keypair::new());
@ -542,7 +540,7 @@ pub fn new_validator_for_tests() -> (Validator, ContactInfo, Keypair, PathBuf) {
#[cfg(test)]
mod tests {
use super::*;
use crate::genesis_utils::create_genesis_block_with_leader;
use crate::genesis_utils::create_genesis_config_with_leader;
use solana_ledger::blocktree::create_new_tmp_ledger;
use std::fs::remove_dir_all;
@ -554,9 +552,10 @@ mod tests {
let validator_keypair = Keypair::new();
let validator_node = Node::new_localhost_with_pubkey(&validator_keypair.pubkey());
let genesis_block =
create_genesis_block_with_leader(10_000, &leader_keypair.pubkey(), 1000).genesis_block;
let (validator_ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_block);
let genesis_config =
create_genesis_config_with_leader(10_000, &leader_keypair.pubkey(), 1000)
.genesis_config;
let (validator_ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
let voting_keypair = Arc::new(Keypair::new());
let storage_keypair = Arc::new(Keypair::new());
@ -585,10 +584,10 @@ mod tests {
.map(|_| {
let validator_keypair = Keypair::new();
let validator_node = Node::new_localhost_with_pubkey(&validator_keypair.pubkey());
let genesis_block =
create_genesis_block_with_leader(10_000, &leader_keypair.pubkey(), 1000)
.genesis_block;
let (validator_ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_block);
let genesis_config =
create_genesis_config_with_leader(10_000, &leader_keypair.pubkey(), 1000)
.genesis_config;
let (validator_ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
ledger_paths.push(validator_ledger_path.clone());
let voting_keypair = Arc::new(Keypair::new());
let storage_keypair = Arc::new(Keypair::new());

4
core/src/window_service.rs
View File

@ -279,7 +279,7 @@ mod test {
use crate::{
cluster_info::ClusterInfo,
contact_info::ContactInfo,
genesis_utils::create_genesis_block_with_leader,
genesis_utils::create_genesis_config_with_leader,
packet::{Packet, Packets},
repair_service::RepairSlotRange,
service::Service,
@ -345,7 +345,7 @@ mod test {
let leader_keypair = Arc::new(Keypair::new());
let leader_pubkey = leader_keypair.pubkey();
let bank = Arc::new(Bank::new(
&create_genesis_block_with_leader(100, &leader_pubkey, 10).genesis_block,
&create_genesis_config_with_leader(100, &leader_pubkey, 10).genesis_config,
));
let cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));

18
core/tests/bank_forks.rs
View File

@ -6,7 +6,7 @@ mod tests {
use fs_extra::dir::CopyOptions;
use itertools::Itertools;
use solana_core::{
genesis_utils::{create_genesis_block, GenesisBlockInfo},
genesis_utils::{create_genesis_config, GenesisConfigInfo},
service::Service,
snapshot_packager_service::SnapshotPackagerService,
};
@ -43,16 +43,16 @@ mod tests {
_snapshot_output_path: TempDir,
snapshot_config: SnapshotConfig,
bank_forks: BankForks,
genesis_block_info: GenesisBlockInfo,
genesis_config_info: GenesisConfigInfo,
}
fn setup_snapshot_test(snapshot_interval_slots: usize) -> SnapshotTestConfig {
let accounts_dir = TempDir::new().unwrap();
let snapshot_dir = TempDir::new().unwrap();
let snapshot_output_path = TempDir::new().unwrap();
let genesis_block_info = create_genesis_block(10_000);
let genesis_config_info = create_genesis_config(10_000);
let bank0 = Bank::new_with_paths(
&genesis_block_info.genesis_block,
&genesis_config_info.genesis_config,
Some(accounts_dir.path().to_str().unwrap().to_string()),
);
bank0.freeze();
@ -70,7 +70,7 @@ mod tests {
_snapshot_output_path: snapshot_output_path,
snapshot_config,
bank_forks,
genesis_block_info,
genesis_config_info,
}
}
@ -121,7 +121,7 @@ mod tests {
let bank_forks = &mut snapshot_test_config.bank_forks;
let accounts_dir = &snapshot_test_config.accounts_dir;
let snapshot_config = &snapshot_test_config.snapshot_config;
let mint_keypair = &snapshot_test_config.genesis_block_info.mint_keypair;
let mint_keypair = &snapshot_test_config.genesis_config_info.mint_keypair;
let (s, _r) = channel();
let sender = Some(s);
@ -198,8 +198,8 @@ mod tests {
let accounts_dir = &snapshot_test_config.accounts_dir;
let snapshots_dir = &snapshot_test_config.snapshot_dir;
let snapshot_config = &snapshot_test_config.snapshot_config;
let mint_keypair = &snapshot_test_config.genesis_block_info.mint_keypair;
let genesis_block = &snapshot_test_config.genesis_block_info.genesis_block;
let mint_keypair = &snapshot_test_config.genesis_config_info.mint_keypair;
let genesis_config = &snapshot_test_config.genesis_config_info.genesis_config;
// Take snapshot of zeroth bank
let bank0 = bank_forks.get(0).unwrap();
@ -230,7 +230,7 @@ mod tests {
);
let slot = bank.slot();
let key1 = Keypair::new().pubkey();
let tx = system_transaction::transfer(&mint_keypair, &key1, 1, genesis_block.hash());
let tx = system_transaction::transfer(&mint_keypair, &key1, 1, genesis_config.hash());
assert_eq!(bank.process_transaction(&tx), Ok(()));
bank.freeze();
bank_forks.insert(bank);

20
core/tests/storage_stage.rs
View File

@ -6,7 +6,7 @@ extern crate solana_ledger;
#[cfg(test)]
mod tests {
use log::*;
use solana_core::genesis_utils::{create_genesis_block, GenesisBlockInfo};
use solana_core::genesis_utils::{create_genesis_config, GenesisConfigInfo};
use solana_core::service::Service;
use solana_core::storage_stage::{test_cluster_info, SLOTS_PER_TURN_TEST};
use solana_core::storage_stage::{StorageStage, StorageState};
@ -38,19 +38,19 @@ mod tests {
let archiver_keypair = Arc::new(Keypair::new());
let exit = Arc::new(AtomicBool::new(false));
let GenesisBlockInfo {
mut genesis_block,
let GenesisConfigInfo {
mut genesis_config,
mint_keypair,
..
} = create_genesis_block(1000);
genesis_block
} = create_genesis_config(1000);
genesis_config
.native_instruction_processors
.push(solana_storage_program::solana_storage_program!());
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_block);
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
let blocktree = Arc::new(Blocktree::open(&ledger_path).unwrap());
let bank = Bank::new(&genesis_block);
let bank = Bank::new(&genesis_config);
let bank = Arc::new(bank);
let bank_forks = Arc::new(RwLock::new(BankForks::new_from_banks(
&[bank.clone()],
@ -164,12 +164,12 @@ mod tests {
let storage_keypair = Arc::new(Keypair::new());
let exit = Arc::new(AtomicBool::new(false));
let GenesisBlockInfo { genesis_block, .. } = create_genesis_block(1000);
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_block);
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(1000);
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
let blocktree = Arc::new(Blocktree::open(&ledger_path).unwrap());
let slot = 1;
let bank = Arc::new(Bank::new(&genesis_block));
let bank = Arc::new(Bank::new(&genesis_config));
let bank_forks = Arc::new(RwLock::new(BankForks::new_from_banks(
&[bank.clone()],
vec![0],