add flashblocks tx

Author: avalonche

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

@@ -1,29 +1,27 @@
-use alloy_consensus::TxEip1559;
-use alloy_eips::{eip7623::TOTAL_COST_FLOOR_PER_TOKEN, Encodable2718};
 use alloy_evm::Database;
 use alloy_primitives::{
     map::foldhash::{HashSet, HashSetExt},
-    Address, TxKind,
+    Address,
 };
 use core::fmt::Debug;
-use op_alloy_consensus::OpTypedTransaction;
 use op_revm::OpTransactionError;
 use reth_evm::{eth::receipt_builder::ReceiptBuilderCtx, ConfigureEvm, Evm};
 use reth_node_api::PayloadBuilderError;
 use reth_optimism_primitives::OpTransactionSigned;
 use reth_primitives::Recovered;
 use reth_provider::{ProviderError, StateProvider};
-use reth_revm::State;
+use reth_revm::{
+    database::StateProviderDatabase, db::states::bundle_state::BundleRetention, State,
+};
 use revm::{
     context::result::{EVMError, ResultAndState},
     DatabaseCommit,
 };
 use tracing::{debug, warn};
 
-use crate::{
-    builders::context::OpPayloadBuilderCtx, primitives::reth::ExecutionInfo, tx_signer::Signer,
-};
+use crate::{builders::context::OpPayloadBuilderCtx, primitives::reth::ExecutionInfo};
 
+#[derive(Debug, Clone)]
 pub struct BuilderTransactionCtx {
     pub gas_used: u64,
     pub da_size: u64,
@@ -70,20 +68,20 @@ impl From<BuilderTransactionError> for PayloadBuilderError {
     }
 }
 
