gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

syscall work, rename syscall to sysvar, rename current to clock (#5074)

Browse Source 
* syscall work, rename syscall to sysvar, rename current to clock

* missed one

* nit
This commit is contained in:
Rob Walker
2019-07-12 16:38:15 -07:00
committed by GitHub
parent 7aecb87bce
commit d2b6c2e0ce
19 changed files with 229 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
programs/stake_api/src/stake_instruction.rs
View File

@ -6,8 +6,8 @@ use serde_derive::{Deserialize, Serialize};
use solana_sdk::account::KeyedAccount;
use solana_sdk::instruction::{AccountMeta, Instruction, InstructionError};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::syscall;
use solana_sdk::system_instruction;
use solana_sdk::sysvar;
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub enum StakeInstruction {
@ -16,7 +16,7 @@ pub enum StakeInstruction {
/// Expects 3 Accounts:
/// 0 - Uninitialized StakeAccount to be delegated <= must have this signature
/// 1 - VoteAccount to which this Stake will be delegated
/// 2 - Current syscall Account that carries current bank epoch
/// 2 - Clock sysvar Account that carries clock bank epoch
///
/// The u64 is the portion of the Stake account balance to be activated,
/// must be less than StakeAccount.lamports
@ -29,7 +29,7 @@ pub enum StakeInstruction {
/// 0 - Delegate StakeAccount to be updated with rewards
/// 1 - VoteAccount to which the Stake is delegated,
/// 2 - RewardsPool Stake Account from which to redeem credits
/// 3 - Rewards syscall Account that carries points values
/// 3 - Rewards sysvar Account that carries points values
RedeemVoteCredits,
/// Withdraw unstaked lamports from the stake account
@ -81,7 +81,7 @@ pub fn redeem_vote_credits(stake_pubkey: &Pubkey, vote_pubkey: &Pubkey) -> Instr
AccountMeta::new(*stake_pubkey, false),
AccountMeta::new(*vote_pubkey, false),
AccountMeta::new(crate::rewards_pools::random_id(), false),
AccountMeta::new_credit_only(syscall::rewards::id(), false),
AccountMeta::new_credit_only(sysvar::rewards::id(), false),
];
Instruction::new(id(), &StakeInstruction::RedeemVoteCredits, account_metas)
}
@ -90,7 +90,7 @@ pub fn delegate_stake(stake_pubkey: &Pubkey, vote_pubkey: &Pubkey, stake: u64) -
let account_metas = vec![
AccountMeta::new(*stake_pubkey, true),
AccountMeta::new(*vote_pubkey, false),
AccountMeta::new_credit_only(syscall::current::id(), false),
AccountMeta::new_credit_only(sysvar::clock::id(), false),
];
Instruction::new(id(), &StakeInstruction::DelegateStake(stake), account_metas)
}
@ -99,7 +99,7 @@ pub fn withdraw(stake_pubkey: &Pubkey, to_pubkey: &Pubkey, lamports: u64) -> Ins
let account_metas = vec![
AccountMeta::new(*stake_pubkey, true),
AccountMeta::new(*to_pubkey, false),
AccountMeta::new_credit_only(syscall::current::id(), false),
AccountMeta::new_credit_only(sysvar::clock::id(), false),
];
Instruction::new(id(), &StakeInstruction::Withdraw(lamports), account_metas)
}
@ -107,7 +107,7 @@ pub fn withdraw(stake_pubkey: &Pubkey, to_pubkey: &Pubkey, lamports: u64) -> Ins
pub fn deactivate_stake(stake_pubkey: &Pubkey) -> Instruction {
let account_metas = vec![
AccountMeta::new(*stake_pubkey, true),
AccountMeta::new_credit_only(syscall::current::id(), false),
AccountMeta::new_credit_only(sysvar::clock::id(), false),
];
Instruction::new(id(), &StakeInstruction::Deactivate, account_metas)
}
@ -137,11 +137,7 @@ pub fn process_instruction(
}
let vote = &rest[0];
me.delegate_stake(
vote,
stake,
&syscall::current::from_keyed_account(&rest[1])?,
)
me.delegate_stake(vote, stake, &sysvar::clock::from_keyed_account(&rest[1])?)
}
StakeInstruction::RedeemVoteCredits => {
if rest.len() != 3 {
@ -155,29 +151,29 @@ pub fn process_instruction(
me.redeem_vote_credits(
vote,
rewards_pool,
&syscall::rewards::from_keyed_account(&rest[0])?,
&sysvar::rewards::from_keyed_account(&rest[0])?,
)
}
StakeInstruction::Withdraw(lamports) => {
if rest.len() != 2 {
Err(InstructionError::InvalidInstructionData)?;
}
let (to, syscall) = &mut rest.split_at_mut(1);
let (to, sysvar) = &mut rest.split_at_mut(1);
let mut to = &mut to[0];
me.withdraw(
lamports,
&mut to,
&syscall::current::from_keyed_account(&syscall[0])?,
&sysvar::clock::from_keyed_account(&sysvar[0])?,
)
}
StakeInstruction::Deactivate => {
if rest.len() != 1 {
Err(InstructionError::InvalidInstructionData)?;
}
let syscall = &rest[0];
let sysvar = &rest[0];
me.deactivate_stake(&syscall::current::from_keyed_account(&syscall)?)
me.deactivate_stake(&sysvar::clock::from_keyed_account(&sysvar)?)
}
}
}
@ -193,10 +189,10 @@ mod tests {
.accounts
.iter()
.map(|meta| {
if syscall::current::check_id(&meta.pubkey) {
syscall::current::create_account(1, 0, 0, 0, 0)
} else if syscall::rewards::check_id(&meta.pubkey) {
syscall::rewards::create_account(1, 0.0, 0.0)
if sysvar::clock::check_id(&meta.pubkey) {
sysvar::clock::create_account(1, 0, 0, 0, 0)
} else if sysvar::rewards::check_id(&meta.pubkey) {
sysvar::rewards::create_account(1, 0.0, 0.0)
} else {
Account::default()
}
@ -286,9 +282,9 @@ mod tests {
KeyedAccount::new(&Pubkey::default(), true, &mut Account::default()),
KeyedAccount::new(&Pubkey::default(), false, &mut Account::default()),
KeyedAccount::new(
&syscall::current::id(),
&sysvar::clock::id(),
false,
&mut syscall::current::create_account(1, 0, 0, 0, 0)
&mut sysvar::clock::create_account(1, 0, 0, 0, 0)
),
],
&serialize(&StakeInstruction::DelegateStake(0)).unwrap(),
@ -305,9 +301,9 @@ mod tests {
KeyedAccount::new(&Pubkey::default(), false, &mut Account::default()),
KeyedAccount::new(&Pubkey::default(), false, &mut Account::default()),
KeyedAccount::new(
&syscall::rewards::id(),
&sysvar::rewards::id(),
false,
&mut syscall::rewards::create_account(1, 0.0, 0.0)
&mut sysvar::rewards::create_account(1, 0.0, 0.0)
),
],
&serialize(&StakeInstruction::RedeemVoteCredits).unwrap(),
@ -315,7 +311,7 @@ mod tests {
Err(InstructionError::InvalidAccountData),
);
// Tests 3rd keyed account is of correct type (Current instead of rewards) in withdraw
// Tests 3rd keyed account is of correct type (Clock instead of rewards) in withdraw
assert_eq!(
super::process_instruction(
&Pubkey::default(),
@ -323,9 +319,9 @@ mod tests {
KeyedAccount::new(&Pubkey::default(), false, &mut Account::default()),
KeyedAccount::new(&Pubkey::default(), false, &mut Account::default()),
KeyedAccount::new(
&syscall::rewards::id(),
&sysvar::rewards::id(),
false,
&mut syscall::rewards::create_account(1, 0.0, 0.0)
&mut sysvar::rewards::create_account(1, 0.0, 0.0)
),
],
&serialize(&StakeInstruction::Withdraw(42)).unwrap(),
@ -340,9 +336,9 @@ mod tests {
&mut [
KeyedAccount::new(&Pubkey::default(), false, &mut Account::default()),
KeyedAccount::new(
&syscall::current::id(),
&sysvar::clock::id(),
false,
&mut syscall::rewards::create_account(1, 0.0, 0.0)
&mut sysvar::rewards::create_account(1, 0.0, 0.0)
),
],
&serialize(&StakeInstruction::Withdraw(42)).unwrap(),
@ -350,16 +346,16 @@ mod tests {
Err(InstructionError::InvalidInstructionData),
);
// Tests 2nd keyed account is of correct type (Current instead of rewards) in deactivate
// Tests 2nd keyed account is of correct type (Clock instead of rewards) in deactivate
assert_eq!(
super::process_instruction(
&Pubkey::default(),
&mut [
KeyedAccount::new(&Pubkey::default(), false, &mut Account::default()),
KeyedAccount::new(
&syscall::rewards::id(),
&sysvar::rewards::id(),
false,
&mut syscall::rewards::create_account(1, 0.0, 0.0)
&mut sysvar::rewards::create_account(1, 0.0, 0.0)
),
],
&serialize(&StakeInstruction::Deactivate).unwrap(),
@ -375,9 +371,9 @@ mod tests {
KeyedAccount::new(&Pubkey::default(), false, &mut Account::default()),
KeyedAccount::new(&Pubkey::default(), false, &mut Account::default()),
KeyedAccount::new(
&syscall::current::id(),
&sysvar::clock::id(),
false,
&mut syscall::rewards::create_account(1, 0.0, 0.0)
&mut sysvar::rewards::create_account(1, 0.0, 0.0)
),
],
&serialize(&StakeInstruction::Deactivate).unwrap(),

84
programs/stake_api/src/stake_state.rs
View File

@ -9,7 +9,7 @@ use solana_sdk::account::{Account, KeyedAccount};
use solana_sdk::account_utils::State;
use solana_sdk::instruction::InstructionError;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::syscall;
use solana_sdk::sysvar;
use solana_sdk::timing::Epoch;
use solana_vote_api::vote_state::VoteState;
use std::cmp;
@ -178,23 +178,20 @@ pub trait StakeAccount {
&mut self,
vote_account: &KeyedAccount,
stake: u64,
current: &syscall::current::Current,
) -> Result<(), InstructionError>;
fn deactivate_stake(
&mut self,
current: &syscall::current::Current,
clock: &sysvar::clock::Clock,
) -> Result<(), InstructionError>;
fn deactivate_stake(&mut self, clock: &sysvar::clock::Clock) -> Result<(), InstructionError>;
fn redeem_vote_credits(
&mut self,
vote_account: &mut KeyedAccount,
rewards_account: &mut KeyedAccount,
rewards: &syscall::rewards::Rewards,
rewards: &sysvar::rewards::Rewards,
) -> Result<(), InstructionError>;
fn withdraw(
&mut self,
lamports: u64,
to: &mut KeyedAccount,
current: &syscall::current::Current,
clock: &sysvar::clock::Clock,
) -> Result<(), InstructionError>;
}
@ -203,7 +200,7 @@ impl<'a> StakeAccount for KeyedAccount<'a> {
&mut self,
vote_account: &KeyedAccount,
new_stake: u64,
current: &syscall::current::Current,
clock: &sysvar::clock::Clock,
) -> Result<(), InstructionError> {
if self.signer_key().is_none() {
return Err(InstructionError::MissingRequiredSignature);
@ -220,7 +217,7 @@ impl<'a> StakeAccount for KeyedAccount<'a> {
new_stake,
vote_account.unsigned_key(),
&vote_account.state()?,
current.epoch,
clock.epoch,
);
self.set_state(&StakeState::Stake(stake))
@ -228,16 +225,13 @@ impl<'a> StakeAccount for KeyedAccount<'a> {
Err(InstructionError::InvalidAccountData)
}
}
fn deactivate_stake(
&mut self,
current: &syscall::current::Current,
) -> Result<(), InstructionError> {
fn deactivate_stake(&mut self, clock: &sysvar::clock::Clock) -> Result<(), InstructionError> {
if self.signer_key().is_none() {
return Err(InstructionError::MissingRequiredSignature);
}
if let StakeState::Stake(mut stake) = self.state()? {
stake.deactivate(current.epoch);
stake.deactivate(clock.epoch);
self.set_state(&StakeState::Stake(stake))
} else {
@ -248,7 +242,7 @@ impl<'a> StakeAccount for KeyedAccount<'a> {
&mut self,
vote_account: &mut KeyedAccount,
rewards_account: &mut KeyedAccount,
rewards: &syscall::rewards::Rewards,
rewards: &sysvar::rewards::Rewards,
) -> Result<(), InstructionError> {
if let (StakeState::Stake(mut stake), StakeState::RewardsPool) =
(self.state()?, rewards_account.state()?)
@ -285,7 +279,7 @@ impl<'a> StakeAccount for KeyedAccount<'a> {
&mut self,
lamports: u64,
to: &mut KeyedAccount,
current: &syscall::current::Current,
clock: &sysvar::clock::Clock,
) -> Result<(), InstructionError> {
if self.signer_key().is_none() {
return Err(InstructionError::MissingRequiredSignature);
@ -293,7 +287,7 @@ impl<'a> StakeAccount for KeyedAccount<'a> {
match self.state()? {
StakeState::Stake(mut stake) => {
let staked = if stake.stake(current.epoch) == 0 {
let staked = if stake.stake(clock.epoch) == 0 {
0
} else {
// Assume full stake if the stake is under warmup/cooldown
@ -359,7 +353,7 @@ mod tests {
#[test]
fn test_stake_delegate_stake() {
let current = syscall::current::Current::default();
let clock = sysvar::clock::Clock::default();
let vote_keypair = Keypair::new();
let mut vote_state = VoteState::default();
@ -387,14 +381,14 @@ mod tests {
}
assert_eq!(
stake_keyed_account.delegate_stake(&vote_keyed_account, 0, &current),
stake_keyed_account.delegate_stake(&vote_keyed_account, 0, &clock),
Err(InstructionError::MissingRequiredSignature)
);
// signed keyed account
let mut stake_keyed_account = KeyedAccount::new(&stake_pubkey, true, &mut stake_account);
assert!(stake_keyed_account
.delegate_stake(&vote_keyed_account, stake_lamports, &current)
.delegate_stake(&vote_keyed_account, stake_lamports, &clock)
.is_ok());
// verify that delegate_stake() looks right, compare against hand-rolled
@ -412,14 +406,14 @@ mod tests {
// verify that delegate_stake can't be called twice StakeState::default()
// signed keyed account
assert_eq!(
stake_keyed_account.delegate_stake(&vote_keyed_account, stake_lamports, &current),
stake_keyed_account.delegate_stake(&vote_keyed_account, stake_lamports, &clock),
Err(InstructionError::InvalidAccountData)
);
// verify can only stake up to account lamports
let mut stake_keyed_account = KeyedAccount::new(&stake_pubkey, true, &mut stake_account);
assert_eq!(
stake_keyed_account.delegate_stake(&vote_keyed_account, stake_lamports + 1, &current),
stake_keyed_account.delegate_stake(&vote_keyed_account, stake_lamports + 1, &clock),
Err(InstructionError::InsufficientFunds)
);
@ -427,7 +421,7 @@ mod tests {
stake_keyed_account.set_state(&stake_state).unwrap();
assert!(stake_keyed_account
.delegate_stake(&vote_keyed_account, 0, &current)
.delegate_stake(&vote_keyed_account, 0, &clock)
.is_err());
}
@ -462,19 +456,19 @@ mod tests {
let mut stake_account =
Account::new(stake_lamports, std::mem::size_of::<StakeState>(), &id());
let current = syscall::current::Current::default();
let clock = sysvar::clock::Clock::default();
// unsigned keyed account
let mut stake_keyed_account = KeyedAccount::new(&stake_pubkey, false, &mut stake_account);
assert_eq!(
stake_keyed_account.deactivate_stake(&current),
stake_keyed_account.deactivate_stake(&clock),
Err(InstructionError::MissingRequiredSignature)
);
// signed keyed account but not staked yet
let mut stake_keyed_account = KeyedAccount::new(&stake_pubkey, true, &mut stake_account);
assert_eq!(
stake_keyed_account.deactivate_stake(&current),
stake_keyed_account.deactivate_stake(&clock),
Err(InstructionError::InvalidAccountData)
);
@ -485,12 +479,12 @@ mod tests {
let mut vote_keyed_account = KeyedAccount::new(&vote_pubkey, false, &mut vote_account);
vote_keyed_account.set_state(&VoteState::default()).unwrap();
assert_eq!(
stake_keyed_account.delegate_stake(&vote_keyed_account, stake_lamports, &current),
stake_keyed_account.delegate_stake(&vote_keyed_account, stake_lamports, &clock),
Ok(())
);
// Deactivate after staking
assert_eq!(stake_keyed_account.deactivate_stake(&current), Ok(()));
assert_eq!(stake_keyed_account.deactivate_stake(&clock), Ok(()));
}
#[test]
@ -501,7 +495,7 @@ mod tests {
let mut stake_account =
Account::new(total_lamports, std::mem::size_of::<StakeState>(), &id());
let current = syscall::current::Current::default();
let clock = sysvar::clock::Clock::default();
let to = Pubkey::new_rand();
let mut to_account = Account::new(1, 0, &system_program::id());
@ -510,7 +504,7 @@ mod tests {
// unsigned keyed account
let mut stake_keyed_account = KeyedAccount::new(&stake_pubkey, false, &mut stake_account);
assert_eq!(
stake_keyed_account.withdraw(total_lamports, &mut to_keyed_account, &current),
stake_keyed_account.withdraw(total_lamports, &mut to_keyed_account, &clock),
Err(InstructionError::MissingRequiredSignature)
);
@ -518,14 +512,14 @@ mod tests {
// try withdrawing more than balance
let mut stake_keyed_account = KeyedAccount::new(&stake_pubkey, true, &mut stake_account);
assert_eq!(
stake_keyed_account.withdraw(total_lamports + 1, &mut to_keyed_account, &current),
stake_keyed_account.withdraw(total_lamports + 1, &mut to_keyed_account, &clock),
Err(InstructionError::InsufficientFunds)
);
// try withdrawing some (enough for rest of the test to carry forward)
let mut stake_keyed_account = KeyedAccount::new(&stake_pubkey, true, &mut stake_account);
assert_eq!(
stake_keyed_account.withdraw(5, &mut to_keyed_account, &current),
stake_keyed_account.withdraw(5, &mut to_keyed_account, &clock),
Ok(())
);
total_lamports -= 5;
@ -537,7 +531,7 @@ mod tests {
let mut vote_keyed_account = KeyedAccount::new(&vote_pubkey, false, &mut vote_account);
vote_keyed_account.set_state(&VoteState::default()).unwrap();
assert_eq!(
stake_keyed_account.delegate_stake(&vote_keyed_account, stake_lamports, &current),
stake_keyed_account.delegate_stake(&vote_keyed_account, stake_lamports, &clock),
Ok(())
);
@ -546,7 +540,7 @@ mod tests {
stake_keyed_account.withdraw(
total_lamports - stake_lamports + 1,
&mut to_keyed_account,
&current
&clock
),
Err(InstructionError::InsufficientFunds)
);
@ -556,7 +550,7 @@ mod tests {
stake_keyed_account.withdraw(
total_lamports - stake_lamports,
&mut to_keyed_account,
&current
&clock
),
Ok(())
);
@ -570,8 +564,8 @@ mod tests {
let mut stake_account =
Account::new(total_lamports, std::mem::size_of::<StakeState>(), &id());
let current = syscall::current::Current::default();
let mut future = syscall::current::Current::default();
let clock = sysvar::clock::Clock::default();
let mut future = sysvar::clock::Clock::default();
future.epoch += 16;
let to = Pubkey::new_rand();
@ -596,7 +590,7 @@ mod tests {
stake_keyed_account.withdraw(
total_lamports - stake_lamports + 1,
&mut to_keyed_account,
&current
&clock
),
Ok(())
);
@ -609,8 +603,8 @@ mod tests {
let mut stake_account =
Account::new(total_lamports, std::mem::size_of::<StakeState>(), &id());
let current = syscall::current::Current::default();
let mut future = syscall::current::Current::default();
let clock = sysvar::clock::Clock::default();
let mut future = sysvar::clock::Clock::default();
future.epoch += 16;
let to = Pubkey::new_rand();
@ -622,7 +616,7 @@ mod tests {
stake_keyed_account.set_state(&stake_state).unwrap();
assert_eq!(
stake_keyed_account.withdraw(total_lamports, &mut to_keyed_account, &current),
stake_keyed_account.withdraw(total_lamports, &mut to_keyed_account, &clock),
Err(InstructionError::InvalidAccountData)
);
}
@ -704,8 +698,8 @@ mod tests {
#[test]
fn test_stake_redeem_vote_credits() {
let current = syscall::current::Current::default();
let mut rewards = syscall::rewards::Rewards::default();
let clock = sysvar::clock::Clock::default();
let mut rewards = sysvar::rewards::Rewards::default();
rewards.validator_point_value = 100.0;
let rewards_pool_pubkey = Pubkey::new_rand();
@ -736,7 +730,7 @@ mod tests {
// delegate the stake
assert!(stake_keyed_account
.delegate_stake(&vote_keyed_account, stake_lamports, &current)
.delegate_stake(&vote_keyed_account, stake_lamports, &clock)
.is_ok());
// no credits to claim
assert_eq!(

6
programs/stake_tests/tests/stake_instruction.rs
View File

@ -7,8 +7,8 @@ use solana_sdk::client::SyncClient;
use solana_sdk::message::Message;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::syscall;
use solana_sdk::syscall::rewards::Rewards;
use solana_sdk::sysvar;
use solana_sdk::sysvar::rewards::Rewards;
use solana_stake_api::id;
use solana_stake_api::stake_instruction;
use solana_stake_api::stake_instruction::process_instruction;
@ -145,7 +145,7 @@ fn test_stake_account_delegate() {
// Test that rewards are there
let rewards_account = bank
.get_account(&syscall::rewards::id())
.get_account(&sysvar::rewards::id())
.expect("account not found");
assert_matches!(Rewards::from(&rewards_account), Some(_));

49
programs/storage_api/src/storage_contract.rs
View File

@ -8,7 +8,7 @@ use solana_sdk::hash::Hash;
use solana_sdk::instruction::InstructionError;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::Signature;
use solana_sdk::syscall;
use solana_sdk::sysvar;
use std::collections::BTreeMap;
// Todo Tune this for actual use cases when PoRep is feature complete
@ -167,7 +167,7 @@ impl<'a> StorageAccount<'a> {
segment_index: u64,
signature: Signature,
blockhash: Hash,
current: syscall::current::Current,
clock: sysvar::clock::Clock,
) -> Result<(), InstructionError> {
let mut storage_contract = &mut self.account.state()?;
if let StorageContract::ReplicatorStorage {
@ -177,7 +177,7 @@ impl<'a> StorageAccount<'a> {
..
} = &mut storage_contract
{
let current_segment = current.segment;
let current_segment = clock.segment;
// clean up the account
// TODO check for time correctness - storage seems to run at a delay of about 3
@ -230,7 +230,7 @@ impl<'a> StorageAccount<'a> {
StorageError::ProofLimitReached as u32,
));
}
credits.update_epoch(current.epoch);
credits.update_epoch(clock.epoch);
segment_proofs.push(proof);
self.account.set_state(storage_contract)
} else {
@ -242,7 +242,7 @@ impl<'a> StorageAccount<'a> {
&mut self,
hash: Hash,
segment: u64,
current: syscall::current::Current,
clock: sysvar::clock::Clock,
) -> Result<(), InstructionError> {
let mut storage_contract = &mut self.account.state()?;
if let StorageContract::ValidatorStorage {
@ -253,11 +253,8 @@ impl<'a> StorageAccount<'a> {
..
} = &mut storage_contract
{
debug!(
"advertise new segment: {} orig: {}",
segment, current.segment
);
if segment < *state_segment || segment > current.segment {
debug!("advertise new segment: {} orig: {}", segment, clock.segment);
if segment < *state_segment || segment > clock.segment {
return Err(InstructionError::CustomError(
StorageError::InvalidSegment as u32,
));
@ -269,7 +266,7 @@ impl<'a> StorageAccount<'a> {
// storage epoch updated, move the lockout_validations to credits
let (_num_valid, total_validations) = count_valid_proofs(&lockout_validations);
lockout_validations.clear();
credits.update_epoch(current.epoch);
credits.update_epoch(clock.epoch);
credits.current_epoch += total_validations;
self.account.set_state(storage_contract)
} else {
@ -280,7 +277,7 @@ impl<'a> StorageAccount<'a> {
pub fn proof_validation(
&mut self,
me: &Pubkey,
current: syscall::current::Current,
clock: sysvar::clock::Clock,
segment_index: u64,
proofs_per_account: Vec<Vec<ProofStatus>>,
replicator_accounts: &mut [StorageAccount],
@ -341,14 +338,8 @@ impl<'a> StorageAccount<'a> {
.into_iter()
.zip(accounts.into_iter())
.filter_map(|(checked_proofs, account)| {
if store_validation_result(
me,
&current,
account,
segment_index,
&checked_proofs,
)
.is_ok()
if store_validation_result(me, &clock, account, segment_index, &checked_proofs)
.is_ok()
{
Some((account.id, checked_proofs))
} else {
@ -376,8 +367,8 @@ impl<'a> StorageAccount<'a> {
pub fn claim_storage_reward(
&mut self,
rewards_pool: &mut KeyedAccount,
current: syscall::current::Current,
rewards: syscall::rewards::Rewards,
clock: sysvar::clock::Clock,
rewards: sysvar::rewards::Rewards,
owner: &mut StorageAccount,
) -> Result<(), InstructionError> {
let mut storage_contract = &mut self.account.state()?;
@ -394,7 +385,7 @@ impl<'a> StorageAccount<'a> {
))?
}
credits.update_epoch(current.epoch);
credits.update_epoch(clock.epoch);
check_redeemable(credits, rewards.storage_point_value, rewards_pool, owner)?;
self.account.set_state(storage_contract)
@ -410,7 +401,7 @@ impl<'a> StorageAccount<'a> {
StorageError::InvalidOwner as u32,
))?
}
credits.update_epoch(current.epoch);
credits.update_epoch(clock.epoch);
let (num_validations, _total_proofs) = count_valid_proofs(&validations);
credits.current_epoch += num_validations;
validations.clear();
@ -451,7 +442,7 @@ pub fn create_rewards_pool() -> Account {
/// Store the result of a proof validation into the replicator account
fn store_validation_result(
me: &Pubkey,
current: &syscall::current::Current,
clock: &sysvar::clock::Clock,
storage_account: &mut StorageAccount,
segment: u64,
proof_mask: &[ProofStatus],
@ -478,7 +469,7 @@ fn store_validation_result(
entry.insert(*me, proof_mask.to_vec());
}
let (total_validations, _) = count_valid_proofs(&validations);
credits.update_epoch(current.epoch);
credits.update_epoch(clock.epoch);
credits.current_epoch += total_validations - recorded_validations;
}
_ => return Err(InstructionError::InvalidAccountData),
@ -571,7 +562,7 @@ mod tests {
// account has no space
store_validation_result(
&Pubkey::default(),
&syscall::current::Current::default(),
&sysvar::clock::Clock::default(),
&mut account,
segment_index,
&vec![ProofStatus::default(); 1],
@ -598,7 +589,7 @@ mod tests {
// proof is valid
store_validation_result(
&Pubkey::default(),
&syscall::current::Current::default(),
&sysvar::clock::Clock::default(),
&mut account,
segment_index,
&vec![ProofStatus::Valid],
@ -608,7 +599,7 @@ mod tests {
// proof failed verification but we should still be able to store it
store_validation_result(
&Pubkey::default(),
&syscall::current::Current::default(),
&sysvar::clock::Clock::default(),
&mut account,
segment_index,
&vec![ProofStatus::NotValid],

12
programs/storage_api/src/storage_instruction.rs
View File

@ -5,8 +5,8 @@ use solana_sdk::hash::Hash;
use solana_sdk::instruction::{AccountMeta, Instruction};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::Signature;
use solana_sdk::syscall::{current, rewards};
use solana_sdk::system_instruction;
use solana_sdk::sysvar::{clock, rewards};
#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum StorageInstruction {
@ -35,7 +35,7 @@ pub enum StorageInstruction {
///
/// Expects 1 Account:
/// 0 - Storage account with credits to redeem
/// 1 - Current Syscall to figure out the current epoch
/// 1 - Clock Syscall to figure out the clock epoch
/// 2 - Replicator account to credit - this account *must* be the owner
/// 3 - MiningPool account to redeem credits from
/// 4 - Rewards Syscall to figure out point values
@ -144,7 +144,7 @@ pub fn mining_proof(
};
let account_metas = vec![
AccountMeta::new(*storage_pubkey, true),
AccountMeta::new(current::id(), false),
AccountMeta::new(clock::id(), false),
];
Instruction::new(id(), &storage_instruction, account_metas)
}
@ -160,7 +160,7 @@ pub fn advertise_recent_blockhash(
};
let account_metas = vec![
AccountMeta::new(*storage_pubkey, true),
AccountMeta::new(current::id(), false),
AccountMeta::new(clock::id(), false),
];
Instruction::new(id(), &storage_instruction, account_metas)
}
@ -172,7 +172,7 @@ pub fn proof_validation(
) -> Instruction {
let mut account_metas = vec![
AccountMeta::new(*storage_pubkey, true),
AccountMeta::new(current::id(), false),
AccountMeta::new(clock::id(), false),
];
let mut proofs = vec![];
checked_proofs.into_iter().for_each(|(id, p)| {
@ -187,7 +187,7 @@ pub fn claim_reward(owner_pubkey: &Pubkey, storage_pubkey: &Pubkey) -> Instructi
let storage_instruction = StorageInstruction::ClaimStorageReward;
let account_metas = vec![
AccountMeta::new(*storage_pubkey, false),
AccountMeta::new(current::id(), false),
AccountMeta::new(clock::id(), false),
AccountMeta::new(rewards::id(), false),
AccountMeta::new(rewards_pools::random_id(), false),
AccountMeta::new(*owner_pubkey, false),

29
programs/storage_api/src/storage_processor.rs
View File

@ -6,7 +6,7 @@ use crate::storage_instruction::StorageInstruction;
use solana_sdk::account::KeyedAccount;
use solana_sdk::instruction::InstructionError;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::syscall;
use solana_sdk::sysvar;
pub fn process_instruction(
_program_id: &Pubkey,
@ -42,13 +42,13 @@ pub fn process_instruction(
// This instruction must be signed by `me`
Err(InstructionError::InvalidArgument)?;
}
let current = syscall::current::from_keyed_account(&rest[0])?;
let clock = sysvar::clock::from_keyed_account(&rest[0])?;
storage_account.submit_mining_proof(
sha_state,
segment_index,
signature,
blockhash,
current,
clock,
)
}
StorageInstruction::AdvertiseStorageRecentBlockhash { hash, segment } => {
@ -56,47 +56,42 @@ pub fn process_instruction(
// This instruction must be signed by `me`
Err(InstructionError::InvalidArgument)?;
}
let current = syscall::current::from_keyed_account(&rest[0])?;
storage_account.advertise_storage_recent_blockhash(hash, segment, current)
let clock = sysvar::clock::from_keyed_account(&rest[0])?;
storage_account.advertise_storage_recent_blockhash(hash, segment, clock)
}
StorageInstruction::ClaimStorageReward => {
if rest.len() != 4 {
Err(InstructionError::InvalidArgument)?;
}
let (current, rest) = rest.split_at_mut(1);
let (clock, rest) = rest.split_at_mut(1);
let (rewards, rest) = rest.split_at_mut(1);
let (rewards_pools, owner) = rest.split_at_mut(1);
let rewards = syscall::rewards::from_keyed_account(&rewards[0])?;
let current = syscall::current::from_keyed_account(&current[0])?;
let rewards = sysvar::rewards::from_keyed_account(&rewards[0])?;
let clock = sysvar::clock::from_keyed_account(&clock[0])?;
let mut owner = StorageAccount::new(*owner[0].unsigned_key(), &mut owner[0].account);
storage_account.claim_storage_reward(
&mut rewards_pools[0],
current,
rewards,
&mut owner,
)
storage_account.claim_storage_reward(&mut rewards_pools[0], clock, rewards, &mut owner)
}
StorageInstruction::ProofValidation { segment, proofs } => {
if rest.is_empty() {
Err(InstructionError::InvalidArgument)?;
}
let (current, rest) = rest.split_at_mut(1);
let (clock, rest) = rest.split_at_mut(1);
if me_unsigned || rest.is_empty() {
// This instruction must be signed by `me` and `rest` cannot be empty
Err(InstructionError::InvalidArgument)?;
}
let me_id = storage_account.id;
let current = syscall::current::from_keyed_account(&current[0])?;
let clock = sysvar::clock::from_keyed_account(&clock[0])?;
let mut rest: Vec<_> = rest
.iter_mut()
.map(|keyed_account| {
StorageAccount::new(*keyed_account.unsigned_key(), &mut keyed_account.account)
})
.collect();
storage_account.proof_validation(&me_id, current, segment, proofs, &mut rest)
storage_account.proof_validation(&me_id, clock, segment, proofs, &mut rest)
}
}
}

48
programs/storage_program/tests/storage_processor.rs
View File

@ -12,10 +12,10 @@ use solana_sdk::instruction::{Instruction, InstructionError};
use solana_sdk::message::Message;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
use solana_sdk::syscall::current::Current;
use solana_sdk::syscall::rewards::Rewards;
use solana_sdk::syscall::{current, rewards};
use solana_sdk::system_instruction;
use solana_sdk::sysvar::clock::Clock;
use solana_sdk::sysvar::rewards::Rewards;
use solana_sdk::sysvar::{clock, rewards};
use solana_sdk::timing::{
get_segment_from_slot, DEFAULT_SLOTS_PER_SEGMENT, DEFAULT_TICKS_PER_SLOT,
};
@ -126,21 +126,18 @@ fn test_proof_bounds() {
Hash::default(),
);
// the proof is for segment 0, need to move the slot into segment 2
let mut current_account = current::create_account(1, 0, 0, 0, 0);
Current::to(
&Current {
let mut clock_account = clock::create_account(1, 0, 0, 0, 0);
Clock::to(
&Clock {
slot: DEFAULT_SLOTS_PER_SEGMENT * 2,
segment: 2,
epoch: 0,
stakers_epoch: 0,
},
&mut current_account,
&mut clock_account,
);
assert_eq!(
test_instruction(&ix, &mut [account, current_account]),
Ok(())
);
assert_eq!(test_instruction(&ix, &mut [account, clock_account]), Ok(()));
}
#[test]
@ -154,12 +151,12 @@ fn test_storage_tx() {
#[test]
fn test_serialize_overflow() {
let pubkey = Pubkey::new_rand();
let current_id = current::id();
let clock_id = clock::id();
let mut keyed_accounts = Vec::new();
let mut user_account = Account::default();
let mut current_account = current::create_account(1, 0, 0, 0, 0);
let mut clock_account = clock::create_account(1, 0, 0, 0, 0);
keyed_accounts.push(KeyedAccount::new(&pubkey, true, &mut user_account));
keyed_accounts.push(KeyedAccount::new(&current_id, false, &mut current_account));
keyed_accounts.push(KeyedAccount::new(&clock_id, false, &mut clock_account));
let ix = storage_instruction::advertise_recent_blockhash(&pubkey, Hash::default(), 1);
@ -182,20 +179,20 @@ fn test_invalid_accounts_len() {
Hash::default(),
);
// move tick height into segment 1
let mut current_account = current::create_account(1, 0, 0, 0, 0);
Current::to(
&Current {
let mut clock_account = clock::create_account(1, 0, 0, 0, 0);
Clock::to(
&Clock {
slot: 16,
segment: 1,
epoch: 0,
stakers_epoch: 0,
},
&mut current_account,
&mut clock_account,
);
assert!(test_instruction(&ix, &mut accounts).is_err());
let mut accounts = [Account::default(), current_account, Account::default()];
let mut accounts = [Account::default(), clock_account, Account::default()];
assert!(test_instruction(&ix, &mut accounts).is_err());
}
@ -242,21 +239,18 @@ fn test_submit_mining_ok() {
Hash::default(),
);
// move slot into segment 1
let mut current_account = current::create_account(1, 0, 0, 0, 0);
Current::to(
&Current {
let mut clock_account = clock::create_account(1, 0, 0, 0, 0);
Clock::to(
&Clock {
slot: DEFAULT_SLOTS_PER_SEGMENT,
segment: 1,
epoch: 0,
stakers_epoch: 0,
},
&mut current_account,
&mut clock_account,
);
assert_matches!(
test_instruction(&ix, &mut [account, current_account]),
Ok(_)
);
assert_matches!(test_instruction(&ix, &mut [account, clock_account]), Ok(_));
}
#[test]

24
programs/vote_api/src/vote_instruction.rs
View File

@ -10,8 +10,8 @@ use solana_metrics::datapoint_warn;
use solana_sdk::account::KeyedAccount;
use solana_sdk::instruction::{AccountMeta, Instruction, InstructionError};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::syscall;
use solana_sdk::system_instruction;
use solana_sdk::sysvar;
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub enum VoteInstruction {
@ -94,10 +94,10 @@ pub fn vote(
vote_pubkey,
authorized_voter_pubkey,
&[
// request slot_hashes syscall account after vote_pubkey
AccountMeta::new_credit_only(syscall::slot_hashes::id(), false),
// request current syscall account after that
AccountMeta::new_credit_only(syscall::current::id(), false),
// request slot_hashes sysvar account after vote_pubkey
AccountMeta::new_credit_only(sysvar::slot_hashes::id(), false),
// request clock sysvar account after that
AccountMeta::new_credit_only(sysvar::clock::id(), false),
],
);
@ -135,12 +135,12 @@ pub fn process_instruction(
if rest.len() < 2 {
Err(InstructionError::InvalidInstructionData)?;
}
let (slot_hashes_and_current, other_signers) = rest.split_at_mut(2);
let (slot_hashes_and_clock, 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])?,
&sysvar::slot_hashes::from_keyed_account(&slot_hashes_and_clock[0])?,
&sysvar::clock::from_keyed_account(&slot_hashes_and_clock[1])?,
other_signers,
&votes,
)
@ -167,10 +167,10 @@ mod tests {
.accounts
.iter()
.map(|meta| {
if syscall::current::check_id(&meta.pubkey) {
syscall::current::create_account(1, 0, 0, 0, 0)
} else if syscall::slot_hashes::check_id(&meta.pubkey) {
syscall::slot_hashes::create_account(1, &[])
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 {
Account::default()
}

24
programs/vote_api/src/vote_state.rs
View File

@ -9,7 +9,7 @@ use solana_sdk::account_utils::State;
use solana_sdk::hash::Hash;
use solana_sdk::instruction::InstructionError;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::syscall::current::Current;
use solana_sdk::sysvar::clock::Clock;
pub use solana_sdk::timing::{Epoch, Slot};
use std::collections::VecDeque;
@ -74,9 +74,9 @@ pub struct VoteState {
pub commission: u8,
pub root_slot: Option<u64>,
/// current epoch
/// clock epoch
epoch: Epoch,
/// current credits earned, monotonically increasing
/// clock credits earned, monotonically increasing
credits: u64,
/// credits as of previous epoch
@ -286,7 +286,7 @@ pub fn authorize_voter(
) -> Result<(), InstructionError> {
let mut vote_state: VoteState = vote_account.state()?;
// current authorized signer must say "yay"
// clock authorized signer must say "yay"
let authorized = Some(&vote_state.authorized_voter_pubkey);
if vote_account.signer_key() != authorized
&& other_signers
@ -323,7 +323,7 @@ pub fn initialize_account(
pub fn process_votes(
vote_account: &mut KeyedAccount,
slot_hashes: &[(Slot, Hash)],
current: &Current,
clock: &Clock,
other_signers: &[KeyedAccount],
votes: &[Vote],
) -> Result<(), InstructionError> {
@ -343,7 +343,7 @@ pub fn process_votes(
return Err(InstructionError::MissingRequiredSignature);
}
vote_state.process_votes(&votes, slot_hashes, current.epoch);
vote_state.process_votes(&votes, slot_hashes, clock.epoch);
vote_account.set_state(&vote_state)
}
@ -427,9 +427,9 @@ mod tests {
process_votes(
&mut KeyedAccount::new(vote_pubkey, true, vote_account),
slot_hashes,
&Current {
&Clock {
epoch,
..Current::default()
..Clock::default()
},
&[],
&[vote.clone()],
@ -533,7 +533,7 @@ mod tests {
let res = process_votes(
&mut KeyedAccount::new(&vote_pubkey, false, &mut vote_account),
&[(vote.slot, vote.hash)],
&Current::default(),
&Clock::default(),
&[],
&[vote],
);
@ -543,7 +543,7 @@ mod tests {
let res = process_votes(
&mut KeyedAccount::new(&vote_pubkey, true, &mut vote_account),
&[(vote.slot, vote.hash)],
&Current::default(),
&Clock::default(),
&[],
&[vote],
);
@ -581,7 +581,7 @@ mod tests {
let res = process_votes(
&mut KeyedAccount::new(&vote_pubkey, true, &mut vote_account),
&[(vote.slot, vote.hash)],
&Current::default(),
&Clock::default(),
&[],
&[vote],
);
@ -592,7 +592,7 @@ mod tests {
let res = process_votes(
&mut KeyedAccount::new(&vote_pubkey, false, &mut vote_account),
&[(vote.slot, vote.hash)],
&Current::default(),
&Clock::default(),
&[KeyedAccount::new(
&authorized_voter_pubkey,
true,