fix: handle sender nonces for bundles

mempirate · mempirate · commit cdfff7b0e382 · 2025-12-17T14:57:48.000+01:00
diff --git a/based/crates/common/src/communication/messages.rs b/based/crates/common/src/communication/messages.rs
@@ -22,7 +22,7 @@ use tokio::sync::oneshot::{self};
 
 use crate::{
     custom_v4::OpExecutionPayloadEnvelopeV4Patch,
-    db::{DBFrag, DBSorting},
+    db::{DBFrag, DBSorting, sorting::StateId},
     order::{SimulatedBundle, ValidatedBundle, bundle::BundleValidationError},
     time::{Duration, IngestionTime, Instant, Nanos},
     transaction::{SimulatedTx, Transaction},
@@ -365,39 +365,40 @@ pub enum SequencerToSimulator<Db> {
     /// Simulate a bundle Top of frag
     SimulateBundleTof(Arc<ValidatedBundle>, DBFrag<Db>),
 }
+
 impl<Db> SequencerToSimulator<Db> {
     /// Returns simulation info.
-    /// TODO(mempirate): return type for bundle?
-    pub fn sim_info(&self) -> (Address, u64, u64) {
+    pub fn sim_info(&self) -> (StateId, Vec<(Address, u64)>) {
         match self {
-            SequencerToSimulator::SimulateTx(t, db) => (t.sender(), t.nonce(), db.state_id()),
-            SequencerToSimulator::SimulateTxTof(t, db) => (t.sender(), t.nonce(), db.state_id()),
-            SequencerToSimulator::SimulateBundle(b, db) => todo!("What to return here?"),
-            SequencerToSimulator::SimulateBundleTof(b, db) => todo!("What to return here?"),
+            SequencerToSimulator::SimulateTx(t, db) => (db.state_id(), vec![(t.sender(), t.nonce())]),
+            SequencerToSimulator::SimulateTxTof(t, db) => (db.state_id(), vec![(t.sender(), t.nonce())]),
+            SequencerToSimulator::SimulateBundle(b, db) => (db.state_id(), b.sender_nonces().collect()),
+            SequencerToSimulator::SimulateBundleTof(b, db) => (db.state_id(), b.sender_nonces().collect()),
         }
     }
 }
 
 #[derive(Debug)]
 pub struct SimulatorToSequencer {
     /// Sender address and nonce
-    pub sender_info: (Address, u64),
+    pub sender_nonces: Vec<(Address, u64)>,
     pub state_id: u64,
     pub simtime: Duration,
     pub msg: SimulatorToSequencerMsg,
 }
 
 impl SimulatorToSequencer {
-    pub fn new(sender_info: (Address, u64), state_id: u64, simtime: Duration, msg: SimulatorToSequencerMsg) -> Self {
-        Self { sender_info, state_id, simtime, msg }
-    }
-
-    pub fn sender(&self) -> &Address {
-        &self.sender_info.0
+    pub fn new(
+        sender_nonces: Vec<(Address, u64)>,
+        state_id: u64,
+        simtime: Duration,
+        msg: SimulatorToSequencerMsg,
+    ) -> Self {
+        Self { sender_nonces, state_id, simtime, msg }
     }
 
-    pub fn nonce(&self) -> u64 {
-        self.sender_info.1
+    pub fn sender_nonces(&self) -> &[(Address, u64)] {
+        &self.sender_nonces
     }
 }
 
diff --git a/based/crates/common/src/db/sorting.rs b/based/crates/common/src/db/sorting.rs
@@ -5,20 +5,22 @@ use parking_lot::RwLock;
 use super::{DBFrag, State};
 use crate::typedefs::*;
 
+pub type StateId = u64;
+
 /// DB That is used when sorting a new frag
 /// Thread safe
 #[derive(Clone, Debug)]
 pub struct DBSorting<Db> {
     pub db: Arc<RwLock<State<DBFrag<Db>>>>,
-    state_id: u64,
+    state_id: StateId,
 }
 
 impl<Db> DBSorting<Db> {
     pub fn new(frag_db: DBFrag<Db>) -> Self {
         Self { db: Arc::new(RwLock::new(State::new(frag_db))), state_id: rand::random() }
     }
 
-    pub fn state_id(&self) -> u64 {
+    pub fn state_id(&self) -> StateId {
         self.state_id
     }
 }
diff --git a/based/crates/common/src/order/bundle.rs b/based/crates/common/src/order/bundle.rs
@@ -164,6 +164,11 @@ impl ValidatedBundle {
         // SAFETY: At this point, the bundle hash is guaranteed to be initialized.
         *self.bundle_hash.get().expect("bundle hash is not initialized")
     }
+
+    /// Returns an iterator over the senders and nonces of the transactions in the bundle.
+    pub fn sender_nonces(&self) -> impl Iterator<Item = (Address, u64)> {
+        self.transactions.iter().map(|tx| (tx.sender(), tx.nonce()))
+    }
 }
 
 /// A simulated bundle.
diff --git a/based/crates/common/src/order/mod.rs b/based/crates/common/src/order/mod.rs
@@ -140,6 +140,13 @@ impl SimulatedOrder {
             SimulatedOrder::Bundle(bundle) => bundle.estimated_da(),
         }
     }
+
+    pub fn included_telemetry(&self, frag: Uuid, id_in_frag: usize) -> Telemetry {
+        match self {
+            SimulatedOrder::Tx(tx) => tx.to_included_telemetry(frag, id_in_frag),
+            SimulatedOrder::Bundle(bundle) => todo!(),
+        }
+    }
 }
 
 /// An order that is ready to be executed in the next block.
diff --git a/based/crates/sequencer/src/lib.rs b/based/crates/sequencer/src/lib.rs
@@ -508,10 +508,11 @@ where
     /// Processes transaction simulation results from the simulator actor.
     ///
     /// Handles both block transaction simulations during sorting and
-    /// transaction pool simulations for future inclusion.
+    /// order pool simulations for future inclusion.
     fn handle_sim_result(mut self, result: SimulatorToSequencer, data: &mut SequencerContext<Db>) -> Self {
-        let (sender, nonce) = result.sender_info;
         let state_id = result.state_id;
+        let sender_nonces = result.sender_nonces;
+
         let simtime = result.simtime;
         // TODO(mempirate): Handle bundle simulations.
         match result.msg {
@@ -526,10 +527,12 @@ where
                 }
 
                 data.timers.handle_sim.start();
-                sort_data.handle_sim(simulated_tx.map(SimulatedOrder::Tx), sender, data.base_fee(), simtime);
+                sort_data.handle_sim(simulated_tx.map(SimulatedOrder::Tx), sender_nonces, data.base_fee(), simtime);
                 data.timers.handle_sim.stop();
             }
             SimulatorToSequencerMsg::TxPoolTopOfFrag(simulated_tx) => {
+                let (sender, nonce) = sender_nonces.first().expect("no sender nonces");
+
                 match simulated_tx {
                     Ok(res) if data.shared_state.as_ref().is_valid(state_id) => {
                         data.tx_pool.handle_simulated(SimulatedOrder::Tx(res))
@@ -539,7 +542,7 @@ where
                         // We would have already re-sent the tx for sim on the correct fragment.
                     }
                     Err(_e) => {
-                        data.tx_pool.remove(&sender, nonce, &mut data.telemetry);
+                        data.tx_pool.remove(sender, *nonce, &mut data.telemetry);
                     }
                 }
             }
@@ -554,7 +557,12 @@ where
                 }
 
                 data.timers.handle_sim.start();
-                sort_data.handle_sim(simulated_bundle.map(SimulatedOrder::Bundle), sender, data.base_fee(), simtime);
+                sort_data.handle_sim(
+                    simulated_bundle.map(SimulatedOrder::Bundle),
+                    sender_nonces,
+                    data.base_fee(),
+                    simtime,
+                );
                 data.timers.handle_sim.stop();
             }
             SimulatorToSequencerMsg::BundleTopOfFrag(simulated_bundle) => match simulated_bundle {
@@ -566,7 +574,9 @@ where
                     // We would have already re-sent the bundle for sim on the correct fragment.
                 }
                 Err(_e) => {
-                    data.tx_pool.remove(&sender, nonce, &mut data.telemetry);
+                    for (sender, nonce) in sender_nonces {
+                        data.tx_pool.remove(&sender, nonce, &mut data.telemetry);
+                    }
                 }
             },
         }
