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

Rename Bank.last_id() to Bank.last_block_hash()

Browse Source
This commit is contained in:
Michael Vines
2019-03-02 10:05:31 -08:00
committed by Greg Fitzgerald
parent 95cbb8a5c0
commit 2bfad87a5f
18 changed files with 86 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
benches/banking_stage.rs
View File

@ -45,7 +45,7 @@ fn create_test_recorder(bank: &Arc<Bank>) -> (Arc<Mutex<PohRecorder>>, PohServic
let exit = Arc::new(AtomicBool::new(false));
let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(
bank.tick_height(),
bank.last_id(),
bank.last_block_hash(),
)));
let poh_service = PohService::new(
poh_recorder.clone(),

12
core/src/banking_stage.rs
View File

@ -361,7 +361,7 @@ mod tests {
let exit = Arc::new(AtomicBool::new(false));
let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(
bank.tick_height(),
bank.last_id(),
bank.last_block_hash(),
)));
let poh_service = PohService::new(
poh_recorder.clone(),
@ -394,7 +394,7 @@ mod tests {
let (mut genesis_block, _mint_keypair) = GenesisBlock::new(2);
genesis_block.ticks_per_slot = 4;
let bank = Arc::new(Bank::new(&genesis_block));
let start_hash = bank.last_id();
let start_hash = bank.last_block_hash();
let (verified_sender, verified_receiver) = channel();
let (poh_recorder, poh_service) = create_test_recorder(&bank);
let (banking_stage, entry_receiver) = BankingStage::new(
@ -413,7 +413,7 @@ mod tests {
.collect();
assert_eq!(entries.len(), genesis_block.ticks_per_slot as usize - 1);
assert!(entries.verify(&start_hash));
assert_eq!(entries[entries.len() - 1].hash, bank.last_id());
assert_eq!(entries[entries.len() - 1].hash, bank.last_block_hash());
banking_stage.join().unwrap();
poh_service.close().unwrap();
}
@ -422,7 +422,7 @@ mod tests {
fn test_banking_stage_entries_only() {
let (genesis_block, mint_keypair) = GenesisBlock::new(2);
let bank = Arc::new(Bank::new(&genesis_block));
let start_hash = bank.last_id();
let start_hash = bank.last_block_hash();
let (verified_sender, verified_receiver) = channel();
let (poh_recorder, poh_service) = create_test_recorder(&bank);
let (banking_stage, entry_receiver) = BankingStage::new(
@ -636,7 +636,7 @@ mod tests {
let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(
bank.tick_height(),
bank.last_id(),
bank.last_block_hash(),
)));
poh_recorder.lock().unwrap().set_working_bank(working_bank);
let pubkey = Keypair::new().pubkey();
@ -691,7 +691,7 @@ mod tests {
};
let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(
bank.tick_height(),
bank.last_id(),
bank.last_block_hash(),
)));
poh_recorder.lock().unwrap().set_working_bank(working_bank);

48
core/src/blocktree_processor.rs
View File

@ -115,7 +115,7 @@ pub fn process_blocktree(
let slot = 0;
let bank = Arc::new(Bank::new_with_paths(&genesis_block, account_paths));
let entry_height = 0;
let last_entry_hash = bank.last_id();
let last_entry_hash = bank.last_block_hash();
vec![(slot, bank, entry_height, last_entry_hash)]
};
@ -500,7 +500,7 @@ mod tests {
let bank = bank_forks[1].clone();
assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 50 - 3);
assert_eq!(bank.tick_height(), 2 * genesis_block.ticks_per_slot - 1);
assert_eq!(bank.last_id(), entries.last().unwrap().hash);
assert_eq!(bank.last_block_hash(), entries.last().unwrap().hash);
}
#[test]
@ -544,19 +544,19 @@ mod tests {
let keypair1 = Keypair::new();
let keypair2 = Keypair::new();
let last_id = bank.last_id();
let last_id = bank.last_block_hash();
// ensure bank can process 2 entries that have a common account and no tick is registered
let tx =
SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 2, bank.last_id(), 0);
SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 2, bank.last_block_hash(), 0);
let entry_1 = next_entry(&last_id, 1, vec![tx]);
let tx =
SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 2, bank.last_id(), 0);
SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 2, bank.last_block_hash(), 0);
let entry_2 = next_entry(&entry_1.hash, 1, vec![tx]);
assert_eq!(par_process_entries(&bank, &[entry_1, entry_2]), Ok(()));
assert_eq!(bank.get_balance(&keypair1.pubkey()), 2);
assert_eq!(bank.get_balance(&keypair2.pubkey()), 2);
assert_eq!(bank.last_id(), last_id);
assert_eq!(bank.last_block_hash(), last_id);
}
#[test]
@ -569,23 +569,23 @@ mod tests {
// fund: put 4 in each of 1 and 2
assert_matches!(
bank.transfer(4, &mint_keypair, keypair1.pubkey(), bank.last_id()),
bank.transfer(4, &mint_keypair, keypair1.pubkey(), bank.last_block_hash()),
Ok(_)
);
assert_matches!(
bank.transfer(4, &mint_keypair, keypair2.pubkey(), bank.last_id()),
bank.transfer(4, &mint_keypair, keypair2.pubkey(), bank.last_block_hash()),
Ok(_)
);
// construct an Entry whose 2nd transaction would cause a lock conflict with previous entry
let entry_1_to_mint = next_entry(
&bank.last_id(),
&bank.last_block_hash(),
1,
vec![SystemTransaction::new_account(
&keypair1,
mint_keypair.pubkey(),
1,
bank.last_id(),
bank.last_block_hash(),
0,
)],
);
@ -594,12 +594,12 @@ mod tests {
&entry_1_to_mint.hash,
1,
vec![
SystemTransaction::new_account(&keypair2, keypair3.pubkey(), 2, bank.last_id(), 0), // should be fine
SystemTransaction::new_account(&keypair2, keypair3.pubkey(), 2, bank.last_block_hash(), 0), // should be fine
SystemTransaction::new_account(
&keypair1,
mint_keypair.pubkey(),
2,
bank.last_id(),
bank.last_block_hash(),
0,
), // will collide
],
@ -626,22 +626,22 @@ mod tests {
//load accounts
let tx =
SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 1, bank.last_id(), 0);
SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 1, bank.last_block_hash(), 0);
assert_eq!(bank.process_transaction(&tx), Ok(()));
let tx =
SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 1, bank.last_id(), 0);
SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 1, bank.last_block_hash(), 0);
assert_eq!(bank.process_transaction(&tx), Ok(()));
// ensure bank can process 2 entries that do not have a common account and no tick is registered
let last_id = bank.last_id();
let tx = SystemTransaction::new_account(&keypair1, keypair3.pubkey(), 1, bank.last_id(), 0);
let last_id = bank.last_block_hash();
let tx = SystemTransaction::new_account(&keypair1, keypair3.pubkey(), 1, bank.last_block_hash(), 0);
let entry_1 = next_entry(&last_id, 1, vec![tx]);
let tx = SystemTransaction::new_account(&keypair2, keypair4.pubkey(), 1, bank.last_id(), 0);
let tx = SystemTransaction::new_account(&keypair2, keypair4.pubkey(), 1, bank.last_block_hash(), 0);
let entry_2 = next_entry(&entry_1.hash, 1, vec![tx]);
assert_eq!(par_process_entries(&bank, &[entry_1, entry_2]), Ok(()));
assert_eq!(bank.get_balance(&keypair3.pubkey()), 1);
assert_eq!(bank.get_balance(&keypair4.pubkey()), 1);
assert_eq!(bank.last_id(), last_id);
assert_eq!(bank.last_block_hash(), last_id);
}
#[test]
@ -655,14 +655,14 @@ mod tests {
//load accounts
let tx =
SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 1, bank.last_id(), 0);
SystemTransaction::new_account(&mint_keypair, keypair1.pubkey(), 1, bank.last_block_hash(), 0);
assert_eq!(bank.process_transaction(&tx), Ok(()));
let tx =
SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 1, bank.last_id(), 0);
SystemTransaction::new_account(&mint_keypair, keypair2.pubkey(), 1, bank.last_block_hash(), 0);
assert_eq!(bank.process_transaction(&tx), Ok(()));
let last_id = bank.last_id();
while last_id == bank.last_id() {
let last_id = bank.last_block_hash();
while last_id == bank.last_block_hash() {
bank.register_tick(&Hash::default());
}
@ -670,7 +670,7 @@ mod tests {
let tx = SystemTransaction::new_account(&keypair2, keypair3.pubkey(), 1, last_id, 0);
let entry_1 = next_entry(&last_id, 1, vec![tx]);
let tick = next_entry(&entry_1.hash, 1, vec![]);
let tx = SystemTransaction::new_account(&keypair1, keypair4.pubkey(), 1, bank.last_id(), 0);
let tx = SystemTransaction::new_account(&keypair1, keypair4.pubkey(), 1, bank.last_block_hash(), 0);
let entry_2 = next_entry(&tick.hash, 1, vec![tx]);
assert_eq!(
par_process_entries(&bank, &[entry_1.clone(), tick.clone(), entry_2.clone()]),
@ -680,7 +680,7 @@ mod tests {
assert_eq!(bank.get_balance(&keypair4.pubkey()), 1);
// ensure that an error is returned for an empty account (keypair2)
let tx = SystemTransaction::new_account(&keypair2, keypair3.pubkey(), 1, bank.last_id(), 0);
let tx = SystemTransaction::new_account(&keypair2, keypair3.pubkey(), 1, bank.last_block_hash(), 0);
let entry_3 = next_entry(&entry_2.hash, 1, vec![tx]);
assert_eq!(
par_process_entries(&bank, &[entry_3]),

4
core/src/fullnode.rs
View File

@ -124,10 +124,10 @@ impl Fullnode {
let bank_info = &bank_forks_info[0];
let bank = bank_forks[bank_info.bank_id].clone();
info!("starting PoH... {} {}", bank.tick_height(), bank.last_id(),);
info!("starting PoH... {} {}", bank.tick_height(), bank.last_block_hash(),);
let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(
bank.tick_height(),
bank.last_id(),
bank.last_block_hash(),
)));
let poh_service = PohService::new(poh_recorder.clone(), &config.tick_config, exit.clone());

2
core/src/leader_confirmation_service.rs
View File

@ -154,7 +154,7 @@ mod tests {
tick_hash = hash(&serialize(&tick_hash).unwrap());
bank.register_tick(&tick_hash);
}
let last_id = bank.last_id();
let last_id = bank.last_block_hash();
// Create a total of 10 vote accounts, each will have a balance of 1 (after giving 1 to
// their vote account), for a total staking pool of 10 tokens.

14
core/src/poh_recorder.rs
View File

@ -223,7 +223,7 @@ mod tests {
fn test_poh_recorder_clear() {
let (genesis_block, _mint_keypair) = GenesisBlock::new(2);
let bank = Arc::new(Bank::new(&genesis_block));
let prev_hash = bank.last_id();
let prev_hash = bank.last_block_hash();
let (entry_sender, _) = channel();
let mut poh_recorder = PohRecorder::new(0, prev_hash);
@ -243,7 +243,7 @@ mod tests {
fn test_poh_recorder_tick_sent_after_min() {
let (genesis_block, _mint_keypair) = GenesisBlock::new(2);
let bank = Arc::new(Bank::new(&genesis_block));
let prev_hash = bank.last_id();
let prev_hash = bank.last_block_hash();
let (entry_sender, entry_receiver) = channel();
let mut poh_recorder = PohRecorder::new(0, prev_hash);
@ -274,7 +274,7 @@ mod tests {
fn test_poh_recorder_tick_sent_upto_and_including_max() {
let (genesis_block, _mint_keypair) = GenesisBlock::new(2);
let bank = Arc::new(Bank::new(&genesis_block));
let prev_hash = bank.last_id();
let prev_hash = bank.last_block_hash();
let (entry_sender, entry_receiver) = channel();
let mut poh_recorder = PohRecorder::new(0, prev_hash);
@ -304,7 +304,7 @@ mod tests {
fn test_poh_recorder_record_to_early() {
let (genesis_block, _mint_keypair) = GenesisBlock::new(2);
let bank = Arc::new(Bank::new(&genesis_block));
let prev_hash = bank.last_id();
let prev_hash = bank.last_block_hash();
let (entry_sender, entry_receiver) = channel();
let mut poh_recorder = PohRecorder::new(0, prev_hash);
@ -326,7 +326,7 @@ mod tests {
fn test_poh_recorder_record_at_min_passes() {
let (genesis_block, _mint_keypair) = GenesisBlock::new(2);
let bank = Arc::new(Bank::new(&genesis_block));
let prev_hash = bank.last_id();
let prev_hash = bank.last_block_hash();
let (entry_sender, entry_receiver) = channel();
let mut poh_recorder = PohRecorder::new(0, prev_hash);
@ -357,7 +357,7 @@ mod tests {
fn test_poh_recorder_record_at_max_fails() {
let (genesis_block, _mint_keypair) = GenesisBlock::new(2);
let bank = Arc::new(Bank::new(&genesis_block));
let prev_hash = bank.last_id();
let prev_hash = bank.last_block_hash();
let (entry_sender, entry_receiver) = channel();
let mut poh_recorder = PohRecorder::new(0, prev_hash);
@ -385,7 +385,7 @@ mod tests {
fn test_poh_cache_on_disconnect() {
let (genesis_block, _mint_keypair) = GenesisBlock::new(2);
let bank = Arc::new(Bank::new(&genesis_block));
let prev_hash = bank.last_id();
let prev_hash = bank.last_block_hash();
let (entry_sender, entry_receiver) = channel();
let mut poh_recorder = PohRecorder::new(0, prev_hash);

4
core/src/poh_service.rs
View File

@ -124,7 +124,7 @@ mod tests {
fn test_poh_service() {
let (genesis_block, _mint_keypair) = GenesisBlock::new(2);
let bank = Arc::new(Bank::new(&genesis_block));
let prev_hash = bank.last_id();
let prev_hash = bank.last_block_hash();
let (entry_sender, entry_receiver) = channel();
let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(bank.tick_height(), prev_hash)));
let exit = Arc::new(AtomicBool::new(false));
@ -204,7 +204,7 @@ mod tests {
fn test_poh_service_drops_working_bank() {
let (genesis_block, _mint_keypair) = GenesisBlock::new(2);
let bank = Arc::new(Bank::new(&genesis_block));
let prev_hash = bank.last_id();
let prev_hash = bank.last_block_hash();
let (entry_sender, entry_receiver) = channel();
let poh_recorder = Arc::new(Mutex::new(PohRecorder::new(bank.tick_height(), prev_hash)));
let exit = Arc::new(AtomicBool::new(false));

16
core/src/replay_stage.rs
View File

@ -137,7 +137,7 @@ impl ReplayStage {
let vote = VoteTransaction::new_vote(
keypair,
*latest_slot_vote,
parent.last_id(),
parent.last_block_hash(),
0,
);
cluster_info.write().unwrap().push_vote(vote);
@ -152,7 +152,7 @@ impl ReplayStage {
);
to_leader_sender.send(TvuRotationInfo {
tick_height: parent.tick_height(),
last_id: parent.last_id(),
last_id: parent.last_block_hash(),
slot: next_slot,
leader_id: next_leader,
})?;
@ -206,7 +206,7 @@ impl ReplayStage {
progress: &mut HashMap<u64, (Hash, usize)>,
) -> result::Result<(Vec<Entry>, usize)> {
let bank_id = bank.slot();
let bank_progress = &mut progress.entry(bank_id).or_insert((bank.last_id(), 0));
let bank_progress = &mut progress.entry(bank_id).or_insert((bank.last_block_hash(), 0));
blocktree.get_slot_entries_with_blob_count(bank_id, bank_progress.1 as u64, None)
}
@ -217,7 +217,7 @@ impl ReplayStage {
forward_entry_sender: &EntrySender,
num: usize,
) -> result::Result<()> {
let bank_progress = &mut progress.entry(bank.slot()).or_insert((bank.last_id(), 0));
let bank_progress = &mut progress.entry(bank.slot()).or_insert((bank.last_block_hash(), 0));
let result = Self::verify_and_process_entries(&bank, &entries, &bank_progress.0);
bank_progress.1 += num;
if let Some(last_entry) = entries.last() {
@ -253,7 +253,7 @@ impl ReplayStage {
entries.len(),
bank.tick_height(),
last_entry,
bank.last_id()
bank.last_block_hash()
);
return Err(result::Error::BlobError(BlobError::VerificationFailed));
}
@ -358,11 +358,11 @@ mod test {
);
let keypair = voting_keypair.as_ref();
let vote = VoteTransaction::new_vote(keypair, 0, bank.last_id(), 0);
let vote = VoteTransaction::new_vote(keypair, 0, bank.last_block_hash(), 0);
cluster_info_me.write().unwrap().push_vote(vote);
info!("Send ReplayStage an entry, should see it on the ledger writer receiver");
let next_tick = create_ticks(1, bank.last_id());
let next_tick = create_ticks(1, bank.last_block_hash());
blocktree.write_entries(1, 0, 0, next_tick.clone()).unwrap();
let received_tick = ledger_writer_recv
@ -383,7 +383,7 @@ mod test {
let (forward_entry_sender, forward_entry_receiver) = channel();
let genesis_block = GenesisBlock::new(10_000).0;
let bank = Arc::new(Bank::new(&genesis_block));
let mut last_id = bank.last_id();
let mut last_id = bank.last_block_hash();
let mut entries = Vec::new();
for _ in 0..5 {
let entry = next_entry_mut(&mut last_id, 1, vec![]); //just ticks

8
core/src/rpc.rs
View File

@ -58,7 +58,7 @@ impl JsonRpcRequestProcessor {
}
fn get_recent_block_hash(&self) -> Result<String> {
let id = self.bank()?.last_id();
let id = self.bank()?.last_block_hash();
Ok(bs58::encode(id).into_string())
}
@ -255,7 +255,7 @@ impl RpcSol for RpcSolImpl {
trace!("request_airdrop id={} tokens={}", id, tokens);
let pubkey = verify_pubkey(id)?;
let last_id = meta.request_processor.read().unwrap().bank()?.last_id();
let last_id = meta.request_processor.read().unwrap().bank()?.last_block_hash();
let transaction = request_airdrop_transaction(&meta.drone_addr, &pubkey, tokens, last_id)
.map_err(|err| {
info!("request_airdrop_transaction failed: {:?}", err);
@ -370,7 +370,7 @@ mod tests {
let (genesis_block, alice) = GenesisBlock::new(10_000);
let bank = Arc::new(Bank::new(&genesis_block));
let last_id = bank.last_id();
let last_id = bank.last_block_hash();
let tx = SystemTransaction::new_move(&alice, pubkey, 20, last_id, 0);
bank.process_transaction(&tx).expect("process transaction");
@ -406,7 +406,7 @@ mod tests {
let mut request_processor = JsonRpcRequestProcessor::new(StorageState::default());
request_processor.set_bank(&bank);
thread::spawn(move || {
let last_id = bank.last_id();
let last_id = bank.last_block_hash();
let tx = SystemTransaction::new_move(&alice, bob_pubkey, 20, last_id, 0);
bank.process_transaction(&tx).expect("process transaction");
})

6
core/src/rpc_pubsub.rs
View File

@ -203,7 +203,7 @@ mod tests {
let bob_pubkey = bob.pubkey();
let bank = Bank::new(&genesis_block);
let arc_bank = Arc::new(bank);
let last_id = arc_bank.last_id();
let last_id = arc_bank.last_block_hash();
let rpc = RpcSolPubSubImpl::default();
@ -232,7 +232,7 @@ mod tests {
let bob_pubkey = Keypair::new().pubkey();
let bank = Bank::new(&genesis_block);
let arc_bank = Arc::new(bank);
let last_id = arc_bank.last_id();
let last_id = arc_bank.last_block_hash();
let session = create_session();
@ -279,7 +279,7 @@ mod tests {
let executable = false; // TODO
let bank = Bank::new(&genesis_block);
let arc_bank = Arc::new(bank);
let last_id = arc_bank.last_id();
let last_id = arc_bank.last_block_hash();
let rpc = RpcSolPubSubImpl::default();
let session = create_session();

4
core/src/rpc_subscriptions.rs
View File

@ -156,7 +156,7 @@ mod tests {
let (genesis_block, mint_keypair) = GenesisBlock::new(100);
let bank = Bank::new(&genesis_block);
let alice = Keypair::new();
let last_id = bank.last_id();
let last_id = bank.last_block_hash();
let tx = SystemTransaction::new_program_account(
&mint_keypair,
alice.pubkey(),
@ -201,7 +201,7 @@ mod tests {
let (genesis_block, mint_keypair) = GenesisBlock::new(100);
let bank = Bank::new(&genesis_block);
let alice = Keypair::new();
let last_id = bank.last_id();
let last_id = bank.last_block_hash();
let tx = SystemTransaction::new_move(&mint_keypair, alice.pubkey(), 20, last_id, 0);
let signature = tx.signatures[0];
bank.process_transaction(&tx).unwrap();

4
core/src/voting_keypair.rs
View File

@ -109,7 +109,7 @@ pub mod tests {
bank: &Bank,
num_tokens: u64,
) {
let last_id = bank.last_id();
let last_id = bank.last_block_hash();
let tx = VoteTransaction::fund_staking_account(
from_keypair,
*voting_pubkey,
@ -121,7 +121,7 @@ pub mod tests {
}
pub fn push_vote<T: KeypairUtil>(voting_keypair: &T, bank: &Bank, slot_height: u64) {
let last_id = bank.last_id();
let last_id = bank.last_block_hash();
let tx = VoteTransaction::new_vote(voting_keypair, slot_height, last_id, 0);
bank.process_transaction(&tx).unwrap();
}

8
programs/native/rewards/tests/rewards.rs
View File

@ -24,7 +24,7 @@ impl<'a> RewardsBank<'a> {
rewards_id: Pubkey,
lamports: u64,
) -> Result<()> {
let last_id = self.bank.last_id();
let last_id = self.bank.last_block_hash();
let tx = RewardsTransaction::new_account(from_keypair, rewards_id, last_id, lamports, 0);
self.bank.process_transaction(&tx)
}
@ -35,13 +35,13 @@ impl<'a> RewardsBank<'a> {
vote_id: Pubkey,
lamports: u64,
) -> Result<()> {
let last_id = self.bank.last_id();
let last_id = self.bank.last_block_hash();
let tx = VoteTransaction::fund_staking_account(from_keypair, vote_id, last_id, lamports, 0);
self.bank.process_transaction(&tx)
}
fn submit_vote(&self, vote_keypair: &Keypair, tick_height: u64) -> Result<VoteState> {
let last_id = self.bank.last_id();
let last_id = self.bank.last_block_hash();
let tx = VoteTransaction::new_vote(vote_keypair, tick_height, last_id, 0);
self.bank.process_transaction(&tx)?;
self.bank.register_tick(&hash(last_id.as_ref()));
@ -51,7 +51,7 @@ impl<'a> RewardsBank<'a> {
}
fn redeem_credits(&self, rewards_id: Pubkey, vote_keypair: &Keypair) -> Result<VoteState> {
let last_id = self.bank.last_id();
let last_id = self.bank.last_block_hash();
let tx = RewardsTransaction::new_redeem_credits(&vote_keypair, rewards_id, last_id, 0);
self.bank.process_transaction(&tx)?;
let vote_account = self.bank.get_account(&vote_keypair.pubkey()).unwrap();

6
programs/native/vote/tests/vote.rs
View File

@ -26,13 +26,13 @@ impl<'a> VoteBank<'a> {
vote_id: Pubkey,
lamports: u64,
) -> Result<()> {
let last_id = self.bank.last_id();
let last_id = self.bank.last_block_hash();
let tx = VoteTransaction::fund_staking_account(from_keypair, vote_id, last_id, lamports, 0);
self.bank.process_transaction(&tx)
}
fn submit_vote(&self, vote_keypair: &Keypair, tick_height: u64) -> Result<VoteState> {
let last_id = self.bank.last_id();
let last_id = self.bank.last_block_hash();
let tx = VoteTransaction::new_vote(vote_keypair, tick_height, last_id, 0);
self.bank.process_transaction(&tx)?;
self.bank.register_tick(&hash(last_id.as_ref()));
@ -71,7 +71,7 @@ fn test_vote_via_bank_with_no_signature() {
.unwrap();
let mallory_id = mallory_keypair.pubkey();
let last_id = bank.last_id();
let last_id = bank.last_block_hash();
let vote_ix = BuilderInstruction::new(
vote_program::id(),
&VoteInstruction::Vote(Vote::new(0)),

16
programs/tests/programs.rs
View File

@ -15,7 +15,7 @@ fn load_program(bank: &Bank, from: &Keypair, loader_id: Pubkey, program: Vec<u8>
let tx = SystemTransaction::new_program_account(
from,
program_account.pubkey(),
bank.last_id(),
bank.last_block_hash(),
1,
program.len() as u64,
loader_id,
@ -32,14 +32,14 @@ fn load_program(bank: &Bank, from: &Keypair, loader_id: Pubkey, program: Vec<u8>
loader_id,
offset,
chunk.to_vec(),
bank.last_id(),
bank.last_block_hash(),
0,
);
bank.process_transaction(&tx).unwrap();
offset += chunk_size as u32;
}
let tx = LoaderTransaction::new_finalize(&program_account, loader_id, bank.last_id(), 0);
let tx = LoaderTransaction::new_finalize(&program_account, loader_id, bank.last_block_hash(), 0);
bank.process_transaction(&tx).unwrap();
assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
@ -57,7 +57,7 @@ fn test_program_native_noop() {
let program_id = load_program(&bank, &mint_keypair, native_loader::id(), program);
// Call user program
let tx = Transaction::new(&mint_keypair, &[], program_id, &1u8, bank.last_id(), 0);
let tx = Transaction::new(&mint_keypair, &[], program_id, &1u8, bank.last_block_hash(), 0);
bank.process_transaction(&tx).unwrap();
assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
}
@ -73,7 +73,7 @@ fn test_program_native_failure() {
let program_id = load_program(&bank, &mint_keypair, native_loader::id(), program);
// Call user program
let tx = Transaction::new(&mint_keypair, &[], program_id, &1u8, bank.last_id(), 0);
let tx = Transaction::new(&mint_keypair, &[], program_id, &1u8, bank.last_block_hash(), 0);
assert_eq!(
bank.process_transaction(&tx),
Err(BankError::ProgramError(0, ProgramError::GenericError))
@ -126,7 +126,7 @@ fn test_program_bpf_c_noop() {
&[],
program_id,
&vec![1u8],
bank.last_id(),
bank.last_block_hash(),
0,
);
bank.process_transaction(&tx).unwrap();
@ -170,7 +170,7 @@ fn test_program_bpf_c() {
&[],
program_id,
&vec![1u8],
bank.last_id(),
bank.last_block_hash(),
0,
);
bank.process_transaction(&tx).unwrap();
@ -210,7 +210,7 @@ fn test_program_bpf_rust() {
&[],
program_id,
&vec![1u8],
bank.last_id(),
bank.last_block_hash(),
0,
);
bank.process_transaction(&tx).unwrap();

6
runtime/benches/bank.rs
View File

@ -25,14 +25,14 @@ fn bench_process_transaction(bencher: &mut Bencher) {
&mint_keypair,
rando0.pubkey(),
10_000,
bank.last_id(),
bank.last_block_hash(),
0,
);
assert_eq!(bank.process_transaction(&tx), Ok(()));
// Seed the 'to' account and a cell for its signature.
let rando1 = Keypair::new();
let tx = SystemTransaction::new_move(&rando0, rando1.pubkey(), 1, bank.last_id(), 0);
let tx = SystemTransaction::new_move(&rando0, rando1.pubkey(), 1, bank.last_block_hash(), 0);
assert_eq!(bank.process_transaction(&tx), Ok(()));
// Finally, return the transaction to the benchmark.
@ -40,7 +40,7 @@ fn bench_process_transaction(bencher: &mut Bencher) {
})
.collect();
let mut id = bank.last_id();
let mut id = bank.last_block_hash();
for _ in 0..(MAX_RECENT_TICK_HASHES - 1) {
bank.register_tick(&id);

10
runtime/src/bank.rs
View File

@ -298,7 +298,7 @@ impl Bank {
}
/// Return the last block hash registered.
pub fn last_id(&self) -> Hash {
pub fn last_block_hash(&self) -> Hash {
self.block_hash_queue.read().unwrap().last_hash()
}
@ -881,7 +881,7 @@ mod tests {
let (genesis_block, mint_keypair) = GenesisBlock::new(10_000);
let pubkey = Keypair::new().pubkey();
let bank = Bank::new(&genesis_block);
assert_eq!(bank.last_id(), genesis_block.hash());
assert_eq!(bank.last_block_hash(), genesis_block.hash());
bank.transfer(1_000, &mint_keypair, pubkey, genesis_block.hash())
.unwrap();
@ -899,7 +899,7 @@ mod tests {
let key1 = Keypair::new().pubkey();
let key2 = Keypair::new().pubkey();
let bank = Bank::new(&genesis_block);
assert_eq!(bank.last_id(), genesis_block.hash());
assert_eq!(bank.last_block_hash(), genesis_block.hash());
let t1 = SystemTransaction::new_move(&mint_keypair, key1, 1, genesis_block.hash(), 0);
let t2 = SystemTransaction::new_move(&mint_keypair, key2, 1, genesis_block.hash(), 0);
@ -1394,11 +1394,11 @@ mod tests {
let pubkey = Keypair::new().pubkey();
bank0
.transfer(1_000, &mint_keypair, pubkey, bank0.last_id())
.transfer(1_000, &mint_keypair, pubkey, bank0.last_block_hash())
.unwrap();
assert_ne!(bank0.hash_internal_state(), initial_state);
bank1
.transfer(1_000, &mint_keypair, pubkey, bank1.last_id())
.transfer(1_000, &mint_keypair, pubkey, bank1.last_block_hash())
.unwrap();
assert_eq!(bank0.hash_internal_state(), bank1.hash_internal_state());

2
tests/tvu.rs
View File

@ -86,7 +86,7 @@ fn test_replay() {
let tvu_addr = target1.info.tvu;
let bank = Bank::new(&genesis_block);
let last_id = bank.last_id();
let last_id = bank.last_block_hash();
let bank_forks = BankForks::new(0, bank);
let bank_forks_info = vec![BankForksInfo {
bank_id: 0,