refactors flashbots provider

Author: dylanlott

Makefile

@@ -45,6 +45,3 @@ clippy:
 
 test-flashbots:
 	$(CARGO) test --test flashbots_provider_test -- --ignored
-
-tx-submitter:
-	$(CARGO) run --bin transaction-submitter

src/tasks/submit/flashbots/mod.rs

@@ -1,10 +1,5 @@
 //! Signet's Flashbots Block Submitter
 
-/// handles rollup block submission to the Flashbots network
-/// via the provider
-pub mod submitter;
-pub use submitter::FlashbotsSubmitter;
-
 /// implements a bundle provider API for building Flashbots
 /// compatible MEV bundles
 pub mod provider;

src/tasks/submit/flashbots/provider.rs

@@ -1,143 +1,76 @@
 //! A generic Flashbots bundle API wrapper.
-use alloy::network::{Ethereum, Network};
-use alloy::primitives::Address;
-use alloy::providers::{
-    Provider, SendableTx,
-    fillers::{FillerControlFlow, TxFiller},
+use crate::config::{BuilderConfig, HostProvider};
+use alloy::{
+    primitives::BlockNumber,
+    providers::Provider,
+    rpc::types::mev::{EthBundleHash, MevSendBundle},
 };
-use alloy::rpc::types::eth::TransactionRequest;
-use alloy::rpc::types::mev::{EthBundleHash, MevSendBundle, ProtocolVersion};
-use alloy_transport::TransportResult;
 use eyre::Context as _;
-use std::ops::Deref;
-
-use crate::tasks::block::sim::SimResult;
-use signet_types::SignedFill;
+use init4_bin_base::deps::tracing::debug;
+use serde_json::json;
+use signet_zenith::Zenith::ZenithInstance;
 
 /// A wrapper over a `Provider` that adds Flashbots MEV bundle helpers.
-#[derive(Debug, Clone)]
-pub struct FlashbotsProvider<P> {
-    inner: P,
+#[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>,
+    /// Builder configuration for the task.
+    pub config: BuilderConfig,
 }
 
-impl<P: Provider<Ethereum>> FlashbotsProvider<P> {
+impl FlashbotsProvider {
     /// Wraps a provider with the URL and returns a new `FlashbotsProvider`.
-    pub fn new(inner: P, relay_url: url::Url) -> Self {
-        Self { inner, relay_url }
-    }
-
-    /// Consume self and return the inner provider.
-    pub fn into_inner(self) -> P {
-        self.inner
-    }
-
-    /// Borrow the inner provider.
-    pub const fn inner(&self) -> &P {
-        &self.inner
-    }
-}
-
-impl<P> Deref for FlashbotsProvider<P> {
-    type Target = P;
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<P> FlashbotsProvider<P>
-where
-    P: Provider<Ethereum> + Clone + Send + Sync + 'static,
-{
-    /// Convert a SignedFill to a TransactionRequest calling the Orders contract.
-    ///
-    /// This prepares the calldata for RollupOrders::fillPermit2(outputs, permit2) and sets
-    /// `to` to the given Orders contract address. The returned request is unsigned.
-    pub fn fill_to_tx_request(fill: &SignedFill, orders_contract: Address) -> TransactionRequest {
-        fill.to_fill_tx(orders_contract)
-    }
-
-    /// Construct a new empty bundle template for the given block number.
-    pub fn empty_bundle(&self, target_block: u64) -> MevSendBundle {
-        MevSendBundle::new(target_block, Some(target_block), ProtocolVersion::V0_1, vec![])
-    }
-
-    /// Prepares a bundle transaction from the simulation result.
-    pub fn prepare_bundle(&self, sim_result: &SimResult, target_block: u64) -> MevSendBundle {
-        let bundle_body = Vec::new();
-
-        // Populate the bundle body with the simulation result.
-
-        // TODO: Push host fills into the Flashbots bundle body.
-        let _host_fills = sim_result.block.host_fills();
-        // _host_fills.iter().map(|f| f.to_fill_tx(todo!()));
-
-        // TODO: Add the rollup block blob transaction to the Flashbots bundle body.
-        // let blob_tx = ...;
-        let _ = &sim_result; // keep param used until wired
-
-        // Create the bundle from the target block and bundle body
-        MevSendBundle::new(target_block, Some(target_block), ProtocolVersion::V0_1, bundle_body)
+    pub fn new(
+        relay_url: url::Url,
+        zenith: ZenithInstance<HostProvider>,
+        config: &BuilderConfig,
+    ) -> Self {
+        Self { relay_url, zenith, 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> {
-        // NOTE: The Flashbots relay expects a single parameter which is the bundle object.
+        // 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
-            .inner
+            .zenith
+            .provider()
             .raw_request("mev_sendBundle".into(), (bundle,))
             .await
-            .wrap_err("flashbots mev_sendBundle RPC failed")?;
+            .wrap_err("mev_sendBundle RPC failed")?;
+        debug!(?hash, "mev_sendBundle response");
         Ok(hash)
     }
 
     /// Simulate a bundle via `mev_simBundle`.
-    pub async fn simulate_bundle(&self, bundle: &MevSendBundle) -> eyre::Result<()> {
-        // We ignore the response (likely a JSON object with sim traces) for now and just ensure success.
-        let _resp: serde_json::Value = self
-            .inner
+    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(),))
             .await
-            .wrap_err("flashbots mev_simBundle RPC failed")?;
+            .wrap_err("mev_simBundle RPC failed")?;
+        debug!(?resp, "mev_simBundle response");
         Ok(())
     }
 
-    /// Check the status of a previously submitted bundle.
-    pub async fn bundle_status(&self, _hash: EthBundleHash) -> eyre::Result<()> {
-        eyre::bail!("FlashbotsProvider::bundle_status unimplemented")
-    }
-}
-
-impl<N, P> TxFiller<N> for FlashbotsProvider<P>
-where
-    N: Network,
-    P: TxFiller<N> + Provider<N> + Clone + Send + Sync + core::fmt::Debug + 'static,
-{
-    type Fillable = <P as TxFiller<N>>::Fillable;
-
-    fn status(&self, tx: &N::TransactionRequest) -> FillerControlFlow {
-        TxFiller::<N>::status(&self.inner, tx)
-    }
-
-    fn fill_sync(&self, tx: &mut SendableTx<N>) {
-        TxFiller::<N>::fill_sync(&self.inner, tx)
-    }
-
-    fn prepare<Prov: Provider<N>>(
-        &self,
-        provider: &Prov,
-        tx: &N::TransactionRequest,
-    ) -> impl core::future::Future<Output = TransportResult<Self::Fillable>> + Send {
-        TxFiller::<N>::prepare(&self.inner, provider, tx)
-    }
-
-    fn fill(
+    /// Check that status of a bundle
+    pub async fn bundle_status(
         &self,
-        fillable: Self::Fillable,
-        tx: SendableTx<N>,
-    ) -> impl core::future::Future<Output = TransportResult<SendableTx<N>>> + Send {
-        TxFiller::<N>::fill(&self.inner, fillable, tx)
+        _hash: EthBundleHash,
+        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,))
+            .await
+            .wrap_err("flashbots_getBundleStatsV2 RPC failed")?;
+        debug!(?resp, "flashbots_getBundleStatsV2 response");
+        Ok(())
     }
 }