refactors and cleanup

- refactors the smoke tests
- cleans up the flashbots provider struct
- tighten up pubs and exports

Author: dylanlott

src/tasks/submit/flashbots/provider.rs

@@ -1,59 +1,79 @@
 //! A generic Flashbots bundle API wrapper.
-use crate::config::{BuilderConfig, HostProvider};
+use crate::config::BuilderConfig;
 use alloy::{
     primitives::BlockNumber,
-    providers::Provider,
     rpc::types::mev::{EthBundleHash, MevSendBundle},
 };
 use eyre::Context as _;
+use eyre::eyre;
 use init4_bin_base::deps::tracing::debug;
+use reqwest::Client as HttpClient;
 use serde_json::json;
-use signet_zenith::Zenith::ZenithInstance;
 
 /// A wrapper over a `Provider` that adds Flashbots MEV bundle helpers.
 #[derive(Debug)]
 pub struct FlashbotsProvider {
     /// The base URL for the Flashbots API.
     pub relay_url: url::Url,
-    /// Zenith instance for constructing Signet blocks.
-    pub zenith: ZenithInstance<HostProvider>,
+    /// Inner HTTP client used for JSON-RPC requests to the relay.
+    pub inner: HttpClient,
     /// Builder configuration for the task.
     pub config: BuilderConfig,
 }
 
 impl FlashbotsProvider {
     /// Wraps a provider with the URL and returns a new `FlashbotsProvider`.
-    pub fn new(
-        relay_url: url::Url,
-        zenith: ZenithInstance<HostProvider>,
-        config: &BuilderConfig,
-    ) -> Self {
-        Self { relay_url, zenith, config: config.clone() }
+    pub 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() }
     }
 
     /// Submit the prepared Flashbots bundle to the relay 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.
-        let hash: EthBundleHash = self
-            .zenith
-            .provider()
-            .raw_request("mev_sendBundle".into(), (bundle,))
+        // 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 RPC failed")?;
+            .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");
         Ok(hash)
     }
 
     /// Simulate a bundle via `mev_simBundle`.
     pub async fn simulate_bundle(&self, bundle: MevSendBundle) -> eyre::Result<()> {
-        let resp: serde_json::Value = self
-            .zenith
-            .provider()
-            .raw_request("mev_simBundle".into(), (bundle.clone(),))
+        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 RPC failed")?;
-        debug!(?resp, "mev_simBundle response");
+            .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");
         Ok(())
     }
 
@@ -64,13 +84,23 @@ impl FlashbotsProvider {
         block_number: BlockNumber,
     ) -> eyre::Result<()> {
         let params = json!({ "bundleHash": _hash, "blockNumber": block_number });
-        let resp: serde_json::Value = self
-            .zenith
-            .provider()
-            .raw_request("flashbots_getBundleStatsV2".into(), (params,))
+        let body = json!({ "jsonrpc": "2.0", "id": 1, "method": "flashbots_getBundleStatsV2", "params": [params] });
+        let resp = self
+            .inner
+            .post(self.relay_url.as_str())
+            .json(&body)
+            .send()
             .await
-            .wrap_err("flashbots_getBundleStatsV2 RPC failed")?;
-        debug!(?resp, "flashbots_getBundleStatsV2 response");
+            .wrap_err("flashbots_getBundleStatsV2 HTTP request failed")?;
+
+        let v: serde_json::Value =
+            resp.json().await.wrap_err("failed to parse flashbots_getBundleStatsV2 response")?;
+        if let Some(err) = v.get("error") {
+            return Err(eyre!("flashbots_getBundleStatsV2 error: {}", err));
+        }
+        debug!(?v, "flashbots_getBundleStatsV2 response");
         Ok(())
     }
 }
+
+// (no additional helpers)

src/test_utils.rs

