solana_program_runtime/

invoke_context.rs

#[cfg(feature = "dev-context-only-utils")]
use {
    crate::program_cache_entry::ProgramCacheEntry,
    qualifier_attr::qualifiers,
    solana_account::{AccountSharedData, WritableAccount},
    solana_epoch_schedule::EpochSchedule,
    solana_instruction::AccountMeta,
    solana_message::{LegacyMessage, Message, SanitizedMessage},
    solana_sdk_ids::sysvar,
    solana_transaction_context::transaction_accounts::KeyedAccountSharedData,
    std::collections::{HashMap, HashSet},
};
use {
    crate::{
        execution_budget::{SVMTransactionExecutionBudget, SVMTransactionExecutionCost},
        loaded_programs::{
            ProgramCacheForTxBatch, ProgramRuntimeEnvironment, ProgramRuntimeEnvironments,
        },
        memory_context::{MemoryContext, MemoryContexts},
        program_cache_entry::ProgramCacheEntryType,
        stable_log,
        sysvar_cache::SysvarCache,
    },
    solana_hash::Hash,
    solana_instruction::Instruction,
    solana_instruction_error::InstructionError,
    solana_pubkey::Pubkey,
    solana_sbpf::{
        ebpf::MM_HEAP_START,
        elf::{ElfError, Executable as GenericExecutable},
        error::{EbpfError, ProgramResult},
        memory_region::MemoryMapping,
        program::{BuiltinProgram, SBPFVersion},
        vm::{Config, ContextObject, EbpfVm},
    },
    solana_sdk_ids::{
        bpf_loader, bpf_loader_deprecated, bpf_loader_upgradeable, loader_v4, native_loader,
    },
    solana_svm_callback::InvokeContextCallback,
    solana_svm_feature_set::SVMFeatureSet,
    solana_svm_log_collector::{LogCollector, ic_msg},
    solana_svm_measure::{measure::Measure, measure_us},
    solana_svm_timings::{ExecuteDetailsTimings, ExecuteTimings},
    solana_svm_transaction::svm_message::SVMMessage,
    solana_svm_type_overrides::sync::Arc,
    solana_transaction_context::{
        IndexOfAccount, MAX_ACCOUNTS_PER_TRANSACTION, instruction::InstructionContext,
        instruction_accounts::InstructionAccount, transaction::TransactionContext,
    },
    std::{
        alloc::Layout,
        borrow::Cow,
        cell::{Cell, RefCell},
        fmt::{self, Debug},
        ptr,
        rc::Rc,
        time::Duration,
    },
};

pub type BuiltinFunctionRegisterer =
    fn(&mut BuiltinProgram<InvokeContext<'static, 'static>>, &str) -> Result<(), ElfError>;
pub type Executable = GenericExecutable<InvokeContext<'static, 'static>>;
pub type RegisterTrace<'a> = &'a [[u64; 12]];

/// Adapter so we can unify the interfaces of built-in programs and syscalls
#[macro_export]
macro_rules! declare_process_instruction {
    ($process_instruction:ident, $cu_to_consume:expr, |$invoke_context:ident| $inner:tt) => {
        $crate::solana_sbpf::declare_builtin_function!(
            $process_instruction,
            fn rust(
                invoke_context: &mut $crate::invoke_context::InvokeContext<'_, '_>,
                _arg0: u64,
                _arg1: u64,
                _arg2: u64,
                _arg3: u64,
                _arg4: u64,
            ) -> Result<u64, Box<dyn std::error::Error>> {
                fn process_instruction_inner(
                    $invoke_context: &mut $crate::invoke_context::InvokeContext,
                ) -> std::result::Result<(), $crate::__private::InstructionError>
                    $inner

                let consumption_result = if $cu_to_consume > 0
                {
                    invoke_context.compute_meter.consume_checked($cu_to_consume)
                } else {
                    Ok(())
                };
                consumption_result
                    .and_then(|_| {
                        process_instruction_inner(invoke_context)
                            .map(|_| 0)
                            .map_err(|err| Box::new(err) as Box<dyn std::error::Error>)
                    })
                    .into()
            }
        );
    };
}

impl ContextObject for InvokeContext<'_, '_> {
    fn consume(&mut self, amount: u64) {
        // 1 to 1 instruction to compute unit mapping
        // ignore overflow, Ebpf will bail if exceeded
        let compute_meter = self.compute_meter.0.get();
        self.compute_meter
            .0
            .set(compute_meter.saturating_sub(amount));
    }

    fn get_remaining(&self) -> u64 {
        self.compute_meter.0.get()
    }

    fn active_mapping_ptr(&mut self) -> ptr::NonNull<MemoryMapping> {
        let memory = self
            .memory_contexts
            .memory_mapping_mut()
            .expect("The memory context must have been set for the current instruction");
        ptr::NonNull::from_mut(memory)
    }
}

#[derive(Clone, PartialEq, Eq, Debug)]
pub struct AllocErr;
impl fmt::Display for AllocErr {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("Error: Memory allocation failed")
    }
}

pub struct BpfAllocator {
    len: u64,
    pos: u64,
}

impl BpfAllocator {
    pub fn new(len: u64) -> Self {
        Self { len, pos: 0 }
    }

    pub fn alloc(&mut self, layout: Layout) -> Result<u64, AllocErr> {
        let bytes_to_align = (self.pos as *const u8).align_offset(layout.align()) as u64;
        if self
            .pos
            .saturating_add(bytes_to_align)
            .saturating_add(layout.size() as u64)
            <= self.len
        {
            self.pos = self.pos.saturating_add(bytes_to_align);
            let addr = MM_HEAP_START.saturating_add(self.pos);
            self.pos = self.pos.saturating_add(layout.size() as u64);
            Ok(addr)
        } else {
            Err(AllocErr)
        }
    }
}

pub struct EnvironmentConfig<'a> {
    pub blockhash: Hash,
    pub blockhash_lamports_per_signature: u64,
    alpenglow_migration_succeeded: bool,
    epoch_stake_callback: &'a dyn InvokeContextCallback,
    feature_set: &'a SVMFeatureSet,
    program_runtime_environments: &'a ProgramRuntimeEnvironments,
    sysvar_cache: &'a SysvarCache,
}
impl<'a> EnvironmentConfig<'a> {
    pub fn new(
        blockhash: Hash,
        blockhash_lamports_per_signature: u64,
        alpenglow_migration_succeeded: bool,
        epoch_stake_callback: &'a dyn InvokeContextCallback,
        feature_set: &'a SVMFeatureSet,
        program_runtime_environments: &'a ProgramRuntimeEnvironments,
        sysvar_cache: &'a SysvarCache,
    ) -> Self {
        Self {
            blockhash,
            blockhash_lamports_per_signature,
            alpenglow_migration_succeeded,
            epoch_stake_callback,
            feature_set,
            program_runtime_environments,
            sysvar_cache,
        }
    }

    /// Get cached sysvars
    pub fn sysvar_cache(&self) -> &SysvarCache {
        self.sysvar_cache
    }
}

pub struct ComputeMeter(Cell<u64>);

impl ComputeMeter {
    /// Consume compute units
    pub fn consume_checked(&self, amount: u64) -> Result<(), Box<dyn std::error::Error>> {
        let compute_meter = self.0.get();
        let exceeded = compute_meter < amount;
        self.0.set(compute_meter.saturating_sub(amount));
        if exceeded {
            return Err(Box::new(InstructionError::ComputationalBudgetExceeded));
        }
        Ok(())
    }

    /// Set compute units
    ///
    /// Only use for tests and benchmarks
    #[cfg(feature = "dev-context-only-utils")]
    pub fn mock_set_remaining(&self, remaining: u64) {
        self.0.set(remaining);
    }
}

/// Main pipeline from runtime to program execution.
pub struct InvokeContext<'a, 'ix_data> {
    /// Information about the currently executing transaction.
    pub transaction_context: &'a mut TransactionContext<'ix_data>,
    /// The local program cache for the transaction batch.
    pub program_cache_for_tx_batch: &'a mut ProgramCacheForTxBatch,
    /// Runtime configurations used to provision the invocation environment.
    pub environment_config: EnvironmentConfig<'a>,
    /// The compute budget for the current invocation.
    compute_budget: SVMTransactionExecutionBudget,
    /// The compute cost for the current invocation.
    execution_cost: SVMTransactionExecutionCost,
    /// Instruction compute meter, for tracking compute units consumed against
    /// the designated compute budget during program execution.
    pub compute_meter: ComputeMeter,
    log_collector: Option<Rc<RefCell<LogCollector>>>,
    /// Time spent so far executing nested program calls.
    pub total_nested_exec_time: Duration,
    pub timings: ExecuteDetailsTimings,
    pub memory_contexts: MemoryContexts,
    /// Pairs of index in TX instruction trace and VM register trace
    register_traces: Vec<(usize, Vec<[u64; 12]>)>,
    /// Debug port to use for this executing transaction.
    #[cfg(feature = "sbpf-debugger")]
    pub debug_port: Option<u16>,
}

impl<'a, 'ix_data> InvokeContext<'a, 'ix_data> {
    pub fn new(
        transaction_context: &'a mut TransactionContext<'ix_data>,
        program_cache_for_tx_batch: &'a mut ProgramCacheForTxBatch,
        environment_config: EnvironmentConfig<'a>,
        log_collector: Option<Rc<RefCell<LogCollector>>>,
        compute_budget: SVMTransactionExecutionBudget,
        execution_cost: SVMTransactionExecutionCost,
    ) -> Self {
        Self {
            transaction_context,
            program_cache_for_tx_batch,
            environment_config,
            log_collector,
            compute_budget,
            execution_cost,
            compute_meter: ComputeMeter(Cell::new(compute_budget.compute_unit_limit)),
            total_nested_exec_time: Duration::ZERO,
            timings: ExecuteDetailsTimings::default(),
            memory_contexts: MemoryContexts::new(),
            register_traces: Vec::new(),
            #[cfg(feature = "sbpf-debugger")]
            debug_port: None,
        }
    }

    /// Push a stack frame onto the invocation stack
    #[cfg_attr(feature = "dev-context-only-utils", qualifiers(pub))]
    fn push(&mut self) -> Result<(), InstructionError> {
        let instruction_context = self.transaction_context.get_next_instruction_context()?;
        let program_id = instruction_context
            .get_program_key()
            .map_err(|_| InstructionError::UnsupportedProgramId)?;
        if self.transaction_context.get_instruction_stack_height() != 0 {
            let contains =
                (0..self.transaction_context.get_instruction_stack_height()).any(|level| {
                    self.transaction_context
                        .get_instruction_context_at_nesting_level(level)
                        .and_then(|instruction_context| instruction_context.get_program_key())
                        .map(|program_key| program_key == program_id)
                        .unwrap_or(false)
                });
            let is_last = self
                .transaction_context
                .get_current_instruction_context()
                .and_then(|instruction_context| instruction_context.get_program_key())
                .map(|program_key| program_key == program_id)
                .unwrap_or(false);
            if contains && !is_last {
                // Reentrancy not allowed unless caller is calling itself
                return Err(InstructionError::ReentrancyNotAllowed);
            }
        }

        let detect_overflow_early = self
            .environment_config
            .feature_set
            .early_instruction_trace_overflow_detection;
        self.transaction_context.push(detect_overflow_early)?;
        self.memory_contexts.push_placeholder();
        Ok(())
    }

    /// Pop a stack frame from the invocation stack
    #[cfg_attr(feature = "dev-context-only-utils", qualifiers(pub))]
    fn pop(&mut self) -> Result<(), InstructionError> {
        self.memory_contexts.pop();
        self.transaction_context.pop()
    }

    /// Current height of the invocation stack, top level instructions are height
    /// `solana_instruction::TRANSACTION_LEVEL_STACK_HEIGHT`
    pub fn get_stack_height(&self) -> usize {
        self.transaction_context.get_instruction_stack_height()
    }

