2019-04-10 17:52:47 -07:00
|
|
|
//! Vote program
|
|
|
|
//! Receive and processes votes from validators
|
|
|
|
|
2019-03-02 13:51:26 -08:00
|
|
|
use crate::id;
|
2019-04-10 17:52:47 -07:00
|
|
|
use crate::vote_state::{self, Vote, VoteState};
|
|
|
|
use bincode::deserialize;
|
|
|
|
use log::*;
|
2019-03-02 13:51:26 -08:00
|
|
|
use serde_derive::{Deserialize, Serialize};
|
2019-05-17 17:34:05 -07:00
|
|
|
use solana_metrics::datapoint_warn;
|
2019-04-10 17:52:47 -07:00
|
|
|
use solana_sdk::account::KeyedAccount;
|
|
|
|
use solana_sdk::instruction::{AccountMeta, Instruction, InstructionError};
|
2019-03-02 13:51:26 -08:00
|
|
|
use solana_sdk::pubkey::Pubkey;
|
2019-06-21 20:43:24 -07:00
|
|
|
use solana_sdk::syscall;
|
2019-04-03 08:45:57 -07:00
|
|
|
use solana_sdk::system_instruction;
|
2019-03-02 13:51:26 -08:00
|
|
|
|
|
|
|
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
|
|
|
|
pub enum VoteInstruction {
|
|
|
|
/// Initialize the VoteState for this `vote account`
|
2019-05-23 23:20:04 -07:00
|
|
|
/// takes a node_pubkey and commission
|
2019-04-10 17:52:47 -07:00
|
|
|
InitializeAccount(Pubkey, u32),
|
2019-03-25 19:57:25 -07:00
|
|
|
|
2019-03-06 13:33:12 -08:00
|
|
|
/// Authorize a voter to send signed votes.
|
|
|
|
AuthorizeVoter(Pubkey),
|
2019-03-25 19:57:25 -07:00
|
|
|
|
2019-04-11 14:48:36 -07:00
|
|
|
/// A Vote instruction with recent votes
|
|
|
|
Vote(Vec<Vote>),
|
2019-03-02 13:51:26 -08:00
|
|
|
}
|
|
|
|
|
2019-05-31 11:45:17 -07:00
|
|
|
fn initialize_account(vote_pubkey: &Pubkey, node_pubkey: &Pubkey, commission: u32) -> Instruction {
|
|
|
|
let account_metas = vec![AccountMeta::new(*vote_pubkey, false)];
|
2019-04-03 08:45:57 -07:00
|
|
|
Instruction::new(
|
|
|
|
id(),
|
2019-05-23 23:20:04 -07:00
|
|
|
&VoteInstruction::InitializeAccount(*node_pubkey, commission),
|
2019-04-03 08:45:57 -07:00
|
|
|
account_metas,
|
|
|
|
)
|
|
|
|
}
|
2019-03-25 19:57:25 -07:00
|
|
|
|
2019-04-10 17:52:47 -07:00
|
|
|
pub fn create_account(
|
2019-05-23 23:20:04 -07:00
|
|
|
from_pubkey: &Pubkey,
|
|
|
|
vote_pubkey: &Pubkey,
|
|
|
|
node_pubkey: &Pubkey,
|
2019-04-10 17:52:47 -07:00
|
|
|
commission: u32,
|
|
|
|
lamports: u64,
|
|
|
|
) -> Vec<Instruction> {
|
|
|
|
let space = VoteState::size_of() as u64;
|
2019-05-23 23:20:04 -07:00
|
|
|
let create_ix =
|
|
|
|
system_instruction::create_account(from_pubkey, vote_pubkey, lamports, space, &id());
|
2019-05-31 11:45:17 -07:00
|
|
|
let init_ix = initialize_account(vote_pubkey, node_pubkey, commission);
|
2019-04-10 17:52:47 -07:00
|
|
|
vec![create_ix, init_ix]
|
|
|
|
}
|
|
|
|
|
2019-05-20 13:32:32 -07:00
|
|
|
fn metas_for_authorized_signer(
|
2019-05-23 23:20:04 -07:00
|
|
|
vote_pubkey: &Pubkey,
|
|
|
|
authorized_voter_pubkey: &Pubkey, // currently authorized
|
2019-06-21 20:43:24 -07:00
|
|
|
other_params: &[AccountMeta],
|
2019-05-20 13:32:32 -07:00
|
|
|
) -> Vec<AccountMeta> {
|
2019-05-23 23:20:04 -07:00
|
|
|
let is_own_signer = authorized_voter_pubkey == vote_pubkey;
|
2019-05-20 13:32:32 -07:00
|
|
|
|
2019-05-31 11:45:17 -07:00
|
|
|
// vote account
|
|
|
|
let mut account_metas = vec![AccountMeta::new(*vote_pubkey, is_own_signer)];
|
2019-05-20 13:32:32 -07:00
|
|
|
|
2019-06-21 20:43:24 -07:00
|
|
|
for meta in other_params {
|
|
|
|
account_metas.push(meta.clone());
|
|
|
|
}
|
|
|
|
|
|
|
|
// append signer at the end
|
2019-05-20 13:32:32 -07:00
|
|
|
if !is_own_signer {
|
2019-05-23 23:20:04 -07:00
|
|
|
account_metas.push(AccountMeta::new(*authorized_voter_pubkey, true)) // signer
|
2019-05-20 13:32:32 -07:00
|
|
|
}
|
2019-06-21 20:43:24 -07:00
|
|
|
|
2019-05-20 13:32:32 -07:00
|
|
|
account_metas
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn authorize_voter(
|
2019-05-23 23:20:04 -07:00
|
|
|
vote_pubkey: &Pubkey,
|
|
|
|
authorized_voter_pubkey: &Pubkey, // currently authorized
|
|
|
|
new_authorized_voter_pubkey: &Pubkey,
|
2019-05-20 13:32:32 -07:00
|
|
|
) -> Instruction {
|
2019-06-21 20:43:24 -07:00
|
|
|
let account_metas = metas_for_authorized_signer(vote_pubkey, authorized_voter_pubkey, &[]);
|
2019-05-20 13:32:32 -07:00
|
|
|
|
2019-04-03 08:45:57 -07:00
|
|
|
Instruction::new(
|
|
|
|
id(),
|
2019-05-23 23:20:04 -07:00
|
|
|
&VoteInstruction::AuthorizeVoter(*new_authorized_voter_pubkey),
|
2019-04-03 08:45:57 -07:00
|
|
|
account_metas,
|
|
|
|
)
|
|
|
|
}
|
2019-03-25 19:57:25 -07:00
|
|
|
|
2019-05-20 13:32:32 -07:00
|
|
|
pub fn vote(
|
2019-05-23 23:20:04 -07:00
|
|
|
vote_pubkey: &Pubkey,
|
|
|
|
authorized_voter_pubkey: &Pubkey,
|
2019-05-20 13:32:32 -07:00
|
|
|
recent_votes: Vec<Vote>,
|
|
|
|
) -> Instruction {
|
2019-06-21 20:43:24 -07:00
|
|
|
let account_metas = metas_for_authorized_signer(
|
|
|
|
vote_pubkey,
|
|
|
|
authorized_voter_pubkey,
|
|
|
|
&[
|
|
|
|
// request slot_hashes syscall account after vote_pubkey
|
|
|
|
AccountMeta::new(syscall::slot_hashes::id(), false),
|
|
|
|
// request current syscall account after that
|
|
|
|
AccountMeta::new(syscall::current::id(), false),
|
|
|
|
],
|
|
|
|
);
|
2019-05-20 13:32:32 -07:00
|
|
|
|
2019-04-11 14:48:36 -07:00
|
|
|
Instruction::new(id(), &VoteInstruction::Vote(recent_votes), account_metas)
|
2019-03-02 13:51:26 -08:00
|
|
|
}
|
2019-04-10 17:52:47 -07:00
|
|
|
|
|
|
|
pub fn process_instruction(
|
|
|
|
_program_id: &Pubkey,
|
|
|
|
keyed_accounts: &mut [KeyedAccount],
|
|
|
|
data: &[u8],
|
|
|
|
) -> Result<(), InstructionError> {
|
|
|
|
solana_logger::setup();
|
|
|
|
|
|
|
|
trace!("process_instruction: {:?}", data);
|
|
|
|
trace!("keyed_accounts: {:?}", keyed_accounts);
|
|
|
|
|
2019-05-31 11:45:17 -07:00
|
|
|
if keyed_accounts.is_empty() {
|
2019-04-30 15:11:08 -07:00
|
|
|
Err(InstructionError::InvalidInstructionData)?;
|
|
|
|
}
|
|
|
|
|
2019-05-31 11:45:17 -07:00
|
|
|
// 0th index is vote account
|
|
|
|
let (me, rest) = &mut keyed_accounts.split_at_mut(1);
|
|
|
|
let me = &mut me[0];
|
2019-05-20 13:32:32 -07:00
|
|
|
|
|
|
|
// TODO: data-driven unpack and dispatch of KeyedAccounts
|
2019-04-10 17:52:47 -07:00
|
|
|
match deserialize(data).map_err(|_| InstructionError::InvalidInstructionData)? {
|
2019-05-23 23:20:04 -07:00
|
|
|
VoteInstruction::InitializeAccount(node_pubkey, commission) => {
|
|
|
|
vote_state::initialize_account(me, &node_pubkey, commission)
|
2019-04-10 17:52:47 -07:00
|
|
|
}
|
2019-05-23 23:20:04 -07:00
|
|
|
VoteInstruction::AuthorizeVoter(voter_pubkey) => {
|
|
|
|
vote_state::authorize_voter(me, rest, &voter_pubkey)
|
2019-04-10 17:52:47 -07:00
|
|
|
}
|
2019-04-30 15:11:08 -07:00
|
|
|
VoteInstruction::Vote(votes) => {
|
2019-05-17 17:34:05 -07:00
|
|
|
datapoint_warn!("vote-native", ("count", 1, i64));
|
2019-06-21 20:43:24 -07:00
|
|
|
if rest.len() < 2 {
|
|
|
|
Err(InstructionError::InvalidInstructionData)?;
|
|
|
|
}
|
|
|
|
let (slot_hashes_and_current, other_signers) = rest.split_at_mut(2);
|
|
|
|
|
|
|
|
vote_state::process_votes(
|
|
|
|
me,
|
|
|
|
&syscall::slot_hashes::from_keyed_account(&slot_hashes_and_current[0])?,
|
|
|
|
&syscall::current::from_keyed_account(&slot_hashes_and_current[1])?,
|
|
|
|
other_signers,
|
|
|
|
&votes,
|
|
|
|
)
|
2019-04-10 17:52:47 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2019-04-30 15:11:08 -07:00
|
|
|
use solana_sdk::account::Account;
|
2019-04-10 17:52:47 -07:00
|
|
|
|
2019-05-20 13:32:32 -07:00
|
|
|
// these are for 100% coverage in this file
|
2019-04-10 17:52:47 -07:00
|
|
|
#[test]
|
2019-04-30 15:11:08 -07:00
|
|
|
fn test_vote_process_instruction_decode_bail() {
|
|
|
|
assert_eq!(
|
2019-05-31 15:29:21 -07:00
|
|
|
super::process_instruction(&Pubkey::default(), &mut [], &[],),
|
2019-04-30 15:11:08 -07:00
|
|
|
Err(InstructionError::InvalidInstructionData),
|
|
|
|
);
|
2019-04-10 17:52:47 -07:00
|
|
|
}
|
|
|
|
|
2019-04-30 15:11:08 -07:00
|
|
|
fn process_instruction(instruction: &Instruction) -> Result<(), InstructionError> {
|
2019-06-21 20:43:24 -07:00
|
|
|
let mut accounts: Vec<_> = instruction
|
|
|
|
.accounts
|
|
|
|
.iter()
|
|
|
|
.map(|meta| {
|
|
|
|
if syscall::current::check_id(&meta.pubkey) {
|
|
|
|
syscall::current::create_account(1, 0, 0, 0)
|
|
|
|
} else if syscall::slot_hashes::check_id(&meta.pubkey) {
|
|
|
|
syscall::slot_hashes::create_account(1, &[])
|
|
|
|
} else {
|
|
|
|
Account::default()
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.collect();
|
|
|
|
|
2019-04-30 15:11:08 -07:00
|
|
|
for _ in 0..instruction.accounts.len() {
|
|
|
|
accounts.push(Account::default());
|
|
|
|
}
|
|
|
|
{
|
|
|
|
let mut keyed_accounts: Vec<_> = instruction
|
|
|
|
.accounts
|
|
|
|
.iter()
|
|
|
|
.zip(accounts.iter_mut())
|
|
|
|
.map(|(meta, account)| KeyedAccount::new(&meta.pubkey, meta.is_signer, account))
|
|
|
|
.collect();
|
2019-05-31 15:29:21 -07:00
|
|
|
super::process_instruction(&Pubkey::default(), &mut keyed_accounts, &instruction.data)
|
2019-04-30 15:11:08 -07:00
|
|
|
}
|
2019-04-10 17:52:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-04-30 15:11:08 -07:00
|
|
|
fn test_vote_process_instruction() {
|
|
|
|
let instructions = create_account(
|
|
|
|
&Pubkey::default(),
|
|
|
|
&Pubkey::default(),
|
|
|
|
&Pubkey::default(),
|
|
|
|
0,
|
|
|
|
100,
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
process_instruction(&instructions[1]),
|
|
|
|
Err(InstructionError::InvalidAccountData),
|
|
|
|
);
|
|
|
|
assert_eq!(
|
2019-05-20 13:32:32 -07:00
|
|
|
process_instruction(&vote(
|
|
|
|
&Pubkey::default(),
|
|
|
|
&Pubkey::default(),
|
|
|
|
vec![Vote::default()]
|
|
|
|
)),
|
2019-04-30 15:11:08 -07:00
|
|
|
Err(InstructionError::InvalidAccountData),
|
|
|
|
);
|
2019-04-10 17:52:47 -07:00
|
|
|
assert_eq!(
|
2019-05-20 13:32:32 -07:00
|
|
|
process_instruction(&authorize_voter(
|
|
|
|
&Pubkey::default(),
|
|
|
|
&Pubkey::default(),
|
|
|
|
&Pubkey::default(),
|
|
|
|
)),
|
2019-04-30 15:11:08 -07:00
|
|
|
Err(InstructionError::InvalidAccountData),
|
2019-04-10 17:52:47 -07:00
|
|
|
);
|
|
|
|
}
|
2019-04-30 15:11:08 -07:00
|
|
|
|
2019-04-10 17:52:47 -07:00
|
|
|
}
|