@@ -22,17 +22,17 @@ pub fn setup_test_config() -> Result<BuilderConfig> {
     let config = BuilderConfig {
         host_chain_id: signet_constants::pecorino::HOST_CHAIN_ID,
         ru_chain_id: signet_constants::pecorino::RU_CHAIN_ID,
-        host_rpc: "https://host-rpc.pecorino.signet.sh"
+        host_rpc: "ws://host-rpc.pecorino.signet.sh"
             .parse::<BuiltInConnectionString>()
             .map(ProviderConfig::new)
             .unwrap(),
-        ru_rpc: "https://rpc.pecorino.signet.sh"
+        ru_rpc: "ws://rpc.pecorino.signet.sh"
             .parse::<BuiltInConnectionString>()
             .unwrap()
             .try_into()
             .unwrap(),
         tx_broadcast_urls: vec!["http://localhost:9000".into()],
-        flashbots_endpoint: "http://localhost:9062".parse().unwrap(), // NB: Flashbots API default
+        flashbots_endpoint: Some("http://localhost:9062".parse().unwrap()), // NB: Flashbots API default
         zenith_address: Address::default(),
         quincey_url: "http://localhost:8080".into(),
         builder_port: 8080,

tests/flashbots_provider_test.rs

@@ -7,27 +7,30 @@ mod tests {
     #[cfg(test)]
     mod tests {
         use super::*;
-        use alloy::{providers::Provider, rpc::types::mev::MevSendBundle};
-        use builder::{config::BuilderConfig, test_utils::setup_logging};
-        use init4_bin_base::utils::from_env::FromEnv;
+        use alloy::{
+            primitives::FixedBytes,
+            rpc::types::mev::{EthBundleHash, MevSendBundle},
+        };
+        use builder::{
+            config::BuilderConfig,
+            test_utils::{setup_logging, setup_test_config},
+        };
+        use init4_bin_base::{
+            deps::tracing::{error, info},
+            utils::from_env::FromEnv,
+        };
 
         #[tokio::test]
         #[ignore = "integration test"]
         async fn smoke_root_provider() {
             setup_logging();
-            let config = BuilderConfig::from_env().unwrap();
-
-            let host_provider = config.connect_host_provider().await.unwrap();
-            let zenith = config.connect_zenith(host_provider.clone());
-            let flashbots =
-                FlashbotsProvider::new(config.clone().flashbots_endpoint, zenith.clone(), &config);
-            FlashbotsProvider::new(config.clone().flashbots_endpoint, zenith.clone(), &config);
-
+            let flashbots = get_test_provider().await;
             assert_eq!(flashbots.relay_url.as_str(), "http://localhost:9062/");
 
-            let provider = flashbots.zenith.provider();
-            let block_number = provider.get_block_number().await.unwrap();
-            assert!(block_number > 0);
+            let status = flashbots
+                .bundle_status(EthBundleHash { bundle_hash: FixedBytes::default() }, 0)
+                .await;
+            assert!(status.is_err());
         }
 
         #[tokio::test]
@@ -37,16 +40,12 @@ mod tests {
 
             let res = flashbots.simulate_bundle(MevSendBundle::default()).await;
 
-            if let Err(err) = &res {
-                eprintln!("simulate error (expected for empty bundle): {err}");
-            }
-
             if let Err(err) = &res {
                 let msg = format!("{err}");
                 assert!(msg.contains("mev_simBundle"));
             }
 
-            assert!(res.is_ok() || res.is_err());
+            assert!(res.is_err());
         }
 
         #[tokio::test]
@@ -64,14 +63,8 @@ mod tests {
         }
 
         async fn get_test_provider() -> FlashbotsProvider {
-            let config = BuilderConfig::from_env().unwrap();
-
-            let host_provider = config.connect_host_provider().await.unwrap();
-            let zenith = config.connect_zenith(host_provider.clone());
-
-            let flashbots =
-                FlashbotsProvider::new(config.flashbots_endpoint.clone(), zenith, &config.clone());
-            flashbots
+            let config = setup_test_config().unwrap();
+            FlashbotsProvider::new(&config.clone())
         }
     }
 }