solana-runtime 4.2.0-beta.0

Solana runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use {
    crate::vote_sender_types::{ReplayVoteMessage, ReplayVoteSendType, ReplayVoteSender},
    solana_runtime_transaction::transaction_with_meta::TransactionWithMeta,
    solana_svm::transaction_commit_result::{
        TransactionCommitResult, TransactionCommitResultExtensions,
    },
    solana_vote::vote_parser,
};
#[cfg(feature = "dev-context-only-utils")]
use {
    crate::{
        bank::Bank,
        genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs},
    },
    solana_pubkey::Pubkey,
    solana_signer::Signer,
};

#[cfg(feature = "dev-context-only-utils")]
pub fn setup_bank_and_vote_pubkeys_for_tests(
    num_vote_accounts: usize,
    stake: u64,
) -> (Bank, Vec<Pubkey>) {
    // Create some voters at genesis
    let validator_voting_keypairs: Vec<_> = (0..num_vote_accounts)
        .map(|_| ValidatorVoteKeypairs::new_rand())
        .collect();

    let vote_pubkeys: Vec<_> = validator_voting_keypairs
        .iter()
        .map(|k| k.vote_keypair.pubkey())
        .collect();
    let GenesisConfigInfo { genesis_config, .. } =
        genesis_utils::create_genesis_config_with_vote_accounts(
            10_000,
            &validator_voting_keypairs,
            vec![stake; validator_voting_keypairs.len()],
        );
    let bank = Bank::new_for_tests(&genesis_config);
    (bank, vote_pubkeys)
}

pub fn find_and_send_votes(
    sanitized_txs: &[impl TransactionWithMeta],
    commit_results: &[TransactionCommitResult],
    vote_sender: Option<&ReplayVoteSender>,
    send_type: ReplayVoteSendType,
) {
    if let Some(vote_sender) = vote_sender {
        sanitized_txs
            .iter()
            .zip(commit_results.iter())
            .for_each(|(tx, commit_result)| {
                if tx.is_simple_vote_transaction()
                    && commit_result.was_executed_successfully()
                    && let Some(parsed_vote) = vote_parser::parse_sanitized_vote_transaction(tx)
                    && parsed_vote.1.last_voted_slot().is_some()
                {
                    let vote = match send_type {
                        ReplayVoteSendType::VerifiedExecuted => {
                            ReplayVoteMessage::VerifiedExecuted(parsed_vote)
                        }
                        ReplayVoteSendType::Executed {
                            replay_bank_id,
                            replay_slot,
                        } => ReplayVoteMessage::Executed {
                            replay_bank_id,
                            replay_slot,
                            message_hash: *tx.message_hash(),
                            parsed_vote,
                        },
                    };
                    let _ = vote_sender.send(vote);
                }
            });
    }
}