2019-05-24 16:21:42 -07:00
|
|
|
pub mod alloc;
|
|
|
|
pub mod allocator_bump;
|
2018-10-16 16:33:31 -07:00
|
|
|
pub mod bpf_verifier;
|
2019-06-21 11:08:50 -07:00
|
|
|
pub mod helpers;
|
2018-10-16 16:33:31 -07:00
|
|
|
|
2018-10-16 09:43:49 -07:00
|
|
|
use byteorder::{ByteOrder, LittleEndian, WriteBytesExt};
|
2018-12-14 20:39:10 -08:00
|
|
|
use log::*;
|
2019-08-23 11:03:53 -07:00
|
|
|
use solana_rbpf::{memory_region::MemoryRegion, EbpfVm};
|
2020-01-02 18:18:56 -08:00
|
|
|
use solana_sdk::{
|
|
|
|
account::KeyedAccount,
|
|
|
|
instruction::InstructionError,
|
2020-01-10 13:20:15 -08:00
|
|
|
instruction_processor_utils::{is_executable, limited_deserialize, next_keyed_account},
|
2020-01-02 18:18:56 -08:00
|
|
|
loader_instruction::LoaderInstruction,
|
|
|
|
pubkey::Pubkey,
|
|
|
|
sysvar::rent,
|
|
|
|
};
|
2020-01-09 23:58:13 -08:00
|
|
|
use std::{
|
|
|
|
convert::TryFrom,
|
|
|
|
io::{prelude::*, Error},
|
|
|
|
mem,
|
|
|
|
};
|
2019-05-24 16:21:42 -07:00
|
|
|
|
2019-11-20 16:32:19 -08:00
|
|
|
solana_sdk::declare_program!(
|
2019-12-03 17:55:18 -08:00
|
|
|
solana_sdk::bpf_loader::ID,
|
2019-11-20 16:32:19 -08:00
|
|
|
solana_bpf_loader_program,
|
|
|
|
process_instruction
|
|
|
|
);
|
|
|
|
|
2019-08-23 11:03:53 -07:00
|
|
|
pub fn create_vm(prog: &[u8]) -> Result<(EbpfVm, MemoryRegion), Error> {
|
|
|
|
let mut vm = EbpfVm::new(None)?;
|
2018-10-26 19:38:07 -07:00
|
|
|
vm.set_verifier(bpf_verifier::check)?;
|
2019-10-02 10:07:44 -07:00
|
|
|
vm.set_max_instruction_count(100_000)?;
|
2018-11-06 14:28:46 -08:00
|
|
|
vm.set_elf(&prog)?;
|
2019-05-24 16:21:42 -07:00
|
|
|
|
2019-06-21 11:08:50 -07:00
|
|
|
let heap_region = helpers::register_helpers(&mut vm)?;
|
2019-05-24 16:21:42 -07:00
|
|
|
|
|
|
|
Ok((vm, heap_region))
|
2018-10-26 19:38:07 -07:00
|
|
|
}
|
|
|
|
|
2019-12-04 12:03:29 -08:00
|
|
|
pub fn check_elf(prog: &[u8]) -> Result<(), Error> {
|
|
|
|
let mut vm = EbpfVm::new(None)?;
|
|
|
|
vm.set_verifier(bpf_verifier::check)?;
|
|
|
|
vm.set_elf(&prog)?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2020-01-02 18:18:56 -08:00
|
|
|
pub fn serialize_parameters(
|
2018-11-17 17:02:14 -08:00
|
|
|
program_id: &Pubkey,
|
2018-11-13 19:54:41 -08:00
|
|
|
keyed_accounts: &mut [KeyedAccount],
|
|
|
|
data: &[u8],
|
|
|
|
) -> Vec<u8> {
|
2018-10-16 09:43:49 -07:00
|
|
|
assert_eq!(32, mem::size_of::<Pubkey>());
|
|
|
|
|
|
|
|
let mut v: Vec<u8> = Vec::new();
|
|
|
|
v.write_u64::<LittleEndian>(keyed_accounts.len() as u64)
|
|
|
|
.unwrap();
|
2020-01-21 10:38:46 -08:00
|
|
|
for keyed_account in keyed_accounts.iter_mut() {
|
|
|
|
v.write_u64::<LittleEndian>(keyed_account.signer_key().is_some() as u64)
|
2018-11-29 12:32:16 -08:00
|
|
|
.unwrap();
|
2020-01-21 10:38:46 -08:00
|
|
|
v.write_all(keyed_account.unsigned_key().as_ref()).unwrap();
|
|
|
|
v.write_u64::<LittleEndian>(keyed_account.account.lamports)
|
2018-10-16 09:43:49 -07:00
|
|
|
.unwrap();
|
2020-01-21 10:38:46 -08:00
|
|
|
v.write_u64::<LittleEndian>(keyed_account.account.data.len() as u64)
|
|
|
|
.unwrap();
|
|
|
|
v.write_all(&keyed_account.account.data).unwrap();
|
|
|
|
v.write_all(keyed_account.account.owner.as_ref()).unwrap();
|
2018-10-16 09:43:49 -07:00
|
|
|
}
|
|
|
|
v.write_u64::<LittleEndian>(data.len() as u64).unwrap();
|
|
|
|
v.write_all(data).unwrap();
|
2018-11-17 17:02:14 -08:00
|
|
|
v.write_all(program_id.as_ref()).unwrap();
|
2018-10-16 09:43:49 -07:00
|
|
|
v
|
|
|
|
}
|
|
|
|
|
2020-01-02 18:18:56 -08:00
|
|
|
pub fn deserialize_parameters(keyed_accounts: &mut [KeyedAccount], buffer: &[u8]) {
|
2018-10-16 09:43:49 -07:00
|
|
|
assert_eq!(32, mem::size_of::<Pubkey>());
|
|
|
|
|
|
|
|
let mut start = mem::size_of::<u64>();
|
2020-01-21 10:38:46 -08:00
|
|
|
for keyed_account in keyed_accounts.iter_mut() {
|
2018-11-29 12:32:16 -08:00
|
|
|
start += mem::size_of::<u64>(); // skip signer_key boolean
|
2018-10-16 09:43:49 -07:00
|
|
|
start += mem::size_of::<Pubkey>(); // skip pubkey
|
2020-01-21 10:38:46 -08:00
|
|
|
keyed_account.account.lamports = LittleEndian::read_u64(&buffer[start..]);
|
2018-10-16 09:43:49 -07:00
|
|
|
|
2019-03-05 16:28:14 -08:00
|
|
|
start += mem::size_of::<u64>() // skip lamports
|
2018-10-16 09:43:49 -07:00
|
|
|
+ mem::size_of::<u64>(); // skip length tag
|
2020-01-21 10:38:46 -08:00
|
|
|
let end = start + keyed_account.account.data.len();
|
|
|
|
keyed_account
|
|
|
|
.account
|
|
|
|
.data
|
|
|
|
.clone_from_slice(&buffer[start..end]);
|
2018-10-16 09:43:49 -07:00
|
|
|
|
2020-01-21 10:38:46 -08:00
|
|
|
start += keyed_account.account.data.len() // skip data
|
2018-11-12 09:29:17 -08:00
|
|
|
+ mem::size_of::<Pubkey>(); // skip owner
|
2018-10-16 09:43:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-12 08:49:59 -07:00
|
|
|
pub fn process_instruction(
|
2018-11-17 17:02:14 -08:00
|
|
|
program_id: &Pubkey,
|
|
|
|
keyed_accounts: &mut [KeyedAccount],
|
2020-01-10 13:20:15 -08:00
|
|
|
instruction_data: &[u8],
|
2019-03-18 09:05:03 -07:00
|
|
|
) -> Result<(), InstructionError> {
|
2020-01-08 09:19:12 -08:00
|
|
|
solana_logger::setup_with_default("solana=info");
|
2018-10-16 16:33:31 -07:00
|
|
|
|
2020-01-10 13:20:15 -08:00
|
|
|
if keyed_accounts.is_empty() {
|
|
|
|
warn!("No account keys");
|
|
|
|
return Err(InstructionError::NotEnoughAccountKeys);
|
|
|
|
}
|
|
|
|
|
|
|
|
if is_executable(keyed_accounts) {
|
|
|
|
let mut keyed_accounts_iter = keyed_accounts.iter_mut();
|
|
|
|
let program = next_keyed_account(&mut keyed_accounts_iter)?;
|
|
|
|
|
|
|
|
if !program.account.executable {
|
|
|
|
warn!("BPF program account not executable");
|
|
|
|
return Err(InstructionError::AccountNotExecutable);
|
|
|
|
}
|
|
|
|
let (mut vm, heap_region) = match create_vm(&program.account.data) {
|
|
|
|
Ok(info) => info,
|
|
|
|
Err(e) => {
|
|
|
|
warn!("Failed to create BPF VM: {}", e);
|
|
|
|
return Err(InstructionError::GenericError);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
let parameter_accounts = keyed_accounts_iter.into_slice();
|
|
|
|
let mut parameter_bytes =
|
|
|
|
serialize_parameters(program_id, parameter_accounts, &instruction_data);
|
|
|
|
|
|
|
|
info!("Call BPF program");
|
|
|
|
match vm.execute_program(parameter_bytes.as_mut_slice(), &[], &[heap_region]) {
|
|
|
|
Ok(status) => match u32::try_from(status) {
|
|
|
|
Ok(status) => {
|
|
|
|
if status > 0 {
|
|
|
|
warn!("BPF program failed: {}", status);
|
|
|
|
return Err(InstructionError::CustomError(status));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Err(e) => {
|
|
|
|
warn!("BPF VM encountered invalid status: {}", e);
|
|
|
|
return Err(InstructionError::GenericError);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
Err(e) => {
|
|
|
|
warn!("BPF VM failed to run program: {}", e);
|
|
|
|
return Err(InstructionError::GenericError);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
deserialize_parameters(parameter_accounts, ¶meter_bytes);
|
|
|
|
info!("BPF program success");
|
|
|
|
} else if !keyed_accounts.is_empty() {
|
|
|
|
match limited_deserialize(instruction_data)? {
|
2018-10-16 09:43:49 -07:00
|
|
|
LoaderInstruction::Write { offset, bytes } => {
|
2019-11-08 09:19:19 -08:00
|
|
|
let mut keyed_accounts_iter = keyed_accounts.iter_mut();
|
|
|
|
let program = next_keyed_account(&mut keyed_accounts_iter)?;
|
|
|
|
if program.signer_key().is_none() {
|
2019-07-16 09:45:32 -07:00
|
|
|
warn!("key[0] did not sign the transaction");
|
2019-11-08 09:19:19 -08:00
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
2019-07-16 09:45:32 -07:00
|
|
|
}
|
2018-10-16 09:43:49 -07:00
|
|
|
let offset = offset as usize;
|
2018-10-19 18:28:38 -07:00
|
|
|
let len = bytes.len();
|
2019-09-10 16:13:23 -07:00
|
|
|
trace!("Write: offset={} length={}", offset, len);
|
2019-11-08 09:19:19 -08:00
|
|
|
if program.account.data.len() < offset + len {
|
2018-10-30 08:39:10 -07:00
|
|
|
warn!(
|
|
|
|
"Write overflow: {} < {}",
|
2019-11-08 09:19:19 -08:00
|
|
|
program.account.data.len(),
|
2018-10-19 18:28:38 -07:00
|
|
|
offset + len
|
|
|
|
);
|
2019-11-08 09:19:19 -08:00
|
|
|
return Err(InstructionError::AccountDataTooSmall);
|
2018-10-16 09:43:49 -07:00
|
|
|
}
|
2019-11-08 09:19:19 -08:00
|
|
|
program.account.data[offset..offset + len].copy_from_slice(&bytes);
|
2018-10-16 09:43:49 -07:00
|
|
|
}
|
|
|
|
LoaderInstruction::Finalize => {
|
2019-11-08 09:19:19 -08:00
|
|
|
let mut keyed_accounts_iter = keyed_accounts.iter_mut();
|
|
|
|
let program = next_keyed_account(&mut keyed_accounts_iter)?;
|
|
|
|
let rent = next_keyed_account(&mut keyed_accounts_iter)?;
|
|
|
|
|
|
|
|
if program.signer_key().is_none() {
|
2019-07-16 09:45:32 -07:00
|
|
|
warn!("key[0] did not sign the transaction");
|
2019-11-08 09:19:19 -08:00
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
2019-07-16 09:45:32 -07:00
|
|
|
}
|
2019-10-03 14:22:48 -07:00
|
|
|
|
2019-12-04 12:03:29 -08:00
|
|
|
if let Err(e) = check_elf(&program.account.data) {
|
|
|
|
warn!("Invalid ELF: {}", e);
|
|
|
|
return Err(InstructionError::InvalidAccountData);
|
|
|
|
}
|
|
|
|
|
2019-11-08 09:19:19 -08:00
|
|
|
rent::verify_rent_exemption(&program, &rent)?;
|
2019-10-03 14:22:48 -07:00
|
|
|
|
2019-11-08 09:19:19 -08:00
|
|
|
program.account.executable = true;
|
|
|
|
info!("Finalize: account {:?}", program.signer_key().unwrap());
|
2018-10-16 09:43:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-12-03 13:32:31 -08:00
|
|
|
Ok(())
|
2018-10-16 09:43:49 -07:00
|
|
|
}
|
2018-10-31 10:59:56 -07:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2019-11-08 09:19:19 -08:00
|
|
|
use solana_sdk::account::Account;
|
|
|
|
use std::fs::File;
|
|
|
|
use std::io::Read;
|
2018-11-06 14:28:46 -08:00
|
|
|
|
2018-10-31 10:59:56 -07:00
|
|
|
#[test]
|
2019-08-23 11:03:53 -07:00
|
|
|
#[should_panic(expected = "Error: Exceeded maximum number of instructions allowed")]
|
2019-11-08 09:19:19 -08:00
|
|
|
fn test_bpf_loader_non_terminating_program() {
|
2018-10-31 10:59:56 -07:00
|
|
|
#[rustfmt::skip]
|
2019-11-08 09:19:19 -08:00
|
|
|
let program = &[
|
2019-02-22 16:27:19 -08:00
|
|
|
0x07, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // r6 + 1
|
|
|
|
0x05, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, // goto -2
|
2018-10-31 10:59:56 -07:00
|
|
|
0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // exit
|
|
|
|
];
|
|
|
|
let input = &mut [0x00];
|
2018-11-06 14:28:46 -08:00
|
|
|
|
2019-08-23 11:03:53 -07:00
|
|
|
let mut vm = EbpfVm::new(None).unwrap();
|
2018-11-06 14:28:46 -08:00
|
|
|
vm.set_verifier(bpf_verifier::check).unwrap();
|
2019-02-22 16:27:19 -08:00
|
|
|
vm.set_max_instruction_count(10).unwrap();
|
2019-11-08 09:19:19 -08:00
|
|
|
vm.set_program(program).unwrap();
|
2019-05-24 16:21:42 -07:00
|
|
|
vm.execute_program(input, &[], &[]).unwrap();
|
2018-10-31 10:59:56 -07:00
|
|
|
}
|
2019-11-08 09:19:19 -08:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_bpf_loader_write() {
|
|
|
|
let program_id = Pubkey::new_rand();
|
|
|
|
let program_key = Pubkey::new_rand();
|
|
|
|
let mut program_account = Account::new(1, 0, &program_id);
|
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, false, &mut program_account)];
|
2020-01-10 13:20:15 -08:00
|
|
|
let instruction_data = bincode::serialize(&LoaderInstruction::Write {
|
2019-11-08 09:19:19 -08:00
|
|
|
offset: 3,
|
|
|
|
bytes: vec![1, 2, 3],
|
|
|
|
})
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
// Case: Empty keyed accounts
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::NotEnoughAccountKeys),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut vec![], &instruction_data)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Not signed
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::MissingRequiredSignature),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut keyed_accounts, &instruction_data)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Write bytes to an offset
|
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, true, &mut program_account)];
|
|
|
|
keyed_accounts[0].account.data = vec![0; 6];
|
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut keyed_accounts, &instruction_data)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
assert_eq!(vec![0, 0, 0, 1, 2, 3], keyed_accounts[0].account.data);
|
|
|
|
|
|
|
|
// Case: Overflow
|
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, true, &mut program_account)];
|
|
|
|
keyed_accounts[0].account.data = vec![0; 5];
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::AccountDataTooSmall),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut keyed_accounts, &instruction_data)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_bpf_loader_finalize() {
|
|
|
|
let program_id = Pubkey::new_rand();
|
|
|
|
let program_key = Pubkey::new_rand();
|
|
|
|
let rent_key = rent::id();
|
2019-12-04 12:03:29 -08:00
|
|
|
let mut file = File::open("test_elfs/noop.so").expect("file open failed");
|
|
|
|
let mut elf = Vec::new();
|
2019-12-09 21:56:43 -08:00
|
|
|
let rent = rent::Rent::default();
|
2019-12-04 12:03:29 -08:00
|
|
|
file.read_to_end(&mut elf).unwrap();
|
2019-12-09 21:56:43 -08:00
|
|
|
let mut program_account = Account::new(rent.minimum_balance(elf.len()), 0, &program_id);
|
2019-12-04 12:03:29 -08:00
|
|
|
program_account.data = elf;
|
2019-11-08 09:19:19 -08:00
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, false, &mut program_account)];
|
2020-01-10 13:20:15 -08:00
|
|
|
let instruction_data = bincode::serialize(&LoaderInstruction::Finalize).unwrap();
|
2019-11-08 09:19:19 -08:00
|
|
|
|
|
|
|
// Case: Empty keyed accounts
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::NotEnoughAccountKeys),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut vec![], &instruction_data)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
2019-12-09 21:56:43 -08:00
|
|
|
let mut rent_account = rent::create_account(1, &rent);
|
2019-11-08 09:19:19 -08:00
|
|
|
keyed_accounts.push(KeyedAccount::new(&rent_key, false, &mut rent_account));
|
|
|
|
|
|
|
|
// Case: Not signed
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::MissingRequiredSignature),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut keyed_accounts, &instruction_data)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Finalize
|
|
|
|
let mut keyed_accounts = vec![
|
|
|
|
KeyedAccount::new(&program_key, true, &mut program_account),
|
|
|
|
KeyedAccount::new(&rent_key, false, &mut rent_account),
|
|
|
|
];
|
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut keyed_accounts, &instruction_data)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
assert!(keyed_accounts[0].account.executable);
|
2020-01-10 13:20:15 -08:00
|
|
|
program_account.executable = false; // Un-finalize the account
|
2019-12-04 12:03:29 -08:00
|
|
|
|
|
|
|
// Case: Finalize
|
|
|
|
program_account.data[0] = 0; // bad elf
|
|
|
|
let mut keyed_accounts = vec![
|
|
|
|
KeyedAccount::new(&program_key, true, &mut program_account),
|
|
|
|
KeyedAccount::new(&rent_key, false, &mut rent_account),
|
|
|
|
];
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::InvalidAccountData),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut keyed_accounts, &instruction_data)
|
2019-12-04 12:03:29 -08:00
|
|
|
);
|
2019-11-08 09:19:19 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_bpf_loader_invoke_main() {
|
|
|
|
let program_id = Pubkey::new_rand();
|
|
|
|
let program_key = Pubkey::new_rand();
|
|
|
|
|
|
|
|
// Create program account
|
|
|
|
let mut file = File::open("test_elfs/noop.so").expect("file open failed");
|
|
|
|
let mut elf = Vec::new();
|
|
|
|
file.read_to_end(&mut elf).unwrap();
|
|
|
|
let mut program_account = Account::new(1, 0, &program_id);
|
|
|
|
program_account.data = elf;
|
|
|
|
program_account.executable = true;
|
|
|
|
|
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, false, &mut program_account)];
|
|
|
|
|
|
|
|
// Case: Empty keyed accounts
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::NotEnoughAccountKeys),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut vec![], &vec![])
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Only a program account
|
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut keyed_accounts, &vec![])
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Account not executable
|
|
|
|
keyed_accounts[0].account.executable = false;
|
|
|
|
assert_eq!(
|
2020-01-10 13:20:15 -08:00
|
|
|
Err(InstructionError::InvalidInstructionData),
|
|
|
|
process_instruction(&program_id, &mut keyed_accounts, &vec![])
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
keyed_accounts[0].account.executable = true;
|
|
|
|
|
|
|
|
// Case: With program and parameter account
|
|
|
|
let mut parameter_account = Account::new(1, 0, &program_id);
|
|
|
|
keyed_accounts.push(KeyedAccount::new(
|
|
|
|
&program_key,
|
|
|
|
false,
|
|
|
|
&mut parameter_account,
|
|
|
|
));
|
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
2020-01-10 13:20:15 -08:00
|
|
|
process_instruction(&program_id, &mut keyed_accounts, &vec![])
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
}
|
2018-10-31 10:59:56 -07:00
|
|
|
}
|