diff --git a/based/crates/sequencer/src/simulator.rs b/based/crates/sequencer/src/simulator.rs
@@ -167,6 +167,7 @@ where
 
     // Get initial coinbase balance BEFORE any transactions
     let start_balance = balance_from_db(evm.db_mut(), coinbase);
+    let mut intermediate_balance = start_balance;
 
     // The post-state of the bundle.
     let mut post_state = ResultVecAndState::<ExecutionResult<OpHaltReason>, EvmState>::new(
@@ -187,6 +188,14 @@ where
             return Err(SimulationError::RevertWithDisallowedRevert);
         }
 
+        // Update intermediate balance and payment.
+        // NOTE: If a transaction does not touch the coinbase, this falls back to the intermediate balance (instead of
+        // 0, which would be incorrect)
+        let end_balance =
+            result_and_state.state.get(&coinbase).map(|a| a.info.balance).unwrap_or_else(|| intermediate_balance);
+        let payment = end_balance.saturating_sub(intermediate_balance);
+        intermediate_balance = end_balance;
+
         // Commit to State's in-memory cache (not the underlying db)
         // so subsequent transactions see these state changes
         // TODO(mempirate): validate that this is actually the case and we're not committing to underlying db
@@ -198,7 +207,7 @@ where
         simulated.push(SimulatedTx::new(
             tx.clone().into(),
             result_and_state,
-            U256::ZERO, // Per-tx payment not meaningful for bundles
+            payment,
             deposit_nonce,
             sim_start.elapsed(),
         ));
