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

Refactor: process_instruction() (#20448)

Browse Source 
* Adds first_instruction_account parameter to process_instruction().

* Removes InvokeContext::remove_first_keyed_account() from all BPF loaders.

* Removes InvokeContext::remove_first_keyed_account() from all builtin programs.

* Removes InvokeContext::remove_first_keyed_account() from all mock ups.

* Deprecates InvokeContext::remove_first_keyed_account().

* Documents index base of keyed_account_at_index().

* Adds dynamic offset to call sites of "keyed_account_at_index()".
This commit is contained in:
Alexander Meißner
2021-10-08 11:41:07 +02:00
committed by GitHub
parent a6a4cfda89
commit 4e65487d2f
17 changed files with 1364 additions and 1366 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
program-runtime/src/instruction_processor.rs
View File

@ -283,6 +283,7 @@ impl std::fmt::Debug for InstructionProcessor {
// These are just type aliases for work around of Debug-ing above pointers // These are just type aliases for work around of Debug-ing above pointers
type ErasedProcessInstructionWithContext = fn( type ErasedProcessInstructionWithContext = fn(
&'static Pubkey, &'static Pubkey,
usize,
&'static [u8], &'static [u8],
&'static mut dyn InvokeContext, &'static mut dyn InvokeContext,
) -> Result<(), InstructionError>; ) -> Result<(), InstructionError>;
@ -361,15 +362,20 @@ impl InstructionProcessor {
if solana_sdk::native_loader::check_id(&root_account.owner()?) { if solana_sdk::native_loader::check_id(&root_account.owner()?) {
for (id, process_instruction) in &self.programs { for (id, process_instruction) in &self.programs {
if id == root_id { if id == root_id {
invoke_context.remove_first_keyed_account()?;
// Call the builtin program // Call the builtin program
return process_instruction(program_id, instruction_data, invoke_context); return process_instruction(
program_id,
1, // root_id to be skipped
instruction_data,
invoke_context,
);
} }
} }
if !invoke_context.is_feature_active(&remove_native_loader::id()) { if !invoke_context.is_feature_active(&remove_native_loader::id()) {
// Call the program via the native loader // Call the program via the native loader
return self.native_loader.process_instruction( return self.native_loader.process_instruction(
&solana_sdk::native_loader::id(), &solana_sdk::native_loader::id(),
0,
instruction_data, instruction_data,
invoke_context, invoke_context,
); );
@ -379,7 +385,12 @@ impl InstructionProcessor {
for (id, process_instruction) in &self.programs { for (id, process_instruction) in &self.programs {
if id == owner_id { if id == owner_id {
// Call the program via a builtin loader // Call the program via a builtin loader
return process_instruction(program_id, instruction_data, invoke_context); return process_instruction(
program_id,
0, // no root_id was provided
instruction_data,
invoke_context,
);
} }
} }
} }
@ -1074,6 +1085,7 @@ mod tests {
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps)]
fn mock_process_instruction( fn mock_process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
@ -1082,6 +1094,7 @@ mod tests {
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps)]
fn mock_ix_processor( fn mock_ix_processor(
_pubkey: &Pubkey, _pubkey: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_context: &mut dyn InvokeContext, _context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {

4
program-runtime/src/native_loader.rs
View File

@ -138,12 +138,13 @@ impl NativeLoader {
pub fn process_instruction( pub fn process_instruction(
&self, &self,
program_id: &Pubkey, program_id: &Pubkey,
first_instruction_account: usize,
instruction_data: &[u8], instruction_data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
let (program_id, name_vec) = { let (program_id, name_vec) = {
let keyed_accounts = invoke_context.get_keyed_accounts()?; let keyed_accounts = invoke_context.get_keyed_accounts()?;
let program = keyed_account_at_index(keyed_accounts, 0)?; let program = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
if native_loader::id() != *program_id { if native_loader::id() != *program_id {
error!("Program id mismatch"); error!("Program id mismatch");
return Err(InstructionError::IncorrectProgramId); return Err(InstructionError::IncorrectProgramId);
@ -173,6 +174,7 @@ impl NativeLoader {
return Err(NativeLoaderError::InvalidAccountData.into()); return Err(NativeLoaderError::InvalidAccountData.into());
} }
trace!("Call native {:?}", name); trace!("Call native {:?}", name);
#[allow(deprecated)]
invoke_context.remove_first_keyed_account()?; invoke_context.remove_first_keyed_account()?;
if name.ends_with("loader_program") { if name.ends_with("loader_program") {
let entrypoint = let entrypoint =

6
program-test/src/lib.rs
View File

@ -101,6 +101,7 @@ fn get_invoke_context<'a>() -> &'a mut dyn InvokeContext {
pub fn builtin_process_instruction( pub fn builtin_process_instruction(
process_instruction: solana_sdk::entrypoint::ProcessInstruction, process_instruction: solana_sdk::entrypoint::ProcessInstruction,
program_id: &Pubkey, program_id: &Pubkey,
_first_instruction_account: usize,
input: &[u8], input: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
@ -109,7 +110,8 @@ pub fn builtin_process_instruction(
let logger = invoke_context.get_logger(); let logger = invoke_context.get_logger();
stable_log::program_invoke(&logger, program_id, invoke_context.invoke_depth()); stable_log::program_invoke(&logger, program_id, invoke_context.invoke_depth());
let keyed_accounts = invoke_context.get_keyed_accounts()?; // Skip the processor account
let keyed_accounts = &invoke_context.get_keyed_accounts()?[1..];
// Copy all the accounts into a HashMap to ensure there are no duplicates // Copy all the accounts into a HashMap to ensure there are no duplicates
let mut accounts: HashMap<Pubkey, Account> = keyed_accounts let mut accounts: HashMap<Pubkey, Account> = keyed_accounts
@ -183,11 +185,13 @@ macro_rules! processor {
($process_instruction:expr) => { ($process_instruction:expr) => {
Some( Some(
|program_id: &Pubkey, |program_id: &Pubkey,
first_instruction_account: usize,
input: &[u8], input: &[u8],
invoke_context: &mut dyn solana_sdk::process_instruction::InvokeContext| { invoke_context: &mut dyn solana_sdk::process_instruction::InvokeContext| {
$crate::builtin_process_instruction( $crate::builtin_process_instruction(
$process_instruction, $process_instruction,
program_id, program_id,
first_instruction_account,
input, input,
invoke_context, invoke_context,
) )

1354
programs/bpf_loader/src/lib.rs
View File

File diff suppressed because it is too large Load Diff

1
programs/compute-budget/src/lib.rs
View File

@ -4,6 +4,7 @@ use solana_sdk::{
pub fn process_instruction( pub fn process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {

226
programs/config/src/config_processor.rs
View File

@ -15,13 +15,15 @@ use std::collections::BTreeSet;
pub fn process_instruction( pub fn process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
first_instruction_account: usize,
data: &[u8], data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
let keyed_accounts = invoke_context.get_keyed_accounts()?; let keyed_accounts = invoke_context.get_keyed_accounts()?;
let key_list: ConfigKeys = limited_deserialize(data)?; let key_list: ConfigKeys = limited_deserialize(data)?;
let config_keyed_account = &mut keyed_account_at_index(keyed_accounts, 0)?; let config_keyed_account =
&mut keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let current_data: ConfigKeys = { let current_data: ConfigKeys = {
let config_account = config_keyed_account.try_account_ref_mut()?; let config_account = config_keyed_account.try_account_ref_mut()?;
if config_account.owner() != &crate::id() { if config_account.owner() != &crate::id() {
@ -53,7 +55,7 @@ pub fn process_instruction(
} }
let mut counter = 0; let mut counter = 0;
let mut keyed_accounts_iter = keyed_accounts.iter().skip(1); let mut keyed_accounts_iter = keyed_accounts.iter().skip(2);
for (signer, _) in key_list.keys.iter().filter(|(_, is_signer)| *is_signer) { for (signer, _) in key_list.keys.iter().filter(|(_, is_signer)| *is_signer) {
counter += 1; counter += 1;
if signer != config_keyed_account.unsigned_key() { if signer != config_keyed_account.unsigned_key() {
@ -147,6 +149,22 @@ mod tests {
}; };
use std::cell::RefCell; use std::cell::RefCell;
fn process_instruction(
owner: &Pubkey,
instruction_data: &[u8],
keyed_accounts: &[(bool, bool, &Pubkey, &RefCell<AccountSharedData>)],
) -> Result<(), InstructionError> {
let processor_account = AccountSharedData::new_ref(0, 0, &solana_sdk::native_loader::id());
let mut keyed_accounts = keyed_accounts.to_vec();
keyed_accounts.insert(0, (false, false, owner, &processor_account));
super::process_instruction(
owner,
1,
instruction_data,
&mut MockInvokeContext::new(create_keyed_accounts_unified(&keyed_accounts)),
)
}
#[derive(Serialize, Deserialize, Debug, PartialEq)] #[derive(Serialize, Deserialize, Debug, PartialEq)]
struct MyConfig { struct MyConfig {
pub item: u64, pub item: u64,
@ -193,14 +211,9 @@ mod tests {
owner: id(), owner: id(),
..Account::default() ..Account::default()
})); }));
let accounts = vec![(true, false, &config_pubkey, &config_account)]; let keyed_accounts = [(true, false, &config_pubkey, &config_account)];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instructions[1].data, &keyed_accounts),
&id(),
&instructions[1].data,
&mut MockInvokeContext::new(keyed_accounts)
),
Ok(()) Ok(())
); );
@ -210,8 +223,7 @@ mod tests {
#[test] #[test]
fn test_process_create_ok() { fn test_process_create_ok() {
solana_logger::setup(); solana_logger::setup();
let keys = vec![]; let (_, config_account) = create_config_account(vec![]);
let (_, config_account) = create_config_account(keys);
assert_eq!( assert_eq!(
Some(MyConfig::default()), Some(MyConfig::default()),
deserialize(get_config_data(config_account.borrow().data()).unwrap()).ok() deserialize(get_config_data(config_account.borrow().data()).unwrap()).ok()
@ -227,14 +239,9 @@ mod tests {
let my_config = MyConfig::new(42); let my_config = MyConfig::new(42);
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config); let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
let accounts = vec![(true, false, &config_pubkey, &config_account)]; let keyed_accounts = [(true, false, &config_pubkey, &config_account)];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Ok(()) Ok(())
); );
assert_eq!( assert_eq!(
@ -253,14 +260,9 @@ mod tests {
let mut instruction = config_instruction::store(&config_pubkey, true, keys, &my_config); let mut instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
instruction.data = vec![0; 123]; // <-- Replace data with a vector that's too large instruction.data = vec![0; 123]; // <-- Replace data with a vector that's too large
let accounts = vec![(true, false, &config_pubkey, &config_account)]; let keyed_accounts = [(true, false, &config_pubkey, &config_account)];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::InvalidInstructionData) Err(InstructionError::InvalidInstructionData)
); );
} }
@ -275,14 +277,9 @@ mod tests {
let mut instruction = config_instruction::store(&config_pubkey, true, vec![], &my_config); let mut instruction = config_instruction::store(&config_pubkey, true, vec![], &my_config);
instruction.accounts[0].is_signer = false; // <----- not a signer instruction.accounts[0].is_signer = false; // <----- not a signer
let accounts = vec![(false, false, &config_pubkey, &config_account)]; let keyed_accounts = [(false, false, &config_pubkey, &config_account)];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::MissingRequiredSignature) Err(InstructionError::MissingRequiredSignature)
); );
} }
@ -305,18 +302,13 @@ mod tests {
let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config); let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config);
let signer0_account = RefCell::new(AccountSharedData::default()); let signer0_account = RefCell::new(AccountSharedData::default());
let signer1_account = RefCell::new(AccountSharedData::default()); let signer1_account = RefCell::new(AccountSharedData::default());
let accounts = vec![ let keyed_accounts = [
(true, false, &config_pubkey, &config_account), (true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account), (true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer1_pubkey, &signer1_account), (true, false, &signer1_pubkey, &signer1_account),
]; ];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Ok(()) Ok(())
); );
let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap(); let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap();
@ -342,14 +334,9 @@ mod tests {
owner: id(), owner: id(),
..Account::default() ..Account::default()
})); }));
let accounts = vec![(true, false, &signer0_pubkey, &signer0_account)]; let keyed_accounts = [(true, false, &signer0_pubkey, &signer0_account)];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::InvalidAccountData) Err(InstructionError::InvalidAccountData)
); );
} }
@ -369,32 +356,19 @@ mod tests {
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config); let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
// Config-data pubkey doesn't match signer // Config-data pubkey doesn't match signer
let accounts = vec![ let mut keyed_accounts = [
(true, false, &config_pubkey, &config_account), (true, false, &config_pubkey, &config_account),
(true, false, &signer1_pubkey, &signer1_account), (true, false, &signer1_pubkey, &signer1_account),
]; ];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::MissingRequiredSignature) Err(InstructionError::MissingRequiredSignature)
); );
// Config-data pubkey not a signer // Config-data pubkey not a signer
let accounts = vec![ keyed_accounts[1] = (false, false, &signer0_pubkey, &signer0_account);
(true, false, &config_pubkey, &config_account),
(false, false, &signer0_pubkey, &signer0_account),
];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::MissingRequiredSignature) Err(InstructionError::MissingRequiredSignature)
); );
} }
@ -419,18 +393,13 @@ mod tests {
let my_config = MyConfig::new(42); let my_config = MyConfig::new(42);
let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config); let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config);
let accounts = vec![ let mut keyed_accounts = [
(true, false, &config_pubkey, &config_account), (true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account), (true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer1_pubkey, &signer1_account), (true, false, &signer1_pubkey, &signer1_account),
]; ];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Ok(()) Ok(())
); );
@ -438,18 +407,9 @@ mod tests {
let new_config = MyConfig::new(84); let new_config = MyConfig::new(84);
let instruction = let instruction =
config_instruction::store(&config_pubkey, false, keys.clone(), &new_config); config_instruction::store(&config_pubkey, false, keys.clone(), &new_config);
let accounts = vec![ keyed_accounts[0].0 = false;
(false, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer1_pubkey, &signer1_account),
];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Ok(()) Ok(())
); );
let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap(); let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap();
@ -463,18 +423,9 @@ mod tests {
// Attempt update with incomplete signatures // Attempt update with incomplete signatures
let keys = vec![(pubkey, false), (signer0_pubkey, true)]; let keys = vec![(pubkey, false), (signer0_pubkey, true)];
let instruction = config_instruction::store(&config_pubkey, false, keys, &my_config); let instruction = config_instruction::store(&config_pubkey, false, keys, &my_config);
let accounts = vec![ keyed_accounts[2].0 = false;
(false, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
(false, false, &signer1_pubkey, &signer1_account),
];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::MissingRequiredSignature) Err(InstructionError::MissingRequiredSignature)
); );
@ -485,18 +436,9 @@ mod tests {
(signer2_pubkey, true), (signer2_pubkey, true),
]; ];
let instruction = config_instruction::store(&config_pubkey, false, keys, &my_config); let instruction = config_instruction::store(&config_pubkey, false, keys, &my_config);
let accounts = vec![ keyed_accounts[2] = (true, false, &signer2_pubkey, &signer2_account);
(false, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer2_pubkey, &signer2_account),
];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::MissingRequiredSignature) Err(InstructionError::MissingRequiredSignature)
); );
} }
@ -518,18 +460,13 @@ mod tests {
// Attempt initialization with duplicate signer inputs // Attempt initialization with duplicate signer inputs
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config); let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
let accounts = vec![ let keyed_accounts = [
(true, false, &config_pubkey, &config_account), (true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account), (true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer0_pubkey, &signer0_account), (true, false, &signer0_pubkey, &signer0_account),
]; ];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::InvalidArgument), Err(InstructionError::InvalidArgument),
); );
} }
@ -552,18 +489,13 @@ mod tests {
let my_config = MyConfig::new(42); let my_config = MyConfig::new(42);
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config); let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
let accounts = vec![ let mut keyed_accounts = [
(true, false, &config_pubkey, &config_account), (true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account), (true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer1_pubkey, &signer1_account), (true, false, &signer1_pubkey, &signer1_account),
]; ];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Ok(()), Ok(()),
); );
@ -575,18 +507,9 @@ mod tests {
(signer0_pubkey, true), (signer0_pubkey, true),
]; ];
let instruction = config_instruction::store(&config_pubkey, false, dupe_keys, &new_config); let instruction = config_instruction::store(&config_pubkey, false, dupe_keys, &new_config);
let accounts = vec![ keyed_accounts[2] = keyed_accounts[1];
(false, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer0_pubkey, &signer0_account),
];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::InvalidArgument), Err(InstructionError::InvalidArgument),
); );
} }
@ -613,17 +536,12 @@ mod tests {
]; ];
let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config); let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config);
let accounts = vec![ let keyed_accounts = [
(true, false, &config_pubkey, &config_account), (true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account), (true, false, &signer0_pubkey, &signer0_account),
]; ];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Ok(()) Ok(())
); );
@ -631,17 +549,8 @@ mod tests {
let new_config = MyConfig::new(84); let new_config = MyConfig::new(84);
let instruction = let instruction =
config_instruction::store(&config_pubkey, true, keys.clone(), &new_config); config_instruction::store(&config_pubkey, true, keys.clone(), &new_config);
let accounts = vec![
(true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Ok(()) Ok(())
); );
let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap(); let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap();
@ -655,14 +564,8 @@ mod tests {
// Attempt update with incomplete signatures // Attempt update with incomplete signatures
let keys = vec![(pubkey, false), (config_keypair.pubkey(), true)]; let keys = vec![(pubkey, false), (config_keypair.pubkey(), true)];
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config); let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
let accounts = vec![(true, false, &config_pubkey, &config_account)];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts[0..1]),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::MissingRequiredSignature) Err(InstructionError::MissingRequiredSignature)
); );
} }
@ -671,16 +574,11 @@ mod tests {
fn test_config_initialize_no_panic() { fn test_config_initialize_no_panic() {
let from_pubkey = solana_sdk::pubkey::new_rand(); let from_pubkey = solana_sdk::pubkey::new_rand();
let config_pubkey = solana_sdk::pubkey::new_rand(); let config_pubkey = solana_sdk::pubkey::new_rand();
let (_, _config_account) = create_config_account(vec![]);
let instructions = let instructions =
config_instruction::create_account::<MyConfig>(&from_pubkey, &config_pubkey, 1, vec![]); config_instruction::create_account::<MyConfig>(&from_pubkey, &config_pubkey, 1, vec![]);
let accounts = vec![];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instructions[1].data, &[]),
&id(),
&instructions[1].data,
&mut MockInvokeContext::new(keyed_accounts)
),
Err(InstructionError::NotEnoughAccountKeys) Err(InstructionError::NotEnoughAccountKeys)
); );
} }
@ -693,6 +591,7 @@ mod tests {
let signer0_pubkey = solana_sdk::pubkey::new_rand(); let signer0_pubkey = solana_sdk::pubkey::new_rand();
let signer0_account = RefCell::new(AccountSharedData::default()); let signer0_account = RefCell::new(AccountSharedData::default());
let config_account = RefCell::new(AccountSharedData::default()); let config_account = RefCell::new(AccountSharedData::default());
let (_, _config_account) = create_config_account(vec![]);
let keys = vec![ let keys = vec![
(from_pubkey, false), (from_pubkey, false),
(signer0_pubkey, true), (signer0_pubkey, true),
@ -700,17 +599,12 @@ mod tests {
]; ];
let instruction = config_instruction::store(&config_pubkey, true, keys, &new_config); let instruction = config_instruction::store(&config_pubkey, true, keys, &new_config);
let accounts = vec![ let keyed_accounts = [
(true, false, &config_pubkey, &config_account), (true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account), (true, false, &signer0_pubkey, &signer0_account),
]; ];
let keyed_accounts = create_keyed_accounts_unified(&accounts);
assert_eq!( assert_eq!(
process_instruction( process_instruction(&id(), &instruction.data, &keyed_accounts),
&id(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts),
),
Err(InstructionError::InvalidAccountOwner) Err(InstructionError::InvalidAccountOwner)
); );
} }

