2019-03-21 15:24:54 -07:00
|
|
|
//! Config program
|
|
|
|
|
2019-08-14 15:54:31 -07:00
|
|
|
use crate::ConfigKeys;
|
2019-07-08 16:33:56 -07:00
|
|
|
use bincode::deserialize;
|
2021-11-17 10:35:07 -08:00
|
|
|
use solana_program_runtime::{ic_msg, invoke_context::InvokeContext};
|
2020-10-28 20:21:50 -07:00
|
|
|
use solana_sdk::{
|
2021-03-10 13:28:03 -08:00
|
|
|
account::{ReadableAccount, WritableAccount},
|
2021-11-17 10:35:07 -08:00
|
|
|
feature_set,
|
2020-10-28 20:21:50 -07:00
|
|
|
instruction::InstructionError,
|
2021-04-19 09:48:48 -07:00
|
|
|
keyed_account::keyed_account_at_index,
|
2020-10-28 20:21:50 -07:00
|
|
|
program_utils::limited_deserialize,
|
|
|
|
pubkey::Pubkey,
|
|
|
|
};
|
2021-06-03 10:36:39 -07:00
|
|
|
use std::collections::BTreeSet;
|
2019-03-21 15:24:54 -07:00
|
|
|
|
|
|
|
pub fn process_instruction(
|
2021-10-08 02:41:07 -07:00
|
|
|
first_instruction_account: usize,
|
2019-03-21 15:24:54 -07:00
|
|
|
data: &[u8],
|
2021-12-02 09:47:16 -08:00
|
|
|
invoke_context: &mut InvokeContext,
|
2019-03-21 15:24:54 -07:00
|
|
|
) -> Result<(), InstructionError> {
|
2021-04-19 09:48:48 -07:00
|
|
|
let keyed_accounts = invoke_context.get_keyed_accounts()?;
|
2021-02-26 14:21:34 -08:00
|
|
|
|
2021-04-19 09:48:48 -07:00
|
|
|
let key_list: ConfigKeys = limited_deserialize(data)?;
|
2021-10-08 02:41:07 -07:00
|
|
|
let config_keyed_account =
|
|
|
|
&mut keyed_account_at_index(keyed_accounts, first_instruction_account)?;
|
2020-01-22 09:11:56 -08:00
|
|
|
let current_data: ConfigKeys = {
|
|
|
|
let config_account = config_keyed_account.try_account_ref_mut()?;
|
2021-08-31 14:51:26 -07:00
|
|
|
if config_account.owner() != &crate::id() {
|
2021-02-26 14:21:34 -08:00
|
|
|
return Err(InstructionError::InvalidAccountOwner);
|
|
|
|
}
|
|
|
|
|
2021-06-18 06:34:46 -07:00
|
|
|
deserialize(config_account.data()).map_err(|err| {
|
2021-02-22 18:20:46 -08:00
|
|
|
ic_msg!(
|
|
|
|
invoke_context,
|
|
|
|
"Unable to deserialize config account: {}",
|
2019-12-24 18:01:21 -08:00
|
|
|
err
|
|
|
|
);
|
2019-10-15 13:35:42 -07:00
|
|
|
InstructionError::InvalidAccountData
|
2020-01-22 09:11:56 -08:00
|
|
|
})?
|
|
|
|
};
|
2019-07-10 01:00:49 -07:00
|
|
|
let current_signer_keys: Vec<Pubkey> = current_data
|
|
|
|
.keys
|
|
|
|
.iter()
|
|
|
|
.filter(|(_, is_signer)| *is_signer)
|
|
|
|
.map(|(pubkey, _)| *pubkey)
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
if current_signer_keys.is_empty() {
|
2019-11-20 10:12:43 -08:00
|
|
|
// Config account keypair must be a signer on account initialization,
|
2019-07-10 01:00:49 -07:00
|
|
|
// or when no signers specified in Config data
|
2019-10-15 13:35:42 -07:00
|
|
|
if config_keyed_account.signer_key().is_none() {
|
2019-10-02 18:04:18 -07:00
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
2019-07-10 01:00:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-09 12:37:18 -07:00
|
|
|
let mut counter = 0;
|
2019-10-15 13:35:42 -07:00
|
|
|
for (signer, _) in key_list.keys.iter().filter(|(_, is_signer)| *is_signer) {
|
2019-07-09 12:37:18 -07:00
|
|
|
counter += 1;
|
2019-10-15 13:35:42 -07:00
|
|
|
if signer != config_keyed_account.unsigned_key() {
|
2021-10-21 11:57:42 -07:00
|
|
|
let signer_account =
|
|
|
|
keyed_account_at_index(keyed_accounts, counter + 1).map_err(|_| {
|
|
|
|
ic_msg!(
|
|
|
|
invoke_context,
|
|
|
|
"account {:?} is not in account list",
|
|
|
|
signer,
|
|
|
|
);
|
|
|
|
InstructionError::MissingRequiredSignature
|
|
|
|
})?;
|
|
|
|
let signer_key = signer_account.signer_key();
|
2019-07-10 01:00:49 -07:00
|
|
|
if signer_key.is_none() {
|
2021-02-22 18:20:46 -08:00
|
|
|
ic_msg!(
|
|
|
|
invoke_context,
|
|
|
|
"account {:?} signer_key().is_none()",
|
|
|
|
signer
|
|
|
|
);
|
2019-10-02 18:04:18 -07:00
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
2019-07-10 01:00:49 -07:00
|
|
|
}
|
|
|
|
if signer_key.unwrap() != signer {
|
2021-02-22 18:20:46 -08:00
|
|
|
ic_msg!(
|
|
|
|
invoke_context,
|
2019-07-10 01:00:49 -07:00
|
|
|
"account[{:?}].signer_key() does not match Config data)",
|
2019-10-15 13:35:42 -07:00
|
|
|
counter + 1
|
2019-07-10 01:00:49 -07:00
|
|
|
);
|
2019-10-02 18:04:18 -07:00
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
2019-07-10 01:00:49 -07:00
|
|
|
}
|
|
|
|
// If Config account is already initialized, update signatures must match Config data
|
|
|
|
if !current_data.keys.is_empty()
|
2021-04-18 10:27:36 -07:00
|
|
|
&& !current_signer_keys.iter().any(|pubkey| pubkey == signer)
|
2019-07-10 01:00:49 -07:00
|
|
|
{
|
2021-02-22 18:20:46 -08:00
|
|
|
ic_msg!(
|
|
|
|
invoke_context,
|
|
|
|
"account {:?} is not in stored signer list",
|
|
|
|
signer
|
|
|
|
);
|
2019-10-02 18:04:18 -07:00
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
2019-07-10 01:00:49 -07:00
|
|
|
}
|
2019-10-15 13:35:42 -07:00
|
|
|
} else if config_keyed_account.signer_key().is_none() {
|
2021-02-22 18:20:46 -08:00
|
|
|
ic_msg!(invoke_context, "account[0].signer_key().is_none()");
|
2019-10-02 18:04:18 -07:00
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
2019-07-09 12:37:18 -07:00
|
|
|
}
|
|
|
|
}
|
2019-07-08 16:33:56 -07:00
|
|
|
|
2021-12-03 03:15:22 -08:00
|
|
|
if invoke_context
|
|
|
|
.feature_set
|
|
|
|
.is_active(&feature_set::dedupe_config_program_signers::id())
|
|
|
|
{
|
2021-06-03 10:36:39 -07:00
|
|
|
let total_new_keys = key_list.keys.len();
|
|
|
|
let unique_new_keys = key_list.keys.into_iter().collect::<BTreeSet<_>>();
|
|
|
|
if unique_new_keys.len() != total_new_keys {
|
|
|
|
ic_msg!(invoke_context, "new config contains duplicate keys");
|
|
|
|
return Err(InstructionError::InvalidArgument);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-10 01:00:49 -07:00
|
|
|
// Check for Config data signers not present in incoming account update
|
|
|
|
if current_signer_keys.len() > counter {
|
2021-02-22 18:20:46 -08:00
|
|
|
ic_msg!(
|
|
|
|
invoke_context,
|
2019-07-10 01:00:49 -07:00
|
|
|
"too few signers: {:?}; expected: {:?}",
|
|
|
|
counter,
|
|
|
|
current_signer_keys.len()
|
|
|
|
);
|
2019-10-02 18:04:18 -07:00
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
2019-07-10 01:00:49 -07:00
|
|
|
}
|
|
|
|
|
2020-01-22 09:11:56 -08:00
|
|
|
if config_keyed_account.data_len()? < data.len() {
|
2021-02-22 18:20:46 -08:00
|
|
|
ic_msg!(invoke_context, "instruction data too large");
|
2019-10-02 18:04:18 -07:00
|
|
|
return Err(InstructionError::InvalidInstructionData);
|
2019-03-21 15:24:54 -07:00
|
|
|
}
|
|
|
|
|
2021-03-10 13:28:03 -08:00
|
|
|
config_keyed_account
|
|
|
|
.try_account_ref_mut()?
|
|
|
|
.data_as_mut_slice()[..data.len()]
|
2021-06-18 06:34:46 -07:00
|
|
|
.copy_from_slice(data);
|
2019-03-21 15:24:54 -07:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
2019-12-04 19:24:12 -08:00
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
use crate::{config_instruction, get_config_data, id, ConfigKeys, ConfigState};
|
|
|
|
use bincode::serialized_size;
|
|
|
|
use serde_derive::{Deserialize, Serialize};
|
2021-11-04 13:47:32 -07:00
|
|
|
use solana_program_runtime::invoke_context::mock_process_instruction;
|
2019-12-04 19:24:12 -08:00
|
|
|
use solana_sdk::{
|
2021-11-04 13:47:32 -07:00
|
|
|
account::AccountSharedData,
|
2021-10-10 13:29:18 -07:00
|
|
|
pubkey::Pubkey,
|
2020-02-20 13:28:55 -08:00
|
|
|
signature::{Keypair, Signer},
|
2019-12-04 19:24:12 -08:00
|
|
|
system_instruction::SystemInstruction,
|
|
|
|
};
|
2021-11-04 13:47:32 -07:00
|
|
|
use std::{cell::RefCell, rc::Rc};
|
2019-12-04 19:24:12 -08:00
|
|
|
|
2021-10-08 02:41:07 -07:00
|
|
|
fn process_instruction(
|
|
|
|
instruction_data: &[u8],
|
2021-11-04 13:47:32 -07:00
|
|
|
keyed_accounts: &[(bool, bool, Pubkey, Rc<RefCell<AccountSharedData>>)],
|
2021-10-08 02:41:07 -07:00
|
|
|
) -> Result<(), InstructionError> {
|
2021-11-04 13:47:32 -07:00
|
|
|
mock_process_instruction(
|
|
|
|
&id(),
|
|
|
|
Vec::new(),
|
2021-10-08 02:41:07 -07:00
|
|
|
instruction_data,
|
2021-11-04 13:47:32 -07:00
|
|
|
keyed_accounts,
|
|
|
|
super::process_instruction,
|
2021-10-08 02:41:07 -07:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2019-12-04 19:24:12 -08:00
|
|
|
#[derive(Serialize, Deserialize, Debug, PartialEq)]
|
|
|
|
struct MyConfig {
|
|
|
|
pub item: u64,
|
|
|
|
}
|
|
|
|
impl Default for MyConfig {
|
|
|
|
fn default() -> Self {
|
2020-05-15 09:35:43 -07:00
|
|
|
Self { item: 123_456_789 }
|
2019-12-04 19:24:12 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
impl MyConfig {
|
|
|
|
pub fn new(item: u64) -> Self {
|
|
|
|
Self { item }
|
|
|
|
}
|
|
|
|
pub fn deserialize(input: &[u8]) -> Option<Self> {
|
|
|
|
deserialize(input).ok()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ConfigState for MyConfig {
|
|
|
|
fn max_space() -> u64 {
|
|
|
|
serialized_size(&Self::default()).unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-04 13:47:32 -07:00
|
|
|
fn create_config_account(
|
|
|
|
keys: Vec<(Pubkey, bool)>,
|
|
|
|
) -> (Keypair, Rc<RefCell<AccountSharedData>>) {
|
|
|
|
let from_pubkey = Pubkey::new_unique();
|
2019-12-04 19:24:12 -08:00
|
|
|
let config_keypair = Keypair::new();
|
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
|
|
|
|
let instructions =
|
|
|
|
config_instruction::create_account::<MyConfig>(&from_pubkey, &config_pubkey, 1, keys);
|
|
|
|
|
|
|
|
let system_instruction = limited_deserialize(&instructions[0].data).unwrap();
|
|
|
|
let space = match system_instruction {
|
|
|
|
SystemInstruction::CreateAccount {
|
|
|
|
lamports: _,
|
|
|
|
space,
|
2020-05-18 12:55:41 -07:00
|
|
|
owner: _,
|
2019-12-04 19:24:12 -08:00
|
|
|
} => space,
|
|
|
|
_ => panic!("Not a CreateAccount system instruction"),
|
|
|
|
};
|
2021-11-04 13:47:32 -07:00
|
|
|
let config_account = AccountSharedData::new_ref(0, space as usize, &id());
|
|
|
|
let keyed_accounts = [(true, false, config_pubkey, config_account.clone())];
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instructions[1].data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Ok(())
|
|
|
|
);
|
|
|
|
|
|
|
|
(config_keypair, config_account)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_process_create_ok() {
|
|
|
|
solana_logger::setup();
|
2021-10-08 02:41:07 -07:00
|
|
|
let (_, config_account) = create_config_account(vec![]);
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
|
|
|
Some(MyConfig::default()),
|
2021-06-18 06:34:46 -07:00
|
|
|
deserialize(get_config_data(config_account.borrow().data()).unwrap()).ok()
|
2019-12-04 19:24:12 -08:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_process_store_ok() {
|
|
|
|
solana_logger::setup();
|
|
|
|
let keys = vec![];
|
2020-01-22 17:54:06 -08:00
|
|
|
let (config_keypair, config_account) = create_config_account(keys.clone());
|
2019-12-04 19:24:12 -08:00
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
2020-05-15 09:35:43 -07:00
|
|
|
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
|
2021-11-04 13:47:32 -07:00
|
|
|
let keyed_accounts = [(true, false, config_pubkey, config_account.clone())];
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Ok(())
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
Some(my_config),
|
2021-06-18 06:34:46 -07:00
|
|
|
deserialize(get_config_data(config_account.borrow().data()).unwrap()).ok()
|
2019-12-04 19:24:12 -08:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_process_store_fail_instruction_data_too_large() {
|
|
|
|
solana_logger::setup();
|
|
|
|
let keys = vec![];
|
2020-01-22 17:54:06 -08:00
|
|
|
let (config_keypair, config_account) = create_config_account(keys.clone());
|
2019-12-04 19:24:12 -08:00
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
2020-05-15 09:35:43 -07:00
|
|
|
let mut instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
|
2019-12-04 19:24:12 -08:00
|
|
|
instruction.data = vec![0; 123]; // <-- Replace data with a vector that's too large
|
2021-11-04 13:47:32 -07:00
|
|
|
let keyed_accounts = [(true, false, config_pubkey, config_account)];
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Err(InstructionError::InvalidInstructionData)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_process_store_fail_account0_not_signer() {
|
|
|
|
solana_logger::setup();
|
|
|
|
let keys = vec![];
|
2020-05-15 09:35:43 -07:00
|
|
|
let (config_keypair, config_account) = create_config_account(keys);
|
2019-12-04 19:24:12 -08:00
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
|
|
|
let mut instruction = config_instruction::store(&config_pubkey, true, vec![], &my_config);
|
|
|
|
instruction.accounts[0].is_signer = false; // <----- not a signer
|
2021-11-04 13:47:32 -07:00
|
|
|
let keyed_accounts = [(false, false, config_pubkey, config_account)];
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Err(InstructionError::MissingRequiredSignature)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_process_store_with_additional_signers() {
|
|
|
|
solana_logger::setup();
|
2021-11-04 13:47:32 -07:00
|
|
|
let pubkey = Pubkey::new_unique();
|
|
|
|
let signer0_pubkey = Pubkey::new_unique();
|
|
|
|
let signer1_pubkey = Pubkey::new_unique();
|
2019-12-04 19:24:12 -08:00
|
|
|
let keys = vec![
|
|
|
|
(pubkey, false),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
(signer1_pubkey, true),
|
|
|
|
];
|
2020-01-22 17:54:06 -08:00
|
|
|
let (config_keypair, config_account) = create_config_account(keys.clone());
|
2019-12-04 19:24:12 -08:00
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
|
|
|
let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config);
|
2021-11-04 13:47:32 -07:00
|
|
|
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
|
|
|
let signer1_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
2021-10-08 02:41:07 -07:00
|
|
|
let keyed_accounts = [
|
2021-11-04 13:47:32 -07:00
|
|
|
(true, false, config_pubkey, config_account.clone()),
|
|
|
|
(true, false, signer0_pubkey, signer0_account),
|
|
|
|
(true, false, signer1_pubkey, signer1_account),
|
2019-12-04 19:24:12 -08:00
|
|
|
];
|
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Ok(())
|
|
|
|
);
|
2021-06-18 06:34:46 -07:00
|
|
|
let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap();
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(meta_data.keys, keys);
|
|
|
|
assert_eq!(
|
|
|
|
Some(my_config),
|
2021-06-18 06:34:46 -07:00
|
|
|
deserialize(get_config_data(config_account.borrow().data()).unwrap()).ok()
|
2019-12-04 19:24:12 -08:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_process_store_without_config_signer() {
|
|
|
|
solana_logger::setup();
|
2021-11-04 13:47:32 -07:00
|
|
|
let pubkey = Pubkey::new_unique();
|
|
|
|
let signer0_pubkey = Pubkey::new_unique();
|
2019-12-04 19:24:12 -08:00
|
|
|
let keys = vec![(pubkey, false), (signer0_pubkey, true)];
|
|
|
|
let (config_keypair, _) = create_config_account(keys.clone());
|
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
2020-05-15 09:35:43 -07:00
|
|
|
let instruction = config_instruction::store(&config_pubkey, false, keys, &my_config);
|
2021-11-04 13:47:32 -07:00
|
|
|
let signer0_account = AccountSharedData::new_ref(0, 0, &id());
|
|
|
|
let keyed_accounts = [(true, false, signer0_pubkey, signer0_account)];
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Err(InstructionError::InvalidAccountData)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_process_store_with_bad_additional_signer() {
|
|
|
|
solana_logger::setup();
|
2021-11-04 13:47:32 -07:00
|
|
|
let signer0_pubkey = Pubkey::new_unique();
|
|
|
|
let signer1_pubkey = Pubkey::new_unique();
|
|
|
|
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
|
|
|
let signer1_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
2019-12-04 19:24:12 -08:00
|
|
|
let keys = vec![(signer0_pubkey, true)];
|
2020-01-22 17:54:06 -08:00
|
|
|
let (config_keypair, config_account) = create_config_account(keys.clone());
|
2019-12-04 19:24:12 -08:00
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
2020-05-15 09:35:43 -07:00
|
|
|
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
|
2019-12-04 19:24:12 -08:00
|
|
|
|
|
|
|
// Config-data pubkey doesn't match signer
|
2021-10-08 02:41:07 -07:00
|
|
|
let mut keyed_accounts = [
|
2021-11-04 13:47:32 -07:00
|
|
|
(true, false, config_pubkey, config_account),
|
|
|
|
(true, false, signer1_pubkey, signer1_account),
|
2019-12-04 19:24:12 -08:00
|
|
|
];
|
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Err(InstructionError::MissingRequiredSignature)
|
|
|
|
);
|
|
|
|
|
|
|
|
// Config-data pubkey not a signer
|
2021-11-04 13:47:32 -07:00
|
|
|
keyed_accounts[1] = (false, false, signer0_pubkey, signer0_account);
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Err(InstructionError::MissingRequiredSignature)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_config_updates() {
|
|
|
|
solana_logger::setup();
|
2021-11-04 13:47:32 -07:00
|
|
|
let pubkey = Pubkey::new_unique();
|
|
|
|
let signer0_pubkey = Pubkey::new_unique();
|
|
|
|
let signer1_pubkey = Pubkey::new_unique();
|
|
|
|
let signer2_pubkey = Pubkey::new_unique();
|
|
|
|
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
|
|
|
let signer1_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
|
|
|
let signer2_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
2019-12-04 19:24:12 -08:00
|
|
|
let keys = vec![
|
|
|
|
(pubkey, false),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
(signer1_pubkey, true),
|
|
|
|
];
|
2020-01-22 17:54:06 -08:00
|
|
|
let (config_keypair, config_account) = create_config_account(keys.clone());
|
2019-12-04 19:24:12 -08:00
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
|
|
|
let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config);
|
2021-10-08 02:41:07 -07:00
|
|
|
let mut keyed_accounts = [
|
2021-11-04 13:47:32 -07:00
|
|
|
(true, false, config_pubkey, config_account.clone()),
|
|
|
|
(true, false, signer0_pubkey, signer0_account),
|
|
|
|
(true, false, signer1_pubkey, signer1_account),
|
2019-12-04 19:24:12 -08:00
|
|
|
];
|
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Ok(())
|
|
|
|
);
|
|
|
|
|
|
|
|
// Update with expected signatures
|
|
|
|
let new_config = MyConfig::new(84);
|
|
|
|
let instruction =
|
|
|
|
config_instruction::store(&config_pubkey, false, keys.clone(), &new_config);
|
2021-10-08 02:41:07 -07:00
|
|
|
keyed_accounts[0].0 = false;
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Ok(())
|
|
|
|
);
|
2021-06-18 06:34:46 -07:00
|
|
|
let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap();
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(meta_data.keys, keys);
|
|
|
|
assert_eq!(
|
|
|
|
new_config,
|
2021-06-18 06:34:46 -07:00
|
|
|
MyConfig::deserialize(get_config_data(config_account.borrow().data()).unwrap())
|
2021-03-09 14:31:33 -08:00
|
|
|
.unwrap()
|
2019-12-04 19:24:12 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Attempt update with incomplete signatures
|
|
|
|
let keys = vec![(pubkey, false), (signer0_pubkey, true)];
|
2020-05-15 09:35:43 -07:00
|
|
|
let instruction = config_instruction::store(&config_pubkey, false, keys, &my_config);
|
2021-10-08 02:41:07 -07:00
|
|
|
keyed_accounts[2].0 = false;
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Err(InstructionError::MissingRequiredSignature)
|
|
|
|
);
|
|
|
|
|
|
|
|
// Attempt update with incorrect signatures
|
|
|
|
let keys = vec![
|
|
|
|
(pubkey, false),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
(signer2_pubkey, true),
|
|
|
|
];
|
2020-05-15 09:35:43 -07:00
|
|
|
let instruction = config_instruction::store(&config_pubkey, false, keys, &my_config);
|
2021-11-04 13:47:32 -07:00
|
|
|
keyed_accounts[2] = (true, false, signer2_pubkey, signer2_account);
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Err(InstructionError::MissingRequiredSignature)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2021-06-03 10:36:39 -07:00
|
|
|
#[test]
|
|
|
|
fn test_config_initialize_contains_duplicates_fails() {
|
|
|
|
solana_logger::setup();
|
|
|
|
let config_address = Pubkey::new_unique();
|
|
|
|
let signer0_pubkey = Pubkey::new_unique();
|
2021-11-04 13:47:32 -07:00
|
|
|
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
2021-06-03 10:36:39 -07:00
|
|
|
let keys = vec![
|
|
|
|
(config_address, false),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
];
|
|
|
|
let (config_keypair, config_account) = create_config_account(keys.clone());
|
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
|
|
|
// Attempt initialization with duplicate signer inputs
|
|
|
|
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
|
2021-10-08 02:41:07 -07:00
|
|
|
let keyed_accounts = [
|
2021-11-04 13:47:32 -07:00
|
|
|
(true, false, config_pubkey, config_account),
|
|
|
|
(true, false, signer0_pubkey, signer0_account.clone()),
|
|
|
|
(true, false, signer0_pubkey, signer0_account),
|
2021-06-03 10:36:39 -07:00
|
|
|
];
|
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2021-06-03 10:36:39 -07:00
|
|
|
Err(InstructionError::InvalidArgument),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_config_update_contains_duplicates_fails() {
|
|
|
|
solana_logger::setup();
|
|
|
|
let config_address = Pubkey::new_unique();
|
|
|
|
let signer0_pubkey = Pubkey::new_unique();
|
|
|
|
let signer1_pubkey = Pubkey::new_unique();
|
2021-11-04 13:47:32 -07:00
|
|
|
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
|
|
|
let signer1_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
2021-06-03 10:36:39 -07:00
|
|
|
let keys = vec![
|
|
|
|
(config_address, false),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
(signer1_pubkey, true),
|
|
|
|
];
|
|
|
|
let (config_keypair, config_account) = create_config_account(keys.clone());
|
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
|
|
|
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
|
2021-10-08 02:41:07 -07:00
|
|
|
let mut keyed_accounts = [
|
2021-11-04 13:47:32 -07:00
|
|
|
(true, false, config_pubkey, config_account),
|
|
|
|
(true, false, signer0_pubkey, signer0_account),
|
|
|
|
(true, false, signer1_pubkey, signer1_account),
|
2021-06-03 10:36:39 -07:00
|
|
|
];
|
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2021-06-03 10:36:39 -07:00
|
|
|
Ok(()),
|
|
|
|
);
|
|
|
|
|
|
|
|
// Attempt update with duplicate signer inputs
|
|
|
|
let new_config = MyConfig::new(84);
|
|
|
|
let dupe_keys = vec![
|
|
|
|
(config_address, false),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
];
|
|
|
|
let instruction = config_instruction::store(&config_pubkey, false, dupe_keys, &new_config);
|
2021-11-04 13:47:32 -07:00
|
|
|
keyed_accounts[2] = keyed_accounts[1].clone();
|
2021-06-03 10:36:39 -07:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2021-06-03 10:36:39 -07:00
|
|
|
Err(InstructionError::InvalidArgument),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-12-04 19:24:12 -08:00
|
|
|
#[test]
|
|
|
|
fn test_config_updates_requiring_config() {
|
|
|
|
solana_logger::setup();
|
2021-11-04 13:47:32 -07:00
|
|
|
let pubkey = Pubkey::new_unique();
|
|
|
|
let signer0_pubkey = Pubkey::new_unique();
|
|
|
|
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
2019-12-04 19:24:12 -08:00
|
|
|
let keys = vec![
|
|
|
|
(pubkey, false),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
]; // Dummy keys for account sizing
|
2020-05-15 09:35:43 -07:00
|
|
|
let (config_keypair, config_account) = create_config_account(keys);
|
2019-12-04 19:24:12 -08:00
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
|
|
|
let keys = vec![
|
|
|
|
(pubkey, false),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
(config_keypair.pubkey(), true),
|
|
|
|
];
|
|
|
|
|
|
|
|
let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config);
|
2021-10-08 02:41:07 -07:00
|
|
|
let keyed_accounts = [
|
2021-11-04 13:47:32 -07:00
|
|
|
(true, false, config_pubkey, config_account.clone()),
|
|
|
|
(true, false, signer0_pubkey, signer0_account),
|
2019-12-04 19:24:12 -08:00
|
|
|
];
|
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Ok(())
|
|
|
|
);
|
|
|
|
|
|
|
|
// Update with expected signatures
|
|
|
|
let new_config = MyConfig::new(84);
|
|
|
|
let instruction =
|
|
|
|
config_instruction::store(&config_pubkey, true, keys.clone(), &new_config);
|
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2019-12-04 19:24:12 -08:00
|
|
|
Ok(())
|
|
|
|
);
|
2021-06-18 06:34:46 -07:00
|
|
|
let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap();
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(meta_data.keys, keys);
|
|
|
|
assert_eq!(
|
|
|
|
new_config,
|
2021-06-18 06:34:46 -07:00
|
|
|
MyConfig::deserialize(get_config_data(config_account.borrow().data()).unwrap())
|
2021-03-09 14:31:33 -08:00
|
|
|
.unwrap()
|
2019-12-04 19:24:12 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Attempt update with incomplete signatures
|
|
|
|
let keys = vec![(pubkey, false), (config_keypair.pubkey(), true)];
|
2020-05-15 09:35:43 -07:00
|
|
|
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
|
2019-12-04 19:24:12 -08:00
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts[0..1]),
|
2019-12-04 19:24:12 -08:00
|
|
|
Err(InstructionError::MissingRequiredSignature)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_config_initialize_no_panic() {
|
2021-11-04 13:47:32 -07:00
|
|
|
let from_pubkey = Pubkey::new_unique();
|
|
|
|
let config_pubkey = Pubkey::new_unique();
|
2021-10-08 02:41:07 -07:00
|
|
|
let (_, _config_account) = create_config_account(vec![]);
|
2019-12-04 19:24:12 -08:00
|
|
|
let instructions =
|
|
|
|
config_instruction::create_account::<MyConfig>(&from_pubkey, &config_pubkey, 1, vec![]);
|
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instructions[1].data, &[]),
|
2019-12-04 19:24:12 -08:00
|
|
|
Err(InstructionError::NotEnoughAccountKeys)
|
|
|
|
);
|
|
|
|
}
|
2021-02-26 14:21:34 -08:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_config_bad_owner() {
|
2021-11-04 13:47:32 -07:00
|
|
|
let from_pubkey = Pubkey::new_unique();
|
|
|
|
let config_pubkey = Pubkey::new_unique();
|
2021-02-26 14:21:34 -08:00
|
|
|
let new_config = MyConfig::new(84);
|
2021-11-04 13:47:32 -07:00
|
|
|
let signer0_pubkey = Pubkey::new_unique();
|
|
|
|
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
|
|
|
let config_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
|
2021-10-08 02:41:07 -07:00
|
|
|
let (_, _config_account) = create_config_account(vec![]);
|
2021-02-26 14:21:34 -08:00
|
|
|
let keys = vec![
|
|
|
|
(from_pubkey, false),
|
|
|
|
(signer0_pubkey, true),
|
|
|
|
(config_pubkey, true),
|
|
|
|
];
|
|
|
|
|
|
|
|
let instruction = config_instruction::store(&config_pubkey, true, keys, &new_config);
|
2021-10-08 02:41:07 -07:00
|
|
|
let keyed_accounts = [
|
2021-11-04 13:47:32 -07:00
|
|
|
(true, false, config_pubkey, config_account),
|
|
|
|
(true, false, signer0_pubkey, signer0_account),
|
2021-02-26 14:21:34 -08:00
|
|
|
];
|
|
|
|
assert_eq!(
|
2021-11-04 13:47:32 -07:00
|
|
|
process_instruction(&instruction.data, &keyed_accounts),
|
2021-02-26 14:21:34 -08:00
|
|
|
Err(InstructionError::InvalidAccountOwner)
|
|
|
|
);
|
|
|
|
}
|
2019-12-04 19:24:12 -08:00
|
|
|
}
|