adds more flashbots integration tests

- adds tests for sending and confirming a bundle on sepolia and mainnet

Author: dylanlott

src/utils/flashbots.rs

@@ -1,16 +1,15 @@
 //! A generic Flashbots bundle API wrapper.
 use crate::utils::signer::LocalOrAws;
 use alloy::{
-    primitives::{keccak256, BlockNumber},
+    primitives::keccak256,
     rpc::{
         json_rpc::{Id, Response, ResponsePayload, RpcRecv, RpcSend},
-        types::mev::{EthBundleHash, MevSendBundle, SimBundleResponse},
+        types::mev::{BundleItem, EthBundleHash, Inclusion, MevSendBundle, SimBundleResponse},
     },
     signers::Signer,
 };
 use init4_from_env_derive::FromEnv;
 use reqwest::header::CONTENT_TYPE;
-use serde_json::json;
 use std::borrow::Cow;
 
 /// Configuration for the Flashbots provider.
@@ -80,21 +79,7 @@ impl Flashbots {
     /// Simulate a bundle via `mev_simBundle`.
     pub async fn simulate_bundle(&self, bundle: &MevSendBundle) -> eyre::Result<()> {
         let resp: SimBundleResponse = self.raw_call("mev_simBundle", &[bundle]).await?;
-        dbg!("successfully simulated bundle", &resp);
-        Ok(())
-    }
-
-    /// Fetch the bundle status by hash.
-    pub async fn bundle_status(
-        &self,
-        hash: EthBundleHash,
-        block_number: BlockNumber,
-    ) -> eyre::Result<()> {
-        let params = json!({ "bundleHash": hash, "blockNumber": block_number });
-        let _resp: serde_json::Value = self
-            .raw_call("flashbots_getBundleStatsV2", &[params])
-            .await?;
-
+        dbg!("sim bundle response ###", resp);
         Ok(())
     }
 
@@ -139,7 +124,6 @@ impl Flashbots {
     async fn compute_signature(&self, body_bz: &[u8]) -> Result<String, eyre::Error> {
         let payload = keccak256(body_bz).to_string();
         let signature = self.signer.sign_message(payload.as_ref()).await?;
-        dbg!(signature.to_string());
         let address = self.signer.address();
         let value = format!("{address}:{signature}");
         Ok(value)

tests/flashbots.rs

@@ -1,6 +1,7 @@
 #![cfg(feature = "flashbots")]
 
 use alloy::{
+    consensus::constants::GWEI_TO_WEI,
     eips::Encodable2718,
     network::EthereumWallet,
     primitives::{B256, U256},
@@ -12,29 +13,40 @@ use alloy::{
         Identity, Provider, ProviderBuilder, SendableTx,
     },
     rpc::types::{
-        mev::{BundleItem, MevSendBundle, ProtocolVersion},
+        mev::{BundleItem, Inclusion, MevSendBundle, Privacy, ProtocolVersion},
         TransactionRequest,
     },
     signers::{local::PrivateKeySigner, Signer},
 };
-use init4_bin_base::utils::{flashbots::Flashbots, signer::LocalOrAws};
-use std::sync::LazyLock;
+use init4_bin_base::{
+    deps::tracing::debug,
+    deps::tracing_subscriber::{
+        fmt, layer::SubscriberExt, registry, util::SubscriberInitExt, EnvFilter, Layer,
+    },
+    utils::{flashbots::Flashbots, signer::LocalOrAws},
+};
+use std::{
+    env,
+    sync::LazyLock,
+    time::{Duration, Instant},
+};
 use url::Url;
 
 static FLASHBOTS_URL: LazyLock<Url> = LazyLock::new(|| {
-    Url::parse("https://relay-sepolia.flashbots.net:443").expect("valid flashbots url")
+    Url::parse("https://relay-sepolia.flashbots.net").expect("valid flashbots url")
 });
-static BUILDER_KEY: LazyLock<LocalOrAws> = LazyLock::new(|| {
+
+static DEFAULT_BUILDER_KEY: LazyLock<LocalOrAws> = LazyLock::new(|| {
     LocalOrAws::Local(PrivateKeySigner::from_bytes(&B256::repeat_byte(0x02)).unwrap())
 });
-static TEST_PROVIDER: LazyLock<Flashbots> = LazyLock::new(get_test_provider);
 
-fn get_test_provider() -> Flashbots {
-    Flashbots::new(FLASHBOTS_URL.clone(), BUILDER_KEY.clone())
+static TEST_PROVIDER: LazyLock<Flashbots> = LazyLock::new(get_default_test_provider);
+
+fn get_default_test_provider() -> Flashbots {
+    Flashbots::new(FLASHBOTS_URL.clone(), DEFAULT_BUILDER_KEY.clone())
 }
 
-#[allow(clippy::type_complexity)]
-fn get_sepolia() -> FillProvider<
+type SepoliaProvider = FillProvider<
     JoinFill<
         JoinFill<
             Identity,
@@ -43,9 +55,12 @@ fn get_sepolia() -> FillProvider<
         WalletFiller<EthereumWallet>,
     >,
     alloy::providers::RootProvider,
-> {
+>;
+
+#[allow(clippy::type_complexity)]
+fn get_sepolia(builder_key: LocalOrAws) -> SepoliaProvider {
     ProviderBuilder::new()
-        .wallet(BUILDER_KEY.clone())
+        .wallet(builder_key.clone())
         .connect_http(
             "https://ethereum-sepolia-rpc.publicnode.com"
                 .parse()
@@ -57,13 +72,13 @@ fn get_sepolia() -> FillProvider<
 #[ignore = "integration test"]
 async fn test_simulate_valid_bundle_sepolia() {
     let flashbots = &*TEST_PROVIDER;
-    let sepolia = get_sepolia();
+    let sepolia = get_sepolia(DEFAULT_BUILDER_KEY.clone());
 
     let req = TransactionRequest::default()
-        .to(BUILDER_KEY.address())
+        .to(DEFAULT_BUILDER_KEY.address())
         .value(U256::from(1u64))
         .gas_limit(51_000)
-        .from(BUILDER_KEY.address());
+        .from(DEFAULT_BUILDER_KEY.address());
     let SendableTx::Envelope(tx) = sepolia.fill(req).await.unwrap() else {
         panic!("expected filled tx");
     };
@@ -78,7 +93,7 @@ async fn test_simulate_valid_bundle_sepolia() {
 
     let bundle_body = vec![BundleItem::Tx {
         tx: tx_bytes,
-        can_revert: true,
+        can_revert: false,
     }];
     let bundle = MevSendBundle::new(latest_block, Some(0), ProtocolVersion::V0_1, bundle_body);
 
@@ -94,3 +109,188 @@ async fn test_simulate_valid_bundle_sepolia() {
         "unexpected error: {err}"
     );
 }
+
+#[tokio::test]
+#[ignore = "integration test"]
+async fn test_send_valid_bundle_sepolia() {
+    setup_logging();
+
+    let raw_key = env::var("BUILDER_KEY").expect("BUILDER_KEY must be set");
+    let builder_key = LocalOrAws::load(&raw_key, Some(11155111))
+        .await
+        .expect("failed to load builder key");
+
+    let flashbots = Flashbots::new(FLASHBOTS_URL.clone(), builder_key.clone());
+    let sepolia = get_sepolia(builder_key.clone());
+
+    let req = TransactionRequest::default()
+        .to(builder_key.address())
+        .value(U256::from(1u64))
+        .gas_limit(21_000)
+        .max_fee_per_gas((50 * GWEI_TO_WEI).into())
+        .max_priority_fee_per_gas((2 * GWEI_TO_WEI).into())
+        .from(builder_key.address());
+
+    sepolia.estimate_gas(req.clone()).await.unwrap();
+
+    let SendableTx::Envelope(tx) = sepolia.fill(req.clone()).await.unwrap() else {
+        panic!("expected filled tx");
+    };
+    let tx_bytes = tx.encoded_2718().into();
+
+    let latest_block = sepolia
+        .get_block_by_number(alloy::eips::BlockNumberOrTag::Latest)
+        .await
+        .unwrap()
+        .unwrap()
+        .number();
+    // Give ourselves a buffer: target a couple blocks out to avoid timing edges
+    let target_block = latest_block + 1;
+
+    // Assemble the bundle and target it to the latest block
+    let bundle_body = vec![BundleItem::Tx {
+        tx: tx_bytes,
+        can_revert: false,
+    }];
+    let mut bundle = MevSendBundle::new(
+        target_block,
+        Some(target_block + 5),
+        ProtocolVersion::V0_1,
+        bundle_body,
+    );
+    bundle.inclusion = Inclusion::at_block(target_block);
+    // bundle.privacy = Some(Privacy::default().with_builders(Some(vec![
+    //     "flashbots".to_string(),
+    //     "rsync".to_string(),
+    //     "Titan".to_string(),
+    //     "beaverbuild.org".to_string(),
+    // ])));
+
+    dbg!(latest_block);
+    dbg!(&bundle.inclusion.block_number(), &bundle.inclusion.max_block_number());
+
+    flashbots.simulate_bundle(&bundle).await.unwrap();
+
+    let bundle_resp = flashbots.send_bundle(&bundle).await.unwrap();
+    assert!(bundle_resp.bundle_hash != B256::ZERO);
+    dbg!(bundle_resp);
+
+    assert_tx_included(&sepolia, tx.hash().clone(), 15).await;
+}
+
+#[tokio::test]
+#[ignore = "integration test"]
+async fn test_send_valid_bundle_mainnet() {
+    setup_logging();
+
+    let raw_key = env::var("BUILDER_KEY").expect("BUILDER_KEY must be set");
+
+    let builder_key = LocalOrAws::load(&raw_key, None)
+        .await
+        .expect("failed to load builder key");
+    debug!(builder_key_address = ?builder_key.address(), "loaded builder key");
+
+    let flashbots = Flashbots::new(
+        Url::parse("https://relay.flashbots.net").unwrap(),
+        builder_key.clone(),
+    );
+    debug!(?flashbots.relay_url, "created flashbots provider");
+
+    let mainnet = ProviderBuilder::new()
+        .wallet(builder_key.clone())
+        .connect_http("https://cloudflare-eth.com".parse().unwrap());
+
+    // Build a valid transaction to bundle
+    let req = TransactionRequest::default()
+        .to(builder_key.address())
+        .value(U256::from(1u64))
+        .gas_limit(21_000)
+        .max_fee_per_gas((50 * GWEI_TO_WEI).into())
+        .max_priority_fee_per_gas((2 * GWEI_TO_WEI).into())
+        .from(builder_key.address());
+    dbg!(req.clone());
+
+    // Estimate gas will fail if this wallet isn't properly funded for this TX.
+    let gas_estimates = mainnet.estimate_gas(req.clone()).await.unwrap();
+    dbg!(gas_estimates);
+
+    let SendableTx::Envelope(tx) = mainnet.fill(req.clone()).await.unwrap() else {
+        panic!("expected filled tx");
+    };
+    dbg!(req.clone());
+
+    let tx_bytes = tx.encoded_2718().into();
+    dbg!(tx.hash());
+
+    // Fetch latest block info to build a valid target block for the bundle
+    let latest_block = mainnet
+        .get_block_by_number(alloy::eips::BlockNumberOrTag::Latest)
+        .await
+        .unwrap()
+        .unwrap()
+        .number();
+    let target_block = latest_block + 1;
+
+    // Assemble the bundle and target it to the latest block
+    let bundle_body = vec![BundleItem::Tx {
+        tx: tx_bytes,
+        can_revert: false,
+    }];
+    let mut bundle = MevSendBundle::new(target_block, None, ProtocolVersion::V0_1, bundle_body);
+    bundle.inclusion = Inclusion::at_block(target_block);
+    bundle.privacy = Some(Privacy::default().with_builders(Some(vec!["flashbots".to_string()])));
+
+    let resp = flashbots
+        .send_bundle(&bundle)
+        .await
+        .expect("should send bundle");
+    dbg!(&resp);
+
+    assert!(resp.bundle_hash != B256::ZERO);
+}
+
+/// Asserts that a tx was included in Sepolia within `deadline` seconds.
+async fn assert_tx_included(sepolia: &SepoliaProvider, tx_hash: B256, deadline: u64) {
+    let now = Instant::now();
+    let deadline = now + Duration::from_secs(deadline);
+    let mut found = false;
+
+    loop {
+        let n = Instant::now();
+        if n >= deadline {
+            break;
+        }
+
+        match sepolia.get_transaction_by_hash(tx_hash).await {
+            Ok(Some(_tx)) => {
+                found = true;
+                break;
+            }
+            Ok(None) => {
+                // Not yet present; wait and retry
+                dbg!("transaction not yet seen");
+                tokio::time::sleep(Duration::from_secs(1)).await;
+            }
+            Err(err) => {
+                // Transient error querying the provider; log and retry
+                eprintln!("warning: error querying tx: {}", err);
+                tokio::time::sleep(Duration::from_secs(1)).await;
+            }
+        }
+    }
+
+    assert!(
+        found,
+        "transaction was not seen by the provider within {:?} seconds",
+        deadline
+    );
+}
+
+/// Initializes logger for printing during testing
+pub fn setup_logging() {
+    // Initialize logging
+    let filter = EnvFilter::from_default_env();
+    let fmt = fmt::layer().with_filter(filter);
+    let registry = registry().with(fmt);
+    let _ = registry.try_init();
+}