fix: allow auto airdrop to pay for rent & simulate inner instructions response

magicblock-aperture/src/requests/http/simulate_transaction.rs

@@ -70,20 +70,24 @@ impl HttpDispatcher {
             }
             .into()
         };
-        let result = RpcSimulateTransactionResult {
-            err: result.result.err(),
-            logs: result.logs,
-            accounts: None,
-            units_consumed: Some(result.units_consumed),
-            return_data: result.return_data.map(Into::into),
-            inner_instructions: result
+
+        let inner_instructions = config.inner_instructions.then(|| {
+            result
                 .inner_instructions
                 .into_iter()
                 .flatten()
                 .enumerate()
                 .map(converter)
                 .collect::<Vec<_>>()
-                .into(),
+        });
+
+        let result = RpcSimulateTransactionResult {
+            err: result.result.err(),
+            logs: result.logs,
+            accounts: None,
+            units_consumed: Some(result.units_consumed),
+            return_data: result.return_data.map(Into::into),
+            inner_instructions,
             replacement_blockhash,
         };
 

magicblock-api/src/magic_validator.rs

@@ -283,6 +283,11 @@ impl MagicValidator {
             account_update_tx: validator_channels.account_update,
             environment: build_svm_env(&accountsdb, latest_block.blockhash, 0),
             tasks_tx: validator_channels.tasks_service,
+            is_auto_airdrop_lamports_enabled: config
+                .accounts
+                .clone
+                .auto_airdrop_lamports
+                > 0,
         };
         txn_scheduler_state
             .load_upgradeable_programs(&programs_to_load(&config.programs))

magicblock-processor/src/executor/mod.rs

@@ -57,6 +57,8 @@ pub(super) struct TransactionExecutor {
     /// A read lock held during a slot's processing to synchronize with critical global
     /// operations like `AccountsDb` snapshots.
     sync: StWLock,
+    /// True when auto airdrop for fee payers is enabled (auto_airdrop_lamports > 0).
+    pub is_auto_airdrop_lamports_enabled: bool,
 }
 
 impl TransactionExecutor {
@@ -103,6 +105,8 @@ impl TransactionExecutor {
             accounts_tx: state.account_update_tx.clone(),
             transaction_tx: state.transaction_status_tx.clone(),
             tasks_tx: state.tasks_tx.clone(),
+            is_auto_airdrop_lamports_enabled: state
+                .is_auto_airdrop_lamports_enabled,
         };
 
         this.processor.fill_missing_sysvar_cache_entries(&this);

magicblock-processor/src/executor/processing.rs

@@ -198,8 +198,15 @@ impl super::TransactionExecutor {
                 })
                 .unwrap_or(false);
 
-            if undelegated_feepayer_was_modified {
-                result = Err(TransactionError::InvalidAccountForFee);
+            if undelegated_feepayer_was_modified
+                && !self.is_auto_airdrop_lamports_enabled
+            {
+                if let Ok(ProcessedTransaction::Executed(ref mut executed)) =
+                    &mut result
+                {
+                    executed.execution_details.status =
+                        Err(TransactionError::InvalidAccountForFee)
+                }
             }
         }
         (result, output.balances)

magicblock-processor/src/scheduler/state.rs

@@ -44,6 +44,8 @@ pub struct TransactionSchedulerState {
     pub transaction_status_tx: TransactionStatusTx,
     /// A channel to send scheduled (crank) tasks created by transactions.
     pub tasks_tx: ScheduledTasksTx,
+    /// True when auto airdrop for fee payers is enabled.
+    pub is_auto_airdrop_lamports_enabled: bool,
 }
 
 impl TransactionSchedulerState {

test-kit/src/lib.rs

@@ -132,6 +132,7 @@ impl ExecutionTestEnv {
             txn_to_process_rx: validator_channels.transaction_to_process,
             tasks_tx: validator_channels.tasks_service,
             environment,
+            is_auto_airdrop_lamports_enabled: false,
         };
 
         // Load test program