adds bundle simulation

Author: dylanlott

bin/builder.rs

@@ -29,7 +29,7 @@ async fn main() -> eyre::Result<()> {
     let builder = BlockBuilder::new(&config, authenticator.clone(), ru_provider);
     let submit = SubmitTask {
         authenticator: authenticator.clone(),
-        host_provider,
+        host_provider: host_provider.clone(),
         zenith,
         client: reqwest::Client::new(),
         sequencer_signer,
@@ -38,7 +38,7 @@ async fn main() -> eyre::Result<()> {
 
     let authenticator_jh = authenticator.spawn();
     let (submit_channel, submit_jh) = submit.spawn();
-    let build_jh = builder.spawn(submit_channel);
+    let build_jh = builder.spawn(submit_channel, host_provider.clone());
 
     let port = config.builder_port;
     let server = serve_builder_with_span(([0, 0, 0, 0], port), span);

src/tasks/block.rs

@@ -1,19 +1,23 @@
 use super::bundler::{Bundle, BundlePoller};
 use super::oauth::Authenticator;
 use super::tx_poller::TxPoller;
-use crate::config::{BuilderConfig, WalletlessProvider};
-use alloy::primitives::{keccak256, Bytes, B256};
-use alloy::providers::Provider;
+
+use crate::config::{BuilderConfig, Provider, WalletlessProvider};
+
+use alloy::primitives::{keccak256, Bytes, FixedBytes, B256};
+use alloy::providers::Provider as _;
+use alloy::rpc::types::TransactionRequest;
 use alloy::{
     consensus::{SidecarBuilder, SidecarCoder, TxEnvelope},
     eips::eip2718::Decodable2718,
 };
 use alloy_rlp::Buf;
+use eyre::{bail, eyre};
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::{sync::OnceLock, time::Duration};
 use tokio::{sync::mpsc, task::JoinHandle};
 use tracing::{debug, error, Instrument};
-use zenith_types::{encode_txns, Alloy2718Coder};
+use zenith_types::{encode_txns, Alloy2718Coder, ZenithEthBundle};
 
 /// Ethereum's slot time in seconds.
 pub const ETHEREUM_SLOT_TIME: u64 = 12;
@@ -153,14 +157,17 @@ impl BlockBuilder {
         }
     }
 
-    async fn get_bundles(&mut self, in_progress: &mut InProgressBlock) {
+    async fn get_bundles(&mut self, host_provider: &Provider, in_progress: &mut InProgressBlock) {
         tracing::trace!("query bundles from cache");
         let bundles = self.bundle_poller.check_bundle_cache().await;
         // OPTIMIZE: Sort bundles received from cache
         match bundles {
             Ok(bundles) => {
                 for bundle in bundles {
-                    in_progress.ingest_bundle(bundle);
+                    let result = self.simulate_bundle(&bundle.bundle, host_provider).await;
+                    if result.is_ok() {
+                        in_progress.ingest_bundle(bundle.clone());
+                    }
                 }
             }
             Err(e) => {
@@ -170,6 +177,54 @@ impl BlockBuilder {
         self.bundle_poller.evict();
     }
 
+    /// Simulates a Flashbots-style ZenithEthBundle, simualating each transaction in it's bundle
+    /// by calling it against the host provider at the current height against default storage (no state overrides)
+    /// and failing the whole bundle if any transaction not listed in the reverts list fails that call.
+    async fn simulate_bundle(
+        &mut self,
+        bundle: &ZenithEthBundle,
+        host_provider: &Provider,
+    ) -> eyre::Result<()> {
+        tracing::info!("simulating bundle");
+
+        let reverts = &bundle.bundle.reverting_tx_hashes;
+        tracing::debug!(reverts = ?reverts, "processing bundle with reverts");
+
+        for tx in &bundle.bundle.txs {
+            let (tx_env, hash) = self.parse_from_bundle(tx)?;
+
+            // Simulate and check for reversion allowance
+            match self.simulate_transaction(host_provider, tx_env).await {
+                Ok(_) => {
+                    // Passed, log trace and continue
+                    tracing::debug!(tx = %hash, "tx passed simulation");
+                    continue;
+                }
+                Err(sim_err) => {
+                    // Failed, only continfue if tx is marked in revert list
+                    tracing::debug!("tx failed simulation: {}", sim_err);
+                    if reverts.contains(&hash) {
+                        continue;
+                    } else {
+                        bail!("tx {hash} failed simulation but was not marked as allowed to revert")
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Simulates a transaction by calling it on the host provider at the current height with the current state.
+    async fn simulate_transaction(
+        &self,
+        host_provider: &Provider,
+        tx_env: TxEnvelope,
+    ) -> eyre::Result<()> {
+        let tx = TransactionRequest::from_transaction(tx_env);
+        host_provider.call(&tx).await?;
+        Ok(())
+    }
+
     async fn filter_transactions(&self, in_progress: &mut InProgressBlock) {
         // query the rollup node to see which transaction(s) have been included
         let mut confirmed_transactions = Vec::new();
@@ -203,9 +258,25 @@ impl BlockBuilder {
         self.secs_to_next_slot() + self.config.target_slot_time
     }
 
+    /// Parses bytes into a transaction envelope that is compatible with Flashbots-style bundles
+    fn parse_from_bundle(&self, tx: &Bytes) -> Result<(TxEnvelope, FixedBytes<32>), eyre::Error> {
+        let tx_env = TxEnvelope::decode_2718(&mut tx.chunk())?;
+        let hash = tx_env.tx_hash().to_owned();
+        tracing::debug!(hash = %hash, "decoded bundle tx");
+        if tx_env.is_eip4844() {
+            tracing::error!("eip-4844 disallowed");
+            return Err(eyre!("EIP-4844 transactions are not allowed in bundles"));
+        }
+        Ok((tx_env, hash))
+    }
+
     /// Spawn the block builder task, returning the inbound channel to it, and
     /// a handle to the running task.
-    pub fn spawn(mut self, outbound: mpsc::UnboundedSender<InProgressBlock>) -> JoinHandle<()> {
+    pub fn spawn(
+        mut self,
+        outbound: mpsc::UnboundedSender<InProgressBlock>,
+        host_provider: Provider,
+    ) -> JoinHandle<()> {
         tokio::spawn(
             async move {
                 loop {
@@ -216,7 +287,7 @@ impl BlockBuilder {
                     // Build a block
                     let mut in_progress = InProgressBlock::default();
                     self.get_transactions(&mut in_progress).await;
-                    self.get_bundles(&mut in_progress).await;
+                    self.get_bundles(&host_provider, &mut in_progress).await;
 
                     // Filter confirmed transactions from the block
                     self.filter_transactions(&mut in_progress).await;

src/tasks/submit.rs

@@ -6,8 +6,7 @@ use crate::{
 use alloy::{
     consensus::{constants::GWEI_TO_WEI, SimpleCoder},
     eips::BlockNumberOrTag,
-    network::TransactionBuilder,
-    network::TransactionBuilder4844,
+    network::{TransactionBuilder, TransactionBuilder4844},
     primitives::{FixedBytes, U256},
     providers::{Provider as _, SendableTx, WalletProvider},
     rpc::types::eth::TransactionRequest,