Struct solana_program_test::InvokeContext

pub struct InvokeContext<'a> {
    pub transaction_context: &'a mut TransactionContext,
    pub sysvar_cache: Cow<'a, SysvarCache>,
    pub feature_set: Arc<FeatureSet>,
    pub timings: ExecuteDetailsTimings,
    pub blockhash: Hash,
    pub lamports_per_signature: u64,
    /* private fields */
}

Fields

transaction_context: &'a mut TransactionContext

sysvar_cache: Cow<'a, SysvarCache>

feature_set: Arc<FeatureSet>

timings: ExecuteDetailsTimings

blockhash: Hash

lamports_per_signature: u64

Implementations

impl<'a> InvokeContext<'a>

pub fn new(
    transaction_context: &'a mut TransactionContext,
    rent: Rent,
    builtin_programs: &'a [BuiltinProgram],
    sysvar_cache: Cow<'a, SysvarCache>,
    log_collector: Option<Rc<RefCell<LogCollector>>>,
    compute_budget: ComputeBudget,
    executors: Rc<RefCell<HashMap<Pubkey, TransactionExecutor, RandomState>>>,
    feature_set: Arc<FeatureSet>,
    blockhash: Hash,
    lamports_per_signature: u64,
    prev_accounts_data_len: u64
) -> InvokeContext<'a>

pub fn new_mock(
    transaction_context: &'a mut TransactionContext,
    builtin_programs: &'a [BuiltinProgram]
) -> InvokeContext<'a>

pub fn push(
    &mut self,
    instruction_accounts: &[InstructionAccount],
    program_indices: &[usize],
    instruction_data: &[u8]
) -> Result<(), InstructionError>

Push a stack frame onto the invocation stack

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

Pop a stack frame from the invocation stack

pub fn get_stack_height(&self) -> usize

Current height of the invocation stack, top level instructions are height solana_sdk::instruction::TRANSACTION_LEVEL_STACK_HEIGHT

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

Entrypoint for a cross-program invocation from a builtin program

pub fn prepare_instruction(
    &mut self,
    instruction: &Instruction,
    signers: &[Pubkey]
) -> Result<(Vec<InstructionAccount, Global>, Vec<usize, Global>), InstructionError>

Helper to prepare for process_instruction()

pub fn process_instruction(
    &mut self,
    instruction_data: &[u8],
    instruction_accounts: &[InstructionAccount],
    program_indices: &[usize],
    compute_units_consumed: &mut u64,
    timings: &mut ExecuteTimings
) -> Result<(), InstructionError>

Processes an instruction and returns how many compute units were used

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

👎Deprecated since 1.11.0: Please use BorrowedAccount instead of KeyedAccount

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

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 + 'static>)

Cache an executor that wasn’t found in the cache

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

Cache an executor that has changed

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

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

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 get_key_of_account_at_index(
    &self,
    index_in_transaction: usize
) -> Result<&Pubkey, InstructionError>

pub fn set_syscall_context(
    &mut self,
    check_aligned: bool,
    check_size: bool,
    orig_account_lengths: Vec<usize, Global>,
    allocator: Rc<RefCell<dyn Alloc + 'static>>
) -> Result<(), InstructionError>

pub fn get_check_aligned(&self) -> bool

pub fn get_check_size(&self) -> bool

pub fn get_orig_account_lengths(&self) -> Result<&[usize], InstructionError>

Get the original account lengths

pub fn get_allocator(
    &self
) -> Result<Rc<RefCell<dyn Alloc + 'static>>, InstructionError>