fix: a transaction may visit miner account but don't update it

src/partition.rs

@@ -104,6 +104,7 @@ where
     pub(crate) fn execute(&mut self) {
         let start = Instant::now();
         let coinbase = self.env.block.coinbase;
+        let mut committed_accumulated_rewards = 0;
         let mut evm = EvmBuilder::default()
             .with_db(&mut self.partition_db)
             .with_spec_id(self.spec_id)
@@ -173,6 +174,16 @@ where
                             read_set.iter().all(|l| tx_states[txid].read_set.contains_key(l.0));
                         skip_validation &=
                             write_set.iter().all(|l| tx_states[txid].write_set.contains(l));
+                        if let Some(accumulator) = self.rewards_accumulators.get(&txid) {
+                            let contains_miner =
+                                write_set.contains(&LocationAndType::Basic(coinbase));
+                            accumulator.rewards_committed.store(contains_miner, Ordering::Release);
+                            if contains_miner {
+                                committed_accumulated_rewards = evm.db().accumulated_rewards;
+                            } else {
+                                evm.db_mut().accumulated_rewards = committed_accumulated_rewards;
+                            }
+                        }
 
                         // temporary commit to cache_db, to make use the remaining txs can read the
                         // updated data

src/scheduler.rs

@@ -21,7 +21,10 @@ use revm::{
 use std::{
     collections::{BTreeMap, BTreeSet},
     ops::DerefMut,
-    sync::{atomic::AtomicUsize, Arc, RwLock},
+    sync::{
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+        Arc, RwLock,
+    },
     time::{Duration, Instant},
 };
 use tokio::sync::Notify;
@@ -137,6 +140,7 @@ pub(crate) struct RewardsAccumulator {
     pub accumulate_counter: AtomicUsize,
     pub accumulate_rewards: Atomic<u128>,
     pub notifier: Arc<Notify>,
+    pub rewards_committed: AtomicBool,
 }
 
 impl RewardsAccumulator {
@@ -146,6 +150,7 @@ impl RewardsAccumulator {
             accumulate_counter: AtomicUsize::new(0),
             accumulate_rewards: Atomic::<u128>::new(0),
             notifier: Arc::new(Notify::new()),
+            rewards_committed: AtomicBool::new(false),
         }
     }
 }
@@ -556,11 +561,13 @@ where
 
         let span = Span::enter_with_local_parent("database commit transitions");
         let mut rewards = 0;
-        let rewards_start_txid =
-            match self.rewards_accumulators.range(..self.num_finality_txs).next_back() {
-                Some((txid, _)) => *txid,
-                None => start_txid,
-            };
+        let mut rewards_start_txid = start_txid;
+        for (txid, accumulator) in self.rewards_accumulators.range(..self.num_finality_txs).rev() {
+            if accumulator.rewards_committed.load(Ordering::Acquire) {
+                rewards_start_txid = *txid;
+                break;
+            }
+        }
         for txid in start_txid..self.num_finality_txs {
             if txid >= rewards_start_txid {
                 rewards += tx_states[txid].execute_result.rewards;

src/storage.rs

@@ -419,7 +419,7 @@ pub(crate) struct PartitionDB<DB> {
     pub current_txid: TxId,
     pub raw_transfer: bool,
     rewards_accumulators: Arc<RewardsAccumulators>,
-    accumulated_rewards: u128,
+    pub accumulated_rewards: u128,
 }
 
 impl<DB> PartitionDB<DB> {