    /// Entrypoint for a cross-program invocation from a builtin program.
    ///
    /// Takes signer seeds and derives PDAs internally via
    /// `create_program_address`, mirroring the SBF CPI path. This makes
    /// it structurally impossible for a builtin to vouch for a non-PDA
    /// address (e.g. a user wallet) as a signer.
    pub fn native_invoke_signed(
        &mut self,
        instruction: Instruction,
        signer_seeds: &[&[&[u8]]],
    ) -> Result<(), InstructionError> {
        let caller_program_id = *self
            .transaction_context
            .get_current_instruction_context()?
            .get_program_key()?;
        // The conversion from `PubkeyError` to `InstructionError` through
        // num-traits is incorrect, but it's the existing behavior.
        let signers = signer_seeds
            .iter()
            .map(|seeds| Pubkey::create_program_address(seeds, &caller_program_id))
            .collect::<Result<Vec<Pubkey>, solana_pubkey::PubkeyError>>()
            .map_err(|e| e as u64)?;
        self.build_instruction_frame(instruction)?;
        self.internal_native_invoke(&signers)?;
        Ok(())
    }

    /// A special native invoke for when the instruction is already configured in the instruction
    /// trace
    pub fn internal_native_invoke(&mut self, signers: &[Pubkey]) -> Result<(), InstructionError> {
        self.verify_instruction_accounts(signers)?;
        let mut compute_units_consumed = 0;
        self.process_instruction(&mut compute_units_consumed, &mut ExecuteTimings::default())?;
        Ok(())
    }

    /// Verifies if all the CPI accounts are present in the caller, and checks writability and
    /// signing permissions.
    pub(crate) fn verify_instruction_accounts(
        &mut self,
        signers: &[Pubkey],
    ) -> Result<(), InstructionError> {
        let instruction_context = self.transaction_context.get_current_instruction_context()?;
        let next_context = self.transaction_context.get_next_instruction_context()?;
        let callee_instruction_accounts = next_context.instruction_accounts();
        for (idx, callee_account) in callee_instruction_accounts.iter().enumerate() {
            if next_context
                .is_instruction_account_duplicate(idx as u16)?
                .is_some()
            {
                continue;
            }

            // The account passed down to the instruction is supposed to be present in the caller
            let index_in_caller = instruction_context
                .get_index_of_account_in_instruction(callee_account.index_in_transaction)?;

            let caller_instruction_account = instruction_context
                .instruction_accounts()
                .get(index_in_caller as usize)
                .expect(
                    "get_index_of_account_in_instruction above has already checked if the index \
                     is valid.",
                );

            let account_key = self
                .transaction_context
                .get_key_of_account_at_index(caller_instruction_account.index_in_transaction)?;

            // Readonly in caller cannot become writable in callee
            if callee_account.is_writable() && !caller_instruction_account.is_writable() {
                ic_msg!(self, "{}'s writable privilege escalated", account_key,);
                return Err(InstructionError::PrivilegeEscalation);
            }

            // To be signed in the callee,
            // it must be either signed in the caller or by the program
            if callee_account.is_signer()
                && !(caller_instruction_account.is_signer() || signers.contains(account_key))
            {
                ic_msg!(self, "{}'s signer privilege escalated", account_key,);
                return Err(InstructionError::PrivilegeEscalation);
            }
        }

        // See if program account is part of the instruction
        // `build_instruction_frame` already checked if the account is part of the transaction.
        let program_id_tx_idx = next_context.get_index_of_program_account_in_transaction()?;
        if instruction_context
            .get_index_of_account_in_instruction(program_id_tx_idx)
            .is_err()
        {
            let callee_program_id = self
                .transaction_context
                .get_key_of_account_at_index(program_id_tx_idx)
                .expect("We should have checked that the program ID is in the transaction");
            ic_msg!(self, "Unknown program {}", callee_program_id);
            return Err(InstructionError::MissingAccount);
        }

        Ok(())
    }

    /// Convert an SDK Instruction from CPI to an InstructionFrame used by runtime.
    pub(crate) fn build_instruction_frame(
        &mut self,
        instruction: Instruction,
    ) -> Result<(), InstructionError> {
        // We reference accounts by an u8 index, so we have a total of 256 accounts.
        let transaction_callee_map_len = (self.transaction_context.get_number_of_accounts()
            as usize)
            .min(MAX_ACCOUNTS_PER_TRANSACTION);
        let mut transaction_callee_map: Vec<u8> = vec![u8::MAX; transaction_callee_map_len];
        let mut instruction_accounts: Vec<InstructionAccount> =
            Vec::with_capacity(instruction.accounts.len());

        // This code block is necessary to restrict the scope of the immutable borrow of
        // transaction context (the `instruction_context` variable). At the end of this
        // function, we must borrow it again as mutable.
        let program_account_index = {
            for account_meta in instruction.accounts.iter() {
                let index_in_transaction = self
                    .transaction_context
                    .find_index_of_account(&account_meta.pubkey)
                    .ok_or_else(|| {
                        ic_msg!(
                            self,
                            "Instruction references an unknown account {}",
                            account_meta.pubkey,
                        );
                        InstructionError::MissingAccount
                    })?;

                debug_assert!((index_in_transaction as usize) < transaction_callee_map.len());
                let index_in_callee = transaction_callee_map
                    .get_mut(index_in_transaction as usize)
                    .unwrap();

                if (*index_in_callee as usize) < instruction_accounts.len() {
                    let cloned_account = {
                        let instruction_account = instruction_accounts
                            .get_mut(*index_in_callee as usize)
                            .ok_or(InstructionError::MissingAccount)?;
                        instruction_account.set_is_signer(
                            instruction_account.is_signer() || account_meta.is_signer,
                        );
                        instruction_account.set_is_writable(
                            instruction_account.is_writable() || account_meta.is_writable,
                        );
                        *instruction_account
                    };
                    instruction_accounts.push(cloned_account);
                } else {
                    *index_in_callee = instruction_accounts.len() as u8;
                    instruction_accounts.push(InstructionAccount::new(
                        index_in_transaction,
                        account_meta.is_signer,
                        account_meta.is_writable,
                    ));
                }
            }

            TransactionContext::replicate_account_flags(
                &mut instruction_accounts,
                &transaction_callee_map,
            );

            // Find executables / program accounts
            let callee_program_id = &instruction.program_id;
            let program_account_index_in_transaction = self
                .transaction_context
                .find_index_of_account(callee_program_id);

            // Validate executables / program accounts
            // Check if the account exists in the transaction
            if program_account_index_in_transaction.is_none() {
                ic_msg!(self, "Unknown program {}", callee_program_id);
                return Err(InstructionError::MissingAccount);
            }

            // SAFETY: This unwrap is safe, because we checked the index in instruction in the
            // previous if-condition.
            program_account_index_in_transaction.unwrap()
        };

        // This ? operator should not error out because `fn get_current_instruction_index` is also called
        // in `get_current_instruction_context`
        let caller_index = self.transaction_context.get_current_instruction_index()?;
        self.transaction_context.configure_instruction_at_index(
            self.transaction_context.get_instruction_trace_length(),
            program_account_index,
            instruction_accounts,
            transaction_callee_map,
            Cow::Owned(instruction.data),
            Some(caller_index as u16),
        )?;
        Ok(())
    }

    /// Process a message. Calls each instruction in the message over the
    /// configured [`TransactionContext`] and returns the final result.
    /// For any instructions that fail, a tuple is returned whose elements are
    /// (index of instruction, instruction error). Once an error is returned,
    /// execution stops.
    pub fn process_message(
        &mut self,
        message: &'ix_data impl SVMMessage,
        execute_timings: &mut ExecuteTimings,
        accumulated_consumed_units: &mut u64,
    ) -> Result<(), (u8, InstructionError)> {
        self.prepare_top_level_instructions(message)?;

        for (top_level_instruction_index, (program_id, instruction)) in
            message.program_instructions_iter().enumerate()
        {
            let mut compute_units_consumed = 0;
            let (result, process_instruction_us) = measure_us!({
                if self.is_precompile(program_id) {
                    self.process_precompile(
                        program_id,
                        instruction.data,
                        message.instructions_iter().map(|ix| ix.data),
                    )
                } else {
                    self.process_instruction(&mut compute_units_consumed, execute_timings)
                }
            });

            *accumulated_consumed_units =
                accumulated_consumed_units.saturating_add(compute_units_consumed);
            // The per_program_timings are only used for metrics reporting at the trace
            // level, so they should only be accumulated when trace level is enabled.
            if log::log_enabled!(log::Level::Trace) {
                execute_timings.details.accumulate_program(
                    program_id,
                    process_instruction_us,
                    compute_units_consumed,
                    result.is_err(),
                );
            }
            self.timings = {
                execute_timings.details.accumulate(&self.timings);
                ExecuteDetailsTimings::default()
            };
            execute_timings
                .execute_accessories
                .process_instructions
                .total_us += process_instruction_us;

            result.map_err(|err| (top_level_instruction_index as u8, err))?;
        }

        Ok(())
    }

    /// Prepare the instruction trace with all the top level instructions
    #[cfg_attr(feature = "dev-context-only-utils", qualifiers(pub))]
    fn prepare_top_level_instructions(
        &mut self,
        message: &'ix_data impl SVMMessage,
    ) -> Result<(), (u8, InstructionError)> {
        for (top_level_instruction_index, (_, instruction)) in
            message.program_instructions_iter().enumerate()
        {
            let transaction_callee_map_len = message
                .account_keys()
                .len()
                .min(MAX_ACCOUNTS_PER_TRANSACTION);
            let mut transaction_callee_map: Vec<u8> = vec![u8::MAX; transaction_callee_map_len];

            let mut instruction_accounts: Vec<InstructionAccount> =
                Vec::with_capacity(instruction.accounts.len());
            for index_in_transaction in instruction.accounts.iter() {
                let index_in_callee = transaction_callee_map
                    .get_mut(*index_in_transaction as usize)
                    .expect("Invalid index in transaction");

                if (*index_in_callee as usize) > instruction_accounts.len() {
                    *index_in_callee = instruction_accounts.len() as u8;
                }

                let index_in_transaction = *index_in_transaction as usize;
                instruction_accounts.push(InstructionAccount::new(
                    index_in_transaction as IndexOfAccount,
                    message.is_signer(index_in_transaction),
                    message.is_writable(index_in_transaction),
                ));
            }

            self.transaction_context
                .configure_instruction_at_index(
                    top_level_instruction_index,
                    instruction.program_id_index as u16,
                    instruction_accounts,
                    transaction_callee_map,
                    Cow::Borrowed(instruction.data),
                    None,
                )
                .map_err(|err| (top_level_instruction_index as u8, err))?;
        }
        Ok(())
    }

    /// Processes an instruction and returns how many compute units were used
    #[cfg_attr(feature = "dev-context-only-utils", qualifiers(pub))]
    pub(crate) fn process_instruction(
        &mut self,
        compute_units_consumed: &mut u64,
        timings: &mut ExecuteTimings,
    ) -> Result<(), InstructionError> {
        *compute_units_consumed = 0;
        self.push()?;
        self.process_executable_chain(compute_units_consumed, timings)
            // MUST pop if and only if `push` succeeded, independent of `result`.
            // Thus, the `.and()` instead of an `.and_then()`.
            .and(self.pop())
    }

    /// Processes a precompile instruction
    #[cfg_attr(feature = "dev-context-only-utils", qualifiers(pub))]
    fn process_precompile(
        &mut self,
        program_id: &Pubkey,
        instruction_data: &[u8],
        message_instruction_datas_iter: impl Iterator<Item = &'ix_data [u8]>,
    ) -> Result<(), InstructionError> {
        self.push()?;
        let instruction_datas: Vec<_> = message_instruction_datas_iter.collect();
        self.environment_config
            .epoch_stake_callback
            .process_precompile(program_id, instruction_data, instruction_datas)
            .map_err(InstructionError::from)
            .and(self.pop())
    }

