debugging and auth updates

Author: dylanlott

Cargo.lock

@@ -37,6 +37,8 @@ alloy = { version = "1.0.19", features = [
     "json-rpc",
     "signer-aws",
     "rpc-types-mev",
+    "rpc-client",
+    "rpc-types-debug",
     "rlp",
     "node-bindings",
     "serde",
@@ -58,3 +60,6 @@ tokio-stream = "0.1.17"
 url = "2.5.4"
 tracing = "0.1.41"
 async-trait = "0.1.88"
+tower = "0.4"
+bytes = "1"
+http = "0.2"

Cargo.toml

@@ -3,7 +3,7 @@
 /// implements a bundle provider API for building Flashbots
 /// compatible MEV bundles
 pub mod provider;
-pub use provider::FlashbotsProvider;
+pub use provider::Flashbots;
 
 /// handles the lifecyle of receiving, preparing, and submitting
 /// a rollup block to the Flashbots network.

src/tasks/submit/flashbots/mod.rs

@@ -1,106 +1,109 @@
 //! A generic Flashbots bundle API wrapper.
+use std::io::Read;
+
 use crate::config::BuilderConfig;
 use alloy::{
-    primitives::BlockNumber,
+    primitives::{BlockNumber, keccak256, ruint::aliases::B256},
     rpc::types::mev::{EthBundleHash, MevSendBundle},
+    signers::Signer,
 };
+use axum::body;
 use eyre::Context as _;
-use eyre::eyre;
-use init4_bin_base::deps::tracing::debug;
-use reqwest::Client as HttpClient;
+
+use reqwest::header::CONTENT_TYPE;
 use serde_json::json;
 
+use init4_bin_base::utils::signer::LocalOrAws;
+
 /// A wrapper over a `Provider` that adds Flashbots MEV bundle helpers.
 #[derive(Debug)]
-pub struct FlashbotsProvider {
+pub struct Flashbots {
     /// The base URL for the Flashbots API.
     pub relay_url: url::Url,
-    /// Inner HTTP client used for JSON-RPC requests to the relay.
-    pub inner: HttpClient,
     /// Builder configuration for the task.
     pub config: BuilderConfig,
+    /// Signer is loaded once at startup.
+    signer: LocalOrAws,
 }
 
-impl FlashbotsProvider {
+impl Flashbots {
     /// Wraps a provider with the URL and returns a new `FlashbotsProvider`.
-    pub fn new(config: &BuilderConfig) -> Self {
+    pub async fn new(config: &BuilderConfig) -> Self {
         let relay_url =
             config.flashbots_endpoint.as_ref().expect("Flashbots endpoint must be set").clone();
-        Self { relay_url, inner: HttpClient::new(), config: config.clone() }
+
+        let signer =
+            config.connect_builder_signer().await.expect("Local or AWS signer must be set");
+
+        Self { relay_url, config: config.clone(), signer }
     }
 
-    /// Submit the prepared Flashbots bundle to the relay via `mev_sendBundle`.
+    /// Sends a bundle  via `mev_sendBundle`.
     pub async fn send_bundle(&self, bundle: MevSendBundle) -> eyre::Result<EthBundleHash> {
-        // NB: The Flashbots relay expects a single parameter which is the bundle object.
-        // Alloy's `raw_request` accepts any serializable params; wrapping in a 1-tuple is fine.
-        // We POST a JSON-RPC request to the relay URL using our inner HTTP client.
-        let body =
-            json!({ "jsonrpc": "2.0", "id": 1, "method": "mev_sendBundle", "params": [bundle] });
-        let resp = self
-            .inner
-            .post(self.relay_url.as_str())
-            .json(&body)
-            .send()
-            .await
-            .wrap_err("mev_sendBundle HTTP request failed")?;
-
-        let v: serde_json::Value =
-            resp.json().await.wrap_err("failed to parse mev_sendBundle response")?;
-        if let Some(err) = v.get("error") {
-            return Err(eyre!("mev_sendBundle error: {}", err));
-        }
-        let result = v.get("result").ok_or_else(|| eyre!("mev_sendBundle missing result"))?;
-        let hash: EthBundleHash = serde_json::from_value(result.clone())
-            .wrap_err("failed to deserialize mev_sendBundle result")?;
-        debug!(?hash, "mev_sendBundle response");
+        let params = serde_json::to_value(bundle)?;
+        let v = self.raw_call("mev_sendBundle", params).await?;
+        let hash: EthBundleHash =
+            serde_json::from_value(v.get("result").cloned().unwrap_or(serde_json::Value::Null))?;
         Ok(hash)
     }
 
     /// Simulate a bundle via `mev_simBundle`.
     pub async fn simulate_bundle(&self, bundle: MevSendBundle) -> eyre::Result<()> {
-        let body =
-            json!({ "jsonrpc": "2.0", "id": 1, "method": "mev_simBundle", "params": [bundle] });
-        let resp = self
-            .inner
-            .post(self.relay_url.as_str())
-            .json(&body)
-            .send()
-            .await
-            .wrap_err("mev_simBundle HTTP request failed")?;
-
-        let v: serde_json::Value =
-            resp.json().await.wrap_err("failed to parse mev_simBundle response")?;
-        if let Some(err) = v.get("error") {
-            return Err(eyre!("mev_simBundle error: {}", err));
-        }
-        debug!(?v, "mev_simBundle response");
+        let params = serde_json::to_value(bundle)?;
+        let _ = self.raw_call("mev_simBundle", params).await?;
         Ok(())
     }
 
-    /// Check that status of a bundle
+    /// Fetches 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 body = json!({ "jsonrpc": "2.0", "id": 1, "method": "flashbots_getBundleStatsV2", "params": [params] });
-        let resp = self
-            .inner
+        let _ = self.raw_call("flashbots_getBundleStatsV2", params).await?;
+        Ok(())
+    }
+
+    /// Makes a raw JSON-RPC call with the Flashbots signature header to the method with the given params.
+    async fn raw_call(
+        &self,
+        method: &str,
+        params: serde_json::Value,
+    ) -> eyre::Result<serde_json::Value> {
+        let params = match params {
+            serde_json::Value::Array(_) => params,
+            other => serde_json::Value::Array(vec![other]),
+        };
+
+        let body = json!({"jsonrpc":"2.0","id":1,"method":method,"params":params});
+        let body_bz = serde_json::to_vec(&body)?;
+
+        let payload = format!("0x{:x}", keccak256(body_bz.clone()));
+        let signature = self.signer.sign_message(payload.as_ref()).await?;
+        dbg!(signature.to_string());
+
+        let address = self.signer.address();
+        let value = format!("{}:{}", address, signature);
+        dbg!(value.clone());
+
+        let client = reqwest::Client::new();
+        let resp = client
             .post(self.relay_url.as_str())
-            .json(&body)
+            .header(CONTENT_TYPE, "application/json")
+            .header("X-Flashbots-Signature", value)
+            .body(body_bz)
             .send()
-            .await
-            .wrap_err("flashbots_getBundleStatsV2 HTTP request failed")?;
-
+            .await?;
+        let text = resp.text().await?;
         let v: serde_json::Value =
-            resp.json().await.wrap_err("failed to parse flashbots_getBundleStatsV2 response")?;
+            serde_json::from_str(&text).wrap_err("failed to parse flashbots JSON")?;
         if let Some(err) = v.get("error") {
-            return Err(eyre!("flashbots_getBundleStatsV2 error: {}", err));
+            eyre::bail!("flashbots error: {err}");
         }
-        debug!(?v, "flashbots_getBundleStatsV2 response");
-        Ok(())
+        Ok(v)
     }
 }
 
-// (no additional helpers)
+// Raw Flashbots JSON-RPC call with header signing via reqwest.
+impl Flashbots {}

src/tasks/submit/flashbots/provider.rs

@@ -5,7 +5,7 @@ use crate::{
     quincey::Quincey,
     tasks::{
         block::sim::SimResult,
-        submit::{SubmitPrep, flashbots::FlashbotsProvider},
+        submit::{SubmitPrep, flashbots::Flashbots},
     },
     utils,
 };
@@ -216,7 +216,7 @@ impl FlashbotsTask {
     async fn task_future(self, mut inbound: mpsc::UnboundedReceiver<SimResult>) {
         debug!("starting flashbots task");
 
-        let flashbots = FlashbotsProvider::new(&self.config);
+        let flashbots = Flashbots::new(&self.config).await;
 
         loop {
             // Wait for a sim result to come in

src/tasks/submit/flashbots/task.rs

@@ -10,4 +10,4 @@ pub use builder_helper::{BuilderHelperTask, ControlFlow};
 
 /// Submission logic for Flashbots
 pub mod flashbots;
-pub use flashbots::{FlashbotsProvider, FlashbotsTask};
+pub use flashbots::{Flashbots, FlashbotsTask};

src/tasks/submit/mod.rs

@@ -1,10 +1,7 @@
 //! Test utilities for testing builder tasks
 use crate::config::BuilderConfig;
 use alloy::{
-    consensus::{SignableTransaction, TxEip1559, TxEnvelope},
-    primitives::{Address, B256, TxKind, U256},
-    rpc::client::BuiltInConnectionString,
-    signers::{SignerSync, local::PrivateKeySigner},
+    consensus::{SignableTransaction, TxEip1559, TxEnvelope}, primitives::{Address, TxKind, B256, U256}, rpc::client::BuiltInConnectionString, signers::{local::PrivateKeySigner, SignerSync}
 };
 use eyre::Result;
 use init4_bin_base::{
@@ -32,12 +29,13 @@ pub fn setup_test_config() -> Result<BuilderConfig> {
             .try_into()
             .unwrap(),
         tx_broadcast_urls: vec!["http://localhost:9000".into()],
-        flashbots_endpoint: Some("http://localhost:9062".parse().unwrap()), // NB: Flashbots API default
+        flashbots_endpoint: Some("https://relay-sepolia.flashbots.net:443".parse().unwrap()), // NB: Flashbots API default
+        // flashbots_endpoint: Some("https://relay.flashbots.net:443".parse().unwrap()), // NB: Flashbots API default
         zenith_address: Address::default(),
         quincey_url: "http://localhost:8080".into(),
         builder_port: 8080,
         sequencer_key: None,
-        builder_key: "0000000000000000000000000000000000000000000000000000000000000000".into(),
+        builder_key: PrivateKeySigner::random().to_bytes().to_string(),
         builder_rewards_address: Address::default(),
         rollup_block_gas_limit: 3_000_000_000,
         tx_pool_url: "http://localhost:9000/".parse().unwrap(),

src/test_utils.rs

@@ -2,52 +2,32 @@
 //! These tests require the `FLASHBOTS_ENDPOINT` env var to be set.
 
 use alloy::{
-    primitives::FixedBytes,
-    rpc::types::mev::{EthBundleHash, MevSendBundle},
+    eips::Encodable2718,
+    primitives::U256,
+    rpc::types::mev::{BundleItem, MevSendBundle, ProtocolVersion},
+    signers::local::PrivateKeySigner,
 };
-use builder::tasks::submit::flashbots::FlashbotsProvider;
-use builder::test_utils::{setup_logging, setup_test_config};
+use builder::tasks::submit::flashbots::Flashbots;
+use builder::test_utils::{new_signed_tx, setup_logging, setup_test_config};
 
 #[tokio::test]
 #[ignore = "integration test"]
-async fn smoke_root_provider() {
+async fn simulate_valid_bundle() {
     setup_logging();
-    let flashbots = get_test_provider().await;
-    assert_eq!(flashbots.relay_url.as_str(), "http://localhost:9062/");
-
-    let status =
-        flashbots.bundle_status(EthBundleHash { bundle_hash: FixedBytes::default() }, 0).await;
-    assert!(status.is_err());
-}
 
-#[tokio::test]
-#[ignore = "integration test"]
-async fn smoke_simulate_bundle() {
     let flashbots = get_test_provider().await;
 
-    let res = flashbots.simulate_bundle(MevSendBundle::default()).await;
+    let wallet = PrivateKeySigner::random();
+    let tx = new_signed_tx(&wallet, 0, U256::from(1u64), 51_000).unwrap();
+    let tx_bytes = tx.encoded_2718().into();
 
-    if let Err(err) = &res {
-        let msg = format!("{err}");
-        assert!(msg.contains("mev_simBundle"));
-    }
-    assert!(res.is_err());
-}
-
-#[tokio::test]
-#[ignore = "integration test"]
-async fn smoke_send_bundle() {
-    let flashbots = get_test_provider().await;
-    let res = flashbots.send_bundle(MevSendBundle::default()).await;
+    let bundle_body = vec![BundleItem::Tx { tx: tx_bytes, can_revert: false }];
+    let bundle = MevSendBundle::new(0, Some(0), ProtocolVersion::V0_1, bundle_body);
 
-    if let Err(err) = &res {
-        let msg = format!("{err}");
-        assert!(msg.contains("mev_sendBundle"));
-    }
-    assert!(res.is_ok() || res.is_err());
+    let _ = flashbots.simulate_bundle(bundle).await.expect("failed to simulate bundle");
 }
 
-async fn get_test_provider() -> FlashbotsProvider {
+async fn get_test_provider() -> Flashbots {
     let config = setup_test_config().unwrap();
-    FlashbotsProvider::new(&config.clone())
+    Flashbots::new(&config.clone()).await
 }