//! Program state processor use { crate::{ extension::{ confidential_mint_burn, confidential_transfer, confidential_transfer_fee, cpi_guard::{self, in_cpi}, default_account_state, group_member_pointer, group_pointer, interest_bearing_mint, memo_transfer::{self, check_previous_sibling_instruction_is_memo}, metadata_pointer, pausable, permissioned_burn, reallocate, scaled_ui_amount, token_group, token_metadata, transfer_fee, transfer_hook, }, pod_instruction::{ decode_instruction_data_with_coption_pubkey, decode_instruction_data_with_coption_u64, AmountCheckedData, AmountData, InitializeMintData, InitializeMultisigData, PodTokenInstruction, SetAuthorityData, }, }, pinocchio::{ account::next_account_view, cpi::{Seed, Signer}, sysvars::{clock::Clock, rent::Rent, Sysvar}, AccountView, }, pinocchio_system::instructions::{CreateAccountAllowPrefund, Funding}, pinocchio_transfer_hook_interface::instructions::Execute, solana_address::Address, solana_cpi::set_return_data, solana_msg::msg, solana_program_error::{ProgramError, ProgramResult}, solana_program_pack::Pack, solana_zero_copy::unaligned::U64, spl_token_2022_interface::{ check_program_account, error::TokenError, extension::{ account_len::{ try_calculate_account_len_from_mint_data, try_for_each_required_init_account_extension, }, confidential_mint_burn::ConfidentialMintBurn, confidential_transfer::{ConfidentialTransferAccount, ConfidentialTransferMint}, confidential_transfer_fee::{ ConfidentialTransferFeeAmount, ConfidentialTransferFeeConfig, }, cpi_guard::CpiGuard, default_account_state::DefaultAccountState, group_member_pointer::GroupMemberPointer, group_pointer::GroupPointer, immutable_owner::ImmutableOwner, interest_bearing_mint::InterestBearingConfig, memo_transfer::memo_required, metadata_pointer::MetadataPointer, mint_close_authority::MintCloseAuthority, non_transferable::{NonTransferable, NonTransferableAccount}, pausable::{PausableAccount, PausableConfig}, permanent_delegate::{get_permanent_delegate, PermanentDelegate}, permissioned_burn::PermissionedBurnConfig, scaled_ui_amount::ScaledUiAmountConfig, transfer_fee::{TransferFeeAmount, TransferFeeConfig}, transfer_hook::{TransferHook, TransferHookAccount}, BaseStateWithExtensions, BaseStateWithExtensionsMut, ExtensionType, PodStateWithExtensions, PodStateWithExtensionsMut, }, inline_spl_token, instruction::{ decode_instruction_data, decode_instruction_type, is_valid_signer_index, AuthorityType, MAX_SIGNERS, }, native_mint::{self, PROGRAM_ADDRESS_SEEDS}, pod::{PodAccount, PodCOption, PodMint, PodMultisig}, state::{AccountState, Mint, PackedSizeOf}, }, spl_token_group_interface::instruction::TokenGroupInstruction, spl_token_metadata_interface::instruction::TokenMetadataInstruction, std::convert::{TryFrom, TryInto}, }; pub(crate) enum TransferInstruction { Unchecked, Checked { decimals: u8 }, CheckedWithFee { decimals: u8, fee: u64 }, } pub(crate) enum InstructionVariant { Unchecked, Checked { decimals: u8 }, } /// Burn instruction variant. Standard variants must not be used with the /// permissioned burn extension. /// /// Permissioned variants require the extra authority to sign. pub(crate) enum BurnInstructionVariant { Standard, Permissioned, } /// Program state handler. pub struct Processor {} impl Processor { fn _process_initialize_mint( accounts: &mut [AccountView], decimals: u8, mint_authority: &Address, freeze_authority: PodCOption
, rent_sysvar_account: bool, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let mint_info = next_account_view(account_info_iter)?; let mint_data_len = mint_info.data_len(); // Note: Storing the value of the owner so borrow checker doesn't complain about // multiple borrows of `mint_info`. let mint_owner = *mint_info.owner(); let mint_lamports = mint_info.lamports(); let mut mint_data = mint_info.try_borrow_mut()?; check_program_account(&mint_owner)?; let rent = if rent_sysvar_account { Rent::from_account_view(next_account_view(account_info_iter)?)? } else { Rent::get()? }; if !rent.is_exempt(mint_lamports, mint_data_len) { return Err(TokenError::NotRentExempt.into()); } let mut mint = PodStateWithExtensionsMut::::unpack_uninitialized(&mut mint_data)?; let extension_types = mint.get_extension_types()?; if ExtensionType::try_calculate_account_len::(&extension_types)? != mint_data_len { return Err(ProgramError::InvalidAccountData); } ExtensionType::check_for_invalid_mint_extension_combinations(&extension_types)?; if let Ok(default_account_state) = mint.get_extension_mut::() { let default_account_state = AccountState::try_from(default_account_state.state) .or(Err(ProgramError::InvalidAccountData))?; if default_account_state == AccountState::Frozen && freeze_authority.is_none() { return Err(TokenError::MintCannotFreeze.into()); } } mint.base.mint_authority = PodCOption::some(*mint_authority); mint.base.decimals = decimals; mint.base.is_initialized = true.into(); mint.base.freeze_authority = freeze_authority; mint.init_account_type()?; Ok(()) } /// Processes an [`InitializeMint`](enum.TokenInstruction.html) instruction. pub fn process_initialize_mint( accounts: &mut [AccountView], decimals: u8, mint_authority: &Address, freeze_authority: PodCOption
, ) -> ProgramResult { Self::_process_initialize_mint(accounts, decimals, mint_authority, freeze_authority, true) } /// Processes an [`InitializeMint2`](enum.TokenInstruction.html) /// instruction. pub fn process_initialize_mint2( accounts: &mut [AccountView], decimals: u8, mint_authority: &Address, freeze_authority: PodCOption
, ) -> ProgramResult { Self::_process_initialize_mint(accounts, decimals, mint_authority, freeze_authority, false) } fn _process_initialize_account( accounts: &mut [AccountView], owner: Option<&Address>, rent_sysvar_account: bool, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let new_account_info = next_account_view(account_info_iter)?; let mint_info = next_account_view(account_info_iter)?; check_program_account(new_account_info.owner())?; check_program_account(mint_info.owner())?; let owner = if let Some(owner) = owner { owner } else { next_account_view(account_info_iter)?.address() }; let new_account_info_data_len = new_account_info.data_len(); let rent = if rent_sysvar_account { Rent::from_account_view(next_account_view(account_info_iter)?)? } else { Rent::get()? }; // Note: Storing the lamports value so borrow checker doesn't complain about // multiple borrows of `new_account_info`. let new_account_lamports = new_account_info.lamports(); let mut account_data = new_account_info.try_borrow_mut()?; // unpack_uninitialized checks account.base.is_initialized() under the hood let mut account = PodStateWithExtensionsMut::::unpack_uninitialized(&mut account_data)?; if !rent.is_exempt(new_account_lamports, new_account_info_data_len) { return Err(TokenError::NotRentExempt.into()); } let mint_data = mint_info.try_borrow()?; let mint = PodStateWithExtensions::::unpack(&mint_data) .map_err(|_| Into::::into(TokenError::InvalidMint))?; if mint .get_extension::() .map(|e| Option::
::from(e.delegate).is_some()) .unwrap_or(false) { msg!("Warning: Mint has a permanent delegate, so tokens in this account may be seized at any time"); } check_program_account(mint_info.owner())?; // Sizing walks every TLV entry, which also validates the extension data. It is only a // lower bound since it skips extensions already initialized on the account (e.g. // `ImmutableOwner`), but each init call below still verifies the space for its own write. // Passing the initialized types as `additional_account_extensions` would make it exact. let required_account_len = try_calculate_account_len_from_mint_data(&mint_data, &[])?; if required_account_len > new_account_info_data_len { return Err(ProgramError::InvalidAccountData); } try_for_each_required_init_account_extension(mint.get_tlv_data(), |extension_type| { account.init_account_extension_from_type(extension_type) })?; let starting_state = if let Ok(default_account_state) = mint.get_extension::() { AccountState::try_from(default_account_state.state) .or(Err(ProgramError::InvalidAccountData))? } else { AccountState::Initialized }; account.base.mint = *mint_info.address(); account.base.owner = *owner; account.base.close_authority = PodCOption::none(); account.base.delegate = PodCOption::none(); account.base.delegated_amount = 0.into(); account.base.state = starting_state.into(); if mint_info.address() == &native_mint::id() { let rent_exempt_reserve = rent.try_minimum_balance(new_account_info_data_len)?; account.base.is_native = PodCOption::some(rent_exempt_reserve.into()); account.base.amount = new_account_lamports .checked_sub(rent_exempt_reserve) .ok_or(TokenError::Overflow)? .into(); } else { account.base.is_native = PodCOption::none(); account.base.amount = 0.into(); }; account.init_account_type()?; Ok(()) } /// Processes an [`InitializeAccount`](enum.TokenInstruction.html) /// instruction. pub fn process_initialize_account(accounts: &mut [AccountView]) -> ProgramResult { Self::_process_initialize_account(accounts, None, true) } /// Processes an [`InitializeAccount2`](enum.TokenInstruction.html) /// instruction. pub fn process_initialize_account2( accounts: &mut [AccountView], owner: &Address, ) -> ProgramResult { Self::_process_initialize_account(accounts, Some(owner), true) } /// Processes an [`InitializeAccount3`](enum.TokenInstruction.html) /// instruction. pub fn process_initialize_account3( accounts: &mut [AccountView], owner: &Address, ) -> ProgramResult { Self::_process_initialize_account(accounts, Some(owner), false) } fn _process_initialize_multisig( accounts: &mut [AccountView], m: u8, rent_sysvar_account: bool, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let multisig_info = next_account_view(account_info_iter)?; check_program_account(multisig_info.owner())?; let multisig_info_data_len = multisig_info.data_len(); let rent = if rent_sysvar_account { Rent::from_account_view(next_account_view(account_info_iter)?)? } else { Rent::get()? }; // Note: Storing the lamports value so borrow checker doesn't complain about // borrowing `multisig_info` multiple times. let multisig_lamports = multisig_info.lamports(); let mut multisig_data = multisig_info.try_borrow_mut()?; let multisig = bytemuck::try_from_bytes_mut::(&mut multisig_data) .map_err(|_| ProgramError::InvalidArgument)?; if bool::from(multisig.is_initialized) { return Err(TokenError::AlreadyInUse.into()); } if !rent.is_exempt(multisig_lamports, multisig_info_data_len) { return Err(TokenError::NotRentExempt.into()); } let signer_infos = account_info_iter.as_slice(); multisig.m = m; multisig.n = signer_infos.len() as u8; if !is_valid_signer_index(multisig.n as usize) { return Err(TokenError::InvalidNumberOfProvidedSigners.into()); } if !is_valid_signer_index(multisig.m as usize) { return Err(TokenError::InvalidNumberOfRequiredSigners.into()); } for (i, signer_info) in signer_infos.iter().enumerate() { multisig.signers[i] = *signer_info.address(); } multisig.is_initialized = true.into(); Ok(()) } /// Processes a [`InitializeMultisig`](enum.TokenInstruction.html) /// instruction. pub fn process_initialize_multisig(accounts: &mut [AccountView], m: u8) -> ProgramResult { Self::_process_initialize_multisig(accounts, m, true) } /// Processes a [`InitializeMultisig2`](enum.TokenInstruction.html) /// instruction. pub fn process_initialize_multisig2(accounts: &mut [AccountView], m: u8) -> ProgramResult { Self::_process_initialize_multisig(accounts, m, false) } /// Processes a [`Transfer`](enum.TokenInstruction.html) instruction. pub(crate) fn process_transfer( program_id: &Address, accounts: &mut [AccountView], amount: u64, transfer_instruction: TransferInstruction, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let source_account_info = next_account_view(account_info_iter)?; let expected_mint_info = match transfer_instruction { TransferInstruction::Unchecked => None, TransferInstruction::Checked { decimals } | TransferInstruction::CheckedWithFee { decimals, .. } => { Some((next_account_view(account_info_iter)?, decimals)) } }; let destination_account_info = next_account_view(account_info_iter)?; let authority_info = next_account_view(account_info_iter)?; let authority_info_data_len = authority_info.data_len(); check_program_account(source_account_info.owner())?; check_program_account(destination_account_info.owner())?; // Note: Make a copy of the source account to borrow the data so we can use the account // info again without violating the borrow checker. The account data is not re-borrowed on // the processor. let mut cloned_source_account_info = *source_account_info; let mut source_account_data = cloned_source_account_info.try_borrow_mut()?; let mut source_account = PodStateWithExtensionsMut::::unpack(&mut source_account_data)?; if source_account.base.is_frozen() { return Err(TokenError::AccountFrozen.into()); } let source_amount = u64::from(source_account.base.amount); if source_amount < amount { return Err(TokenError::InsufficientFunds.into()); } if source_account .get_extension::() .is_ok() { return Err(TokenError::NonTransferable.into()); } let (calculated_fee, maybe_permanent_delegate, maybe_transfer_hook_program_id) = if let Some((ref mint_info, expected_decimals)) = expected_mint_info { check_program_account(mint_info.owner())?; if &source_account.base.mint != mint_info.address() { return Err(TokenError::MintMismatch.into()); } let mint_data = mint_info.try_borrow()?; let mint = PodStateWithExtensions::::unpack(&mint_data)?; if expected_decimals != mint.base.decimals { return Err(TokenError::MintDecimalsMismatch.into()); } let fee = if let Ok(transfer_fee_config) = mint.get_extension::() { transfer_fee_config .calculate_epoch_fee(Clock::get()?.epoch, amount) .ok_or(TokenError::Overflow)? } else { 0 }; if let Ok(extension) = mint.get_extension::() { if extension.paused.into() { return Err(TokenError::MintPaused.into()); } } let maybe_permanent_delegate = get_permanent_delegate(&mint); let maybe_transfer_hook_program_id = transfer_hook::get_program_id(&mint); ( fee, maybe_permanent_delegate, maybe_transfer_hook_program_id, ) } else { // Transfer hook extension exists on the account, but no mint // was provided to figure out required accounts, abort if source_account .get_extension::() .is_ok() { return Err(TokenError::MintRequiredForTransfer.into()); } // Transfer fee amount extension exists on the account, but no mint // was provided to calculate the fee, abort if source_account .get_extension_mut::() .is_ok() { return Err(TokenError::MintRequiredForTransfer.into()); } // Pausable extension exists on the account, but no mint // was provided to see if it's paused, abort if source_account.get_extension::().is_ok() { return Err(TokenError::MintRequiredForTransfer.into()); } (0, None, None) }; if let TransferInstruction::CheckedWithFee { fee, .. } = transfer_instruction { if calculated_fee != fee { msg!("Calculated fee {calculated_fee}, received {fee}"); return Err(TokenError::FeeMismatch.into()); } } let self_transfer = source_account_info.address() == destination_account_info.address(); if let Ok(cpi_guard) = source_account.get_extension::() { // Blocks all cases where the authority has signed if CPI Guard is // enabled, including: // * the account is delegated to the owner // * the account owner is the permanent delegate if *authority_info.address() == source_account.base.owner && cpi_guard.lock_cpi.into() && in_cpi() { return Err(TokenError::CpiGuardTransferBlocked.into()); } } match (source_account.base.delegate, maybe_permanent_delegate) { (_, Some(ref delegate)) if authority_info.address() == delegate => { Self::validate_owner( program_id, delegate, authority_info, authority_info_data_len, account_info_iter.as_slice(), )? } ( PodCOption { option: PodCOption::
::SOME, value: delegate, }, _, ) if authority_info.address() == &delegate => { Self::validate_owner( program_id, &delegate, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; let delegated_amount = u64::from(source_account.base.delegated_amount); if delegated_amount < amount { return Err(TokenError::InsufficientFunds.into()); } if !self_transfer { source_account.base.delegated_amount = delegated_amount .checked_sub(amount) .ok_or(TokenError::Overflow)? .into(); if u64::from(source_account.base.delegated_amount) == 0 { source_account.base.delegate = PodCOption::none(); } } } _ => { Self::validate_owner( program_id, &source_account.base.owner, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; } } // This check MUST occur just before the amounts are manipulated // to ensure self-transfers are fully validated if self_transfer { if memo_required(&source_account) { check_previous_sibling_instruction_is_memo()?; } return Ok(()); } // Note: Make a copy of the destination account to borrow the data so we can use the account // info again without violating the borrow checker. The account data is not re-borrowed on // the processor. let mut cloned_destination_account_info = *destination_account_info; // self-transfer was dealt with earlier, so this *should* be safe let mut destination_account_data = cloned_destination_account_info.try_borrow_mut()?; let mut destination_account = PodStateWithExtensionsMut::::unpack(&mut destination_account_data)?; if destination_account.base.is_frozen() { return Err(TokenError::AccountFrozen.into()); } if source_account.base.mint != destination_account.base.mint { return Err(TokenError::MintMismatch.into()); } if memo_required(&destination_account) { check_previous_sibling_instruction_is_memo()?; } if let Ok(confidential_transfer_state) = destination_account.get_extension::() { confidential_transfer_state.non_confidential_transfer_allowed()? } source_account.base.amount = source_amount .checked_sub(amount) .ok_or(TokenError::Overflow)? .into(); let credited_amount = amount .checked_sub(calculated_fee) .ok_or(TokenError::Overflow)?; destination_account.base.amount = u64::from(destination_account.base.amount) .checked_add(credited_amount) .ok_or(TokenError::Overflow)? .into(); if calculated_fee > 0 { if let Ok(extension) = destination_account.get_extension_mut::() { let new_withheld_amount = u64::from(extension.withheld_amount) .checked_add(calculated_fee) .ok_or(TokenError::Overflow)?; extension.withheld_amount = new_withheld_amount.into(); } else { // Use the generic error since this should never happen. If there's // a fee, then the mint has a fee configured, which means all accounts // must have the withholding. return Err(TokenError::InvalidState.into()); } } if source_account.base.is_native() { let source_starting_lamports = source_account_info.lamports(); source_account_info.set_lamports( source_starting_lamports .checked_sub(amount) .ok_or(TokenError::Overflow)?, ); let destination_starting_lamports = destination_account_info.lamports(); destination_account_info.set_lamports( destination_starting_lamports .checked_add(amount) .ok_or(TokenError::Overflow)?, ); } if let Some(program_id) = maybe_transfer_hook_program_id { if let Some((mint_info, _)) = expected_mint_info { // set transferring flags transfer_hook::set_transferring(&mut source_account)?; transfer_hook::set_transferring(&mut destination_account)?; // must drop these to avoid the double-borrow during CPI drop(source_account_data); drop(destination_account_data); Execute { program_id: &program_id, source: source_account_info, mint: mint_info, destination: destination_account_info, authority: authority_info, additional_accounts: account_info_iter.as_slice(), amount, } .invoke()?; // unset transferring flag crate::extension::unset_transferring(source_account_info)?; crate::extension::unset_transferring(destination_account_info)?; } else { return Err(TokenError::MintRequiredForTransfer.into()); } } Ok(()) } /// Processes an [`Approve`](enum.TokenInstruction.html) instruction. pub(crate) fn process_approve( program_id: &Address, accounts: &mut [AccountView], amount: u64, instruction_variant: InstructionVariant, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let source_account_info = next_account_view(account_info_iter)?; check_program_account(source_account_info.owner())?; let expected_mint_info = if let InstructionVariant::Checked { decimals } = instruction_variant { Some((next_account_view(account_info_iter)?, decimals)) } else { None }; let delegate_info = next_account_view(account_info_iter)?; let owner_info = next_account_view(account_info_iter)?; let owner_info_data_len = owner_info.data_len(); let mut source_account_data = source_account_info.try_borrow_mut()?; let source_account = PodStateWithExtensionsMut::::unpack(&mut source_account_data)?; if source_account.base.is_frozen() { return Err(TokenError::AccountFrozen.into()); } if let Some((mint_info, expected_decimals)) = expected_mint_info { check_program_account(mint_info.owner())?; if &source_account.base.mint != mint_info.address() { return Err(TokenError::MintMismatch.into()); } let mint_data = mint_info.try_borrow()?; let mint = PodStateWithExtensions::::unpack(&mint_data)?; if expected_decimals != mint.base.decimals { return Err(TokenError::MintDecimalsMismatch.into()); } } Self::validate_owner( program_id, &source_account.base.owner, owner_info, owner_info_data_len, account_info_iter.as_slice(), )?; if let Ok(cpi_guard) = source_account.get_extension::() { if cpi_guard.lock_cpi.into() && in_cpi() { return Err(TokenError::CpiGuardApproveBlocked.into()); } } source_account.base.delegate = PodCOption::some(*delegate_info.address()); source_account.base.delegated_amount = amount.into(); Ok(()) } /// Processes an [`Revoke`](enum.TokenInstruction.html) instruction. pub fn process_revoke(program_id: &Address, accounts: &mut [AccountView]) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let source_account_info = next_account_view(account_info_iter)?; let authority_info = next_account_view(account_info_iter)?; let authority_info_data_len = authority_info.data_len(); check_program_account(source_account_info.owner())?; let mut source_account_data = source_account_info.try_borrow_mut()?; let source_account = PodStateWithExtensionsMut::::unpack(&mut source_account_data)?; if source_account.base.is_frozen() { return Err(TokenError::AccountFrozen.into()); } Self::validate_owner( program_id, match &source_account.base.delegate { PodCOption { option: PodCOption::
::SOME, value: delegate, } if authority_info.address() == delegate => delegate, _ => &source_account.base.owner, }, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; source_account.base.delegate = PodCOption::none(); source_account.base.delegated_amount = 0.into(); Ok(()) } /// Processes a [`SetAuthority`](enum.TokenInstruction.html) instruction. pub fn process_set_authority( program_id: &Address, accounts: &mut [AccountView], authority_type: AuthorityType, new_authority: PodCOption
, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let account_info = next_account_view(account_info_iter)?; let authority_info = next_account_view(account_info_iter)?; let authority_info_data_len = authority_info.data_len(); check_program_account(account_info.owner())?; let mut account_data = account_info.try_borrow_mut()?; if let Ok(mut account) = PodStateWithExtensionsMut::::unpack(&mut account_data) { if account.base.is_frozen() { return Err(TokenError::AccountFrozen.into()); } match authority_type { AuthorityType::AccountOwner => { Self::validate_owner( program_id, &account.base.owner, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; if account.get_extension_mut::().is_ok() { return Err(TokenError::ImmutableOwner.into()); } if let Ok(cpi_guard) = account.get_extension::() { if cpi_guard.lock_cpi.into() && in_cpi() { return Err(TokenError::CpiGuardSetAuthorityBlocked.into()); } else if cpi_guard.lock_cpi.into() { return Err(TokenError::CpiGuardOwnerChangeBlocked.into()); } } if let PodCOption { option: PodCOption::
::SOME, value: authority, } = new_authority { account.base.owner = authority; } else { return Err(TokenError::InvalidInstruction.into()); } account.base.delegate = PodCOption::none(); account.base.delegated_amount = 0.into(); if account.base.is_native() { account.base.close_authority = PodCOption::none(); } } AuthorityType::CloseAccount => { let authority = account.base.close_authority.unwrap_or(account.base.owner); Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; if let Ok(cpi_guard) = account.get_extension::() { if cpi_guard.lock_cpi.into() && in_cpi() && new_authority.is_some() { return Err(TokenError::CpiGuardSetAuthorityBlocked.into()); } } account.base.close_authority = new_authority; } _ => { return Err(TokenError::AuthorityTypeNotSupported.into()); } } } else if let Ok(mut mint) = PodStateWithExtensionsMut::::unpack(&mut account_data) { match authority_type { AuthorityType::MintTokens => { // Once a mint's supply is fixed, it cannot be undone by setting a new // mint_authority let mint_authority = mint .base .mint_authority .ok_or(Into::::into(TokenError::FixedSupply))?; Self::validate_owner( program_id, &mint_authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; mint.base.mint_authority = new_authority; } AuthorityType::FreezeAccount => { // Once a mint's freeze authority is disabled, it cannot be re-enabled by // setting a new freeze_authority let freeze_authority = mint .base .freeze_authority .ok_or(Into::::into(TokenError::MintCannotFreeze))?; Self::validate_owner( program_id, &freeze_authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; mint.base.freeze_authority = new_authority; } AuthorityType::CloseMint => { let extension = mint.get_extension_mut::()?; let maybe_close_authority: Option
= extension.close_authority.into(); let close_authority = maybe_close_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &close_authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.close_authority = new_authority.try_into()?; } AuthorityType::TransferFeeConfig => { let extension = mint.get_extension_mut::()?; let maybe_transfer_fee_config_authority: Option
= extension.transfer_fee_config_authority.into(); let transfer_fee_config_authority = maybe_transfer_fee_config_authority .ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &transfer_fee_config_authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.transfer_fee_config_authority = new_authority.try_into()?; } AuthorityType::WithheldWithdraw => { let extension = mint.get_extension_mut::()?; let maybe_withdraw_withheld_authority: Option
= extension.withdraw_withheld_authority.into(); let withdraw_withheld_authority = maybe_withdraw_withheld_authority .ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &withdraw_withheld_authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.withdraw_withheld_authority = new_authority.try_into()?; } AuthorityType::InterestRate => { let extension = mint.get_extension_mut::()?; let maybe_rate_authority: Option
= extension.rate_authority.into(); let rate_authority = maybe_rate_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &rate_authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.rate_authority = new_authority.try_into()?; } AuthorityType::PermanentDelegate => { let extension = mint.get_extension_mut::()?; let maybe_delegate: Option
= extension.delegate.into(); let delegate = maybe_delegate.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &delegate, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.delegate = new_authority.try_into()?; } AuthorityType::ConfidentialTransferMint => { let extension = mint.get_extension_mut::()?; let maybe_confidential_transfer_mint_authority: Option
= extension.authority.into(); let confidential_transfer_mint_authority = maybe_confidential_transfer_mint_authority .ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &confidential_transfer_mint_authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.authority = new_authority.try_into()?; } AuthorityType::TransferHookProgramId => { let extension = mint.get_extension_mut::()?; let maybe_authority: Option
= extension.authority.into(); let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.authority = new_authority.try_into()?; } AuthorityType::ConfidentialTransferFeeConfig => { let extension = mint.get_extension_mut::()?; let maybe_authority: Option
= extension.authority.into(); let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.authority = new_authority.try_into()?; } AuthorityType::MetadataPointer => { let extension = mint.get_extension_mut::()?; let maybe_authority: Option
= extension.authority.into(); let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.authority = new_authority.try_into()?; } AuthorityType::GroupPointer => { let extension = mint.get_extension_mut::()?; let maybe_authority: Option
= extension.authority.into(); let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.authority = new_authority.try_into()?; } AuthorityType::GroupMemberPointer => { let extension = mint.get_extension_mut::()?; let maybe_authority: Option
= extension.authority.into(); let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.authority = new_authority.try_into()?; } AuthorityType::ScaledUiAmount => { let extension = mint.get_extension_mut::()?; let maybe_authority: Option
= extension.authority.into(); let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.authority = new_authority.try_into()?; } AuthorityType::Pause => { let extension = mint.get_extension_mut::()?; let maybe_authority: Option
= extension.authority.into(); let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.authority = new_authority.try_into()?; } AuthorityType::PermissionedBurn => { let extension = mint.get_extension_mut::()?; let maybe_authority: Option
= extension.authority.into(); let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; extension.authority = new_authority.try_into()?; } _ => { return Err(TokenError::AuthorityTypeNotSupported.into()); } } } else { return Err(ProgramError::InvalidAccountData); } Ok(()) } /// Processes a [`MintTo`](enum.TokenInstruction.html) instruction. pub(crate) fn process_mint_to( program_id: &Address, accounts: &mut [AccountView], amount: u64, instruction_variant: InstructionVariant, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let mint_info = next_account_view(account_info_iter)?; let destination_account_info = next_account_view(account_info_iter)?; let owner_info = next_account_view(account_info_iter)?; let owner_info_data_len = owner_info.data_len(); check_program_account(mint_info.owner())?; check_program_account(destination_account_info.owner())?; let mut destination_account_data = destination_account_info.try_borrow_mut()?; let destination_account = PodStateWithExtensionsMut::::unpack(&mut destination_account_data)?; if destination_account.base.is_frozen() { return Err(TokenError::AccountFrozen.into()); } if destination_account.base.is_native() { return Err(TokenError::NativeNotSupported.into()); } if mint_info.address() != &destination_account.base.mint { return Err(TokenError::MintMismatch.into()); } let mut mint_data = mint_info.try_borrow_mut()?; let mint = PodStateWithExtensionsMut::::unpack(&mut mint_data)?; // If the mint if non-transferable, only allow minting to accounts // with immutable ownership and the non-transferable extension. if mint.get_extension::().is_ok() && (destination_account .get_extension::() .is_err() || destination_account .get_extension::() .is_err()) { // This error name isn't totally correct since we also require the // non-transferable account extension, but that case only happens in // the case of a mint recreated with the extension, which should be // very rare. We leave the error name as it was. return Err(TokenError::NonTransferableNeedsImmutableOwnership.into()); } if let Ok(extension) = mint.get_extension::() { if extension.paused.into() { return Err(TokenError::MintPaused.into()); } } if mint.get_extension::().is_ok() { return Err(TokenError::IllegalMintBurnConversion.into()); } if let InstructionVariant::Checked { decimals } = instruction_variant { if decimals != mint.base.decimals { return Err(TokenError::MintDecimalsMismatch.into()); } } match &mint.base.mint_authority { PodCOption { option: PodCOption::
::SOME, value: mint_authority, } => Self::validate_owner( program_id, mint_authority, owner_info, owner_info_data_len, account_info_iter.as_slice(), )?, _ => return Err(TokenError::FixedSupply.into()), } destination_account.base.amount = u64::from(destination_account.base.amount) .checked_add(amount) .ok_or(TokenError::Overflow)? .into(); mint.base.supply = u64::from(mint.base.supply) .checked_add(amount) .ok_or(TokenError::Overflow)? .into(); Ok(()) } /// Processes a [`Burn`](enum.TokenInstruction.html) instruction. pub(crate) fn process_burn( program_id: &Address, accounts: &mut [AccountView], amount: u64, burn_variant: BurnInstructionVariant, instruction_variant: InstructionVariant, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let source_account_info = next_account_view(account_info_iter)?; let mint_info = next_account_view(account_info_iter)?; check_program_account(source_account_info.owner())?; check_program_account(mint_info.owner())?; let (permissioned_burn_authority_info, authority_info) = match burn_variant { BurnInstructionVariant::Permissioned => { let permissioned_burn_authority_info = next_account_view(account_info_iter)?; let authority_info = next_account_view(account_info_iter)?; (Some(permissioned_burn_authority_info), authority_info) } BurnInstructionVariant::Standard => (None, next_account_view(account_info_iter)?), }; let authority_info_data_len = authority_info.data_len(); // Note: Storing the address of the mint so borrow checker doesn't complain about // multiple borrows of `mint_info`. let mint_address = *mint_info.address(); let mut mint_data = mint_info.try_borrow_mut()?; let mint = PodStateWithExtensionsMut::::unpack(&mut mint_data)?; let permissioned_ext = mint.get_extension::(); let maybe_permissioned_burn_authority = permissioned_ext .as_ref() .ok() .and_then(|ext| Option::
::from(ext.authority)); match burn_variant { BurnInstructionVariant::Standard => { // Standard burns cannot be used when the permissioned burn // extension is present. if maybe_permissioned_burn_authority.is_some() { return Err(TokenError::InvalidInstruction.into()); } } BurnInstructionVariant::Permissioned => { permissioned_ext.map_err(|_| TokenError::InvalidInstruction)?; let expected_burn_authority = maybe_permissioned_burn_authority.ok_or_else(|| { msg!("Permissioned burn authority is None; use the standard burn"); TokenError::InvalidInstruction })?; // Pull the required extra signer from the accounts let approver_ai = permissioned_burn_authority_info.ok_or(ProgramError::NotEnoughAccountKeys)?; if !approver_ai.is_signer() { return Err(ProgramError::MissingRequiredSignature); } if *approver_ai.address() != expected_burn_authority { return Err(ProgramError::InvalidAccountData); } } } let mut source_account_data = source_account_info.try_borrow_mut()?; let source_account = PodStateWithExtensionsMut::::unpack(&mut source_account_data)?; if source_account.base.is_frozen() { return Err(TokenError::AccountFrozen.into()); } if source_account.base.is_native() { return Err(TokenError::NativeNotSupported.into()); } if u64::from(source_account.base.amount) < amount { return Err(TokenError::InsufficientFunds.into()); } if mint_address != source_account.base.mint { return Err(TokenError::MintMismatch.into()); } if let InstructionVariant::Checked { decimals } = instruction_variant { if decimals != mint.base.decimals { return Err(TokenError::MintDecimalsMismatch.into()); } } if let Ok(extension) = mint.get_extension::() { if extension.paused.into() { return Err(TokenError::MintPaused.into()); } } if mint.get_extension::().is_ok() { return Err(TokenError::IllegalMintBurnConversion.into()); } let maybe_permanent_delegate = get_permanent_delegate(&mint); if let Ok(cpi_guard) = source_account.get_extension::() { // Blocks all cases where the authority has signed if CPI Guard is // enabled, including: // * the account is delegated to the owner // * the account owner is the permanent delegate if *authority_info.address() == source_account.base.owner && cpi_guard.lock_cpi.into() && in_cpi() { return Err(TokenError::CpiGuardBurnBlocked.into()); } } if !source_account .base .is_owned_by_system_program_or_incinerator() { match (&source_account.base.delegate, maybe_permanent_delegate) { (_, Some(ref delegate)) if authority_info.address() == delegate => { Self::validate_owner( program_id, delegate, authority_info, authority_info_data_len, account_info_iter.as_slice(), )? } ( PodCOption { option: PodCOption::
::SOME, value: delegate, }, _, ) if authority_info.address() == delegate => { Self::validate_owner( program_id, delegate, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; if u64::from(source_account.base.delegated_amount) < amount { return Err(TokenError::InsufficientFunds.into()); } source_account.base.delegated_amount = u64::from(source_account.base.delegated_amount) .checked_sub(amount) .ok_or(TokenError::Overflow)? .into(); if u64::from(source_account.base.delegated_amount) == 0 { source_account.base.delegate = PodCOption::none(); } } _ => { Self::validate_owner( program_id, &source_account.base.owner, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; } } } source_account.base.amount = u64::from(source_account.base.amount) .checked_sub(amount) .ok_or(TokenError::Overflow)? .into(); mint.base.supply = u64::from(mint.base.supply) .checked_sub(amount) .ok_or(TokenError::Overflow)? .into(); Ok(()) } /// Processes a [`CloseAccount`](enum.TokenInstruction.html) instruction. pub fn process_close_account( program_id: &Address, accounts: &mut [AccountView], ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let source_account_info = next_account_view(account_info_iter)?; let destination_account_info = next_account_view(account_info_iter)?; let authority_info = next_account_view(account_info_iter)?; let authority_info_data_len = authority_info.data_len(); check_program_account(source_account_info.owner())?; if source_account_info.address() == destination_account_info.address() { return Err(ProgramError::InvalidAccountData); } let source_account_data = source_account_info.try_borrow()?; if let Ok(source_account) = PodStateWithExtensions::::unpack(&source_account_data) { if !source_account.base.is_native() && u64::from(source_account.base.amount) != 0 { return Err(TokenError::NonNativeHasBalance.into()); } let authority = source_account .base .close_authority .unwrap_or(source_account.base.owner); if !source_account .base .is_owned_by_system_program_or_incinerator() { if let Ok(cpi_guard) = source_account.get_extension::() { if cpi_guard.lock_cpi.into() && in_cpi() && destination_account_info.address() != &source_account.base.owner { return Err(TokenError::CpiGuardCloseAccountBlocked.into()); } } Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; } else if !solana_sdk_ids::incinerator::check_id(destination_account_info.address()) { return Err(ProgramError::InvalidAccountData); } if let Ok(confidential_transfer_state) = source_account.get_extension::() { confidential_transfer_state.closable()? } if let Ok(confidential_transfer_fee_state) = source_account.get_extension::() { confidential_transfer_fee_state.closable()? } if let Ok(transfer_fee_state) = source_account.get_extension::() { transfer_fee_state.closable()? } } else if let Ok(mint) = PodStateWithExtensions::::unpack(&source_account_data) { let extension = mint.get_extension::()?; let maybe_authority: Option
= extension.close_authority.into(); let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?; Self::validate_owner( program_id, &authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; if u64::from(mint.base.supply) != 0 { return Err(TokenError::MintHasSupply.into()); } if let Ok(confidential_mint_burn) = mint.get_extension::() { confidential_mint_burn.closable()?; } } else { return Err(ProgramError::UninitializedAccount); } let destination_starting_lamports = destination_account_info.lamports(); destination_account_info.set_lamports( destination_starting_lamports .checked_add(source_account_info.lamports()) .ok_or(TokenError::Overflow)?, ); drop(source_account_data); // SAFETY: There are no active borrows of `source_account_info` at this point. unsafe { source_account_info.close_unchecked() }; Ok(()) } /// Processes a [`FreezeAccount`](enum.TokenInstruction.html) or a /// [`ThawAccount`](enum.TokenInstruction.html) instruction. pub fn process_toggle_freeze_account( program_id: &Address, accounts: &mut [AccountView], freeze: bool, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let source_account_info = next_account_view(account_info_iter)?; let mint_info = next_account_view(account_info_iter)?; let authority_info = next_account_view(account_info_iter)?; let authority_info_data_len = authority_info.data_len(); check_program_account(source_account_info.owner())?; check_program_account(mint_info.owner())?; let mut source_account_data = source_account_info.try_borrow_mut()?; let source_account = PodStateWithExtensionsMut::::unpack(&mut source_account_data)?; if freeze && source_account.base.is_frozen() || !freeze && !source_account.base.is_frozen() { return Err(TokenError::InvalidState.into()); } if source_account.base.is_native() { return Err(TokenError::NativeNotSupported.into()); } if mint_info.address() != &source_account.base.mint { return Err(TokenError::MintMismatch.into()); } let mint_data = mint_info.try_borrow()?; let mint = PodStateWithExtensions::::unpack(&mint_data)?; match &mint.base.freeze_authority { PodCOption { option: PodCOption::
::SOME, value: authority, } => Self::validate_owner( program_id, authority, authority_info, authority_info_data_len, account_info_iter.as_slice(), ), _ => Err(TokenError::MintCannotFreeze.into()), }?; source_account.base.state = if freeze { AccountState::Frozen.into() } else { AccountState::Initialized.into() }; Ok(()) } /// Processes a [`SyncNative`](enum.TokenInstruction.html) instruction pub fn process_sync_native(accounts: &mut [AccountView]) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let native_account_info = next_account_view(account_info_iter)?; check_program_account(native_account_info.owner())?; let rent_exempt_reserve = if let Ok(rent_sysvar_info) = next_account_view(account_info_iter) { let rent = Rent::from_account_view(rent_sysvar_info)?; rent.try_minimum_balance(native_account_info.data_len())? } else { Rent::get()?.try_minimum_balance(native_account_info.data_len())? }; // Note: Storing the lamports of the native account so borrow checker doesn't complain about // multiple borrows of `native_account_info`. let native_account_lamports = native_account_info.lamports(); let mut native_account_data = native_account_info.try_borrow_mut()?; let native_account = PodStateWithExtensionsMut::::unpack(&mut native_account_data)?; match native_account.base.is_native { PodCOption { option: PodCOption::::SOME, .. } => { let new_amount = native_account_lamports .checked_sub(rent_exempt_reserve) .ok_or(TokenError::Overflow)?; native_account.base.is_native = PodCOption::some(rent_exempt_reserve.into()); native_account.base.amount = new_amount.into(); } _ => return Err(TokenError::NonNativeNotSupported.into()), } Ok(()) } /// Processes an /// [`InitializeMintCloseAuthority`](enum.TokenInstruction.html) /// instruction pub fn process_initialize_mint_close_authority( accounts: &mut [AccountView], close_authority: PodCOption
, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let mint_account_info = next_account_view(account_info_iter)?; check_program_account(mint_account_info.owner())?; let mut mint_data = mint_account_info.try_borrow_mut()?; let mut mint = PodStateWithExtensionsMut::::unpack_uninitialized(&mut mint_data)?; let extension = mint.init_extension::(true)?; extension.close_authority = close_authority.try_into()?; Ok(()) } /// Processes a [`GetAccountDataSize`](enum.TokenInstruction.html) /// instruction pub fn process_get_account_data_size( accounts: &[AccountView], new_extension_types: &[ExtensionType], ) -> ProgramResult { let account_info_iter = &mut accounts.iter(); let mint_account_info = next_account_view(account_info_iter)?; check_program_account(mint_account_info.owner())?; let mint_data = mint_account_info.try_borrow()?; let account_len = try_calculate_account_len_from_mint_data(&mint_data, new_extension_types)?; set_return_data(&account_len.to_le_bytes()); Ok(()) } /// Processes an [`InitializeImmutableOwner`](enum.TokenInstruction.html) /// instruction pub fn process_initialize_immutable_owner(accounts: &mut [AccountView]) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let token_account_info = next_account_view(account_info_iter)?; check_program_account(token_account_info.owner())?; let token_account_data = &mut token_account_info.try_borrow_mut()?; let mut token_account = PodStateWithExtensionsMut::::unpack_uninitialized(token_account_data)?; token_account .init_extension::(true) .map(|_| ()) } /// Processes an [`AmountToUiAmount`](enum.TokenInstruction.html) /// instruction pub fn process_amount_to_ui_amount(accounts: &[AccountView], amount: u64) -> ProgramResult { let account_info_iter = &mut accounts.iter(); let mint_info = next_account_view(account_info_iter)?; check_program_account(mint_info.owner())?; let mint_data = mint_info.try_borrow()?; let mint = PodStateWithExtensions::::unpack(&mint_data) .map_err(|_| Into::::into(TokenError::InvalidMint))?; let ui_amount = if let Ok(extension) = mint.get_extension::() { let unix_timestamp = Clock::get()?.unix_timestamp; extension .amount_to_ui_amount(amount, mint.base.decimals, unix_timestamp) .ok_or(ProgramError::InvalidArgument)? } else if let Ok(extension) = mint.get_extension::() { let unix_timestamp = Clock::get()?.unix_timestamp; extension .amount_to_ui_amount(amount, mint.base.decimals, unix_timestamp) .ok_or(ProgramError::InvalidArgument)? } else { crate::amount_to_ui_amount_string_trimmed(amount, mint.base.decimals) }; set_return_data(&ui_amount.into_bytes()); Ok(()) } /// Processes an [`UiAmountToAmount`](enum.TokenInstruction.html) /// instruction pub fn process_ui_amount_to_amount(accounts: &[AccountView], ui_amount: &str) -> ProgramResult { let account_info_iter = &mut accounts.iter(); let mint_info = next_account_view(account_info_iter)?; check_program_account(mint_info.owner())?; let mint_data = mint_info.try_borrow()?; let mint = PodStateWithExtensions::::unpack(&mint_data) .map_err(|_| Into::::into(TokenError::InvalidMint))?; let amount = if let Ok(extension) = mint.get_extension::() { let unix_timestamp = Clock::get()?.unix_timestamp; extension.try_ui_amount_into_amount(ui_amount, mint.base.decimals, unix_timestamp)? } else if let Ok(extension) = mint.get_extension::() { let unix_timestamp = Clock::get()?.unix_timestamp; extension.try_ui_amount_into_amount(ui_amount, mint.base.decimals, unix_timestamp)? } else { crate::try_ui_amount_into_amount(ui_amount.to_string(), mint.base.decimals)? }; set_return_data(&amount.to_le_bytes()); Ok(()) } /// Processes a [`CreateNativeMint`](enum.TokenInstruction.html) instruction pub fn process_create_native_mint(accounts: &mut [AccountView]) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let payer_info = next_account_view(account_info_iter)?; let native_mint_info = next_account_view(account_info_iter)?; let _system_program_info = next_account_view(account_info_iter)?; if *native_mint_info.address() != native_mint::id() { return Err(TokenError::InvalidMint.into()); } let rent = Rent::get()?; let new_minimum_balance = rent.try_minimum_balance(Mint::get_packed_len())?; let lamports_diff = new_minimum_balance.saturating_sub(native_mint_info.lamports()); let signer_seeds = &[ Seed::from(PROGRAM_ADDRESS_SEEDS[0]), Seed::from(PROGRAM_ADDRESS_SEEDS[1]), ]; // Note: Use `CreateAccountAllowPrefund` to create the native mint account with the // correct lamports. CreateAccountAllowPrefund { funding: Some(Funding { from: payer_info, lamports: lamports_diff, }), to: native_mint_info, space: Mint::get_packed_len() as u64, owner: &crate::ID, } .invoke_signed(&[Signer::from(signer_seeds)])?; Mint::pack( Mint { decimals: native_mint::DECIMALS, is_initialized: true, ..Mint::default() }, &mut native_mint_info.try_borrow_mut()?, ) } /// Processes an /// [`InitializeNonTransferableMint`](enum.TokenInstruction.html) /// instruction pub fn process_initialize_non_transferable_mint(accounts: &mut [AccountView]) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let mint_account_info = next_account_view(account_info_iter)?; check_program_account(mint_account_info.owner())?; let mut mint_data = mint_account_info.try_borrow_mut()?; let mut mint = PodStateWithExtensionsMut::::unpack_uninitialized(&mut mint_data)?; mint.init_extension::(true)?; Ok(()) } /// Processes an [`InitializePermanentDelegate`](enum.TokenInstruction.html) /// instruction pub fn process_initialize_permanent_delegate( accounts: &mut [AccountView], delegate: &Address, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let mint_account_info = next_account_view(account_info_iter)?; check_program_account(mint_account_info.owner())?; let mut mint_data = mint_account_info.try_borrow_mut()?; let mut mint = PodStateWithExtensionsMut::::unpack_uninitialized(&mut mint_data)?; let extension = mint.init_extension::(true)?; extension.delegate = Some(*delegate) .try_into() .map_err(|_| ProgramError::InvalidArgument)?; Ok(()) } /// Withdraw Excess Lamports is used to recover Lamports transferred to any /// `TokenProgram` owned account by moving them to another account /// of the source account. pub fn process_withdraw_excess_lamports( program_id: &Address, accounts: &mut [AccountView], ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let source_info = next_account_view(account_info_iter)?; let destination_info = next_account_view(account_info_iter)?; let authority_info = next_account_view(account_info_iter)?; check_program_account(source_info.owner())?; let source_data = source_info.try_borrow()?; if let Ok(account) = PodStateWithExtensions::::unpack(&source_data) { if account.base.is_native() { return Err(TokenError::NativeNotSupported.into()); } Self::validate_owner( program_id, &account.base.owner, authority_info, authority_info.data_len(), account_info_iter.as_slice(), )?; if let Ok(cpi_guard) = account.get_extension::() { if cpi_guard.lock_cpi.into() && in_cpi() { return Err(TokenError::CpiGuardTransferBlocked.into()); } } } else if let Ok(mint) = PodStateWithExtensions::::unpack(&source_data) { match &mint.base.mint_authority { PodCOption { option: PodCOption::
::SOME, value: mint_authority, } => { Self::validate_owner( program_id, mint_authority, authority_info, authority_info.data_len(), account_info_iter.as_slice(), )?; } PodCOption { option: PodCOption::
::NONE, value: _, } if source_info.address() == authority_info.address() => { // This is a special case where there is no mint authority set but the mint // account is the same as the authority account and, therefore, needs to be // a signer. if !authority_info.is_signer() { return Err(ProgramError::MissingRequiredSignature); } } _ => return Err(TokenError::AuthorityTypeNotSupported.into()), } } else if source_data.len() == PodMultisig::SIZE_OF { Self::validate_owner( program_id, source_info.address(), authority_info, authority_info.data_len(), account_info_iter.as_slice(), )?; } else { return Err(TokenError::InvalidState.into()); } // Note: Drop the borrow of `source_data` to avoid borrow checker issues. drop(source_data); let source_rent_exempt_reserve = Rent::get()?.try_minimum_balance(source_info.data_len())?; let transfer_amount = source_info .lamports() .checked_sub(source_rent_exempt_reserve) .ok_or(TokenError::NotRentExempt)?; let source_starting_lamports = source_info.lamports(); source_info.set_lamports( source_starting_lamports .checked_sub(transfer_amount) .ok_or(TokenError::Overflow)?, ); let destination_starting_lamports = destination_info.lamports(); destination_info.set_lamports( destination_starting_lamports .checked_add(transfer_amount) .ok_or(TokenError::Overflow)?, ); Ok(()) } /// Processes a [`UnwrapLamports`](enum.TokenInstruction.html) /// instruction pub fn process_unwrap_lamports( program_id: &Address, accounts: &mut [AccountView], amount: PodCOption, ) -> ProgramResult { let account_info_iter = &mut accounts.iter_mut(); let source_account_info = next_account_view(account_info_iter)?; let destination_account_info = next_account_view(account_info_iter)?; let authority_info = next_account_view(account_info_iter)?; let authority_info_data_len = authority_info.data_len(); check_program_account(source_account_info.owner())?; let mut source_account_data = source_account_info.try_borrow_mut()?; let source_account = PodStateWithExtensionsMut::::unpack(&mut source_account_data)?; let (amount, remaining_amount) = match amount { PodCOption { option: PodCOption::::SOME, value: amount, } => ( amount, Into::::into(source_account.base.amount) .checked_sub(amount) .ok_or(TokenError::InsufficientFunds)?, ), PodCOption { option: PodCOption::::NONE, value: _, } => (source_account.base.amount.into(), 0), _ => return Err(ProgramError::InvalidInstructionData), }; if !source_account.base.is_native() { return Err(TokenError::NonNativeNotSupported.into()); } match source_account.base.delegate { PodCOption { option: PodCOption::
::SOME, value: delegate, } if authority_info.address() == &delegate => { Self::validate_owner( program_id, &delegate, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; let delegated_amount = u64::from(source_account.base.delegated_amount); source_account.base.delegated_amount = delegated_amount .checked_sub(amount) .ok_or(TokenError::InsufficientFunds)? .into(); if u64::from(source_account.base.delegated_amount) == 0 { source_account.base.delegate = PodCOption::none(); } } _ => { Self::validate_owner( program_id, &source_account.base.owner, authority_info, authority_info_data_len, account_info_iter.as_slice(), )?; } } if let Ok(cpi_guard) = source_account.get_extension::() { if cpi_guard.lock_cpi.into() && in_cpi() { return Err(TokenError::CpiGuardTransferBlocked.into()); } } if amount != 0 { source_account.base.amount = remaining_amount.into(); // Note: Drop the borrow of `source_account_data` to avoid borrow checker issues. drop(source_account_data); if source_account_info.address() != destination_account_info.address() { let source_starting_lamports = source_account_info.lamports(); source_account_info.set_lamports( source_starting_lamports .checked_sub(amount) .ok_or(TokenError::Overflow)?, ); let destination_starting_lamports = destination_account_info.lamports(); destination_account_info.set_lamports( destination_starting_lamports .checked_add(amount) .ok_or(TokenError::Overflow)?, ); } } Ok(()) } /// The size of the batch instruction header. /// /// The header of each instruction consists of two `u8` values: /// * number of the accounts /// * length of the instruction data const IX_HEADER_SIZE: usize = 2; /// Processes an [`Batch`](enum.TokenInstruction.html) /// instruction pub fn process_batch( program_id: &Address, mut accounts: &mut [AccountView], mut data: &[u8], ) -> ProgramResult { loop { let header = data .get(..Self::IX_HEADER_SIZE) .ok_or(TokenError::InvalidInstruction)?; let expected_accounts = header[0] as usize; let data_offset = Self::IX_HEADER_SIZE + header[1] as usize; let ix_accounts = accounts .get_mut(..expected_accounts) .ok_or(ProgramError::NotEnoughAccountKeys)?; let ix_data = data .get(Self::IX_HEADER_SIZE..data_offset) .ok_or(TokenError::InvalidInstruction)?; Self::_process_inner(program_id, ix_accounts, ix_data)?; if data_offset == data.len() { break; } accounts = &mut accounts[expected_accounts..]; data = &data[data_offset..]; } Ok(()) } /// Processes an [`Instruction`](enum.Instruction.html). pub fn process( program_id: &Address, accounts: &mut [AccountView], input: &[u8], ) -> ProgramResult { if let Ok(PodTokenInstruction::Batch) = decode_instruction_type(input) { msg!("Instruction: Batch"); Self::process_batch(program_id, accounts, &input[1..]) } else { Self::_process_inner(program_id, accounts, input) } } fn _process_inner( program_id: &Address, accounts: &mut [AccountView], input: &[u8], ) -> ProgramResult { if let Ok(instruction_type) = decode_instruction_type(input) { match instruction_type { PodTokenInstruction::InitializeMint => { msg!("Instruction: InitializeMint"); let (data, freeze_authority) = decode_instruction_data_with_coption_pubkey::(input)?; Self::process_initialize_mint( accounts, data.decimals, &data.mint_authority, freeze_authority, ) } PodTokenInstruction::InitializeMint2 => { msg!("Instruction: InitializeMint2"); let (data, freeze_authority) = decode_instruction_data_with_coption_pubkey::(input)?; Self::process_initialize_mint2( accounts, data.decimals, &data.mint_authority, freeze_authority, ) } PodTokenInstruction::InitializeAccount => { msg!("Instruction: InitializeAccount"); Self::process_initialize_account(accounts) } PodTokenInstruction::InitializeAccount2 => { msg!("Instruction: InitializeAccount2"); let owner = decode_instruction_data::
(input)?; Self::process_initialize_account2(accounts, owner) } PodTokenInstruction::InitializeAccount3 => { msg!("Instruction: InitializeAccount3"); let owner = decode_instruction_data::
(input)?; Self::process_initialize_account3(accounts, owner) } PodTokenInstruction::InitializeMultisig => { msg!("Instruction: InitializeMultisig"); let data = decode_instruction_data::(input)?; Self::process_initialize_multisig(accounts, data.m) } PodTokenInstruction::InitializeMultisig2 => { msg!("Instruction: InitializeMultisig2"); let data = decode_instruction_data::(input)?; Self::process_initialize_multisig2(accounts, data.m) } #[allow(deprecated)] PodTokenInstruction::Transfer => { msg!("Instruction: Transfer"); let data = decode_instruction_data::(input)?; Self::process_transfer( program_id, accounts, data.amount.into(), TransferInstruction::Unchecked, ) } PodTokenInstruction::Approve => { msg!("Instruction: Approve"); let data = decode_instruction_data::(input)?; Self::process_approve( program_id, accounts, data.amount.into(), InstructionVariant::Unchecked, ) } PodTokenInstruction::Revoke => { msg!("Instruction: Revoke"); Self::process_revoke(program_id, accounts) } PodTokenInstruction::SetAuthority => { msg!("Instruction: SetAuthority"); let (data, new_authority) = decode_instruction_data_with_coption_pubkey::(input)?; Self::process_set_authority( program_id, accounts, AuthorityType::from(data.authority_type)?, new_authority, ) } PodTokenInstruction::MintTo => { msg!("Instruction: MintTo"); let data = decode_instruction_data::(input)?; Self::process_mint_to( program_id, accounts, data.amount.into(), InstructionVariant::Unchecked, ) } PodTokenInstruction::Burn => { msg!("Instruction: Burn"); let data = decode_instruction_data::(input)?; Self::process_burn( program_id, accounts, data.amount.into(), BurnInstructionVariant::Standard, InstructionVariant::Unchecked, ) } PodTokenInstruction::CloseAccount => { msg!("Instruction: CloseAccount"); Self::process_close_account(program_id, accounts) } PodTokenInstruction::FreezeAccount => { msg!("Instruction: FreezeAccount"); Self::process_toggle_freeze_account(program_id, accounts, true) } PodTokenInstruction::ThawAccount => { msg!("Instruction: ThawAccount"); Self::process_toggle_freeze_account(program_id, accounts, false) } PodTokenInstruction::TransferChecked => { msg!("Instruction: TransferChecked"); let data = decode_instruction_data::(input)?; Self::process_transfer( program_id, accounts, data.amount.into(), TransferInstruction::Checked { decimals: data.decimals, }, ) } PodTokenInstruction::ApproveChecked => { msg!("Instruction: ApproveChecked"); let data = decode_instruction_data::(input)?; Self::process_approve( program_id, accounts, data.amount.into(), InstructionVariant::Checked { decimals: data.decimals, }, ) } PodTokenInstruction::MintToChecked => { msg!("Instruction: MintToChecked"); let data = decode_instruction_data::(input)?; Self::process_mint_to( program_id, accounts, data.amount.into(), InstructionVariant::Checked { decimals: data.decimals, }, ) } PodTokenInstruction::BurnChecked => { msg!("Instruction: BurnChecked"); let data = decode_instruction_data::(input)?; Self::process_burn( program_id, accounts, data.amount.into(), BurnInstructionVariant::Standard, InstructionVariant::Checked { decimals: data.decimals, }, ) } PodTokenInstruction::SyncNative => { msg!("Instruction: SyncNative"); Self::process_sync_native(accounts) } PodTokenInstruction::GetAccountDataSize => { msg!("Instruction: GetAccountDataSize"); let extension_types = input[1..] .chunks(std::mem::size_of::()) .map(ExtensionType::try_from) .collect::, _>>()?; Self::process_get_account_data_size(accounts, &extension_types) } PodTokenInstruction::InitializeMintCloseAuthority => { msg!("Instruction: InitializeMintCloseAuthority"); let (_, close_authority) = decode_instruction_data_with_coption_pubkey::<()>(input)?; Self::process_initialize_mint_close_authority(accounts, close_authority) } PodTokenInstruction::TransferFeeExtension => { transfer_fee::processor::process_instruction(program_id, accounts, &input[1..]) } PodTokenInstruction::ConfidentialTransferExtension => { confidential_transfer::processor::process_instruction( program_id, accounts, &input[1..], ) } PodTokenInstruction::DefaultAccountStateExtension => { default_account_state::processor::process_instruction( program_id, accounts, &input[1..], ) } PodTokenInstruction::InitializeImmutableOwner => { msg!("Instruction: InitializeImmutableOwner"); Self::process_initialize_immutable_owner(accounts) } PodTokenInstruction::AmountToUiAmount => { msg!("Instruction: AmountToUiAmount"); let data = decode_instruction_data::(input)?; Self::process_amount_to_ui_amount(accounts, data.amount.into()) } PodTokenInstruction::UiAmountToAmount => { msg!("Instruction: UiAmountToAmount"); let ui_amount = std::str::from_utf8(&input[1..]) .map_err(|_| TokenError::InvalidInstruction)?; Self::process_ui_amount_to_amount(accounts, ui_amount) } PodTokenInstruction::Reallocate => { msg!("Instruction: Reallocate"); let extension_types = input[1..] .chunks(std::mem::size_of::()) .map(ExtensionType::try_from) .collect::, _>>()?; reallocate::process_reallocate(program_id, accounts, extension_types) } PodTokenInstruction::MemoTransferExtension => { memo_transfer::processor::process_instruction(program_id, accounts, &input[1..]) } PodTokenInstruction::CreateNativeMint => { msg!("Instruction: CreateNativeMint"); Self::process_create_native_mint(accounts) } PodTokenInstruction::InitializeNonTransferableMint => { msg!("Instruction: InitializeNonTransferableMint"); Self::process_initialize_non_transferable_mint(accounts) } PodTokenInstruction::InterestBearingMintExtension => { interest_bearing_mint::processor::process_instruction( program_id, accounts, &input[1..], ) } PodTokenInstruction::CpiGuardExtension => { cpi_guard::processor::process_instruction(program_id, accounts, &input[1..]) } PodTokenInstruction::InitializePermanentDelegate => { msg!("Instruction: InitializePermanentDelegate"); let delegate = decode_instruction_data::
(input)?; Self::process_initialize_permanent_delegate(accounts, delegate) } PodTokenInstruction::TransferHookExtension => { transfer_hook::processor::process_instruction(program_id, accounts, &input[1..]) } PodTokenInstruction::ConfidentialTransferFeeExtension => { confidential_transfer_fee::processor::process_instruction( program_id, accounts, &input[1..], ) } PodTokenInstruction::WithdrawExcessLamports => { msg!("Instruction: WithdrawExcessLamports"); Self::process_withdraw_excess_lamports(program_id, accounts) } PodTokenInstruction::MetadataPointerExtension => { metadata_pointer::processor::process_instruction( program_id, accounts, &input[1..], ) } PodTokenInstruction::GroupPointerExtension => { group_pointer::processor::process_instruction(program_id, accounts, &input[1..]) } PodTokenInstruction::GroupMemberPointerExtension => { group_member_pointer::processor::process_instruction( program_id, accounts, &input[1..], ) } PodTokenInstruction::ConfidentialMintBurnExtension => { msg!("Instruction: ConfidentialMintBurnExtension"); confidential_mint_burn::processor::process_instruction( program_id, accounts, &input[1..], ) } PodTokenInstruction::ScaledUiAmountExtension => { msg!("Instruction: ScaledUiAmountExtension"); scaled_ui_amount::processor::process_instruction( program_id, accounts, &input[1..], ) } PodTokenInstruction::PausableExtension => { msg!("Instruction: PausableExtension"); pausable::processor::process_instruction(program_id, accounts, &input[1..]) } PodTokenInstruction::PermissionedBurnExtension => { msg!("Instruction: PermissionedBurnExtension"); permissioned_burn::processor::process_instruction( program_id, accounts, &input[1..], ) } PodTokenInstruction::UnwrapLamports => { msg!("Instruction: UnwrapLamports"); let (_, amount) = decode_instruction_data_with_coption_u64::<()>(input)?; Self::process_unwrap_lamports(program_id, accounts, amount) } PodTokenInstruction::Batch => Err(TokenError::InvalidInstruction.into()), } } else if let Ok(instruction) = TokenMetadataInstruction::unpack(input) { token_metadata::processor::process_instruction(program_id, accounts, instruction) } else if let Ok(instruction) = TokenGroupInstruction::unpack(input) { token_group::processor::process_instruction(program_id, accounts, instruction) } else { Err(TokenError::InvalidInstruction.into()) } } /// Validates owner(s) are present. Used for Mints and Accounts only. pub fn validate_owner( program_id: &Address, expected_owner: &Address, owner_account_info: &AccountView, owner_account_data_len: usize, signers: &[AccountView], ) -> ProgramResult { if expected_owner != owner_account_info.address() { return Err(TokenError::OwnerMismatch.into()); } let owned_by_token_program = program_id == owner_account_info.owner() || owner_account_info.owner() == &inline_spl_token::id() || owner_account_info.owner() == &spl_token_2022_interface::id(); if owned_by_token_program && owner_account_data_len == PodMultisig::SIZE_OF { let multisig_data = &owner_account_info.try_borrow()?; let multisig = bytemuck::try_from_bytes::(multisig_data) .map_err(|_| ProgramError::InvalidArgument)?; if !bool::from(multisig.is_initialized) { return Err(ProgramError::UninitializedAccount); } let mut num_signers = 0; let mut matched = [false; MAX_SIGNERS]; for signer in signers.iter() { for (position, key) in multisig.signers[0..multisig.n as usize].iter().enumerate() { if key == signer.address() && !matched[position] { if !signer.is_signer() { return Err(ProgramError::MissingRequiredSignature); } matched[position] = true; num_signers += 1; } } } if num_signers < multisig.m { return Err(ProgramError::MissingRequiredSignature); } return Ok(()); } else if !owner_account_info.is_signer() { return Err(ProgramError::MissingRequiredSignature); } Ok(()) } } #[cfg(test)] mod tests { use { super::*, mollusk_svm::{result::Check, Mollusk}, solana_account::{ state_traits::StateMutWincode, Account as SolanaAccount, ReadableAccount, }, solana_account_info::AccountInfo, solana_account_info::IntoAccountInfo, solana_instruction::{AccountMeta, Instruction}, solana_program_option::COption, solana_rent::Rent, solana_sdk_ids::system_program, solana_sdk_ids::sysvar::{self, rent}, spl_token_2022_interface::{ extension::{ permissioned_burn, transfer_fee::instruction::initialize_transfer_fee_config, ExtensionType, }, instruction::*, state::{Account, Multisig}, }, std::collections::HashMap, }; fn do_process_instruction( instruction: Instruction, mut accounts: Vec<&mut SolanaAccount>, checks: &[Check], ) { // Prepare accounts for mollusk. let instruction_accounts: Vec<(Address, SolanaAccount)> = instruction .accounts .iter() .zip(&accounts) .map(|(account_meta, account)| (account_meta.pubkey, (*account).clone())) .collect(); let mut mollusk = Mollusk::new(&crate::id(), "spl_token_2022"); mollusk.sysvars.rent = test_rent(); // Always panic on failed checks in tests. mollusk.config.panic = true; // Process the instruction and validate the result. It panics if the result does not // match the expected checks. let result = mollusk.process_and_validate_instruction(&instruction, &instruction_accounts, checks); // Update accounts after the instruction is processed. for (original, (_, updated)) in accounts.iter_mut().zip(result.resulting_accounts) { original.data = updated.data().to_vec(); original.lamports = updated.lamports(); original.owner = *updated.owner(); } } fn do_process_instruction_dups( instruction: Instruction, account_infos: Vec, checks: &[Check], ) { let mut cached_accounts = HashMap::new(); let mut dedup_accounts = Vec::new(); // Dedup accounts for mollusk. account_infos.iter().for_each(|account_info| { if !cached_accounts.contains_key(account_info.key) { let account = SolanaAccount { lamports: account_info.lamports(), data: account_info.try_borrow_data().unwrap().to_vec(), owner: *account_info.owner, executable: account_info.executable, rent_epoch: u64::MAX, }; dedup_accounts.push((*account_info.key, account)); cached_accounts.insert(account_info.key, account_info); } }); let mut mollusk = Mollusk::new(&crate::id(), "spl_token_2022"); mollusk.sysvars.rent = test_rent(); // Always panic on failed checks in tests. mollusk.config.panic = true; // Process the instruction and validate the result. It panics if the result does not // match the expected checks. let result = mollusk.process_and_validate_instruction(&instruction, &dedup_accounts, checks); // Update accounts after the instruction is processed. result .resulting_accounts .into_iter() .for_each(|(pubkey, account)| { let account_info = cached_accounts.get_mut(&pubkey).unwrap(); if account.data().is_empty() { // Set an empty data slice for accounts that have been resized // to zero length. *account_info.try_borrow_mut_data().unwrap() = &mut []; } else { account_info .try_borrow_mut_data() .unwrap() .copy_from_slice(account.data()); } **account_info.try_borrow_mut_lamports().unwrap() = account.lamports(); account_info.assign(account.owner()); }); } fn return_token_error_as_program_error() -> ProgramError { TokenError::MintMismatch.into() } fn test_rent() -> solana_rent::Rent { solana_rent::Rent::default() } fn rent_sysvar() -> SolanaAccount { SolanaAccount::new_data_with_space(1, &test_rent(), solana_rent::SIZE, &sysvar::id()) .unwrap() } fn mint_minimum_balance() -> u64 { solana_rent::Rent::default().minimum_balance(Mint::get_packed_len()) } fn account_minimum_balance() -> u64 { solana_rent::Rent::default().minimum_balance(Account::get_packed_len()) } fn multisig_minimum_balance() -> u64 { solana_rent::Rent::default().minimum_balance(Multisig::get_packed_len()) } fn batch_instruction(instructions: &[&Instruction]) -> Result { // Create a `Vec` of ordered `AccountMeta`s let mut accounts: Vec = vec![]; // Start with the batch discriminator let mut data: Vec = vec![0xff]; for instruction in instructions { // Error out on non-token IX. if instruction.program_id.ne(&crate::ID) { return Err(ProgramError::IncorrectProgramId); } data.push(instruction.accounts.len() as u8); data.push(instruction.data.len() as u8); data.extend_from_slice(&instruction.data); accounts.extend_from_slice(&instruction.accounts); } Ok(Instruction { program_id: crate::ID, data, accounts, }) } fn native_mint() -> SolanaAccount { let mut rent_sysvar = rent_sysvar(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &crate::id()); do_process_instruction( initialize_mint( &crate::id(), &crate::native_mint::id(), &Address::default(), None, crate::native_mint::DECIMALS, ) .unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); mint_account } fn native_mint_to(account: &AccountInfo, amount: u64) -> ProgramResult { let mut buffer = account.try_borrow_mut_data()?; let mut account_account = Account::unpack(&buffer)?; if !account_account.is_native() { return Err(TokenError::NonNativeNotSupported.into()); } let mut lamports = account.try_borrow_mut_lamports()?; **lamports += amount; account_account.amount += amount; Account::pack(account_account, &mut buffer)?; Ok(()) } #[test] fn test_error_as_custom() { assert_eq!( return_token_error_as_program_error(), ProgramError::Custom(3) ); } #[test] fn test_unique_account_sizes() { assert_ne!(Mint::get_packed_len(), 0); assert_ne!(Mint::get_packed_len(), Account::get_packed_len()); assert_ne!(Mint::get_packed_len(), Multisig::get_packed_len()); assert_ne!(Account::get_packed_len(), 0); assert_ne!(Account::get_packed_len(), Multisig::get_packed_len()); assert_ne!(Multisig::get_packed_len(), 0); } #[test] fn test_initialize_mint() { let program_id = crate::id(); let owner_key = Address::new_unique(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(42, Mint::get_packed_len(), &program_id); let mint2_key = Address::new_unique(); let mut mint2_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // mint is not rent exempt do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::err(TokenError::NotRentExempt.into())], ); mint_account.lamports = mint_minimum_balance(); // create new mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create twice do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::err(TokenError::AlreadyInUse.into())], ); // create another mint that can freeze do_process_instruction( initialize_mint(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(), vec![&mut mint2_account, &mut rent_sysvar], &[Check::success()], ); let mint = Mint::unpack_unchecked(&mint2_account.data).unwrap(); assert_eq!(mint.freeze_authority, COption::Some(owner_key)); } #[test] fn test_initialize_mint2() { let program_id = crate::id(); let owner_key = Address::new_unique(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(42, Mint::get_packed_len(), &program_id); let mint2_key = Address::new_unique(); let mut mint2_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); // mint is not rent exempt do_process_instruction( initialize_mint2(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account], &[Check::err(TokenError::NotRentExempt.into())], ); mint_account.lamports = mint_minimum_balance(); // create new mint do_process_instruction( initialize_mint2(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account], &[Check::success()], ); // create twice do_process_instruction( initialize_mint2(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account], &[Check::err(TokenError::AlreadyInUse.into())], ); // create another mint that can freeze do_process_instruction( initialize_mint2(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(), vec![&mut mint2_account], &[Check::success()], ); let mint = Mint::unpack_unchecked(&mint2_account.data).unwrap(); assert_eq!(mint.freeze_authority, COption::Some(owner_key)); } #[test] fn test_initialize_mint_account() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new(42, Account::get_packed_len(), &program_id); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // account is not rent exempt do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::err(TokenError::NotRentExempt.into())], ); account_account.lamports = account_minimum_balance(); // mint is not valid (not initialized) do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::err(TokenError::InvalidMint.into())], ); // create mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // mint not owned by program let not_program_id = Address::new_unique(); mint_account.owner = not_program_id; do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::err(ProgramError::IncorrectProgramId)], ); mint_account.owner = program_id; // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create twice do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::err(TokenError::AlreadyInUse.into())], ); } #[test] fn test_transfer_dups() { let program_id = crate::id(); let account1_key = Address::new_unique(); let mut account1_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mut account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into(); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mut account2_info: AccountInfo = (&account2_key, false, &mut account2_account).into(); let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account3_info: AccountInfo = (&account3_key, false, &mut account3_account).into(); let account4_key = Address::new_unique(); let mut account4_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account4_info: AccountInfo = (&account4_key, true, &mut account4_account).into(); let multisig_key = Address::new_unique(); let mut multisig_account = SolanaAccount::new( multisig_minimum_balance(), Multisig::get_packed_len(), &program_id, ); let multisig_info: AccountInfo = (&multisig_key, true, &mut multisig_account).into(); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); // create mint do_process_instruction_dups( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![mint_info.clone(), rent_info.clone()], &[Check::success()], ); // create account do_process_instruction_dups( initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), rent_info.clone(), ], &[Check::success()], ); // create another account do_process_instruction_dups( initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(), vec![ account2_info.clone(), mint_info.clone(), owner_info.clone(), rent_info.clone(), ], &[Check::success()], ); // mint to account do_process_instruction_dups( mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(), vec![mint_info.clone(), account1_info.clone(), owner_info.clone()], &[Check::success()], ); // source-owner transfer do_process_instruction_dups( #[allow(deprecated)] transfer( &program_id, &account1_key, &account2_key, &account1_key, &[], 500, ) .unwrap(), vec![ account1_info.clone(), account2_info.clone(), account1_info.clone(), ], &[Check::success()], ); // source-owner TransferChecked do_process_instruction_dups( transfer_checked( &program_id, &account1_key, &mint_key, &account2_key, &account1_key, &[], 500, 2, ) .unwrap(), vec![ account1_info.clone(), mint_info.clone(), account2_info.clone(), account1_info.clone(), ], &[Check::success()], ); // source-delegate transfer let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap(); account.amount = 1000; account.delegated_amount = 1000; account.delegate = COption::Some(account1_key); account.owner = owner_key; Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap(); do_process_instruction_dups( #[allow(deprecated)] transfer( &program_id, &account1_key, &account2_key, &account1_key, &[], 500, ) .unwrap(), vec![ account1_info.clone(), account2_info.clone(), account1_info.clone(), ], &[Check::success()], ); // source-delegate TransferChecked do_process_instruction_dups( transfer_checked( &program_id, &account1_key, &mint_key, &account2_key, &account1_key, &[], 500, 2, ) .unwrap(), vec![ account1_info.clone(), mint_info.clone(), account2_info.clone(), account1_info.clone(), ], &[Check::success()], ); // test destination-owner transfer do_process_instruction_dups( initialize_account(&program_id, &account3_key, &mint_key, &account2_key).unwrap(), vec![ account3_info.clone(), mint_info.clone(), account2_info.clone(), rent_info.clone(), ], &[Check::success()], ); do_process_instruction_dups( mint_to(&program_id, &mint_key, &account3_key, &owner_key, &[], 1000).unwrap(), vec![mint_info.clone(), account3_info.clone(), owner_info.clone()], &[Check::success()], ); account1_info.is_signer = false; account2_info.is_signer = true; do_process_instruction_dups( #[allow(deprecated)] transfer( &program_id, &account3_key, &account2_key, &account2_key, &[], 500, ) .unwrap(), vec![ account3_info.clone(), account2_info.clone(), account2_info.clone(), ], &[Check::success()], ); // destination-owner TransferChecked do_process_instruction_dups( transfer_checked( &program_id, &account3_key, &mint_key, &account2_key, &account2_key, &[], 500, 2, ) .unwrap(), vec![ account3_info.clone(), mint_info.clone(), account2_info.clone(), account2_info.clone(), ], &[Check::success()], ); // test source-multisig signer do_process_instruction_dups( initialize_multisig(&program_id, &multisig_key, &[&account4_key], 1).unwrap(), vec![ multisig_info.clone(), rent_info.clone(), account4_info.clone(), ], &[Check::success()], ); do_process_instruction_dups( initialize_account(&program_id, &account4_key, &mint_key, &multisig_key).unwrap(), vec![ account4_info.clone(), mint_info.clone(), multisig_info.clone(), rent_info.clone(), ], &[Check::success()], ); do_process_instruction_dups( mint_to(&program_id, &mint_key, &account4_key, &owner_key, &[], 1000).unwrap(), vec![mint_info.clone(), account4_info.clone(), owner_info.clone()], &[Check::success()], ); // source-multisig-signer transfer do_process_instruction_dups( #[allow(deprecated)] transfer( &program_id, &account4_key, &account2_key, &multisig_key, &[&account4_key], 500, ) .unwrap(), vec![ account4_info.clone(), account2_info.clone(), multisig_info.clone(), account4_info.clone(), ], &[Check::success()], ); // source-multisig-signer TransferChecked do_process_instruction_dups( transfer_checked( &program_id, &account4_key, &mint_key, &account2_key, &multisig_key, &[&account4_key], 500, 2, ) .unwrap(), vec![ account4_info.clone(), mint_info.clone(), account2_info.clone(), multisig_info.clone(), account4_info.clone(), ], &[Check::success()], ); } #[test] fn test_transfer() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let delegate_key = Address::new_unique(); let mut delegate_account = SolanaAccount::default(); let mismatch_key = Address::new_unique(); let mut mismatch_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint2_key = Address::new_unique(); let mut rent_sysvar = rent_sysvar(); // create mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(), vec![ &mut account2_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(), vec![ &mut account3_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create mismatch account do_process_instruction( initialize_account(&program_id, &mismatch_key, &mint_key, &owner_key).unwrap(), vec![ &mut mismatch_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); let mut account = Account::unpack_unchecked(&mismatch_account.data).unwrap(); account.mint = mint2_key; Account::pack(account, &mut mismatch_account.data).unwrap(); // mint to account do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::success()], ); // missing signer #[allow(deprecated)] let mut instruction = transfer( &program_id, &account_key, &account2_key, &owner_key, &[], 1000, ) .unwrap(); instruction.accounts[2].is_signer = false; do_process_instruction( instruction, vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::err(ProgramError::MissingRequiredSignature)], ); // mismatch mint do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &mismatch_key, &owner_key, &[], 1000, ) .unwrap(), vec![ &mut account_account, &mut mismatch_account, &mut owner_account, ], &[Check::err(TokenError::MintMismatch.into())], ); // missing owner do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &owner2_key, &[], 1000, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner2_account, ], &[Check::err(TokenError::OwnerMismatch.into())], ); // account not owned by program let not_program_id = Address::new_unique(); account_account.owner = not_program_id; do_process_instruction( #[allow(deprecated)] transfer(&program_id, &account_key, &account2_key, &owner_key, &[], 0).unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner2_account, ], &[Check::err(ProgramError::IncorrectProgramId)], ); account_account.owner = program_id; // account 2 not owned by program let not_program_id = Address::new_unique(); account2_account.owner = not_program_id; do_process_instruction( #[allow(deprecated)] transfer(&program_id, &account_key, &account2_key, &owner_key, &[], 0).unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner2_account, ], &[Check::err(ProgramError::IncorrectProgramId)], ); account2_account.owner = program_id; // transfer do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &owner_key, &[], 1000, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::success()], ); // insufficient funds do_process_instruction( #[allow(deprecated)] transfer(&program_id, &account_key, &account2_key, &owner_key, &[], 1).unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::err(TokenError::InsufficientFunds.into())], ); // transfer half back do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account2_key, &account_key, &owner_key, &[], 500, ) .unwrap(), vec![ &mut account2_account, &mut account_account, &mut owner_account, ], &[Check::success()], ); // incorrect decimals do_process_instruction( transfer_checked( &program_id, &account2_key, &mint_key, &account_key, &owner_key, &[], 1, 10, // <-- incorrect decimals ) .unwrap(), vec![ &mut account2_account, &mut mint_account, &mut account_account, &mut owner_account, ], &[Check::err(TokenError::MintDecimalsMismatch.into())], ); // incorrect mint do_process_instruction( transfer_checked( &program_id, &account2_key, &account3_key, // <-- incorrect mint &account_key, &owner_key, &[], 1, 2, ) .unwrap(), vec![ &mut account2_account, &mut account3_account, // <-- incorrect mint &mut account_account, &mut owner_account, ], &[Check::err(TokenError::MintMismatch.into())], ); // transfer rest with explicit decimals do_process_instruction( transfer_checked( &program_id, &account2_key, &mint_key, &account_key, &owner_key, &[], 500, 2, ) .unwrap(), vec![ &mut account2_account, &mut mint_account, &mut account_account, &mut owner_account, ], &[Check::success()], ); // insufficient funds do_process_instruction( #[allow(deprecated)] transfer(&program_id, &account2_key, &account_key, &owner_key, &[], 1).unwrap(), vec![ &mut account2_account, &mut account_account, &mut owner_account, ], &[Check::err(TokenError::InsufficientFunds.into())], ); // approve delegate do_process_instruction( approve( &program_id, &account_key, &delegate_key, &owner_key, &[], 100, ) .unwrap(), vec![ &mut account_account, &mut delegate_account, &mut owner_account, ], &[Check::success()], ); // not a delegate of source account do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &owner2_key, // <-- incorrect owner or delegate &[], 1, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner2_account, ], &[Check::err(TokenError::OwnerMismatch.into())], ); // insufficient funds approved via delegate do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &delegate_key, &[], 101, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut delegate_account, ], &[Check::err(TokenError::InsufficientFunds.into())], ); // transfer via delegate do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &delegate_key, &[], 100, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut delegate_account, ], &[Check::success()], ); // insufficient funds approved via delegate do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &delegate_key, &[], 1, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut delegate_account, ], &[Check::err(TokenError::OwnerMismatch.into())], ); // transfer rest do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &owner_key, &[], 900, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::success()], ); // approve delegate do_process_instruction( approve( &program_id, &account_key, &delegate_key, &owner_key, &[], 100, ) .unwrap(), vec![ &mut account_account, &mut delegate_account, &mut owner_account, ], &[Check::success()], ); // insufficient funds in source account via delegate do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &delegate_key, &[], 100, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut delegate_account, ], &[Check::err(TokenError::InsufficientFunds.into())], ); } #[test] fn test_self_transfer() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let delegate_key = Address::new_unique(); let mut delegate_account = SolanaAccount::default(); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(), vec![ &mut account2_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(), vec![ &mut account3_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // mint to account do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::success()], ); let account_info = (&account_key, false, &mut account_account).into_account_info(); let account3_info = (&account3_key, false, &mut account3_account).into_account_info(); let delegate_info = (&delegate_key, true, &mut delegate_account).into_account_info(); let owner_info = (&owner_key, true, &mut owner_account).into_account_info(); let owner2_info = (&owner2_key, true, &mut owner2_account).into_account_info(); let mint_info = (&mint_key, false, &mut mint_account).into_account_info(); // transfer #[allow(deprecated)] let instruction = transfer( &program_id, account_info.key, account_info.key, owner_info.key, &[], 1000, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), owner_info.clone(), ], &[Check::success()], ); // no balance change... let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap(); assert_eq!(account.amount, 1000); // transfer checked let instruction = transfer_checked( &program_id, account_info.key, mint_info.key, account_info.key, owner_info.key, &[], 1000, 2, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), mint_info.clone(), account_info.clone(), owner_info.clone(), ], &[Check::success()], ); // no balance change... let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap(); assert_eq!(account.amount, 1000); // missing signer let mut owner_no_sign_info = owner_info.clone(); #[allow(deprecated)] let mut instruction = transfer( &program_id, account_info.key, account_info.key, owner_no_sign_info.key, &[], 1000, ) .unwrap(); instruction.accounts[2].is_signer = false; owner_no_sign_info.is_signer = false; do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), owner_no_sign_info.clone(), ], &[Check::err(ProgramError::MissingRequiredSignature)], ); // missing signer checked let mut instruction = transfer_checked( &program_id, account_info.key, mint_info.key, account_info.key, owner_no_sign_info.key, &[], 1000, 2, ) .unwrap(); instruction.accounts[3].is_signer = false; do_process_instruction_dups( instruction, vec![ account_info.clone(), mint_info.clone(), account_info.clone(), owner_no_sign_info, ], &[Check::err(ProgramError::MissingRequiredSignature)], ); // missing owner #[allow(deprecated)] let instruction = transfer( &program_id, account_info.key, account_info.key, owner2_info.key, &[], 1000, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), owner2_info.clone(), ], &[Check::err(TokenError::OwnerMismatch.into())], ); // missing owner checked let instruction = transfer_checked( &program_id, account_info.key, mint_info.key, account_info.key, owner2_info.key, &[], 1000, 2, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), mint_info.clone(), account_info.clone(), owner2_info.clone(), ], &[Check::err(TokenError::OwnerMismatch.into())], ); // insufficient funds #[allow(deprecated)] let instruction = transfer( &program_id, account_info.key, account_info.key, owner_info.key, &[], 1001, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), owner_info.clone(), ], &[Check::err(TokenError::InsufficientFunds.into())], ); // insufficient funds checked let instruction = transfer_checked( &program_id, account_info.key, mint_info.key, account_info.key, owner_info.key, &[], 1001, 2, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), mint_info.clone(), account_info.clone(), owner_info.clone(), ], &[Check::err(TokenError::InsufficientFunds.into())], ); // incorrect decimals let instruction = transfer_checked( &program_id, account_info.key, mint_info.key, account_info.key, owner_info.key, &[], 1, 10, // <-- incorrect decimals ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), mint_info.clone(), account_info.clone(), owner_info.clone(), ], &[Check::err(TokenError::MintDecimalsMismatch.into())], ); // incorrect mint let instruction = transfer_checked( &program_id, account_info.key, account3_info.key, // <-- incorrect mint account_info.key, owner_info.key, &[], 1, 2, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account3_info.clone(), // <-- incorrect mint account_info.clone(), owner_info.clone(), ], &[Check::err(TokenError::MintMismatch.into())], ); // approve delegate let instruction = approve( &program_id, account_info.key, delegate_info.key, owner_info.key, &[], 100, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), delegate_info.clone(), owner_info.clone(), ], &[Check::success()], ); // delegate transfer #[allow(deprecated)] let instruction = transfer( &program_id, account_info.key, account_info.key, delegate_info.key, &[], 100, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), delegate_info.clone(), ], &[Check::success()], ); // no balance change... let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap(); assert_eq!(account.amount, 1000); assert_eq!(account.delegated_amount, 100); // delegate transfer checked let instruction = transfer_checked( &program_id, account_info.key, mint_info.key, account_info.key, delegate_info.key, &[], 100, 2, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), mint_info.clone(), account_info.clone(), delegate_info.clone(), ], &[Check::success()], ); // no balance change... let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap(); assert_eq!(account.amount, 1000); assert_eq!(account.delegated_amount, 100); // delegate insufficient funds #[allow(deprecated)] let instruction = transfer( &program_id, account_info.key, account_info.key, delegate_info.key, &[], 101, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), delegate_info.clone(), ], &[Check::err(TokenError::InsufficientFunds.into())], ); // delegate insufficient funds checked let instruction = transfer_checked( &program_id, account_info.key, mint_info.key, account_info.key, delegate_info.key, &[], 101, 2, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), mint_info.clone(), account_info.clone(), delegate_info.clone(), ], &[Check::err(TokenError::InsufficientFunds.into())], ); // owner transfer with delegate assigned #[allow(deprecated)] let instruction = transfer( &program_id, account_info.key, account_info.key, owner_info.key, &[], 1000, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), owner_info.clone(), ], &[Check::success()], ); // no balance change... let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap(); assert_eq!(account.amount, 1000); // owner transfer with delegate assigned checked let instruction = transfer_checked( &program_id, account_info.key, mint_info.key, account_info.key, owner_info.key, &[], 1000, 2, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), mint_info.clone(), account_info.clone(), owner_info.clone(), ], &[Check::success()], ); // no balance change... let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap(); assert_eq!(account.amount, 1000); } #[test] fn test_unwrap_lamports_dups() { let program_id = crate::id(); let account1_key = Address::new_unique(); let mut account1_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mut account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into(); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mut account2_info: AccountInfo = (&account2_key, false, &mut account2_account).into(); let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account3_info: AccountInfo = (&account3_key, false, &mut account3_account).into(); let account4_key = Address::new_unique(); let mut account4_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account4_info: AccountInfo = (&account4_key, true, &mut account4_account).into(); let multisig_key = Address::new_unique(); let mut multisig_account = SolanaAccount::new( multisig_minimum_balance(), Multisig::get_packed_len(), &program_id, ); let multisig_info: AccountInfo = (&multisig_key, true, &mut multisig_account).into(); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into(); let mint_key = native_mint::id(); let mut mint_account = native_mint(); let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); // create account do_process_instruction_dups( initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), rent_info.clone(), ], &[Check::success()], ); // create another account do_process_instruction_dups( initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(), vec![ account2_info.clone(), mint_info.clone(), owner_info.clone(), rent_info.clone(), ], &[Check::success()], ); // mint to account native_mint_to(&account1_info, 1000).unwrap(); // source-owner unwrap lamports do_process_instruction_dups( unwrap_lamports( &program_id, &account1_key, &account2_key, &account1_key, &[], Some(500), ) .unwrap(), vec![ account1_info.clone(), account2_info.clone(), account1_info.clone(), ], &[Check::success()], ); // test destination-owner unwrap lamports do_process_instruction_dups( initialize_account(&program_id, &account3_key, &mint_key, &account2_key).unwrap(), vec![ account3_info.clone(), mint_info.clone(), account2_info.clone(), rent_info.clone(), ], &[Check::success()], ); native_mint_to(&account3_info, 1000).unwrap(); account1_info.is_signer = false; account2_info.is_signer = true; do_process_instruction_dups( unwrap_lamports( &program_id, &account3_key, &account2_key, &account2_key, &[], Some(500), ) .unwrap(), vec![ account3_info.clone(), account2_info.clone(), account2_info.clone(), ], &[Check::success()], ); // test source-multisig signer do_process_instruction_dups( initialize_multisig(&program_id, &multisig_key, &[&account4_key], 1).unwrap(), vec![ multisig_info.clone(), rent_info.clone(), account4_info.clone(), ], &[Check::success()], ); do_process_instruction_dups( initialize_account(&program_id, &account4_key, &mint_key, &multisig_key).unwrap(), vec![ account4_info.clone(), mint_info.clone(), multisig_info.clone(), rent_info.clone(), ], &[Check::success()], ); native_mint_to(&account4_info, 1000).unwrap(); // source-multisig-signer unwrap lamports do_process_instruction_dups( unwrap_lamports( &program_id, &account4_key, &account2_key, &multisig_key, &[&account4_key], Some(500), ) .unwrap(), vec![ account4_info.clone(), account2_info.clone(), multisig_info.clone(), account4_info.clone(), ], &[Check::success()], ); } #[test] fn test_unwrap_lamports() { let program_id = crate::id(); let zero_space_rent_exempt_balance = Rent::default().minimum_balance(0); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( zero_space_rent_exempt_balance, Account::get_packed_len(), &program_id, ); let mismatch_account_key = Address::new_unique(); let mut mismatch_account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let mint_key = native_mint::id(); let mut mint_account = native_mint(); let mismatch_mint_key = Address::new_unique(); let mut mismatch_mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create mismatch mint do_process_instruction( initialize_mint(&program_id, &mismatch_mint_key, &owner_key, None, 2).unwrap(), vec![&mut mismatch_mint_account, &mut rent_sysvar], &[Check::success()], ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create mismatch account do_process_instruction( initialize_account( &program_id, &mismatch_account_key, &mismatch_mint_key, &owner_key, ) .unwrap(), vec![ &mut mismatch_account_account, &mut mismatch_mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // mint to account let account_info = (&account_key, false, &mut account_account).into(); native_mint_to(&account_info, 1000).unwrap(); // missing signer let mut instruction = unwrap_lamports( &program_id, &account_key, &account2_key, &owner_key, &[], Some(1000), ) .unwrap(); instruction.accounts[2].is_signer = false; do_process_instruction( instruction, vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::err(ProgramError::MissingRequiredSignature)], ); // non native mint do_process_instruction( unwrap_lamports( &program_id, &mismatch_account_key, &account_key, &owner_key, &[], None, ) .unwrap(), vec![ &mut mismatch_account_account, &mut account_account, &mut owner_account, ], &[Check::err(TokenError::NonNativeNotSupported.into())], ); // missing owner do_process_instruction( unwrap_lamports( &program_id, &account_key, &account2_key, &owner2_key, &[], Some(1000), ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner2_account, ], &[Check::err(TokenError::OwnerMismatch.into())], ); // account not owned by program let not_program_id = Address::new_unique(); account_account.owner = not_program_id; do_process_instruction( unwrap_lamports( &program_id, &account_key, &account2_key, &owner_key, &[], Some(0), ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner2_account, ], &[Check::err(ProgramError::IncorrectProgramId)], ); account_account.owner = program_id; // unwrap Some(500) lamports do_process_instruction( unwrap_lamports( &program_id, &account_key, &account2_key, &owner_key, &[], Some(500), ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::success()], ); // 500 amount balance change... let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, 500); // 500 lamports balance change... assert_eq!(account_account.lamports(), 500 + account_minimum_balance()); assert_eq!( account2_account.lamports(), zero_space_rent_exempt_balance + 500 ); // insufficient funds do_process_instruction( unwrap_lamports( &program_id, &account_key, &account2_key, &owner_key, &[], Some(501), ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::err(TokenError::InsufficientFunds.into())], ); // unwrap None lamports do_process_instruction( unwrap_lamports( &program_id, &account_key, &account2_key, &owner_key, &[], None, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::success()], ); // 500 amount balance change... let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, 0); // 500 lamports balance change... assert_eq!(account_account.lamports(), account_minimum_balance()); assert_eq!( account2_account.lamports(), zero_space_rent_exempt_balance + 500 + 500 ); } #[test] fn test_self_unwrap_lamports() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mismatch_account_key = Address::new_unique(); let mut mismatch_account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let mint_key = native_mint::id(); let mut mint_account = native_mint(); let mismatch_mint_key = Address::new_unique(); let mut mismatch_mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create mismatch mint do_process_instruction( initialize_mint(&program_id, &mismatch_mint_key, &owner_key, None, 2).unwrap(), vec![&mut mismatch_mint_account, &mut rent_sysvar], &[Check::success()], ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create mismatch account do_process_instruction( initialize_account( &program_id, &mismatch_account_key, &mismatch_mint_key, &owner_key, ) .unwrap(), vec![ &mut mismatch_account_account, &mut mismatch_mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); let account_info = (&account_key, false, &mut account_account).into_account_info(); let mismatch_account_info = (&mismatch_account_key, false, &mut mismatch_account_account).into_account_info(); let owner_info = (&owner_key, true, &mut owner_account).into_account_info(); let owner2_info = (&owner2_key, true, &mut owner2_account).into_account_info(); // mint to account native_mint_to(&account_info, 1000).unwrap(); // unwrap Some(500) lamports let instruction = unwrap_lamports( &program_id, account_info.key, account_info.key, owner_info.key, &[], Some(500), ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), owner_info.clone(), ], &[Check::success()], ); // 500 amount balance change... let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap(); assert_eq!(account.amount, 500); // no lamport balance change... assert_eq!(account_info.lamports(), 1000 + account_minimum_balance()); // insufficient funds let instruction = unwrap_lamports( &program_id, account_info.key, account_info.key, owner_info.key, &[], Some(501), ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), owner_info.clone(), ], &[Check::err(TokenError::InsufficientFunds.into())], ); // missing signer let mut owner_no_sign_info = owner_info.clone(); let mut instruction = unwrap_lamports( &program_id, account_info.key, account_info.key, owner_no_sign_info.key, &[], Some(500), ) .unwrap(); instruction.accounts[2].is_signer = false; owner_no_sign_info.is_signer = false; do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), owner_no_sign_info.clone(), ], &[Check::err(ProgramError::MissingRequiredSignature)], ); // non native mint let instruction = unwrap_lamports( &program_id, mismatch_account_info.key, mismatch_account_info.key, owner_info.key, &[], None, ) .unwrap(); do_process_instruction_dups( instruction, vec![ mismatch_account_info.clone(), mismatch_account_info.clone(), owner_info.clone(), ], &[Check::err(TokenError::NonNativeNotSupported.into())], ); // missing owner let instruction = unwrap_lamports( &program_id, account_info.key, account_info.key, owner2_info.key, &[], Some(500), ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), owner2_info.clone(), ], &[Check::err(TokenError::OwnerMismatch.into())], ); // unwrap None lamports let instruction = unwrap_lamports( &program_id, account_info.key, account_info.key, owner_info.key, &[], None, ) .unwrap(); do_process_instruction_dups( instruction, vec![ account_info.clone(), account_info.clone(), owner_info.clone(), ], &[Check::success()], ); // 500 amount balance change... let account = Account::unpack_unchecked(&account_info.try_borrow_data().unwrap()).unwrap(); assert_eq!(account.amount, 0); // no lamport balance change... assert_eq!(account_info.lamports(), 1000 + account_minimum_balance()); } #[test] fn test_mintable_token_with_zero_supply() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create mint-able token with zero supply let decimals = 2; do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, decimals).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); let mint = Mint::unpack_unchecked(&mint_account.data).unwrap(); assert_eq!( mint, Mint { mint_authority: COption::Some(owner_key), supply: 0, decimals, is_initialized: true, freeze_authority: COption::None, } ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // mint to do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 42).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::success()], ); let _ = Mint::unpack(&mint_account.data).unwrap(); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, 42); // mint to 2, with incorrect decimals do_process_instruction( mint_to_checked( &program_id, &mint_key, &account_key, &owner_key, &[], 42, decimals + 1, ) .unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::err(TokenError::MintDecimalsMismatch.into())], ); let _ = Mint::unpack(&mint_account.data).unwrap(); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, 42); // mint to 2 do_process_instruction( mint_to_checked( &program_id, &mint_key, &account_key, &owner_key, &[], 42, decimals, ) .unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::success()], ); let _ = Mint::unpack(&mint_account.data).unwrap(); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, 84); } #[test] fn test_approve_dups() { let program_id = crate::id(); let account1_key = Address::new_unique(); let mut account1_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into(); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_info: AccountInfo = (&account2_key, false, &mut account2_account).into(); let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account3_info: AccountInfo = (&account3_key, true, &mut account3_account).into(); let multisig_key = Address::new_unique(); let mut multisig_account = SolanaAccount::new( multisig_minimum_balance(), Multisig::get_packed_len(), &program_id, ); let multisig_info: AccountInfo = (&multisig_key, true, &mut multisig_account).into(); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); // create mint do_process_instruction_dups( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![mint_info.clone(), rent_info.clone()], &[Check::success()], ); // create account do_process_instruction_dups( initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), rent_info.clone(), ], &[Check::success()], ); // create another account do_process_instruction_dups( initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(), vec![ account2_info.clone(), mint_info.clone(), owner_info.clone(), rent_info.clone(), ], &[Check::success()], ); // mint to account do_process_instruction_dups( mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(), vec![mint_info.clone(), account1_info.clone(), owner_info.clone()], &[Check::success()], ); // source-owner approve do_process_instruction_dups( approve( &program_id, &account1_key, &account2_key, &account1_key, &[], 500, ) .unwrap(), vec![ account1_info.clone(), account2_info.clone(), account1_info.clone(), ], &[Check::success()], ); // source-owner approve_checked do_process_instruction_dups( approve_checked( &program_id, &account1_key, &mint_key, &account2_key, &account1_key, &[], 500, 2, ) .unwrap(), vec![ account1_info.clone(), mint_info.clone(), account2_info.clone(), account1_info.clone(), ], &[Check::success()], ); // source-owner revoke do_process_instruction_dups( revoke(&program_id, &account1_key, &account1_key, &[]).unwrap(), vec![account1_info.clone(), account1_info.clone()], &[Check::success()], ); // test source-multisig signer do_process_instruction_dups( initialize_multisig(&program_id, &multisig_key, &[&account3_key], 1).unwrap(), vec![ multisig_info.clone(), rent_info.clone(), account3_info.clone(), ], &[Check::success()], ); do_process_instruction_dups( initialize_account(&program_id, &account3_key, &mint_key, &multisig_key).unwrap(), vec![ account3_info.clone(), mint_info.clone(), multisig_info.clone(), rent_info.clone(), ], &[Check::success()], ); do_process_instruction_dups( mint_to(&program_id, &mint_key, &account3_key, &owner_key, &[], 1000).unwrap(), vec![mint_info.clone(), account3_info.clone(), owner_info.clone()], &[Check::success()], ); // source-multisig-signer approve do_process_instruction_dups( approve( &program_id, &account3_key, &account2_key, &multisig_key, &[&account3_key], 500, ) .unwrap(), vec![ account3_info.clone(), account2_info.clone(), multisig_info.clone(), account3_info.clone(), ], &[Check::success()], ); // source-multisig-signer approve_checked do_process_instruction_dups( approve_checked( &program_id, &account3_key, &mint_key, &account2_key, &multisig_key, &[&account3_key], 500, 2, ) .unwrap(), vec![ account3_info.clone(), mint_info.clone(), account2_info.clone(), multisig_info.clone(), account3_info.clone(), ], &[Check::success()], ); // source-owner multisig-signer do_process_instruction_dups( revoke(&program_id, &account3_key, &multisig_key, &[&account3_key]).unwrap(), vec![ account3_info.clone(), multisig_info.clone(), account3_info.clone(), ], &[Check::success()], ); // approve to source do_process_instruction_dups( approve_checked( &program_id, &account2_key, &mint_key, &account2_key, &owner_key, &[], 500, 2, ) .unwrap(), vec![ account2_info.clone(), mint_info.clone(), account2_info.clone(), owner_info.clone(), ], &[Check::success()], ); // source-delegate revoke, force account2 to be a signer let account2_info: AccountInfo = (&account2_key, true, &mut account2_account).into(); do_process_instruction_dups( revoke(&program_id, &account2_key, &account2_key, &[]).unwrap(), vec![account2_info.clone(), account2_info.clone()], &[Check::success()], ); } #[test] fn test_approve() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let delegate_key = Address::new_unique(); let mut delegate_account = SolanaAccount::default(); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(), vec![ &mut account2_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // mint to account do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::success()], ); // missing signer let mut instruction = approve( &program_id, &account_key, &delegate_key, &owner_key, &[], 100, ) .unwrap(); instruction.accounts[2].is_signer = false; do_process_instruction( instruction, vec![ &mut account_account, &mut delegate_account, &mut owner_account, ], &[Check::err(ProgramError::MissingRequiredSignature)], ); // no owner do_process_instruction( approve( &program_id, &account_key, &delegate_key, &owner2_key, &[], 100, ) .unwrap(), vec![ &mut account_account, &mut delegate_account, &mut owner2_account, ], &[Check::err(TokenError::OwnerMismatch.into())], ); // approve delegate do_process_instruction( approve( &program_id, &account_key, &delegate_key, &owner_key, &[], 100, ) .unwrap(), vec![ &mut account_account, &mut delegate_account, &mut owner_account, ], &[Check::success()], ); // approve delegate 2, with incorrect decimals do_process_instruction( approve_checked( &program_id, &account_key, &mint_key, &delegate_key, &owner_key, &[], 100, 0, // <-- incorrect decimals ) .unwrap(), vec![ &mut account_account, &mut mint_account, &mut delegate_account, &mut owner_account, ], &[Check::err(TokenError::MintDecimalsMismatch.into())], ); // approve delegate 2, with incorrect mint do_process_instruction( approve_checked( &program_id, &account_key, &account2_key, // <-- bad mint &delegate_key, &owner_key, &[], 100, 0, ) .unwrap(), vec![ &mut account_account, &mut account2_account, // <-- bad mint &mut delegate_account, &mut owner_account, ], &[Check::err(TokenError::MintMismatch.into())], ); // approve delegate 2 do_process_instruction( approve_checked( &program_id, &account_key, &mint_key, &delegate_key, &owner_key, &[], 100, 2, ) .unwrap(), vec![ &mut account_account, &mut mint_account, &mut delegate_account, &mut owner_account, ], &[Check::success()], ); // revoke delegate do_process_instruction( revoke(&program_id, &account_key, &owner_key, &[]).unwrap(), vec![&mut account_account, &mut owner_account], &[Check::success()], ); // approve delegate 3 do_process_instruction( approve_checked( &program_id, &account_key, &mint_key, &delegate_key, &owner_key, &[], 100, 2, ) .unwrap(), vec![ &mut account_account, &mut mint_account, &mut delegate_account, &mut owner_account, ], &[Check::success()], ); // revoke by delegate do_process_instruction( revoke(&program_id, &account_key, &delegate_key, &[]).unwrap(), vec![&mut account_account, &mut delegate_account], &[Check::success()], ); // fails the second time do_process_instruction( revoke(&program_id, &account_key, &delegate_key, &[]).unwrap(), vec![&mut account_account, &mut delegate_account], &[Check::err(TokenError::OwnerMismatch.into())], ); } #[test] fn test_set_authority_dups() { let program_id = crate::id(); let account1_key = Address::new_unique(); let mut account1_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into(); let owner_key = Address::new_unique(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); // create mint do_process_instruction_dups( initialize_mint(&program_id, &mint_key, &mint_key, Some(&mint_key), 2).unwrap(), vec![mint_info.clone(), rent_info.clone()], &[Check::success()], ); // create account do_process_instruction_dups( initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), rent_info.clone(), ], &[Check::success()], ); // set mint_authority when currently self do_process_instruction_dups( set_authority( &program_id, &mint_key, Some(&owner_key), AuthorityType::MintTokens, &mint_key, &[], ) .unwrap(), vec![mint_info.clone(), mint_info.clone()], &[Check::success()], ); // set freeze_authority when currently self do_process_instruction_dups( set_authority( &program_id, &mint_key, Some(&owner_key), AuthorityType::FreezeAccount, &mint_key, &[], ) .unwrap(), vec![mint_info.clone(), mint_info.clone()], &[Check::success()], ); // set account owner when currently self do_process_instruction_dups( set_authority( &program_id, &account1_key, Some(&owner_key), AuthorityType::AccountOwner, &account1_key, &[], ) .unwrap(), vec![account1_info.clone(), account1_info.clone()], &[Check::success()], ); // set close_authority when currently self let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap(); account.close_authority = COption::Some(account1_key); Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap(); do_process_instruction_dups( set_authority( &program_id, &account1_key, Some(&owner_key), AuthorityType::CloseAccount, &account1_key, &[], ) .unwrap(), vec![account1_info.clone(), account1_info.clone()], &[Check::success()], ); } #[test] fn test_set_authority() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let owner3_key = Address::new_unique(); let mut owner3_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint2_key = Address::new_unique(); let mut mint2_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create new mint with owner do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create mint with owner and freeze_authority do_process_instruction( initialize_mint(&program_id, &mint2_key, &owner_key, Some(&owner_key), 2).unwrap(), vec![&mut mint2_account, &mut rent_sysvar], &[Check::success()], ); // invalid account do_process_instruction( set_authority( &program_id, &account_key, Some(&owner2_key), AuthorityType::AccountOwner, &owner_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner_account], &[Check::err(ProgramError::InvalidAccountData)], ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account2_key, &mint2_key, &owner_key).unwrap(), vec![ &mut account2_account, &mut mint2_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // missing owner do_process_instruction( set_authority( &program_id, &account_key, Some(&owner_key), AuthorityType::AccountOwner, &owner2_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner2_account], &[Check::err(TokenError::OwnerMismatch.into())], ); // owner did not sign let mut instruction = set_authority( &program_id, &account_key, Some(&owner2_key), AuthorityType::AccountOwner, &owner_key, &[], ) .unwrap(); instruction.accounts[1].is_signer = false; do_process_instruction( instruction, vec![&mut account_account, &mut owner_account], &[Check::err(ProgramError::MissingRequiredSignature)], ); // wrong authority type do_process_instruction( set_authority( &program_id, &account_key, Some(&owner2_key), AuthorityType::FreezeAccount, &owner_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner_account], &[Check::err(TokenError::AuthorityTypeNotSupported.into())], ); // account owner may not be set to None do_process_instruction( set_authority( &program_id, &account_key, None, AuthorityType::AccountOwner, &owner_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner_account], &[Check::err(TokenError::InvalidInstruction.into())], ); // set delegate do_process_instruction( approve( &program_id, &account_key, &owner2_key, &owner_key, &[], u64::MAX, ) .unwrap(), vec![ &mut account_account, &mut owner2_account, &mut owner_account, ], &[Check::success()], ); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.delegate, COption::Some(owner2_key)); assert_eq!(account.delegated_amount, u64::MAX); // set owner do_process_instruction( set_authority( &program_id, &account_key, Some(&owner3_key), AuthorityType::AccountOwner, &owner_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner_account], &[Check::success()], ); // check delegate cleared let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.delegate, COption::None); assert_eq!(account.delegated_amount, 0); // set owner without existing delegate do_process_instruction( set_authority( &program_id, &account_key, Some(&owner2_key), AuthorityType::AccountOwner, &owner3_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner3_account], &[Check::success()], ); // set close_authority do_process_instruction( set_authority( &program_id, &account_key, Some(&owner2_key), AuthorityType::CloseAccount, &owner2_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner2_account], &[Check::success()], ); // close_authority may be set to None do_process_instruction( set_authority( &program_id, &account_key, None, AuthorityType::CloseAccount, &owner2_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner2_account], &[Check::success()], ); // wrong owner do_process_instruction( set_authority( &program_id, &mint_key, Some(&owner3_key), AuthorityType::MintTokens, &owner2_key, &[], ) .unwrap(), vec![&mut mint_account, &mut owner2_account], &[Check::err(TokenError::OwnerMismatch.into())], ); // owner did not sign let mut instruction = set_authority( &program_id, &mint_key, Some(&owner2_key), AuthorityType::MintTokens, &owner_key, &[], ) .unwrap(); instruction.accounts[1].is_signer = false; do_process_instruction( instruction, vec![&mut mint_account, &mut owner_account], &[Check::err(ProgramError::MissingRequiredSignature)], ); // cannot freeze do_process_instruction( set_authority( &program_id, &mint_key, Some(&owner2_key), AuthorityType::FreezeAccount, &owner_key, &[], ) .unwrap(), vec![&mut mint_account, &mut owner_account], &[Check::err(TokenError::MintCannotFreeze.into())], ); // set owner do_process_instruction( set_authority( &program_id, &mint_key, Some(&owner2_key), AuthorityType::MintTokens, &owner_key, &[], ) .unwrap(), vec![&mut mint_account, &mut owner_account], &[Check::success()], ); // set owner to None do_process_instruction( set_authority( &program_id, &mint_key, None, AuthorityType::MintTokens, &owner2_key, &[], ) .unwrap(), vec![&mut mint_account, &mut owner2_account], &[Check::success()], ); // test unsetting mint_authority is one-way operation do_process_instruction( set_authority( &program_id, &mint2_key, Some(&owner2_key), AuthorityType::MintTokens, &owner_key, &[], ) .unwrap(), vec![&mut mint_account, &mut owner_account], &[Check::err(TokenError::FixedSupply.into())], ); // set freeze_authority do_process_instruction( set_authority( &program_id, &mint2_key, Some(&owner2_key), AuthorityType::FreezeAccount, &owner_key, &[], ) .unwrap(), vec![&mut mint2_account, &mut owner_account], &[Check::success()], ); // test unsetting freeze_authority is one-way operation do_process_instruction( set_authority( &program_id, &mint2_key, None, AuthorityType::FreezeAccount, &owner2_key, &[], ) .unwrap(), vec![&mut mint2_account, &mut owner2_account], &[Check::success()], ); do_process_instruction( set_authority( &program_id, &mint2_key, Some(&owner2_key), AuthorityType::FreezeAccount, &owner_key, &[], ) .unwrap(), vec![&mut mint2_account, &mut owner2_account], &[Check::err(TokenError::MintCannotFreeze.into())], ); } #[test] fn test_set_authority_with_immutable_owner_extension() { let program_id = crate::id(); let account_key = Address::new_unique(); let account_len = ExtensionType::try_calculate_account_len::(&[ExtensionType::ImmutableOwner]) .unwrap(); let mut account_account = SolanaAccount::new( Rent::default().minimum_balance(account_len), account_len, &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create account do_process_instruction( initialize_immutable_owner(&program_id, &account_key).unwrap(), vec![&mut account_account], &[Check::success()], ); do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // Immutable Owner extension blocks account owner authority changes do_process_instruction( set_authority( &program_id, &account_key, Some(&owner2_key), AuthorityType::AccountOwner, &owner_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner_account], &[Check::err(TokenError::ImmutableOwner.into())], ); } #[test] fn test_mint_to_dups() { let program_id = crate::id(); let account1_key = Address::new_unique(); let mut account1_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into(); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); // create mint do_process_instruction_dups( initialize_mint(&program_id, &mint_key, &mint_key, None, 2).unwrap(), vec![mint_info.clone(), rent_info.clone()], &[Check::success()], ); // create account do_process_instruction_dups( initialize_account(&program_id, &account1_key, &mint_key, &owner_key).unwrap(), vec![ account1_info.clone(), mint_info.clone(), owner_info.clone(), rent_info.clone(), ], &[Check::success()], ); // mint_to when mint_authority is self do_process_instruction_dups( mint_to(&program_id, &mint_key, &account1_key, &mint_key, &[], 42).unwrap(), vec![mint_info.clone(), account1_info.clone(), mint_info.clone()], &[Check::success()], ); // mint_to_checked when mint_authority is self do_process_instruction_dups( mint_to_checked(&program_id, &mint_key, &account1_key, &mint_key, &[], 42, 2).unwrap(), vec![mint_info.clone(), account1_info.clone(), mint_info.clone()], &[Check::success()], ); // mint_to when mint_authority is account owner let mut mint = Mint::unpack_unchecked(&mint_info.data.borrow()).unwrap(); mint.mint_authority = COption::Some(account1_key); Mint::pack(mint, &mut mint_info.data.borrow_mut()).unwrap(); do_process_instruction_dups( mint_to( &program_id, &mint_key, &account1_key, &account1_key, &[], 42, ) .unwrap(), vec![ mint_info.clone(), account1_info.clone(), account1_info.clone(), ], &[Check::success()], ); // mint_to_checked when mint_authority is account owner do_process_instruction_dups( mint_to( &program_id, &mint_key, &account1_key, &account1_key, &[], 42, ) .unwrap(), vec![ mint_info.clone(), account1_info.clone(), account1_info.clone(), ], &[Check::success()], ); } #[test] fn test_mint_to() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mismatch_key = Address::new_unique(); let mut mismatch_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint2_key = Address::new_unique(); let uninitialized_key = Address::new_unique(); let mut uninitialized_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mut rent_sysvar = rent_sysvar(); // create new mint with owner do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(), vec![ &mut account2_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(), vec![ &mut account3_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create mismatch account do_process_instruction( initialize_account(&program_id, &mismatch_key, &mint_key, &owner_key).unwrap(), vec![ &mut mismatch_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); let mut account = Account::unpack_unchecked(&mismatch_account.data).unwrap(); account.mint = mint2_key; Account::pack(account, &mut mismatch_account.data).unwrap(); // mint to do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 42).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::success()], ); let mint = Mint::unpack_unchecked(&mint_account.data).unwrap(); assert_eq!(mint.supply, 42); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, 42); // mint to another account to test supply accumulation do_process_instruction( mint_to(&program_id, &mint_key, &account2_key, &owner_key, &[], 42).unwrap(), vec![&mut mint_account, &mut account2_account, &mut owner_account], &[Check::success()], ); let mint = Mint::unpack_unchecked(&mint_account.data).unwrap(); assert_eq!(mint.supply, 84); let account = Account::unpack_unchecked(&account2_account.data).unwrap(); assert_eq!(account.amount, 42); // missing signer let mut instruction = mint_to(&program_id, &mint_key, &account2_key, &owner_key, &[], 42).unwrap(); instruction.accounts[2].is_signer = false; do_process_instruction( instruction, vec![&mut mint_account, &mut account2_account, &mut owner_account], &[Check::err(ProgramError::MissingRequiredSignature)], ); // mismatch account do_process_instruction( mint_to(&program_id, &mint_key, &mismatch_key, &owner_key, &[], 42).unwrap(), vec![&mut mint_account, &mut mismatch_account, &mut owner_account], &[Check::err(TokenError::MintMismatch.into())], ); // missing owner do_process_instruction( mint_to(&program_id, &mint_key, &account2_key, &owner2_key, &[], 42).unwrap(), vec![ &mut mint_account, &mut account2_account, &mut owner2_account, ], &[Check::err(TokenError::OwnerMismatch.into())], ); // mint not owned by program let not_program_id = Address::new_unique(); mint_account.owner = not_program_id; do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 0).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::err(ProgramError::IncorrectProgramId)], ); mint_account.owner = program_id; // account not owned by program let not_program_id = Address::new_unique(); account_account.owner = not_program_id; do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 0).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::err(ProgramError::IncorrectProgramId)], ); account_account.owner = program_id; // uninitialized destination account do_process_instruction( mint_to( &program_id, &mint_key, &uninitialized_key, &owner_key, &[], 42, ) .unwrap(), vec![ &mut mint_account, &mut uninitialized_account, &mut owner_account, ], &[Check::err(ProgramError::UninitializedAccount)], ); // unset mint_authority and test minting fails do_process_instruction( set_authority( &program_id, &mint_key, None, AuthorityType::MintTokens, &owner_key, &[], ) .unwrap(), vec![&mut mint_account, &mut owner_account], &[Check::success()], ); do_process_instruction( mint_to(&program_id, &mint_key, &account2_key, &owner_key, &[], 42).unwrap(), vec![&mut mint_account, &mut account2_account, &mut owner_account], &[Check::err(TokenError::FixedSupply.into())], ); } #[test] fn test_batch_with_invalid_count() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mint_account_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_owner = Address::new_unique(); let account_owner = Address::new_unique(); let mut account_owner_account = SolanaAccount::default(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let account_info: AccountInfo = (&account_key, true, &mut account_account).into(); let mint_account_info: AccountInfo = (&mint_account_key, true, &mut mint_account).into(); let account_owner_info: AccountInfo = (&account_owner, true, &mut account_owner_account).into(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); let initialize_mint_instruction = initialize_mint(&program_id, &mint_account_key, &mint_owner, None, 9).unwrap(); let initialize_account_instruction = initialize_account3(&program_id, &account_key, &mint_account_key, &account_owner) .unwrap(); let close_account_instruction = close_account( &program_id, &account_key, &account_owner, &account_owner, &[], ) .unwrap(); let mut batch_instr = batch_instruction(&[ &initialize_mint_instruction, &initialize_account_instruction, &close_account_instruction, ]) .unwrap(); // clear the close discriminator batch_instr.data.pop(); let temp_mint_data = mint_account_info.data.borrow().to_vec(); let temp_account_data = account_info.data.borrow().to_vec(); do_process_instruction_dups( batch_instr, vec![ mint_account_info.clone(), rent_info.clone(), account_info.clone(), mint_account_info.clone(), account_info.clone(), account_owner_info.clone(), account_owner_info.clone(), ], &[Check::err(TokenError::InvalidInstruction.into())], ); // reset the accounts mint_account_info .data .borrow_mut() .copy_from_slice(&temp_mint_data); account_info .data .borrow_mut() .copy_from_slice(&temp_account_data); let mut batch_instr = batch_instruction(&[ &initialize_mint_instruction, &initialize_account_instruction, &close_account_instruction, ]) .unwrap(); // Omit account metas as well so the program sees the truncated account list. batch_instr.accounts.truncate(3); do_process_instruction_dups( batch_instr, vec![ mint_account_info.clone(), rent_info.clone(), account_info.clone(), ], // leave out the `initialize_account3` accounts and `close_account` accounts &[Check::err(ProgramError::NotEnoughAccountKeys)], ); // reset the accounts mint_account_info .data .borrow_mut() .copy_from_slice(&temp_mint_data); account_info .data .borrow_mut() .copy_from_slice(&temp_account_data); let batch_instruction = batch_instruction(&[ &initialize_mint_instruction, &initialize_account_instruction, &close_account_instruction, ]) .unwrap(); do_process_instruction_dups( batch_instruction, vec![ mint_account_info.clone(), rent_info.clone(), account_info.clone(), mint_account_info.clone(), account_info.clone(), account_owner_info.clone(), account_owner_info.clone(), ], &[Check::success()], ); } #[test] fn test_batch_in_batch() { let program_id = crate::id(); let mint_account_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_owner = Address::new_unique(); let mut mint_owner_account = SolanaAccount::default(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let mint_account_info: AccountInfo = (&mint_account_key, true, &mut mint_account).into(); let mint_owner_info: AccountInfo = (&mint_owner, true, &mut mint_owner_account).into(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); let initialize_mint_instruction = initialize_mint( &program_id, &mint_account_key, &mint_owner, Some(&mint_owner), 9, ) .unwrap(); let set_authority_instruction = set_authority( &program_id, &mint_account_key, None, AuthorityType::FreezeAccount, &mint_owner, &[], ) .unwrap(); let batch_instr = batch_instruction(&[&set_authority_instruction]).unwrap(); let batch_in_batch_instruction = batch_instruction(&[&batch_instr, &initialize_mint_instruction]).unwrap(); let temp_mint_account_data = mint_account_info.data.borrow().to_vec(); do_process_instruction_dups( batch_in_batch_instruction, vec![ mint_account_info.clone(), rent_info.clone(), mint_account_info.clone(), mint_owner_info.clone(), ], &[Check::err(TokenError::InvalidInstruction.into())], ); // reset account mint_account_info .data .borrow_mut() .copy_from_slice(&temp_mint_account_data); do_process_instruction_dups( initialize_mint_instruction, vec![mint_account_info.clone(), rent_info.clone()], &[Check::success()], ); do_process_instruction_dups( batch_instr, vec![mint_account_info.clone(), mint_owner_info.clone()], &[Check::success()], ); } #[test] #[allow(deprecated)] fn test_batch_initialize_mint_swap() { let program_id = crate::id(); let account1_key = Address::new_unique(); let mut account1_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account4_key = Address::new_unique(); let mut account4_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mint_account1_key = Address::new_unique(); let mut mint1_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_account2_key = Address::new_unique(); let mut mint2_account = SolanaAccount::new( mint_minimum_balance(), Mint::get_packed_len(), &Address::new_unique(), ); let mint_owner = Address::new_unique(); let mut mint_owner_account = SolanaAccount::default(); let account_owner = Address::new_unique(); let mut account_owner_account = SolanaAccount::default(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into(); let account2_info: AccountInfo = (&account2_key, true, &mut account2_account).into(); let account3_info: AccountInfo = (&account3_key, true, &mut account3_account).into(); let account4_info: AccountInfo = (&account4_key, true, &mut account4_account).into(); let mint_account1_info: AccountInfo = (&mint_account1_key, true, &mut mint1_account).into(); let mint_account2_info: AccountInfo = (&mint_account2_key, true, &mut mint2_account).into(); let mint_owner_info: AccountInfo = (&mint_owner, true, &mut mint_owner_account).into(); let account_owner_info: AccountInfo = (&account_owner, true, &mut account_owner_account).into(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); let initialize_mint_1_instruction = initialize_mint(&program_id, &mint_account1_key, &mint_owner, None, 9).unwrap(); let initialize_mint_2_instruction = initialize_mint(&program_id, &mint_account2_key, &mint_owner, None, 9).unwrap(); let initialize_account_1_instruction = initialize_account3( &program_id, &account1_key, &mint_account1_key, &account_owner, ) .unwrap(); let initialize_account_2_instruction = initialize_account3( &program_id, &account2_key, &mint_account2_key, &account_owner, ) .unwrap(); let initialize_account_3_instruction = initialize_account3( &program_id, &account3_key, &mint_account1_key, &account_owner, ) .unwrap(); let initialize_account_4_instruction = initialize_account3( &program_id, &account4_key, &mint_account2_key, &account_owner, ) .unwrap(); let mint_to_1_instruction = mint_to( &program_id, &mint_account1_key, &account1_key, &mint_owner, &[], 1000, ) .unwrap(); let mint_to_2_instruction = mint_to_checked( &program_id, &mint_account2_key, &account2_key, &mint_owner, &[], 1000, 9, ) .unwrap(); let mint_to_2_with_invalid_decimals = mint_to_checked( &program_id, &mint_account2_key, &account2_key, &mint_owner, &[], 1000, 8, ) .unwrap(); let transfer_to_3_instruction = transfer( &program_id, &account1_key, &account3_key, &account_owner, &[], 500, ) .unwrap(); let transfer_to_3_with_invalid_amount = transfer( &program_id, &account1_key, &account3_key, &account_owner, &[], 501, ) .unwrap(); let transfer_4_instruction = transfer_checked( &program_id, &account2_key, &mint_account2_key, &account4_key, &account_owner, &[], 500, 9, ) .unwrap(); let batch_1_instruction = batch_instruction(&[&initialize_mint_1_instruction]).unwrap(); do_process_instruction_dups( batch_1_instruction, vec![mint_account1_info.clone(), rent_info.clone()], &[Check::success()], ); let temp_mint1_data = mint_account1_info.data.borrow().to_vec(); let temp_account1_data = account1_info.data.borrow().to_vec(); let temp_account2_data = account2_info.data.borrow().to_vec(); // fails with incorrect program id(caused by `initialize_account_2_instr`) let batch_2_fail_instruction = batch_instruction(&[ &initialize_mint_2_instruction, &initialize_account_1_instruction, &initialize_account_2_instruction, &initialize_account_3_instruction, &initialize_account_4_instruction, ]) .unwrap(); do_process_instruction_dups( batch_2_fail_instruction, vec![ mint_account2_info.clone(), rent_info.clone(), account1_info.clone(), mint_account1_info.clone(), account2_info.clone(), mint_account2_info.clone(), account3_info.clone(), mint_account1_info.clone(), account4_info.clone(), mint_account2_info.clone(), ], &[Check::err(ProgramError::IncorrectProgramId)], ); // reset accounts mint_account1_info .data .borrow_mut() .copy_from_slice(&temp_mint1_data); account1_info .data .borrow_mut() .copy_from_slice(&temp_account1_data); account2_info .data .borrow_mut() .copy_from_slice(&temp_account2_data); // correct the owner let mut mint2_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_account2_info: AccountInfo = (&mint_account2_key, true, &mut mint2_account).into(); // with correct owner let batch_2_success_instruction = batch_instruction(&[ &initialize_mint_2_instruction, &initialize_account_1_instruction, &initialize_account_2_instruction, &initialize_account_3_instruction, &initialize_account_4_instruction, ]) .unwrap(); do_process_instruction_dups( batch_2_success_instruction, vec![ mint_account2_info.clone(), rent_info.clone(), account1_info.clone(), mint_account1_info.clone(), account2_info.clone(), mint_account2_info.clone(), account3_info.clone(), mint_account1_info.clone(), account4_info.clone(), mint_account2_info.clone(), ], &[Check::success()], ); let temp_mint1_data = mint_account1_info.data.borrow().to_vec(); let temp_account1_data = account1_info.data.borrow().to_vec(); let temp_mint2_data = mint_account2_info.data.borrow().to_vec(); let temp_account2_data = account2_info.data.borrow().to_vec(); // with decimals mismatch let batch_3_fail_instruction = batch_instruction(&[ &mint_to_1_instruction, &mint_to_2_instruction, &mint_to_2_with_invalid_decimals, ]) .unwrap(); do_process_instruction_dups( batch_3_fail_instruction, vec![ mint_account1_info.clone(), account1_info.clone(), mint_owner_info.clone(), mint_account2_info.clone(), account2_info.clone(), mint_owner_info.clone(), mint_account2_info.clone(), account2_info.clone(), mint_owner_info.clone(), ], &[Check::err(TokenError::MintDecimalsMismatch.into())], ); // reset accounts mint_account1_info .data .borrow_mut() .copy_from_slice(&temp_mint1_data); account1_info .data .borrow_mut() .copy_from_slice(&temp_account1_data); mint_account2_info .data .borrow_mut() .copy_from_slice(&temp_mint2_data); account2_info .data .borrow_mut() .copy_from_slice(&temp_account2_data); // without the invalid decimals instruction let batch_3_success_instruction = batch_instruction(&[&mint_to_1_instruction, &mint_to_2_instruction]).unwrap(); do_process_instruction_dups( batch_3_success_instruction, vec![ mint_account1_info.clone(), account1_info.clone(), mint_owner_info.clone(), mint_account2_info.clone(), account2_info.clone(), mint_owner_info.clone(), ], &[Check::success()], ); let temp_account1_data = account1_info.data.borrow().to_vec(); let temp_account3_data = account3_info.data.borrow().to_vec(); let temp_account2_data = account2_info.data.borrow().to_vec(); let temp_account4_data = account4_info.data.borrow().to_vec(); let batch_4_fail_instruction = batch_instruction(&[ &transfer_to_3_instruction, &transfer_to_3_with_invalid_amount, &transfer_4_instruction, ]) .unwrap(); do_process_instruction_dups( batch_4_fail_instruction, vec![ account1_info.clone(), account3_info.clone(), account_owner_info.clone(), account1_info.clone(), account3_info.clone(), account_owner_info.clone(), account2_info.clone(), mint_account2_info.clone(), account4_info.clone(), account_owner_info.clone(), ], &[Check::err(TokenError::InsufficientFunds.into())], ); // reset accounts account1_info .data .borrow_mut() .copy_from_slice(&temp_account1_data); account3_info .data .borrow_mut() .copy_from_slice(&temp_account3_data); account2_info .data .borrow_mut() .copy_from_slice(&temp_account2_data); account4_info .data .borrow_mut() .copy_from_slice(&temp_account4_data); // with valid amount let batch_4_success_instruction = batch_instruction(&[&transfer_to_3_instruction, &transfer_4_instruction]).unwrap(); do_process_instruction_dups( batch_4_success_instruction, vec![ account1_info.clone(), account3_info.clone(), account_owner_info.clone(), account2_info.clone(), mint_account2_info.clone(), account4_info.clone(), account_owner_info.clone(), ], &[Check::success()], ); } #[test] fn test_burn_dups() { let program_id = crate::id(); let account1_key = Address::new_unique(); let mut account1_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into(); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner_info: AccountInfo = (&owner_key, true, &mut owner_account).into(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); // create mint do_process_instruction_dups( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![mint_info.clone(), rent_info.clone()], &[Check::success()], ); // create account do_process_instruction_dups( initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), rent_info.clone(), ], &[Check::success()], ); // mint to account do_process_instruction_dups( mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(), vec![mint_info.clone(), account1_info.clone(), owner_info.clone()], &[Check::success()], ); // source-owner burn do_process_instruction_dups( burn( &program_id, &account1_key, &mint_key, &account1_key, &[], 500, ) .unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), ], &[Check::success()], ); // source-owner burn_checked do_process_instruction_dups( burn_checked( &program_id, &account1_key, &mint_key, &account1_key, &[], 500, 2, ) .unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), ], &[Check::success()], ); // mint-owner burn do_process_instruction_dups( mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(), vec![mint_info.clone(), account1_info.clone(), owner_info.clone()], &[Check::success()], ); let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap(); account.owner = mint_key; Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap(); do_process_instruction_dups( burn(&program_id, &account1_key, &mint_key, &mint_key, &[], 500).unwrap(), vec![account1_info.clone(), mint_info.clone(), mint_info.clone()], &[Check::success()], ); // mint-owner burn_checked do_process_instruction_dups( burn_checked( &program_id, &account1_key, &mint_key, &mint_key, &[], 500, 2, ) .unwrap(), vec![account1_info.clone(), mint_info.clone(), mint_info.clone()], &[Check::success()], ); // source-delegate burn do_process_instruction_dups( mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(), vec![mint_info.clone(), account1_info.clone(), owner_info.clone()], &[Check::success()], ); let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap(); account.delegated_amount = 1000; account.delegate = COption::Some(account1_key); account.owner = owner_key; Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap(); do_process_instruction_dups( burn( &program_id, &account1_key, &mint_key, &account1_key, &[], 500, ) .unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), ], &[Check::success()], ); // source-delegate burn_checked do_process_instruction_dups( burn_checked( &program_id, &account1_key, &mint_key, &account1_key, &[], 500, 2, ) .unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), ], &[Check::success()], ); // mint-delegate burn do_process_instruction_dups( mint_to(&program_id, &mint_key, &account1_key, &owner_key, &[], 1000).unwrap(), vec![mint_info.clone(), account1_info.clone(), owner_info.clone()], &[Check::success()], ); let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap(); account.delegated_amount = 1000; account.delegate = COption::Some(mint_key); account.owner = owner_key; Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap(); do_process_instruction_dups( burn(&program_id, &account1_key, &mint_key, &mint_key, &[], 500).unwrap(), vec![account1_info.clone(), mint_info.clone(), mint_info.clone()], &[Check::success()], ); // mint-delegate burn_checked do_process_instruction_dups( burn_checked( &program_id, &account1_key, &mint_key, &mint_key, &[], 500, 2, ) .unwrap(), vec![account1_info.clone(), mint_info.clone(), mint_info.clone()], &[Check::success()], ); } #[test] fn test_burn() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let delegate_key = Address::new_unique(); let mut delegate_account = SolanaAccount::default(); let mismatch_key = Address::new_unique(); let mut mismatch_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint2_key = Address::new_unique(); let mut rent_sysvar = rent_sysvar(); // create new mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(), vec![ &mut account2_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account3_key, &mint_key, &owner_key).unwrap(), vec![ &mut account3_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create mismatch account do_process_instruction( initialize_account(&program_id, &mismatch_key, &mint_key, &owner_key).unwrap(), vec![ &mut mismatch_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // mint to account do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::success()], ); // mint to mismatch account and change mint key do_process_instruction( mint_to(&program_id, &mint_key, &mismatch_key, &owner_key, &[], 1000).unwrap(), vec![&mut mint_account, &mut mismatch_account, &mut owner_account], &[Check::success()], ); let mut account = Account::unpack_unchecked(&mismatch_account.data).unwrap(); account.mint = mint2_key; Account::pack(account, &mut mismatch_account.data).unwrap(); // missing signer let mut instruction = burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 42).unwrap(); instruction.accounts[1].is_signer = false; do_process_instruction( instruction, vec![ &mut account_account, &mut mint_account, &mut delegate_account, ], &[Check::err(TokenError::OwnerMismatch.into())], ); // missing owner do_process_instruction( burn(&program_id, &account_key, &mint_key, &owner2_key, &[], 42).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner2_account], &[Check::err(TokenError::OwnerMismatch.into())], ); // account not owned by program let not_program_id = Address::new_unique(); account_account.owner = not_program_id; do_process_instruction( burn(&program_id, &account_key, &mint_key, &owner_key, &[], 0).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::err(ProgramError::IncorrectProgramId)], ); account_account.owner = program_id; // mint not owned by program let not_program_id = Address::new_unique(); mint_account.owner = not_program_id; do_process_instruction( burn(&program_id, &account_key, &mint_key, &owner_key, &[], 0).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::err(ProgramError::IncorrectProgramId)], ); mint_account.owner = program_id; // mint mismatch do_process_instruction( burn(&program_id, &mismatch_key, &mint_key, &owner_key, &[], 42).unwrap(), vec![&mut mismatch_account, &mut mint_account, &mut owner_account], &[Check::err(TokenError::MintMismatch.into())], ); // burn do_process_instruction( burn(&program_id, &account_key, &mint_key, &owner_key, &[], 21).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::success()], ); // burn_checked, with incorrect decimals do_process_instruction( burn_checked(&program_id, &account_key, &mint_key, &owner_key, &[], 21, 3).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::err(TokenError::MintDecimalsMismatch.into())], ); // burn_checked do_process_instruction( burn_checked(&program_id, &account_key, &mint_key, &owner_key, &[], 21, 2).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::success()], ); let mint = Mint::unpack_unchecked(&mint_account.data).unwrap(); assert_eq!(mint.supply, 2000 - 42); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, 1000 - 42); // insufficient funds do_process_instruction( burn( &program_id, &account_key, &mint_key, &owner_key, &[], 100_000_000, ) .unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::err(TokenError::InsufficientFunds.into())], ); // approve delegate do_process_instruction( approve( &program_id, &account_key, &delegate_key, &owner_key, &[], 84, ) .unwrap(), vec![ &mut account_account, &mut delegate_account, &mut owner_account, ], &[Check::success()], ); // not a delegate of source account do_process_instruction( burn( &program_id, &account_key, &mint_key, &owner2_key, // <-- incorrect owner or delegate &[], 1, ) .unwrap(), vec![&mut account_account, &mut mint_account, &mut owner2_account], &[Check::err(TokenError::OwnerMismatch.into())], ); // insufficient funds approved via delegate do_process_instruction( burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 85).unwrap(), vec![ &mut account_account, &mut mint_account, &mut delegate_account, ], &[Check::err(TokenError::InsufficientFunds.into())], ); // burn via delegate do_process_instruction( burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 84).unwrap(), vec![ &mut account_account, &mut mint_account, &mut delegate_account, ], &[Check::success()], ); // match let mint = Mint::unpack_unchecked(&mint_account.data).unwrap(); assert_eq!(mint.supply, 2000 - 42 - 84); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, 1000 - 42 - 84); // insufficient funds approved via delegate do_process_instruction( burn(&program_id, &account_key, &mint_key, &delegate_key, &[], 1).unwrap(), vec![ &mut account_account, &mut mint_account, &mut delegate_account, ], &[Check::err(TokenError::OwnerMismatch.into())], ); } #[test] fn test_multisig() { let program_id = crate::id(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let account_key = Address::new_unique(); let mut account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let multisig_key = Address::new_unique(); let mut multisig_account = SolanaAccount::new(42, Multisig::get_packed_len(), &program_id); let mut empty_multisig_account = SolanaAccount::new(42, Multisig::get_packed_len(), &program_id); let multisig_delegate_key = Address::new_unique(); let mut multisig_delegate_account = SolanaAccount::new( multisig_minimum_balance(), Multisig::get_packed_len(), &program_id, ); let signer_keys = vec![Address::new_unique(); MAX_SIGNERS]; let signer_key_refs: Vec<&Address> = signer_keys.iter().collect(); let mut signer_accounts = vec![SolanaAccount::new(0, 0, &program_id); MAX_SIGNERS]; let mut rent_sysvar = rent_sysvar(); // multisig is not rent exempt let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( initialize_multisig(&program_id, &multisig_key, &[&signer_keys[0]], 1).unwrap(), vec![ &mut multisig_account, &mut rent_sysvar, account_info_iter.next().unwrap(), ], &[Check::err(TokenError::NotRentExempt.into())], ); multisig_account.lamports = multisig_minimum_balance(); let mut multisig_account2 = multisig_account.clone(); // single signer let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( initialize_multisig(&program_id, &multisig_key, &[&signer_keys[0]], 1).unwrap(), vec![ &mut multisig_account, &mut rent_sysvar, account_info_iter.next().unwrap(), ], &[Check::success()], ); // single signer using `initialize_multisig2` let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( initialize_multisig2(&program_id, &multisig_key, &[&signer_keys[0]], 1).unwrap(), vec![&mut multisig_account2, account_info_iter.next().unwrap()], &[Check::success()], ); // multiple signer let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( initialize_multisig( &program_id, &multisig_delegate_key, &signer_key_refs, MAX_SIGNERS as u8, ) .unwrap(), vec![ &mut multisig_delegate_account, &mut rent_sysvar, account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), ], &[Check::success()], ); // create new mint with multisig owner do_process_instruction( initialize_mint(&program_id, &mint_key, &multisig_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create account with multisig owner do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &multisig_key).unwrap(), vec![ &mut account, &mut mint_account, &mut multisig_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account with multisig owner do_process_instruction( initialize_account( &program_id, &account2_key, &mint_key, &multisig_delegate_key, ) .unwrap(), vec![ &mut account2_account, &mut mint_account, &mut multisig_account, &mut rent_sysvar, ], &[Check::success()], ); // mint to account let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( mint_to( &program_id, &mint_key, &account_key, &multisig_key, &[&signer_keys[0]], 1000, ) .unwrap(), vec![ &mut mint_account, &mut account, &mut multisig_account, account_info_iter.next().unwrap(), ], &[Check::success()], ); // fail with uninitialized multisig let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( approve( &program_id, &account_key, &multisig_delegate_key, &multisig_key, &[], 100, ) .unwrap(), vec![ &mut account, &mut multisig_delegate_account, &mut empty_multisig_account, account_info_iter.next().unwrap(), ], &[Check::err(ProgramError::UninitializedAccount)], ); // approve let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( approve( &program_id, &account_key, &multisig_delegate_key, &multisig_key, &[&signer_keys[0]], 100, ) .unwrap(), vec![ &mut account, &mut multisig_delegate_account, &mut multisig_account, account_info_iter.next().unwrap(), ], &[Check::success()], ); // transfer let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &multisig_key, &[&signer_keys[0]], 42, ) .unwrap(), vec![ &mut account, &mut account2_account, &mut multisig_account, account_info_iter.next().unwrap(), ], &[Check::success()], ); // transfer via delegate let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &multisig_delegate_key, &signer_key_refs, 42, ) .unwrap(), vec![ &mut account, &mut account2_account, &mut multisig_delegate_account, account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), ], &[Check::success()], ); // mint to let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( mint_to( &program_id, &mint_key, &account2_key, &multisig_key, &[&signer_keys[0]], 42, ) .unwrap(), vec![ &mut mint_account, &mut account2_account, &mut multisig_account, account_info_iter.next().unwrap(), ], &[Check::success()], ); // burn let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( burn( &program_id, &account_key, &mint_key, &multisig_key, &[&signer_keys[0]], 42, ) .unwrap(), vec![ &mut account, &mut mint_account, &mut multisig_account, account_info_iter.next().unwrap(), ], &[Check::success()], ); // burn via delegate let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( burn( &program_id, &account_key, &mint_key, &multisig_delegate_key, &signer_key_refs, 42, ) .unwrap(), vec![ &mut account, &mut mint_account, &mut multisig_delegate_account, account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), account_info_iter.next().unwrap(), ], &[Check::success()], ); // freeze account let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mint2_key = Address::new_unique(); let mut mint2_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); do_process_instruction( initialize_mint( &program_id, &mint2_key, &multisig_key, Some(&multisig_key), 2, ) .unwrap(), vec![&mut mint2_account, &mut rent_sysvar], &[Check::success()], ); do_process_instruction( initialize_account(&program_id, &account3_key, &mint2_key, &owner_key).unwrap(), vec![ &mut account3_account, &mut mint2_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( mint_to( &program_id, &mint2_key, &account3_key, &multisig_key, &[&signer_keys[0]], 1000, ) .unwrap(), vec![ &mut mint2_account, &mut account3_account, &mut multisig_account, account_info_iter.next().unwrap(), ], &[Check::success()], ); let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( freeze_account( &program_id, &account3_key, &mint2_key, &multisig_key, &[&signer_keys[0]], ) .unwrap(), vec![ &mut account3_account, &mut mint2_account, &mut multisig_account, account_info_iter.next().unwrap(), ], &[Check::success()], ); // do SetAuthority on mint let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( set_authority( &program_id, &mint_key, Some(&owner_key), AuthorityType::MintTokens, &multisig_key, &[&signer_keys[0]], ) .unwrap(), vec![ &mut mint_account, &mut multisig_account, account_info_iter.next().unwrap(), ], &[Check::success()], ); // do SetAuthority on account let account_info_iter = &mut signer_accounts.iter_mut(); do_process_instruction( set_authority( &program_id, &account_key, Some(&owner_key), AuthorityType::AccountOwner, &multisig_key, &[&signer_keys[0]], ) .unwrap(), vec![ &mut account, &mut multisig_account, account_info_iter.next().unwrap(), ], &[Check::success()], ); } #[test] fn test_permissioned_burn_none_authority_errors() { let program_id = crate::id(); let mint_key = Address::new_unique(); let owner_key = Address::new_unique(); let burn_authority_key = Address::new_unique(); let account_key = Address::new_unique(); let mint_size = ExtensionType::try_calculate_account_len::(&[ExtensionType::PermissionedBurn]) .unwrap(); let mut mint_account = SolanaAccount::new( Rent::default().minimum_balance(mint_size), mint_size, &program_id, ); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mut owner_account = SolanaAccount::default(); let mut burn_authority_account = SolanaAccount::default(); let mut rent_sysvar = rent_sysvar(); do_process_instruction( permissioned_burn::instruction::initialize(&program_id, &mint_key, &burn_authority_key) .unwrap(), vec![&mut mint_account], &[Check::success()], ); do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // Create account and mint some tokens. do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 10).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::success()], ); // Clear the permissioned burn authority. do_process_instruction( set_authority( &program_id, &mint_key, None, AuthorityType::PermissionedBurn, &burn_authority_key, &[], ) .unwrap(), vec![&mut mint_account, &mut burn_authority_account], &[Check::success()], ); // Attempt a permissioned burn should fail when authority is None. do_process_instruction( permissioned_burn::instruction::burn( &program_id, &account_key, &mint_key, &burn_authority_key, &owner_key, &[], 1, ) .unwrap(), vec![ &mut account_account, &mut mint_account, &mut burn_authority_account, &mut owner_account, ], &[Check::err(TokenError::InvalidInstruction.into())], ); // Standard burn should still succeed after authority is cleared. do_process_instruction( burn(&program_id, &account_key, &mint_key, &owner_key, &[], 1).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::success()], ); } #[test] fn test_validate_owner() { use pinocchio::{account::RuntimeAccount, entrypoint::NON_DUP_MARKER}; // Create a `RuntimeAccount` and a corresponding `AccountView` for testing. // // SAFETY: The caller must ensure that the returned `AccountView` is not used // after the `storage` vector is dropped. unsafe fn make_account_view( address: &Address, owner: &Address, is_signer: bool, data: &[u8], ) -> (Vec, AccountView) { let mut storage = vec![0u64; (size_of::() + data.len()).div_ceil(size_of::())]; let account = storage.as_mut_ptr() as *mut RuntimeAccount; account.write(RuntimeAccount { borrow_state: NON_DUP_MARKER, address: *address, owner: *owner, is_signer: u8::from(is_signer), data_len: data.len() as u64, ..RuntimeAccount::default() }); core::ptr::copy_nonoverlapping( data.as_ptr(), (account as *mut u8).add(size_of::()), data.len(), ); (storage, AccountView::new_unchecked(account)) } let program_id = crate::id(); let owner_key = Address::new_unique(); let account_to_validate = Address::new_unique(); let mut signer_keys = [Address::default(); MAX_SIGNERS]; for signer_key in signer_keys.iter_mut().take(MAX_SIGNERS) { *signer_key = Address::new_unique(); } let signer_accounts: Vec<_> = signer_keys .iter() .chain(std::iter::once(&owner_key)) .map(|key| unsafe { make_account_view(key, &program_id, true, &[]) }) .collect(); let mut signers: Vec<_> = signer_accounts.iter().map(|(_, view)| *view).collect(); let mut data = vec![0; Multisig::get_packed_len()]; let mut multisig = Multisig::unpack_unchecked(&data).unwrap(); multisig.m = MAX_SIGNERS as u8; multisig.n = MAX_SIGNERS as u8; multisig.signers = signer_keys; multisig.is_initialized = true; Multisig::pack(multisig, &mut data).unwrap(); let (_owner_backing, mut owner_account_info) = unsafe { make_account_view(&owner_key, &program_id, false, &data) }; let owner_account_data_len = owner_account_info.data_len(); // no multisig, but the account is its own authority, and data is mutably // borrowed { let mut data = vec![0; Account::get_packed_len()]; let mut account = Account::unpack_unchecked(&data).unwrap(); account.owner = account_to_validate; Account::pack(account, &mut data).unwrap(); let (_account_backing, account_info) = unsafe { make_account_view(&account_to_validate, &program_id, true, &data) }; let account_info_data_len = account_info.data_len(); let mut account_alias = account_info; let mut borrowed_data = account_alias.try_borrow_mut().unwrap(); Processor::validate_owner( &program_id, &account_to_validate, &account_info, account_info_data_len, &[], ) .unwrap(); // modify the data to be sure that it wasn't silently dropped by the compiler borrowed_data[0] = 1; } // full 11 of 11 Processor::validate_owner( &program_id, &owner_key, &owner_account_info, owner_account_data_len, &signers, ) .unwrap(); // full 11 of 11, multisig owned by tokenkeg (legacy spl-token program) { let tokenkeg_id = inline_spl_token::id(); let mut data = vec![0; Multisig::get_packed_len()]; let mut multisig = Multisig::unpack_unchecked(&data).unwrap(); multisig.m = MAX_SIGNERS as u8; multisig.n = MAX_SIGNERS as u8; multisig.signers = signer_keys; multisig.is_initialized = true; Multisig::pack(multisig, &mut data).unwrap(); let (_tokenkeg_backing, tokenkeg_multisig_info) = unsafe { make_account_view(&owner_key, &tokenkeg_id, false, &data) }; let tokenkeg_multisig_data_len = tokenkeg_multisig_info.data_len(); Processor::validate_owner( &program_id, &owner_key, &tokenkeg_multisig_info, tokenkeg_multisig_data_len, &signers, ) .unwrap(); } // 1 of 11 { let mut multisig = Multisig::unpack_unchecked(&owner_account_info.try_borrow().unwrap()).unwrap(); multisig.m = 1; Multisig::pack(multisig, &mut owner_account_info.try_borrow_mut().unwrap()).unwrap(); } Processor::validate_owner( &program_id, &owner_key, &owner_account_info, owner_account_data_len, &signers, ) .unwrap(); // 2:1 { let mut multisig = Multisig::unpack_unchecked(&owner_account_info.try_borrow().unwrap()).unwrap(); multisig.m = 2; multisig.n = 1; Multisig::pack(multisig, &mut owner_account_info.try_borrow_mut().unwrap()).unwrap(); } assert_eq!( Err(ProgramError::MissingRequiredSignature), Processor::validate_owner( &program_id, &owner_key, &owner_account_info, owner_account_data_len, &signers ) ); // 0:11 { let mut multisig = Multisig::unpack_unchecked(&owner_account_info.try_borrow().unwrap()).unwrap(); multisig.m = 0; multisig.n = 11; Multisig::pack(multisig, &mut owner_account_info.try_borrow_mut().unwrap()).unwrap(); } Processor::validate_owner( &program_id, &owner_key, &owner_account_info, owner_account_data_len, &signers, ) .unwrap(); // 2:11 but 0 provided { let mut multisig = Multisig::unpack_unchecked(&owner_account_info.try_borrow().unwrap()).unwrap(); multisig.m = 2; multisig.n = 11; Multisig::pack(multisig, &mut owner_account_info.try_borrow_mut().unwrap()).unwrap(); } assert_eq!( Err(ProgramError::MissingRequiredSignature), Processor::validate_owner( &program_id, &owner_key, &owner_account_info, owner_account_data_len, &[] ) ); // 2:11 but 1 provided { let mut multisig = Multisig::unpack_unchecked(&owner_account_info.try_borrow().unwrap()).unwrap(); multisig.m = 2; multisig.n = 11; Multisig::pack(multisig, &mut owner_account_info.try_borrow_mut().unwrap()).unwrap(); } assert_eq!( Err(ProgramError::MissingRequiredSignature), Processor::validate_owner( &program_id, &owner_key, &owner_account_info, owner_account_data_len, &signers[0..1] ) ); // 2:11, 2 from middle provided { let mut multisig = Multisig::unpack_unchecked(&owner_account_info.try_borrow().unwrap()).unwrap(); multisig.m = 2; multisig.n = 11; Multisig::pack(multisig, &mut owner_account_info.try_borrow_mut().unwrap()).unwrap(); } Processor::validate_owner( &program_id, &owner_key, &owner_account_info, owner_account_data_len, &signers[5..7], ) .unwrap(); // 11:11, one is not a signer { let mut multisig = Multisig::unpack_unchecked(&owner_account_info.try_borrow().unwrap()).unwrap(); multisig.m = 11; multisig.n = 11; Multisig::pack(multisig, &mut owner_account_info.try_borrow_mut().unwrap()).unwrap(); } let (_non_signer_backing, non_signer) = unsafe { make_account_view(&signer_keys[5], &program_id, false, &[]) }; signers[5] = non_signer; assert_eq!( Err(ProgramError::MissingRequiredSignature), Processor::validate_owner( &program_id, &owner_key, &owner_account_info, owner_account_data_len, &signers ) ); signers[5] = signer_accounts[5].1; // 11:11, single signer signs multiple times { let signers = vec![signers[5]; MAX_SIGNERS + 1]; let mut multisig = Multisig::unpack_unchecked(&owner_account_info.try_borrow().unwrap()).unwrap(); multisig.m = 11; multisig.n = 11; Multisig::pack(multisig, &mut owner_account_info.try_borrow_mut().unwrap()).unwrap(); assert_eq!( Err(ProgramError::MissingRequiredSignature), Processor::validate_owner( &program_id, &owner_key, &owner_account_info, owner_account_data_len, &signers ) ); } } #[test] fn test_owner_close_account_dups() { let program_id = crate::id(); let owner_key = Address::new_unique(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); // create mint do_process_instruction_dups( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![mint_info.clone(), rent_info.clone()], &[Check::success()], ); let to_close_key = Address::new_unique(); let mut to_close_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let to_close_account_info: AccountInfo = (&to_close_key, true, &mut to_close_account).into(); let destination_account_key = Address::new_unique(); let mut destination_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let destination_account_info: AccountInfo = (&destination_account_key, true, &mut destination_account).into(); // create account do_process_instruction_dups( initialize_account(&program_id, &to_close_key, &mint_key, &to_close_key).unwrap(), vec![ to_close_account_info.clone(), mint_info.clone(), to_close_account_info.clone(), rent_info.clone(), ], &[Check::success()], ); // source-owner close do_process_instruction_dups( close_account( &program_id, &to_close_key, &destination_account_key, &to_close_key, &[], ) .unwrap(), vec![ to_close_account_info.clone(), destination_account_info.clone(), to_close_account_info.clone(), ], &[Check::success()], ); assert!((*to_close_account_info.data.borrow()).is_empty()); } #[test] fn test_close_authority_close_account_dups() { let program_id = crate::id(); let owner_key = Address::new_unique(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_info: AccountInfo = (&mint_key, false, &mut mint_account).into(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); // create mint do_process_instruction_dups( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![mint_info.clone(), rent_info.clone()], &[Check::success()], ); let to_close_key = Address::new_unique(); let mut to_close_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let to_close_account_info: AccountInfo = (&to_close_key, true, &mut to_close_account).into(); let destination_account_key = Address::new_unique(); let mut destination_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let destination_account_info: AccountInfo = (&destination_account_key, true, &mut destination_account).into(); // create account do_process_instruction_dups( initialize_account(&program_id, &to_close_key, &mint_key, &to_close_key).unwrap(), vec![ to_close_account_info.clone(), mint_info.clone(), to_close_account_info.clone(), rent_info.clone(), ], &[Check::success()], ); let mut account = Account::unpack_unchecked(&to_close_account_info.data.borrow()).unwrap(); account.close_authority = COption::Some(to_close_key); account.owner = owner_key; Account::pack(account, &mut to_close_account_info.data.borrow_mut()).unwrap(); do_process_instruction_dups( close_account( &program_id, &to_close_key, &destination_account_key, &to_close_key, &[], ) .unwrap(), vec![ to_close_account_info.clone(), destination_account_info.clone(), to_close_account_info.clone(), ], &[Check::success()], ); assert!(to_close_account_info.data.borrow().is_empty()); } #[test] fn test_close_account() { let program_id = crate::id(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance() + 42, Account::get_packed_len(), &program_id, ); let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let mut rent_sysvar = rent_sysvar(); // uninitialized do_process_instruction( close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(), vec![ &mut account_account, &mut account3_account, &mut owner2_account, ], &[Check::err(ProgramError::UninitializedAccount)], ); // initialize and mint to non-native account do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 42).unwrap(), vec![ &mut mint_account, &mut account_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, 42); // initialize native account do_process_instruction( initialize_account( &program_id, &account2_key, &crate::native_mint::id(), &owner_key, ) .unwrap(), vec![ &mut account2_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); let account = Account::unpack_unchecked(&account2_account.data).unwrap(); assert!(account.is_native()); assert_eq!(account.amount, 42); // close non-native account with balance do_process_instruction( close_account(&program_id, &account_key, &account3_key, &owner_key, &[]).unwrap(), vec![ &mut account_account, &mut account3_account, &mut owner_account, ], &[Check::err(TokenError::NonNativeHasBalance.into())], ); assert_eq!(account_account.lamports, account_minimum_balance()); // empty account do_process_instruction( burn(&program_id, &account_key, &mint_key, &owner_key, &[], 42).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::success()], ); // wrong owner do_process_instruction( close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(), vec![ &mut account_account, &mut account3_account, &mut owner2_account, ], &[Check::err(TokenError::OwnerMismatch.into())], ); // close account do_process_instruction( close_account(&program_id, &account_key, &account3_key, &owner_key, &[]).unwrap(), vec![ &mut account_account, &mut account3_account, &mut owner_account, ], &[Check::success()], ); assert_eq!(account_account.lamports, 0); assert_eq!(account3_account.lamports, 2 * account_minimum_balance()); assert!(account_account.data.is_empty()); assert_eq!(account_account.owner, system_program::id()); // fund and initialize new non-native account to test close authority let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); account_account.lamports = 2; do_process_instruction( set_authority( &program_id, &account_key, Some(&owner2_key), AuthorityType::CloseAccount, &owner_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner_account], &[Check::success()], ); // account owner cannot authorize close if close_authority is set do_process_instruction( close_account(&program_id, &account_key, &account3_key, &owner_key, &[]).unwrap(), vec![ &mut account_account, &mut account3_account, &mut owner_account, ], &[Check::err(TokenError::OwnerMismatch.into())], ); // close non-native account with close_authority do_process_instruction( close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(), vec![ &mut account_account, &mut account3_account, &mut owner2_account, ], &[Check::success()], ); assert_eq!(account_account.lamports, 0); assert_eq!(account3_account.lamports, 2 * account_minimum_balance() + 2); assert!(account_account.data.is_empty()); assert_eq!(account_account.owner, system_program::id()); // close native account do_process_instruction( close_account(&program_id, &account2_key, &account3_key, &owner_key, &[]).unwrap(), vec![ &mut account2_account, &mut account3_account, &mut owner_account, ], &[Check::success()], ); assert!(account2_account.data.is_empty()); assert_eq!(account2_account.owner, system_program::id()); assert_eq!( account3_account.lamports, 3 * account_minimum_balance() + 2 + 42 ); } #[test] fn test_native_token() { let program_id = crate::id(); let mut mint_account = native_mint(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance() + 40, Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account3_key = Address::new_unique(); let mut account3_account = SolanaAccount::new(account_minimum_balance(), 0, &program_id); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let owner3_key = Address::new_unique(); let mut rent_sysvar = rent_sysvar(); // initialize native account do_process_instruction( initialize_account( &program_id, &account_key, &crate::native_mint::id(), &owner_key, ) .unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert!(account.is_native()); assert_eq!(account.amount, 40); // initialize native account do_process_instruction( initialize_account( &program_id, &account2_key, &crate::native_mint::id(), &owner_key, ) .unwrap(), vec![ &mut account2_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); let account = Account::unpack_unchecked(&account2_account.data).unwrap(); assert!(account.is_native()); assert_eq!(account.amount, 0); // mint_to unsupported do_process_instruction( mint_to( &program_id, &crate::native_mint::id(), &account_key, &owner_key, &[], 42, ) .unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::err(TokenError::NativeNotSupported.into())], ); // burn unsupported let bogus_mint_key = Address::new_unique(); let mut bogus_mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); do_process_instruction( initialize_mint(&program_id, &bogus_mint_key, &owner_key, None, 2).unwrap(), vec![&mut bogus_mint_account, &mut rent_sysvar], &[Check::success()], ); do_process_instruction( burn( &program_id, &account_key, &bogus_mint_key, &owner_key, &[], 42, ) .unwrap(), vec![ &mut account_account, &mut bogus_mint_account, &mut owner_account, ], &[Check::err(TokenError::NativeNotSupported.into())], ); // ensure can't transfer below rent-exempt reserve do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &owner_key, &[], 50, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::err(TokenError::InsufficientFunds.into())], ); // transfer between native accounts do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &owner_key, &[], 40, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::success()], ); assert_eq!(account_account.lamports, account_minimum_balance()); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert!(account.is_native()); assert_eq!(account.amount, 0); assert_eq!(account2_account.lamports, account_minimum_balance() + 40); let account = Account::unpack_unchecked(&account2_account.data).unwrap(); assert!(account.is_native()); assert_eq!(account.amount, 40); // set close authority do_process_instruction( set_authority( &program_id, &account_key, Some(&owner3_key), AuthorityType::CloseAccount, &owner_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner_account], &[Check::success()], ); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.close_authority, COption::Some(owner3_key)); // set new account owner do_process_instruction( set_authority( &program_id, &account_key, Some(&owner2_key), AuthorityType::AccountOwner, &owner_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner_account], &[Check::success()], ); // close authority cleared let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.close_authority, COption::None); // close native account do_process_instruction( close_account(&program_id, &account_key, &account3_key, &owner2_key, &[]).unwrap(), vec![ &mut account_account, &mut account3_account, &mut owner2_account, ], &[Check::success()], ); assert_eq!(account_account.lamports, 0); assert_eq!(account3_account.lamports, 2 * account_minimum_balance()); assert!(account_account.data.is_empty()); assert_eq!(account_account.owner, system_program::id()); } #[test] fn test_overflow() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let mint_owner_key = Address::new_unique(); let mut mint_owner_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create new mint with owner do_process_instruction( initialize_mint(&program_id, &mint_key, &mint_owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create an account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account2_key, &mint_key, &owner2_key).unwrap(), vec![ &mut account2_account, &mut mint_account, &mut owner2_account, &mut rent_sysvar, ], &[Check::success()], ); // mint the max to an account do_process_instruction( mint_to( &program_id, &mint_key, &account_key, &mint_owner_key, &[], u64::MAX, ) .unwrap(), vec![ &mut mint_account, &mut account_account, &mut mint_owner_account, ], &[Check::success()], ); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, u64::MAX); // attempt to mint one more to account do_process_instruction( mint_to( &program_id, &mint_key, &account_key, &mint_owner_key, &[], 1, ) .unwrap(), vec![ &mut mint_account, &mut account_account, &mut mint_owner_account, ], &[Check::err(TokenError::Overflow.into())], ); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, u64::MAX); // attempt to mint one more to the other account do_process_instruction( mint_to( &program_id, &mint_key, &account2_key, &mint_owner_key, &[], 1, ) .unwrap(), vec![ &mut mint_account, &mut account2_account, &mut mint_owner_account, ], &[Check::err(TokenError::Overflow.into())], ); // burn some of the supply do_process_instruction( burn(&program_id, &account_key, &mint_key, &owner_key, &[], 100).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::success()], ); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, u64::MAX - 100); do_process_instruction( mint_to( &program_id, &mint_key, &account_key, &mint_owner_key, &[], 100, ) .unwrap(), vec![ &mut mint_account, &mut account_account, &mut mint_owner_account, ], &[Check::success()], ); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.amount, u64::MAX); // manipulate account balance to attempt overflow transfer let mut account = Account::unpack_unchecked(&account2_account.data).unwrap(); account.amount = 1; Account::pack(account, &mut account2_account.data).unwrap(); do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account2_key, &account_key, &owner2_key, &[], 1, ) .unwrap(), vec![ &mut account2_account, &mut account_account, &mut owner2_account, ], &[Check::err(TokenError::Overflow.into())], ); } #[test] fn test_frozen() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account2_key = Address::new_unique(); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create new mint and fund first account do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // create another account do_process_instruction( initialize_account(&program_id, &account2_key, &mint_key, &owner_key).unwrap(), vec![ &mut account2_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // fund first account do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::success()], ); // no transfer if either account is frozen let mut account = Account::unpack_unchecked(&account2_account.data).unwrap(); account.state = AccountState::Frozen; Account::pack(account, &mut account2_account.data).unwrap(); do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &owner_key, &[], 500, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::err(TokenError::AccountFrozen.into())], ); let mut account = Account::unpack_unchecked(&account_account.data).unwrap(); account.state = AccountState::Initialized; Account::pack(account, &mut account_account.data).unwrap(); let mut account = Account::unpack_unchecked(&account2_account.data).unwrap(); account.state = AccountState::Frozen; Account::pack(account, &mut account2_account.data).unwrap(); do_process_instruction( #[allow(deprecated)] transfer( &program_id, &account_key, &account2_key, &owner_key, &[], 500, ) .unwrap(), vec![ &mut account_account, &mut account2_account, &mut owner_account, ], &[Check::err(TokenError::AccountFrozen.into())], ); // no approve if account is frozen let mut account = Account::unpack_unchecked(&account_account.data).unwrap(); account.state = AccountState::Frozen; Account::pack(account, &mut account_account.data).unwrap(); let delegate_key = Address::new_unique(); let mut delegate_account = SolanaAccount::default(); do_process_instruction( approve( &program_id, &account_key, &delegate_key, &owner_key, &[], 100, ) .unwrap(), vec![ &mut account_account, &mut delegate_account, &mut owner_account, ], &[Check::err(TokenError::AccountFrozen.into())], ); // no revoke if account is frozen let mut account = Account::unpack_unchecked(&account_account.data).unwrap(); account.delegate = COption::Some(delegate_key); account.delegated_amount = 100; Account::pack(account, &mut account_account.data).unwrap(); do_process_instruction( revoke(&program_id, &account_key, &owner_key, &[]).unwrap(), vec![&mut account_account, &mut owner_account], &[Check::err(TokenError::AccountFrozen.into())], ); // no set authority if account is frozen let new_owner_key = Address::new_unique(); do_process_instruction( set_authority( &program_id, &account_key, Some(&new_owner_key), AuthorityType::AccountOwner, &owner_key, &[], ) .unwrap(), vec![&mut account_account, &mut owner_account], &[Check::err(TokenError::AccountFrozen.into())], ); // no mint_to if destination account is frozen do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 100).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::err(TokenError::AccountFrozen.into())], ); // no burn if account is frozen do_process_instruction( burn(&program_id, &account_key, &mint_key, &owner_key, &[], 100).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::err(TokenError::AccountFrozen.into())], ); } #[test] fn test_freeze_thaw_dups() { let program_id = crate::id(); let account1_key = Address::new_unique(); let mut account1_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account1_info: AccountInfo = (&account1_key, true, &mut account1_account).into(); let owner_key = Address::new_unique(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into(); let rent_key = rent::id(); let mut rent_sysvar = rent_sysvar(); let rent_info: AccountInfo = (&rent_key, false, &mut rent_sysvar).into(); // create mint do_process_instruction_dups( initialize_mint(&program_id, &mint_key, &owner_key, Some(&account1_key), 2).unwrap(), vec![mint_info.clone(), rent_info.clone()], &[Check::success()], ); // create account do_process_instruction_dups( initialize_account(&program_id, &account1_key, &mint_key, &account1_key).unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), rent_info.clone(), ], &[Check::success()], ); // freeze where mint freeze_authority is account do_process_instruction_dups( freeze_account(&program_id, &account1_key, &mint_key, &account1_key, &[]).unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), ], &[Check::success()], ); // thaw where mint freeze_authority is account let mut account = Account::unpack_unchecked(&account1_info.data.borrow()).unwrap(); account.state = AccountState::Frozen; Account::pack(account, &mut account1_info.data.borrow_mut()).unwrap(); do_process_instruction_dups( thaw_account(&program_id, &account1_key, &mint_key, &account1_key, &[]).unwrap(), vec![ account1_info.clone(), mint_info.clone(), account1_info.clone(), ], &[Check::success()], ); } #[test] fn test_freeze_account() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let account_owner_key = Address::new_unique(); let mut account_owner_account = SolanaAccount::default(); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let owner2_key = Address::new_unique(); let mut owner2_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create new mint with owner different from account owner do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // create account do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &account_owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut account_owner_account, &mut rent_sysvar, ], &[Check::success()], ); // mint to account do_process_instruction( mint_to(&program_id, &mint_key, &account_key, &owner_key, &[], 1000).unwrap(), vec![&mut mint_account, &mut account_account, &mut owner_account], &[Check::success()], ); // mint cannot freeze do_process_instruction( freeze_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::err(TokenError::MintCannotFreeze.into())], ); // missing freeze_authority let mut mint = Mint::unpack_unchecked(&mint_account.data).unwrap(); mint.freeze_authority = COption::Some(owner_key); Mint::pack(mint, &mut mint_account.data).unwrap(); do_process_instruction( freeze_account(&program_id, &account_key, &mint_key, &owner2_key, &[]).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner2_account], &[Check::err(TokenError::OwnerMismatch.into())], ); // check explicit thaw do_process_instruction( thaw_account(&program_id, &account_key, &mint_key, &owner2_key, &[]).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner2_account], &[Check::err(TokenError::InvalidState.into())], ); // freeze do_process_instruction( freeze_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::success()], ); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.state, AccountState::Frozen); // check explicit freeze do_process_instruction( freeze_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::err(TokenError::InvalidState.into())], ); // check thaw authority do_process_instruction( thaw_account(&program_id, &account_key, &mint_key, &owner2_key, &[]).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner2_account], &[Check::err(TokenError::OwnerMismatch.into())], ); // thaw do_process_instruction( thaw_account(&program_id, &account_key, &mint_key, &owner_key, &[]).unwrap(), vec![&mut account_account, &mut mint_account, &mut owner_account], &[Check::success()], ); let account = Account::unpack_unchecked(&account_account.data).unwrap(); assert_eq!(account.state, AccountState::Initialized); } #[test] fn test_initialize_account2_and_3() { let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mut account2_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let mut account3_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // create mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); do_process_instruction( initialize_account(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![ &mut account_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); do_process_instruction( initialize_account2(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![&mut account2_account, &mut mint_account, &mut rent_sysvar], &[Check::success()], ); assert_eq!(account_account, account2_account); do_process_instruction( initialize_account3(&program_id, &account_key, &mint_key, &owner_key).unwrap(), vec![&mut account3_account, &mut mint_account], &[Check::success()], ); assert_eq!(account_account, account3_account); } #[test] fn initialize_account_on_non_transferable_mint() { let program_id = crate::id(); let account = Address::new_unique(); let account_len = ExtensionType::try_calculate_account_len::(&[ ExtensionType::NonTransferableAccount, ]) .unwrap(); let mut account_without_enough_length = SolanaAccount::new( Rent::default().minimum_balance(account_len), account_len, &program_id, ); let account2 = Address::new_unique(); let account2_len = ExtensionType::try_calculate_account_len::(&[ ExtensionType::NonTransferableAccount, ExtensionType::ImmutableOwner, ]) .unwrap(); let mut account_with_enough_length = SolanaAccount::new( Rent::default().minimum_balance(account2_len), account2_len, &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let mint_key = Address::new_unique(); let mint_len = ExtensionType::try_calculate_account_len::(&[ExtensionType::NonTransferable]) .unwrap(); let mut mint_account = SolanaAccount::new( Rent::default().minimum_balance(mint_len), mint_len, &program_id, ); let mut rent_sysvar = rent_sysvar(); // create a non-transferable mint do_process_instruction( initialize_non_transferable_mint(&program_id, &mint_key).unwrap(), vec![&mut mint_account], &[Check::success()], ); do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); //fail when account space is not enough for adding the immutable ownership // extension do_process_instruction( initialize_account(&program_id, &account, &mint_key, &owner_key).unwrap(), vec![ &mut account_without_enough_length, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::err(ProgramError::InvalidAccountData)], ); //success to initialize an account with enough data space do_process_instruction( initialize_account(&program_id, &account2, &mint_key, &owner_key).unwrap(), vec![ &mut account_with_enough_length, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); } #[test] fn test_sync_native() { let program_id = crate::id(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let native_account_key = Address::new_unique(); let lamports = 40; let mut native_account = SolanaAccount::new( account_minimum_balance() + lamports, Account::get_packed_len(), &program_id, ); let non_native_account_key = Address::new_unique(); let mut non_native_account = SolanaAccount::new( account_minimum_balance() + 50, Account::get_packed_len(), &program_id, ); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let mut rent_sysvar = rent_sysvar(); // initialize non-native mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); // initialize non-native account do_process_instruction( initialize_account(&program_id, &non_native_account_key, &mint_key, &owner_key) .unwrap(), vec![ &mut non_native_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); let account = Account::unpack_unchecked(&non_native_account.data).unwrap(); assert!(!account.is_native()); assert_eq!(account.amount, 0); // fail sync non-native do_process_instruction( sync_native(&program_id, &non_native_account_key).unwrap(), vec![&mut non_native_account], &[Check::err(TokenError::NonNativeNotSupported.into())], ); // fail sync uninitialized do_process_instruction( sync_native(&program_id, &native_account_key).unwrap(), vec![&mut native_account], &[Check::err(ProgramError::UninitializedAccount)], ); // wrap native account do_process_instruction( initialize_account( &program_id, &native_account_key, &crate::native_mint::id(), &owner_key, ) .unwrap(), vec![ &mut native_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); // fail sync, not owned by program let not_program_id = Address::new_unique(); native_account.owner = not_program_id; do_process_instruction( sync_native(&program_id, &native_account_key).unwrap(), vec![&mut native_account], &[Check::err(ProgramError::IncorrectProgramId)], ); native_account.owner = program_id; let account = Account::unpack_unchecked(&native_account.data).unwrap(); assert!(account.is_native()); assert_eq!(account.amount, lamports); // sync, no change do_process_instruction( sync_native(&program_id, &native_account_key).unwrap(), vec![&mut native_account], &[Check::success()], ); let account = Account::unpack_unchecked(&native_account.data).unwrap(); assert_eq!(account.amount, lamports); // transfer sol let new_lamports = lamports + 50; native_account.lamports = account_minimum_balance() + new_lamports; // success sync do_process_instruction( sync_native(&program_id, &native_account_key).unwrap(), vec![&mut native_account], &[Check::success()], ); let account = Account::unpack_unchecked(&native_account.data).unwrap(); assert_eq!(account.amount, new_lamports); // reduce sol native_account.lamports -= 1; // succeed sync with reduced value do_process_instruction( sync_native(&program_id, &native_account_key).unwrap(), vec![&mut native_account], &[Check::success()], ); let account = Account::unpack_unchecked(&native_account.data).unwrap(); assert_eq!(account.amount, new_lamports - 1); } #[test] fn test_get_account_data_size() { let program_id = crate::id(); let owner_key = Address::new_unique(); let mut owner_account = SolanaAccount::default(); let mut rent_sysvar = rent_sysvar(); // Base mint let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mint_key = Address::new_unique(); do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); do_process_instruction( get_account_data_size(&program_id, &mint_key, &[]).unwrap(), vec![&mut mint_account], &[ Check::success(), Check::return_data( &ExtensionType::try_calculate_account_len::(&[]) .unwrap() .to_le_bytes(), ), ], ); do_process_instruction( get_account_data_size( &program_id, &mint_key, &[ ExtensionType::TransferFeeAmount, ExtensionType::TransferFeeAmount, // Duplicate user input ignored... ], ) .unwrap(), vec![&mut mint_account], &[ Check::success(), Check::return_data( &ExtensionType::try_calculate_account_len::(&[ ExtensionType::TransferFeeAmount, ]) .unwrap() .to_le_bytes(), ), ], ); // Native mint let mut mint_account = native_mint(); do_process_instruction( get_account_data_size(&program_id, &mint_key, &[]).unwrap(), vec![&mut mint_account], &[ Check::success(), Check::return_data( &ExtensionType::try_calculate_account_len::(&[]) .unwrap() .to_le_bytes(), ), ], ); // Extended mint let mint_len = ExtensionType::try_calculate_account_len::(&[ExtensionType::TransferFeeConfig]) .unwrap(); let mut extended_mint_account = SolanaAccount::new( Rent::default().minimum_balance(mint_len), mint_len, &program_id, ); let extended_mint_key = Address::new_unique(); do_process_instruction( initialize_transfer_fee_config(&program_id, &extended_mint_key, None, None, 10, 4242) .unwrap(), vec![&mut extended_mint_account], &[Check::success()], ); do_process_instruction( initialize_mint(&program_id, &extended_mint_key, &owner_key, None, 2).unwrap(), vec![&mut extended_mint_account, &mut rent_sysvar], &[Check::success()], ); do_process_instruction( get_account_data_size(&program_id, &mint_key, &[]).unwrap(), vec![&mut extended_mint_account], &[ Check::success(), Check::return_data( &ExtensionType::try_calculate_account_len::(&[ ExtensionType::TransferFeeAmount, ]) .unwrap() .to_le_bytes(), ), ], ); do_process_instruction( get_account_data_size( &program_id, &mint_key, // User extension that's also added by the mint ignored... &[ExtensionType::TransferFeeAmount], ) .unwrap(), vec![&mut extended_mint_account], &[ Check::success(), Check::return_data( &ExtensionType::try_calculate_account_len::(&[ ExtensionType::TransferFeeAmount, ]) .unwrap() .to_le_bytes(), ), ], ); // Invalid mint let mut invalid_mint_account = SolanaAccount::new( account_minimum_balance(), Account::get_packed_len(), &program_id, ); let invalid_mint_key = Address::new_unique(); do_process_instruction( initialize_account(&program_id, &invalid_mint_key, &mint_key, &owner_key).unwrap(), vec![ &mut invalid_mint_account, &mut mint_account, &mut owner_account, &mut rent_sysvar, ], &[Check::success()], ); do_process_instruction( get_account_data_size(&program_id, &invalid_mint_key, &[]).unwrap(), vec![&mut invalid_mint_account], &[Check::err(TokenError::InvalidMint.into())], ); // Invalid mint owner let invalid_program_id = Address::new_unique(); let mut invalid_mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let invalid_mint_key = Address::new_unique(); let instruction = initialize_mint(&program_id, &invalid_mint_key, &owner_key, None, 2).unwrap(); do_process_instruction( instruction, vec![&mut invalid_mint_account, &mut rent_sysvar], &[Check::success()], ); invalid_mint_account.owner = invalid_program_id; do_process_instruction( get_account_data_size(&program_id, &invalid_mint_key, &[]).unwrap(), vec![&mut invalid_mint_account], &[Check::err(ProgramError::IncorrectProgramId)], ); // Invalid Extension Type for mint and uninitialized account do_process_instruction( get_account_data_size(&program_id, &mint_key, &[ExtensionType::Uninitialized]).unwrap(), vec![&mut mint_account], &[Check::err(TokenError::ExtensionTypeMismatch.into())], ); do_process_instruction( get_account_data_size( &program_id, &mint_key, &[ ExtensionType::MemoTransfer, ExtensionType::MintCloseAuthority, ], ) .unwrap(), vec![&mut mint_account], &[Check::err(TokenError::ExtensionTypeMismatch.into())], ); } #[test] fn test_amount_to_ui_amount() { let program_id = crate::id(); let owner_key = Address::new_unique(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // fail if an invalid mint is passed in do_process_instruction( amount_to_ui_amount(&program_id, &mint_key, 110).unwrap(), vec![&mut mint_account], &[Check::err(TokenError::InvalidMint.into())], ); // create mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); do_process_instruction( amount_to_ui_amount(&program_id, &mint_key, 23).unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data("0.23".as_bytes())], ); do_process_instruction( amount_to_ui_amount(&program_id, &mint_key, 110).unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data("1.1".as_bytes())], ); do_process_instruction( amount_to_ui_amount(&program_id, &mint_key, 4200).unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data("42".as_bytes())], ); do_process_instruction( amount_to_ui_amount(&program_id, &mint_key, 0).unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data("0".as_bytes())], ); } #[test] fn test_ui_amount_to_amount() { let program_id = crate::id(); let owner_key = Address::new_unique(); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); // fail if an invalid mint is passed in do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "1.1").unwrap(), vec![&mut mint_account], &[Check::err(TokenError::InvalidMint.into())], ); // create mint do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "0.23").unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data(&23u64.to_le_bytes())], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "0.20").unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data(&20u64.to_le_bytes())], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "0.2000").unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data(&20u64.to_le_bytes())], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, ".20").unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data(&20u64.to_le_bytes())], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "1.1").unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data(&110u64.to_le_bytes())], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "1.10").unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data(&110u64.to_le_bytes())], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "42").unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data(&4200u64.to_le_bytes())], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "42.").unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data(&4200u64.to_le_bytes())], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "0").unwrap(), vec![&mut mint_account], &[Check::success(), Check::return_data(&0u64.to_le_bytes())], ); // fail if invalid ui_amount passed in do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "").unwrap(), vec![&mut mint_account], &[Check::err(ProgramError::InvalidArgument)], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, ".").unwrap(), vec![&mut mint_account], &[Check::err(ProgramError::InvalidArgument)], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "0.111").unwrap(), vec![&mut mint_account], &[Check::err(ProgramError::InvalidArgument)], ); do_process_instruction( ui_amount_to_amount(&program_id, &mint_key, "0.t").unwrap(), vec![&mut mint_account], &[Check::err(ProgramError::InvalidArgument)], ); } #[test] fn test_withdraw_excess_lamports_from_multisig() { let program_id = crate::id(); let mut lamports = 0; let mut destination_data = vec![]; let system_program_id = system_program::id(); let destination_key = Address::new_unique(); let destination_info = AccountInfo::new( &destination_key, true, false, &mut lamports, &mut destination_data, &system_program_id, false, ); let multisig_key = Address::new_unique(); let mut multisig_account = SolanaAccount::new(0, Multisig::get_packed_len(), &program_id); let excess_lamports = 4_000_000_000_000; multisig_account.lamports = excess_lamports + multisig_minimum_balance(); let mut signer_keys = [Address::default(); MAX_SIGNERS]; for signer_key in signer_keys.iter_mut().take(MAX_SIGNERS) { *signer_key = Address::new_unique(); } let signer_refs: Vec<&Address> = signer_keys.iter().collect(); let mut signer_lamports = 0; let mut signer_data = vec![]; let mut signers: Vec> = vec![ AccountInfo::new( &destination_key, true, false, &mut signer_lamports, &mut signer_data, &program_id, false, ); MAX_SIGNERS + 1 ]; for (signer, key) in signers.iter_mut().zip(&signer_keys) { signer.key = key; } let mut multisig = Multisig::unpack_unchecked(&vec![0; Multisig::get_packed_len()]).unwrap(); multisig.m = MAX_SIGNERS as u8; multisig.n = MAX_SIGNERS as u8; multisig.signers = signer_keys; multisig.is_initialized = true; Multisig::pack(multisig, &mut multisig_account.data).unwrap(); let multisig_info: AccountInfo = (&multisig_key, true, &mut multisig_account).into(); let mut signers_infos = vec![ multisig_info.clone(), destination_info.clone(), multisig_info.clone(), ]; signers_infos.extend(signers); do_process_instruction_dups( withdraw_excess_lamports( &program_id, &multisig_key, &destination_key, &multisig_key, &signer_refs, ) .unwrap(), signers_infos, &[Check::success()], ); assert_eq!(destination_info.lamports(), excess_lamports); } #[test] fn test_withdraw_excess_lamports_from_account() { let excess_lamports = 4_000_000_000_000; let program_id = crate::id(); let account_key = Address::new_unique(); let mut account_account = SolanaAccount::new( excess_lamports + account_minimum_balance(), Account::get_packed_len(), &program_id, ); let system_program_id = system_program::id(); let owner_key = Address::new_unique(); let mut destination_lamports = 0; let mut destination_data = vec![]; let destination_key = Address::new_unique(); let destination_info = AccountInfo::new( &destination_key, true, false, &mut destination_lamports, &mut destination_data, &system_program_id, false, ); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new(mint_minimum_balance(), Mint::get_packed_len(), &program_id); let mut rent_sysvar = rent_sysvar(); do_process_instruction( initialize_mint(&program_id, &mint_key, &owner_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); let mint_info = AccountInfo::new( &mint_key, true, false, &mut mint_account.lamports, &mut mint_account.data, &program_id, false, ); let account_info: AccountInfo = (&account_key, true, &mut account_account).into(); do_process_instruction_dups( initialize_account3(&program_id, &account_key, &mint_key, &account_key).unwrap(), vec![account_info.clone(), mint_info.clone()], &[Check::success()], ); do_process_instruction_dups( withdraw_excess_lamports( &program_id, &account_key, &destination_key, &account_key, &[], ) .unwrap(), vec![ account_info.clone(), destination_info.clone(), account_info.clone(), ], &[Check::success()], ); assert_eq!(destination_info.lamports(), excess_lamports); } #[test] fn test_withdraw_excess_lamports_from_mint() { let excess_lamports = 4_000_000_000_000; let program_id = crate::id(); let system_program_id = system_program::id(); let mut destination_lamports = 0; let mut destination_data = vec![]; let destination_key = Address::new_unique(); let destination_info = AccountInfo::new( &destination_key, true, false, &mut destination_lamports, &mut destination_data, &system_program_id, false, ); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new( excess_lamports + mint_minimum_balance(), Mint::get_packed_len(), &program_id, ); let mut rent_sysvar = rent_sysvar(); do_process_instruction( initialize_mint(&program_id, &mint_key, &mint_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into(); do_process_instruction_dups( withdraw_excess_lamports(&program_id, &mint_key, &destination_key, &mint_key, &[]) .unwrap(), vec![ mint_info.clone(), destination_info.clone(), mint_info.clone(), ], &[Check::success()], ); assert_eq!(destination_info.lamports(), excess_lamports); } #[test] fn test_withdraw_excess_lamports_from_mint_with_no_mint_authority() { let excess_lamports = 4_000_000_000_000; let program_id = crate::id(); let system_program_id = system_program::id(); let mut destination_lamports = 0; let mut destination_data = vec![]; let destination_key = Address::new_unique(); let destination_info = AccountInfo::new( &destination_key, true, false, &mut destination_lamports, &mut destination_data, &system_program_id, false, ); let mint_key = Address::new_unique(); let mut mint_account = SolanaAccount::new( excess_lamports + mint_minimum_balance(), Mint::get_packed_len(), &program_id, ); let mut mint_authority_lamports = 0; let mut mint_authority_data = vec![]; let mint_authority_key = Address::new_unique(); let mint_authority_info = AccountInfo::new( &mint_authority_key, true, false, &mut mint_authority_lamports, &mut mint_authority_data, &system_program_id, false, ); let mut rent_sysvar = rent_sysvar(); do_process_instruction( initialize_mint(&program_id, &mint_key, &mint_authority_key, None, 2).unwrap(), vec![&mut mint_account, &mut rent_sysvar], &[Check::success()], ); let mint_info: AccountInfo = (&mint_key, true, &mut mint_account).into(); // fail when withdrawing with the mint as authority when there is // a mint authority set do_process_instruction_dups( withdraw_excess_lamports(&program_id, &mint_key, &destination_key, &mint_key, &[]) .unwrap(), vec![ mint_info.clone(), destination_info.clone(), mint_info.clone(), ], &[Check::err(TokenError::OwnerMismatch.into())], ); do_process_instruction_dups( set_authority( &program_id, &mint_key, None, AuthorityType::MintTokens, &mint_authority_key, &[], ) .unwrap(), vec![mint_info.clone(), mint_authority_info.clone()], &[Check::success()], ); // fail when withdrawing with the previous mint authority do_process_instruction_dups( withdraw_excess_lamports( &program_id, &mint_key, &destination_key, &mint_authority_key, &[], ) .unwrap(), vec![ mint_info.clone(), destination_info.clone(), mint_authority_info.clone(), ], &[Check::err(TokenError::AuthorityTypeNotSupported.into())], ); do_process_instruction_dups( withdraw_excess_lamports(&program_id, &mint_key, &destination_key, &mint_key, &[]) .unwrap(), vec![ mint_info.clone(), destination_info.clone(), mint_info.clone(), ], &[Check::success()], ); assert_eq!(destination_info.lamports(), excess_lamports); } }