Struct Program 

pub struct Program<'info, T: Id + Clone> { /* 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
• Out of the Box Types

Basic Functionality

Checks:

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

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.

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: Id + Clone> Program<'a, T>

pub fn try_from(info: &AccountInfo<'a>) -> Result<Program<'a, T>>

Deserializes the given info into a Program.

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

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

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

pub fn unsigned_key(&self) -> &Pubkey

pub fn lamports(&self) -> u64

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

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 realloc( &self, new_len: usize, zero_init: bool, ) -> Result<(), ProgramError>

Realloc the account’s data and optionally zero-initialize the new memory.

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

Note: Memory used to grow is already zero-initialized upon program entrypoint and re-zeroing it wastes compute units. If within the same call a program reallocs from larger to smaller and back to larger again the new space could contain stale data. Pass true for zero_init in this case, otherwise compute units will be wasted re-zero-initializing.

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

pub fn deserialize_data<T>(&self) -> Result<T, Box<ErrorKind>>

where T: DeserializeOwned,

pub fn serialize_data<T>(&self, state: &T) -> Result<(), Box<ErrorKind>>

where T: Serialize,

Trait Implementations

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

where T: Id + Clone,

fn try_accounts( _program_id: &Pubkey, accounts: &mut &[AccountInfo<'info>], _ix_data: &[u8], _bumps: &mut BTreeMap<String, u8>, ) -> 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 + Id + Clone> AccountsExit<'info> for Program<'info, T>

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

program_id is the currently executing program.

impl<'info, T: Id + Clone> 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 + Id + 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<'info, T: Id + Clone + Debug> Debug for Program<'info, T>

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

Formats the value using the given formatter.

impl<'info, T: Id + Clone> Deref for Program<'info, T>

type Target = AccountInfo<'info>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'info, T: AccountDeserialize + Id + Clone> Key for Program<'info, T>

fn key(&self) -> Pubkey

impl<'info, T: Id + Clone> ToAccountInfos<'info> for Program<'info, T>

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

impl<'info, T: Id + Clone> ToAccountMetas for Program<'info, 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.