    /// Calls the instruction's program entrypoint method
    fn process_executable_chain(
        &mut self,
        compute_units_consumed: &mut u64,
        timings: &mut ExecuteTimings,
    ) -> Result<(), InstructionError> {
        let instruction_context = self.transaction_context.get_current_instruction_context()?;
        let process_executable_chain_time = Measure::start("process_executable_chain_time");

        let builtin_id = {
            let owner_id = instruction_context.get_program_owner()?;
            if native_loader::check_id(&owner_id) {
                *instruction_context.get_program_key()?
            } else if bpf_loader_deprecated::check_id(&owner_id)
                || bpf_loader::check_id(&owner_id)
                || bpf_loader_upgradeable::check_id(&owner_id)
                || loader_v4::check_id(&owner_id)
            {
                owner_id
            } else {
                return Err(InstructionError::UnsupportedProgramId);
            }
        };

        // The Murmur3 hash value (used by RBPF) of the string "entrypoint"
        const ENTRYPOINT_KEY: u32 = 0x71E3CF81;
        let entry = self
            .program_cache_for_tx_batch
            .find(&builtin_id)
            .ok_or(InstructionError::UnsupportedProgramId)?;
        let function = match &entry.program {
            ProgramCacheEntryType::Builtin(program) => program
                .get_function_registry()
                .lookup_by_key(ENTRYPOINT_KEY)
                .map(|(_name, (function, _codegen))| function),
            _ => None,
        }
        .ok_or(InstructionError::UnsupportedProgramId)?;

        let program_id = *instruction_context.get_program_key()?;
        self.transaction_context
            .set_return_data(program_id, Vec::new())?;
        let logger = self.get_log_collector();
        stable_log::program_invoke(&logger, &program_id, self.get_stack_height());
        let pre_remaining_units = self.get_remaining();
        // For now, only built-ins are invoked from here, so the VM and its Config are irrelevant.
        self.memory_contexts
            .set_memory_context_abi_v1(MemoryContext::new(
                BpfAllocator::new(0),
                Vec::new(),
                // SAFETY:
                // This path invokes a builtin program, so this mapping is never used.
                unsafe {
                    MemoryMapping::new(Vec::new(), &Config::default(), SBPFVersion::Reserved)
                        .unwrap()
                },
            ))?;
        let mut vm = EbpfVm::new(
            Arc::clone(
                &**self
                    .environment_config
                    .program_runtime_environments
                    .get_env_for_execution(),
            ),
            SBPFVersion::V0,
            // Removes lifetime tracking
            unsafe { std::mem::transmute::<&mut InvokeContext, &mut InvokeContext>(self) },
            0,
        );
        vm.invoke_function(function);
        let result = match vm.program_result {
            ProgramResult::Ok(_) => {
                stable_log::program_success(&logger, &program_id);
                Ok(())
            }
            ProgramResult::Err(ref err) => {
                if let EbpfError::SyscallError(syscall_error) = err {
                    if let Some(instruction_err) = syscall_error.downcast_ref::<InstructionError>()
                    {
                        stable_log::program_failure(&logger, &program_id, instruction_err);
                        Err(instruction_err.clone())
                    } else {
                        stable_log::program_failure(&logger, &program_id, syscall_error);
                        Err(InstructionError::ProgramFailedToComplete)
                    }
                } else {
                    stable_log::program_failure(&logger, &program_id, err);
                    Err(InstructionError::ProgramFailedToComplete)
                }
            }
        };
        let post_remaining_units = self.get_remaining();
        *compute_units_consumed = pre_remaining_units.saturating_sub(post_remaining_units);

        if builtin_id == program_id && result.is_ok() && *compute_units_consumed == 0 {
            return Err(InstructionError::BuiltinProgramsMustConsumeComputeUnits);
        }

        timings
            .execute_accessories
            .process_instructions
            .process_executable_chain_us += process_executable_chain_time.end_as_us();
        result
    }

    /// Get this invocation's LogCollector
    pub fn get_log_collector(&self) -> Option<Rc<RefCell<LogCollector>>> {
        self.log_collector.clone()
    }

    #[cfg(feature = "dev-context-only-utils")]
    pub fn set_alpenglow_migration_succeeded_for_tests(&mut self, succeeded: bool) {
        self.environment_config.alpenglow_migration_succeeded = succeeded;
    }

    /// Get this invocation's compute budget
    pub fn get_compute_budget(&self) -> &SVMTransactionExecutionBudget {
        &self.compute_budget
    }

    /// Get this invocation's compute budget
    pub fn get_execution_cost(&self) -> &SVMTransactionExecutionCost {
        &self.execution_cost
    }

    /// Get the current feature set.
    pub fn get_feature_set(&self) -> &SVMFeatureSet {
        self.environment_config.feature_set
    }

    pub fn get_program_runtime_environment_for_deployment(&self) -> &ProgramRuntimeEnvironment {
        self.environment_config
            .program_runtime_environments
            .get_env_for_deployment()
    }

    pub fn is_deprecate_legacy_vote_ixs_active(&self) -> bool {
        self.environment_config
            .feature_set
            .deprecate_legacy_vote_ixs
    }

    pub fn is_alpenglow_migration_succeeded(&self) -> bool {
        self.environment_config.alpenglow_migration_succeeded
    }

    /// Get cached epoch total stake.
    pub fn get_epoch_stake(&self) -> u64 {
        self.environment_config
            .epoch_stake_callback
            .get_epoch_stake()
    }

    /// Get cached stake for the epoch vote account.
    pub fn get_epoch_stake_for_vote_account(&self, pubkey: &'a Pubkey) -> u64 {
        self.environment_config
            .epoch_stake_callback
            .get_epoch_stake_for_vote_account(pubkey)
    }

    pub fn is_precompile(&self, pubkey: &Pubkey) -> bool {
        self.environment_config
            .epoch_stake_callback
            .is_precompile(pubkey)
    }

    // Should alignment be enforced during user pointer translation
    pub fn get_check_aligned(&self) -> bool {
        self.transaction_context
            .get_current_instruction_context()
            .and_then(|instruction_context| {
                let owner_id = instruction_context.get_program_owner();
                debug_assert!(owner_id.is_ok());
                owner_id
            })
            .map(|owner_key| owner_key != bpf_loader_deprecated::id())
            .unwrap_or(true)
    }

    /// Insert a VM register trace
    pub(crate) fn insert_register_trace(&mut self, register_trace: Vec<[u64; 12]>) {
        if register_trace.is_empty() {
            return;
        }
        let Ok(instruction_context) = self.transaction_context.get_current_instruction_context()
        else {
            return;
        };
        self.register_traces
            .push((instruction_context.get_index_in_trace(), register_trace));
    }

    /// Iterates over all VM register traces (including CPI)
    pub fn iterate_vm_traces(
        &self,
        callback: &dyn Fn(InstructionContext, &Executable, RegisterTrace),
    ) {
        for (index_in_trace, register_trace) in &self.register_traces {
            let Ok(instruction_context) = self
                .transaction_context
                .get_instruction_context_at_index_in_trace(*index_in_trace)
            else {
                continue;
            };
            let Ok(program_id) = instruction_context.get_program_key() else {
                continue;
            };
            let Some(entry) = self.program_cache_for_tx_batch.find(program_id) else {
                continue;
            };
            let ProgramCacheEntryType::Loaded(ref executable) = entry.program else {
                continue;
            };
            callback(instruction_context, executable, register_trace.as_slice());
        }
    }
}

#[cfg(feature = "dev-context-only-utils")]
#[macro_export]
macro_rules! with_mock_invoke_context_with_feature_set {
    (
        $invoke_context:ident,
        $transaction_context:ident,
        $feature_set:ident,
        $top_level_instructions:literal,
        $transaction_accounts:expr,
        $all_accounts:expr $(,)?
    ) => {
        use {
            solana_svm_callback::InvokeContextCallback,
            solana_svm_log_collector::LogCollector,
            $crate::{
                __private::{DropOnBailOut, Hash, ReadableAccount, Rent, TransactionContext},
                execution_budget::{SVMTransactionExecutionBudget, SVMTransactionExecutionCost},
                invoke_context::{EnvironmentConfig, InvokeContext},
                loaded_programs::{ProgramCacheForTxBatch, ProgramRuntimeEnvironments},
                sysvar_cache::SysvarCache,
            },
        };

        struct MockInvokeContextCallback {}
        impl InvokeContextCallback for MockInvokeContextCallback {}

        let compute_budget = SVMTransactionExecutionBudget::new_with_defaults(
            $feature_set.raise_cpi_nesting_limit_to_8,
        );
        let mut sysvar_cache = SysvarCache::default();
        sysvar_cache.fill_missing_entries(|pubkey, callback| {
            for (key, account) in $all_accounts.iter() {
                if key == pubkey {
                    callback(account.data());
                }
            }
        });
        let mut $transaction_context = TransactionContext::new_with_feature_flags(
            $transaction_accounts,
            Rent::default(),
            compute_budget.max_instruction_stack_depth,
            compute_budget.max_instruction_trace_length,
            $top_level_instructions,
            DropOnBailOut::Disabled,
        );
        let program_runtime_environments = ProgramRuntimeEnvironments::mock();
        let environment_config = EnvironmentConfig::new(
            Hash::default(),
            0,
            false,
            &MockInvokeContextCallback {},
            $feature_set,
            &program_runtime_environments,
            &sysvar_cache,
        );
        let mut program_cache_for_tx_batch = ProgramCacheForTxBatch::default();
        let mut $invoke_context = InvokeContext::new(
            &mut $transaction_context,
            &mut program_cache_for_tx_batch,
            environment_config,
            Some(LogCollector::new_ref()),
            compute_budget,
            SVMTransactionExecutionCost::default(),
        );
    };
    (
        $invoke_context:ident,
        $transaction_context:ident,
        $feature_set:ident,
        $top_level_instructions:literal,
        $transaction_accounts:expr $(,)?
    ) => {
        let transaction_accounts: Vec<(solana_pubkey::Pubkey, solana_account::AccountSharedData)> =
            $transaction_accounts;
        $crate::with_mock_invoke_context_with_feature_set!(
            $invoke_context,
            $transaction_context,
            $feature_set,
            $top_level_instructions,
            transaction_accounts,
            &transaction_accounts
        );
    };
    (
        $invoke_context:ident,
        $transaction_context:ident,
        $feature_set:ident,
        $transaction_accounts:expr $(,)?
    ) => {
        $crate::with_mock_invoke_context_with_feature_set!(
            $invoke_context,
            $transaction_context,
            $feature_set,
            1,
            $transaction_accounts
        );
    };
}

#[cfg(feature = "dev-context-only-utils")]
#[macro_export]
macro_rules! with_mock_invoke_context {
    (
        $invoke_context:ident,
        $transaction_context:ident,
        $top_level_instructions:literal,
        $transaction_accounts:expr $(,)?
    ) => {
        let feature_set = &solana_svm_feature_set::SVMFeatureSet::default();
        $crate::with_mock_invoke_context_with_feature_set!(
            $invoke_context,
            $transaction_context,
            feature_set,
            $top_level_instructions,
            $transaction_accounts
        )
    };
    (
        $invoke_context:ident,
        $transaction_context:ident,
        $transaction_accounts:expr $(,)?
    ) => {
        with_mock_invoke_context!(
            $invoke_context,
            $transaction_context,
            1,
            $transaction_accounts
        );
    };
}

#[cfg(feature = "dev-context-only-utils")]
pub fn mock_compile_message<A>(
    instruction: &Instruction,
    accounts: &[(Pubkey, A)],
    program_id: &Pubkey,
    loader_key: &Pubkey,
) -> (SanitizedMessage, Vec<(Pubkey, AccountSharedData)>)
where
    AccountSharedData: From<A>,
    A: Clone,
{
    let message = Message::new(std::slice::from_ref(instruction), None);
    let transaction_accounts: Vec<_> = message
        .account_keys
        .iter()
        .map(|key| {
            let account = accounts
                .iter()
                .find(|(k, _)| k == key)
                .map(|(_, a)| AccountSharedData::from(a.clone()))
                .unwrap_or_else(|| {
                    if key == program_id {
                        let mut account = AccountSharedData::new(0, 0, loader_key);
                        account.set_executable(true);
                        account
                    } else {
                        AccountSharedData::default()
                    }
                });
            (*key, account)
        })
        .collect();

    let sanitized_message = SanitizedMessage::Legacy(LegacyMessage::new(message, &HashSet::new()));

    (sanitized_message, transaction_accounts)
}

