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

Refactor: move simple vote parsing to runtime (#22537)

Browse Source
This commit is contained in:
Justin Starry
2022-01-20 10:39:21 +08:00
committed by GitHub
parent d343713f61
commit 7f20c6149e
16 changed files with 239 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
runtime/src/bank.rs
View File

@ -61,6 +61,7 @@ use {
system_instruction_processor::{get_system_account_kind, SystemAccountKind},
transaction_batch::TransactionBatch,
vote_account::VoteAccount,
vote_parser,
},
byteorder::{ByteOrder, LittleEndian},
dashmap::DashMap,
@ -117,7 +118,6 @@ use {
nonce, nonce_account,
packet::PACKET_DATA_SIZE,
precompiles::get_precompiles,
program_utils::limited_deserialize,
pubkey::Pubkey,
saturating_add_assign, secp256k1_program,
signature::{Keypair, Signature},
@ -135,10 +135,7 @@ use {
solana_stake_program::stake_state::{
self, InflationPointCalculationEvent, PointValue, StakeState,
},
solana_vote_program::{
vote_instruction::VoteInstruction,
vote_state::{VoteState, VoteStateVersions},
},
solana_vote_program::vote_state::{VoteState, VoteStateVersions},
std::{
borrow::Cow,
cell::RefCell,
@ -3912,7 +3909,7 @@ impl Bank {
}
}
let is_vote = is_simple_vote_transaction(tx);
let is_vote = vote_parser::is_simple_vote_transaction(tx);
let store = match transaction_log_collector_config.filter {
TransactionLogCollectorFilter::All => {
!is_vote || !filtered_mentioned_addresses.is_empty()
@ -6409,29 +6406,6 @@ pub fn goto_end_of_slot(bank: &mut Bank) {
}
}
fn is_simple_vote_transaction(transaction: &SanitizedTransaction) -> bool {
if transaction.message().instructions().len() == 1 {
let (program_pubkey, instruction) = transaction
.message()
.program_instructions_iter()
.next()
.unwrap();
if program_pubkey == &solana_vote_program::id() {
if let Ok(vote_instruction) = limited_deserialize::<VoteInstruction>(&instruction.data)
{
return matches!(
vote_instruction,
VoteInstruction::Vote(_)
| VoteInstruction::VoteSwitch(_, _)
| VoteInstruction::UpdateVoteState(_)
| VoteInstruction::UpdateVoteStateSwitch(_, _)
);
}
}
}
false
}
#[cfg(test)]
pub(crate) mod tests {
#[allow(deprecated)]

6
runtime/src/bank_utils.rs
View File

@ -2,10 +2,10 @@ use {
crate::{
bank::{Bank, TransactionResults},
genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs},
vote_parser,
vote_sender_types::ReplayVoteSender,
},
solana_sdk::{pubkey::Pubkey, signature::Signer, transaction::SanitizedTransaction},
solana_vote_program::vote_transaction,
};
pub fn setup_bank_and_vote_pubkeys_for_tests(
@ -45,9 +45,7 @@ pub fn find_and_send_votes(
.zip(execution_results.iter())
.for_each(|(tx, result)| {
if tx.is_simple_vote_transaction() && result.was_executed_successfully() {
if let Some(parsed_vote) =
vote_transaction::parse_sanitized_vote_transaction(tx)
{
if let Some(parsed_vote) = vote_parser::parse_sanitized_vote_transaction(tx) {
if parsed_vote.1.last_voted_slot().is_some() {
let _ = vote_sender.send(parsed_vote);
}

2
runtime/src/lib.rs
View File

@ -58,7 +58,9 @@ mod system_instruction_processor;
pub mod transaction_batch;
pub mod transaction_cost_metrics_sender;
pub mod vote_account;
pub mod vote_parser;
pub mod vote_sender_types;
pub mod vote_transaction;
pub mod waitable_condvar;
#[macro_use]

133
runtime/src/vote_parser.rs Normal file
View File

@ -0,0 +1,133 @@
use {
crate::vote_transaction::VoteTransaction,
solana_sdk::{
hash::Hash,
program_utils::limited_deserialize,
pubkey::Pubkey,
transaction::{SanitizedTransaction, Transaction},
},
solana_vote_program::vote_instruction::VoteInstruction,
};
pub type ParsedVote = (Pubkey, VoteTransaction, Option<Hash>);
// Used for filtering out votes from the transaction log collector
pub(crate) fn is_simple_vote_transaction(transaction: &SanitizedTransaction) -> bool {
if transaction.message().instructions().len() == 1 {
let (program_pubkey, instruction) = transaction
.message()
.program_instructions_iter()
.next()
.unwrap();
if program_pubkey == &solana_vote_program::id() {
if let Ok(vote_instruction) = limited_deserialize::<VoteInstruction>(&instruction.data)
{
return matches!(
vote_instruction,
VoteInstruction::Vote(_)
| VoteInstruction::VoteSwitch(_, _)
| VoteInstruction::UpdateVoteState(_)
| VoteInstruction::UpdateVoteStateSwitch(_, _)
);
}
}
}
false
}
// Used for locally forwarding processed vote transactions to consensus
pub fn parse_sanitized_vote_transaction(tx: &SanitizedTransaction) -> Option<ParsedVote> {
// Check first instruction for a vote
let message = tx.message();
let (program_id, first_instruction) = message.program_instructions_iter().next()?;
if !solana_vote_program::check_id(program_id) {
return None;
}
let first_account = usize::from(*first_instruction.accounts.first()?);
let key = message.get_account_key(first_account)?;
let (vote, switch_proof_hash) = parse_vote_instruction_data(&first_instruction.data)?;
Some((*key, vote, switch_proof_hash))
}
// Used for parsing gossip vote transactions
pub fn parse_vote_transaction(tx: &Transaction) -> Option<ParsedVote> {
// Check first instruction for a vote
let message = tx.message();
let first_instruction = message.instructions.first()?;
let program_id_index = usize::from(first_instruction.program_id_index);
let program_id = message.account_keys.get(program_id_index)?;
if !solana_vote_program::check_id(program_id) {
return None;
}
let first_account = usize::from(*first_instruction.accounts.first()?);
let key = message.account_keys.get(first_account)?;
let (vote, switch_proof_hash) = parse_vote_instruction_data(&first_instruction.data)?;
Some((*key, vote, switch_proof_hash))
}
fn parse_vote_instruction_data(
vote_instruction_data: &[u8],
) -> Option<(VoteTransaction, Option<Hash>)> {
match limited_deserialize(vote_instruction_data).ok()? {
VoteInstruction::Vote(vote) => Some((VoteTransaction::from(vote), None)),
VoteInstruction::VoteSwitch(vote, hash) => Some((VoteTransaction::from(vote), Some(hash))),
VoteInstruction::UpdateVoteState(vote_state_update) => {
Some((VoteTransaction::from(vote_state_update), None))
}
VoteInstruction::UpdateVoteStateSwitch(vote_state_update, hash) => {
Some((VoteTransaction::from(vote_state_update), Some(hash)))
}
VoteInstruction::Authorize(_, _)
| VoteInstruction::AuthorizeChecked(_)
| VoteInstruction::InitializeAccount(_)
| VoteInstruction::UpdateCommission(_)
| VoteInstruction::UpdateValidatorIdentity
| VoteInstruction::Withdraw(_) => None,
}
}
#[cfg(test)]
mod test {
use solana_sdk::signature::{Keypair, Signer};
use solana_vote_program::{
vote_instruction, vote_state::Vote, vote_transaction::new_vote_transaction,
};
use {super::*, solana_sdk::hash::hash};
fn run_test_parse_vote_transaction(input_hash: Option<Hash>) {
let node_keypair = Keypair::new();
let vote_keypair = Keypair::new();
let auth_voter_keypair = Keypair::new();
let bank_hash = Hash::default();
let vote_tx = new_vote_transaction(
vec![42],
bank_hash,
Hash::default(),
&node_keypair,
&vote_keypair,
&auth_voter_keypair,
input_hash,
);
let (key, vote, hash) = parse_vote_transaction(&vote_tx).unwrap();
assert_eq!(hash, input_hash);
assert_eq!(vote, VoteTransaction::from(Vote::new(vec![42], bank_hash)));
assert_eq!(key, vote_keypair.pubkey());
// Test bad program id fails
let mut vote_ix = vote_instruction::vote(
&vote_keypair.pubkey(),
&auth_voter_keypair.pubkey(),
Vote::new(vec![1, 2], Hash::default()),
);
vote_ix.program_id = Pubkey::default();
let vote_tx = Transaction::new_with_payer(&[vote_ix], Some(&node_keypair.pubkey()));
assert!(parse_vote_transaction(&vote_tx).is_none());
}
#[test]
fn test_parse_vote_transaction() {
run_test_parse_vote_transaction(None);
run_test_parse_vote_transaction(Some(hash(&[42u8])));
}
}

2
runtime/src/vote_sender_types.rs
View File

@ -1,6 +1,6 @@
use {
crate::vote_parser::ParsedVote,
crossbeam_channel::{Receiver, Sender},
solana_vote_program::vote_transaction::ParsedVote,
};
pub type ReplayVoteSender = Sender<ParsedVote>;

74
runtime/src/vote_transaction.rs Normal file
View File

@ -0,0 +1,74 @@
use {
solana_sdk::{
clock::{Slot, UnixTimestamp},
hash::Hash,
},
solana_vote_program::vote_state::{Vote, VoteStateUpdate},
};
#[derive(Debug, PartialEq)]
pub enum VoteTransaction {
Vote(Vote),
VoteStateUpdate(VoteStateUpdate),
}
impl VoteTransaction {
pub fn slots(&self) -> Vec<Slot> {
match self {
VoteTransaction::Vote(vote) => vote.slots.clone(),
VoteTransaction::VoteStateUpdate(vote_state_update) => vote_state_update
.lockouts
.iter()
.map(|lockout| lockout.slot)
.collect(),
}
}
pub fn is_empty(&self) -> bool {
match self {
VoteTransaction::Vote(vote) => vote.slots.is_empty(),
VoteTransaction::VoteStateUpdate(vote_state_update) => {
vote_state_update.lockouts.is_empty()
}
}
}
pub fn hash(&self) -> Hash {
match self {
VoteTransaction::Vote(vote) => vote.hash,
VoteTransaction::VoteStateUpdate(vote_state_update) => vote_state_update.hash,
}
}
pub fn timestamp(&self) -> Option<UnixTimestamp> {
match self {
VoteTransaction::Vote(vote) => vote.timestamp,
VoteTransaction::VoteStateUpdate(vote_state_update) => vote_state_update.timestamp,
}
}
pub fn last_voted_slot(&self) -> Option<Slot> {
match self {
VoteTransaction::Vote(vote) => vote.slots.last().copied(),
VoteTransaction::VoteStateUpdate(vote_state_update) => {
Some(vote_state_update.lockouts.back()?.slot)
}
}
}
pub fn last_voted_slot_hash(&self) -> Option<(Slot, Hash)> {
Some((self.last_voted_slot()?, self.hash()))
}
}
impl From<Vote> for VoteTransaction {
fn from(vote: Vote) -> Self {
VoteTransaction::Vote(vote)
}
}
impl From<VoteStateUpdate> for VoteTransaction {
fn from(vote_state_update: VoteStateUpdate) -> Self {
VoteTransaction::VoteStateUpdate(vote_state_update)
}
}