Struct account_compression::processor::initialize_address_merkle_tree::InterfaceAccount

pub struct InterfaceAccount<'info, T>
where
    T: AccountSerialize + AccountDeserialize + Clone,
{ /* private fields */ }

Wrapper around AccountInfo that verifies program ownership and deserializes underlying data into a Rust type.

Table of Contents

• Basic Functionality
• Using InterfaceAccount with non-anchor types
• Out of the box wrapper types

Basic Functionality

InterfaceAccount checks that T::owners().contains(Account.info.owner). This means that the data type that Accounts wraps around (=T) needs to implement the Owners trait. The #[account] attribute implements the Owners trait for a struct using multiple crate::IDs declared by declareId in the same program. It follows that InterfaceAccount can also be used with a T that comes from a different program.

Checks:

• T::owners().contains(InterfaceAccount.info.owner)
• !(InterfaceAccount.info.owner == SystemProgram && InterfaceAccount.info.lamports() == 0)

Example

use anchor_lang::prelude::*;
use other_program::Auth;

declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");

#[program]
mod hello_anchor {
    use super::*;
    pub fn set_data(ctx: Context<SetData>, data: u64) -> Result<()> {
        if (*ctx.accounts.auth_account).authorized {
            (*ctx.accounts.my_account).data = data;
        }
        Ok(())
    }
}

#[account]
#[derive(Default)]
pub struct MyData {
    pub data: u64
}

#[derive(Accounts)]
pub struct SetData<'info> {
    #[account(mut)]
    pub my_account: InterfaceAccount<'info, MyData> // checks that my_account.info.owner == Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS
    pub auth_account: InterfaceAccount<'info, Auth> // checks that auth_account.info.owner == FEZGUxNhZWpYPj9MJCrZJvUo1iF9ys34UHx52y4SzVW9
}

// In a different program

...
declare_id!("FEZGUxNhZWpYPj9MJCrZJvUo1iF9ys34UHx52y4SzVW9");
#[account]
#[derive(Default)]
pub struct Auth {
    pub authorized: bool
}
...

Using InterfaceAccount with non-anchor programs

InterfaceAccount can also be used with non-anchor programs. The data types from those programs are not annotated with #[account] so you have to

• create a wrapper type around the structs you want to wrap with InterfaceAccount
• implement the functions required by InterfaceAccount yourself instead of using #[account]. You only have to implement a fraction of the functions #[account] generates. See the example below for the code you have to write.

The mint wrapper type that Anchor provides out of the box for the token program (source)

#[derive(Clone)]
pub struct Mint(spl_token::state::Mint);

// This is necessary so we can use "anchor_spl::token::Mint::LEN"
// because rust does not resolve "anchor_spl::token::Mint::LEN" to
// "spl_token::state::Mint::LEN" automatically
impl Mint {
    pub const LEN: usize = spl_token::state::Mint::LEN;
}

// You don't have to implement the "try_deserialize" function
// from this trait. It delegates to
// "try_deserialize_unchecked" by default which is what we want here
// because non-anchor accounts don't have a discriminator to check
impl anchor_lang::AccountDeserialize for Mint {
    fn try_deserialize_unchecked(buf: &mut &[u8]) -> Result<Self> {
        spl_token::state::Mint::unpack(buf).map(Mint)
    }
}
// AccountSerialize defaults to a no-op which is what we want here
// because it's a foreign program, so our program does not
// have permission to write to the foreign program's accounts anyway
impl anchor_lang::AccountSerialize for Mint {}

impl anchor_lang::Owner for Mint {
    fn owner() -> Pubkey {
        // pub use spl_token::ID is used at the top of the file
        ID
    }
}

// Implement the "std::ops::Deref" trait for better user experience
impl Deref for Mint {
    type Target = spl_token::state::Mint;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

Out of the box wrapper types

SPL Types

Anchor provides wrapper types to access accounts owned by the token programs. Use

use anchor_spl::token_interface::TokenAccount;

#[derive(Accounts)]
pub struct Example {
    pub my_acc: InterfaceAccount<'info, TokenAccount>
}

to access token accounts and

use anchor_spl::token_interface::Mint;

#[derive(Accounts)]
pub struct Example {
    pub my_acc: InterfaceAccount<'info, Mint>
}

to access mint accounts.

Implementations

impl<'a, T> InterfaceAccount<'a, T>

where T: AccountSerialize + AccountDeserialize + Clone,

pub fn reload(&mut self) -> Result<(), Error>

Reloads the account from storage. This is useful, for example, when observing side effects after CPI.

pub fn into_inner(self) -> T

pub fn set_inner(&mut self, inner: T)

Sets the inner account.

Instead of this:

pub fn new_user(ctx: Context<CreateUser>, new_user:User) -> Result<()> {
    (*ctx.accounts.user_to_create).name = new_user.name;
    (*ctx.accounts.user_to_create).age = new_user.age;
    (*ctx.accounts.user_to_create).address = new_user.address;
}

You can do this:

pub fn new_user(ctx: Context<CreateUser>, new_user:User) -> Result<()> {
    ctx.accounts.user_to_create.set_inner(new_user);
}

impl<'a, T> InterfaceAccount<'a, T>

where T: AccountSerialize + AccountDeserialize + CheckOwner + Clone,

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

Deserializes the given info into a InterfaceAccount.

pub fn try_from_unchecked( info: &'a AccountInfo<'a>, ) -> Result<InterfaceAccount<'a, T>, Error>

Deserializes the given info into a InterfaceAccount without checking the account discriminator. Be careful when using this and avoid it if possible.

Trait Implementations

impl<'info, B, T> Accounts<'info, B> for InterfaceAccount<'info, T>

where T: AccountSerialize + AccountDeserialize + CheckOwner + Clone,

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

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> AccountsClose<'info> for InterfaceAccount<'info, T>

where T: AccountSerialize + AccountDeserialize + Clone,

fn close(&self, sol_destination: AccountInfo<'info>) -> Result<(), Error>

impl<'info, T> AccountsExit<'info> for InterfaceAccount<'info, T>

where T: AccountSerialize + AccountDeserialize + Owners + Clone,

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

program_id is the currently executing program.

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

where T: AccountSerialize + AccountDeserialize + Clone,

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

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

impl<'info, T> AsRef<T> for InterfaceAccount<'info, T>

where T: AccountSerialize + AccountDeserialize + Clone,

fn as_ref(&self) -> &T

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

impl<'info, T> Clone for InterfaceAccount<'info, T>

where T: Clone + AccountSerialize + AccountDeserialize,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'info, T> Debug for InterfaceAccount<'info, T>

where T: AccountSerialize + AccountDeserialize + Clone + Debug,

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

Formats the value using the given formatter.

impl<'a, T> Deref for InterfaceAccount<'a, T>

where T: AccountSerialize + AccountDeserialize + Clone,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<InterfaceAccount<'a, T> as Deref>::Target

Dereferences the value.

impl<'a, T> DerefMut for InterfaceAccount<'a, T>

where T: AccountSerialize + AccountDeserialize + Clone,

fn deref_mut(&mut self) -> &mut <InterfaceAccount<'a, T> as Deref>::Target

Mutably dereferences the value.

impl<'info, T> Key for InterfaceAccount<'info, T>

where T: AccountSerialize + AccountDeserialize + Clone,

fn key(&self) -> Pubkey

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

where T: AccountSerialize + AccountDeserialize + Clone,

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

impl<'info, T> ToAccountMetas for InterfaceAccount<'info, T>

where T: AccountSerialize + AccountDeserialize + Clone,

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.