#[cfg(feature = "dev-context-only-utils")]
pub fn mock_process_instruction_with_feature_set<
    F: FnMut(&mut InvokeContext),
    G: FnMut(&mut InvokeContext),
>(
    program_id: &Pubkey,
    instruction_data: &[u8],
    mut accounts: Vec<KeyedAccountSharedData>,
    instruction_account_metas: Vec<AccountMeta>,
    expected_result: Result<(), InstructionError>,
    builtin: BuiltinFunctionRegisterer,
    mut pre_adjustments: F,
    mut post_adjustments: G,
    feature_set: &SVMFeatureSet,
) -> Vec<AccountSharedData> {
    let original_len = accounts.len();
    if !accounts
        .iter()
        .any(|(key, _)| *key == sysvar::epoch_schedule::id())
    {
        let mut account = AccountSharedData::new(1, solana_epoch_schedule::SIZE, &sysvar::id());
        wincode::serialize_into(account.data_as_mut_slice(), &EpochSchedule::default()).unwrap();
        accounts.push((sysvar::epoch_schedule::id(), account));
    }

    let instruction =
        Instruction::new_with_bytes(*program_id, instruction_data, instruction_account_metas);
    let (sanitized_message, transaction_accounts) =
        mock_compile_message(&instruction, &accounts, program_id, &native_loader::id());

    let program_owner = accounts
        .iter()
        .find(|(key, _)| key == program_id)
        .map(|(_, acct)| *acct.owner())
        .unwrap_or_else(native_loader::id);
    let is_builtin = native_loader::check_id(&program_owner);

    with_mock_invoke_context_with_feature_set!(
        invoke_context,
        transaction_context,
        feature_set,
        1,
        transaction_accounts,
        &accounts
    );

    let mut program_cache_for_tx_batch = ProgramCacheForTxBatch::default();
    program_cache_for_tx_batch.replenish(
        if is_builtin {
            *program_id
        } else {
            program_owner
        },
        Arc::new(ProgramCacheEntry::new_builtin(builtin)),
    );
    program_cache_for_tx_batch.set_slot_for_tests(
        invoke_context
            .environment_config
            .sysvar_cache()
            .get_clock()
            .map(|clock| clock.slot)
            .unwrap_or(1),
    );
    invoke_context.program_cache_for_tx_batch = &mut program_cache_for_tx_batch;

    pre_adjustments(&mut invoke_context);

    invoke_context
        .prepare_top_level_instructions(&sanitized_message)
        .unwrap();

    let result = invoke_context.process_instruction(&mut 0, &mut ExecuteTimings::default());
    assert_eq!(result, expected_result);
    post_adjustments(&mut invoke_context);

    let txn_result_keys: Vec<_> = (0..transaction_context.get_number_of_accounts())
        .map(|i| *transaction_context.get_key_of_account_at_index(i).unwrap())
        .collect();
    let txn_result_accounts = transaction_context.deconstruct_without_keys().unwrap();
    let txn_result_map = txn_result_keys
        .into_iter()
        .zip(txn_result_accounts)
        .collect::<HashMap<Pubkey, AccountSharedData>>();

    accounts
        .into_iter()
        .take(original_len)
        .map(|(key, original)| txn_result_map.get(&key).cloned().unwrap_or(original))
        .collect()
}

#[cfg(feature = "dev-context-only-utils")]
pub fn mock_process_instruction<F: FnMut(&mut InvokeContext), G: FnMut(&mut InvokeContext)>(
    program_id: &Pubkey,
    instruction_data: &[u8],
    accounts: Vec<KeyedAccountSharedData>,
    instruction_account_metas: Vec<AccountMeta>,
    expected_result: Result<(), InstructionError>,
    builtin: BuiltinFunctionRegisterer,
    pre_adjustments: F,
    post_adjustments: G,
) -> Vec<AccountSharedData> {
    mock_process_instruction_with_feature_set(
        program_id,
        instruction_data,
        accounts,
        instruction_account_metas,
        expected_result,
        builtin,
        pre_adjustments,
        post_adjustments,
        &SVMFeatureSet::all_enabled(),
    )
}

#[cfg(test)]
mod tests {
    use {
        super::*,
        crate::execution_budget::{
            DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT, MAX_INSTRUCTION_STACK_DEPTH,
            MAX_INSTRUCTION_STACK_DEPTH_SIMD_0268,
        },
        openssl::{
            ec::{EcGroup, EcKey},
            nid::Nid,
        },
        solana_account::{Account, DUMMY_INHERITABLE_ACCOUNT_FIELDS, ReadableAccount},
        solana_ed25519_program::new_ed25519_instruction_with_signature,
        solana_keypair::{Address, Keypair},
        solana_message::AccountKeys,
        solana_precompile_error::PrecompileError,
        solana_rent::Rent,
        solana_sbpf::program::BuiltinFunctionDefinition,
        solana_sdk_ids::{ed25519_program, secp256k1_program, system_program},
        solana_secp256k1_program::{
            eth_address_from_pubkey, new_secp256k1_instruction_with_signature,
        },
        solana_secp256r1_program::{new_secp256r1_instruction_with_signature, sign_message},
        solana_signer::Signer,
        solana_svm_feature_set::SVMFeatureSet,
        solana_transaction::{Transaction, sanitized::SanitizedTransaction},
        solana_transaction_context::{MAX_ACCOUNTS_PER_INSTRUCTION, MAX_ACCOUNTS_PER_TRANSACTION},
        test_case::test_case,
    };

    #[derive(Debug, wincode::SchemaRead, wincode::SchemaWrite)]
    enum MockInstruction {
        NoopSuccess,
        NoopFail,
        ModifyOwned,
        ModifyNotOwned,
        ModifyReadonly,
        UnbalancedPush,
        UnbalancedPop,
        ConsumeComputeUnits {
            compute_units_to_consume: u64,
            desired_result: Result<(), InstructionError>,
        },
        Resize {
            new_len: u64,
        },
    }

    const MOCK_BUILTIN_COMPUTE_UNIT_COST: u64 = 1;

    declare_process_instruction!(
        MockBuiltin,
        MOCK_BUILTIN_COMPUTE_UNIT_COST,
        |invoke_context| {
            let transaction_context = &invoke_context.transaction_context;
            let instruction_context = transaction_context.get_current_instruction_context()?;
            let instruction_data = instruction_context.get_instruction_data();
            let program_id = instruction_context.get_program_key()?;
            let instruction_accounts = (0..4)
                .map(|instruction_account_index| {
                    InstructionAccount::new(instruction_account_index, false, false)
                })
                .collect::<Vec<_>>();
            assert_eq!(
                program_id,
                instruction_context
                    .try_borrow_instruction_account(0)?
                    .get_owner()
            );
            assert_ne!(
                instruction_context
                    .try_borrow_instruction_account(1)?
                    .get_owner(),
                instruction_context.get_key_of_instruction_account(0)?
            );

            if let Ok(instruction) = wincode::deserialize(instruction_data) {
                match instruction {
                    MockInstruction::NoopSuccess => (),
                    MockInstruction::NoopFail => return Err(InstructionError::GenericError),
                    MockInstruction::ModifyOwned => instruction_context
                        .try_borrow_instruction_account(0)?
                        .set_data_from_slice(&[1])?,
                    MockInstruction::ModifyNotOwned => instruction_context
                        .try_borrow_instruction_account(1)?
                        .set_data_from_slice(&[1])?,
                    MockInstruction::ModifyReadonly => instruction_context
                        .try_borrow_instruction_account(2)?
                        .set_data_from_slice(&[1])?,
                    MockInstruction::UnbalancedPush => {
                        instruction_context
                            .try_borrow_instruction_account(0)?
                            .checked_add_lamports(1)?;
                        let program_id = *transaction_context.get_key_of_account_at_index(3)?;
                        let metas = vec![
                            AccountMeta::new_readonly(
                                *transaction_context.get_key_of_account_at_index(0)?,
                                false,
                            ),
                            AccountMeta::new_readonly(
                                *transaction_context.get_key_of_account_at_index(1)?,
                                false,
                            ),
                        ];
                        let inner_instruction = Instruction::new_with_wincode(
                            program_id,
                            &MockInstruction::NoopSuccess,
                            metas,
                        );
                        invoke_context
                            .transaction_context
                            .configure_top_level_instruction_for_tests(
                                3,
                                instruction_accounts,
                                vec![],
                            )
                            .unwrap();
                        let result = invoke_context.push();
                        assert_eq!(result, Err(InstructionError::UnbalancedInstruction));
                        result?;
                        invoke_context
                            .native_invoke_signed(inner_instruction, &[])
                            .and(invoke_context.pop())?;
                    }
                    MockInstruction::UnbalancedPop => instruction_context
                        .try_borrow_instruction_account(0)?
                        .checked_add_lamports(1)?,
                    MockInstruction::ConsumeComputeUnits {
                        compute_units_to_consume,
                        desired_result,
                    } => {
                        invoke_context
                            .compute_meter
                            .consume_checked(compute_units_to_consume)
                            .map_err(|_| InstructionError::ComputationalBudgetExceeded)?;
                        return desired_result;
                    }
                    MockInstruction::Resize { new_len } => instruction_context
                        .try_borrow_instruction_account(0)?
                        .set_data_from_slice(&vec![0; new_len as usize])?,
                }
            } else {
                return Err(InstructionError::InvalidInstructionData);
            }
            Ok(())
        }
    );

    #[test_case(false; "SIMD-0268 disabled")]
    #[test_case(true; "SIMD-0268 enabled")]
    fn test_instruction_stack_height(simd_0268_active: bool) {
        let feature_set = &SVMFeatureSet {
            raise_cpi_nesting_limit_to_8: simd_0268_active,
            ..SVMFeatureSet::all_enabled()
        };
        let max_depth = SVMTransactionExecutionBudget::new_with_defaults(simd_0268_active)
            .max_instruction_stack_depth;
        assert_eq!(
            max_depth,
            if simd_0268_active {
                MAX_INSTRUCTION_STACK_DEPTH_SIMD_0268
            } else {
                MAX_INSTRUCTION_STACK_DEPTH
            },
        );

        // Set up max_depth + 1 accounts (one extra to trigger the failing push)
        // and a matching program account for each.
        let mut invoke_stack = vec![];
        let mut transaction_accounts = vec![];
        let mut instruction_accounts = vec![];
        for index in 0..max_depth.saturating_add(1) {
            let program_id = solana_pubkey::new_rand();
            invoke_stack.push(program_id);
            transaction_accounts.push((
                solana_pubkey::new_rand(),
                AccountSharedData::new(1, 1, &program_id),
            ));
            instruction_accounts.push(InstructionAccount::new(
                index as IndexOfAccount,
                false,
                true,
            ));
        }

        // Append program accounts after the regular accounts so that
        // `first_program_account + depth` indexes the right program.
        let first_program_account = transaction_accounts.len();
        for (index, program_id) in invoke_stack.iter().enumerate() {
            transaction_accounts.push((
                *program_id,
                AccountSharedData::new(1, 1, &solana_pubkey::Pubkey::default()),
            ));
            instruction_accounts.push(InstructionAccount::new(
                index as IndexOfAccount,
                false,
                false,
            ));
        }
        with_mock_invoke_context_with_feature_set!(
            invoke_context,
            transaction_context,
            feature_set,
            transaction_accounts,
        );

        // Each push must succeed and the stack height must track.
        for depth in 0..max_depth {
            assert_eq!(invoke_context.get_stack_height(), depth);
            invoke_context
                .transaction_context
                .configure_top_level_instruction_for_tests(
                    (first_program_account.saturating_add(depth)) as IndexOfAccount,
                    instruction_accounts.clone(),
                    vec![],
                )
                .unwrap();
            assert!(
                invoke_context.push().is_ok(),
                "push at depth {depth} should succeed (max_depth={max_depth})",
            );
        }

        // At exactly max_depth, one more push must fail with CallDepth.
        assert_eq!(invoke_context.get_stack_height(), max_depth);
        invoke_context
            .transaction_context
            .configure_top_level_instruction_for_tests(
                (first_program_account.saturating_add(max_depth)) as IndexOfAccount,
                instruction_accounts.clone(),
                vec![],
            )
            .unwrap();
        assert_eq!(invoke_context.push(), Err(InstructionError::CallDepth),);

        // Stack height must not have changed after the rejected push.
        assert_eq!(invoke_context.get_stack_height(), max_depth);
    }