439
programs/stake/src/stake_instruction.rs
View File

@ -25,6 +25,7 @@ pub use solana_sdk::stake::instruction::*;
pub fn process_instruction( pub fn process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
first_instruction_account: usize,
data: &[u8], data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
@ -33,19 +34,20 @@ pub fn process_instruction(
trace!("process_instruction: {:?}", data); trace!("process_instruction: {:?}", data);
trace!("keyed_accounts: {:?}", keyed_accounts); trace!("keyed_accounts: {:?}", keyed_accounts);
let signers = get_signers(keyed_accounts); let me = &keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let me = &keyed_account_at_index(keyed_accounts, 0)?;
if me.owner()? != id() { if me.owner()? != id() {
return Err(InstructionError::InvalidAccountOwner); return Err(InstructionError::InvalidAccountOwner);
} }
let signers = get_signers(&keyed_accounts[1..]);
match limited_deserialize(data)? { match limited_deserialize(data)? {
StakeInstruction::Initialize(authorized, lockup) => me.initialize( StakeInstruction::Initialize(authorized, lockup) => me.initialize(
&authorized, &authorized,
&lockup, &lockup,
&from_keyed_account::<Rent>(keyed_account_at_index(keyed_accounts, 1)?)?, &from_keyed_account::<Rent>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 1,
)?)?,
), ),
StakeInstruction::Authorize(authorized_pubkey, stake_authorize) => { StakeInstruction::Authorize(authorized_pubkey, stake_authorize) => {
let require_custodian_for_locked_stake_authorize = invoke_context.is_feature_active( let require_custodian_for_locked_stake_authorize = invoke_context.is_feature_active(
@ -53,12 +55,16 @@ pub fn process_instruction(
); );
if require_custodian_for_locked_stake_authorize { if require_custodian_for_locked_stake_authorize {
let clock = let clock = from_keyed_account::<Clock>(keyed_account_at_index(
from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 1)?)?; keyed_accounts,
let _current_authority = keyed_account_at_index(keyed_accounts, 2)?; first_instruction_account + 1,
let custodian = keyed_account_at_index(keyed_accounts, 3) )?)?;
.ok() let _current_authority =
.map(|ka| ka.unsigned_key()); keyed_account_at_index(keyed_accounts, first_instruction_account + 2)?;
let custodian =
keyed_account_at_index(keyed_accounts, first_instruction_account + 3)
.ok()
.map(|ka| ka.unsigned_key());
me.authorize( me.authorize(
&signers, &signers,
@ -80,17 +86,21 @@ pub fn process_instruction(
} }
} }
StakeInstruction::AuthorizeWithSeed(args) => { StakeInstruction::AuthorizeWithSeed(args) => {
let authority_base = keyed_account_at_index(keyed_accounts, 1)?; let authority_base =
keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
let require_custodian_for_locked_stake_authorize = invoke_context.is_feature_active( let require_custodian_for_locked_stake_authorize = invoke_context.is_feature_active(
&feature_set::require_custodian_for_locked_stake_authorize::id(), &feature_set::require_custodian_for_locked_stake_authorize::id(),
); );
if require_custodian_for_locked_stake_authorize { if require_custodian_for_locked_stake_authorize {
let clock = let clock = from_keyed_account::<Clock>(keyed_account_at_index(
from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 2)?)?; keyed_accounts,
let custodian = keyed_account_at_index(keyed_accounts, 3) first_instruction_account + 2,
.ok() )?)?;
.map(|ka| ka.unsigned_key()); let custodian =
keyed_account_at_index(keyed_accounts, first_instruction_account + 3)
.ok()
.map(|ka| ka.unsigned_key());
me.authorize_with_seed( me.authorize_with_seed(
authority_base, authority_base,
@ -118,48 +128,74 @@ pub fn process_instruction(
StakeInstruction::DelegateStake => { StakeInstruction::DelegateStake => {
let can_reverse_deactivation = let can_reverse_deactivation =
invoke_context.is_feature_active(&feature_set::stake_program_v4::id()); invoke_context.is_feature_active(&feature_set::stake_program_v4::id());
let vote = keyed_account_at_index(keyed_accounts, 1)?; let vote = keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
me.delegate( me.delegate(
vote, vote,
&from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 2)?)?, &from_keyed_account::<Clock>(keyed_account_at_index(
&from_keyed_account::<StakeHistory>(keyed_account_at_index(keyed_accounts, 3)?)?, keyed_accounts,
&config::from_keyed_account(keyed_account_at_index(keyed_accounts, 4)?)?, first_instruction_account + 2,
)?)?,
&from_keyed_account::<StakeHistory>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 3,
)?)?,
&config::from_keyed_account(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 4,
)?)?,
&signers, &signers,
can_reverse_deactivation, can_reverse_deactivation,
) )
} }
StakeInstruction::Split(lamports) => { StakeInstruction::Split(lamports) => {
let split_stake = &keyed_account_at_index(keyed_accounts, 1)?; let split_stake =
&keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
me.split(lamports, split_stake, &signers) me.split(lamports, split_stake, &signers)
} }
StakeInstruction::Merge => { StakeInstruction::Merge => {
let source_stake = &keyed_account_at_index(keyed_accounts, 1)?; let source_stake =
&keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
let can_merge_expired_lockups = let can_merge_expired_lockups =
invoke_context.is_feature_active(&feature_set::stake_program_v4::id()); invoke_context.is_feature_active(&feature_set::stake_program_v4::id());
me.merge( me.merge(
invoke_context, invoke_context,
source_stake, source_stake,
&from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 2)?)?, &from_keyed_account::<Clock>(keyed_account_at_index(
&from_keyed_account::<StakeHistory>(keyed_account_at_index(keyed_accounts, 3)?)?, keyed_accounts,
first_instruction_account + 2,
)?)?,
&from_keyed_account::<StakeHistory>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 3,
)?)?,
&signers, &signers,
can_merge_expired_lockups, can_merge_expired_lockups,
) )
} }
StakeInstruction::Withdraw(lamports) => { StakeInstruction::Withdraw(lamports) => {
let to = &keyed_account_at_index(keyed_accounts, 1)?; let to = &keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
me.withdraw( me.withdraw(
lamports, lamports,
to, to,
&from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 2)?)?, &from_keyed_account::<Clock>(keyed_account_at_index(
&from_keyed_account::<StakeHistory>(keyed_account_at_index(keyed_accounts, 3)?)?, keyed_accounts,
keyed_account_at_index(keyed_accounts, 4)?, first_instruction_account + 2,
keyed_account_at_index(keyed_accounts, 5).ok(), )?)?,
&from_keyed_account::<StakeHistory>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 3,
)?)?,
keyed_account_at_index(keyed_accounts, first_instruction_account + 4)?,
keyed_account_at_index(keyed_accounts, first_instruction_account + 5).ok(),
invoke_context.is_feature_active(&feature_set::stake_program_v4::id()), invoke_context.is_feature_active(&feature_set::stake_program_v4::id()),
) )
} }
StakeInstruction::Deactivate => me.deactivate( StakeInstruction::Deactivate => me.deactivate(
&from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 1)?)?, &from_keyed_account::<Clock>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 1,
)?)?,
&signers, &signers,
), ),
StakeInstruction::SetLockup(lockup) => { StakeInstruction::SetLockup(lockup) => {
@ -174,16 +210,23 @@ pub fn process_instruction(
if invoke_context.is_feature_active(&feature_set::vote_stake_checked_instructions::id()) if invoke_context.is_feature_active(&feature_set::vote_stake_checked_instructions::id())
{ {
let authorized = Authorized { let authorized = Authorized {
staker: *keyed_account_at_index(keyed_accounts, 2)?.unsigned_key(), staker: *keyed_account_at_index(keyed_accounts, first_instruction_account + 2)?
withdrawer: *keyed_account_at_index(keyed_accounts, 3)? .unsigned_key(),
.signer_key() withdrawer: *keyed_account_at_index(
.ok_or(InstructionError::MissingRequiredSignature)?, keyed_accounts,
first_instruction_account + 3,
)?
.signer_key()
.ok_or(InstructionError::MissingRequiredSignature)?,
}; };
me.initialize( me.initialize(
&authorized, &authorized,
&Lockup::default(), &Lockup::default(),
&from_keyed_account::<Rent>(keyed_account_at_index(keyed_accounts, 1)?)?, &from_keyed_account::<Rent>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 1,
)?)?,
) )
} else { } else {
Err(InstructionError::InvalidInstructionData) Err(InstructionError::InvalidInstructionData)
@ -192,15 +235,20 @@ pub fn process_instruction(
StakeInstruction::AuthorizeChecked(stake_authorize) => { StakeInstruction::AuthorizeChecked(stake_authorize) => {
if invoke_context.is_feature_active(&feature_set::vote_stake_checked_instructions::id()) if invoke_context.is_feature_active(&feature_set::vote_stake_checked_instructions::id())
{ {
let clock = let clock = from_keyed_account::<Clock>(keyed_account_at_index(
from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 1)?)?; keyed_accounts,
let _current_authority = keyed_account_at_index(keyed_accounts, 2)?; first_instruction_account + 1,
let authorized_pubkey = &keyed_account_at_index(keyed_accounts, 3)? )?)?;
.signer_key() let _current_authority =
.ok_or(InstructionError::MissingRequiredSignature)?; keyed_account_at_index(keyed_accounts, first_instruction_account + 2)?;
let custodian = keyed_account_at_index(keyed_accounts, 4) let authorized_pubkey =
.ok() &keyed_account_at_index(keyed_accounts, first_instruction_account + 3)?
.map(|ka| ka.unsigned_key()); .signer_key()
.ok_or(InstructionError::MissingRequiredSignature)?;
let custodian =
keyed_account_at_index(keyed_accounts, first_instruction_account + 4)
.ok()
.map(|ka| ka.unsigned_key());
me.authorize( me.authorize(
&signers, &signers,
@ -217,15 +265,20 @@ pub fn process_instruction(
StakeInstruction::AuthorizeCheckedWithSeed(args) => { StakeInstruction::AuthorizeCheckedWithSeed(args) => {
if invoke_context.is_feature_active(&feature_set::vote_stake_checked_instructions::id()) if invoke_context.is_feature_active(&feature_set::vote_stake_checked_instructions::id())
{ {
let authority_base = keyed_account_at_index(keyed_accounts, 1)?; let authority_base =
let clock = keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 2)?)?; let clock = from_keyed_account::<Clock>(keyed_account_at_index(
let authorized_pubkey = &keyed_account_at_index(keyed_accounts, 3)? keyed_accounts,
.signer_key() first_instruction_account + 2,
.ok_or(InstructionError::MissingRequiredSignature)?; )?)?;
let custodian = keyed_account_at_index(keyed_accounts, 4) let authorized_pubkey =
.ok() &keyed_account_at_index(keyed_accounts, first_instruction_account + 3)?
.map(|ka| ka.unsigned_key()); .signer_key()
.ok_or(InstructionError::MissingRequiredSignature)?;
let custodian =
keyed_account_at_index(keyed_accounts, first_instruction_account + 4)
.ok()
.map(|ka| ka.unsigned_key());
me.authorize_with_seed( me.authorize_with_seed(
authority_base, authority_base,
@ -244,7 +297,9 @@ pub fn process_instruction(
StakeInstruction::SetLockupChecked(lockup_checked) => { StakeInstruction::SetLockupChecked(lockup_checked) => {
if invoke_context.is_feature_active(&feature_set::vote_stake_checked_instructions::id()) if invoke_context.is_feature_active(&feature_set::vote_stake_checked_instructions::id())
{ {
let custodian = if let Ok(custodian) = keyed_account_at_index(keyed_accounts, 2) { let custodian = if let Ok(custodian) =
keyed_account_at_index(keyed_accounts, first_instruction_account + 2)
{
Some( Some(
*custodian *custodian
.signer_key() .signer_key()
@ -276,7 +331,7 @@ mod tests {
use solana_sdk::{ use solana_sdk::{
account::{self, Account, AccountSharedData, WritableAccount}, account::{self, Account, AccountSharedData, WritableAccount},
instruction::{AccountMeta, Instruction}, instruction::{AccountMeta, Instruction},
keyed_account::KeyedAccount, keyed_account::create_keyed_accounts_unified,
process_instruction::{mock_set_sysvar, MockInvokeContext}, process_instruction::{mock_set_sysvar, MockInvokeContext},
rent::Rent, rent::Rent,
stake::{ stake::{
@ -315,7 +370,27 @@ mod tests {
Pubkey::from_str("Spoofed111111111111111111111111111111111111").unwrap() Pubkey::from_str("Spoofed111111111111111111111111111111111111").unwrap()
} }
fn process_instruction(instruction: &Instruction) -> Result<(), InstructionError> { fn process_instruction(
owner: &Pubkey,
instruction_data: &[u8],
keyed_accounts: &[(bool, bool, &Pubkey, &RefCell<AccountSharedData>)],
) -> Result<(), InstructionError> {
let processor_account = AccountSharedData::new_ref(0, 0, &solana_sdk::native_loader::id());
let mut keyed_accounts = keyed_accounts.to_vec();
keyed_accounts.insert(0, (false, false, owner, &processor_account));
super::process_instruction(
owner,
1,
instruction_data,
&mut MockInvokeContext::new(create_keyed_accounts_unified(&keyed_accounts)),
)
}
fn process_instruction_as_one_arg(instruction: &Instruction) -> Result<(), InstructionError> {
let processor_account = RefCell::new(AccountSharedData::from(Account {
owner: solana_sdk::native_loader::id(),
..Account::default()
}));
let accounts: Vec<_> = instruction let accounts: Vec<_> = instruction
.accounts .accounts
.iter() .iter()
@ -357,28 +432,35 @@ mod tests {
.collect(); .collect();
{ {
let keyed_accounts: Vec<_> = instruction let mut keyed_accounts: Vec<_> = instruction
.accounts .accounts
.iter() .iter()
.zip(accounts.iter()) .zip(accounts.iter())
.map(|(meta, account)| KeyedAccount::new(&meta.pubkey, meta.is_signer, account)) .map(|(meta, account)| (meta.is_signer, false, &meta.pubkey, account))
.collect(); .collect();
let processor_id = id();
let mut invoke_context = MockInvokeContext::new(keyed_accounts); keyed_accounts.insert(0, (false, false, &processor_id, &processor_account));
let mut invoke_context =
MockInvokeContext::new(create_keyed_accounts_unified(&keyed_accounts));
mock_set_sysvar( mock_set_sysvar(
&mut invoke_context, &mut invoke_context,
sysvar::clock::id(), sysvar::clock::id(),
sysvar::clock::Clock::default(), sysvar::clock::Clock::default(),
) )
.unwrap(); .unwrap();
super::process_instruction(&Pubkey::default(), &instruction.data, &mut invoke_context) super::process_instruction(
&Pubkey::default(),
1,
&instruction.data,
&mut invoke_context,
)
} }
} }
#[test] #[test]
fn test_stake_process_instruction() { fn test_stake_process_instruction() {
assert_eq!( assert_eq!(
process_instruction(&instruction::initialize( process_instruction_as_one_arg(&instruction::initialize(
&Pubkey::default(), &Pubkey::default(),
&Authorized::default(), &Authorized::default(),
&Lockup::default() &Lockup::default()
@ -386,7 +468,7 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction(&instruction::authorize( process_instruction_as_one_arg(&instruction::authorize(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
@ -396,7 +478,7 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction( process_instruction_as_one_arg(
&instruction::split( &instruction::split(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
@ -407,7 +489,7 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction( process_instruction_as_one_arg(
&instruction::merge( &instruction::merge(
&Pubkey::default(), &Pubkey::default(),
&invalid_stake_state_pubkey(), &invalid_stake_state_pubkey(),
@ -417,7 +499,7 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction( process_instruction_as_one_arg(
&instruction::split_with_seed( &instruction::split_with_seed(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
@ -430,7 +512,7 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction(&instruction::delegate_stake( process_instruction_as_one_arg(&instruction::delegate_stake(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
&invalid_vote_state_pubkey(), &invalid_vote_state_pubkey(),
@ -438,7 +520,7 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction(&instruction::withdraw( process_instruction_as_one_arg(&instruction::withdraw(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
&solana_sdk::pubkey::new_rand(), &solana_sdk::pubkey::new_rand(),
@ -448,14 +530,14 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction(&instruction::deactivate_stake( process_instruction_as_one_arg(&instruction::deactivate_stake(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default() &Pubkey::default()
)), )),
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction(&instruction::set_lockup( process_instruction_as_one_arg(&instruction::set_lockup(
&Pubkey::default(), &Pubkey::default(),
&LockupArgs::default(), &LockupArgs::default(),
&Pubkey::default() &Pubkey::default()
@ -467,7 +549,7 @@ mod tests {
#[test] #[test]
fn test_spoofed_stake_accounts() { fn test_spoofed_stake_accounts() {
assert_eq!( assert_eq!(
process_instruction(&instruction::initialize( process_instruction_as_one_arg(&instruction::initialize(
&spoofed_stake_state_pubkey(), &spoofed_stake_state_pubkey(),
&Authorized::default(), &Authorized::default(),
&Lockup::default() &Lockup::default()
@ -475,7 +557,7 @@ mod tests {
Err(InstructionError::InvalidAccountOwner), Err(InstructionError::InvalidAccountOwner),
); );
assert_eq!( assert_eq!(
process_instruction(&instruction::authorize( process_instruction_as_one_arg(&instruction::authorize(
&spoofed_stake_state_pubkey(), &spoofed_stake_state_pubkey(),
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
@ -485,7 +567,7 @@ mod tests {
Err(InstructionError::InvalidAccountOwner), Err(InstructionError::InvalidAccountOwner),
); );
assert_eq!( assert_eq!(
process_instruction( process_instruction_as_one_arg(
&instruction::split( &instruction::split(
&spoofed_stake_state_pubkey(), &spoofed_stake_state_pubkey(),
&Pubkey::default(), &Pubkey::default(),
@ -496,7 +578,7 @@ mod tests {
Err(InstructionError::InvalidAccountOwner), Err(InstructionError::InvalidAccountOwner),
); );
assert_eq!( assert_eq!(
process_instruction( process_instruction_as_one_arg(
&instruction::split( &instruction::split(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
@ -507,7 +589,7 @@ mod tests {
Err(InstructionError::IncorrectProgramId), Err(InstructionError::IncorrectProgramId),
); );
assert_eq!( assert_eq!(
process_instruction( process_instruction_as_one_arg(
&instruction::merge( &instruction::merge(
&spoofed_stake_state_pubkey(), &spoofed_stake_state_pubkey(),
&Pubkey::default(), &Pubkey::default(),
@ -517,7 +599,7 @@ mod tests {
Err(InstructionError::InvalidAccountOwner), Err(InstructionError::InvalidAccountOwner),
); );
assert_eq!( assert_eq!(
process_instruction( process_instruction_as_one_arg(
&instruction::merge( &instruction::merge(
&Pubkey::default(), &Pubkey::default(),
&spoofed_stake_state_pubkey(), &spoofed_stake_state_pubkey(),
@ -527,7 +609,7 @@ mod tests {
Err(InstructionError::IncorrectProgramId), Err(InstructionError::IncorrectProgramId),
); );
assert_eq!( assert_eq!(
process_instruction( process_instruction_as_one_arg(
&instruction::split_with_seed( &instruction::split_with_seed(
&spoofed_stake_state_pubkey(), &spoofed_stake_state_pubkey(),
&Pubkey::default(), &Pubkey::default(),
@ -540,7 +622,7 @@ mod tests {
Err(InstructionError::InvalidAccountOwner), Err(InstructionError::InvalidAccountOwner),
); );
assert_eq!( assert_eq!(
process_instruction(&instruction::delegate_stake( process_instruction_as_one_arg(&instruction::delegate_stake(
&spoofed_stake_state_pubkey(), &spoofed_stake_state_pubkey(),
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
@ -548,7 +630,7 @@ mod tests {
Err(InstructionError::InvalidAccountOwner), Err(InstructionError::InvalidAccountOwner),
); );
assert_eq!( assert_eq!(
process_instruction(&instruction::withdraw( process_instruction_as_one_arg(&instruction::withdraw(
&spoofed_stake_state_pubkey(), &spoofed_stake_state_pubkey(),
&Pubkey::default(), &Pubkey::default(),
&solana_sdk::pubkey::new_rand(), &solana_sdk::pubkey::new_rand(),
@ -558,14 +640,14 @@ mod tests {
Err(InstructionError::InvalidAccountOwner), Err(InstructionError::InvalidAccountOwner),
); );
assert_eq!( assert_eq!(
process_instruction(&instruction::deactivate_stake( process_instruction_as_one_arg(&instruction::deactivate_stake(
&spoofed_stake_state_pubkey(), &spoofed_stake_state_pubkey(),
&Pubkey::default() &Pubkey::default()
)), )),
Err(InstructionError::InvalidAccountOwner), Err(InstructionError::InvalidAccountOwner),
); );
assert_eq!( assert_eq!(
process_instruction(&instruction::set_lockup( process_instruction_as_one_arg(&instruction::set_lockup(
&spoofed_stake_state_pubkey(), &spoofed_stake_state_pubkey(),
&LockupArgs::default(), &LockupArgs::default(),
&Pubkey::default() &Pubkey::default()
@ -580,14 +662,14 @@ mod tests {
// gets the "is_empty()" check // gets the "is_empty()" check
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::Initialize( &serialize(&StakeInstruction::Initialize(
Authorized::default(), Authorized::default(),
Lockup::default() Lockup::default()
)) ))
.unwrap(), .unwrap(),
&mut MockInvokeContext::new(vec![]) &[],
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -595,16 +677,16 @@ mod tests {
// no account for rent // no account for rent
let stake_address = Pubkey::default(); let stake_address = Pubkey::default();
let stake_account = create_default_stake_account(); let stake_account = create_default_stake_account();
let keyed_accounts = vec![KeyedAccount::new(&stake_address, false, &stake_account)]; let keyed_accounts = [(false, false, &stake_address, &stake_account)];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::Initialize( &serialize(&StakeInstruction::Initialize(
Authorized::default(), Authorized::default(),
Lockup::default() Lockup::default()
)) ))
.unwrap(), .unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -614,19 +696,19 @@ mod tests {
let stake_account = create_default_stake_account(); let stake_account = create_default_stake_account();
let rent_address = sysvar::rent::id(); let rent_address = sysvar::rent::id();
let rent_account = create_default_account(); let rent_account = create_default_account();
let keyed_accounts = vec![ let keyed_accounts = [
KeyedAccount::new(&stake_address, false, &stake_account), (false, false, &stake_address, &stake_account),
KeyedAccount::new(&rent_address, false, &rent_account), (false, false, &rent_address, &rent_account),
]; ];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::Initialize( &serialize(&StakeInstruction::Initialize(
Authorized::default(), Authorized::default(),
Lockup::default() Lockup::default()
)) ))
.unwrap(), .unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Err(InstructionError::InvalidArgument), Err(InstructionError::InvalidArgument),
); );
@ -638,19 +720,19 @@ mod tests {
let rent_account = RefCell::new(account::create_account_shared_data_for_test( let rent_account = RefCell::new(account::create_account_shared_data_for_test(
&Rent::default(), &Rent::default(),
)); ));
let keyed_accounts = vec![ let keyed_accounts = [
KeyedAccount::new(&stake_address, false, &stake_account), (false, false, &stake_address, &stake_account),
KeyedAccount::new(&rent_address, false, &rent_account), (false, false, &rent_address, &rent_account),
]; ];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::Initialize( &serialize(&StakeInstruction::Initialize(
Authorized::default(), Authorized::default(),
Lockup::default() Lockup::default()
)) ))
.unwrap(), .unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
@ -658,12 +740,12 @@ mod tests {
// gets the first check in delegate, wrong number of accounts // gets the first check in delegate, wrong number of accounts
let stake_address = Pubkey::default(); let stake_address = Pubkey::default();
let stake_account = create_default_stake_account(); let stake_account = create_default_stake_account();
let keyed_accounts = vec![KeyedAccount::new(&stake_address, false, &stake_account)]; let keyed_accounts = [(false, false, &stake_address, &stake_account)];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::DelegateStake).unwrap(), &serialize(&StakeInstruction::DelegateStake).unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -671,12 +753,12 @@ mod tests {
// gets the sub-check for number of args // gets the sub-check for number of args
let stake_address = Pubkey::default(); let stake_address = Pubkey::default();
let stake_account = create_default_stake_account(); let stake_account = create_default_stake_account();
let keyed_accounts = vec![KeyedAccount::new(&stake_address, false, &stake_account)]; let keyed_accounts = [(false, false, &stake_address, &stake_account)];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::DelegateStake).unwrap(), &serialize(&StakeInstruction::DelegateStake).unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -700,18 +782,18 @@ mod tests {
let config_address = stake_config::id(); let config_address = stake_config::id();
let config_account = let config_account =
RefCell::new(config::create_account(0, &stake_config::Config::default())); RefCell::new(config::create_account(0, &stake_config::Config::default()));
let keyed_accounts = vec![ let keyed_accounts = [
KeyedAccount::new(&stake_address, true, &stake_account), (true, false, &stake_address, &stake_account),
KeyedAccount::new(&vote_address, false, &bad_vote_account), (false, false, &vote_address, &bad_vote_account),
KeyedAccount::new(&clock_address, false, &clock_account), (false, false, &clock_address, &clock_account),
KeyedAccount::new(&stake_history_address, false, &stake_history_account), (false, false, &stake_history_address, &stake_history_account),
KeyedAccount::new(&config_address, false, &config_account), (false, false, &config_address, &config_account),
]; ];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::DelegateStake).unwrap(), &serialize(&StakeInstruction::DelegateStake).unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
@ -729,17 +811,17 @@ mod tests {
let stake_history_account = RefCell::new(account::create_account_shared_data_for_test( let stake_history_account = RefCell::new(account::create_account_shared_data_for_test(
&StakeHistory::default(), &StakeHistory::default(),
)); ));
let keyed_accounts = vec![ let keyed_accounts = [
KeyedAccount::new(&stake_address, false, &stake_account), (false, false, &stake_address, &stake_account),
KeyedAccount::new(&vote_address, false, &vote_account), (false, false, &vote_address, &vote_account),
KeyedAccount::new(&rewards_address, false, &rewards_account), (false, false, &rewards_address, &rewards_account),
KeyedAccount::new(&stake_history_address, false, &stake_history_account), (false, false, &stake_history_address, &stake_history_account),
]; ];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::Withdraw(42)).unwrap(), &serialize(&StakeInstruction::Withdraw(42)).unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Err(InstructionError::InvalidArgument), Err(InstructionError::InvalidArgument),
); );
@ -747,12 +829,12 @@ mod tests {
// Tests correct number of accounts are provided in withdraw // Tests correct number of accounts are provided in withdraw
let stake_address = Pubkey::default(); let stake_address = Pubkey::default();
let stake_account = create_default_stake_account(); let stake_account = create_default_stake_account();
let keyed_accounts = vec![KeyedAccount::new(&stake_address, false, &stake_account)]; let keyed_accounts = [(false, false, &stake_address, &stake_account)];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::Withdraw(42)).unwrap(), &serialize(&StakeInstruction::Withdraw(42)).unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -764,25 +846,25 @@ mod tests {
let rewards_account = RefCell::new(account::create_account_shared_data_for_test( let rewards_account = RefCell::new(account::create_account_shared_data_for_test(
&sysvar::rewards::Rewards::new(0.0), &sysvar::rewards::Rewards::new(0.0),
)); ));
let keyed_accounts = vec![ let keyed_accounts = [
KeyedAccount::new(&stake_address, false, &stake_account), (false, false, &stake_address, &stake_account),
KeyedAccount::new(&rewards_address, false, &rewards_account), (false, false, &rewards_address, &rewards_account),
]; ];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::Deactivate).unwrap(), &serialize(&StakeInstruction::Deactivate).unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Err(InstructionError::InvalidArgument), Err(InstructionError::InvalidArgument),
); );
// Tests correct number of accounts are provided in deactivate // Tests correct number of accounts are provided in deactivate
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::Deactivate).unwrap(), &serialize(&StakeInstruction::Deactivate).unwrap(),
&mut MockInvokeContext::new(vec![]) &[],
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -799,7 +881,7 @@ mod tests {
initialize_checked(&stake_address, &Authorized { staker, withdrawer }); initialize_checked(&stake_address, &Authorized { staker, withdrawer });
instruction.accounts[3] = AccountMeta::new_readonly(withdrawer, false); instruction.accounts[3] = AccountMeta::new_readonly(withdrawer, false);
assert_eq!( assert_eq!(
process_instruction(&instruction), process_instruction_as_one_arg(&instruction),
Err(InstructionError::MissingRequiredSignature), Err(InstructionError::MissingRequiredSignature),
); );
@ -816,18 +898,17 @@ mod tests {
let staker_account = create_default_account(); let staker_account = create_default_account();
let withdrawer_account = create_default_account(); let withdrawer_account = create_default_account();
let keyed_accounts = vec![ let keyed_accounts: [(bool, bool, &Pubkey, &RefCell<AccountSharedData>); 4] = [
KeyedAccount::new(&stake_address, false, &stake_account), (false, false, &stake_address, &stake_account),
KeyedAccount::new(&rent_address, false, &rent_account), (false, false, &rent_address, &rent_account),
KeyedAccount::new(&staker, false, &staker_account), (false, false, &staker, &staker_account),
KeyedAccount::new(&withdrawer, true, &withdrawer_account), (true, false, &withdrawer, &withdrawer_account),
]; ];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::InitializeChecked).unwrap(), &serialize(&StakeInstruction::InitializeChecked).unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Ok(()), Ok(()),
); );
@ -843,7 +924,7 @@ mod tests {
); );
instruction.accounts[3] = AccountMeta::new_readonly(staker, false); instruction.accounts[3] = AccountMeta::new_readonly(staker, false);
assert_eq!( assert_eq!(
process_instruction(&instruction), process_instruction_as_one_arg(&instruction),
Err(InstructionError::MissingRequiredSignature), Err(InstructionError::MissingRequiredSignature),
); );
@ -856,7 +937,7 @@ mod tests {
); );
instruction.accounts[3] = AccountMeta::new_readonly(withdrawer, false); instruction.accounts[3] = AccountMeta::new_readonly(withdrawer, false);
assert_eq!( assert_eq!(
process_instruction(&instruction), process_instruction_as_one_arg(&instruction),
Err(InstructionError::MissingRequiredSignature), Err(InstructionError::MissingRequiredSignature),
); );
@ -875,37 +956,30 @@ mod tests {
let authorized_account = create_default_account(); let authorized_account = create_default_account();
let new_authorized_account = create_default_account(); let new_authorized_account = create_default_account();
let keyed_accounts = vec![ let mut keyed_accounts = [
KeyedAccount::new(&stake_address, false, &stake_account), (false, false, &stake_address, &stake_account),
KeyedAccount::new(&clock_address, false, &clock_account), (false, false, &clock_address, &clock_account),
KeyedAccount::new(&authorized_address, true, &authorized_account), (true, false, &authorized_address, &authorized_account),
KeyedAccount::new(&staker, true, &new_authorized_account), (true, false, &staker, &new_authorized_account),
]; ];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::AuthorizeChecked(StakeAuthorize::Staker)).unwrap(), &serialize(&StakeInstruction::AuthorizeChecked(StakeAuthorize::Staker)).unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Ok(()), Ok(()),
); );
let keyed_accounts = vec![ keyed_accounts[3] = (true, false, &withdrawer, &new_authorized_account);
KeyedAccount::new(&stake_address, false, &stake_account),
KeyedAccount::new(&clock_address, false, &clock_account),
KeyedAccount::new(&authorized_address, true, &authorized_account),
KeyedAccount::new(&withdrawer, true, &new_authorized_account),
];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::AuthorizeChecked( &serialize(&StakeInstruction::AuthorizeChecked(
StakeAuthorize::Withdrawer StakeAuthorize::Withdrawer
)) ))
.unwrap(), .unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Ok(()), Ok(()),
); );
@ -926,7 +1000,7 @@ mod tests {
); );
instruction.accounts[3] = AccountMeta::new_readonly(staker, false); instruction.accounts[3] = AccountMeta::new_readonly(staker, false);
assert_eq!( assert_eq!(
process_instruction(&instruction), process_instruction_as_one_arg(&instruction),
Err(InstructionError::MissingRequiredSignature), Err(InstructionError::MissingRequiredSignature),
); );
@ -941,7 +1015,7 @@ mod tests {
); );
instruction.accounts[3] = AccountMeta::new_readonly(staker, false); instruction.accounts[3] = AccountMeta::new_readonly(staker, false);
assert_eq!( assert_eq!(
process_instruction(&instruction), process_instruction_as_one_arg(&instruction),
Err(InstructionError::MissingRequiredSignature), Err(InstructionError::MissingRequiredSignature),
); );
@ -953,15 +1027,14 @@ mod tests {
&id(), &id(),
) )
.unwrap(); .unwrap();
let keyed_accounts = vec![ let mut keyed_accounts = [
KeyedAccount::new(&address_with_seed, false, &stake_account), (false, false, &address_with_seed, &stake_account),
KeyedAccount::new(&authorized_owner, true, &authorized_account), (true, false, &authorized_owner, &authorized_account),
KeyedAccount::new(&clock_address, false, &clock_account), (false, false, &clock_address, &clock_account),
KeyedAccount::new(&staker, true, &new_authorized_account), (true, false, &staker, &new_authorized_account),
]; ];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::AuthorizeCheckedWithSeed( &serialize(&StakeInstruction::AuthorizeCheckedWithSeed(
AuthorizeCheckedWithSeedArgs { AuthorizeCheckedWithSeedArgs {
@ -971,20 +1044,14 @@ mod tests {
} }
)) ))
.unwrap(), .unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Ok(()), Ok(()),
); );
let keyed_accounts = vec![ keyed_accounts[3] = (true, false, &withdrawer, &new_authorized_account);
KeyedAccount::new(&address_with_seed, false, &stake_account),
KeyedAccount::new(&authorized_owner, true, &authorized_account),
KeyedAccount::new(&clock_address, false, &clock_account),
KeyedAccount::new(&withdrawer, true, &new_authorized_account),
];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&StakeInstruction::AuthorizeCheckedWithSeed( &serialize(&StakeInstruction::AuthorizeCheckedWithSeed(
AuthorizeCheckedWithSeedArgs { AuthorizeCheckedWithSeedArgs {
@ -994,7 +1061,7 @@ mod tests {
} }
)) ))
.unwrap(), .unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Ok(()), Ok(()),
); );
@ -1012,7 +1079,7 @@ mod tests {
); );
instruction.accounts[2] = AccountMeta::new_readonly(custodian, false); instruction.accounts[2] = AccountMeta::new_readonly(custodian, false);
assert_eq!( assert_eq!(
process_instruction(&instruction), process_instruction_as_one_arg(&instruction),
Err(InstructionError::MissingRequiredSignature), Err(InstructionError::MissingRequiredSignature),
); );
@ -1026,13 +1093,18 @@ mod tests {
.unwrap(); .unwrap();
let custodian_account = create_default_account(); let custodian_account = create_default_account();
let keyed_accounts = vec![ let processor_account = RefCell::new(AccountSharedData::from(Account {
KeyedAccount::new(&stake_address, false, &stake_account), owner: solana_sdk::native_loader::id(),
KeyedAccount::new(&withdrawer, true, &withdrawer_account), ..Account::default()
KeyedAccount::new(&custodian, true, &custodian_account), }));
let keyed_accounts = [
(false, false, &id(), &processor_account),
(false, false, &stake_address, &stake_account),
(true, false, &withdrawer, &withdrawer_account),
(true, false, &custodian, &custodian_account),
]; ];
let mut invoke_context =
let mut invoke_context = MockInvokeContext::new(keyed_accounts); MockInvokeContext::new(create_keyed_accounts_unified(&keyed_accounts));
let clock = Clock::default(); let clock = Clock::default();
let mut data = vec![]; let mut data = vec![];
bincode::serialize_into(&mut data, &clock).unwrap(); bincode::serialize_into(&mut data, &clock).unwrap();
@ -1043,12 +1115,13 @@ mod tests {
assert_eq!( assert_eq!(
super::process_instruction( super::process_instruction(
&Pubkey::default(), &Pubkey::default(),
1,
&serialize(&StakeInstruction::SetLockupChecked(LockupCheckedArgs { &serialize(&StakeInstruction::SetLockupChecked(LockupCheckedArgs {
unix_timestamp: None, unix_timestamp: None,
epoch: Some(1), epoch: Some(1),
})) }))
.unwrap(), .unwrap(),
&mut invoke_context &mut invoke_context,
), ),
Ok(()), Ok(()),
); );

141
programs/vote/src/vote_instruction.rs
View File

@ -309,6 +309,7 @@ fn verify_rent_exemption(
pub fn process_instruction( pub fn process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
first_instruction_account: usize,
data: &[u8], data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
@ -317,22 +318,26 @@ pub fn process_instruction(
trace!("process_instruction: {:?}", data); trace!("process_instruction: {:?}", data);
trace!("keyed_accounts: {:?}", keyed_accounts); trace!("keyed_accounts: {:?}", keyed_accounts);
let signers: HashSet<Pubkey> = get_signers(keyed_accounts); let me = &mut keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let me = &mut keyed_account_at_index(keyed_accounts, 0)?;
if me.owner()? != id() { if me.owner()? != id() {
return Err(InstructionError::InvalidAccountOwner); return Err(InstructionError::InvalidAccountOwner);
} }
let signers: HashSet<Pubkey> = get_signers(&keyed_accounts[1..]);
match limited_deserialize(data)? { match limited_deserialize(data)? {
VoteInstruction::InitializeAccount(vote_init) => { VoteInstruction::InitializeAccount(vote_init) => {
verify_rent_exemption(me, keyed_account_at_index(keyed_accounts, 1)?)?; verify_rent_exemption(
me,
keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?,
)?;
vote_state::initialize_account( vote_state::initialize_account(
me, me,
&vote_init, &vote_init,
&signers, &signers,
&from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 2)?)?, &from_keyed_account::<Clock>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 2,
)?)?,
invoke_context.is_feature_active(&feature_set::check_init_vote_data::id()), invoke_context.is_feature_active(&feature_set::check_init_vote_data::id()),
) )
} }
@ -341,11 +346,14 @@ pub fn process_instruction(
&voter_pubkey, &voter_pubkey,
vote_authorize, vote_authorize,
&signers, &signers,
&from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 1)?)?, &from_keyed_account::<Clock>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 1,
)?)?,
), ),
VoteInstruction::UpdateValidatorIdentity => vote_state::update_validator_identity( VoteInstruction::UpdateValidatorIdentity => vote_state::update_validator_identity(
me, me,
keyed_account_at_index(keyed_accounts, 1)?.unsigned_key(), keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?.unsigned_key(),
&signers, &signers,
), ),
VoteInstruction::UpdateCommission(commission) => { VoteInstruction::UpdateCommission(commission) => {
@ -355,28 +363,38 @@ pub fn process_instruction(
inc_new_counter_info!("vote-native", 1); inc_new_counter_info!("vote-native", 1);
vote_state::process_vote( vote_state::process_vote(
me, me,
&from_keyed_account::<SlotHashes>(keyed_account_at_index(keyed_accounts, 1)?)?, &from_keyed_account::<SlotHashes>(keyed_account_at_index(
&from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 2)?)?, keyed_accounts,
first_instruction_account + 1,
)?)?,
&from_keyed_account::<Clock>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 2,
)?)?,
&vote, &vote,
&signers, &signers,
) )
} }
VoteInstruction::Withdraw(lamports) => { VoteInstruction::Withdraw(lamports) => {
let to = keyed_account_at_index(keyed_accounts, 1)?; let to = keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
vote_state::withdraw(me, lamports, to, &signers) vote_state::withdraw(me, lamports, to, &signers)
} }
VoteInstruction::AuthorizeChecked(vote_authorize) => { VoteInstruction::AuthorizeChecked(vote_authorize) => {
if invoke_context.is_feature_active(&feature_set::vote_stake_checked_instructions::id()) if invoke_context.is_feature_active(&feature_set::vote_stake_checked_instructions::id())
{ {
let voter_pubkey = &keyed_account_at_index(keyed_accounts, 3)? let voter_pubkey =
.signer_key() &keyed_account_at_index(keyed_accounts, first_instruction_account + 3)?
.ok_or(InstructionError::MissingRequiredSignature)?; .signer_key()
.ok_or(InstructionError::MissingRequiredSignature)?;
vote_state::authorize( vote_state::authorize(
me, me,
voter_pubkey, voter_pubkey,
vote_authorize, vote_authorize,
&signers, &signers,
&from_keyed_account::<Clock>(keyed_account_at_index(keyed_accounts, 1)?)?, &from_keyed_account::<Clock>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 1,
)?)?,
) )
} else { } else {
Err(InstructionError::InvalidInstructionData) Err(InstructionError::InvalidInstructionData)
@ -391,6 +409,7 @@ mod tests {
use bincode::serialize; use bincode::serialize;
use solana_sdk::{ use solana_sdk::{
account::{self, Account, AccountSharedData}, account::{self, Account, AccountSharedData},
keyed_account::create_keyed_accounts_unified,
process_instruction::MockInvokeContext, process_instruction::MockInvokeContext,
rent::Rent, rent::Rent,
}; };
@ -401,21 +420,24 @@ mod tests {
RefCell::new(AccountSharedData::default()) RefCell::new(AccountSharedData::default())
} }
// these are for 100% coverage in this file fn process_instruction(
#[test] owner: &Pubkey,
fn test_vote_process_instruction_decode_bail() { instruction_data: &[u8],
assert_eq!( keyed_accounts: &[(bool, bool, &Pubkey, &RefCell<AccountSharedData>)],
super::process_instruction( ) -> Result<(), InstructionError> {
&Pubkey::default(), let processor_account = AccountSharedData::new_ref(0, 0, &solana_sdk::native_loader::id());
&[], let mut keyed_accounts = keyed_accounts.to_vec();
&mut MockInvokeContext::new(vec![]) keyed_accounts.insert(0, (false, false, owner, &processor_account));
), super::process_instruction(
Err(InstructionError::NotEnoughAccountKeys), owner,
); 1,
instruction_data,
&mut MockInvokeContext::new(create_keyed_accounts_unified(&keyed_accounts)),
)
} }
#[allow(clippy::same_item_push)] #[allow(clippy::same_item_push)]
fn process_instruction(instruction: &Instruction) -> Result<(), InstructionError> { fn process_instruction_as_one_arg(instruction: &Instruction) -> Result<(), InstructionError> {
let mut accounts: Vec<_> = instruction let mut accounts: Vec<_> = instruction
.accounts .accounts
.iter() .iter()
@ -448,13 +470,9 @@ mod tests {
.accounts .accounts
.iter() .iter()
.zip(accounts.iter()) .zip(accounts.iter())
.map(|(meta, account)| KeyedAccount::new(&meta.pubkey, meta.is_signer, account)) .map(|(meta, account)| (meta.is_signer, false, &meta.pubkey, account))
.collect(); .collect();
super::process_instruction( process_instruction(&Pubkey::default(), &instruction.data, &keyed_accounts)
&Pubkey::default(),
&instruction.data,
&mut MockInvokeContext::new(keyed_accounts),
)
} }
} }
@ -462,10 +480,19 @@ mod tests {
Pubkey::from_str("BadVote111111111111111111111111111111111111").unwrap() Pubkey::from_str("BadVote111111111111111111111111111111111111").unwrap()
} }
// these are for 100% coverage in this file
#[test]
fn test_vote_process_instruction_decode_bail() {
assert_eq!(
process_instruction(&Pubkey::default(), &[], &[]),
Err(InstructionError::NotEnoughAccountKeys),
);
}
#[test] #[test]
fn test_spoofed_vote() { fn test_spoofed_vote() {
assert_eq!( assert_eq!(
process_instruction(&vote( process_instruction_as_one_arg(&vote(
&invalid_vote_state_pubkey(), &invalid_vote_state_pubkey(),
&Pubkey::default(), &Pubkey::default(),
Vote::default(), Vote::default(),
@ -484,11 +511,11 @@ mod tests {
100, 100,
); );
assert_eq!( assert_eq!(
process_instruction(&instructions[1]), process_instruction_as_one_arg(&instructions[1]),
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction(&vote( process_instruction_as_one_arg(&vote(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
Vote::default(), Vote::default(),
@ -496,7 +523,7 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction(&vote_switch( process_instruction_as_one_arg(&vote_switch(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
Vote::default(), Vote::default(),
@ -505,7 +532,7 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction(&authorize( process_instruction_as_one_arg(&authorize(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
@ -514,7 +541,7 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction(&update_validator_identity( process_instruction_as_one_arg(&update_validator_identity(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
@ -522,7 +549,7 @@ mod tests {
Err(InstructionError::InvalidAccountData), Err(InstructionError::InvalidAccountData),
); );
assert_eq!( assert_eq!(
process_instruction(&update_commission( process_instruction_as_one_arg(&update_commission(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
0, 0,
@ -531,7 +558,7 @@ mod tests {
); );
assert_eq!( assert_eq!(
process_instruction(&withdraw( process_instruction_as_one_arg(&withdraw(
&Pubkey::default(), &Pubkey::default(),
&Pubkey::default(), &Pubkey::default(),
0, 0,
@ -556,7 +583,7 @@ mod tests {
); );
instruction.accounts = instruction.accounts[0..2].to_vec(); instruction.accounts = instruction.accounts[0..2].to_vec();
assert_eq!( assert_eq!(
process_instruction(&instruction), process_instruction_as_one_arg(&instruction),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -568,7 +595,7 @@ mod tests {
); );
instruction.accounts = instruction.accounts[0..2].to_vec(); instruction.accounts = instruction.accounts[0..2].to_vec();
assert_eq!( assert_eq!(
process_instruction(&instruction), process_instruction_as_one_arg(&instruction),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -581,7 +608,7 @@ mod tests {
); );
instruction.accounts[3] = AccountMeta::new_readonly(new_authorized_pubkey, false); instruction.accounts[3] = AccountMeta::new_readonly(new_authorized_pubkey, false);
assert_eq!( assert_eq!(
process_instruction(&instruction), process_instruction_as_one_arg(&instruction),
Err(InstructionError::MissingRequiredSignature), Err(InstructionError::MissingRequiredSignature),
); );
@ -593,7 +620,7 @@ mod tests {
); );
instruction.accounts[3] = AccountMeta::new_readonly(new_authorized_pubkey, false); instruction.accounts[3] = AccountMeta::new_readonly(new_authorized_pubkey, false);
assert_eq!( assert_eq!(
process_instruction(&instruction), process_instruction_as_one_arg(&instruction),
Err(InstructionError::MissingRequiredSignature), Err(InstructionError::MissingRequiredSignature),
); );
@ -606,35 +633,29 @@ mod tests {
let default_authorized_pubkey = Pubkey::default(); let default_authorized_pubkey = Pubkey::default();
let authorized_account = create_default_account(); let authorized_account = create_default_account();
let new_authorized_account = create_default_account(); let new_authorized_account = create_default_account();
let keyed_accounts = vec![ let keyed_accounts: [(bool, bool, &Pubkey, &RefCell<AccountSharedData>); 4] = [
KeyedAccount::new(&vote_pubkey, false, &vote_account), (false, false, &vote_pubkey, &vote_account),
KeyedAccount::new(&clock_address, false, &clock_account), (false, false, &clock_address, &clock_account),
KeyedAccount::new(&default_authorized_pubkey, true, &authorized_account), (true, false, &default_authorized_pubkey, &authorized_account),
KeyedAccount::new(&new_authorized_pubkey, true, &new_authorized_account), (true, false, &new_authorized_pubkey, &new_authorized_account),
]; ];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&VoteInstruction::AuthorizeChecked(VoteAuthorize::Voter)).unwrap(), &serialize(&VoteInstruction::AuthorizeChecked(VoteAuthorize::Voter)).unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Ok(()) Ok(())
); );
let keyed_accounts = vec![
KeyedAccount::new(&vote_pubkey, false, &vote_account),
KeyedAccount::new(&clock_address, false, &clock_account),
KeyedAccount::new(&default_authorized_pubkey, true, &authorized_account),
KeyedAccount::new(&new_authorized_pubkey, true, &new_authorized_account),
];
assert_eq!( assert_eq!(
super::process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
&serialize(&VoteInstruction::AuthorizeChecked( &serialize(&VoteInstruction::AuthorizeChecked(
VoteAuthorize::Withdrawer VoteAuthorize::Withdrawer
)) ))
.unwrap(), .unwrap(),
&mut MockInvokeContext::new(keyed_accounts) &keyed_accounts,
), ),
Ok(()) Ok(())
); );

1
runtime/benches/bank.rs
View File

@ -33,6 +33,7 @@ const NOOP_PROGRAM_ID: [u8; 32] = [
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps)]
fn process_instruction( fn process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {

40
runtime/src/bank.rs
View File

@ -6693,6 +6693,7 @@ pub(crate) mod tests {
fn mock_process_instruction( fn mock_process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
first_instruction_account: usize,
data: &[u8], data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> result::Result<(), InstructionError> { ) -> result::Result<(), InstructionError> {
@ -6700,11 +6701,11 @@ pub(crate) mod tests {
if let Ok(instruction) = bincode::deserialize(data) { if let Ok(instruction) = bincode::deserialize(data) {
match instruction { match instruction {
MockInstruction::Deduction => { MockInstruction::Deduction => {
keyed_accounts[1] keyed_accounts[first_instruction_account + 1]
.account .account
.borrow_mut() .borrow_mut()
.checked_add_lamports(1)?; .checked_add_lamports(1)?;
keyed_accounts[2] keyed_accounts[first_instruction_account + 2]
.account .account
.borrow_mut() .borrow_mut()
.checked_sub_lamports(1)?; .checked_sub_lamports(1)?;
@ -10340,6 +10341,7 @@ pub(crate) mod tests {
} }
fn mock_vote_processor( fn mock_vote_processor(
program_id: &Pubkey, program_id: &Pubkey,
_first_instruction_account: usize,
_instruction_data: &[u8], _instruction_data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> std::result::Result<(), InstructionError> { ) -> std::result::Result<(), InstructionError> {
@ -10397,6 +10399,7 @@ pub(crate) mod tests {
fn mock_vote_processor( fn mock_vote_processor(
_pubkey: &Pubkey, _pubkey: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> std::result::Result<(), InstructionError> { ) -> std::result::Result<(), InstructionError> {
@ -10447,6 +10450,7 @@ pub(crate) mod tests {
fn mock_ix_processor( fn mock_ix_processor(
_pubkey: &Pubkey, _pubkey: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> std::result::Result<(), InstructionError> { ) -> std::result::Result<(), InstructionError> {
@ -11288,21 +11292,24 @@ pub(crate) mod tests {
fn mock_process_instruction( fn mock_process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
first_instruction_account: usize,
data: &[u8], data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> result::Result<(), InstructionError> { ) -> result::Result<(), InstructionError> {
let keyed_accounts = invoke_context.get_keyed_accounts()?; let keyed_accounts = invoke_context.get_keyed_accounts()?;
let lamports = data[0] as u64; let lamports = data[0] as u64;
{ {
let mut to_account = keyed_accounts[1].try_account_ref_mut()?; let mut to_account =
let mut dup_account = keyed_accounts[2].try_account_ref_mut()?; keyed_accounts[first_instruction_account + 1].try_account_ref_mut()?;
let mut dup_account =
keyed_accounts[first_instruction_account + 2].try_account_ref_mut()?;
dup_account.checked_sub_lamports(lamports)?; dup_account.checked_sub_lamports(lamports)?;
to_account.checked_add_lamports(lamports)?; to_account.checked_add_lamports(lamports)?;
} }
keyed_accounts[0] keyed_accounts[first_instruction_account]
.try_account_ref_mut()? .try_account_ref_mut()?
.checked_sub_lamports(lamports)?; .checked_sub_lamports(lamports)?;
keyed_accounts[1] keyed_accounts[first_instruction_account + 1]
.try_account_ref_mut()? .try_account_ref_mut()?
.checked_add_lamports(lamports)?; .checked_add_lamports(lamports)?;
Ok(()) Ok(())
@ -11346,6 +11353,7 @@ pub(crate) mod tests {
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps)]
fn mock_process_instruction( fn mock_process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> result::Result<(), InstructionError> { ) -> result::Result<(), InstructionError> {
@ -11532,6 +11540,7 @@ pub(crate) mod tests {
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps)]
fn mock_ok_vote_processor( fn mock_ok_vote_processor(
_pubkey: &Pubkey, _pubkey: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> std::result::Result<(), InstructionError> { ) -> std::result::Result<(), InstructionError> {
@ -11782,12 +11791,18 @@ pub(crate) mod tests {
fn test_same_program_id_uses_unqiue_executable_accounts() { fn test_same_program_id_uses_unqiue_executable_accounts() {
fn nested_processor( fn nested_processor(
_program_id: &Pubkey, _program_id: &Pubkey,
first_instruction_account: usize,
_data: &[u8], _data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> result::Result<(), InstructionError> { ) -> result::Result<(), InstructionError> {
let keyed_accounts = invoke_context.get_keyed_accounts()?; let keyed_accounts = invoke_context.get_keyed_accounts()?;
assert_eq!(42, keyed_accounts[0].lamports().unwrap()); assert_eq!(
let mut account = keyed_accounts[0].try_account_ref_mut()?; 42,
keyed_accounts[first_instruction_account]
.lamports()
.unwrap()
);
let mut account = keyed_accounts[first_instruction_account].try_account_ref_mut()?;
account.checked_add_lamports(1)?; account.checked_add_lamports(1)?;
Ok(()) Ok(())
} }
@ -12148,6 +12163,7 @@ pub(crate) mod tests {
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps)]
fn mock_ix_processor( fn mock_ix_processor(
_pubkey: &Pubkey, _pubkey: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> std::result::Result<(), InstructionError> { ) -> std::result::Result<(), InstructionError> {
@ -12197,6 +12213,7 @@ pub(crate) mod tests {
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps)]
fn mock_ix_processor( fn mock_ix_processor(
_pubkey: &Pubkey, _pubkey: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_context: &mut dyn InvokeContext, _context: &mut dyn InvokeContext,
) -> std::result::Result<(), InstructionError> { ) -> std::result::Result<(), InstructionError> {
@ -12583,8 +12600,8 @@ pub(crate) mod tests {
impl Executor for TestExecutor { impl Executor for TestExecutor {
fn execute( fn execute(
&self, &self,
_loader_id: &Pubkey,
_program_id: &Pubkey, _program_id: &Pubkey,
_first_instruction_account: usize,
_instruction_data: &[u8], _instruction_data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
_use_jit: bool, _use_jit: bool,
@ -13088,6 +13105,7 @@ pub(crate) mod tests {
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps)]
fn mock_process_instruction( fn mock_process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> std::result::Result<(), solana_sdk::instruction::InstructionError> { ) -> std::result::Result<(), solana_sdk::instruction::InstructionError> {
@ -14585,12 +14603,13 @@ pub(crate) mod tests {
fn mock_ix_processor( fn mock_ix_processor(
_pubkey: &Pubkey, _pubkey: &Pubkey,
first_instruction_account: usize,
_data: &[u8], _data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> std::result::Result<(), InstructionError> { ) -> std::result::Result<(), InstructionError> {
use solana_sdk::account::WritableAccount; use solana_sdk::account::WritableAccount;
let keyed_accounts = invoke_context.get_keyed_accounts()?; let keyed_accounts = invoke_context.get_keyed_accounts()?;
let mut data = keyed_accounts[1].try_account_ref_mut()?; let mut data = keyed_accounts[first_instruction_account + 1].try_account_ref_mut()?;
data.data_as_mut_slice()[0] = 5; data.data_as_mut_slice()[0] = 5;
Ok(()) Ok(())
} }
@ -14794,6 +14813,7 @@ pub(crate) mod tests {
fn mock_ix_processor( fn mock_ix_processor(
_pubkey: &Pubkey, _pubkey: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> std::result::Result<(), InstructionError> { ) -> std::result::Result<(), InstructionError> {

19
runtime/src/builtins.rs
View File

@ -14,13 +14,21 @@ use solana_frozen_abi::abi_example::AbiExample;
fn process_instruction_with_program_logging( fn process_instruction_with_program_logging(
process_instruction: ProcessInstructionWithContext, process_instruction: ProcessInstructionWithContext,
program_id: &Pubkey, program_id: &Pubkey,
first_instruction_account: usize,
instruction_data: &[u8], instruction_data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
debug_assert_eq!(first_instruction_account, 1);
let logger = invoke_context.get_logger(); let logger = invoke_context.get_logger();
stable_log::program_invoke(&logger, program_id, invoke_context.invoke_depth()); stable_log::program_invoke(&logger, program_id, invoke_context.invoke_depth());
let result = process_instruction(program_id, instruction_data, invoke_context); let result = process_instruction(
program_id,
first_instruction_account,
instruction_data,
invoke_context,
);
match &result { match &result {
Ok(()) => stable_log::program_success(&logger, program_id), Ok(()) => stable_log::program_success(&logger, program_id),
@ -31,10 +39,14 @@ fn process_instruction_with_program_logging(
macro_rules! with_program_logging { macro_rules! with_program_logging {
($process_instruction:expr) => { ($process_instruction:expr) => {
|program_id: &Pubkey, instruction_data: &[u8], invoke_context: &mut dyn InvokeContext| { |program_id: &Pubkey,
first_instruction_account: usize,
instruction_data: &[u8],
invoke_context: &mut dyn InvokeContext| {
process_instruction_with_program_logging( process_instruction_with_program_logging(
$process_instruction, $process_instruction,
program_id, program_id,
first_instruction_account,
instruction_data, instruction_data,
invoke_context, invoke_context,
) )
@ -82,7 +94,7 @@ impl AbiExample for Builtin {
Self { Self {
name: String::default(), name: String::default(),
id: Pubkey::default(), id: Pubkey::default(),
process_instruction_with_context: |_, _, _| Ok(()), process_instruction_with_context: |_, _, _, _| Ok(()),
} }
} }
} }
@ -130,6 +142,7 @@ fn genesis_builtins() -> Vec<Builtin> {
/// place holder for secp256k1, remove when the precompile program is deactivated via feature activation /// place holder for secp256k1, remove when the precompile program is deactivated via feature activation
fn dummy_process_instruction( fn dummy_process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {

73
runtime/src/message_processor.rs
View File

@ -11,7 +11,8 @@ use solana_sdk::{
compute_budget::ComputeBudget, compute_budget::ComputeBudget,
feature_set::{ feature_set::{
demote_program_write_locks, do_support_realloc, neon_evm_compute_budget, demote_program_write_locks, do_support_realloc, neon_evm_compute_budget,
prevent_calling_precompiles_as_programs, tx_wide_compute_cap, FeatureSet, prevent_calling_precompiles_as_programs, remove_native_loader, tx_wide_compute_cap,
FeatureSet,
}, },
fee_calculator::FeeCalculator, fee_calculator::FeeCalculator,
hash::Hash, hash::Hash,
@ -329,12 +330,14 @@ impl<'a> InvokeContext for ThisInvokeContext<'a> {
.ok_or(InstructionError::CallDepth) .ok_or(InstructionError::CallDepth)
} }
fn remove_first_keyed_account(&mut self) -> Result<(), InstructionError> { fn remove_first_keyed_account(&mut self) -> Result<(), InstructionError> {
let stack_frame = &mut self if !self.is_feature_active(&remove_native_loader::id()) {
.invoke_stack let stack_frame = &mut self
.last_mut() .invoke_stack
.ok_or(InstructionError::CallDepth)?; .last_mut()
stack_frame.keyed_accounts_range.start = .ok_or(InstructionError::CallDepth)?;
stack_frame.keyed_accounts_range.start.saturating_add(1); stack_frame.keyed_accounts_range.start =
stack_frame.keyed_accounts_range.start.saturating_add(1);
}
Ok(()) Ok(())
} }
fn get_keyed_accounts(&self) -> Result<&[KeyedAccount], InstructionError> { fn get_keyed_accounts(&self) -> Result<&[KeyedAccount], InstructionError> {
@ -596,14 +599,18 @@ mod tests {
fn mock_process_instruction( fn mock_process_instruction(
program_id: &Pubkey, program_id: &Pubkey,
first_instruction_account: usize,
data: &[u8], data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
let keyed_accounts = invoke_context.get_keyed_accounts()?; let keyed_accounts = invoke_context.get_keyed_accounts()?;
assert_eq!(*program_id, keyed_accounts[0].owner()?); assert_eq!(
*program_id,
keyed_accounts[first_instruction_account].owner()?
);
assert_ne!( assert_ne!(
keyed_accounts[1].owner()?, keyed_accounts[first_instruction_account + 1].owner()?,
*keyed_accounts[0].unsigned_key() *keyed_accounts[first_instruction_account].unsigned_key()
); );
if let Ok(instruction) = bincode::deserialize(data) { if let Ok(instruction) = bincode::deserialize(data) {
@ -611,13 +618,19 @@ mod tests {
MockInstruction::NoopSuccess => (), MockInstruction::NoopSuccess => (),
MockInstruction::NoopFail => return Err(InstructionError::GenericError), MockInstruction::NoopFail => return Err(InstructionError::GenericError),
MockInstruction::ModifyOwned => { MockInstruction::ModifyOwned => {
keyed_accounts[0].try_account_ref_mut()?.data_as_mut_slice()[0] = 1 keyed_accounts[first_instruction_account]
.try_account_ref_mut()?
.data_as_mut_slice()[0] = 1
} }
MockInstruction::ModifyNotOwned => { MockInstruction::ModifyNotOwned => {
keyed_accounts[1].try_account_ref_mut()?.data_as_mut_slice()[0] = 1 keyed_accounts[first_instruction_account + 1]
.try_account_ref_mut()?
.data_as_mut_slice()[0] = 1
} }
MockInstruction::ModifyReadonly => { MockInstruction::ModifyReadonly => {
keyed_accounts[2].try_account_ref_mut()?.data_as_mut_slice()[0] = 1 keyed_accounts[first_instruction_account + 2]
.try_account_ref_mut()?
.data_as_mut_slice()[0] = 1
} }
} }
} else { } else {
@ -809,6 +822,7 @@ mod tests {
fn mock_system_process_instruction( fn mock_system_process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
first_instruction_account: usize,
data: &[u8], data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
@ -817,11 +831,11 @@ mod tests {
match instruction { match instruction {
MockSystemInstruction::Correct => Ok(()), MockSystemInstruction::Correct => Ok(()),
MockSystemInstruction::AttemptCredit { lamports } => { MockSystemInstruction::AttemptCredit { lamports } => {
keyed_accounts[0] keyed_accounts[first_instruction_account]
.account .account
.borrow_mut() .borrow_mut()
.checked_sub_lamports(lamports)?; .checked_sub_lamports(lamports)?;
keyed_accounts[1] keyed_accounts[first_instruction_account + 1]
.account .account
.borrow_mut() .borrow_mut()
.checked_add_lamports(lamports)?; .checked_add_lamports(lamports)?;
@ -829,7 +843,10 @@ mod tests {
} }
// Change data in a read-only account // Change data in a read-only account
MockSystemInstruction::AttemptDataChange { data } => { MockSystemInstruction::AttemptDataChange { data } => {
keyed_accounts[1].account.borrow_mut().set_data(vec![data]); keyed_accounts[first_instruction_account + 1]
.account
.borrow_mut()
.set_data(vec![data]);
Ok(()) Ok(())
} }
} }
@ -979,6 +996,7 @@ mod tests {
fn mock_system_process_instruction( fn mock_system_process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
first_instruction_account: usize,
data: &[u8], data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
@ -986,8 +1004,10 @@ mod tests {
if let Ok(instruction) = bincode::deserialize(data) { if let Ok(instruction) = bincode::deserialize(data) {
match instruction { match instruction {
MockSystemInstruction::BorrowFail => { MockSystemInstruction::BorrowFail => {
let from_account = keyed_accounts[0].try_account_ref_mut()?; let from_account =
let dup_account = keyed_accounts[2].try_account_ref_mut()?; keyed_accounts[first_instruction_account].try_account_ref_mut()?;
let dup_account =
keyed_accounts[first_instruction_account + 2].try_account_ref_mut()?;
if from_account.lamports() != dup_account.lamports() { if from_account.lamports() != dup_account.lamports() {
return Err(InstructionError::InvalidArgument); return Err(InstructionError::InvalidArgument);
} }
@ -995,11 +1015,13 @@ mod tests {
} }
MockSystemInstruction::MultiBorrowMut => { MockSystemInstruction::MultiBorrowMut => {
let from_lamports = { let from_lamports = {
let from_account = keyed_accounts[0].try_account_ref_mut()?; let from_account =
keyed_accounts[first_instruction_account].try_account_ref_mut()?;
from_account.lamports() from_account.lamports()
}; };
let dup_lamports = { let dup_lamports = {
let dup_account = keyed_accounts[2].try_account_ref_mut()?; let dup_account = keyed_accounts[first_instruction_account + 2]
.try_account_ref_mut()?;
dup_account.lamports() dup_account.lamports()
}; };
if from_lamports != dup_lamports { if from_lamports != dup_lamports {
@ -1009,16 +1031,18 @@ mod tests {
} }
MockSystemInstruction::DoWork { lamports, data } => { MockSystemInstruction::DoWork { lamports, data } => {
{ {
let mut to_account = keyed_accounts[1].try_account_ref_mut()?; let mut to_account = keyed_accounts[first_instruction_account + 1]
let mut dup_account = keyed_accounts[2].try_account_ref_mut()?; .try_account_ref_mut()?;
let mut dup_account = keyed_accounts[first_instruction_account + 2]
.try_account_ref_mut()?;
dup_account.checked_sub_lamports(lamports)?; dup_account.checked_sub_lamports(lamports)?;
to_account.checked_add_lamports(lamports)?; to_account.checked_add_lamports(lamports)?;
dup_account.set_data(vec![data]); dup_account.set_data(vec![data]);
} }
keyed_accounts[0] keyed_accounts[first_instruction_account]
.try_account_ref_mut()? .try_account_ref_mut()?
.checked_sub_lamports(lamports)?; .checked_sub_lamports(lamports)?;
keyed_accounts[1] keyed_accounts[first_instruction_account + 1]
.try_account_ref_mut()? .try_account_ref_mut()?
.checked_add_lamports(lamports)?; .checked_add_lamports(lamports)?;
Ok(()) Ok(())
@ -1500,6 +1524,7 @@ mod tests {
let mock_program_id = Pubkey::new_unique(); let mock_program_id = Pubkey::new_unique();
fn mock_process_instruction( fn mock_process_instruction(
_program_id: &Pubkey, _program_id: &Pubkey,
_first_instruction_account: usize,
_data: &[u8], _data: &[u8],
_invoke_context: &mut dyn InvokeContext, _invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {

375
runtime/src/system_instruction_processor.rs
View File

@ -264,6 +264,7 @@ fn transfer_with_seed(
pub fn process_instruction( pub fn process_instruction(
_owner: &Pubkey, _owner: &Pubkey,
first_instruction_account: usize,
instruction_data: &[u8], instruction_data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
@ -273,16 +274,16 @@ pub fn process_instruction(
trace!("process_instruction: {:?}", instruction); trace!("process_instruction: {:?}", instruction);
trace!("keyed_accounts: {:?}", keyed_accounts); trace!("keyed_accounts: {:?}", keyed_accounts);
let signers = get_signers(keyed_accounts); let _ = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let signers = get_signers(&keyed_accounts[first_instruction_account..]);
match instruction { match instruction {
SystemInstruction::CreateAccount { SystemInstruction::CreateAccount {
lamports, lamports,
space, space,
owner, owner,
} => { } => {
let from = keyed_account_at_index(keyed_accounts, 0)?; let from = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let to = keyed_account_at_index(keyed_accounts, 1)?; let to = keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
let to_address = Address::create(to.unsigned_key(), None, invoke_context)?; let to_address = Address::create(to.unsigned_key(), None, invoke_context)?;
create_account( create_account(
from, from,
@ -302,8 +303,8 @@ pub fn process_instruction(
space, space,
owner, owner,
} => { } => {
let from = keyed_account_at_index(keyed_accounts, 0)?; let from = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let to = keyed_account_at_index(keyed_accounts, 1)?; let to = keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
let to_address = Address::create( let to_address = Address::create(
to.unsigned_key(), to.unsigned_key(),
Some((&base, &seed, &owner)), Some((&base, &seed, &owner)),
@ -321,14 +322,14 @@ pub fn process_instruction(
) )
} }
SystemInstruction::Assign { owner } => { SystemInstruction::Assign { owner } => {
let keyed_account = keyed_account_at_index(keyed_accounts, 0)?; let keyed_account = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let mut account = keyed_account.try_account_ref_mut()?; let mut account = keyed_account.try_account_ref_mut()?;
let address = Address::create(keyed_account.unsigned_key(), None, invoke_context)?; let address = Address::create(keyed_account.unsigned_key(), None, invoke_context)?;
assign(&mut account, &address, &owner, &signers, invoke_context) assign(&mut account, &address, &owner, &signers, invoke_context)
} }
SystemInstruction::Transfer { lamports } => { SystemInstruction::Transfer { lamports } => {
let from = keyed_account_at_index(keyed_accounts, 0)?; let from = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let to = keyed_account_at_index(keyed_accounts, 1)?; let to = keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
transfer(from, to, lamports, invoke_context) transfer(from, to, lamports, invoke_context)
} }
SystemInstruction::TransferWithSeed { SystemInstruction::TransferWithSeed {
@ -336,9 +337,9 @@ pub fn process_instruction(
from_seed, from_seed,
from_owner, from_owner,
} => { } => {
let from = keyed_account_at_index(keyed_accounts, 0)?; let from = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let base = keyed_account_at_index(keyed_accounts, 1)?; let base = keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
let to = keyed_account_at_index(keyed_accounts, 2)?; let to = keyed_account_at_index(keyed_accounts, first_instruction_account + 2)?;
transfer_with_seed( transfer_with_seed(
from, from,
base, base,
@ -350,10 +351,10 @@ pub fn process_instruction(
) )
} }
SystemInstruction::AdvanceNonceAccount => { SystemInstruction::AdvanceNonceAccount => {
let me = &mut keyed_account_at_index(keyed_accounts, 0)?; let me = &mut keyed_account_at_index(keyed_accounts, first_instruction_account)?;
#[allow(deprecated)] #[allow(deprecated)]
if from_keyed_account::<solana_sdk::sysvar::recent_blockhashes::RecentBlockhashes>( if from_keyed_account::<solana_sdk::sysvar::recent_blockhashes::RecentBlockhashes>(
keyed_account_at_index(keyed_accounts, 1)?, keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?,
)? )?
.is_empty() .is_empty()
{ {
@ -366,25 +367,28 @@ pub fn process_instruction(
me.advance_nonce_account(&signers, invoke_context) me.advance_nonce_account(&signers, invoke_context)
} }
SystemInstruction::WithdrawNonceAccount(lamports) => { SystemInstruction::WithdrawNonceAccount(lamports) => {
let me = &mut keyed_account_at_index(keyed_accounts, 0)?; let me = &mut keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let to = &mut keyed_account_at_index(keyed_accounts, 1)?; let to = &mut keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
#[allow(deprecated)] #[allow(deprecated)]
let _ = from_keyed_account::<solana_sdk::sysvar::recent_blockhashes::RecentBlockhashes>( let _ = from_keyed_account::<solana_sdk::sysvar::recent_blockhashes::RecentBlockhashes>(
keyed_account_at_index(keyed_accounts, 2)?, keyed_account_at_index(keyed_accounts, first_instruction_account + 2)?,
)?; )?;
me.withdraw_nonce_account( me.withdraw_nonce_account(
lamports, lamports,
to, to,
&from_keyed_account::<Rent>(keyed_account_at_index(keyed_accounts, 3)?)?, &from_keyed_account::<Rent>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 3,
)?)?,
&signers, &signers,
invoke_context, invoke_context,
) )
} }
SystemInstruction::InitializeNonceAccount(authorized) => { SystemInstruction::InitializeNonceAccount(authorized) => {
let me = &mut keyed_account_at_index(keyed_accounts, 0)?; let me = &mut keyed_account_at_index(keyed_accounts, first_instruction_account)?;
#[allow(deprecated)] #[allow(deprecated)]
if from_keyed_account::<solana_sdk::sysvar::recent_blockhashes::RecentBlockhashes>( if from_keyed_account::<solana_sdk::sysvar::recent_blockhashes::RecentBlockhashes>(
keyed_account_at_index(keyed_accounts, 1)?, keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?,
)? )?
.is_empty() .is_empty()
{ {
@ -396,16 +400,19 @@ pub fn process_instruction(
} }
me.initialize_nonce_account( me.initialize_nonce_account(
&authorized, &authorized,
&from_keyed_account::<Rent>(keyed_account_at_index(keyed_accounts, 2)?)?, &from_keyed_account::<Rent>(keyed_account_at_index(
keyed_accounts,
first_instruction_account + 2,
)?)?,
invoke_context, invoke_context,
) )
} }
SystemInstruction::AuthorizeNonceAccount(nonce_authority) => { SystemInstruction::AuthorizeNonceAccount(nonce_authority) => {
let me = &mut keyed_account_at_index(keyed_accounts, 0)?; let me = &mut keyed_account_at_index(keyed_accounts, first_instruction_account)?;
me.authorize_nonce_account(&nonce_authority, &signers, invoke_context) me.authorize_nonce_account(&nonce_authority, &signers, invoke_context)
} }
SystemInstruction::Allocate { space } => { SystemInstruction::Allocate { space } => {
let keyed_account = keyed_account_at_index(keyed_accounts, 0)?; let keyed_account = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let mut account = keyed_account.try_account_ref_mut()?; let mut account = keyed_account.try_account_ref_mut()?;
let address = Address::create(keyed_account.unsigned_key(), None, invoke_context)?; let address = Address::create(keyed_account.unsigned_key(), None, invoke_context)?;
allocate(&mut account, &address, space, &signers, invoke_context) allocate(&mut account, &address, space, &signers, invoke_context)
@ -416,7 +423,7 @@ pub fn process_instruction(
space, space,
owner, owner,
} => { } => {
let keyed_account = keyed_account_at_index(keyed_accounts, 0)?; let keyed_account = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let mut account = keyed_account.try_account_ref_mut()?; let mut account = keyed_account.try_account_ref_mut()?;
let address = Address::create( let address = Address::create(
keyed_account.unsigned_key(), keyed_account.unsigned_key(),
@ -433,7 +440,7 @@ pub fn process_instruction(
) )
} }
SystemInstruction::AssignWithSeed { base, seed, owner } => { SystemInstruction::AssignWithSeed { base, seed, owner } => {
let keyed_account = keyed_account_at_index(keyed_accounts, 0)?; let keyed_account = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let mut account = keyed_account.try_account_ref_mut()?; let mut account = keyed_account.try_account_ref_mut()?;
let address = Address::create( let address = Address::create(
keyed_account.unsigned_key(), keyed_account.unsigned_key(),
@ -484,6 +491,7 @@ mod tests {
genesis_config::create_genesis_config, genesis_config::create_genesis_config,
hash::{hash, Hash}, hash::{hash, Hash},
instruction::{AccountMeta, Instruction, InstructionError}, instruction::{AccountMeta, Instruction, InstructionError},
keyed_account::create_keyed_accounts_unified,
message::Message, message::Message,
nonce, nonce_account, nonce, nonce_account,
process_instruction::MockInvokeContext, process_instruction::MockInvokeContext,
@ -506,13 +514,21 @@ mod tests {
fn process_instruction( fn process_instruction(
owner: &Pubkey, owner: &Pubkey,
keyed_accounts: Vec<KeyedAccount>,
instruction_data: &[u8], instruction_data: &[u8],
keyed_accounts: &[(bool, bool, &Pubkey, &RefCell<AccountSharedData>)],
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
let processor_account = RefCell::new(AccountSharedData::from(Account {
owner: solana_sdk::native_loader::id(),
..Account::default()
}));
let mut keyed_accounts = keyed_accounts.to_vec();
let processor_id = Pubkey::default();
keyed_accounts.insert(0, (false, false, &processor_id, &processor_account));
super::process_instruction( super::process_instruction(
owner, owner,
1,
instruction_data, instruction_data,
&mut MockInvokeContext::new(keyed_accounts), &mut MockInvokeContext::new(create_keyed_accounts_unified(&keyed_accounts)),
) )
} }
@ -546,16 +562,16 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![
KeyedAccount::new(&from, true, &from_account),
KeyedAccount::new(&to, true, &to_account)
],
&bincode::serialize(&SystemInstruction::CreateAccount { &bincode::serialize(&SystemInstruction::CreateAccount {
lamports: 50, lamports: 50,
space: 2, space: 2,
owner: new_owner owner: new_owner
}) })
.unwrap() .unwrap(),
&[
(true, false, &from, &from_account),
(true, false, &to, &to_account),
],
), ),
Ok(()) Ok(())
); );
@ -571,17 +587,12 @@ mod tests {
let from = solana_sdk::pubkey::new_rand(); let from = solana_sdk::pubkey::new_rand();
let seed = "shiny pepper"; let seed = "shiny pepper";
let to = Pubkey::create_with_seed(&from, seed, &new_owner).unwrap(); let to = Pubkey::create_with_seed(&from, seed, &new_owner).unwrap();
let from_account = AccountSharedData::new_ref(100, 0, &system_program::id()); let from_account = AccountSharedData::new_ref(100, 0, &system_program::id());
let to_account = AccountSharedData::new_ref(0, 0, &Pubkey::default()); let to_account = AccountSharedData::new_ref(0, 0, &Pubkey::default());
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![
KeyedAccount::new(&from, true, &from_account),
KeyedAccount::new(&to, false, &to_account)
],
&bincode::serialize(&SystemInstruction::CreateAccountWithSeed { &bincode::serialize(&SystemInstruction::CreateAccountWithSeed {
base: from, base: from,
seed: seed.to_string(), seed: seed.to_string(),
@ -589,7 +600,11 @@ mod tests {
space: 2, space: 2,
owner: new_owner owner: new_owner
}) })
.unwrap() .unwrap(),
&[
(true, false, &from, &from_account),
(false, false, &to, &to_account),
],
), ),
Ok(()) Ok(())
); );
@ -606,7 +621,6 @@ mod tests {
let base = solana_sdk::pubkey::new_rand(); let base = solana_sdk::pubkey::new_rand();
let seed = "shiny pepper"; let seed = "shiny pepper";
let to = Pubkey::create_with_seed(&base, seed, &new_owner).unwrap(); let to = Pubkey::create_with_seed(&base, seed, &new_owner).unwrap();
let from_account = AccountSharedData::new_ref(100, 0, &system_program::id()); let from_account = AccountSharedData::new_ref(100, 0, &system_program::id());
let to_account = AccountSharedData::new_ref(0, 0, &Pubkey::default()); let to_account = AccountSharedData::new_ref(0, 0, &Pubkey::default());
let base_account = AccountSharedData::new_ref(0, 0, &Pubkey::default()); let base_account = AccountSharedData::new_ref(0, 0, &Pubkey::default());
@ -614,11 +628,6 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![
KeyedAccount::new(&from, true, &from_account),
KeyedAccount::new(&to, false, &to_account),
KeyedAccount::new(&base, true, &base_account)
],
&bincode::serialize(&SystemInstruction::CreateAccountWithSeed { &bincode::serialize(&SystemInstruction::CreateAccountWithSeed {
base, base,
seed: seed.to_string(), seed: seed.to_string(),
@ -626,7 +635,12 @@ mod tests {
space: 2, space: 2,
owner: new_owner owner: new_owner
}) })
.unwrap() .unwrap(),
&[
(true, false, &from, &from_account),
(false, false, &to, &to_account),
(true, false, &base, &base_account),
],
), ),
Ok(()) Ok(())
); );
@ -1036,7 +1050,6 @@ mod tests {
#[test] #[test]
fn test_assign() { fn test_assign() {
let new_owner = Pubkey::new(&[9; 32]); let new_owner = Pubkey::new(&[9; 32]);
let pubkey = solana_sdk::pubkey::new_rand(); let pubkey = solana_sdk::pubkey::new_rand();
let mut account = AccountSharedData::new(100, 0, &system_program::id()); let mut account = AccountSharedData::new(100, 0, &system_program::id());
@ -1050,6 +1063,7 @@ mod tests {
), ),
Err(InstructionError::MissingRequiredSignature) Err(InstructionError::MissingRequiredSignature)
); );
// no change, no signature needed // no change, no signature needed
assert_eq!( assert_eq!(
assign( assign(
@ -1066,8 +1080,8 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![KeyedAccount::new(&pubkey, true, &account)], &bincode::serialize(&SystemInstruction::Assign { owner: new_owner }).unwrap(),
&bincode::serialize(&SystemInstruction::Assign { owner: new_owner }).unwrap() &[(true, false, &pubkey, &account)],
), ),
Ok(()) Ok(())
); );
@ -1123,18 +1137,18 @@ mod tests {
owner: solana_sdk::pubkey::new_rand(), owner: solana_sdk::pubkey::new_rand(),
}; };
let data = serialize(&instruction).unwrap(); let data = serialize(&instruction).unwrap();
let result = process_instruction(&system_program::id(), vec![], &data); let result = process_instruction(&system_program::id(), &data, &[]);
assert_eq!(result, Err(InstructionError::NotEnoughAccountKeys)); assert_eq!(result, Err(InstructionError::NotEnoughAccountKeys));
// Attempt to transfer with no destination
let from = solana_sdk::pubkey::new_rand(); let from = solana_sdk::pubkey::new_rand();
let from_account = AccountSharedData::new_ref(100, 0, &system_program::id()); let from_account = AccountSharedData::new_ref(100, 0, &system_program::id());
// Attempt to transfer with no destination
let instruction = SystemInstruction::Transfer { lamports: 0 }; let instruction = SystemInstruction::Transfer { lamports: 0 };
let data = serialize(&instruction).unwrap(); let data = serialize(&instruction).unwrap();
let result = process_instruction( let result = process_instruction(
&system_program::id(), &system_program::id(),
vec![KeyedAccount::new(&from, true, &from_account)],
&data, &data,
&[(true, false, &from, &from_account)],
); );
assert_eq!(result, Err(InstructionError::NotEnoughAccountKeys)); assert_eq!(result, Err(InstructionError::NotEnoughAccountKeys));
} }
@ -1178,7 +1192,7 @@ mod tests {
0, 0,
&MockInvokeContext::new(vec![]), &MockInvokeContext::new(vec![]),
) )
.is_ok(),); .is_ok());
assert_eq!(from_keyed_account.account.borrow().lamports(), 50); assert_eq!(from_keyed_account.account.borrow().lamports(), 50);
assert_eq!(to_keyed_account.account.borrow().lamports(), 51); assert_eq!(to_keyed_account.account.borrow().lamports(), 51);
@ -1252,7 +1266,7 @@ mod tests {
0, 0,
&MockInvokeContext::new(vec![]), &MockInvokeContext::new(vec![]),
) )
.is_ok(),); .is_ok());
assert_eq!(from_keyed_account.account.borrow().lamports(), 50); assert_eq!(from_keyed_account.account.borrow().lamports(), 50);
assert_eq!(to_keyed_account.account.borrow().lamports(), 51); assert_eq!(to_keyed_account.account.borrow().lamports(), 51);
} }
@ -1487,9 +1501,9 @@ mod tests {
.accounts .accounts
.iter() .iter()
.zip(accounts.iter()) .zip(accounts.iter())
.map(|(meta, account)| KeyedAccount::new(&meta.pubkey, meta.is_signer, account)) .map(|(meta, account)| (meta.is_signer, false, &meta.pubkey, account))
.collect(); .collect();
process_instruction(&Pubkey::default(), keyed_accounts, &instruction.data) process_instruction(&Pubkey::default(), &instruction.data, &keyed_accounts)
} }
} }
@ -1509,8 +1523,8 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![], &serialize(&SystemInstruction::AdvanceNonceAccount).unwrap(),
&serialize(&SystemInstruction::AdvanceNonceAccount).unwrap() &[],
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -1521,12 +1535,8 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![KeyedAccount::new(
&Pubkey::default(),
true,
&create_default_account(),
)],
&serialize(&SystemInstruction::AdvanceNonceAccount).unwrap(), &serialize(&SystemInstruction::AdvanceNonceAccount).unwrap(),
&[(true, false, &Pubkey::default(), &create_default_account())],
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -1537,16 +1547,17 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::AdvanceNonceAccount).unwrap(),
KeyedAccount::new(&Pubkey::default(), true, &create_default_account()), &[
KeyedAccount::new( (true, false, &Pubkey::default(), &create_default_account()),
(
false,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&create_default_account(), &create_default_account(),
), ),
], ],
&serialize(&SystemInstruction::AdvanceNonceAccount).unwrap(),
), ),
Err(InstructionError::InvalidArgument), Err(InstructionError::InvalidArgument),
); );
@ -1557,17 +1568,23 @@ mod tests {
let nonce_acc = nonce_account::create_account(1_000_000); let nonce_acc = nonce_account::create_account(1_000_000);
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
KeyedAccount::new(&Pubkey::default(), true, &nonce_acc), &[
KeyedAccount::new( (true, false, &Pubkey::default(), &nonce_acc),
(
false,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&create_default_recent_blockhashes_account(), &create_default_recent_blockhashes_account(),
), ),
KeyedAccount::new(&sysvar::rent::id(), false, &create_default_rent_account()), (
false,
false,
&sysvar::rent::id(),
&create_default_rent_account(),
),
], ],
&serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
) )
.unwrap(); .unwrap();
let blockhash = &hash(&serialize(&0).unwrap()); let blockhash = &hash(&serialize(&0).unwrap());
@ -1584,14 +1601,22 @@ mod tests {
let owner = Pubkey::default(); let owner = Pubkey::default();
#[allow(deprecated)] #[allow(deprecated)]
let blockhash_id = sysvar::recent_blockhashes::id(); let blockhash_id = sysvar::recent_blockhashes::id();
let mut invoke_context = &mut MockInvokeContext::new(vec![ let processor_account = RefCell::new(AccountSharedData::from(Account {
KeyedAccount::new(&owner, true, &nonce_acc), owner: solana_sdk::native_loader::id(),
KeyedAccount::new(&blockhash_id, false, &new_recent_blockhashes_account), ..Account::default()
]); }));
let keyed_accounts = [
(false, false, &Pubkey::default(), &processor_account),
(true, false, &owner, &nonce_acc),
(false, false, &blockhash_id, &new_recent_blockhashes_account),
];
let mut invoke_context =
&mut MockInvokeContext::new(create_keyed_accounts_unified(&keyed_accounts));
invoke_context.blockhash = *blockhash; invoke_context.blockhash = *blockhash;
assert_eq!( assert_eq!(
super::process_instruction( super::process_instruction(
&Pubkey::default(), &Pubkey::default(),
1,
&serialize(&SystemInstruction::AdvanceNonceAccount).unwrap(), &serialize(&SystemInstruction::AdvanceNonceAccount).unwrap(),
invoke_context, invoke_context,
), ),
@ -1617,8 +1642,8 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![],
&serialize(&SystemInstruction::WithdrawNonceAccount(42)).unwrap(), &serialize(&SystemInstruction::WithdrawNonceAccount(42)).unwrap(),
&[],
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -1629,12 +1654,8 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![KeyedAccount::new(
&Pubkey::default(),
true,
&create_default_account()
)],
&serialize(&SystemInstruction::WithdrawNonceAccount(42)).unwrap(), &serialize(&SystemInstruction::WithdrawNonceAccount(42)).unwrap(),
&[(true, false, &Pubkey::default(), &create_default_account())],
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -1645,17 +1666,18 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::WithdrawNonceAccount(42)).unwrap(),
KeyedAccount::new(&Pubkey::default(), true, &create_default_account()), &[
KeyedAccount::new(&Pubkey::default(), false, &create_default_account()), (true, false, &Pubkey::default(), &create_default_account()),
KeyedAccount::new( (false, false, &Pubkey::default(), &create_default_account()),
(
false,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&create_default_account() &create_default_account()
), ),
], ],
&serialize(&SystemInstruction::WithdrawNonceAccount(42)).unwrap(),
), ),
Err(InstructionError::InvalidArgument), Err(InstructionError::InvalidArgument),
); );
@ -1666,22 +1688,24 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::WithdrawNonceAccount(42)).unwrap(),
KeyedAccount::new( &[
&Pubkey::default(), (
true, true,
false,
&Pubkey::default(),
&nonce_account::create_account(1_000_000), &nonce_account::create_account(1_000_000),
), ),
KeyedAccount::new(&Pubkey::default(), true, &create_default_account()), (true, false, &Pubkey::default(), &create_default_account()),
KeyedAccount::new( (
false,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&create_default_recent_blockhashes_account(), &create_default_recent_blockhashes_account(),
), ),
KeyedAccount::new(&sysvar::rent::id(), false, &create_default_account()), (false, false, &sysvar::rent::id(), &create_default_account()),
], ],
&serialize(&SystemInstruction::WithdrawNonceAccount(42)).unwrap(),
), ),
Err(InstructionError::InvalidArgument), Err(InstructionError::InvalidArgument),
); );
@ -1692,22 +1716,29 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::WithdrawNonceAccount(42)).unwrap(),
KeyedAccount::new( &[
&Pubkey::default(), (
true, true,
false,
&Pubkey::default(),
&nonce_account::create_account(1_000_000), &nonce_account::create_account(1_000_000),
), ),
KeyedAccount::new(&Pubkey::default(), true, &create_default_account()), (true, false, &Pubkey::default(), &create_default_account()),
KeyedAccount::new( (
false,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&create_default_recent_blockhashes_account(), &create_default_recent_blockhashes_account(),
), ),
KeyedAccount::new(&sysvar::rent::id(), false, &create_default_rent_account()), (
false,
false,
&sysvar::rent::id(),
&create_default_rent_account()
),
], ],
&serialize(&SystemInstruction::WithdrawNonceAccount(42)).unwrap(),
), ),
Ok(()), Ok(()),
); );
@ -1718,8 +1749,8 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![],
&serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(), &serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
&[],
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -1730,12 +1761,13 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![KeyedAccount::new( &serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
&Pubkey::default(), &[(
true, true,
false,
&Pubkey::default(),
&nonce_account::create_account(1_000_000), &nonce_account::create_account(1_000_000),
)], )],
&serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
), ),
Err(InstructionError::NotEnoughAccountKeys), Err(InstructionError::NotEnoughAccountKeys),
); );
@ -1746,20 +1778,22 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
KeyedAccount::new( &[
&Pubkey::default(), (
true, true,
false,
&Pubkey::default(),
&nonce_account::create_account(1_000_000), &nonce_account::create_account(1_000_000),
), ),
KeyedAccount::new( (
true,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&create_default_account() &create_default_account()
), ),
], ],
&serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
), ),
Err(InstructionError::InvalidArgument), Err(InstructionError::InvalidArgument),
); );
@ -1770,21 +1804,23 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
KeyedAccount::new( &[
&Pubkey::default(), (
true, true,
false,
&Pubkey::default(),
&nonce_account::create_account(1_000_000), &nonce_account::create_account(1_000_000),
), ),
KeyedAccount::new( (
false,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&create_default_recent_blockhashes_account(), &create_default_recent_blockhashes_account(),
), ),
KeyedAccount::new(&sysvar::rent::id(), false, &create_default_account()), (false, false, &sysvar::rent::id(), &create_default_account()),
], ],
&serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
), ),
Err(InstructionError::InvalidArgument), Err(InstructionError::InvalidArgument),
); );
@ -1795,21 +1831,28 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
KeyedAccount::new( &[
&Pubkey::default(), (
true, true,
false,
&Pubkey::default(),
&nonce_account::create_account(1_000_000), &nonce_account::create_account(1_000_000),
), ),
KeyedAccount::new( (
false,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&create_default_recent_blockhashes_account(), &create_default_recent_blockhashes_account(),
), ),
KeyedAccount::new(&sysvar::rent::id(), false, &create_default_rent_account()), (
false,
false,
&sysvar::rent::id(),
&create_default_rent_account()
),
], ],
&serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
), ),
Ok(()), Ok(()),
); );
@ -1820,24 +1863,30 @@ mod tests {
let nonce_acc = nonce_account::create_account(1_000_000); let nonce_acc = nonce_account::create_account(1_000_000);
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
KeyedAccount::new(&Pubkey::default(), true, &nonce_acc), &[
KeyedAccount::new( (true, false, &Pubkey::default(), &nonce_acc),
(
false,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&create_default_recent_blockhashes_account(), &create_default_recent_blockhashes_account(),
), ),
KeyedAccount::new(&sysvar::rent::id(), false, &create_default_rent_account()), (
false,
false,
&sysvar::rent::id(),
&create_default_rent_account(),
),
], ],
&serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
) )
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![KeyedAccount::new(&Pubkey::default(), true, &nonce_acc,),], &serialize(&SystemInstruction::AuthorizeNonceAccount(Pubkey::default())).unwrap(),
&serialize(&SystemInstruction::AuthorizeNonceAccount(Pubkey::default(),)).unwrap(), &[(true, false, &Pubkey::default(), &nonce_acc)],
), ),
Ok(()), Ok(()),
); );
@ -1920,17 +1969,23 @@ mod tests {
assert_eq!( assert_eq!(
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
KeyedAccount::new(&Pubkey::default(), true, &nonce_acc), &[
KeyedAccount::new( (true, false, &Pubkey::default(), &nonce_acc),
(
false,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&new_recent_blockhashes_account, &new_recent_blockhashes_account,
), ),
KeyedAccount::new(&sysvar::rent::id(), false, &create_default_rent_account()), (
false,
false,
&sysvar::rent::id(),
&create_default_rent_account()
),
], ],
&serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
), ),
Err(NonceError::NoRecentBlockhashes.into()) Err(NonceError::NoRecentBlockhashes.into())
); );
@ -1941,17 +1996,23 @@ mod tests {
let nonce_acc = nonce_account::create_account(1_000_000); let nonce_acc = nonce_account::create_account(1_000_000);
process_instruction( process_instruction(
&Pubkey::default(), &Pubkey::default(),
vec![ &serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
KeyedAccount::new(&Pubkey::default(), true, &nonce_acc), &[
KeyedAccount::new( (true, false, &Pubkey::default(), &nonce_acc),
(
false,
false,
#[allow(deprecated)] #[allow(deprecated)]
&sysvar::recent_blockhashes::id(), &sysvar::recent_blockhashes::id(),
false,
&create_default_recent_blockhashes_account(), &create_default_recent_blockhashes_account(),
), ),
KeyedAccount::new(&sysvar::rent::id(), false, &create_default_rent_account()), (
false,
false,
&sysvar::rent::id(),
&create_default_rent_account(),
),
], ],
&serialize(&SystemInstruction::InitializeNonceAccount(Pubkey::default())).unwrap(),
) )
.unwrap(); .unwrap();
let blockhash = &hash(&serialize(&0).unwrap()); let blockhash = &hash(&serialize(&0).unwrap());
@ -1964,14 +2025,22 @@ mod tests {
let owner = Pubkey::default(); let owner = Pubkey::default();
#[allow(deprecated)] #[allow(deprecated)]
let blockhash_id = sysvar::recent_blockhashes::id(); let blockhash_id = sysvar::recent_blockhashes::id();
let mut invoke_context = &mut MockInvokeContext::new(vec![ let processor_account = RefCell::new(AccountSharedData::from(Account {
KeyedAccount::new(&owner, true, &nonce_acc), owner: solana_sdk::native_loader::id(),
KeyedAccount::new(&blockhash_id, false, &new_recent_blockhashes_account), ..Account::default()
]); }));
let keyed_accounts = [
(false, false, &Pubkey::default(), &processor_account),
(true, false, &owner, &nonce_acc),
(false, false, &blockhash_id, &new_recent_blockhashes_account),
];
let mut invoke_context =
&mut MockInvokeContext::new(create_keyed_accounts_unified(&keyed_accounts));
invoke_context.blockhash = *blockhash; invoke_context.blockhash = *blockhash;
assert_eq!( assert_eq!(
super::process_instruction( super::process_instruction(
&Pubkey::default(), &Pubkey::default(),
1,
&serialize(&SystemInstruction::AdvanceNonceAccount).unwrap(), &serialize(&SystemInstruction::AdvanceNonceAccount).unwrap(),
invoke_context, invoke_context,
), ),

2
sdk/src/builtins.rs
View File

@ -80,6 +80,7 @@ macro_rules! declare_builtin_name {
/// ///
/// fn my_process_instruction( /// fn my_process_instruction(
/// program_id: &Pubkey, /// program_id: &Pubkey,
/// first_instruction_account: usize,
/// keyed_accounts: &[KeyedAccount], /// keyed_accounts: &[KeyedAccount],
/// instruction_data: &[u8], /// instruction_data: &[u8],
/// ) -> Result<(), InstructionError> { /// ) -> Result<(), InstructionError> {
@ -111,6 +112,7 @@ macro_rules! declare_builtin_name {
/// ///
/// fn my_process_instruction( /// fn my_process_instruction(
/// program_id: &Pubkey, /// program_id: &Pubkey,
/// first_instruction_account: usize,
/// keyed_accounts: &[KeyedAccount], /// keyed_accounts: &[KeyedAccount],
/// instruction_data: &[u8], /// instruction_data: &[u8],
/// ) -> Result<(), InstructionError> { /// ) -> Result<(), InstructionError> {

5
sdk/src/entrypoint_native.rs
View File

@ -95,6 +95,7 @@ macro_rules! declare_name {
/// ///
/// fn my_process_instruction( /// fn my_process_instruction(
/// program_id: &Pubkey, /// program_id: &Pubkey,
/// first_instruction_account: usize,
/// instruction_data: &[u8], /// instruction_data: &[u8],
/// invoke_context: &mut dyn InvokeContext, /// invoke_context: &mut dyn InvokeContext,
/// ) -> Result<(), InstructionError> { /// ) -> Result<(), InstructionError> {
@ -128,6 +129,7 @@ macro_rules! declare_name {
/// ///
/// fn my_process_instruction( /// fn my_process_instruction(
/// program_id: &Pubkey, /// program_id: &Pubkey,
/// first_instruction_account: usize,
/// instruction_data: &[u8], /// instruction_data: &[u8],
/// invoke_context: &mut dyn InvokeContext, /// invoke_context: &mut dyn InvokeContext,
/// ) -> Result<(), InstructionError> { /// ) -> Result<(), InstructionError> {
@ -154,10 +156,11 @@ macro_rules! declare_program(
#[no_mangle] #[no_mangle]
pub extern "C" fn $name( pub extern "C" fn $name(
program_id: &$crate::pubkey::Pubkey, program_id: &$crate::pubkey::Pubkey,
first_instruction_account: usize,
instruction_data: &[u8], instruction_data: &[u8],
invoke_context: &mut dyn $crate::process_instruction::InvokeContext, invoke_context: &mut dyn $crate::process_instruction::InvokeContext,
) -> Result<(), $crate::instruction::InstructionError> { ) -> Result<(), $crate::instruction::InstructionError> {
$entrypoint(program_id, instruction_data, invoke_context) $entrypoint(program_id, first_instruction_account, instruction_data, invoke_context)
} }
) )
); );

2
sdk/src/keyed_account.rs
View File

@ -217,6 +217,8 @@ pub fn next_keyed_account<'a, 'b, I: Iterator<Item = &'a KeyedAccount<'b>>>(
} }
/// Return the KeyedAccount at the specified index or a NotEnoughAccountKeys error /// Return the KeyedAccount at the specified index or a NotEnoughAccountKeys error
///
/// Index zero starts at the chain of program accounts, followed by the instruction accounts.
pub fn keyed_account_at_index<'a>( pub fn keyed_account_at_index<'a>(
keyed_accounts: &'a [KeyedAccount], keyed_accounts: &'a [KeyedAccount],
index: usize, index: usize,

23
sdk/src/process_instruction.rs
View File

@ -4,6 +4,7 @@ use itertools::Itertools;
use solana_sdk::{ use solana_sdk::{
account::AccountSharedData, account::AccountSharedData,
compute_budget::ComputeBudget, compute_budget::ComputeBudget,
feature_set::remove_native_loader,
fee_calculator::FeeCalculator, fee_calculator::FeeCalculator,
hash::Hash, hash::Hash,
instruction::{CompiledInstruction, Instruction, InstructionError}, instruction::{CompiledInstruction, Instruction, InstructionError},
@ -27,7 +28,7 @@ pub type LoaderEntrypoint = unsafe extern "C" fn(
) -> Result<(), InstructionError>; ) -> Result<(), InstructionError>;
pub type ProcessInstructionWithContext = pub type ProcessInstructionWithContext =
fn(&Pubkey, &[u8], &mut dyn InvokeContext) -> Result<(), InstructionError>; fn(&Pubkey, usize, &[u8], &mut dyn InvokeContext) -> Result<(), InstructionError>;
pub struct InvokeContextStackFrame<'a> { pub struct InvokeContextStackFrame<'a> {
pub key: Pubkey, pub key: Pubkey,
@ -81,6 +82,10 @@ pub trait InvokeContext {
/// Get the program ID of the currently executing program /// Get the program ID of the currently executing program
fn get_caller(&self) -> Result<&Pubkey, InstructionError>; fn get_caller(&self) -> Result<&Pubkey, InstructionError>;
/// Removes the first keyed account /// Removes the first keyed account
#[deprecated(
since = "1.9.0",
note = "To be removed together with remove_native_loader"
)]
fn remove_first_keyed_account(&mut self) -> Result<(), InstructionError>; fn remove_first_keyed_account(&mut self) -> Result<(), InstructionError>;
/// Get the list of keyed accounts /// Get the list of keyed accounts
fn get_keyed_accounts(&self) -> Result<&[KeyedAccount], InstructionError>; fn get_keyed_accounts(&self) -> Result<&[KeyedAccount], InstructionError>;
@ -395,8 +400,8 @@ pub trait Executor: Debug + Send + Sync {
/// Execute the program /// Execute the program
fn execute( fn execute(
&self, &self,
loader_id: &Pubkey,
program_id: &Pubkey, program_id: &Pubkey,
first_instruction_account: usize,
instruction_data: &[u8], instruction_data: &[u8],
invoke_context: &mut dyn InvokeContext, invoke_context: &mut dyn InvokeContext,
use_jit: bool, use_jit: bool,
@ -538,12 +543,14 @@ impl<'a> InvokeContext for MockInvokeContext<'a> {
.ok_or(InstructionError::CallDepth) .ok_or(InstructionError::CallDepth)
} }
fn remove_first_keyed_account(&mut self) -> Result<(), InstructionError> { fn remove_first_keyed_account(&mut self) -> Result<(), InstructionError> {
let stack_frame = &mut self if !self.is_feature_active(&remove_native_loader::id()) {
.invoke_stack let stack_frame = &mut self
.last_mut() .invoke_stack
.ok_or(InstructionError::CallDepth)?; .last_mut()
stack_frame.keyed_accounts_range.start = .ok_or(InstructionError::CallDepth)?;
stack_frame.keyed_accounts_range.start.saturating_add(1); stack_frame.keyed_accounts_range.start =
stack_frame.keyed_accounts_range.start.saturating_add(1);
}
Ok(()) Ok(())
} }
fn get_keyed_accounts(&self) -> Result<&[KeyedAccount], InstructionError> { fn get_keyed_accounts(&self) -> Result<&[KeyedAccount], InstructionError> {