@@ -248,7 +257,7 @@ where
         });
 
         connections.receive(|msg: SequencerToSimulator<Db>, senders| {
-            let (sender, nonce, state_id) = msg.sim_info();
+            let (state_id, sender_nonces) = msg.sim_info();
             let curt = Instant::now();
             let msg = match msg {
                 SequencerToSimulator::SimulateTx(tx, db) => SimulatorToSequencerMsg::Tx(Self::simulate_transaction(
@@ -291,7 +300,7 @@ where
                 }
             };
             let _ = senders.send_timeout(
-                SimulatorToSequencer::new((sender, nonce), state_id, curt.elapsed(), msg),
+                SimulatorToSequencer::new(sender_nonces, state_id, curt.elapsed(), msg),
                 Duration::from_millis(10),
             );
         });
diff --git a/based/crates/sequencer/src/sorting/sorting_data.rs b/based/crates/sequencer/src/sorting/sorting_data.rs
@@ -207,32 +207,37 @@ impl<Db> SortingData<Db> {
     pub fn handle_sim(
         &mut self,
         simulated_order: SimulationResult<SimulatedOrder>,
-        sender: Address,
+        sender_nonces: Vec<(Address, u64)>,
         base_fee: u64,
         simtime: Duration,
     ) {
         self.in_flight_sims -= 1;
         self.telemetry.tot_sim_time += simtime;
 
-        tracing::trace!(%sender, "handling simulation result");
+        tracing::trace!(?sender_nonces, "handling simulation result");
 
         // handle errored sim
         let Ok(order) = simulated_order.inspect_err(|e| {
-            tracing::trace!(%sender, error = ?e, "error handling simulation result");
+            tracing::trace!(?sender_nonces, error = ?e, "error handling simulation result");
             // Send metric for simulation error
             MetricsUpdate::send(
                 self.uuid,
                 Metric::IncrementCounter(Counter::SimulationErrors, 1),
                 &mut self.metrics_producer,
             );
         }) else {
-            self.tof_snapshot.remove_from_sender(sender, base_fee);
+            for (sender, _) in &sender_nonces {
+                self.tof_snapshot.remove_from_sender(*sender, base_fee);
+            }
+
             self.telemetry.n_sims_errored += 1;
             return;
         };
 
         if self.gas_remaining < order.gas_used() {
-            self.tof_snapshot.remove_from_sender(sender, base_fee);
+            for (sender, _) in &sender_nonces {
+                self.tof_snapshot.remove_from_sender(*sender, base_fee);
+            }
             return;
         }
         self.telemetry.n_sims_succesful += 1;
@@ -439,7 +444,7 @@ impl<Db: DatabaseRef> SortingData<Db> {
         self.db.commit_ref(result_and_state.state());
         TelemetryUpdate::send(
             order.uuid(),
-            tx.to_included_telemetry(self.uuid, self.transactions.len()),
+            order.to_included_telemetry(self.uuid, self.transactions.len()),
             &mut self.telemetry_producer,
         );
 

Original file line number	Diff line number	Diff line change
`@@ -5,20 +5,22 @@ use parking_lot::RwLock;`
`5`	`5`	`use super::{DBFrag, State};`
`6`	`6`	`use crate::typedefs::*;`
`7`	`7`
	`8`	`+pub type StateId = u64;`
	`9`	`+`
`8`	`10`	`/// DB That is used when sorting a new frag`
`9`	`11`	`/// Thread safe`
`10`	`12`	`#[derive(Clone, Debug)]`
`11`	`13`	`pub struct DBSorting<Db> {`
`12`	`14`	`pub db: Arc<RwLock<State<DBFrag<Db>>>>,`
`13`		`- state_id: u64,`
	`15`	`+ state_id: StateId,`
`14`	`16`	`}`
`15`	`17`
`16`	`18`	`impl<Db> DBSorting<Db> {`
`17`	`19`	`pub fn new(frag_db: DBFrag<Db>) -> Self {`
`18`	`20`	`Self { db: Arc::new(RwLock::new(State::new(frag_db))), state_id: rand::random() }`
`19`	`21`	`}`
`20`	`22`
`21`		`- pub fn state_id(&self) -> u64 {`
	`23`	`+ pub fn state_id(&self) -> StateId {`
`22`	`24`	`self.state_id`
`23`	`25`	`}`
`24`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -164,6 +164,11 @@ impl ValidatedBundle {`
`164`	`164`	`// SAFETY: At this point, the bundle hash is guaranteed to be initialized.`
`165`	`165`	`*self.bundle_hash.get().expect("bundle hash is not initialized")`
`166`	`166`	`}`
	`167`	`+`
	`168`	`+ /// Returns an iterator over the senders and nonces of the transactions in the bundle.`
	`169`	`+ pub fn sender_nonces(&self) -> impl Iterator<Item = (Address, u64)> {`
	`170`	`+ self.transactions.iter().map(\|tx\| (tx.sender(), tx.nonce()))`
	`171`	`+ }`
`167`	`172`	`}`
`168`	`173`
`169`	`174`	`/// A simulated bundle.`
Original file line number	Diff line number	Diff line change
`@@ -140,6 +140,13 @@ impl SimulatedOrder {`
`140`	`140`	`SimulatedOrder::Bundle(bundle) => bundle.estimated_da(),`
`141`	`141`	`}`
`142`	`142`	`}`
	`143`	`+`
	`144`	`+ pub fn included_telemetry(&self, frag: Uuid, id_in_frag: usize) -> Telemetry {`
	`145`	`+ match self {`
	`146`	`+ SimulatedOrder::Tx(tx) => tx.to_included_telemetry(frag, id_in_frag),`
	`147`	`+ SimulatedOrder::Bundle(bundle) => todo!(),`
	`148`	`+ }`
	`149`	`+ }`
`143`	`150`	`}`
`144`	`151`
`145`	`152`	`/// An order that is ready to be executed in the next block.`
Original file line number	Diff line number	Diff line change
`@@ -508,10 +508,11 @@ where`
`508`	`508`	`/// Processes transaction simulation results from the simulator actor.`
`509`	`509`	`///`
`510`	`510`	`/// Handles both block transaction simulations during sorting and`
`511`		`- /// transaction pool simulations for future inclusion.`
	`511`	`+ /// order pool simulations for future inclusion.`
`512`	`512`	`fn handle_sim_result(mut self, result: SimulatorToSequencer, data: &mut SequencerContext<Db>) -> Self {`
`513`		`- let (sender, nonce) = result.sender_info;`
`514`	`513`	`let state_id = result.state_id;`
	`514`	`+ let sender_nonces = result.sender_nonces;`
	`515`	`+`
`515`	`516`	`let simtime = result.simtime;`
`516`	`517`	`// TODO(mempirate): Handle bundle simulations.`
`517`	`518`	`match result.msg {`
`@@ -526,10 +527,12 @@ where`
`526`	`527`	`}`
`527`	`528`
`528`	`529`	`data.timers.handle_sim.start();`
`529`		`- sort_data.handle_sim(simulated_tx.map(SimulatedOrder::Tx), sender, data.base_fee(), simtime);`
	`530`	`+ sort_data.handle_sim(simulated_tx.map(SimulatedOrder::Tx), sender_nonces, data.base_fee(), simtime);`
`530`	`531`	`data.timers.handle_sim.stop();`
`531`	`532`	`}`
`532`	`533`	`SimulatorToSequencerMsg::TxPoolTopOfFrag(simulated_tx) => {`
	`534`	`+ let (sender, nonce) = sender_nonces.first().expect("no sender nonces");`
	`535`	`+`
`533`	`536`	`match simulated_tx {`
`534`	`537`	`Ok(res) if data.shared_state.as_ref().is_valid(state_id) => {`
`535`	`538`	`data.tx_pool.handle_simulated(SimulatedOrder::Tx(res))`
`@@ -539,7 +542,7 @@ where`
`539`	`542`	`// We would have already re-sent the tx for sim on the correct fragment.`
`540`	`543`	`}`
`541`	`544`	`Err(_e) => {`
`542`		`- data.tx_pool.remove(&sender, nonce, &mut data.telemetry);`
	`545`	`+ data.tx_pool.remove(sender, *nonce, &mut data.telemetry);`
`543`	`546`	`}`
`544`	`547`	`}`
`545`	`548`	`}`
`@@ -554,7 +557,12 @@ where`
`554`	`557`	`}`
`555`	`558`
`556`	`559`	`data.timers.handle_sim.start();`
`557`		`- sort_data.handle_sim(simulated_bundle.map(SimulatedOrder::Bundle), sender, data.base_fee(), simtime);`
	`560`	`+ sort_data.handle_sim(`
	`561`	`+ simulated_bundle.map(SimulatedOrder::Bundle),`
	`562`	`+ sender_nonces,`
	`563`	`+ data.base_fee(),`
	`564`	`+ simtime,`
	`565`	`+ );`
`558`	`566`	`data.timers.handle_sim.stop();`
`559`	`567`	`}`
`560`	`568`	`SimulatorToSequencerMsg::BundleTopOfFrag(simulated_bundle) => match simulated_bundle {`
`@@ -566,7 +574,9 @@ where`
`566`	`574`	`// We would have already re-sent the bundle for sim on the correct fragment.`
`567`	`575`	`}`
`568`	`576`	`Err(_e) => {`
`569`		`- data.tx_pool.remove(&sender, nonce, &mut data.telemetry);`
	`577`	`+ for (sender, nonce) in sender_nonces {`
	`578`	`+ data.tx_pool.remove(&sender, nonce, &mut data.telemetry);`
	`579`	`+ }`
`570`	`580`	`}`
`571`	`581`	`},`
`572`	`582`	`}`