From 0aeb60edb97f18f272b795fa725d79360943722d Mon Sep 17 00:00:00 2001 From: Hardhat Chad Date: Sun, 24 Mar 2024 20:51:47 +0000 Subject: [PATCH] loaders unit tests --- src/loaders.rs | 940 +++++++++++++++++++++++++++++++++++++++ tests/test_initialize.rs | 154 ++----- tests/test_reset.rs | 17 + 3 files changed, 983 insertions(+), 128 deletions(-) diff --git a/src/loaders.rs b/src/loaders.rs index 288ca60..902b996 100644 --- a/src/loaders.rs +++ b/src/loaders.rs @@ -276,6 +276,7 @@ pub fn load_uninitialized_account<'a, 'info>( if !info.is_writable { return Err(ProgramError::InvalidAccountData); } + Ok(()) } @@ -329,3 +330,942 @@ pub fn load_program<'a, 'info>( Ok(()) } + +#[cfg(test)] +mod tests { + use solana_program::{ + account_info::AccountInfo, keccak::Hash as KeccakHash, program_option::COption, + program_pack::Pack, pubkey::Pubkey, system_program, + }; + use spl_token::state::{AccountState, Mint}; + + use crate::{ + loaders::{ + load_account, load_any_bus, load_bus, load_mint, load_proof, load_signer, load_sysvar, + load_token_account, load_treasury, load_uninitialized_account, load_uninitialized_pda, + }, + state::{Bus, Proof, Treasury}, + utils::Discriminator, + BUS, BUS_ADDRESSES, BUS_COUNT, MINT_ADDRESS, PROOF, TOKEN_DECIMALS, TREASURY, + TREASURY_ADDRESS, + }; + + use super::load_program; + + #[test] + pub fn test_signer_not_signer() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_signer(&info).is_err()); + } + + #[test] + pub fn test_load_bus_bad_account_owner() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_bus(&info, 0, true).is_err()); + } + + #[test] + pub fn test_load_bus_bad_key() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_bus(&info, 0, true).is_err()); + } + + #[test] + pub fn test_load_bus_empty_data() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_bus(&info, 0, true).is_err()); + } + + #[test] + pub fn test_load_bus_bad_data() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = [ + &(Treasury::discriminator() as u64).to_le_bytes(), // Bus discriminator + Bus { id: 0, rewards: 0 }.to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_bus(&info, 0, true).is_err()); + } + + #[test] + pub fn test_load_bus_bad_id() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = [ + &(Bus::discriminator() as u64).to_le_bytes(), // Bus discriminator + Bus { id: 1, rewards: 0 }.to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_bus(&info, 0, true).is_err()); + } + + #[test] + pub fn test_load_bus_not_writeable() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = [ + &(Bus::discriminator() as u64).to_le_bytes(), + Bus { id: 0, rewards: 0 }.to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_bus(&info, 0, true).is_err()); + } + + #[test] + pub fn test_load_any_bus_bad_account_owner() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_any_bus(&info, true).is_err()); + } + + #[test] + pub fn test_load_any_bus_bad_key() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_any_bus(&info, true).is_err()); + } + + #[test] + pub fn test_load_any_bus_empty_data() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_any_bus(&info, true).is_err()); + } + + #[test] + pub fn test_load_any_bus_bad_data() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = [ + &(Treasury::discriminator() as u64).to_le_bytes(), // Treasury discriminator + Bus { id: 0, rewards: 0 }.to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_any_bus(&info, true).is_err()); + } + + #[test] + pub fn test_load_any_bus_bad_id() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = [ + &(Bus::discriminator() as u64).to_le_bytes(), + Bus { + id: (BUS_COUNT + 1) as u64, + rewards: 0, + } + .to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_any_bus(&info, true).is_err()); + } + + #[test] + pub fn test_load_any_bus_mismatch_id() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = [ + &(Bus::discriminator() as u64).to_le_bytes(), + Bus { + id: 1 as u64, + rewards: 0, + } + .to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_any_bus(&info, true).is_err()); + } + + #[test] + pub fn test_load_any_bus_not_writeable() { + let key = BUS_ADDRESSES[0]; + let mut lamports = 1_000_000_000; + let mut data = [ + &(Bus::discriminator() as u64).to_le_bytes(), + Bus { id: 0, rewards: 0 }.to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_any_bus(&info, true).is_err()); + } + + #[test] + pub fn test_load_proof_bad_account_owner() { + let authority = Pubkey::new_unique(); + let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id()); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &pda.0, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_proof(&info, &authority, true).is_err()); + } + + #[test] + pub fn test_load_proof_bad_key() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_proof(&info, &Pubkey::new_unique(), true).is_err()); + } + + #[test] + pub fn test_load_proof_empty_data() { + let authority = Pubkey::new_unique(); + let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id()); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = crate::id(); + let info = AccountInfo::new( + &pda.0, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_proof(&info, &authority, true).is_err()); + } + + #[test] + pub fn test_load_proof_bad_data() { + let authority = Pubkey::new_unique(); + let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id()); + let mut lamports = 1_000_000_000; + let mut data = [ + &(Bus::discriminator() as u64).to_le_bytes(), // Bus discriminator + Proof { + authority, + claimable_rewards: 0, + hash: KeccakHash::new_from_array([u8::MAX; 32]).into(), + total_hashes: 0, + total_rewards: 0, + } + .to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &pda.0, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_proof(&info, &authority, true).is_err()); + } + + #[test] + pub fn test_load_proof_not_writeable() { + let authority = Pubkey::new_unique(); + let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id()); + let mut lamports = 1_000_000_000; + let mut data = [ + &(Proof::discriminator() as u64).to_le_bytes(), + Proof { + authority, + claimable_rewards: 0, + hash: KeccakHash::new_from_array([u8::MAX; 32]).into(), + total_hashes: 0, + total_rewards: 0, + } + .to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &pda.0, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_proof(&info, &authority, true).is_err()); + } + + #[test] + pub fn test_load_treasury_bad_account_owner() { + let pda = Pubkey::find_program_address(&[TREASURY], &crate::id()); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &pda.0, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_treasury(&info, true).is_err()); + } + + #[test] + pub fn test_load_treasury_bad_key() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_treasury(&info, true).is_err()); + } + + #[test] + pub fn test_load_treasury_empty_data() { + let key = TREASURY_ADDRESS; + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = crate::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_treasury(&info, true).is_err()); + } + + #[test] + pub fn test_load_treasury_bad_data() { + let pda = Pubkey::find_program_address(&[TREASURY], &crate::id()); + let mut lamports = 1_000_000_000; + let mut data = [ + &(Bus::discriminator() as u64).to_le_bytes(), // Bus discriminator + Treasury { + bump: pda.1 as u64, + admin: Pubkey::new_unique(), + difficulty: KeccakHash::new_from_array([u8::MAX; 32]).into(), + last_reset_at: 0, + reward_rate: 100, + total_claimed_rewards: 0, + } + .to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &pda.0, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_treasury(&info, true).is_err()); + } + + #[test] + pub fn test_load_treasury_not_writeable() { + let pda = Pubkey::find_program_address(&[TREASURY], &crate::id()); + let mut lamports = 1_000_000_000; + let mut data = [ + &(Treasury::discriminator() as u64).to_le_bytes(), + Treasury { + bump: pda.1 as u64, + admin: Pubkey::new_unique(), + difficulty: KeccakHash::new_from_array([u8::MAX; 32]).into(), + last_reset_at: 0, + reward_rate: 100, + total_claimed_rewards: 0, + } + .to_bytes(), + ] + .concat(); + let owner = crate::id(); + let info = AccountInfo::new( + &pda.0, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_treasury(&info, true).is_err()); + } + + #[test] + pub fn test_load_mint_bad_account_owner() { + let key = MINT_ADDRESS; + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err()); + } + + #[test] + pub fn test_load_mint_bad_key() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = spl_token::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_mint(&info, true).is_err()); + } + + #[test] + pub fn test_load_mint_empty_data() { + let key = MINT_ADDRESS; + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = spl_token::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_mint(&info, true).is_err()); + } + + #[test] + pub fn test_load_mint_bad_data() { + let key = MINT_ADDRESS; + let mut lamports = 1_000_000_000; + let mut data = [1]; + let owner = spl_token::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_mint(&info, true).is_err()); + } + + #[test] + pub fn test_load_mint_not_writeable() { + let mut data: [u8; Mint::LEN] = [0; Mint::LEN]; + Mint { + mint_authority: COption::Some(TREASURY_ADDRESS), + supply: 0, + decimals: TOKEN_DECIMALS, + is_initialized: true, + freeze_authority: COption::None, + } + .pack_into_slice(&mut data); + let key = MINT_ADDRESS; + let mut lamports = 1_000_000_000; + let owner = spl_token::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_mint(&info, true).is_err()); + } + + #[test] + pub fn test_load_token_account_bad_account_owner() { + let mut data: [u8; spl_token::state::Account::LEN] = [0; spl_token::state::Account::LEN]; + spl_token::state::Account { + mint: MINT_ADDRESS, + owner: TREASURY_ADDRESS, + amount: 2_000_000_000, + delegate: COption::None, + state: AccountState::Initialized, + is_native: COption::None, + delegated_amount: 0, + close_authority: COption::None, + } + .pack_into_slice(&mut data); + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err()); + } + + #[test] + pub fn test_load_token_account_empty_data() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = spl_token::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err()); + } + + #[test] + pub fn test_load_token_account_bad_data() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = [1]; + let owner = spl_token::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err()); + } + + #[test] + pub fn test_load_token_account_bad_owner_mint() { + let mut data: [u8; spl_token::state::Account::LEN] = [0; spl_token::state::Account::LEN]; + spl_token::state::Account { + mint: MINT_ADDRESS, + owner: TREASURY_ADDRESS, + amount: 2_000_000_000, + delegate: COption::None, + state: AccountState::Initialized, + is_native: COption::None, + delegated_amount: 0, + close_authority: COption::None, + } + .pack_into_slice(&mut data); + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let owner = spl_token::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_token_account(&info, Some(&key), &MINT_ADDRESS, false).is_err()); + assert!(load_token_account(&info, None, &Pubkey::new_unique(), false).is_err()); + assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err()); + } + + #[test] + pub fn test_load_uninitialized_pda_bad_key_bump() { + let pda = Pubkey::find_program_address(&[TREASURY], &crate::id()); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &pda.0, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_uninitialized_pda(&info, &[BUS], pda.1, &crate::id()).is_err()); + assert!(load_uninitialized_pda(&info, &[TREASURY], 0, &crate::id()).is_err()); + } + + #[test] + pub fn test_load_uninitialized_account_bad_owner() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = spl_token::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_uninitialized_account(&info).is_err()); + } + + #[test] + pub fn test_load_uninitialized_account_data_not_empty() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = [0]; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + true, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_uninitialized_account(&info).is_err()); + } + + #[test] + pub fn test_load_uninitialized_account_not_writeable() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_uninitialized_account(&info).is_err()); + } + + #[test] + pub fn test_load_sysvar_bad_owner() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_sysvar(&info, key).is_err()); + } + + #[test] + pub fn test_load_account_bad_key() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_account(&info, Pubkey::new_unique(), false).is_err()); + } + + #[test] + pub fn test_load_account_not_writeable() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_account(&info, key, true).is_err()); + } + + #[test] + pub fn test_load_program_bad_key() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + true, + 0, + ); + assert!(load_program(&info, Pubkey::new_unique()).is_err()); + } + + #[test] + pub fn test_load_program_not_executable() { + let key = Pubkey::new_unique(); + let mut lamports = 1_000_000_000; + let mut data = []; + let owner = system_program::id(); + let info = AccountInfo::new( + &key, + false, + false, + &mut lamports, + &mut data, + &owner, + false, + 0, + ); + assert!(load_program(&info, key).is_err()); + } +} diff --git a/tests/test_initialize.rs b/tests/test_initialize.rs index e65b706..66afdd9 100644 --- a/tests/test_initialize.rs +++ b/tests/test_initialize.rs @@ -3,12 +3,10 @@ use mpl_token_metadata::{ types::{Key, TokenStandard}, }; use ore::{ - instruction::{InitializeArgs, OreInstruction}, state::{Bus, Treasury}, utils::AccountDeserialize, - BUS, BUS_ADDRESSES, BUS_COUNT, INITIAL_DIFFICULTY, INITIAL_REWARD_RATE, METADATA, - METADATA_ADDRESS, METADATA_NAME, METADATA_SYMBOL, METADATA_URI, MINT, MINT_ADDRESS, MINT_NOISE, - TREASURY, + BUS_ADDRESSES, BUS_COUNT, INITIAL_DIFFICULTY, INITIAL_REWARD_RATE, METADATA_ADDRESS, + METADATA_NAME, METADATA_SYMBOL, METADATA_URI, MINT_ADDRESS, TREASURY, }; use solana_program::{ hash::Hash, program_option::COption, program_pack::Pack, pubkey::Pubkey, rent::Rent, @@ -119,136 +117,36 @@ async fn test_initialize_not_enough_accounts() { } #[tokio::test] -async fn test_initialize_bad_pda() { +async fn test_initialize_bad_key() { // Setup let (mut banks, payer, blockhash) = setup_program_test_env().await; - // Pdas - let bus_pdas = [ - Pubkey::find_program_address(&[BUS, &[0]], &ore::id()), - Pubkey::find_program_address(&[BUS, &[1]], &ore::id()), - Pubkey::find_program_address(&[BUS, &[2]], &ore::id()), - Pubkey::find_program_address(&[BUS, &[3]], &ore::id()), - Pubkey::find_program_address(&[BUS, &[4]], &ore::id()), - Pubkey::find_program_address(&[BUS, &[5]], &ore::id()), - Pubkey::find_program_address(&[BUS, &[6]], &ore::id()), - Pubkey::find_program_address(&[BUS, &[7]], &ore::id()), - ]; - let mint_pda = Pubkey::find_program_address(&[MINT, MINT_NOISE.as_slice()], &ore::id()); - let treasury_pda = Pubkey::find_program_address(&[TREASURY], &ore::id()); - let metadata_pda = Pubkey::find_program_address( - &[ - METADATA, - mpl_token_metadata::ID.as_ref(), - mint_pda.0.as_ref(), - ], - &mpl_token_metadata::ID, - ); + // Bad addresses let bad_pda = Pubkey::find_program_address(&[b"t"], &ore::id()); + for i in 1..12 { + let mut ix = ore::instruction::initialize(payer.pubkey()); + ix.accounts[i].pubkey = bad_pda.0; + let tx = + Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash); + let res = banks.process_transaction(tx).await; + assert!(res.is_err()); + } +} - // Bad bus pda - let mut ix = ore::instruction::initialize(payer.pubkey()); - ix.accounts[1].pubkey = bad_pda.0; - ix.data = [ - OreInstruction::Initialize.to_vec(), - InitializeArgs { - bus_0_bump: bad_pda.1, - bus_1_bump: bus_pdas[1].1, - bus_2_bump: bus_pdas[2].1, - bus_3_bump: bus_pdas[3].1, - bus_4_bump: bus_pdas[4].1, - bus_5_bump: bus_pdas[5].1, - bus_6_bump: bus_pdas[6].1, - bus_7_bump: bus_pdas[7].1, - metadata_bump: metadata_pda.1, - mint_bump: mint_pda.1, - treasury_bump: treasury_pda.1, - } - .to_bytes() - .to_vec(), - ] - .concat(); - let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash); - let res = banks.process_transaction(tx).await; - assert!(res.is_err()); +#[tokio::test] +async fn test_initialize_bad_programs() { + // Setup + let (mut banks, payer, blockhash) = setup_program_test_env().await; - // Bad metadata pda - let mut ix = ore::instruction::initialize(payer.pubkey()); - ix.accounts[9].pubkey = bad_pda.0; - ix.data = [ - OreInstruction::Initialize.to_vec(), - InitializeArgs { - bus_0_bump: bus_pdas[0].1, - bus_1_bump: bus_pdas[1].1, - bus_2_bump: bus_pdas[2].1, - bus_3_bump: bus_pdas[3].1, - bus_4_bump: bus_pdas[4].1, - bus_5_bump: bus_pdas[5].1, - bus_6_bump: bus_pdas[6].1, - bus_7_bump: bus_pdas[7].1, - metadata_bump: bad_pda.1, - mint_bump: mint_pda.1, - treasury_bump: treasury_pda.1, - } - .to_bytes() - .to_vec(), - ] - .concat(); - let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash); - let res = banks.process_transaction(tx).await; - assert!(res.is_err()); - - // Bad mint pda - let mut ix = ore::instruction::initialize(payer.pubkey()); - ix.accounts[10].pubkey = bad_pda.0; - ix.data = [ - OreInstruction::Initialize.to_vec(), - InitializeArgs { - bus_0_bump: bus_pdas[0].1, - bus_1_bump: bus_pdas[1].1, - bus_2_bump: bus_pdas[2].1, - bus_3_bump: bus_pdas[3].1, - bus_4_bump: bus_pdas[4].1, - bus_5_bump: bus_pdas[5].1, - bus_6_bump: bus_pdas[6].1, - bus_7_bump: bus_pdas[7].1, - metadata_bump: metadata_pda.1, - mint_bump: bad_pda.1, - treasury_bump: treasury_pda.1, - } - .to_bytes() - .to_vec(), - ] - .concat(); - let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash); - let res = banks.process_transaction(tx).await; - assert!(res.is_err()); - - // Bad treasury pda - let mut ix = ore::instruction::initialize(payer.pubkey()); - ix.accounts[11].pubkey = bad_pda.0; - ix.data = [ - OreInstruction::Initialize.to_vec(), - InitializeArgs { - bus_0_bump: bus_pdas[0].1, - bus_1_bump: bus_pdas[1].1, - bus_2_bump: bus_pdas[2].1, - bus_3_bump: bus_pdas[3].1, - bus_4_bump: bus_pdas[4].1, - bus_5_bump: bus_pdas[5].1, - bus_6_bump: bus_pdas[6].1, - bus_7_bump: bus_pdas[7].1, - metadata_bump: metadata_pda.1, - mint_bump: mint_pda.1, - treasury_bump: bad_pda.1, - } - .to_bytes() - .to_vec(), - ] - .concat(); - let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash); - let res = banks.process_transaction(tx).await; - assert!(res.is_err()); + // Bad addresses + for i in 13..18 { + let mut ix = ore::instruction::initialize(payer.pubkey()); + ix.accounts[i].pubkey = Pubkey::new_unique(); + let tx = + Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash); + let res = banks.process_transaction(tx).await; + assert!(res.is_err()); + } } async fn setup_program_test_env() -> (BanksClient, Keypair, Hash) { diff --git a/tests/test_reset.rs b/tests/test_reset.rs index 43fb4bd..e0355c2 100644 --- a/tests/test_reset.rs +++ b/tests/test_reset.rs @@ -105,6 +105,23 @@ async fn test_reset() { assert_eq!(treasury_tokens.close_authority, COption::None); } +#[tokio::test] +async fn test_reset_bad_key() { + // Setup + let (mut banks, payer, _, blockhash) = setup_program_test_env(ClockState::Normal).await; + + // Bad addresses + let bad_pda = Pubkey::find_program_address(&[b"t"], &ore::id()); + for i in 1..13 { + let mut ix = ore::instruction::reset(payer.pubkey()); + ix.accounts[i].pubkey = bad_pda.0; + let tx = + Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash); + let res = banks.process_transaction(tx).await; + assert!(res.is_err()); + } +} + #[tokio::test] async fn test_reset_busses_out_of_order_fail() { // Setup