From d2b6c2e0cef934a616de8f005a6ef9026b8ac2e5 Mon Sep 17 00:00:00 2001 From: Rob Walker Date: Fri, 12 Jul 2019 16:38:15 -0700 Subject: [PATCH] syscall work, rename syscall to sysvar, rename current to clock (#5074) * syscall work, rename syscall to sysvar, rename current to clock * missed one * nit --- programs/stake_api/src/stake_instruction.rs | 66 +++++++-------- programs/stake_api/src/stake_state.rs | 84 +++++++++---------- .../stake_tests/tests/stake_instruction.rs | 6 +- programs/storage_api/src/storage_contract.rs | 49 +++++------ .../storage_api/src/storage_instruction.rs | 12 +-- programs/storage_api/src/storage_processor.rs | 29 +++---- .../tests/storage_processor.rs | 48 +++++------ programs/vote_api/src/vote_instruction.rs | 24 +++--- programs/vote_api/src/vote_state.rs | 24 +++--- runtime/src/accounts.rs | 8 +- runtime/src/bank.rs | 20 ++--- runtime/src/system_instruction_processor.rs | 16 ++-- sdk/src/lib.rs | 2 +- sdk/src/syscall/mod.rs | 24 ------ .../{syscall/current.rs => sysvar/clock.rs} | 28 +++---- sdk/src/{syscall => sysvar}/fees.rs | 10 +-- sdk/src/sysvar/mod.rs | 21 +++++ sdk/src/{syscall => sysvar}/rewards.rs | 10 +-- sdk/src/{syscall => sysvar}/slot_hashes.rs | 19 ++--- 19 files changed, 229 insertions(+), 271 deletions(-) delete mode 100644 sdk/src/syscall/mod.rs rename sdk/src/{syscall/current.rs => sysvar/clock.rs} (66%) rename sdk/src/{syscall => sysvar}/fees.rs (82%) create mode 100644 sdk/src/sysvar/mod.rs rename sdk/src/{syscall => sysvar}/rewards.rs (86%) rename sdk/src/{syscall => sysvar}/slot_hashes.rs (86%) diff --git a/programs/stake_api/src/stake_instruction.rs b/programs/stake_api/src/stake_instruction.rs index a496149ca8..7853727d9b 100644 --- a/programs/stake_api/src/stake_instruction.rs +++ b/programs/stake_api/src/stake_instruction.rs @@ -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(), diff --git a/programs/stake_api/src/stake_state.rs b/programs/stake_api/src/stake_state.rs index 97e3771a8a..9aa0f639b9 100644 --- a/programs/stake_api/src/stake_state.rs +++ b/programs/stake_api/src/stake_state.rs @@ -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, ¤t), + 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, ¤t) + .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, ¤t), + 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, ¤t), + 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, ¤t) + .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::(), &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(¤t), + 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(¤t), + 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, ¤t), + stake_keyed_account.delegate_stake(&vote_keyed_account, stake_lamports, &clock), Ok(()) ); // Deactivate after staking - assert_eq!(stake_keyed_account.deactivate_stake(¤t), 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::(), &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, ¤t), + 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, ¤t), + 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, ¤t), + 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, ¤t), + 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, - ¤t + &clock ), Err(InstructionError::InsufficientFunds) ); @@ -556,7 +550,7 @@ mod tests { stake_keyed_account.withdraw( total_lamports - stake_lamports, &mut to_keyed_account, - ¤t + &clock ), Ok(()) ); @@ -570,8 +564,8 @@ mod tests { let mut stake_account = Account::new(total_lamports, std::mem::size_of::(), &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, - ¤t + &clock ), Ok(()) ); @@ -609,8 +603,8 @@ mod tests { let mut stake_account = Account::new(total_lamports, std::mem::size_of::(), &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, ¤t), + 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, ¤t) + .delegate_stake(&vote_keyed_account, stake_lamports, &clock) .is_ok()); // no credits to claim assert_eq!( diff --git a/programs/stake_tests/tests/stake_instruction.rs b/programs/stake_tests/tests/stake_instruction.rs index e69bc7fa8d..245c11761b 100644 --- a/programs/stake_tests/tests/stake_instruction.rs +++ b/programs/stake_tests/tests/stake_instruction.rs @@ -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(_)); diff --git a/programs/storage_api/src/storage_contract.rs b/programs/storage_api/src/storage_contract.rs index ebca9172b0..e1cf91ac68 100644 --- a/programs/storage_api/src/storage_contract.rs +++ b/programs/storage_api/src/storage_contract.rs @@ -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>, 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, - ¤t, - 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], diff --git a/programs/storage_api/src/storage_instruction.rs b/programs/storage_api/src/storage_instruction.rs index 292882c38c..eb8b5d471b 100644 --- a/programs/storage_api/src/storage_instruction.rs +++ b/programs/storage_api/src/storage_instruction.rs @@ -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), diff --git a/programs/storage_api/src/storage_processor.rs b/programs/storage_api/src/storage_processor.rs index 44e4be4aff..2c4c46f4e8 100644 --- a/programs/storage_api/src/storage_processor.rs +++ b/programs/storage_api/src/storage_processor.rs @@ -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(¤t[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(¤t[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) } } } diff --git a/programs/storage_program/tests/storage_processor.rs b/programs/storage_program/tests/storage_processor.rs index 5b03222431..4d160eeeaa 100644 --- a/programs/storage_program/tests/storage_processor.rs +++ b/programs/storage_program/tests/storage_processor.rs @@ -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(¤t_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] diff --git a/programs/vote_api/src/vote_instruction.rs b/programs/vote_api/src/vote_instruction.rs index 969449dfa5..8786b63103 100644 --- a/programs/vote_api/src/vote_instruction.rs +++ b/programs/vote_api/src/vote_instruction.rs @@ -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() } diff --git a/programs/vote_api/src/vote_state.rs b/programs/vote_api/src/vote_state.rs index f5b1520c38..cbb8598b5a 100644 --- a/programs/vote_api/src/vote_state.rs +++ b/programs/vote_api/src/vote_state.rs @@ -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, - /// 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, diff --git a/runtime/src/accounts.rs b/runtime/src/accounts.rs index 9cd97c86a1..a65a613850 100644 --- a/runtime/src/accounts.rs +++ b/runtime/src/accounts.rs @@ -15,8 +15,8 @@ use solana_sdk::message::Message; use solana_sdk::native_loader; use solana_sdk::pubkey::Pubkey; use solana_sdk::signature::{Keypair, KeypairUtil}; -use solana_sdk::syscall; use solana_sdk::system_program; +use solana_sdk::sysvar; use solana_sdk::transaction::Result; use solana_sdk::transaction::{Transaction, TransactionError}; use std::collections::{HashMap, HashSet}; @@ -494,7 +494,7 @@ impl Accounts { pub fn hash_internal_state(&self, fork_id: Fork) -> Option { let account_hashes = self.scan_fork(fork_id, |stored_account| { - if !syscall::check_id(&stored_account.balance.owner) { + if !sysvar::check_id(&stored_account.balance.owner) { Some(Self::hash_account(stored_account)) } else { None @@ -695,7 +695,7 @@ mod tests { use solana_sdk::hash::Hash; use solana_sdk::instruction::CompiledInstruction; use solana_sdk::signature::{Keypair, KeypairUtil}; - use solana_sdk::syscall; + use solana_sdk::sysvar; use solana_sdk::transaction::Transaction; use std::io::Cursor; use std::sync::atomic::AtomicBool; @@ -1183,7 +1183,7 @@ mod tests { fn test_accounts_empty_hash_internal_state() { let accounts = Accounts::new(None); assert_eq!(accounts.hash_internal_state(0), None); - accounts.store_slow(0, &Pubkey::default(), &Account::new(1, 0, &syscall::id())); + accounts.store_slow(0, &Pubkey::default(), &Account::new(1, 0, &sysvar::id())); assert_eq!(accounts.hash_internal_state(0), None); } diff --git a/runtime/src/bank.rs b/runtime/src/bank.rs index d5b5d81384..7a75b25877 100644 --- a/runtime/src/bank.rs +++ b/runtime/src/bank.rs @@ -33,11 +33,11 @@ use solana_sdk::inflation::Inflation; use solana_sdk::native_loader; use solana_sdk::pubkey::Pubkey; use solana_sdk::signature::{Keypair, Signature}; -use solana_sdk::syscall::{ - current, fees, rewards, +use solana_sdk::system_transaction; +use solana_sdk::sysvar::{ + clock, fees, rewards, slot_hashes::{self, SlotHashes}, }; -use solana_sdk::system_transaction; use solana_sdk::timing::{duration_as_ns, get_segment_from_slot, MAX_RECENT_BLOCKHASHES}; use solana_sdk::transaction::{Result, Transaction, TransactionError}; use std::cmp; @@ -289,7 +289,7 @@ impl Bank { bank.epoch_stakes.insert(i, stakes.clone()); } } - bank.update_current(); + bank.update_clock(); bank } @@ -366,7 +366,7 @@ impl Bank { }); self.update_rewards(parent.epoch()); - self.update_current(); + self.update_clock(); self.update_fees(); self } @@ -408,10 +408,10 @@ impl Bank { *self.hash.read().unwrap() != Hash::default() } - fn update_current(&self) { + fn update_clock(&self) { self.store_account( - ¤t::id(), - ¤t::create_account( + &clock::id(), + &clock::create_account( 1, self.slot, get_segment_from_slot(self.slot, self.slots_per_segment), @@ -1461,9 +1461,9 @@ mod tests { use solana_sdk::instruction::InstructionError; use solana_sdk::poh_config::PohConfig; use solana_sdk::signature::{Keypair, KeypairUtil}; - use solana_sdk::syscall::{fees::Fees, rewards::Rewards}; use solana_sdk::system_instruction; use solana_sdk::system_transaction; + use solana_sdk::sysvar::{fees::Fees, rewards::Rewards}; use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT; use solana_vote_api::vote_instruction; use solana_vote_api::vote_state::{VoteState, MAX_LOCKOUT_HISTORY}; @@ -2252,7 +2252,7 @@ mod tests { let bank0 = Arc::new(Bank::new(&create_genesis_block(10).0)); let hash0 = bank0.hash_internal_state(); // save hash0 because new_from_parent - // updates syscall entries + // updates sysvar entries let bank1 = Bank::new_from_parent(&bank0, &collector_id, 1); diff --git a/runtime/src/system_instruction_processor.rs b/runtime/src/system_instruction_processor.rs index c8b8140ff8..69d8e67ea9 100644 --- a/runtime/src/system_instruction_processor.rs +++ b/runtime/src/system_instruction_processor.rs @@ -2,9 +2,9 @@ use log::*; use solana_sdk::account::KeyedAccount; use solana_sdk::instruction::InstructionError; use solana_sdk::pubkey::Pubkey; -use solana_sdk::syscall; use solana_sdk::system_instruction::{SystemError, SystemInstruction}; use solana_sdk::system_program; +use solana_sdk::sysvar; const FROM_ACCOUNT_INDEX: usize = 0; const TO_ACCOUNT_INDEX: usize = 1; @@ -33,7 +33,7 @@ fn create_system_account( Err(SystemError::AccountAlreadyInUse)?; } - if syscall::check_id(&program_id) { + if sysvar::check_id(&program_id) { debug!( "CreateAccount: invalid argument; program id {} invalid", program_id @@ -41,7 +41,7 @@ fn create_system_account( Err(SystemError::InvalidProgramId)?; } - if syscall::is_syscall_id(&keyed_accounts[TO_ACCOUNT_INDEX].unsigned_key()) { + if sysvar::is_sysvar_id(&keyed_accounts[TO_ACCOUNT_INDEX].unsigned_key()) { debug!( "CreateAccount: invalid argument; account id {} invalid", program_id @@ -207,7 +207,7 @@ mod tests { } #[test] - fn test_create_syscall_invalid_id() { + fn test_create_sysvar_invalid_id() { // Attempt to create system account in account already owned by another program let from = Pubkey::new_rand(); let mut from_account = Account::new(100, 0, &system_program::id()); @@ -219,18 +219,18 @@ mod tests { KeyedAccount::new(&from, true, &mut from_account), KeyedAccount::new(&to, false, &mut to_account), ]; - // fail to create a syscall::id() owned account - let result = create_system_account(&mut keyed_accounts, 50, 2, &syscall::id()); + // fail to create a sysvar::id() owned account + let result = create_system_account(&mut keyed_accounts, 50, 2, &sysvar::id()); assert_eq!(result, Err(SystemError::InvalidProgramId)); - let to = syscall::fees::id(); + let to = sysvar::fees::id(); let mut to_account = Account::default(); let mut keyed_accounts = [ KeyedAccount::new(&from, true, &mut from_account), KeyedAccount::new(&to, false, &mut to_account), ]; - // fail to create an account with a syscall id + // fail to create an account with a sysvar id let result = create_system_account(&mut keyed_accounts, 50, 2, &system_program::id()); assert_eq!(result, Err(SystemError::InvalidAccountId)); diff --git a/sdk/src/lib.rs b/sdk/src/lib.rs index addcdd99c9..37ca5a4be8 100644 --- a/sdk/src/lib.rs +++ b/sdk/src/lib.rs @@ -17,10 +17,10 @@ pub mod pubkey; pub mod rpc_port; pub mod short_vec; pub mod signature; -pub mod syscall; pub mod system_instruction; pub mod system_program; pub mod system_transaction; +pub mod sysvar; pub mod timing; pub mod transaction; pub mod transport; diff --git a/sdk/src/syscall/mod.rs b/sdk/src/syscall/mod.rs deleted file mode 100644 index edb6497b1a..0000000000 --- a/sdk/src/syscall/mod.rs +++ /dev/null @@ -1,24 +0,0 @@ -//! named accounts for synthesized data accounts for bank state, etc. -//! -use crate::pubkey::Pubkey; - -pub mod current; -pub mod fees; -pub mod rewards; -pub mod slot_hashes; - -pub fn is_syscall_id(id: &Pubkey) -> bool { - current::check_id(id) - || fees::check_id(id) - || rewards::check_id(id) - || slot_hashes::check_id(id) -} - -/// "Sysca11111111111111111111111111111111111111" -/// owner pubkey for syscall accounts -const ID: [u8; 32] = [ - 6, 167, 211, 138, 69, 216, 137, 185, 198, 189, 33, 204, 111, 12, 217, 220, 229, 201, 34, 52, - 253, 202, 87, 144, 232, 16, 195, 192, 0, 0, 0, 0, -]; - -crate::solana_name_id!(ID, "Sysca11111111111111111111111111111111111111"); diff --git a/sdk/src/syscall/current.rs b/sdk/src/sysvar/clock.rs similarity index 66% rename from sdk/src/syscall/current.rs rename to sdk/src/sysvar/clock.rs index ad46d1b059..e5582fcaed 100644 --- a/sdk/src/syscall/current.rs +++ b/sdk/src/sysvar/clock.rs @@ -1,28 +1,28 @@ -//! This account contains the current slot, epoch, and stakers_epoch +//! This account contains the clock slot, epoch, and stakers_epoch //! use crate::account::Account; -use crate::syscall; +use crate::sysvar; use bincode::serialized_size; pub use crate::timing::{Epoch, Slot}; -crate::solana_name_id!(ID, "Sysca11Current11111111111111111111111111111"); - const ID: [u8; 32] = [ - 6, 167, 211, 138, 69, 218, 14, 184, 34, 50, 188, 33, 201, 49, 63, 13, 15, 193, 33, 132, 208, - 238, 129, 224, 101, 67, 14, 11, 160, 0, 0, 0, + 6, 167, 213, 23, 24, 199, 116, 201, 40, 86, 99, 152, 105, 29, 94, 182, 139, 94, 184, 163, 155, + 75, 109, 92, 115, 85, 91, 33, 0, 0, 0, 0, ]; +crate::solana_name_id!(ID, "SysvarC1ock11111111111111111111111111111111"); + #[repr(C)] #[derive(Serialize, Deserialize, Debug, Default, PartialEq)] -pub struct Current { +pub struct Clock { pub slot: Slot, pub segment: Segment, pub epoch: Epoch, pub stakers_epoch: Epoch, } -impl Current { +impl Clock { pub fn from(account: &Account) -> Option { account.deserialize_data().ok() } @@ -44,13 +44,13 @@ pub fn create_account( ) -> Account { Account::new_data( lamports, - &Current { + &Clock { slot, segment, epoch, stakers_epoch, }, - &syscall::id(), + &sysvar::id(), ) .unwrap() } @@ -59,11 +59,11 @@ use crate::account::KeyedAccount; use crate::instruction::InstructionError; use crate::timing::Segment; -pub fn from_keyed_account(account: &KeyedAccount) -> Result { +pub fn from_keyed_account(account: &KeyedAccount) -> Result { if !check_id(account.unsigned_key()) { return Err(InstructionError::InvalidArgument); } - Current::from(account.account).ok_or(InstructionError::InvalidArgument) + Clock::from(account.account).ok_or(InstructionError::InvalidArgument) } #[cfg(test)] @@ -73,7 +73,7 @@ mod tests { #[test] fn test_create_account() { let account = create_account(1, 0, 0, 0, 0); - let current = Current::from(&account).unwrap(); - assert_eq!(current, Current::default()); + let clock = Clock::from(&account).unwrap(); + assert_eq!(clock, Clock::default()); } } diff --git a/sdk/src/syscall/fees.rs b/sdk/src/sysvar/fees.rs similarity index 82% rename from sdk/src/syscall/fees.rs rename to sdk/src/sysvar/fees.rs index 5fdc80a187..77d19574c9 100644 --- a/sdk/src/syscall/fees.rs +++ b/sdk/src/sysvar/fees.rs @@ -2,16 +2,16 @@ //! use crate::account::Account; use crate::fee_calculator::FeeCalculator; -use crate::syscall; +use crate::sysvar; use bincode::serialized_size; /// fees account pubkey const ID: [u8; 32] = [ - 6, 167, 211, 138, 69, 218, 104, 33, 3, 92, 89, 173, 16, 89, 109, 253, 49, 97, 98, 165, 87, 222, - 119, 112, 253, 90, 76, 184, 0, 0, 0, 0, + 6, 167, 213, 23, 24, 226, 90, 141, 131, 80, 60, 37, 26, 122, 240, 113, 38, 253, 114, 0, 223, + 111, 196, 237, 82, 106, 156, 144, 0, 0, 0, 0, ]; -crate::solana_name_id!(ID, "Sysca11Fees11111111111111111111111111111111"); +crate::solana_name_id!(ID, "SysvarFees111111111111111111111111111111111"); #[repr(C)] #[derive(Serialize, Deserialize, Debug, Default)] @@ -38,7 +38,7 @@ pub fn create_account(lamports: u64, fee_calculator: &FeeCalculator) -> Account &Fees { fee_calculator: fee_calculator.clone(), }, - &syscall::id(), + &sysvar::id(), ) .unwrap() } diff --git a/sdk/src/sysvar/mod.rs b/sdk/src/sysvar/mod.rs new file mode 100644 index 0000000000..4e1869295b --- /dev/null +++ b/sdk/src/sysvar/mod.rs @@ -0,0 +1,21 @@ +//! named accounts for synthesized data accounts for bank state, etc. +//! +use crate::pubkey::Pubkey; + +pub mod clock; +pub mod fees; +pub mod rewards; +pub mod slot_hashes; + +pub fn is_sysvar_id(id: &Pubkey) -> bool { + clock::check_id(id) || fees::check_id(id) || rewards::check_id(id) || slot_hashes::check_id(id) +} + +/// "Sysvar1111111111111111111111111111111111111" +/// owner pubkey for sysvar accounts +const ID: [u8; 32] = [ + 6, 167, 213, 23, 24, 117, 247, 41, 199, 61, 147, 64, 143, 33, 97, 32, 6, 126, 216, 140, 118, + 224, 140, 40, 127, 193, 148, 96, 0, 0, 0, 0, +]; + +crate::solana_name_id!(ID, "Sysvar1111111111111111111111111111111111111"); diff --git a/sdk/src/syscall/rewards.rs b/sdk/src/sysvar/rewards.rs similarity index 86% rename from sdk/src/syscall/rewards.rs rename to sdk/src/sysvar/rewards.rs index a8299ccefb..b5f2948603 100644 --- a/sdk/src/syscall/rewards.rs +++ b/sdk/src/sysvar/rewards.rs @@ -1,16 +1,16 @@ //! This account contains the current cluster rewards point values //! use crate::account::Account; -use crate::syscall; +use crate::sysvar; use bincode::serialized_size; /// account pubkey const ID: [u8; 32] = [ - 6, 167, 211, 138, 69, 219, 174, 221, 84, 28, 161, 202, 169, 28, 9, 210, 255, 70, 57, 99, 48, - 156, 150, 32, 59, 104, 53, 117, 192, 0, 0, 0, + 6, 167, 213, 23, 25, 44, 97, 55, 206, 224, 146, 217, 182, 146, 62, 225, 204, 214, 25, 3, 250, + 130, 184, 161, 97, 145, 87, 141, 128, 0, 0, 0, ]; -crate::solana_name_id!(ID, "Sysca11Rewards11111111111111111111111111111"); +crate::solana_name_id!(ID, "SysvarRewards111111111111111111111111111111"); #[repr(C)] #[derive(Serialize, Deserialize, Debug, Default, PartialEq)] @@ -42,7 +42,7 @@ pub fn create_account( validator_point_value, storage_point_value, }, - &syscall::id(), + &sysvar::id(), ) .unwrap() } diff --git a/sdk/src/syscall/slot_hashes.rs b/sdk/src/sysvar/slot_hashes.rs similarity index 86% rename from sdk/src/syscall/slot_hashes.rs rename to sdk/src/sysvar/slot_hashes.rs index cce9fb24db..6bf50bc6f9 100644 --- a/sdk/src/syscall/slot_hashes.rs +++ b/sdk/src/sysvar/slot_hashes.rs @@ -4,27 +4,18 @@ //! use crate::account::Account; use crate::hash::Hash; -use crate::pubkey::Pubkey; -use crate::syscall; +use crate::sysvar; use bincode::serialized_size; use std::ops::Deref; pub use crate::timing::Slot; -/// "Sysca11SlotHashes11111111111111111111111111" -/// slot hashes account pubkey const ID: [u8; 32] = [ - 6, 167, 211, 138, 69, 219, 186, 157, 48, 170, 46, 66, 2, 146, 193, 59, 39, 59, 245, 188, 30, - 60, 130, 78, 86, 27, 113, 191, 208, 0, 0, 0, + 6, 167, 213, 23, 25, 44, 97, 55, 206, 224, 146, 217, 182, 146, 62, 225, 204, 214, 25, 3, 250, + 130, 184, 161, 97, 145, 87, 141, 128, 0, 0, 0, ]; -pub fn id() -> Pubkey { - Pubkey::new(&ID) -} - -pub fn check_id(pubkey: &Pubkey) -> bool { - pubkey.as_ref() == ID -} +crate::solana_name_id!(ID, "SysvarRewards111111111111111111111111111111"); pub const MAX_SLOT_HASHES: usize = 512; // 512 slots to get your vote in @@ -67,7 +58,7 @@ impl Deref for SlotHashes { } pub fn create_account(lamports: u64, slot_hashes: &[(Slot, Hash)]) -> Account { - let mut account = Account::new(lamports, SlotHashes::size_of(), &syscall::id()); + let mut account = Account::new(lamports, SlotHashes::size_of(), &sysvar::id()); SlotHashes::new(slot_hashes).to(&mut account).unwrap(); account }