Credit transaction fees to the slot leader

runtime/src/accounts.rs

@@ -112,18 +112,21 @@ impl AccountsDB {
         txs: &[Transaction],
         res: &[Result<()>],
         loaded: &[Result<(InstructionAccounts, InstructionLoaders)>],
-    ) {
+    ) -> u64 {
+        let mut fee = 0;
         for (i, raccs) in loaded.iter().enumerate() {
             if res[i].is_err() || raccs.is_err() {
                 continue;
             }
 
             let tx = &txs[i];
+            fee += tx.fee;
             let acc = raccs.as_ref().unwrap();
             for (key, account) in tx.account_keys.iter().zip(acc.0.iter()) {
                 self.store(purge, key, account);
             }
         }
+        fee
     }
     fn load_tx_accounts<U>(
         checkpoints: &[U],
@@ -372,7 +375,7 @@ impl Accounts {
         txs: &[Transaction],
         res: &[Result<()>],
         loaded: &[Result<(InstructionAccounts, InstructionLoaders)>],
-    ) {
+    ) -> u64 {
         self.accounts_db
             .write()
             .unwrap()

runtime/src/bank.rs

@@ -446,9 +446,10 @@ impl Bank {
         txs: &[Transaction],
         loaded_accounts: &[Result<(InstructionAccounts, InstructionLoaders)>],
         executed: &[Result<()>],
-    ) {
+    ) -> u64 {
         let now = Instant::now();
-        self.accounts
+        let fee = self
+            .accounts
             .store_accounts(true, txs, executed, loaded_accounts);
 
         // once committed there is no way to unroll
@@ -459,6 +460,7 @@ impl Bank {
             txs.len(),
         );
         self.update_transaction_statuses(txs, &executed);
+        fee
     }
 
     /// Process a batch of transactions.
@@ -468,18 +470,19 @@ impl Bank {
         txs: &[Transaction],
         lock_results: Vec<Result<()>>,
         max_age: usize,
-    ) -> Vec<Result<()>> {
+    ) -> (Vec<Result<()>>, u64) {
         let (loaded_accounts, executed) =
             self.load_and_execute_transactions(txs, lock_results, max_age);
 
-        self.commit_transactions(txs, &loaded_accounts, &executed);
-        executed
+        let fee = self.commit_transactions(txs, &loaded_accounts, &executed);
+        (executed, fee)
     }
 
     #[must_use]
     pub fn process_transactions(&self, txs: &[Transaction]) -> Vec<Result<()>> {
         let lock_results = self.lock_accounts(txs);
-        let results = self.load_execute_and_commit_transactions(txs, lock_results, MAX_ENTRY_IDS);
+        let (results, _fee) =
+            self.load_execute_and_commit_transactions(txs, lock_results, MAX_ENTRY_IDS);
         self.unlock_accounts(txs, &results);
         results
     }
@@ -526,6 +529,13 @@ impl Bank {
         parents
     }
 
+    pub fn collect_tx_fee(&self, pubkey: &Pubkey, fee: u64) {
+        if let Some(mut account) = self.get_account(pubkey) {
+            account.tokens += fee;
+            self.accounts.store_slow(false, pubkey, &account);
+        }
+    }
+
     pub fn get_account(&self, pubkey: &Pubkey) -> Option<Account> {
         let parents = self.parents();
         let mut accounts = vec![&self.accounts];
@@ -888,7 +898,7 @@ mod tests {
         let pay_alice = vec![tx1];
 
         let lock_result = bank.lock_accounts(&pay_alice);
-        let results_alice =
+        let (results_alice, fee) =
             bank.load_execute_and_commit_transactions(&pay_alice, lock_result, MAX_ENTRY_IDS);
         assert_eq!(results_alice[0], Ok(()));