Charge transaction fee even in case of ProgramError

runtime/src/bank.rs

@@ -579,6 +579,12 @@ impl Bank {
         parents
     }
 
+    pub fn withdraw(&self, pubkey: &Pubkey, tokens: u64) {
+        let mut account = self.get_account(pubkey).unwrap_or_default();
+        account.tokens -= tokens;
+        self.accounts.store_slow(true, pubkey, &account);
+    }
+
     pub fn deposit(&self, pubkey: &Pubkey, tokens: u64) {
         let mut account = self.get_account(pubkey).unwrap_or_default();
         account.tokens += tokens;

src/blocktree_processor.rs

@@ -16,13 +16,21 @@ use std::time::Instant;
 pub fn process_entry(bank: &Bank, entry: &Entry) -> (Result<()>, u64) {
     if !entry.is_tick() {
         let old_results = bank.process_transactions(&entry.transactions);
-        let results = ignore_program_errors(old_results);
         let fee = entry
             .transactions
             .iter()
-            .zip(&results)
+            .zip(&old_results)
-            .map(|(tx, res)| if res.is_ok() { tx.fee } else { 0 })
+            .map(|(tx, res)| match res {
+                Err(BankError::ProgramError(_, _)) => {
+                    // Charge the transaction fee in case of ProgramError
+                    bank.withdraw(&tx.account_keys[0], tx.fee);
+                    tx.fee
+                }
+                Ok(()) => tx.fee,
+                _ => 0,
+            })
             .sum();
+        let results = ignore_program_errors(old_results);
         (first_err(&results), fee)
     } else {
         bank.register_tick(&entry.id);
@@ -63,14 +71,22 @@ fn par_execute_entries(bank: &Bank, entries: &[(&Entry, Vec<Result<()>>)]) -> (R
                 lock_results.to_vec(),
                 MAX_ENTRY_IDS,
             );
-            let results = ignore_program_errors(old_results);
-            bank.unlock_accounts(&e.transactions, &results);
             let fee = e
                 .transactions
                 .iter()
-                .zip(&results)
+                .zip(&old_results)
-                .map(|(tx, res)| if res.is_ok() { tx.fee } else { 0 })
+                .map(|(tx, res)| match res {
+                    Err(BankError::ProgramError(_, _)) => {
+                        // Charge the transaction fee in case of ProgramError
+                        bank.withdraw(&tx.account_keys[0], tx.fee);
+                        tx.fee
+                    }
+                    Ok(()) => tx.fee,
+                    _ => 0,
+                })
                 .sum();
+            let results = ignore_program_errors(old_results);
+            bank.unlock_accounts(&e.transactions, &results);
             (first_err(&results), fee)
         })
         .collect();