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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
#[cfg(test)]
pub(crate) mod tests {
use {
rand::Rng,
solana_runtime::{
bank::Bank,
vote_account::{VoteAccount, VoteAccounts},
},
solana_sdk::{
account::AccountSharedData,
clock::Clock,
instruction::Instruction,
pubkey::Pubkey,
signature::{Keypair, Signer},
signers::Signers,
stake::{
instruction as stake_instruction,
state::{Authorized, Lockup},
},
transaction::Transaction,
},
solana_vote_program::{
vote_instruction,
vote_state::{VoteInit, VoteState, VoteStateVersions},
},
};
pub(crate) fn setup_vote_and_stake_accounts(
bank: &Bank,
from_account: &Keypair,
vote_account: &Keypair,
validator_identity_account: &Keypair,
amount: u64,
) {
let vote_pubkey = vote_account.pubkey();
fn process_instructions<T: Signers>(bank: &Bank, keypairs: &T, ixs: &[Instruction]) {
let tx = Transaction::new_signed_with_payer(
ixs,
Some(&keypairs.pubkeys()[0]),
keypairs,
bank.last_blockhash(),
);
bank.process_transaction(&tx).unwrap();
}
process_instructions(
bank,
&[from_account, vote_account, validator_identity_account],
&vote_instruction::create_account(
&from_account.pubkey(),
&vote_pubkey,
&VoteInit {
node_pubkey: validator_identity_account.pubkey(),
authorized_voter: vote_pubkey,
authorized_withdrawer: vote_pubkey,
commission: 0,
},
amount,
),
);
let stake_account_keypair = Keypair::new();
let stake_account_pubkey = stake_account_keypair.pubkey();
process_instructions(
bank,
&[from_account, &stake_account_keypair],
&stake_instruction::create_account_and_delegate_stake(
&from_account.pubkey(),
&stake_account_pubkey,
&vote_pubkey,
&Authorized::auto(&stake_account_pubkey),
&Lockup::default(),
amount,
),
);
}
#[test]
fn test_to_staked_nodes() {
let mut stakes = Vec::new();
let node1 = solana_sdk::pubkey::new_rand();
for i in 0..3 {
stakes.push((
i,
VoteState::new(
&VoteInit {
node_pubkey: node1,
..VoteInit::default()
},
&Clock::default(),
),
));
}
let node2 = solana_sdk::pubkey::new_rand();
stakes.push((
5,
VoteState::new(
&VoteInit {
node_pubkey: node2,
..VoteInit::default()
},
&Clock::default(),
),
));
let mut rng = rand::thread_rng();
let vote_accounts = stakes.into_iter().map(|(stake, vote_state)| {
let account = AccountSharedData::new_data(
rng.gen(),
&VoteStateVersions::new_current(vote_state),
&Pubkey::new_unique(),
)
.unwrap();
let vote_pubkey = Pubkey::new_unique();
(vote_pubkey, (stake, VoteAccount::from(account)))
});
let result = vote_accounts.collect::<VoteAccounts>().staked_nodes();
assert_eq!(result.len(), 2);
assert_eq!(result[&node1], 3);
assert_eq!(result[&node2], 5);
}
}