harness: generic-vm: agave vm v1

Author: buffalojoec

harness/src/lib.rs

@@ -455,16 +455,14 @@ pub use mollusk_svm_result as result;
 use mollusk_svm_result::Compare;
 #[cfg(feature = "precompiles")]
 use solana_precompile_error::PrecompileError;
-#[cfg(feature = "invocation-inspect-callback")]
-use solana_transaction_context::InstructionAccount;
 use {
     crate::{
         account_store::AccountStore,
         compile_accounts::CompiledAccounts,
         epoch_stake::EpochStake,
         program::ProgramCache,
         sysvar::Sysvars,
-        vm::{agave::AgaveVM, SolanaVM},
+        vm::{agave::AgaveVM, SolanaVM, SolanaVMContext, SolanaVMInstruction, SolanaVMTrace},
     },
     agave_feature_set::FeatureSet,
     mollusk_svm_error::error::{MolluskError, MolluskPanic},
@@ -473,14 +471,19 @@ use {
     solana_compute_budget::compute_budget::ComputeBudget,
     solana_hash::Hash,
     solana_instruction::{AccountMeta, Instruction},
-    solana_program_runtime::invoke_context::{EnvironmentConfig, InvokeContext},
+    solana_program_runtime::invoke_context::EnvironmentConfig,
     solana_pubkey::Pubkey,
     solana_svm_callback::InvokeContextCallback,
     solana_svm_log_collector::LogCollector,
     solana_svm_timings::ExecuteTimings,
     solana_transaction_context::TransactionContext,
     std::{cell::RefCell, collections::HashSet, iter::once, marker::PhantomData, rc::Rc},
 };
+#[cfg(feature = "invocation-inspect-callback")]
+use {
+    solana_program_runtime::invoke_context::InvokeContext,
+    solana_transaction_context::InstructionAccount,
+};
 
 pub(crate) const DEFAULT_LOADER_KEY: Pubkey = solana_sdk_ids::bpf_loader_upgradeable::id();
 
@@ -797,54 +800,39 @@ impl<VM: SolanaVM> Mollusk<VM> {
             };
             let runtime_features = self.feature_set.runtime_features();
             let sysvar_cache = self.sysvars.setup_sysvar_cache(accounts);
-            let mut invoke_context = InvokeContext::new(
-                &mut transaction_context,
-                &mut program_cache,
-                EnvironmentConfig::new(
+
+            let context = SolanaVMContext {
+                transaction_context: &mut transaction_context,
+                program_cache: &mut program_cache,
+                compute_budget: self.compute_budget,
+                environment_config: EnvironmentConfig::new(
                     Hash::default(),
                     /* blockhash_lamports_per_signature */ 5000, // The default value
                     &callback,
                     &runtime_features,
                     &sysvar_cache,
                 ),
-                self.logger.clone(),
-                self.compute_budget.to_budget(),
-                self.compute_budget.to_cost(),
-            );
-
-            // Configure the next instruction frame for this invocation.
-            invoke_context
-                .transaction_context
-                .configure_next_instruction_for_tests(
-                    program_id_index,
-                    instruction_accounts.clone(),
-                    &instruction.data,
-                )
-                .expect("failed to configure next instruction");
-
-            #[cfg(feature = "invocation-inspect-callback")]
-            self.invocation_inspect_callback.before_invocation(
-                &instruction.program_id,
-                &instruction.data,
-                &instruction_accounts,
-                &invoke_context,
-            );
+            };
 
-            let result = if invoke_context.is_precompile(&instruction.program_id) {
-                invoke_context.process_precompile(
-                    &instruction.program_id,
-                    &instruction.data,
-                    std::iter::once(instruction.data.as_ref()),
-                )
-            } else {
-                invoke_context.process_instruction(&mut compute_units_consumed, &mut timings)
+            let instruction = SolanaVMInstruction {
+                program_id_index,
+                accounts: instruction_accounts,
+                data: &instruction.data,
             };
 
-            #[cfg(feature = "invocation-inspect-callback")]
-            self.invocation_inspect_callback
-                .after_invocation(&invoke_context);
+            let trace = SolanaVMTrace {
+                compute_units_consumed: &mut compute_units_consumed,
+                execute_timings: &mut timings,
+                log_collector: self.logger.clone(),
+            };
 
-            result
+            VM::process_instruction(
+                context,
+                instruction,
+                trace,
+                #[cfg(feature = "invocation-inspect-callback")]
+                self.invocation_inspect_callback.as_ref(),
+            )
         };
 
         let return_data = transaction_context.get_return_data().1.to_vec();

harness/src/vm.rs

@@ -0,0 +1,69 @@
+//! The SBPF virtual machine used in Anza's Agave validator.
+
+#[cfg(feature = "invocation-inspect-callback")]
+use crate::InvocationInspectCallback;
+use {
+    super::{SolanaVM, SolanaVMContext, SolanaVMInstruction, SolanaVMTrace},
+    solana_instruction_error::InstructionError,
+    solana_program_runtime::invoke_context::InvokeContext,
+};
+
+/// The SBPF virtual machine used in Anza's Agave validator.
+pub struct AgaveVM {}
+
+impl SolanaVM for AgaveVM {
+    fn process_instruction(
+        context: SolanaVMContext,
+        instruction: SolanaVMInstruction,
+        trace: SolanaVMTrace,
+        #[cfg(feature = "invocation-inspect-callback")]
+        invocation_inspect_callback: &dyn InvocationInspectCallback,
+    ) -> Result<(), InstructionError> {
+        let mut invoke_context = InvokeContext::new(
+            context.transaction_context,
+            context.program_cache,
+            context.environment_config,
+            trace.log_collector,
+            context.compute_budget.to_budget(),
+            context.compute_budget.to_cost(),
+        );
+
+        // Configure the next instruction frame for this invocation.
+        invoke_context
+            .transaction_context
+            .configure_next_instruction_for_tests(
+                instruction.program_id_index,
+                instruction.accounts.clone(),
+                instruction.data,
+            )
+            .expect("failed to configure next instruction");
+
+        let program_id = invoke_context
+            .transaction_context
+            .get_key_of_account_at_index(instruction.program_id_index)
+            .cloned()?;
+
+        #[cfg(feature = "invocation-inspect-callback")]
+        invocation_inspect_callback.before_invocation(
+            &program_id,
+            instruction.data,
+            &instruction.accounts,
+            &invoke_context,
+        );
+
+        let result = if invoke_context.is_precompile(&program_id) {
+            invoke_context.process_precompile(
+                &program_id,
+                instruction.data,
+                std::iter::once(instruction.data),
+            )
+        } else {
+            invoke_context.process_instruction(trace.compute_units_consumed, trace.execute_timings)
+        };
+
+        #[cfg(feature = "invocation-inspect-callback")]
+        invocation_inspect_callback.after_invocation(&invoke_context);
+
+        result
+    }
+}

harness/src/vm/agave.rs

@@ -0,0 +1,51 @@
+//! Virtual Machine API for using Mollusk with custom VMs.
+
+pub mod agave;
+
+#[cfg(feature = "invocation-inspect-callback")]
+use crate::InvocationInspectCallback;
+use {
+    solana_compute_budget::compute_budget::ComputeBudget,
+    solana_instruction_error::InstructionError,
+    solana_program_runtime::{
+        invoke_context::EnvironmentConfig, loaded_programs::ProgramCacheForTxBatch,
+    },
+    solana_svm_log_collector::LogCollector,
+    solana_svm_timings::ExecuteTimings,
+    solana_transaction_context::{InstructionAccount, TransactionContext},
+    std::{cell::RefCell, rc::Rc},
+};
+
+/// Context required to process a Solana instruction in a VM.
+pub struct SolanaVMContext<'a> {
+    pub transaction_context: &'a mut TransactionContext,
+    pub program_cache: &'a mut ProgramCacheForTxBatch,
+    pub compute_budget: ComputeBudget,
+    pub environment_config: EnvironmentConfig<'a>,
+}
+
+/// A Solana instruction to be processed by a VM.
+pub struct SolanaVMInstruction<'a> {
+    pub program_id_index: u16,
+    pub accounts: Vec<InstructionAccount>,
+    pub data: &'a [u8],
+}
+
+/// Trace information about a Solana VM instruction invocation.
+pub struct SolanaVMTrace<'a> {
+    pub compute_units_consumed: &'a mut u64,
+    pub execute_timings: &'a mut ExecuteTimings,
+    pub log_collector: Option<Rc<RefCell<LogCollector>>>,
+}
+
+/// A virtual machine compatible with the Solana calling convention.
+pub trait SolanaVM {
+    /// Process a Solana instruction.
+    fn process_instruction(
+        context: SolanaVMContext,
+        instruction: SolanaVMInstruction,
+        trace: SolanaVMTrace,
+        #[cfg(feature = "invocation-inspect-callback")]
+        invocation_inspect_callback: &dyn InvocationInspectCallback,
+    ) -> Result<(), InstructionError>;
+}