feat: async transaction execution

crates/cli/src/cli/mod.rs

@@ -616,6 +616,7 @@ impl StartSimnet {
                 Some(self.observability.log_bytes_limit)
             },
             skip_blockhash_check: self.svm.skip_blockhash_check,
+            skip_signature_verification: self.svm.skip_signature_verification,
         }
     }
 

crates/core/src/rpc/jito.rs

@@ -13,7 +13,7 @@ use solana_transaction_status::{TransactionConfirmationStatus, UiTransactionEnco
 use surfpool_types::{
     JitoBundleStatus, RpcBundleExecutionError, RpcBundleRequest, RpcBundleSimulationSummary,
     RpcSimulateBundleConfig, RpcSimulateBundleResult, RpcSimulateBundleTransactionResult,
-    TransactionStatusEvent,
+    TransactionBlockhashValidationMode, TransactionStatusEvent,
 };
 
 use super::{RunloopContext, utils::decode_and_deserialize};
@@ -336,12 +336,13 @@ impl Jito for SurfpoolJitoRpc {
                 // HTTP worker thread is already inside a tokio runtime and `block_on` on the
                 // current handle panics with "Cannot start a runtime from within a runtime".
                 let process_res = sandbox_locker
-                    .process_transaction(
+                    .process_transaction_with_blockhash_validation(
                         remote_ctx,
                         tx.clone(),
                         status_tx,
                         skip_preflight,
                         sigverify,
+                        TransactionBlockhashValidationMode::ValidateAtExecution,
                     )
                     .await;
 
@@ -825,6 +826,7 @@ impl Jito for SurfpoolJitoRpc {
                         // caller asked for it. Avoids double-work on the hot path.
                         false,
                         true, // do_propagate -> status_rx receives typed errors
+                        TransactionBlockhashValidationMode::ValidateAtExecution,
                     )
                     .await;
 
@@ -1451,7 +1453,9 @@ mod tests {
                         continue;
                     };
                     match cmd {
-                        SimnetCommand::ProcessTransaction(_, tx, status_tx, _, _) => {
+                        SimnetCommand::ProcessTransaction(request) => {
+                            let tx = request.transaction;
+                            let status_tx = request.status_tx;
                             observed_process_tx_clone.fetch_add(1, Ordering::SeqCst);
 
                             // Minimal bookkeeping (mirrors other bundle tests) + unblock the RPC.

crates/core/src/runloops/mod.rs

@@ -478,10 +478,17 @@ pub async fn start_block_production_runloop(
                         block_production_mode = update;
                         continue
                     }
-                    SimnetCommand::ProcessTransaction(_key, transaction, status_tx, skip_preflight, skip_sig_verify_override) => {
-                       let skip_sig_verify = skip_sig_verify_override.unwrap_or(global_skip_sig_verify);
+                    SimnetCommand::ProcessTransaction(request) => {
+                       let skip_sig_verify = request.skip_sig_verify.unwrap_or(global_skip_sig_verify);
                        let sigverify = !skip_sig_verify;
-                       if let Err(e) = svm_locker.process_transaction(&remote_client_with_commitment, transaction, status_tx, skip_preflight, sigverify).await {
+                       if let Err(e) = svm_locker.process_transaction_with_blockhash_validation(
+                            &remote_client_with_commitment,
+                            request.transaction,
+                            request.status_tx,
+                            request.skip_preflight,
+                            sigverify,
+                            request.blockhash_validation,
+                        ).await {
                             let _ = svm_locker.simnet_events_tx().send(SimnetEvent::error(format!("Failed to process transaction: {}", e)));
                        }
                        if block_production_mode.eq(&BlockProductionMode::Transaction) {

crates/core/src/surfnet/locker.rs

@@ -54,8 +54,8 @@ use solana_transaction_status::{
 use surfpool_types::{
     AccountSnapshot, ComputeUnitsEstimationResult, ExecutionCapture, ExportSnapshotConfig, Idl,
     KeyedProfileResult, ProfileResult, RpcProfileResultConfig, RunbookExecutionStatusReport,
-    SimnetCommand, SimnetEvent, TransactionConfirmationStatus, TransactionStatusEvent,
-    UiKeyedProfileResult, UuidOrSignature, VersionedIdl,
+    SimnetCommand, SimnetEvent, TransactionBlockhashValidationMode, TransactionConfirmationStatus,
+    TransactionStatusEvent, UiKeyedProfileResult, UuidOrSignature, VersionedIdl,
 };
 use tokio::sync::RwLock;
 use txtx_addon_kit::indexmap::IndexSet;
@@ -83,6 +83,11 @@ enum ProcessTransactionResult {
     ExecutionFailure(FailedTransactionMetadata),
 }
 
+pub enum TransactionPreflightError {
+    SimulationFailure(FailedTransactionMetadata),
+    VerificationFailure(String),
+}
+
 pub struct SvmAccessContext<T> {
     pub slot: Slot,
     pub latest_epoch_info: EpochInfo,
@@ -1166,6 +1171,73 @@ impl SurfnetSvmLocker {
         })
     }
 
+    pub async fn preflight_transaction(
+        &self,
+        remote_ctx: &Option<(SurfnetRemoteClient, CommitmentConfig)>,
+        transaction: VersionedTransaction,
+        sigverify: bool,
+        blockhash_validation: TransactionBlockhashValidationMode,
+    ) -> Result<(), TransactionPreflightError> {
+        let tx_loaded_addresses = self
+            .get_loaded_addresses(remote_ctx, &transaction.message)
+            .await
+            .map_err(|e| TransactionPreflightError::VerificationFailure(e.to_string()))?;
+
+        if let Some(ref loaded) = tx_loaded_addresses {
+            let static_keys: HashSet<&Pubkey> =
+                transaction.message.static_account_keys().iter().collect();
+            for loaded_key in loaded.all_loaded_addresses() {
+                if static_keys.contains(loaded_key) {
+                    return Err(TransactionPreflightError::SimulationFailure(
+                        FailedTransactionMetadata {
+                            err: TransactionError::AccountLoadedTwice,
+                            meta: TransactionMetadata::default(),
+                        },
+                    ));
+                }
+            }
+        }
+
+        let transaction_accounts = self.get_pubkeys_from_message(
+            &transaction.message,
+            tx_loaded_addresses
+                .as_ref()
+                .map(|loaded| loaded.all_loaded_addresses()),
+        );
+
+        let account_updates = self
+            .get_multiple_accounts(remote_ctx, &transaction_accounts, None)
+            .await
+            .map_err(|e| TransactionPreflightError::VerificationFailure(e.to_string()))?
+            .inner;
+
+        let alt_account_updates = self
+            .get_multiple_accounts(
+                remote_ctx,
+                &tx_loaded_addresses
+                    .as_ref()
+                    .map(|loaded| loaded.alt_addresses())
+                    .unwrap_or_default(),
+                None,
+            )
+            .await
+            .map_err(|e| TransactionPreflightError::VerificationFailure(e.to_string()))?
+            .inner;
+
+        self.write_multiple_account_updates(&account_updates);
+        self.write_multiple_account_updates(&alt_account_updates);
+
+        self.with_svm_reader(|svm_reader| {
+            svm_reader.simulate_transaction_with_blockhash_validation(
+                transaction,
+                sigverify,
+                blockhash_validation,
+            )
+        })
+        .map(|_| ())
+        .map_err(TransactionPreflightError::SimulationFailure)
+    }
+
     pub fn is_instruction_profiling_enabled(&self) -> bool {
         self.with_svm_reader(|svm_reader| svm_reader.instruction_profiling_enabled)
     }
@@ -1181,6 +1253,26 @@ impl SurfnetSvmLocker {
         status_tx: Sender<TransactionStatusEvent>,
         skip_preflight: bool,
         sigverify: bool,
+    ) -> SurfpoolResult<()> {
+        self.process_transaction_with_blockhash_validation(
+            remote_ctx,
+            transaction,
+            status_tx,
+            skip_preflight,
+            sigverify,
+            TransactionBlockhashValidationMode::ValidateAtExecution,
+        )
+        .await
+    }
+
+    pub async fn process_transaction_with_blockhash_validation(
+        &self,
+        remote_ctx: &Option<(SurfnetRemoteClient, CommitmentConfig)>,
+        transaction: VersionedTransaction,
+        status_tx: Sender<TransactionStatusEvent>,
+        skip_preflight: bool,
+        sigverify: bool,
+        blockhash_validation: TransactionBlockhashValidationMode,
     ) -> SurfpoolResult<()> {
         let do_propagate_status_updates = true;
         let signature = transaction.signatures[0];
@@ -1192,6 +1284,7 @@ impl SurfnetSvmLocker {
                 skip_preflight,
                 sigverify,
                 do_propagate_status_updates,
+                blockhash_validation,
             )
             .await
         {
@@ -1250,6 +1343,7 @@ impl SurfnetSvmLocker {
                 skip_preflight,
                 sigverify,
                 do_propagate_status_updates,
+                TransactionBlockhashValidationMode::ValidateAtExecution,
             )
             .await?;
 
@@ -1271,6 +1365,7 @@ impl SurfnetSvmLocker {
         skip_preflight: bool,
         sigverify: bool,
         do_propagate: bool,
+        blockhash_validation: TransactionBlockhashValidationMode,
     ) -> SurfpoolResult<KeyedProfileResult> {
         let signature = transaction.signatures[0];
 
@@ -1465,6 +1560,7 @@ impl SurfnetSvmLocker {
                 pre_execution_capture,
                 &status_tx,
                 do_propagate,
+                blockhash_validation,
             )
             .await?;
 
@@ -1563,6 +1659,7 @@ impl SurfnetSvmLocker {
                     pre_execution_capture_cursor,
                     status_tx,
                     do_propagate,
+                    TransactionBlockhashValidationMode::ValidateAtExecution,
                 )
                 .await?;
 
@@ -1983,9 +2080,15 @@ impl SurfnetSvmLocker {
         pre_execution_capture: ExecutionCapture,
         status_tx: &Sender<TransactionStatusEvent>,
         do_propagate: bool,
+        blockhash_validation: TransactionBlockhashValidationMode,
     ) -> SurfpoolResult<ProfileResult> {
         let res = match self
-            .do_process_transaction_internal(transaction.clone(), skip_preflight, sigverify)
+            .do_process_transaction_internal(
+                transaction.clone(),
+                skip_preflight,
+                sigverify,
+                blockhash_validation,
+            )
             .await
         {
             ProcessTransactionResult::Success(transaction_metadata) => self
@@ -2033,12 +2136,17 @@ impl SurfnetSvmLocker {
         transaction: VersionedTransaction,
         skip_preflight: bool,
         sigverify: bool,
+        blockhash_validation: TransactionBlockhashValidationMode,
     ) -> ProcessTransactionResult {
         // if not skipping preflight, simulate the transaction
         if !skip_preflight {
             if let Err(e) = self.with_svm_reader(|svm_reader| {
                 svm_reader
-                    .simulate_transaction(transaction.clone(), sigverify)
+                    .simulate_transaction_with_blockhash_validation(
+                        transaction.clone(),
+                        sigverify,
+                        blockhash_validation,
+                    )
                     .map_err(ProcessTransactionResult::SimulationFailure)
             }) {
                 return e;
@@ -2047,7 +2155,12 @@ impl SurfnetSvmLocker {
 
         match self.with_svm_writer(|svm_writer| {
             svm_writer
-                .send_transaction(transaction, false /* cu_analysis_enabled */, sigverify)
+                .send_transaction_with_blockhash_validation(
+                    transaction,
+                    false, /* cu_analysis_enabled */
+                    sigverify,
+                    blockhash_validation,
+                )
                 .map_err(|e| {
                     debug!("Transaction execution failure: {:?}", e.meta);
                     ProcessTransactionResult::ExecutionFailure(e)