Struct Program 

pub struct Program<'info, T = ()> { /* private fields */ }

Type validating that the account is the given Program

The type has a programdata_address function that will return Option::Some if the program is owned by the BPFUpgradeableLoader which will contain the programdata_address property of the Program variant of the UpgradeableLoaderState enum.

Table of Contents

• Basic Functionality
• Generic Program Validation
• Out of the Box Types

Basic Functionality

For Program<'info, T> where T implements Id: Checks:

• account_info.key == expected_program
• account_info.executable == true

Generic Program Validation

For Program<'info> (without type parameter):

• Only checks: account_info.executable == true
• Use this when you only need to verify that an address is executable, without validating against a specific program ID.

Example

#[program]
mod my_program {
    fn set_admin_settings(...){...}
}

#[account]
#[derive(Default)]
pub struct AdminSettings {
    ...
}

#[derive(Accounts)]
pub struct SetAdminSettings<'info> {
    #[account(mut, seeds = [b"admin"], bump)]
    pub admin_settings: Account<'info, AdminSettings>,
    #[account(constraint = program.programdata_address()? == Some(program_data.key()))]
    pub program: Program<'info, MyProgram>,
    #[account(constraint = program_data.upgrade_authority_address == Some(authority.key()))]
    pub program_data: Account<'info, ProgramData>,
    pub authority: Signer<'info>,
}

The given program has a function with which the upgrade authority can set admin settings.

The required constraints are as follows:

• program is the account of the program itself. Its constraint checks that program_data is the account that contains the program’s upgrade authority. Implicitly, this checks that program is a BPFUpgradeable program (program.programdata_address()? will be None if it’s not).
• program_data’s constraint checks that its upgrade authority is the authority account.
• Finally, authority needs to sign the transaction.

Generic Program Example

#[derive(Accounts)]
pub struct ValidateExecutableProgram<'info> {
    // Only validates that the provided account is executable
    pub any_program: Program<'info>,
    pub authority: Signer<'info>,
}

Out of the Box Types

Between the anchor_lang and anchor_spl crates, the following Program types are provided out of the box:

• System
• AssociatedToken
• Token

Implementations

impl<'a, T> Program<'a, T>

pub fn programdata_address(&self) -> Result<Option<Pubkey>>

Methods from Deref<Target = AccountInfo<'info>>

pub fn signer_key(&self) -> Option<&Address>

pub fn unsigned_key(&self) -> &Address

pub fn lamports(&self) -> u64

pub fn try_lamports(&self) -> Result<u64, ProgramError>

pub unsafe fn original_data_len(&self) -> usize

Return the account’s original data length when it was serialized for the current program invocation.

Safety

This method assumes that the original data length was serialized as a u32 integer in the 4 bytes immediately preceding the serialized account key.

pub fn data_len(&self) -> usize

pub fn try_data_len(&self) -> Result<usize, ProgramError>

pub fn data_is_empty(&self) -> bool

pub fn try_data_is_empty(&self) -> Result<bool, ProgramError>

pub fn try_borrow_lamports(&self) -> Result<Ref<'_, &mut u64>, ProgramError>

pub fn try_borrow_mut_lamports( &self, ) -> Result<RefMut<'_, &'a mut u64>, ProgramError>

pub fn try_borrow_data(&self) -> Result<Ref<'_, &mut [u8]>, ProgramError>

pub fn try_borrow_mut_data( &self, ) -> Result<RefMut<'_, &'a mut [u8]>, ProgramError>

pub fn resize(&self, new_len: usize) -> Result<(), ProgramError>

Resize the account’s data: Either truncating or zero extending.

Note: Account data can be increased within a single call by up to solana_program::entrypoint::MAX_PERMITTED_DATA_INCREASE bytes.

Safety

This method makes assumptions about the layout and location of memory referenced by AccountInfo fields. It should only be called for instances of AccountInfo that were created by the runtime and received in the process_instruction entrypoint of a program.

pub fn assign(&self, new_owner: &Address)

Trait Implementations

impl<'info, B, T: Id> Accounts<'info, B> for Program<'info, T>

fn try_accounts( _program_id: &Pubkey, accounts: &mut &'info [AccountInfo<'info>], _ix_data: &[u8], _bumps: &mut B, _reallocs: &mut BTreeSet<Pubkey>, ) -> Result<Self>

Returns the validated accounts struct. What constitutes “valid” is program dependent. However, users of these types should never have to worry about account substitution attacks. For example, if a program expects a Mint account from the SPL token program in a particular field, then it should be impossible for this method to return Ok if any other account type is given–from the SPL token program or elsewhere.

impl<'info, T: AccountDeserialize> AccountsExit<'info> for Program<'info, T>

fn exit(&self, _program_id: &Pubkey) -> Result<()>

program_id is the currently executing program.

impl<'info, T> AsRef<AccountInfo<'info>> for Program<'info, T>

fn as_ref(&self) -> &AccountInfo<'info>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'info, T: Clone> Clone for Program<'info, T>

fn clone(&self) -> Program<'info, T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Program<'_, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'info, T> Deref for Program<'info, T>

type Target = AccountInfo<'info>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: AccountDeserialize> Key for Program<'_, T>

fn key(&self) -> Pubkey

impl<'info, T> ToAccountInfos<'info> for Program<'info, T>

fn to_account_infos(&self) -> Vec<AccountInfo<'info>>

impl<T> ToAccountMetas for Program<'_, T>

fn to_account_metas(&self, is_signer: Option<bool>) -> Vec<AccountMeta>

is_signer is given as an optional override for the signer meta field. This covers the edge case when a program-derived-address needs to relay a transaction from a client to another program but sign the transaction before the relay. The client cannot mark the field as a signer, and so we have to override the is_signer meta field given by the client.

impl<'a, T: Id> TryFrom<&'a AccountInfo<'a>> for Program<'a, T>

fn try_from(info: &'a AccountInfo<'a>) -> Result<Self>

Deserializes the given info into a Program.

type Error = Error

The type returned in the event of a conversion error.