Struct solana_program_runtime::invoke_context::InvokeContext

pub struct InvokeContext<'a> {
    pub sysvar_cache: Cow<'a, SysvarCache>,
    pub instruction_trace: Vec<InstructionRecorder>,
    pub feature_set: Arc<FeatureSet>,
    pub timings: ExecuteDetailsTimings,
    pub blockhash: Hash,
    pub lamports_per_signature: u64,
    pub return_data: (Pubkey, Vec<u8>),
    /* private fields */
}

Fields

sysvar_cache: Cow<'a, SysvarCache>

instruction_trace: Vec<InstructionRecorder>

feature_set: Arc<FeatureSet>

timings: ExecuteDetailsTimings

blockhash: Hash

lamports_per_signature: u64

return_data: (Pubkey, Vec<u8>)

Implementations

impl<'a> InvokeContext<'a>

pub fn new(
    rent: Rent,
    accounts: &'a [TransactionAccountRefCell],
    builtin_programs: &'a [BuiltinProgram],
    sysvar_cache: Cow<'a, SysvarCache>,
    log_collector: Option<Rc<RefCell<LogCollector>>>,
    compute_budget: ComputeBudget,
    executors: Rc<RefCell<Executors>>,
    feature_set: Arc<FeatureSet>,
    blockhash: Hash,
    lamports_per_signature: u64,
    initial_accounts_data_len: u64
) -> Self

pub fn new_mock(
    accounts: &'a [TransactionAccountRefCell],
    builtin_programs: &'a [BuiltinProgram]
) -> Self

pub fn push(
    &mut self,
    message: &SanitizedMessage,
    instruction: &CompiledInstruction,
    program_indices: &[usize],
    account_indices: &[usize]
) -> Result<(), InstructionError>

Push a stack frame onto the invocation stack

pub fn pop(&mut self)

Pop a stack frame from the invocation stack

pub fn get_stack_height(&self) -> usize

Current height of the stack

pub fn native_invoke(
    &mut self,
    instruction: Instruction,
    signers: &[Pubkey]
) -> Result<(), InstructionError>

Entrypoint for a cross-program invocation from a builtin program

pub fn create_message(
    &mut self,
    instruction: &Instruction,
    signers: &[Pubkey]
) -> Result<(Message, Vec<bool>, Vec<usize>), InstructionError>

Helper to prepare for process_instruction()

pub fn process_instruction(
    &mut self,
    message: &SanitizedMessage,
    instruction: &CompiledInstruction,
    program_indices: &[usize],
    account_indices: &[usize],
    caller_write_privileges: &[bool],
    timings: &mut ExecuteTimings
) -> ProcessInstructionResult

Processes a cross-program instruction and returns how many compute units were used

pub fn get_caller(&self) -> Result<&Pubkey, InstructionError>

Get the program ID of the currently executing program

pub fn get_loader(&self) -> Result<Pubkey, InstructionError>

Get the owner of the currently executing program

pub fn remove_first_keyed_account(&mut self) -> Result<(), InstructionError>

👎 Deprecated since 1.9.0:

To be removed together with remove_native_loader

Removes the first keyed account

pub fn get_keyed_accounts(
    &self
) -> Result<&[KeyedAccount<'_>], InstructionError>

Get the list of keyed accounts

pub fn get_instruction_keyed_accounts(
    &self
) -> Result<&[KeyedAccount<'_>], InstructionError>

Get the list of keyed accounts without the chain of program accounts

Note: This only contains the KeyedAccounts passed by the caller.

pub fn get_log_collector(&self) -> Option<Rc<RefCell<LogCollector>>>

Get this invocation’s LogCollector

pub fn get_compute_meter(&self) -> Rc<RefCell<ComputeMeter>>

Get this invocation’s ComputeMeter

pub fn get_accounts_data_meter(&self) -> &AccountsDataMeter

Get this invocation’s AccountsDataMeter

pub fn add_executor(&self, pubkey: &Pubkey, executor: Arc<dyn Executor>)

Cache an executor that wasn’t found in the cache

pub fn update_executor(&self, pubkey: &Pubkey, executor: Arc<dyn Executor>)

Cache an executor that has changed

pub fn get_executor(&self, pubkey: &Pubkey) -> Option<Arc<dyn Executor>>

Get the completed loader work that can be re-used across execution

pub fn get_account(
    &self,
    pubkey: &Pubkey
) -> Option<(usize, Rc<RefCell<AccountSharedData>>)>

Find an account_index and account by its key

pub fn get_compute_budget(&self) -> &ComputeBudget

Get this invocation’s compute budget

pub fn get_sysvar_cache(&self) -> &SysvarCache

Get cached sysvars

pub fn record_top_level_instruction(&mut self, instruction: Instruction)

Record top-level instruction in the instruction trace

pub fn record_instruction(
    &mut self,
    stack_height: usize,
    instruction: Instruction
)

Record instruction in the instruction trace

pub fn get_instruction_trace(&self) -> &[InstructionRecorder]

Get the instruction trace

pub fn get_instruction_trace_mut(&mut self) -> &mut Vec<InstructionRecorder>

Get the mutable instruction trace