2019-04-01 16:45:53 -07:00
|
|
|
//! Stake state
|
|
|
|
//! * delegate stakes to vote accounts
|
|
|
|
//! * keep track of rewards
|
|
|
|
//! * own mining pools
|
|
|
|
|
2019-05-07 17:08:49 -07:00
|
|
|
use crate::id;
|
2019-04-01 16:45:53 -07:00
|
|
|
use serde_derive::{Deserialize, Serialize};
|
2019-05-07 17:08:49 -07:00
|
|
|
use solana_sdk::account::{Account, KeyedAccount};
|
2019-04-01 16:45:53 -07:00
|
|
|
use solana_sdk::instruction::InstructionError;
|
2019-04-04 12:01:09 -07:00
|
|
|
use solana_sdk::instruction_processor_utils::State;
|
2019-04-01 16:45:53 -07:00
|
|
|
use solana_sdk::pubkey::Pubkey;
|
|
|
|
use solana_vote_api::vote_state::VoteState;
|
|
|
|
|
|
|
|
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]
|
|
|
|
pub enum StakeState {
|
2019-05-21 07:32:38 -07:00
|
|
|
Uninitialized,
|
2019-04-01 16:45:53 -07:00
|
|
|
Delegate {
|
|
|
|
voter_id: Pubkey,
|
|
|
|
credits_observed: u64,
|
|
|
|
},
|
|
|
|
MiningPool,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for StakeState {
|
|
|
|
fn default() -> Self {
|
2019-05-21 07:32:38 -07:00
|
|
|
StakeState::Uninitialized
|
2019-04-01 16:45:53 -07:00
|
|
|
}
|
|
|
|
}
|
2019-04-07 21:45:28 -07:00
|
|
|
// TODO: trusted values of network parameters come from where?
|
|
|
|
const TICKS_PER_SECOND: f64 = 10f64;
|
|
|
|
const TICKS_PER_SLOT: f64 = 8f64;
|
|
|
|
|
|
|
|
// credits/yr or slots/yr is seconds/year * ticks/second * slots/tick
|
|
|
|
const CREDITS_PER_YEAR: f64 = (365f64 * 24f64 * 3600f64) * TICKS_PER_SECOND / TICKS_PER_SLOT;
|
|
|
|
|
|
|
|
// TODO: 20% is a niiice rate... TODO: make this a member of MiningPool?
|
|
|
|
const STAKE_REWARD_TARGET_RATE: f64 = 0.20;
|
|
|
|
|
|
|
|
#[cfg(test)]
|
2019-05-07 17:08:49 -07:00
|
|
|
const STAKE_GETS_PAID_EVERY_VOTE: u64 = 200_000_000; // if numbers above (TICKS_YEAR) move, fix this
|
2019-04-07 21:45:28 -07:00
|
|
|
|
|
|
|
impl StakeState {
|
2019-05-16 08:23:31 -07:00
|
|
|
// utility function, used by Stakes, tests
|
|
|
|
pub fn from(account: &Account) -> Option<StakeState> {
|
|
|
|
account.state().ok()
|
|
|
|
}
|
|
|
|
|
|
|
|
// utility function, used by Stakes, tests
|
|
|
|
pub fn voter_id_from(account: &Account) -> Option<Pubkey> {
|
|
|
|
Self::from(account).and_then(|state: Self| state.voter_id())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn voter_id(&self) -> Option<Pubkey> {
|
|
|
|
match self {
|
|
|
|
StakeState::Delegate { voter_id, .. } => Some(*voter_id),
|
|
|
|
_ => None,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-07 21:45:28 -07:00
|
|
|
pub fn calculate_rewards(
|
|
|
|
credits_observed: u64,
|
|
|
|
stake: u64,
|
|
|
|
vote_state: &VoteState,
|
|
|
|
) -> Option<(u64, u64)> {
|
|
|
|
if credits_observed >= vote_state.credits() {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
let total_rewards = stake as f64
|
|
|
|
* STAKE_REWARD_TARGET_RATE
|
|
|
|
* (vote_state.credits() - credits_observed) as f64
|
|
|
|
/ CREDITS_PER_YEAR;
|
|
|
|
|
|
|
|
// don't bother trying to collect fractional lamports
|
|
|
|
if total_rewards < 1f64 {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
let (voter_rewards, staker_rewards, is_split) = vote_state.commission_split(total_rewards);
|
|
|
|
|
|
|
|
if (voter_rewards < 1f64 || staker_rewards < 1f64) && is_split {
|
|
|
|
// don't bother trying to collect fractional lamports
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
Some((voter_rewards as u64, staker_rewards as u64))
|
|
|
|
}
|
|
|
|
}
|
2019-04-01 16:45:53 -07:00
|
|
|
|
|
|
|
pub trait StakeAccount {
|
2019-05-21 07:32:38 -07:00
|
|
|
fn initialize_mining_pool(&mut self) -> Result<(), InstructionError>;
|
|
|
|
fn initialize_delegate(&mut self) -> Result<(), InstructionError>;
|
2019-04-01 16:45:53 -07:00
|
|
|
fn delegate_stake(&mut self, vote_account: &KeyedAccount) -> Result<(), InstructionError>;
|
|
|
|
fn redeem_vote_credits(
|
|
|
|
&mut self,
|
|
|
|
stake_account: &mut KeyedAccount,
|
2019-04-07 21:45:28 -07:00
|
|
|
vote_account: &mut KeyedAccount,
|
2019-04-01 16:45:53 -07:00
|
|
|
) -> Result<(), InstructionError>;
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> StakeAccount for KeyedAccount<'a> {
|
2019-05-21 07:32:38 -07:00
|
|
|
fn initialize_mining_pool(&mut self) -> Result<(), InstructionError> {
|
|
|
|
if let StakeState::Uninitialized = self.state()? {
|
|
|
|
self.set_state(&StakeState::MiningPool)
|
|
|
|
} else {
|
|
|
|
Err(InstructionError::InvalidAccountData)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fn initialize_delegate(&mut self) -> Result<(), InstructionError> {
|
|
|
|
if let StakeState::Uninitialized = self.state()? {
|
|
|
|
self.set_state(&StakeState::Delegate {
|
|
|
|
voter_id: Pubkey::default(),
|
|
|
|
credits_observed: 0,
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
Err(InstructionError::InvalidAccountData)
|
|
|
|
}
|
|
|
|
}
|
2019-04-01 16:45:53 -07:00
|
|
|
fn delegate_stake(&mut self, vote_account: &KeyedAccount) -> Result<(), InstructionError> {
|
|
|
|
if self.signer_key().is_none() {
|
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
|
|
|
}
|
|
|
|
|
|
|
|
if let StakeState::Delegate { .. } = self.state()? {
|
|
|
|
let vote_state: VoteState = vote_account.state()?;
|
|
|
|
self.set_state(&StakeState::Delegate {
|
|
|
|
voter_id: *vote_account.unsigned_key(),
|
|
|
|
credits_observed: vote_state.credits(),
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
Err(InstructionError::InvalidAccountData)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn redeem_vote_credits(
|
|
|
|
&mut self,
|
|
|
|
stake_account: &mut KeyedAccount,
|
2019-04-07 21:45:28 -07:00
|
|
|
vote_account: &mut KeyedAccount,
|
2019-04-01 16:45:53 -07:00
|
|
|
) -> Result<(), InstructionError> {
|
|
|
|
if let (
|
|
|
|
StakeState::MiningPool,
|
|
|
|
StakeState::Delegate {
|
|
|
|
voter_id,
|
2019-04-07 21:45:28 -07:00
|
|
|
credits_observed,
|
2019-04-01 16:45:53 -07:00
|
|
|
},
|
|
|
|
) = (self.state()?, stake_account.state()?)
|
|
|
|
{
|
|
|
|
let vote_state: VoteState = vote_account.state()?;
|
|
|
|
|
|
|
|
if voter_id != *vote_account.unsigned_key() {
|
|
|
|
return Err(InstructionError::InvalidArgument);
|
|
|
|
}
|
|
|
|
|
|
|
|
if credits_observed > vote_state.credits() {
|
|
|
|
return Err(InstructionError::InvalidAccountData);
|
|
|
|
}
|
|
|
|
|
2019-04-07 21:45:28 -07:00
|
|
|
if let Some((stakers_reward, voters_reward)) = StakeState::calculate_rewards(
|
2019-04-01 16:45:53 -07:00
|
|
|
credits_observed,
|
2019-04-07 21:45:28 -07:00
|
|
|
stake_account.account.lamports,
|
|
|
|
&vote_state,
|
|
|
|
) {
|
|
|
|
if self.account.lamports < (stakers_reward + voters_reward) {
|
|
|
|
return Err(InstructionError::UnbalancedInstruction);
|
|
|
|
}
|
|
|
|
self.account.lamports -= stakers_reward + voters_reward;
|
|
|
|
stake_account.account.lamports += stakers_reward;
|
|
|
|
vote_account.account.lamports += voters_reward;
|
|
|
|
|
|
|
|
stake_account.set_state(&StakeState::Delegate {
|
|
|
|
voter_id,
|
|
|
|
credits_observed: vote_state.credits(),
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
// not worth collecting
|
2019-05-21 07:32:38 -07:00
|
|
|
Err(InstructionError::CustomError(1))
|
2019-04-07 21:45:28 -07:00
|
|
|
}
|
2019-04-01 16:45:53 -07:00
|
|
|
} else {
|
|
|
|
Err(InstructionError::InvalidAccountData)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-07 17:08:49 -07:00
|
|
|
// utility function, used by Bank, tests, genesis
|
|
|
|
pub fn create_delegate_stake_account(
|
|
|
|
voter_id: &Pubkey,
|
|
|
|
vote_state: &VoteState,
|
|
|
|
lamports: u64,
|
|
|
|
) -> Account {
|
|
|
|
let mut stake_account = Account::new(lamports, std::mem::size_of::<StakeState>(), &id());
|
|
|
|
|
|
|
|
stake_account
|
|
|
|
.set_state(&StakeState::Delegate {
|
|
|
|
voter_id: *voter_id,
|
|
|
|
credits_observed: vote_state.credits(),
|
|
|
|
})
|
|
|
|
.expect("set_state");
|
|
|
|
|
|
|
|
stake_account
|
|
|
|
}
|
|
|
|
|
2019-04-01 16:45:53 -07:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
use crate::id;
|
|
|
|
use solana_sdk::account::Account;
|
2019-04-10 17:52:47 -07:00
|
|
|
use solana_sdk::pubkey::Pubkey;
|
2019-04-01 16:45:53 -07:00
|
|
|
use solana_sdk::signature::{Keypair, KeypairUtil};
|
2019-04-10 17:52:47 -07:00
|
|
|
use solana_vote_api::vote_state::{self, Vote};
|
2019-04-01 16:45:53 -07:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_stake_delegate_stake() {
|
|
|
|
let vote_keypair = Keypair::new();
|
|
|
|
let mut vote_state = VoteState::default();
|
|
|
|
for i in 0..1000 {
|
2019-04-10 17:52:47 -07:00
|
|
|
vote_state.process_vote(&Vote::new(i));
|
2019-04-01 16:45:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
let vote_pubkey = vote_keypair.pubkey();
|
2019-04-10 17:52:47 -07:00
|
|
|
let mut vote_account =
|
|
|
|
vote_state::create_account(&vote_pubkey, &Pubkey::new_rand(), 0, 100);
|
2019-04-01 16:45:53 -07:00
|
|
|
let mut vote_keyed_account = KeyedAccount::new(&vote_pubkey, false, &mut vote_account);
|
|
|
|
vote_keyed_account.set_state(&vote_state).unwrap();
|
|
|
|
|
|
|
|
let stake_pubkey = Pubkey::default();
|
|
|
|
let mut stake_account = Account::new(0, std::mem::size_of::<StakeState>(), &id());
|
|
|
|
|
|
|
|
let mut stake_keyed_account = KeyedAccount::new(&stake_pubkey, false, &mut stake_account);
|
|
|
|
|
2019-05-07 17:08:49 -07:00
|
|
|
{
|
|
|
|
let stake_state: StakeState = stake_keyed_account.state().unwrap();
|
|
|
|
assert_eq!(stake_state, StakeState::default());
|
|
|
|
}
|
|
|
|
|
2019-05-21 07:32:38 -07:00
|
|
|
stake_keyed_account.initialize_delegate().unwrap();
|
2019-04-01 16:45:53 -07:00
|
|
|
assert_eq!(
|
|
|
|
stake_keyed_account.delegate_stake(&vote_keyed_account),
|
|
|
|
Err(InstructionError::MissingRequiredSignature)
|
|
|
|
);
|
|
|
|
|
|
|
|
let mut stake_keyed_account = KeyedAccount::new(&stake_pubkey, true, &mut stake_account);
|
|
|
|
assert!(stake_keyed_account
|
|
|
|
.delegate_stake(&vote_keyed_account)
|
|
|
|
.is_ok());
|
|
|
|
|
2019-05-07 17:08:49 -07:00
|
|
|
// verify that create_delegate_stake_account() matches the
|
|
|
|
// resulting account from delegate_stake()
|
|
|
|
assert_eq!(
|
|
|
|
create_delegate_stake_account(&vote_pubkey, &vote_state, 0),
|
|
|
|
*stake_keyed_account.account,
|
|
|
|
);
|
|
|
|
|
2019-04-01 16:45:53 -07:00
|
|
|
let stake_state: StakeState = stake_keyed_account.state().unwrap();
|
|
|
|
assert_eq!(
|
|
|
|
stake_state,
|
|
|
|
StakeState::Delegate {
|
|
|
|
voter_id: vote_keypair.pubkey(),
|
|
|
|
credits_observed: vote_state.credits()
|
|
|
|
}
|
|
|
|
);
|
2019-05-07 17:08:49 -07:00
|
|
|
|
2019-04-01 16:45:53 -07:00
|
|
|
let stake_state = StakeState::MiningPool;
|
|
|
|
stake_keyed_account.set_state(&stake_state).unwrap();
|
|
|
|
assert!(stake_keyed_account
|
|
|
|
.delegate_stake(&vote_keyed_account)
|
|
|
|
.is_err());
|
|
|
|
}
|
2019-04-07 21:45:28 -07:00
|
|
|
#[test]
|
|
|
|
fn test_stake_state_calculate_rewards() {
|
|
|
|
let mut vote_state = VoteState::default();
|
|
|
|
let mut vote_i = 0;
|
|
|
|
|
|
|
|
// put a credit in the vote_state
|
|
|
|
while vote_state.credits() == 0 {
|
2019-04-10 17:52:47 -07:00
|
|
|
vote_state.process_vote(&Vote::new(vote_i));
|
2019-04-07 21:45:28 -07:00
|
|
|
vote_i += 1;
|
|
|
|
}
|
|
|
|
// this guy can't collect now, not enough stake to get paid on 1 credit
|
|
|
|
assert_eq!(None, StakeState::calculate_rewards(0, 100, &vote_state));
|
|
|
|
// this guy can
|
|
|
|
assert_eq!(
|
|
|
|
Some((0, 1)),
|
|
|
|
StakeState::calculate_rewards(0, STAKE_GETS_PAID_EVERY_VOTE, &vote_state)
|
|
|
|
);
|
|
|
|
// but, there's not enough to split
|
|
|
|
vote_state.commission = std::u32::MAX / 2;
|
|
|
|
assert_eq!(
|
|
|
|
None,
|
|
|
|
StakeState::calculate_rewards(0, STAKE_GETS_PAID_EVERY_VOTE, &vote_state)
|
|
|
|
);
|
|
|
|
|
|
|
|
// put more credit in the vote_state
|
|
|
|
while vote_state.credits() < 10 {
|
2019-04-10 17:52:47 -07:00
|
|
|
vote_state.process_vote(&Vote::new(vote_i));
|
2019-04-07 21:45:28 -07:00
|
|
|
vote_i += 1;
|
|
|
|
}
|
|
|
|
vote_state.commission = 0;
|
|
|
|
assert_eq!(
|
|
|
|
Some((0, 10)),
|
|
|
|
StakeState::calculate_rewards(0, STAKE_GETS_PAID_EVERY_VOTE, &vote_state)
|
|
|
|
);
|
|
|
|
vote_state.commission = std::u32::MAX;
|
|
|
|
assert_eq!(
|
|
|
|
Some((10, 0)),
|
|
|
|
StakeState::calculate_rewards(0, STAKE_GETS_PAID_EVERY_VOTE, &vote_state)
|
|
|
|
);
|
|
|
|
vote_state.commission = std::u32::MAX / 2;
|
|
|
|
assert_eq!(
|
|
|
|
Some((5, 5)),
|
|
|
|
StakeState::calculate_rewards(0, STAKE_GETS_PAID_EVERY_VOTE, &vote_state)
|
|
|
|
);
|
|
|
|
// not even enough stake to get paid on 10 credits...
|
|
|
|
assert_eq!(None, StakeState::calculate_rewards(0, 100, &vote_state));
|
|
|
|
}
|
2019-04-01 16:45:53 -07:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_stake_redeem_vote_credits() {
|
|
|
|
let vote_keypair = Keypair::new();
|
|
|
|
let mut vote_state = VoteState::default();
|
|
|
|
for i in 0..1000 {
|
2019-04-10 17:52:47 -07:00
|
|
|
vote_state.process_vote(&Vote::new(i));
|
2019-04-01 16:45:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
let vote_pubkey = vote_keypair.pubkey();
|
2019-04-10 17:52:47 -07:00
|
|
|
let mut vote_account =
|
|
|
|
vote_state::create_account(&vote_pubkey, &Pubkey::new_rand(), 0, 100);
|
2019-04-01 16:45:53 -07:00
|
|
|
let mut vote_keyed_account = KeyedAccount::new(&vote_pubkey, false, &mut vote_account);
|
|
|
|
vote_keyed_account.set_state(&vote_state).unwrap();
|
|
|
|
|
|
|
|
let pubkey = Pubkey::default();
|
2019-04-07 21:45:28 -07:00
|
|
|
let mut stake_account = Account::new(
|
|
|
|
STAKE_GETS_PAID_EVERY_VOTE,
|
|
|
|
std::mem::size_of::<StakeState>(),
|
|
|
|
&id(),
|
|
|
|
);
|
2019-04-01 16:45:53 -07:00
|
|
|
let mut stake_keyed_account = KeyedAccount::new(&pubkey, true, &mut stake_account);
|
2019-05-21 07:32:38 -07:00
|
|
|
stake_keyed_account.initialize_delegate().unwrap();
|
2019-04-01 16:45:53 -07:00
|
|
|
|
|
|
|
// delegate the stake
|
|
|
|
assert!(stake_keyed_account
|
|
|
|
.delegate_stake(&vote_keyed_account)
|
|
|
|
.is_ok());
|
|
|
|
|
|
|
|
let mut mining_pool_account = Account::new(0, std::mem::size_of::<StakeState>(), &id());
|
|
|
|
let mut mining_pool_keyed_account =
|
|
|
|
KeyedAccount::new(&pubkey, true, &mut mining_pool_account);
|
|
|
|
|
2019-04-07 21:45:28 -07:00
|
|
|
// not a mining pool yet...
|
2019-04-01 16:45:53 -07:00
|
|
|
assert_eq!(
|
|
|
|
mining_pool_keyed_account
|
2019-04-07 21:45:28 -07:00
|
|
|
.redeem_vote_credits(&mut stake_keyed_account, &mut vote_keyed_account),
|
2019-04-01 16:45:53 -07:00
|
|
|
Err(InstructionError::InvalidAccountData)
|
|
|
|
);
|
|
|
|
|
|
|
|
mining_pool_keyed_account
|
|
|
|
.set_state(&StakeState::MiningPool)
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
// no movement in vote account, so no redemption needed
|
2019-05-21 07:32:38 -07:00
|
|
|
assert_eq!(
|
|
|
|
mining_pool_keyed_account
|
|
|
|
.redeem_vote_credits(&mut stake_keyed_account, &mut vote_keyed_account),
|
|
|
|
Err(InstructionError::CustomError(1))
|
|
|
|
);
|
2019-04-01 16:45:53 -07:00
|
|
|
|
|
|
|
// move the vote account forward
|
2019-04-10 17:52:47 -07:00
|
|
|
vote_state.process_vote(&Vote::new(1000));
|
2019-04-01 16:45:53 -07:00
|
|
|
vote_keyed_account.set_state(&vote_state).unwrap();
|
|
|
|
|
2019-04-07 21:45:28 -07:00
|
|
|
// now, no lamports in the pool!
|
2019-04-01 16:45:53 -07:00
|
|
|
assert_eq!(
|
|
|
|
mining_pool_keyed_account
|
2019-04-07 21:45:28 -07:00
|
|
|
.redeem_vote_credits(&mut stake_keyed_account, &mut vote_keyed_account),
|
2019-04-01 16:45:53 -07:00
|
|
|
Err(InstructionError::UnbalancedInstruction)
|
|
|
|
);
|
|
|
|
|
2019-04-07 21:45:28 -07:00
|
|
|
// add a lamport to pool
|
2019-04-01 16:45:53 -07:00
|
|
|
mining_pool_keyed_account.account.lamports = 2;
|
|
|
|
assert!(mining_pool_keyed_account
|
2019-04-07 21:45:28 -07:00
|
|
|
.redeem_vote_credits(&mut stake_keyed_account, &mut vote_keyed_account)
|
|
|
|
.is_ok()); // yay
|
|
|
|
|
|
|
|
// lamports only shifted around, none made or lost
|
|
|
|
assert_eq!(
|
|
|
|
2 + 100 + STAKE_GETS_PAID_EVERY_VOTE,
|
|
|
|
mining_pool_account.lamports + vote_account.lamports + stake_account.lamports
|
|
|
|
);
|
2019-04-01 16:45:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_stake_redeem_vote_credits_vote_errors() {
|
|
|
|
let vote_keypair = Keypair::new();
|
|
|
|
let mut vote_state = VoteState::default();
|
|
|
|
for i in 0..1000 {
|
2019-04-10 17:52:47 -07:00
|
|
|
vote_state.process_vote(&Vote::new(i));
|
2019-04-01 16:45:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
let vote_pubkey = vote_keypair.pubkey();
|
2019-04-10 17:52:47 -07:00
|
|
|
let mut vote_account =
|
|
|
|
vote_state::create_account(&vote_pubkey, &Pubkey::new_rand(), 0, 100);
|
2019-04-01 16:45:53 -07:00
|
|
|
let mut vote_keyed_account = KeyedAccount::new(&vote_pubkey, false, &mut vote_account);
|
|
|
|
vote_keyed_account.set_state(&vote_state).unwrap();
|
|
|
|
|
|
|
|
let pubkey = Pubkey::default();
|
|
|
|
let mut stake_account = Account::new(0, std::mem::size_of::<StakeState>(), &id());
|
|
|
|
let mut stake_keyed_account = KeyedAccount::new(&pubkey, true, &mut stake_account);
|
2019-05-21 07:32:38 -07:00
|
|
|
stake_keyed_account.initialize_delegate().unwrap();
|
2019-04-01 16:45:53 -07:00
|
|
|
|
|
|
|
// delegate the stake
|
|
|
|
assert!(stake_keyed_account
|
|
|
|
.delegate_stake(&vote_keyed_account)
|
|
|
|
.is_ok());
|
|
|
|
|
|
|
|
let mut mining_pool_account = Account::new(0, std::mem::size_of::<StakeState>(), &id());
|
|
|
|
let mut mining_pool_keyed_account =
|
|
|
|
KeyedAccount::new(&pubkey, true, &mut mining_pool_account);
|
|
|
|
mining_pool_keyed_account
|
|
|
|
.set_state(&StakeState::MiningPool)
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
let mut vote_state = VoteState::default();
|
|
|
|
for i in 0..100 {
|
|
|
|
// go back in time, previous state had 1000 votes
|
2019-04-10 17:52:47 -07:00
|
|
|
vote_state.process_vote(&Vote::new(i));
|
2019-04-01 16:45:53 -07:00
|
|
|
}
|
|
|
|
vote_keyed_account.set_state(&vote_state).unwrap();
|
|
|
|
// voter credits lower than stake_delegate credits... TODO: is this an error?
|
|
|
|
assert_eq!(
|
|
|
|
mining_pool_keyed_account
|
2019-04-07 21:45:28 -07:00
|
|
|
.redeem_vote_credits(&mut stake_keyed_account, &mut vote_keyed_account),
|
2019-04-01 16:45:53 -07:00
|
|
|
Err(InstructionError::InvalidAccountData)
|
|
|
|
);
|
|
|
|
|
|
|
|
let vote1_keypair = Keypair::new();
|
|
|
|
let vote1_pubkey = vote1_keypair.pubkey();
|
2019-04-10 17:52:47 -07:00
|
|
|
let mut vote1_account =
|
|
|
|
vote_state::create_account(&vote1_pubkey, &Pubkey::new_rand(), 0, 100);
|
2019-04-01 16:45:53 -07:00
|
|
|
let mut vote1_keyed_account = KeyedAccount::new(&vote1_pubkey, false, &mut vote1_account);
|
|
|
|
vote1_keyed_account.set_state(&vote_state).unwrap();
|
|
|
|
|
|
|
|
// wrong voter_id...
|
|
|
|
assert_eq!(
|
|
|
|
mining_pool_keyed_account
|
2019-04-07 21:45:28 -07:00
|
|
|
.redeem_vote_credits(&mut stake_keyed_account, &mut vote1_keyed_account),
|
2019-04-01 16:45:53 -07:00
|
|
|
Err(InstructionError::InvalidArgument)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|