Struct AccountInfo 

#[repr(C)]
pub struct AccountInfo<'a> {
    pub key: &'a Pubkey,
    pub lamports: Rc<RefCell<&'a mut u64>>,
    pub data: Rc<RefCell<&'a mut [u8]>>,
    pub owner: &'a Pubkey,
    pub rent_epoch: u64,
    pub is_signer: bool,
    pub is_writable: bool,
    pub executable: bool,
}

Account information

Fields

key: &'a Pubkey

Public key of the account

lamports: Rc<RefCell<&'a mut u64>>

The lamports in the account. Modifiable by programs.

data: Rc<RefCell<&'a mut [u8]>>

The data held in this account. Modifiable by programs.

owner: &'a Pubkey

Program that owns this account

rent_epoch: u64

The epoch at which this account will next owe rent

is_signer: bool

Was the transaction signed by this account’s public key?

is_writable: bool

Is the account writable?

executable: bool

This account’s data contains a loaded program (and is now read-only)

Implementations

impl<'a> AccountInfo<'a>

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

👎Deprecated since 2.3.0: Use AccountInfo::resize() instead

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: zero_init being false will no longer be supported by the program runtime.

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 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: &Pubkey)

pub fn new( key: &'a Pubkey, is_signer: bool, is_writable: bool, lamports: &'a mut u64, data: &'a mut [u8], owner: &'a Pubkey, executable: bool, rent_epoch: u64, ) -> AccountInfo<'a>

Trait Implementations

impl AccountInfoTrait for AccountInfo<'_>

Implement trait for solana AccountInfo

type Pubkey = Pubkey

type DataRef<'b> = Ref<'b, [u8]> where AccountInfo<'_>: 'b

type DataRefMut<'b> = RefMut<'b, [u8]> where AccountInfo<'_>: 'b

fn key(&self) -> [u8; 32]

Return raw byte array for maximum compatibility

fn key_ref(&self) -> &[u8]

Return a reference to the key bytes with the lifetime of the account. Used when building seed ref arrays that borrow from the accounts slice.

fn pubkey(&self) -> <AccountInfo<'_> as AccountInfoTrait>::Pubkey

Return the pubkey in the native format

fn pubkey_from_bytes( bytes: [u8; 32], ) -> <AccountInfo<'_> as AccountInfoTrait>::Pubkey

Convert byte array to native Pubkey type

fn is_writable(&self) -> bool

fn is_signer(&self) -> bool

fn executable(&self) -> bool

fn lamports(&self) -> u64

fn data_len(&self) -> usize

fn try_borrow_data( &self, ) -> Result<<AccountInfo<'_> as AccountInfoTrait>::DataRef<'_>, AccountError>

Unified data access interface

fn try_borrow_mut_data( &self, ) -> Result<<AccountInfo<'_> as AccountInfoTrait>::DataRefMut<'_>, AccountError>

fn is_owned_by(&self, program: &[u8; 32]) -> bool

Check ownership safely - each implementation handles this without exposing owner

fn find_program_address( seeds: &[&[u8]], program_id: &[u8; 32], ) -> ([u8; 32], u8)

PDA functions - each implementation uses its own backend

fn create_program_address( seeds: &[&[u8]], program_id: &[u8; 32], ) -> Result<[u8; 32], AccountError>

fn get_min_rent_balance(size: usize) -> Result<u64, AccountError>

Get minimum rent balance for a given size

fn get_current_slot() -> Result<u64, AccountError>

Get the current clock slot from sysvar. Only meaningful on-chain; implementations may error off-chain.

fn assign(&self, new_owner: &[u8; 32]) -> Result<(), AccountError>

Assign the account to a new owner program.

fn realloc(&self, new_len: usize, zero_init: bool) -> Result<(), AccountError>

Resize the account data (truncating or zero-extending).

fn sub_lamports(&self, amount: u64) -> Result<(), AccountError>

Subtract lamports from the account (checked).

fn add_lamports(&self, amount: u64) -> Result<(), AccountError>

Add lamports to the account (checked).

fn close(&self, destination: &AccountInfo<'_>) -> Result<(), AccountError>

Close this account: zero data, transfer all lamports to destination, assign to system program.

fn create_pda_account( &self, lamports: u64, space: u64, owner: &[u8; 32], pda_seeds: &[&[u8]], rent_payer: &AccountInfo<'_>, rent_payer_seeds: &[&[u8]], system_program: &AccountInfo<'_>, ) -> Result<(), AccountError>

Create a PDA account via system program CPI (invoke_signed).

fn transfer_lamports_cpi( &self, destination: &AccountInfo<'_>, lamports: u64, signer_seeds: &[&[u8]], ) -> Result<(), AccountError>

Transfer lamports via system program CPI with invoke_signed. Pass &[] for signer_seeds if the sender is already a signer.

fn invoke_cpi( program_id: &[u8; 32], instruction_data: &[u8], account_metas: &[CpiMeta], account_infos: &[AccountInfo<'_>], signer_seeds: &[&[&[u8]]], ) -> Result<(), AccountError>

Invoke an arbitrary program via CPI with optional PDA signing.

fn data_is_empty(&self) -> bool

fn transfer_lamports( &self, destination: &Self, lamports: u64, ) -> Result<(), AccountError>

Transfer lamports by direct lamport manipulation (no CPI).

impl<'a> AsRef<AccountInfo<'a>> for AccountInfo<'a>

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

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

impl<'a> Clone for AccountInfo<'a>

fn clone(&self) -> AccountInfo<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AccountInfo<'_>

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

Formats the value using the given formatter.

impl<'a, T> From<T> for AccountInfo<'a>

where T: IntoAccountInfo<'a>,

fn from(src: T) -> AccountInfo<'a>

Converts to this type from the input type.