2019-03-21 15:24:54 -07:00
|
|
|
//! Config program
|
|
|
|
|
|
|
|
use log::*;
|
|
|
|
use solana_sdk::account::KeyedAccount;
|
2019-03-23 20:12:27 -07:00
|
|
|
use solana_sdk::instruction::InstructionError;
|
2019-03-21 15:24:54 -07:00
|
|
|
use solana_sdk::pubkey::Pubkey;
|
|
|
|
|
|
|
|
pub fn process_instruction(
|
|
|
|
_program_id: &Pubkey,
|
|
|
|
keyed_accounts: &mut [KeyedAccount],
|
|
|
|
data: &[u8],
|
|
|
|
) -> Result<(), InstructionError> {
|
2019-05-12 22:47:12 -07:00
|
|
|
if keyed_accounts[0].signer_key().is_none() {
|
|
|
|
error!("account[0].signer_key().is_none()");
|
2019-03-21 15:24:54 -07:00
|
|
|
Err(InstructionError::MissingRequiredSignature)?;
|
|
|
|
}
|
|
|
|
|
2019-05-12 22:47:12 -07:00
|
|
|
if keyed_accounts[0].account.data.len() < data.len() {
|
2019-03-21 15:24:54 -07:00
|
|
|
error!("instruction data too large");
|
|
|
|
Err(InstructionError::InvalidInstructionData)?;
|
|
|
|
}
|
|
|
|
|
2019-05-12 22:47:12 -07:00
|
|
|
keyed_accounts[0].account.data[0..data.len()].copy_from_slice(data);
|
2019-03-21 15:24:54 -07:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2019-04-03 08:45:57 -07:00
|
|
|
use crate::{config_instruction, id, ConfigState};
|
2019-03-21 15:24:54 -07:00
|
|
|
use bincode::{deserialize, serialized_size};
|
|
|
|
use serde_derive::{Deserialize, Serialize};
|
|
|
|
use solana_runtime::bank::Bank;
|
|
|
|
use solana_runtime::bank_client::BankClient;
|
2019-04-11 00:25:14 -07:00
|
|
|
use solana_sdk::client::SyncClient;
|
2019-05-07 11:16:22 -07:00
|
|
|
use solana_sdk::genesis_block::create_genesis_block;
|
2019-03-27 04:36:01 -07:00
|
|
|
use solana_sdk::message::Message;
|
2019-03-21 15:24:54 -07:00
|
|
|
use solana_sdk::signature::{Keypair, KeypairUtil};
|
2019-04-03 08:45:57 -07:00
|
|
|
use solana_sdk::system_instruction;
|
2019-03-21 15:24:54 -07:00
|
|
|
|
|
|
|
#[derive(Serialize, Deserialize, Default, Debug, PartialEq)]
|
|
|
|
struct MyConfig {
|
|
|
|
pub item: u64,
|
|
|
|
}
|
|
|
|
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()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn create_bank(lamports: u64) -> (Bank, Keypair) {
|
2019-05-07 11:16:22 -07:00
|
|
|
let (genesis_block, mint_keypair) = create_genesis_block(lamports);
|
2019-03-21 15:24:54 -07:00
|
|
|
let mut bank = Bank::new(&genesis_block);
|
|
|
|
bank.add_instruction_processor(id(), process_instruction);
|
|
|
|
(bank, mint_keypair)
|
|
|
|
}
|
|
|
|
|
2019-05-17 20:17:50 -07:00
|
|
|
fn create_config_account(bank: Bank, mint_keypair: &Keypair) -> (BankClient, Keypair) {
|
2019-03-27 06:34:01 -07:00
|
|
|
let config_keypair = Keypair::new();
|
|
|
|
let config_pubkey = config_keypair.pubkey();
|
|
|
|
|
2019-04-11 11:29:59 -07:00
|
|
|
let bank_client = BankClient::new(bank);
|
2019-03-27 06:34:01 -07:00
|
|
|
bank_client
|
2019-04-03 14:11:08 -07:00
|
|
|
.send_instruction(
|
2019-05-17 20:17:50 -07:00
|
|
|
mint_keypair,
|
2019-04-03 08:45:57 -07:00
|
|
|
config_instruction::create_account::<MyConfig>(
|
2019-03-27 06:34:01 -07:00
|
|
|
&mint_keypair.pubkey(),
|
|
|
|
&config_pubkey,
|
|
|
|
1,
|
|
|
|
),
|
|
|
|
)
|
2019-03-21 15:24:54 -07:00
|
|
|
.expect("new_account");
|
|
|
|
|
2019-05-12 22:47:12 -07:00
|
|
|
(bank_client, config_keypair)
|
2019-03-21 15:24:54 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_process_create_ok() {
|
|
|
|
solana_logger::setup();
|
2019-05-12 22:47:12 -07:00
|
|
|
let (bank, mint_keypair) = create_bank(10_000);
|
2019-05-17 20:17:50 -07:00
|
|
|
let (bank_client, config_keypair) = create_config_account(bank, &mint_keypair);
|
2019-04-11 11:29:59 -07:00
|
|
|
let config_account_data = bank_client
|
|
|
|
.get_account_data(&config_keypair.pubkey())
|
|
|
|
.unwrap()
|
|
|
|
.unwrap();
|
2019-03-21 15:24:54 -07:00
|
|
|
assert_eq!(
|
|
|
|
MyConfig::default(),
|
2019-04-11 11:29:59 -07:00
|
|
|
MyConfig::deserialize(&config_account_data).unwrap()
|
2019-03-21 15:24:54 -07:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_process_store_ok() {
|
|
|
|
solana_logger::setup();
|
|
|
|
let (bank, mint_keypair) = create_bank(10_000);
|
2019-05-17 20:17:50 -07:00
|
|
|
let (bank_client, config_keypair) = create_config_account(bank, &mint_keypair);
|
2019-03-27 06:34:01 -07:00
|
|
|
let config_pubkey = config_keypair.pubkey();
|
2019-03-21 15:24:54 -07:00
|
|
|
|
|
|
|
let my_config = MyConfig::new(42);
|
2019-05-12 22:47:12 -07:00
|
|
|
|
|
|
|
let instruction = config_instruction::store(&config_pubkey, &my_config);
|
2019-05-17 20:17:50 -07:00
|
|
|
let message = Message::new_with_payer(vec![instruction], Some(&mint_keypair.pubkey()));
|
2019-03-27 06:34:01 -07:00
|
|
|
bank_client
|
2019-05-17 20:17:50 -07:00
|
|
|
.send_message(&[&mint_keypair, &config_keypair], message)
|
2019-03-27 06:34:01 -07:00
|
|
|
.unwrap();
|
2019-03-21 15:24:54 -07:00
|
|
|
|
2019-04-03 20:40:29 -07:00
|
|
|
let config_account_data = bank_client
|
|
|
|
.get_account_data(&config_pubkey)
|
|
|
|
.unwrap()
|
|
|
|
.unwrap();
|
2019-03-21 15:24:54 -07:00
|
|
|
assert_eq!(
|
|
|
|
my_config,
|
2019-04-03 15:36:10 -07:00
|
|
|
MyConfig::deserialize(&config_account_data).unwrap()
|
2019-03-21 15:24:54 -07:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_process_store_fail_instruction_data_too_large() {
|
|
|
|
solana_logger::setup();
|
|
|
|
let (bank, mint_keypair) = create_bank(10_000);
|
2019-05-17 20:17:50 -07:00
|
|
|
let (bank_client, config_keypair) = create_config_account(bank, &mint_keypair);
|
2019-05-12 22:47:12 -07:00
|
|
|
let config_pubkey = config_keypair.pubkey();
|
2019-03-21 15:24:54 -07:00
|
|
|
|
|
|
|
let my_config = MyConfig::new(42);
|
|
|
|
|
2019-05-12 22:47:12 -07:00
|
|
|
let mut instruction = config_instruction::store(&config_pubkey, &my_config);
|
|
|
|
instruction.data = vec![0; 123]; // <-- Replace data with a vector that's too large
|
2019-03-27 06:34:01 -07:00
|
|
|
let message = Message::new(vec![instruction]);
|
|
|
|
bank_client
|
2019-05-12 22:47:12 -07:00
|
|
|
.send_message(&[&config_keypair], message)
|
2019-03-27 06:34:01 -07:00
|
|
|
.unwrap_err();
|
2019-03-21 15:24:54 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-05-12 22:47:12 -07:00
|
|
|
fn test_process_store_fail_account0_not_signer() {
|
2019-03-21 15:24:54 -07:00
|
|
|
solana_logger::setup();
|
|
|
|
let (bank, mint_keypair) = create_bank(10_000);
|
|
|
|
let system_keypair = Keypair::new();
|
|
|
|
let system_pubkey = system_keypair.pubkey();
|
2019-05-12 22:47:12 -07:00
|
|
|
|
2019-03-27 04:59:30 -07:00
|
|
|
bank.transfer(42, &mint_keypair, &system_pubkey).unwrap();
|
2019-05-17 20:17:50 -07:00
|
|
|
let (bank_client, config_keypair) = create_config_account(bank, &mint_keypair);
|
2019-05-12 22:47:12 -07:00
|
|
|
let config_pubkey = config_keypair.pubkey();
|
2019-03-21 15:24:54 -07:00
|
|
|
|
2019-04-23 12:30:42 -07:00
|
|
|
let transfer_instruction =
|
2019-05-23 15:19:53 -07:00
|
|
|
system_instruction::transfer(&system_pubkey, &Pubkey::new_rand(), 42);
|
2019-03-21 15:24:54 -07:00
|
|
|
let my_config = MyConfig::new(42);
|
2019-05-12 22:47:12 -07:00
|
|
|
let mut store_instruction = config_instruction::store(&config_pubkey, &my_config);
|
|
|
|
store_instruction.accounts[0].is_signer = false; // <----- not a signer
|
2019-03-21 15:24:54 -07:00
|
|
|
|
2019-04-23 12:30:42 -07:00
|
|
|
let message = Message::new(vec![transfer_instruction, store_instruction]);
|
2019-03-27 06:34:01 -07:00
|
|
|
bank_client
|
2019-04-03 14:11:08 -07:00
|
|
|
.send_message(&[&system_keypair], message)
|
2019-03-27 06:34:01 -07:00
|
|
|
.unwrap_err();
|
2019-03-21 15:24:54 -07:00
|
|
|
}
|
|
|
|
}
|