use FBPooledTransaction

Author: cody-wang-cb

crates/op-rbuilder/src/builders/context.rs

@@ -646,11 +646,7 @@ impl<ExtraCtx: Debug + Default> OpPayloadBuilderCtx<ExtraCtx> {
                     let total_backrun_da_size: u64 = stored_bundle
                         .backrun_txs
                         .iter()
-                        .map(|tx| {
-                            op_alloy_flz::tx_estimated_size_fjord_bytes(
-                                tx.encoded_2718().as_slice(),
-                            )
-                        })
+                        .map(|tx| tx.estimated_da_size())
                         .sum();
 
                     if let Err(result) = info.is_tx_over_limits(
@@ -678,7 +674,8 @@ impl<ExtraCtx: Debug + Default> OpPayloadBuilderCtx<ExtraCtx> {
                     let mut pending_results = Vec::with_capacity(stored_bundle.backrun_txs.len());
 
                     for backrun_tx in &stored_bundle.backrun_txs {
-                        let ResultAndState { result, state } = match evm.transact(backrun_tx) {
+                        let consensus_tx = backrun_tx.clone_into_consensus();
+                        let ResultAndState { result, state } = match evm.transact(&consensus_tx) {
                             Ok(res) => res,
                             Err(err) => {
                                 return Err(PayloadBuilderError::evm(err));
@@ -690,28 +687,25 @@ impl<ExtraCtx: Debug + Default> OpPayloadBuilderCtx<ExtraCtx> {
                             info!(
                                 target: "payload_builder",
                                 target_tx = ?tx_hash,
-                                failed_tx = ?backrun_tx.tx_hash(),
+                                failed_tx = ?backrun_tx.hash(),
                                 bundle_id = ?stored_bundle.bundle_id,
                                 gas_used = result.gas_used(),
                                 "Backrun bundle reverted (all-or-nothing)"
                             );
                             continue 'bundle_loop;
                         }
 
-                        pending_results.push((backrun_tx, result, state));
+                        pending_results.push((backrun_tx.clone(), consensus_tx, result, state));
                     }
 
-                    for (backrun_tx, result, state) in pending_results {
+                    for (backrun_tx, consensus_tx, result, state) in pending_results {
                         let backrun_gas_used = result.gas_used();
 
                         info.cumulative_gas_used += backrun_gas_used;
-                        info.cumulative_da_bytes_used +=
-                            op_alloy_flz::tx_estimated_size_fjord_bytes(
-                                backrun_tx.encoded_2718().as_slice(),
-                            );
+                        info.cumulative_da_bytes_used += backrun_tx.estimated_da_size();
 
                         let ctx = ReceiptBuilderCtx {
-                            tx: backrun_tx.inner(),
+                            tx: consensus_tx.inner(),
                             evm: &evm,
                             result,
                             state: &state,
@@ -726,9 +720,8 @@ impl<ExtraCtx: Debug + Default> OpPayloadBuilderCtx<ExtraCtx> {
                             .expect("fee is always valid; execution succeeded");
                         info.total_fees += U256::from(miner_fee) * U256::from(backrun_gas_used);
 
-                        info.executed_senders.push(backrun_tx.signer());
-                        info.executed_transactions
-                            .push(backrun_tx.clone().into_inner());
+                        info.executed_senders.push(backrun_tx.sender());
+                        info.executed_transactions.push(consensus_tx.into_inner());
                     }
 
                     self.metrics.backrun_bundles_landed_total.increment(1);

crates/op-rbuilder/src/tx_data_store.rs

@@ -1,12 +1,13 @@
-use crate::metrics::OpRBuilderMetrics;
-use alloy_consensus::{Transaction, transaction::Recovered};
+use crate::{metrics::OpRBuilderMetrics, tx::FBPooledTransaction};
+use alloy_consensus::Transaction;
 use alloy_primitives::{Address, TxHash};
 use concurrent_queue::ConcurrentQueue;
 use jsonrpsee::{
     core::{RpcResult, async_trait},
     proc_macros::rpc,
 };
-use op_alloy_consensus::OpTxEnvelope;
+use reth_optimism_txpool::OpPooledTransaction;
+use reth_transaction_pool::PoolTransaction;
 use std::{
     fmt::Debug,
     sync::{
@@ -23,7 +24,7 @@ use uuid::Uuid;
 pub struct StoredBackrunBundle {
     pub bundle_id: Uuid,
     pub sender: Address,
-    pub backrun_txs: Vec<Recovered<OpTxEnvelope>>,
+    pub backrun_txs: Vec<FBPooledTransaction>,
     pub total_priority_fee: u128,
 }
 
@@ -114,8 +115,26 @@ impl TxDataStore {
         }
 
         let target_tx_hash = bundle.txs[0].tx_hash();
-        let backrun_txs: Vec<Recovered<OpTxEnvelope>> = bundle.txs[1..].to_vec();
-        let backrun_sender = backrun_txs[0].signer();
+
+        // Convert OpTxEnvelope transactions to FBPooledTransaction
+        let backrun_txs: Vec<FBPooledTransaction> = bundle.txs[1..]
+            .iter()
+            .filter_map(|tx| {
+                let (envelope, signer) = tx.clone().into_parts();
+                let pooled_envelope: op_alloy_consensus::OpPooledTransaction =
+                    envelope.try_into().ok()?;
+                let recovered_pooled =
+                    alloy_consensus::transaction::Recovered::new_unchecked(pooled_envelope, signer);
+                let pooled = OpPooledTransaction::from_pooled(recovered_pooled);
+                Some(FBPooledTransaction::from(pooled))
+            })
+            .collect();
+
+        if backrun_txs.is_empty() {
+            return Err("No valid poolable transactions in backrun bundle".to_string());
+        }
+
+        let backrun_sender = backrun_txs[0].sender();
 
         self.evict_if_needed();
         let _ = self.data.lru.push(target_tx_hash);
@@ -307,7 +326,7 @@ impl BaseApiExtServer for TxDataStoreExt {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use alloy_consensus::SignableTransaction;
+    use alloy_consensus::{SignableTransaction, transaction::Recovered};
     use alloy_primitives::{Address, B256, TxHash, U256};
     use alloy_provider::network::TxSignerSync;
     use alloy_signer_local::PrivateKeySigner;
@@ -425,7 +444,7 @@ mod tests {
         assert_eq!(data.backrun_bundles.len(), 1);
         assert_eq!(data.backrun_bundles[0].backrun_txs.len(), 1);
         assert_eq!(
-            data.backrun_bundles[0].backrun_txs[0].tx_hash(),
+            *data.backrun_bundles[0].backrun_txs[0].hash(),
             backrun_tx1.tx_hash()
         );
 
@@ -437,7 +456,7 @@ mod tests {
         let data = store.get(&target_tx_hash);
         assert_eq!(data.backrun_bundles.len(), 1);
         assert_eq!(
-            data.backrun_bundles[0].backrun_txs[0].tx_hash(),
+            *data.backrun_bundles[0].backrun_txs[0].hash(),
             backrun_tx2.tx_hash()
         );