    #[test_case(false; "simd_582_disabled")]
    #[test_case(true; "simd_582_enabled")]
    fn test_max_instruction_trace_length_top_level(fail_early: bool) {
        const MAX_INSTRUCTIONS: usize = 8;
        let mut transaction_context = TransactionContext::new(
            vec![(
                Pubkey::new_unique(),
                AccountSharedData::new(1, 1, &Pubkey::new_unique()),
            )],
            Rent::default(),
            1,
            MAX_INSTRUCTIONS,
            MAX_INSTRUCTIONS,
        );
        for _ in 0..MAX_INSTRUCTIONS {
            transaction_context.push(fail_early).unwrap();
            transaction_context
                .configure_top_level_instruction_for_tests(
                    0,
                    vec![InstructionAccount::new(0, false, false)],
                    vec![],
                )
                .unwrap();
            transaction_context.pop().unwrap();
        }

        assert_eq!(
            transaction_context.push(fail_early),
            Err(InstructionError::MaxInstructionTraceLengthExceeded)
        );
    }

    #[test_case(false; "simd_582_disabled")]
    #[test_case(true; "simd_582_enabled")]
    fn test_max_instruction_trace_length_cpi(fail_early: bool) {
        // Hitting the limit with CPIs
        const MAX_INSTRUCTIONS: usize = 8;
        let mut transaction_context = TransactionContext::new(
            vec![(
                Pubkey::new_unique(),
                AccountSharedData::new(1, 1, &Pubkey::new_unique()),
            )],
            Rent::default(),
            256,
            MAX_INSTRUCTIONS,
            2,
        );
        let num_transaction_accounts = usize::from(transaction_context.get_number_of_accounts());

        transaction_context
            .configure_instruction_at_index(
                0,
                0,
                vec![InstructionAccount::new(0, false, false)],
                vec![u8::MAX; num_transaction_accounts],
                Cow::Owned(Vec::new()),
                None,
            )
            .unwrap();

        transaction_context
            .configure_instruction_at_index(
                1,
                0,
                vec![InstructionAccount::new(0, false, false)],
                vec![u8::MAX; num_transaction_accounts],
                Cow::Owned(Vec::new()),
                None,
            )
            .unwrap();

        for ix_in_trace in (2..).take(MAX_INSTRUCTIONS) {
            let result = transaction_context.push(fail_early);
            if ix_in_trace > MAX_INSTRUCTIONS && fail_early {
                assert_eq!(
                    result,
                    Err(InstructionError::MaxInstructionTraceLengthExceeded)
                );
            } else {
                assert!(result.is_ok());
            }

            transaction_context
                .configure_next_cpi_for_tests(
                    0,
                    vec![InstructionAccount::new(0, false, false)],
                    Vec::new(),
                )
                .unwrap();
        }

        if !fail_early {
            assert_eq!(
                transaction_context.push(false),
                Err(InstructionError::MaxInstructionTraceLengthExceeded)
            );
        }
    }

    #[test_case(MockInstruction::NoopSuccess, Ok(()); "NoopSuccess")]
    #[test_case(MockInstruction::NoopFail, Err(InstructionError::GenericError); "NoopFail")]
    #[test_case(MockInstruction::ModifyOwned, Ok(()); "ModifyOwned")]
    #[test_case(MockInstruction::ModifyNotOwned, Err(InstructionError::ExternalAccountDataModified); "ModifyNotOwned")]
    #[test_case(MockInstruction::ModifyReadonly, Err(InstructionError::ReadonlyDataModified); "ModifyReadonly")]
    #[test_case(MockInstruction::UnbalancedPush, Err(InstructionError::UnbalancedInstruction); "UnbalancedPush")]
    #[test_case(MockInstruction::UnbalancedPop, Err(InstructionError::UnbalancedInstruction); "UnbalancedPop")]
    fn test_process_instruction_account_modifications(
        instruction: MockInstruction,
        expected_result: Result<(), InstructionError>,
    ) {
        let callee_program_id = solana_pubkey::new_rand();
        let owned_account = AccountSharedData::new(42, 1, &callee_program_id);
        let not_owned_account = AccountSharedData::new(84, 1, &solana_pubkey::new_rand());
        let readonly_account = AccountSharedData::new(168, 1, &solana_pubkey::new_rand());
        let loader_account = AccountSharedData::new(0, 1, &native_loader::id());
        let mut program_account = AccountSharedData::new(1, 1, &native_loader::id());
        program_account.set_executable(true);
        let transaction_accounts = vec![
            (solana_pubkey::new_rand(), owned_account),
            (solana_pubkey::new_rand(), not_owned_account),
            (solana_pubkey::new_rand(), readonly_account),
            (callee_program_id, program_account),
            (solana_pubkey::new_rand(), loader_account),
        ];
        let metas = vec![
            AccountMeta::new(transaction_accounts.first().unwrap().0, false),
            AccountMeta::new(transaction_accounts.get(1).unwrap().0, false),
            AccountMeta::new_readonly(transaction_accounts.get(2).unwrap().0, false),
        ];
        let instruction_accounts = (0..4)
            .map(|instruction_account_index| {
                InstructionAccount::new(
                    instruction_account_index,
                    false,
                    instruction_account_index < 2,
                )
            })
            .collect::<Vec<_>>();
        with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);
        let mut program_cache_for_tx_batch = ProgramCacheForTxBatch::default();
        program_cache_for_tx_batch.replenish(
            callee_program_id,
            Arc::new(ProgramCacheEntry::new_builtin(MockBuiltin::register)),
        );
        invoke_context.program_cache_for_tx_batch = &mut program_cache_for_tx_batch;

