comments + add meterbundleres to bundlewmetadata

Author: wlawt

crates/core/src/lib.rs

@@ -5,4 +5,6 @@ pub mod types;
 #[cfg(any(test, feature = "test-utils"))]
 pub mod test_utils;
 
-pub use types::{Bundle, BundleHash, BundleWithMetadata, CancelBundle, MeterBundleResponse};
+pub use types::{
+    BLOCK_TIME, Bundle, BundleHash, BundleWithMetadata, CancelBundle, MeterBundleResponse,
+};

crates/core/src/types.rs

@@ -7,6 +7,9 @@ use op_alloy_flz::tx_estimated_size_fjord_bytes;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
+/// Block time in microseconds
+pub const BLOCK_TIME: u128 = 2_000_000;
+
 #[derive(Default, Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct Bundle {
@@ -70,6 +73,7 @@ pub struct BundleWithMetadata {
     bundle: Bundle,
     uuid: Uuid,
     transactions: Vec<OpTxEnvelope>,
+    meter_bundle_response: Option<MeterBundleResponse>,
 }
 
 impl BundleWithMetadata {
@@ -96,6 +100,7 @@ impl BundleWithMetadata {
             bundle,
             transactions,
             uuid,
+            meter_bundle_response: None,
         })
     }
 
@@ -140,6 +145,10 @@ impl BundleWithMetadata {
             .map(|t| tx_estimated_size_fjord_bytes(&t.encoded_2718()))
             .sum()
     }
+
+    pub fn set_meter_bundle_response(&mut self, meter_bundle_response: MeterBundleResponse) {
+        self.meter_bundle_response = Some(meter_bundle_response);
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

crates/ingress-rpc/src/service.rs

@@ -11,7 +11,9 @@ use op_alloy_network::Optimism;
 use reth_rpc_eth_types::EthApiError;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tips_audit::{BundleEvent, BundleEventPublisher};
-use tips_core::{Bundle, BundleHash, BundleWithMetadata, CancelBundle, MeterBundleResponse};
+use tips_core::{
+    BLOCK_TIME, Bundle, BundleHash, BundleWithMetadata, CancelBundle, MeterBundleResponse,
+};
 use tracing::{info, warn};
 
 use crate::queue::QueuePublisher;
@@ -65,8 +67,8 @@ where
     Audit: BundleEventPublisher + Sync + Send + 'static,
 {
     async fn send_bundle(&self, bundle: Bundle) -> RpcResult<BundleHash> {
-        let bundle_with_metadata = self.validate_bundle(&bundle).await?;
-        self.meter_bundle(&bundle).await?;
+        let mut bundle_with_metadata = self.validate_bundle(&bundle).await?;
+        bundle_with_metadata.set_meter_bundle_response(self.meter_bundle(&bundle).await?);
 
         let bundle_hash = bundle_with_metadata.bundle_hash();
         if let Err(e) = self
@@ -118,10 +120,11 @@ where
             reverting_tx_hashes: vec![transaction.tx_hash()],
             ..Default::default()
         };
-        self.meter_bundle(&bundle).await?;
+        let meter_bundle_response = self.meter_bundle(&bundle).await?;
 
-        let bundle_with_metadata = BundleWithMetadata::load(bundle)
+        let mut bundle_with_metadata = BundleWithMetadata::load(bundle)
             .map_err(|e| EthApiError::InvalidParams(e.to_string()).into_rpc_err())?;
+        bundle_with_metadata.set_meter_bundle_response(meter_bundle_response);
         let bundle_hash = bundle_with_metadata.bundle_hash();
 
         if let Err(e) = self
@@ -215,20 +218,24 @@ where
         Ok(bundle_with_metadata)
     }
 
-    async fn meter_bundle(&self, bundle: &Bundle) -> RpcResult<()> {
+    /// `meter_bundle` is used to determine how long a bundle will take to execute. A bundle that
+    /// is within `BLOCK_TIME` will return the `MeterBundleResponse` that can be passed along
+    /// to the builder.
+    async fn meter_bundle(&self, bundle: &Bundle) -> RpcResult<MeterBundleResponse> {
         let res: MeterBundleResponse = self
             .provider
             .client()
             .request("base_meterBundle", (bundle,))
             .await
             .map_err(|e| EthApiError::InvalidParams(e.to_string()).into_rpc_err())?;
 
-        // if simulation takes longer than 2s, we don't include and just error to user
-        if res.total_execution_time_us > 2000000 {
+        // we can save some builder payload building computation by not including bundles
+        // that we know will take longer than the block time to execute
+        if res.total_execution_time_us > BLOCK_TIME {
             return Err(
                 EthApiError::InvalidParams("Bundle simulation took too long".into()).into_rpc_err(),
             );
         }
-        Ok(())
+        Ok(res)
     }
 }