Merge native programs parts into one unit (#7047)

programs/vote/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "solana-vote-program"
+version = "0.21.0"
+description = "Solana Vote program API"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+bincode = "1.2.0"
+log = "0.4.8"
+num-derive = "0.3"
+num-traits = "0.2"
+serde = "1.0.102"
+serde_derive = "1.0.102"
+solana-logger = { path = "../../logger", version = "0.21.0" }
+solana-metrics = { path = "../../metrics", version = "0.21.0" }
+solana-sdk = { path = "../../sdk", version = "0.21.0" }
+
+[lib]
+crate-type = ["lib", "cdylib"]
+name = "solana_vote_program"

programs/vote/src/lib.rs

@@ -0,0 +1,16 @@
+pub mod vote_instruction;
+pub mod vote_state;
+
+use crate::vote_instruction::process_instruction;
+
+const VOTE_PROGRAM_ID: [u8; 32] = [
+    7, 97, 72, 29, 53, 116, 116, 187, 124, 77, 118, 36, 235, 211, 189, 179, 216, 53, 94, 115, 209,
+    16, 67, 252, 13, 163, 83, 128, 0, 0, 0, 0,
+];
+
+solana_sdk::declare_program!(
+    VOTE_PROGRAM_ID,
+    "Vote111111111111111111111111111111111111111",
+    solana_vote_program,
+    process_instruction
+);

programs/vote/src/vote_instruction.rs

@@ -0,0 +1,292 @@
+//! Vote program
+//! Receive and processes votes from validators
+
+use crate::{
+    id,
+    vote_state::{self, Vote, VoteAuthorize, VoteInit, VoteState},
+};
+use log::*;
+use num_derive::{FromPrimitive, ToPrimitive};
+use serde_derive::{Deserialize, Serialize};
+use solana_metrics::datapoint_debug;
+use solana_sdk::{
+    account::{get_signers, KeyedAccount},
+    instruction::{AccountMeta, Instruction, InstructionError, WithSigner},
+    instruction_processor_utils::{limited_deserialize, next_keyed_account, DecodeError},
+    pubkey::Pubkey,
+    system_instruction,
+    sysvar::{self, clock::Clock, slot_hashes::SlotHashes, Sysvar},
+};
+
+/// Reasons the stake might have had an error
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, FromPrimitive, ToPrimitive)]
+pub enum VoteError {
+    VoteTooOld,
+    SlotsMismatch,
+    SlotHashMismatch,
+    EmptySlots,
+}
+impl<E> DecodeError<E> for VoteError {
+    fn type_of() -> &'static str {
+        "VoteError"
+    }
+}
+
+impl std::fmt::Display for VoteError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                VoteError::VoteTooOld => "vote already recorded or not in slot hashes history",
+                VoteError::SlotsMismatch => "vote slots do not match bank history",
+                VoteError::SlotHashMismatch => "vote hash does not match bank hash",
+                VoteError::EmptySlots => "vote has no slots, invalid",
+            }
+        )
+    }
+}
+impl std::error::Error for VoteError {}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
+pub enum VoteInstruction {
+    /// Initialize the VoteState for this `vote account`
+    InitializeAccount(VoteInit),
+
+    /// Authorize a voter to send signed votes or a withdrawer
+    ///  to withdraw
+    Authorize(Pubkey, VoteAuthorize),
+
+    /// A Vote instruction with recent votes
+    Vote(Vote),
+
+    /// Withdraw some amount of funds
+    Withdraw(u64),
+}
+
+fn initialize_account(vote_pubkey: &Pubkey, vote_init: &VoteInit) -> Instruction {
+    let account_metas = vec![
+        AccountMeta::new(*vote_pubkey, false),
+        AccountMeta::new(sysvar::rent::id(), false),
+    ];
+    Instruction::new(
+        id(),
+        &VoteInstruction::InitializeAccount(*vote_init),
+        account_metas,
+    )
+}
+
+pub fn create_account(
+    from_pubkey: &Pubkey,
+    vote_pubkey: &Pubkey,
+    vote_init: &VoteInit,
+    lamports: u64,
+) -> Vec<Instruction> {
+    let space = VoteState::size_of() as u64;
+    let create_ix =
+        system_instruction::create_account(from_pubkey, vote_pubkey, lamports, space, &id());
+    let init_ix = initialize_account(vote_pubkey, vote_init);
+    vec![create_ix, init_ix]
+}
+
+pub fn authorize(
+    vote_pubkey: &Pubkey,
+    authorized_pubkey: &Pubkey, // currently authorized
+    new_authorized_pubkey: &Pubkey,
+    vote_authorize: VoteAuthorize,
+) -> Instruction {
+    let account_metas = vec![AccountMeta::new(*vote_pubkey, false)].with_signer(authorized_pubkey);
+
+    Instruction::new(
+        id(),
+        &VoteInstruction::Authorize(*new_authorized_pubkey, vote_authorize),
+        account_metas,
+    )
+}
+
+pub fn vote(vote_pubkey: &Pubkey, authorized_voter_pubkey: &Pubkey, vote: Vote) -> Instruction {
+    let account_metas = vec![
+        AccountMeta::new(*vote_pubkey, false),
+        AccountMeta::new_readonly(sysvar::slot_hashes::id(), false),
+        AccountMeta::new_readonly(sysvar::clock::id(), false),
+    ]
+    .with_signer(authorized_voter_pubkey);
+
+    Instruction::new(id(), &VoteInstruction::Vote(vote), account_metas)
+}
+
+pub fn withdraw(
+    vote_pubkey: &Pubkey,
+    withdrawer_pubkey: &Pubkey,
+    lamports: u64,
+    to_pubkey: &Pubkey,
+) -> Instruction {
+    let account_metas = vec![
+        AccountMeta::new(*vote_pubkey, false),
+        AccountMeta::new(*to_pubkey, false),
+    ]
+    .with_signer(withdrawer_pubkey);
+
+    Instruction::new(id(), &VoteInstruction::Withdraw(lamports), account_metas)
+}
+
+pub fn process_instruction(
+    _program_id: &Pubkey,
+    keyed_accounts: &mut [KeyedAccount],
+    data: &[u8],
+) -> Result<(), InstructionError> {
+    solana_logger::setup_with_filter("solana=info");
+
+    trace!("process_instruction: {:?}", data);
+    trace!("keyed_accounts: {:?}", keyed_accounts);
+
+    let signers = get_signers(keyed_accounts);
+
+    let keyed_accounts = &mut keyed_accounts.iter_mut();
+    let me = &mut next_keyed_account(keyed_accounts)?;
+
+    match limited_deserialize(data)? {
+        VoteInstruction::InitializeAccount(vote_init) => {
+            sysvar::rent::verify_rent_exemption(me, next_keyed_account(keyed_accounts)?)?;
+            vote_state::initialize_account(me, &vote_init)
+        }
+        VoteInstruction::Authorize(voter_pubkey, vote_authorize) => {
+            vote_state::authorize(me, &voter_pubkey, vote_authorize, &signers)
+        }
+        VoteInstruction::Vote(vote) => {
+            datapoint_debug!("vote-native", ("count", 1, i64));
+            vote_state::process_vote(
+                me,
+                &SlotHashes::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
+                &Clock::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
+                &vote,
+                &signers,
+            )
+        }
+        VoteInstruction::Withdraw(lamports) => {
+            let to = next_keyed_account(keyed_accounts)?;
+            vote_state::withdraw(me, lamports, to, &signers)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use solana_sdk::account::Account;
+    use solana_sdk::rent::Rent;
+
+    // these are for 100% coverage in this file
+    #[test]
+    fn test_vote_process_instruction_decode_bail() {
+        assert_eq!(
+            super::process_instruction(&Pubkey::default(), &mut [], &[],),
+            Err(InstructionError::NotEnoughAccountKeys),
+        );
+    }
+
+    fn process_instruction(instruction: &Instruction) -> Result<(), InstructionError> {
+        let mut accounts: Vec<_> = instruction
+            .accounts
+            .iter()
+            .map(|meta| {
+                if sysvar::clock::check_id(&meta.pubkey) {
+                    sysvar::clock::create_account(1, 0, 0, 0, 0)
+                } else if sysvar::slot_hashes::check_id(&meta.pubkey) {
+                    sysvar::slot_hashes::create_account(1, &[])
+                } else if sysvar::rent::check_id(&meta.pubkey) {
+                    Rent::default().create_account(1)
+                } else {
+                    Account::default()
+                }
+            })
+            .collect();
+
+        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();
+            super::process_instruction(&Pubkey::default(), &mut keyed_accounts, &instruction.data)
+        }
+    }
+
+    #[test]
+    fn test_vote_process_instruction() {
+        let instructions = create_account(
+            &Pubkey::default(),
+            &Pubkey::default(),
+            &VoteInit::default(),
+            100,
+        );
+        assert_eq!(
+            process_instruction(&instructions[1]),
+            Err(InstructionError::InvalidAccountData),
+        );
+        assert_eq!(
+            process_instruction(&vote(
+                &Pubkey::default(),
+                &Pubkey::default(),
+                Vote::default(),
+            )),
+            Err(InstructionError::InvalidAccountData),
+        );
+        assert_eq!(
+            process_instruction(&authorize(
+                &Pubkey::default(),
+                &Pubkey::default(),
+                &Pubkey::default(),
+                VoteAuthorize::Voter,
+            )),
+            Err(InstructionError::InvalidAccountData),
+        );
+        assert_eq!(
+            process_instruction(&withdraw(
+                &Pubkey::default(),
+                &Pubkey::default(),
+                0,
+                &Pubkey::default()
+            )),
+            Err(InstructionError::InvalidAccountData),
+        );
+    }
+
+    #[test]
+    fn test_minimum_balance() {
+        let rent = solana_sdk::rent::Rent::default();
+        let minimum_balance = rent.minimum_balance(VoteState::size_of());
+        // vote state cheaper than "my $0.02" ;)
+        assert!(minimum_balance as f64 / 10f64.powf(9.0) < 0.02)
+    }
+
+    #[test]
+    fn test_custom_error_decode() {
+        use num_traits::FromPrimitive;
+        fn pretty_err<T>(err: InstructionError) -> String
+        where
+            T: 'static + std::error::Error + DecodeError<T> + FromPrimitive,
+        {
+            if let InstructionError::CustomError(code) = err {
+                let specific_error: T = T::decode_custom_error_to_enum(code).unwrap();
+                format!(
+                    "{:?}: {}::{:?} - {}",
+                    err,
+                    T::type_of(),
+                    specific_error,
+                    specific_error,
+                )
+            } else {
+                "".to_string()
+            }
+        }
+        assert_eq!(
+            "CustomError(0): VoteError::VoteTooOld - vote already recorded or not in slot hashes history",
+            pretty_err::<VoteError>(VoteError::VoteTooOld.into())
+        )
+    }
+}