        // Account modification tests
        invoke_context
            .transaction_context
            .configure_top_level_instruction_for_tests(4, instruction_accounts, vec![])
            .unwrap();
        invoke_context.push().unwrap();
        let inner_instruction =
            Instruction::new_with_wincode(callee_program_id, &instruction, metas);
        let result = invoke_context
            .native_invoke_signed(inner_instruction, &[])
            .and(invoke_context.pop());
        assert_eq!(result, expected_result);
    }

    #[test_case(Ok(()); "Ok")]
    #[test_case(Err(InstructionError::GenericError); "GenericError")]
    fn test_process_instruction_compute_unit_consumption(
        expected_result: Result<(), InstructionError>,
    ) {
        let callee_program_id = solana_pubkey::new_rand();
        let owned_account = AccountSharedData::new(42, 1, &callee_program_id);
        let not_owned_account = AccountSharedData::new(84, 1, &solana_pubkey::new_rand());
        let readonly_account = AccountSharedData::new(168, 1, &solana_pubkey::new_rand());
        let loader_account = AccountSharedData::new(0, 1, &native_loader::id());
        let mut program_account = AccountSharedData::new(1, 1, &native_loader::id());
        program_account.set_executable(true);
        let transaction_accounts = vec![
            (solana_pubkey::new_rand(), owned_account),
            (solana_pubkey::new_rand(), not_owned_account),
            (solana_pubkey::new_rand(), readonly_account),
            (callee_program_id, program_account),
            (solana_pubkey::new_rand(), loader_account),
        ];
        let metas = vec![
            AccountMeta::new(transaction_accounts.first().unwrap().0, false),
            AccountMeta::new(transaction_accounts.get(1).unwrap().0, false),
            AccountMeta::new_readonly(transaction_accounts.get(2).unwrap().0, false),
        ];
        let instruction_accounts = (0..4)
            .map(|instruction_account_index| {
                InstructionAccount::new(
                    instruction_account_index,
                    false,
                    instruction_account_index < 2,
                )
            })
            .collect::<Vec<_>>();
        with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);
        let mut program_cache_for_tx_batch = ProgramCacheForTxBatch::default();
        program_cache_for_tx_batch.replenish(
            callee_program_id,
            Arc::new(ProgramCacheEntry::new_builtin(MockBuiltin::register)),
        );
        invoke_context.program_cache_for_tx_batch = &mut program_cache_for_tx_batch;

        // Compute unit consumption tests
        let compute_units_to_consume = 10;
        invoke_context
            .transaction_context
            .configure_top_level_instruction_for_tests(4, instruction_accounts, vec![])
            .unwrap();
        invoke_context.push().unwrap();
        let inner_instruction = Instruction::new_with_wincode(
            callee_program_id,
            &MockInstruction::ConsumeComputeUnits {
                compute_units_to_consume,
                desired_result: expected_result.clone(),
            },
            metas,
        );

        invoke_context
            .build_instruction_frame(inner_instruction)
            .unwrap();
        invoke_context.verify_instruction_accounts(&[]).unwrap();

        let mut compute_units_consumed = 0;
        let result = invoke_context
            .process_instruction(&mut compute_units_consumed, &mut ExecuteTimings::default());

        // Because the instruction had compute cost > 0, then regardless of the execution result,
        // the number of compute units consumed should be a non-default which is something greater
        // than zero.
        assert!(compute_units_consumed > 0);
        assert_eq!(
            compute_units_consumed,
            compute_units_to_consume.saturating_add(MOCK_BUILTIN_COMPUTE_UNIT_COST),
        );
        assert_eq!(result, expected_result);

        invoke_context.pop().unwrap();
    }

    #[test]
    fn test_invoke_context_compute_budget() {
        let transaction_accounts = vec![(solana_pubkey::new_rand(), AccountSharedData::default())];
        let execution_budget = SVMTransactionExecutionBudget {
            compute_unit_limit: u64::from(DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT),
            ..SVMTransactionExecutionBudget::default()
        };

        with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);
        invoke_context.compute_budget = execution_budget;

        invoke_context
            .transaction_context
            .configure_top_level_instruction_for_tests(0, vec![], vec![])
            .unwrap();
        invoke_context.push().unwrap();
        assert_eq!(*invoke_context.get_compute_budget(), execution_budget);
        invoke_context.pop().unwrap();
    }

    #[test_case(0; "Resize the account to *the same size*, so not consuming any additional size")]
    #[test_case(1; "Resize the account larger")]
    #[test_case(-1; "Resize the account smaller")]
    fn test_process_instruction_accounts_resize_delta(resize_delta: i64) {
        let program_key = Pubkey::new_unique();
        let user_account_data_len = 123u64;
        let user_account =
            AccountSharedData::new(100, user_account_data_len as usize, &program_key);
        let dummy_account = AccountSharedData::new(10, 0, &program_key);
        let mut program_account = AccountSharedData::new(500, 500, &native_loader::id());
        program_account.set_executable(true);
        let transaction_accounts = vec![
            (Pubkey::new_unique(), user_account),
            (Pubkey::new_unique(), dummy_account),
            (program_key, program_account),
        ];
        let instruction_accounts = vec![
            InstructionAccount::new(0, false, true),
            InstructionAccount::new(1, false, false),
        ];
        with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);
        let mut program_cache_for_tx_batch = ProgramCacheForTxBatch::default();
        program_cache_for_tx_batch.replenish(
            program_key,
            Arc::new(ProgramCacheEntry::new_builtin(MockBuiltin::register)),
        );
        invoke_context.program_cache_for_tx_batch = &mut program_cache_for_tx_batch;

        let new_len = (user_account_data_len as i64).saturating_add(resize_delta) as u64;
        let instruction_data = wincode::serialize(&MockInstruction::Resize { new_len }).unwrap();

        invoke_context
            .transaction_context
            .configure_top_level_instruction_for_tests(2, instruction_accounts, instruction_data)
            .unwrap();
        let result = invoke_context.process_instruction(&mut 0, &mut ExecuteTimings::default());

        assert!(result.is_ok());
        assert_eq!(
            invoke_context.transaction_context.accounts().resize_delta(),
            resize_delta
        );
    }

    #[test]
    fn test_prepare_instruction_maximum_accounts() {
        const MAX_ACCOUNTS_REFERENCED: usize = u16::MAX as usize;
        let mut transaction_accounts: Vec<KeyedAccountSharedData> =
            Vec::with_capacity(MAX_ACCOUNTS_PER_TRANSACTION);
        let mut account_metas: Vec<AccountMeta> = Vec::with_capacity(MAX_ACCOUNTS_REFERENCED);

        // Fee-payer
        let fee_payer = Keypair::new();
        transaction_accounts.push((
            fee_payer.pubkey(),
            AccountSharedData::new(1, 1, &Pubkey::new_unique()),
        ));
        account_metas.push(AccountMeta::new(fee_payer.pubkey(), true));

        let program_id = Pubkey::new_unique();
        let mut program_account = AccountSharedData::new(1, 1, &Pubkey::new_unique());
        program_account.set_executable(true);
        transaction_accounts.push((program_id, program_account));
        account_metas.push(AccountMeta::new_readonly(program_id, false));

        for i in 2..MAX_ACCOUNTS_REFERENCED {
            // Let's reference 256 unique accounts, and the rest is repeated.
            if i < MAX_ACCOUNTS_PER_TRANSACTION {
                let key = Pubkey::new_unique();
                transaction_accounts
                    .push((key, AccountSharedData::new(1, 1, &Pubkey::new_unique())));
                account_metas.push(AccountMeta::new_readonly(key, false));
            } else {
                let repeated_key = transaction_accounts
                    .get(i % MAX_ACCOUNTS_PER_TRANSACTION)
                    .unwrap()
                    .0;
                account_metas.push(AccountMeta::new_readonly(repeated_key, false));
            }
        }

        with_mock_invoke_context!(invoke_context, transaction_context, 2, transaction_accounts);

        let instruction_1 = Instruction::new_with_bytes(program_id, &[20], account_metas.clone());

        let instruction_2 = Instruction::new_with_bytes(
            program_id,
            &[20],
            account_metas.iter().rev().cloned().collect(),
        );

        let transaction = Transaction::new_with_payer(
            &[instruction_1.clone(), instruction_2.clone()],
            Some(&fee_payer.pubkey()),
        );

        let sanitized =
            SanitizedTransaction::try_from_legacy_transaction(transaction, &HashSet::new())
                .unwrap();

        fn test_case_1(invoke_context: &InvokeContext) {
            let instruction_context = invoke_context
                .transaction_context
                .get_next_instruction_context()
                .unwrap();
            for index_in_instruction in 0..MAX_ACCOUNTS_REFERENCED as IndexOfAccount {
                let index_in_transaction = instruction_context
                    .get_index_of_instruction_account_in_transaction(index_in_instruction)
                    .unwrap();
                let other_ix_index = instruction_context
                    .get_index_of_account_in_instruction(index_in_transaction)
                    .unwrap();
                if (index_in_instruction as usize) < MAX_ACCOUNTS_PER_TRANSACTION {
                    assert_eq!(index_in_instruction, index_in_transaction);
                    assert_eq!(index_in_instruction, other_ix_index);
                } else {
                    assert_eq!(
                        index_in_instruction as usize % MAX_ACCOUNTS_PER_TRANSACTION,
                        index_in_transaction as usize
                    );
                    assert_eq!(
                        index_in_instruction as usize % MAX_ACCOUNTS_PER_TRANSACTION,
                        other_ix_index as usize
                    );
                }
            }
        }

        fn test_case_2(invoke_context: &InvokeContext) {
            let instruction_context = invoke_context
                .transaction_context
                .get_next_instruction_context()
                .unwrap();
            for index_in_instruction in 0..MAX_ACCOUNTS_REFERENCED as IndexOfAccount {
                let index_in_transaction = instruction_context
                    .get_index_of_instruction_account_in_transaction(index_in_instruction)
                    .unwrap();
                let other_ix_index = instruction_context
                    .get_index_of_account_in_instruction(index_in_transaction)
                    .unwrap();
                assert_eq!(
                    index_in_transaction,
                    (MAX_ACCOUNTS_REFERENCED as u16)
                        .saturating_sub(index_in_instruction)
                        .saturating_sub(1)
                        .overflowing_rem(MAX_ACCOUNTS_PER_TRANSACTION as u16)
                        .0
                );
                if (index_in_instruction as usize) < MAX_ACCOUNTS_PER_TRANSACTION {
                    assert_eq!(index_in_instruction, other_ix_index);
                } else {
                    assert_eq!(
                        index_in_instruction as usize % MAX_ACCOUNTS_PER_TRANSACTION,
                        other_ix_index as usize
                    );
                }
            }
        }

        invoke_context
            .prepare_top_level_instructions(&sanitized)
            .unwrap();

        test_case_1(&invoke_context);

        invoke_context.transaction_context.push(true).unwrap();
        invoke_context.transaction_context.pop().unwrap();

        test_case_2(&invoke_context);

        invoke_context.transaction_context.push(true).unwrap();
        invoke_context
            .build_instruction_frame(instruction_1)
            .unwrap();
        invoke_context
            .verify_instruction_accounts(&[fee_payer.pubkey()])
            .unwrap();
        test_case_1(&invoke_context);

        invoke_context.transaction_context.push(true).unwrap();
        invoke_context
            .build_instruction_frame(instruction_2)
            .unwrap();
        invoke_context
            .verify_instruction_accounts(&[fee_payer.pubkey()])
            .unwrap();
        test_case_2(&invoke_context);
    }

    #[test]
    fn test_duplicated_accounts() {
        let mut transaction_accounts: Vec<KeyedAccountSharedData> =
            Vec::with_capacity(MAX_ACCOUNTS_PER_TRANSACTION);
        let mut account_metas: Vec<AccountMeta> =
            Vec::with_capacity(MAX_ACCOUNTS_PER_INSTRUCTION.saturating_sub(1));

        // Fee-payer
        let fee_payer = Keypair::new();
        transaction_accounts.push((
            fee_payer.pubkey(),
            AccountSharedData::new(1, 1, &Pubkey::new_unique()),
        ));
        account_metas.push(AccountMeta::new(fee_payer.pubkey(), true));

        let program_id = Pubkey::new_unique();
        let mut program_account = AccountSharedData::new(1, 1, &Pubkey::new_unique());
        program_account.set_executable(true);
        transaction_accounts.push((program_id, program_account));
        account_metas.push(AccountMeta::new_readonly(program_id, false));

        for i in 2..account_metas.capacity() {
            if i % 2 == 0 {
                let key = Pubkey::new_unique();
                transaction_accounts
                    .push((key, AccountSharedData::new(1, 1, &Pubkey::new_unique())));
                account_metas.push(AccountMeta::new_readonly(key, false));
            } else {
                let last_key = transaction_accounts.last().unwrap().0;
                account_metas.push(AccountMeta::new_readonly(last_key, false));
            }
        }

        with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);

        let instruction = Instruction::new_with_bytes(program_id, &[20], account_metas.clone());

        let transaction = Transaction::new_with_payer(&[instruction], Some(&fee_payer.pubkey()));

        let sanitized =
            SanitizedTransaction::try_from_legacy_transaction(transaction, &HashSet::new())
                .unwrap();

        invoke_context
            .prepare_top_level_instructions(&sanitized)
            .unwrap();

        {
            let instruction_context = invoke_context
                .transaction_context
                .get_next_instruction_context()
                .unwrap();
            for index_in_instruction in 2..account_metas.len() as IndexOfAccount {
                let is_duplicate = instruction_context
                    .is_instruction_account_duplicate(index_in_instruction)
                    .unwrap();
                if index_in_instruction % 2 == 0 {
                    assert!(is_duplicate.is_none());
                } else {
                    assert_eq!(is_duplicate, Some(index_in_instruction.saturating_sub(1)));
                }
            }
        }

        invoke_context.transaction_context.push(true).unwrap();

        let instruction = Instruction::new_with_bytes(
            program_id,
            &[20],
            account_metas.iter().cloned().rev().collect(),
        );

        invoke_context.build_instruction_frame(instruction).unwrap();
        invoke_context
            .verify_instruction_accounts(&[fee_payer.pubkey()])
            .unwrap();
        let instruction_context = invoke_context
            .transaction_context
            .get_next_instruction_context()
            .unwrap();
        for index_in_instruction in 2..account_metas.len().saturating_sub(1) as u16 {
            let is_duplicate = instruction_context
                .is_instruction_account_duplicate(index_in_instruction)
                .unwrap();
            if index_in_instruction % 2 == 0 {
                assert!(is_duplicate.is_none());
            } else {
                assert_eq!(is_duplicate, Some(index_in_instruction.saturating_sub(1)));
            }
        }
    }

    // Used for native_invoke_signed tests below.
    const TEST_CALLER_PROGRAM_ID: Pubkey = Pubkey::new_from_array([1u8; 32]);
    const TEST_CALLEE_PROGRAM_ID: Pubkey = Pubkey::new_from_array([2u8; 32]);
    const TEST_WRONG_PROGRAM_ID: Pubkey = Pubkey::new_from_array([3u8; 32]);
    const TEST_MOCK_EXTRA_KEY: Pubkey = Pubkey::new_from_array([4u8; 32]);
    const TEST_ACCOUNT_KEY: Pubkey = Pubkey::new_from_array([5u8; 32]);

    /// Runs a `native_invoke_signed` call with the standard test setup and returns
    /// the result.
    ///
    /// Same layout for all tests:
    ///   0: target account (writable, signer iff `target_is_signer`)
    ///   1: caller program (executable)
    ///   2: mock extra (satisfies MockBuiltin's 2-account requirement)
    ///   3: callee program (executable)
    fn run_native_invoke_signed_test(
        target_key: Pubkey,
        target_is_signer: bool,
        inner_instruction: Instruction,
        signer_seeds: &[&[&[u8]]],
    ) -> Result<(), InstructionError> {
        let target_account = AccountSharedData::new(100, 0, &TEST_CALLEE_PROGRAM_ID);
        let mock_extra_account = AccountSharedData::new(0, 1, &system_program::id());
        let mut caller_program_account = AccountSharedData::new(1, 1, &native_loader::id());
        caller_program_account.set_executable(true);
        let mut callee_program_account = AccountSharedData::new(1, 1, &native_loader::id());
        callee_program_account.set_executable(true);
        let transaction_accounts = vec![
            (target_key, target_account),
            (TEST_CALLER_PROGRAM_ID, caller_program_account),
            (TEST_MOCK_EXTRA_KEY, mock_extra_account),
            (TEST_CALLEE_PROGRAM_ID, callee_program_account),
        ];

        with_mock_invoke_context!(invoke_context, transaction_context, transaction_accounts);
        let mut program_cache_for_tx_batch = ProgramCacheForTxBatch::default();
        program_cache_for_tx_batch.replenish(
            TEST_CALLEE_PROGRAM_ID,
            Arc::new(ProgramCacheEntry::new_builtin(MockBuiltin::register)),
        );
        invoke_context.program_cache_for_tx_batch = &mut program_cache_for_tx_batch;

        let instruction_accounts = (0..4)
            .map(|i| InstructionAccount::new(i, i == 0 && target_is_signer, i < 2))
            .collect::<Vec<_>>();
        invoke_context
            .transaction_context
            .configure_top_level_instruction_for_tests(1, instruction_accounts, vec![])
            .unwrap();
        invoke_context.push().unwrap();

        let result = invoke_context.native_invoke_signed(inner_instruction, signer_seeds);
        invoke_context.pop().unwrap();
        result
    }

    // Valid PDA seeds grant signer privilege to the derived address.
    #[test]
    fn test_native_invoke_signed_with_valid_pda_signer() {
        let (pda_key, bump_seed) =
            Pubkey::find_program_address(&[b"seed"], &TEST_CALLER_PROGRAM_ID);
        let instruction = Instruction::new_with_wincode(
            TEST_CALLEE_PROGRAM_ID,
            &MockInstruction::NoopSuccess,
            vec![
                AccountMeta::new(pda_key, true),
                AccountMeta::new_readonly(TEST_MOCK_EXTRA_KEY, false),
            ],
        );
        let result =
            run_native_invoke_signed_test(pda_key, false, instruction, &[&[b"seed", &[bump_seed]]]);
        assert!(
            result.is_ok(),
            "valid PDA signer should succeed: {result:?}"
        );
    }

    // Oversized seeds (>MAX_SEED_LEN) hit `MaxSeedLengthExceeded`
    // (discriminant 0) which the broken `as u64` num-traits conversion
    // maps to `Custom(0)`.
    #[test]
    fn test_native_invoke_signed_with_invalid_seeds() {
        let instruction = Instruction::new_with_wincode(
            TEST_CALLEE_PROGRAM_ID,
            &MockInstruction::NoopSuccess,
            vec![AccountMeta::new(TEST_ACCOUNT_KEY, true)],
        );
        let oversized_seed = [0u8; 33];
        let result = run_native_invoke_signed_test(
            TEST_ACCOUNT_KEY,
            false,
            instruction,
            &[&[&oversized_seed]],
        );
        assert_eq!(result, Err(InstructionError::Custom(0)));
    }

    // CPI marks an account as signer but caller provides no seeds —
    // signer privilege escalation.
    #[test]
    fn test_native_invoke_signed_pda_privilege_escalation_without_seeds() {
        let (pda_key, _bump_seed) =
            Pubkey::find_program_address(&[b"seed"], &TEST_CALLER_PROGRAM_ID);
        let instruction = Instruction::new_with_wincode(
            TEST_CALLEE_PROGRAM_ID,
            &MockInstruction::NoopSuccess,
            vec![AccountMeta::new(pda_key, true)],
        );
        let result = run_native_invoke_signed_test(pda_key, false, instruction, &[]);
        assert_eq!(result, Err(InstructionError::PrivilegeEscalation));
    }

    // Seeds valid for a different program ID don't grant signer privilege
    // because native_invoke_signed derives against the caller's own program ID.
    #[test]
    fn test_native_invoke_signed_uses_caller_program_id_for_pda() {
        let (pda_key, bump_seed) = Pubkey::find_program_address(&[b"seed"], &TEST_WRONG_PROGRAM_ID);
        let instruction = Instruction::new_with_wincode(
            TEST_CALLEE_PROGRAM_ID,
            &MockInstruction::NoopSuccess,
            vec![AccountMeta::new(pda_key, true)],
        );
        let result =
            run_native_invoke_signed_test(pda_key, false, instruction, &[&[b"seed", &[bump_seed]]]);
        assert_eq!(result, Err(InstructionError::PrivilegeEscalation));
    }

    // Top-level signer privilege carries through CPI without needing seeds.
    #[test]
    fn test_native_invoke_signed_top_level_signer_needs_no_seeds() {
        let (pda_key, _bump_seed) =
            Pubkey::find_program_address(&[b"seed"], &TEST_CALLER_PROGRAM_ID);
        let instruction = Instruction::new_with_wincode(
            TEST_CALLEE_PROGRAM_ID,
            &MockInstruction::NoopSuccess,
            vec![
                AccountMeta::new(pda_key, true),
                AccountMeta::new_readonly(TEST_MOCK_EXTRA_KEY, false),
            ],
        );
        let result = run_native_invoke_signed_test(pda_key, true, instruction, &[]);
        assert!(
            result.is_ok(),
            "top-level signer should not need seeds: {result:?}"
        );
    }

    #[test]
    fn test_compile_message() {
        let program_id = Pubkey::new_from_array([1u8; 32]);
        let writable = Pubkey::new_from_array([2u8; 32]);
        let loader_key = Pubkey::new_from_array([3u8; 32]);

        let instruction = Instruction {
            program_id,
            accounts: vec![AccountMeta::new(writable, false)],
            data: vec![1, 2, 3],
        };

        let accounts = vec![(
            writable,
            Account {
                lamports: 100,
                ..Account::default()
            },
        )];

        let (message, tx_accounts) =
            mock_compile_message(&instruction, &accounts, &program_id, &loader_key);

        assert_eq!(message.instructions().len(), 1);
        assert_eq!(tx_accounts.len(), 2);
        assert_eq!(tx_accounts.first().unwrap().0, writable);
        assert_eq!(tx_accounts.get(1).unwrap().0, program_id);

        // Verify the writable account is NOT promoted to signer.
        assert!(!message.is_signer(0));
    }

    struct MockCallback {}
    impl InvokeContextCallback for MockCallback {}

    fn create_loadable_account_for_test(name: &str) -> AccountSharedData {
        let (lamports, rent_epoch) = DUMMY_INHERITABLE_ACCOUNT_FIELDS;
        AccountSharedData::from(Account {
            lamports,
            owner: native_loader::id(),
            data: name.as_bytes().to_vec(),
            executable: true,
            rent_epoch,
        })
    }

    fn new_sanitized_message(message: Message) -> SanitizedMessage {
        SanitizedMessage::try_from_legacy_message(message, &HashSet::new()).unwrap()
    }

    #[test]
    fn test_process_message_readonly_handling() {
        #[derive(wincode::SchemaRead, wincode::SchemaWrite)]
        enum MockSystemInstruction {
            Correct,
            TransferLamports { lamports: u64 },
            ChangeData { data: u8 },
        }

        declare_process_instruction!(MockBuiltin, 1, |invoke_context| {
            let transaction_context = &invoke_context.transaction_context;
            let instruction_context = transaction_context.get_current_instruction_context()?;
            let instruction_data = instruction_context.get_instruction_data();
            if let Ok(instruction) = wincode::deserialize(instruction_data) {
                match instruction {
                    MockSystemInstruction::Correct => Ok(()),
                    MockSystemInstruction::TransferLamports { lamports } => {
                        instruction_context
                            .try_borrow_instruction_account(0)?
                            .checked_sub_lamports(lamports)?;
                        instruction_context
                            .try_borrow_instruction_account(1)?
                            .checked_add_lamports(lamports)?;
                        Ok(())
                    }
                    MockSystemInstruction::ChangeData { data } => {
                        instruction_context
                            .try_borrow_instruction_account(1)?
                            .set_data_from_slice(&[data])?;
                        Ok(())
                    }
                }
            } else {
                Err(InstructionError::InvalidInstructionData)
            }
        });

        let writable_pubkey = Pubkey::new_unique();
        let readonly_pubkey = Pubkey::new_unique();
        let mock_system_program_id = Pubkey::new_unique();

        let accounts = vec![
            (
                writable_pubkey,
                AccountSharedData::new(100, 1, &mock_system_program_id),
            ),
            (
                readonly_pubkey,
                AccountSharedData::new(0, 1, &mock_system_program_id),
            ),
            (
                mock_system_program_id,
                create_loadable_account_for_test("mock_system_program"),
            ),
        ];
        let mut transaction_context =
            TransactionContext::new(accounts.clone(), Rent::default(), 1, 3, 1);
        let mut program_cache_for_tx_batch = ProgramCacheForTxBatch::default();
        program_cache_for_tx_batch.replenish(
            mock_system_program_id,
            Arc::new(ProgramCacheEntry::new_builtin(MockBuiltin::register)),
        );
        let account_keys = (0..transaction_context.get_number_of_accounts())
            .map(|index| {
                *transaction_context
                    .get_key_of_account_at_index(index)
                    .unwrap()
            })
            .collect::<Vec<_>>();
        let account_metas = vec![
            AccountMeta::new(writable_pubkey, true),
            AccountMeta::new_readonly(readonly_pubkey, false),
        ];

        let message = new_sanitized_message(Message::new_with_compiled_instructions(
            1,
            0,
            2,
            account_keys.clone(),
            Hash::default(),
            AccountKeys::new(&account_keys, None).compile_instructions(&[
                Instruction::new_with_wincode(
                    mock_system_program_id,
                    &MockSystemInstruction::Correct,
                    account_metas.clone(),
                ),
            ]),
        ));
        let sysvar_cache = SysvarCache::default();
        let feature_set = SVMFeatureSet::all_enabled();
        let program_runtime_environments = ProgramRuntimeEnvironments::mock();
        let environment_config = EnvironmentConfig::new(
            Hash::default(),
            0,
            false,
            &MockCallback {},
            &feature_set,
            &program_runtime_environments,
            &sysvar_cache,
        );
        let mut invoke_context = InvokeContext::new(
            &mut transaction_context,
            &mut program_cache_for_tx_batch,
            environment_config,
            None,
            SVMTransactionExecutionBudget::default(),
            SVMTransactionExecutionCost::default(),
        );
        let result =
            invoke_context.process_message(&message, &mut ExecuteTimings::default(), &mut 0);
        assert!(result.is_ok());
        assert_eq!(
            transaction_context
                .accounts()
                .try_borrow(0)
                .unwrap()
                .lamports(),
            100
        );
        assert_eq!(
            transaction_context
                .accounts()
                .try_borrow(1)
                .unwrap()
                .lamports(),
            0
        );

        let message = new_sanitized_message(Message::new_with_compiled_instructions(
            1,
            0,
            2,
            account_keys.clone(),
            Hash::default(),
            AccountKeys::new(&account_keys, None).compile_instructions(&[
                Instruction::new_with_wincode(
                    mock_system_program_id,
                    &MockSystemInstruction::TransferLamports { lamports: 50 },
                    account_metas.clone(),
                ),
            ]),
        ));
        let program_runtime_environments = ProgramRuntimeEnvironments::mock();
        let environment_config = EnvironmentConfig::new(
            Hash::default(),
            0,
            false,
            &MockCallback {},
            &feature_set,
            &program_runtime_environments,
            &sysvar_cache,
        );
        let mut transaction_context =
            TransactionContext::new(accounts.clone(), Rent::default(), 1, 3, 1);
        let mut invoke_context = InvokeContext::new(
            &mut transaction_context,
            &mut program_cache_for_tx_batch,
            environment_config,
            None,
            SVMTransactionExecutionBudget::default(),
            SVMTransactionExecutionCost::default(),
        );
        let result =
            invoke_context.process_message(&message, &mut ExecuteTimings::default(), &mut 0);
        assert_eq!(result, Err((0, InstructionError::ReadonlyLamportChange)));

        let message = new_sanitized_message(Message::new_with_compiled_instructions(
            1,
            0,
            2,
            account_keys.clone(),
            Hash::default(),
            AccountKeys::new(&account_keys, None).compile_instructions(&[
                Instruction::new_with_wincode(
                    mock_system_program_id,
                    &MockSystemInstruction::ChangeData { data: 50 },
                    account_metas,
                ),
            ]),
        ));
        let program_runtime_environments = ProgramRuntimeEnvironments::mock();
        let environment_config = EnvironmentConfig::new(
            Hash::default(),
            0,
            false,
            &MockCallback {},
            &feature_set,
            &program_runtime_environments,
            &sysvar_cache,
        );
        let mut transaction_context = TransactionContext::new(accounts, Rent::default(), 1, 3, 1);
        let mut invoke_context = InvokeContext::new(
            &mut transaction_context,
            &mut program_cache_for_tx_batch,
            environment_config,
            None,
            SVMTransactionExecutionBudget::default(),
            SVMTransactionExecutionCost::default(),
        );
        let result =
            invoke_context.process_message(&message, &mut ExecuteTimings::default(), &mut 0);
        assert_eq!(result, Err((0, InstructionError::ReadonlyDataModified)));
    }

    #[test]
    fn test_process_message_duplicate_accounts() {
        #[derive(wincode::SchemaRead, wincode::SchemaWrite)]
        enum MockSystemInstruction {
            BorrowFail,
            MultiBorrowMut,
            DoWork { lamports: u64, data: u8 },
        }

        declare_process_instruction!(MockBuiltin, 1, |invoke_context| {
            let transaction_context = &invoke_context.transaction_context;
            let instruction_context = transaction_context.get_current_instruction_context()?;
            let instruction_data = instruction_context.get_instruction_data();
            let mut to_account = instruction_context.try_borrow_instruction_account(1)?;
            if let Ok(instruction) = wincode::deserialize(instruction_data) {
                match instruction {
                    MockSystemInstruction::BorrowFail => {
                        let from_account = instruction_context.try_borrow_instruction_account(0)?;
                        let dup_account = instruction_context.try_borrow_instruction_account(2)?;
                        if from_account.get_lamports() != dup_account.get_lamports() {
                            return Err(InstructionError::InvalidArgument);
                        }
                        Ok(())
                    }
                    MockSystemInstruction::MultiBorrowMut => {
                        let lamports_a = instruction_context
                            .try_borrow_instruction_account(0)?
                            .get_lamports();
                        let lamports_b = instruction_context
                            .try_borrow_instruction_account(2)?
                            .get_lamports();
                        if lamports_a != lamports_b {
                            return Err(InstructionError::InvalidArgument);
                        }
                        Ok(())
                    }
                    MockSystemInstruction::DoWork { lamports, data } => {
                        let mut dup_account =
                            instruction_context.try_borrow_instruction_account(2)?;
                        dup_account.checked_sub_lamports(lamports)?;
                        to_account.checked_add_lamports(lamports)?;
                        dup_account.set_data_from_slice(&[data])?;
                        drop(dup_account);
                        let mut from_account =
                            instruction_context.try_borrow_instruction_account(0)?;
                        from_account.checked_sub_lamports(lamports)?;
                        to_account.checked_add_lamports(lamports)?;
                        Ok(())
                    }
                }
            } else {
                Err(InstructionError::InvalidInstructionData)
            }
        });
        let mock_program_id = Pubkey::from([2u8; 32]);
        let accounts = vec![
            (
                solana_pubkey::new_rand(),
                AccountSharedData::new(100, 1, &mock_program_id),
            ),
            (
                solana_pubkey::new_rand(),
                AccountSharedData::new(0, 1, &mock_program_id),
            ),
            (
                mock_program_id,
                create_loadable_account_for_test("mock_system_program"),
            ),
        ];
        let mut transaction_context =
            TransactionContext::new(accounts.clone(), Rent::default(), 1, 3, 1);
        let mut program_cache_for_tx_batch = ProgramCacheForTxBatch::default();
        program_cache_for_tx_batch.replenish(
            mock_program_id,
            Arc::new(ProgramCacheEntry::new_builtin(MockBuiltin::register)),
        );
        let account_metas = vec![
            AccountMeta::new(
                *transaction_context.get_key_of_account_at_index(0).unwrap(),
                true,
            ),
            AccountMeta::new(
                *transaction_context.get_key_of_account_at_index(1).unwrap(),
                false,
            ),
            AccountMeta::new(
                *transaction_context.get_key_of_account_at_index(0).unwrap(),
                false,
            ),
        ];

        // Try to borrow mut the same account
        let message = new_sanitized_message(Message::new(
            &[Instruction::new_with_wincode(
                mock_program_id,
                &MockSystemInstruction::BorrowFail,
                account_metas.clone(),
            )],
            Some(transaction_context.get_key_of_account_at_index(0).unwrap()),
        ));
        let sysvar_cache = SysvarCache::default();
        let feature_set = SVMFeatureSet::all_enabled();
        let program_runtime_environments = ProgramRuntimeEnvironments::mock();
        let environment_config = EnvironmentConfig::new(
            Hash::default(),
            0,
            false,
            &MockCallback {},
            &feature_set,
            &program_runtime_environments,
            &sysvar_cache,
        );
        let mut invoke_context = InvokeContext::new(
            &mut transaction_context,
            &mut program_cache_for_tx_batch,
            environment_config,
            None,
            SVMTransactionExecutionBudget::default(),
            SVMTransactionExecutionCost::default(),
        );
        let result =
            invoke_context.process_message(&message, &mut ExecuteTimings::default(), &mut 0);
        assert_eq!(result, Err((0, InstructionError::AccountBorrowFailed)));

        // Try to borrow mut the same account in a safe way
        let message = new_sanitized_message(Message::new(
            &[Instruction::new_with_wincode(
                mock_program_id,
                &MockSystemInstruction::MultiBorrowMut,
                account_metas.clone(),
            )],
            Some(transaction_context.get_key_of_account_at_index(0).unwrap()),
        ));
        let program_runtime_environments = ProgramRuntimeEnvironments::mock();
        let environment_config = EnvironmentConfig::new(
            Hash::default(),
            0,
            false,
            &MockCallback {},
            &feature_set,
            &program_runtime_environments,
            &sysvar_cache,
        );
        let mut transaction_context =
            TransactionContext::new(accounts.clone(), Rent::default(), 1, 3, 1);
        let mut invoke_context = InvokeContext::new(
            &mut transaction_context,
            &mut program_cache_for_tx_batch,
            environment_config,
            None,
            SVMTransactionExecutionBudget::default(),
            SVMTransactionExecutionCost::default(),
        );
        let result =
            invoke_context.process_message(&message, &mut ExecuteTimings::default(), &mut 0);
        assert!(result.is_ok());

        // Do work on the same transaction account but at different instruction accounts
        let message = new_sanitized_message(Message::new(
            &[Instruction::new_with_wincode(
                mock_program_id,
                &MockSystemInstruction::DoWork {
                    lamports: 10,
                    data: 42,
                },
                account_metas,
            )],
            Some(transaction_context.get_key_of_account_at_index(0).unwrap()),
        ));
        let program_runtime_environments = ProgramRuntimeEnvironments::mock();
        let environment_config = EnvironmentConfig::new(
            Hash::default(),
            0,
            false,
            &MockCallback {},
            &feature_set,
            &program_runtime_environments,
            &sysvar_cache,
        );
        let mut transaction_context = TransactionContext::new(accounts, Rent::default(), 1, 3, 1);
        let mut invoke_context = InvokeContext::new(
            &mut transaction_context,
            &mut program_cache_for_tx_batch,
            environment_config,
            None,
            SVMTransactionExecutionBudget::default(),
            SVMTransactionExecutionCost::default(),
        );
        let result =
            invoke_context.process_message(&message, &mut ExecuteTimings::default(), &mut 0);
        assert!(result.is_ok());
        assert_eq!(
            transaction_context
                .accounts()
                .try_borrow(0)
                .unwrap()
                .lamports(),
            80
        );
        assert_eq!(
            transaction_context
                .accounts()
                .try_borrow(1)
                .unwrap()
                .lamports(),
            20
        );
        assert_eq!(
            transaction_context.accounts().try_borrow(0).unwrap().data(),
            &vec![42]
        );
    }

    fn secp256k1_instruction_for_test() -> Instruction {
        let message = b"hello";
        let bytes: [u8; 32] = rand::random();
        let secret_key = libsecp256k1::SecretKey::parse(&bytes).unwrap();
        let pubkey = libsecp256k1::PublicKey::from_secret_key(&secret_key);
        let eth_address = eth_address_from_pubkey(&pubkey.serialize()[1..].try_into().unwrap());
        let (signature, recovery_id) =
            solana_secp256k1_program::sign_message(&secret_key.serialize(), &message[..]).unwrap();
        new_secp256k1_instruction_with_signature(
            &message[..],
            &signature,
            recovery_id,
            &eth_address,
        )
    }

    fn ed25519_instruction_for_test() -> Instruction {
        let keypair = Keypair::new();
        let signature = keypair.sign_message(b"hello");
        let pubkey = keypair.pubkey().to_bytes();
        new_ed25519_instruction_with_signature(b"hello", signature.as_array(), &pubkey)
    }

    fn secp256r1_instruction_for_test() -> Instruction {
        let group = EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap();
        let secret_key = EcKey::generate(&group).unwrap();
        let signature = sign_message(b"hello", &secret_key.private_key_to_der().unwrap()).unwrap();
        let mut ctx = openssl::bn::BigNumContext::new().unwrap();
        let pubkey = secret_key
            .public_key()
            .to_bytes(
                &group,
                openssl::ec::PointConversionForm::COMPRESSED,
                &mut ctx,
            )
            .unwrap();
        new_secp256r1_instruction_with_signature(b"hello", &signature, &pubkey.try_into().unwrap())
    }

    #[test]
    fn test_precompile() {
        let mock_program_id = Pubkey::new_unique();
        declare_process_instruction!(MockBuiltin, 1, |_invoke_context| {
            Err(InstructionError::Custom(0xbabb1e))
        });

        let mut secp256k1_account = AccountSharedData::new(1, 0, &native_loader::id());
        secp256k1_account.set_executable(true);
        let mut ed25519_account = AccountSharedData::new(1, 0, &native_loader::id());
        ed25519_account.set_executable(true);
        let mut secp256r1_account = AccountSharedData::new(1, 0, &native_loader::id());
        secp256r1_account.set_executable(true);
        let mut mock_program_account = AccountSharedData::new(1, 0, &native_loader::id());
        mock_program_account.set_executable(true);

        let fee_payer = Pubkey::new_unique();
        let accounts_map: HashMap<Address, AccountSharedData> = HashMap::from([
            (
                fee_payer,
                AccountSharedData::new(1, 0, &system_program::id()),
            ),
            (secp256k1_program::id(), secp256k1_account),
            (ed25519_program::id(), ed25519_account),
            (solana_secp256r1_program::id(), secp256r1_account),
            (mock_program_id, mock_program_account),
        ]);

        let message = new_sanitized_message(Message::new(
            &[
                secp256k1_instruction_for_test(),
                ed25519_instruction_for_test(),
                secp256r1_instruction_for_test(),
                Instruction::new_with_bytes(mock_program_id, &[], vec![]),
            ],
            Some(&fee_payer),
        ));

        let accounts = message
            .account_keys()
            .iter()
            .map(|key| (*key, accounts_map.get(key).unwrap().clone()))
            .collect();
        let mut transaction_context = TransactionContext::new(accounts, Rent::default(), 1, 4, 4);

        let sysvar_cache = SysvarCache::default();
        let mut program_cache_for_tx_batch = ProgramCacheForTxBatch::default();
        program_cache_for_tx_batch.replenish(
            mock_program_id,
            Arc::new(ProgramCacheEntry::new_builtin(MockBuiltin::register)),
        );

        struct MockCallback {}
        impl InvokeContextCallback for MockCallback {
            fn is_precompile(&self, program_id: &Pubkey) -> bool {
                program_id == &secp256k1_program::id()
                    || program_id == &ed25519_program::id()
                    || program_id == &solana_secp256r1_program::id()
            }

            fn process_precompile(
                &self,
                program_id: &Pubkey,
                _data: &[u8],
                _instruction_datas: Vec<&[u8]>,
            ) -> std::result::Result<(), PrecompileError> {
                if self.is_precompile(program_id) {
                    Ok(())
                } else {
                    Err(PrecompileError::InvalidPublicKey)
                }
            }
        }
        let feature_set = SVMFeatureSet::all_enabled();
        let program_runtime_environments = ProgramRuntimeEnvironments::mock();
        let environment_config = EnvironmentConfig::new(
            Hash::default(),
            0,
            false,
            &MockCallback {},
            &feature_set,
            &program_runtime_environments,
            &sysvar_cache,
        );
        let mut invoke_context = InvokeContext::new(
            &mut transaction_context,
            &mut program_cache_for_tx_batch,
            environment_config,
            None,
            SVMTransactionExecutionBudget::default(),
            SVMTransactionExecutionCost::default(),
        );
        let result =
            invoke_context.process_message(&message, &mut ExecuteTimings::default(), &mut 0);

        assert_eq!(result, Err((3, InstructionError::Custom(0xbabb1e))));
        assert_eq!(
            transaction_context.number_of_called_instructions_in_trace(),
            4
        );
    }
}