-pub trait BuilderTransactions: Debug {
+pub trait BuilderTransactions<ExtraCtx: Debug + Default = ()>: Debug {
     fn simulate_builder_txs<Extra: Debug + Default>(
         &self,
         state_provider: impl StateProvider + Clone,
         info: &mut ExecutionInfo<Extra>,
-        ctx: &OpPayloadBuilderCtx,
+        ctx: &OpPayloadBuilderCtx<ExtraCtx>,
         db: &mut State<impl Database>,
     ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError>;
 
     fn add_builder_txs<Extra: Debug + Default>(
         &self,
         state_provider: impl StateProvider + Clone,
         info: &mut ExecutionInfo<Extra>,
-        builder_ctx: &OpPayloadBuilderCtx,
+        builder_ctx: &OpPayloadBuilderCtx<ExtraCtx>,
         db: &mut State<impl Database>,
     ) -> Result<(), BuilderTransactionError> {
         {
@@ -92,7 +90,7 @@ pub trait BuilderTransactions: Debug {
                 .evm_with_env(&mut *db, builder_ctx.evm_env.clone());
 
             let mut invalid: HashSet<Address> = HashSet::new();
-            // simulate builder txs on the top of block state
+
             let builder_txs =
                 self.simulate_builder_txs(state_provider, info, builder_ctx, evm.db_mut())?;
             for builder_tx in builder_txs {
@@ -139,108 +137,33 @@ pub trait BuilderTransactions: Debug {
             Ok(())
         }
     }
-}
-
-// Scaffolding for how to construct the end of block builder transaction
-// This will be the regular end of block transaction without the TEE key
-#[derive(Debug, Clone)]
-pub struct StandardBuilderTx {
-    #[allow(dead_code)]
-    pub signer: Option<Signer>,
-}
-
-impl StandardBuilderTx {
-    pub fn new(signer: Option<Signer>) -> Self {
-        Self { signer }
-    }
 
-    pub fn simulate_builder_tx(
+    fn simulate_builder_txs_state<Extra: Debug + Default>(
         &self,
-        ctx: &OpPayloadBuilderCtx,
+        state_provider: impl StateProvider + Clone,
+        builder_txs: Vec<&BuilderTransactionCtx>,
+        ctx: &OpPayloadBuilderCtx<ExtraCtx>,
         db: &mut State<impl Database>,
-    ) -> Result<Option<BuilderTransactionCtx>, BuilderTransactionError> {
-        match self.signer {
-            Some(signer) => {
-                let message: Vec<u8> = format!("Block Number: {}", ctx.block_number()).into_bytes();
-                let gas_used = self.estimate_builder_tx_gas(&message);
-                let signed_tx = self.signed_builder_tx(ctx, db, signer, gas_used, message)?;
-                let da_size = op_alloy_flz::tx_estimated_size_fjord_bytes(
-                    signed_tx.encoded_2718().as_slice(),
-                );
-                Ok(Some(BuilderTransactionCtx {
-                    gas_used,
-                    da_size,
-                    signed_tx,
-                }))
-            }
-            None => Ok(None),
+    ) -> Result<State<StateProviderDatabase<impl StateProvider>>, BuilderTransactionError> {
+        let state = StateProviderDatabase::new(state_provider.clone());
+        let mut simulation_state = State::builder()
+            .with_database(state)
+            .with_bundle_prestate(db.bundle_state.clone())
+            .with_bundle_update()
+            .build();
+        let mut evm = ctx
+            .evm_config
+            .evm_with_env(&mut simulation_state, ctx.evm_env.clone());
+
+        for builder_tx in builder_txs {
+            let ResultAndState { state, .. } = evm
+                .transact(&builder_tx.signed_tx)
+                .map_err(|err| BuilderTransactionError::EvmExecutionError(Box::new(err)))?;
+
+            evm.db_mut().commit(state);
+            evm.db_mut().merge_transitions(BundleRetention::Reverts);
         }
-    }
 
-    fn estimate_builder_tx_gas(&self, input: &[u8]) -> u64 {
-        // Count zero and non-zero bytes
-        let (zero_bytes, nonzero_bytes) = input.iter().fold((0, 0), |(zeros, nonzeros), &byte| {
-            if byte == 0 {
-                (zeros + 1, nonzeros)
-            } else {
-                (zeros, nonzeros + 1)
-            }
-        });
-
-        // Calculate gas cost (4 gas per zero byte, 16 gas per non-zero byte)
-        let zero_cost = zero_bytes * 4;
-        let nonzero_cost = nonzero_bytes * 16;
-
-        // Tx gas should be not less than floor gas https://eips.ethereum.org/EIPS/eip-7623
-        let tokens_in_calldata = zero_bytes + nonzero_bytes * 4;
-        let floor_gas = 21_000 + tokens_in_calldata * TOTAL_COST_FLOOR_PER_TOKEN;
-
-        std::cmp::max(zero_cost + nonzero_cost + 21_000, floor_gas)
-    }
-
-    fn signed_builder_tx(
-        &self,
-        ctx: &OpPayloadBuilderCtx,
-        db: &mut State<impl Database>,
-        signer: Signer,
-        gas_used: u64,
-        message: Vec<u8>,
-    ) -> Result<Recovered<OpTransactionSigned>, BuilderTransactionError> {
-        let nonce = db
-            .load_cache_account(signer.address)
-            .map(|acc| acc.account_info().unwrap_or_default().nonce)
-            .map_err(|_| BuilderTransactionError::AccountLoadFailed(signer.address))?;
-
-        // Create the EIP-1559 transaction
-        let tx = OpTypedTransaction::Eip1559(TxEip1559 {
-            chain_id: ctx.chain_id(),
-            nonce,
-            gas_limit: gas_used,
-            max_fee_per_gas: ctx.base_fee().into(),
-            max_priority_fee_per_gas: 0,
-            to: TxKind::Call(Address::ZERO),
-            // Include the message as part of the transaction data
-            input: message.into(),
-            ..Default::default()
-        });
-        // Sign the transaction
-        let builder_tx = signer
-            .sign_tx(tx)
-            .map_err(BuilderTransactionError::SigningError)?;
-
-        Ok(builder_tx)
-    }
-}
-
-impl BuilderTransactions for StandardBuilderTx {
-    fn simulate_builder_txs<Extra: Debug + Default>(
-        &self,
-        _state_provider: impl StateProvider + Clone,
-        _info: &mut ExecutionInfo<Extra>,
-        ctx: &OpPayloadBuilderCtx,
-        db: &mut State<impl Database>,
-    ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError> {
-        let builder_tx = self.simulate_builder_tx(ctx, db)?;
-        Ok(builder_tx.into_iter().collect())
+        Ok(simulation_state)
     }
 }

crates/op-rbuilder/src/builders/flashblocks/builder_tx.rs

@@ -0,0 +1,149 @@
+use alloy_consensus::TxEip1559;
+use alloy_eips::{eip7623::TOTAL_COST_FLOOR_PER_TOKEN, Encodable2718};
+use alloy_evm::Database;
+use alloy_primitives::{Address, TxKind};
+use core::fmt::Debug;
+use op_alloy_consensus::OpTypedTransaction;
+use reth_optimism_primitives::OpTransactionSigned;
+use reth_primitives::Recovered;
+use reth_provider::StateProvider;
+use reth_revm::State;
+
+use crate::{
+    builders::{
+        context::OpPayloadBuilderCtx, flashblocks::payload::FlashblocksExtraCtx,
+        BuilderTransactionCtx, BuilderTransactionError, BuilderTransactions,
+    },
+    flashtestations::builder_tx::FlashtestationsBuilderTx,
+    primitives::reth::ExecutionInfo,
+    tx_signer::Signer,
+};
+
+// This will be the end of block transaction of a regular block
+#[derive(Debug, Clone)]
+pub struct FlashblocksBuilderTx {
+    pub signer: Option<Signer>,
+    pub flashtestations_builder_tx: Option<FlashtestationsBuilderTx>,
+}
+
+impl FlashblocksBuilderTx {
+    pub fn new(
+        signer: Option<Signer>,
+        flashtestations_builder_tx: Option<FlashtestationsBuilderTx>,
+    ) -> Self {
+        Self {
+            signer,
+            flashtestations_builder_tx,
+        }
+    }
+
+    pub fn simulate_builder_tx<ExtraCtx: Debug + Default>(
+        &self,
+        ctx: &OpPayloadBuilderCtx<ExtraCtx>,
+        db: &mut State<impl Database>,
+    ) -> Result<Option<BuilderTransactionCtx>, BuilderTransactionError> {
+        match self.signer {
+            Some(signer) => {
+                let message: Vec<u8> = format!("Block Number: {}", ctx.block_number()).into_bytes();
+                let gas_used = self.estimate_builder_tx_gas(&message);
+                let signed_tx = self.signed_builder_tx(ctx, db, signer, gas_used, message)?;
+                let da_size = op_alloy_flz::tx_estimated_size_fjord_bytes(
+                    signed_tx.encoded_2718().as_slice(),
+                );
+                Ok(Some(BuilderTransactionCtx {
+                    gas_used,
+                    da_size,
+                    signed_tx,
+                }))
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn estimate_builder_tx_gas(&self, input: &[u8]) -> u64 {
+        // Count zero and non-zero bytes
+        let (zero_bytes, nonzero_bytes) = input.iter().fold((0, 0), |(zeros, nonzeros), &byte| {
+            if byte == 0 {
+                (zeros + 1, nonzeros)
+            } else {
+                (zeros, nonzeros + 1)
+            }
+        });
+
+        // Calculate gas cost (4 gas per zero byte, 16 gas per non-zero byte)
+        let zero_cost = zero_bytes * 4;
+        let nonzero_cost = nonzero_bytes * 16;
+
+        // Tx gas should be not less than floor gas https://eips.ethereum.org/EIPS/eip-7623
+        let tokens_in_calldata = zero_bytes + nonzero_bytes * 4;
+        let floor_gas = 21_000 + tokens_in_calldata * TOTAL_COST_FLOOR_PER_TOKEN;
+
+        std::cmp::max(zero_cost + nonzero_cost + 21_000, floor_gas)
+    }
+
+    fn signed_builder_tx<ExtraCtx: Debug + Default>(
+        &self,
+        ctx: &OpPayloadBuilderCtx<ExtraCtx>,
+        db: &mut State<impl Database>,
+        signer: Signer,
+        gas_used: u64,
+        message: Vec<u8>,
+    ) -> Result<Recovered<OpTransactionSigned>, BuilderTransactionError> {
+        let nonce = db
+            .load_cache_account(signer.address)
+            .map(|acc| acc.account_info().unwrap_or_default().nonce)
+            .map_err(|_| BuilderTransactionError::AccountLoadFailed(signer.address))?;
+
+        // Create the EIP-1559 transaction
+        let tx = OpTypedTransaction::Eip1559(TxEip1559 {
+            chain_id: ctx.chain_id(),
+            nonce,
+            gas_limit: gas_used,
+            max_fee_per_gas: ctx.base_fee().into(),
+            max_priority_fee_per_gas: 0,
+            to: TxKind::Call(Address::ZERO),
+            // Include the message as part of the transaction data
+            input: message.into(),
+            ..Default::default()
+        });
+        // Sign the transaction
+        let builder_tx = signer
+            .sign_tx(tx)
+            .map_err(BuilderTransactionError::SigningError)?;
+
+        Ok(builder_tx)
+    }
+}
+
+impl BuilderTransactions<FlashblocksExtraCtx> for FlashblocksBuilderTx {
+    fn simulate_builder_txs<Extra: Debug + Default>(
+        &self,
+        state_provider: impl StateProvider + Clone,
+        info: &mut ExecutionInfo<Extra>,
+        ctx: &OpPayloadBuilderCtx<FlashblocksExtraCtx>,
+        db: &mut State<impl Database>,
+    ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError> {
+        let mut builder_txs = Vec::<BuilderTransactionCtx>::new();
+        let flashblocks_builder_tx = self.simulate_builder_tx(ctx, db)?;
+        builder_txs.extend(flashblocks_builder_tx.clone());
+        if let Some(flashtestations_builder_tx) = &self.flashtestations_builder_tx {
+            // We only include flashtestations txs in the last flashblock
+            if ctx.flashblock_index() == ctx.target_flashblock_count() - 1 {
+                let mut simulation_state = self.simulate_builder_txs_state::<FlashblocksExtraCtx>(
+                    state_provider.clone(),
+                    flashblocks_builder_tx.iter().collect(),
+                    ctx,
+                    db,
+                )?;
+                let flashtestations_builder_txs = flashtestations_builder_tx.simulate_builder_txs(
+                    state_provider,
+                    info,
+                    ctx,
+                    &mut simulation_state,
+                )?;
+                builder_txs.extend(flashtestations_builder_txs);
+            }
+        }
+        Ok(builder_txs)
+    }
+}

crates/op-rbuilder/src/builders/flashblocks/mod.rs

@@ -3,8 +3,8 @@ use crate::traits::{NodeBounds, PoolBounds};
 use config::FlashblocksConfig;
 use service::FlashblocksServiceBuilder;
 
+mod builder_tx;
 mod config;
-//mod context;
 mod payload;
 mod service;
 mod wspub;