make meter_response not optional

Author: wlawt

crates/core/src/test_utils.rs

@@ -1,4 +1,4 @@
-use crate::{Bundle, BundleWithMetadata};
+use crate::{Bundle, BundleWithMetadata, MeterBundleResponse};
 use alloy_consensus::SignableTransaction;
 use alloy_primitives::{Address, U256};
 use alloy_provider::network::TxSignerSync;
@@ -38,6 +38,7 @@ pub fn create_test_bundle(
         max_timestamp,
         ..Default::default()
     };
+    let meter_bundle_response = MeterBundleResponse::default();
 
-    BundleWithMetadata::load(bundle).unwrap()
+    BundleWithMetadata::load(bundle, meter_bundle_response).unwrap()
 }

crates/core/src/types.rs

@@ -73,11 +73,14 @@ pub struct BundleWithMetadata {
     bundle: Bundle,
     uuid: Uuid,
     transactions: Vec<OpTxEnvelope>,
-    meter_bundle_response: Option<MeterBundleResponse>,
+    meter_bundle_response: MeterBundleResponse,
 }
 
 impl BundleWithMetadata {
-    pub fn load(mut bundle: Bundle) -> Result<Self, String> {
+    pub fn load(
+        mut bundle: Bundle,
+        meter_bundle_response: MeterBundleResponse,
+    ) -> Result<Self, String> {
         let uuid = bundle
             .replacement_uuid
             .clone()
@@ -100,7 +103,7 @@ impl BundleWithMetadata {
             bundle,
             transactions,
             uuid,
-            meter_bundle_response: None,
+            meter_bundle_response,
         })
     }
 
@@ -145,10 +148,6 @@ 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)]
@@ -187,6 +186,24 @@ pub struct MeterBundleResponse {
     pub state_root_time_us: u128,
 }
 
+impl Default for MeterBundleResponse {
+    fn default() -> Self {
+        Self {
+            bundle_gas_price: "0".to_string(),
+            bundle_hash: B256::default(),
+            coinbase_diff: "0".to_string(),
+            eth_sent_to_coinbase: "0".to_string(),
+            gas_fees: "0".to_string(),
+            results: vec![],
+            state_block_number: 0,
+            state_flashblock_index: None,
+            total_gas_used: 0,
+            total_execution_time_us: 0,
+            state_root_time_us: 0,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -206,12 +223,15 @@ mod tests {
         let tx1_bytes = tx1.encoded_2718();
         let tx2_bytes = tx2.encoded_2718();
 
-        let bundle = BundleWithMetadata::load(Bundle {
-            replacement_uuid: None,
-            txs: vec![tx1_bytes.clone().into()],
-            block_number: 1,
-            ..Default::default()
-        })
+        let bundle = BundleWithMetadata::load(
+            Bundle {
+                replacement_uuid: None,
+                txs: vec![tx1_bytes.clone().into()],
+                block_number: 1,
+                ..Default::default()
+            },
+            MeterBundleResponse::default(),
+        )
         .unwrap();
 
         assert!(!bundle.uuid().is_nil());
@@ -234,12 +254,15 @@ mod tests {
         assert_eq!(bundle.bundle_hash(), expected_bundle_hash_single);
 
         let uuid = Uuid::new_v4();
-        let bundle = BundleWithMetadata::load(Bundle {
-            replacement_uuid: Some(uuid.to_string()),
-            txs: vec![tx1_bytes.clone().into(), tx2_bytes.clone().into()],
-            block_number: 1,
-            ..Default::default()
-        })
+        let bundle = BundleWithMetadata::load(
+            Bundle {
+                replacement_uuid: Some(uuid.to_string()),
+                txs: vec![tx1_bytes.clone().into(), tx2_bytes.clone().into()],
+                block_number: 1,
+                ..Default::default()
+            },
+            MeterBundleResponse::default(),
+        )
         .unwrap();
 
         assert_eq!(*bundle.uuid(), uuid);

crates/ingress-rpc/src/queue.rs

@@ -75,7 +75,7 @@ impl QueuePublisher for KafkaQueuePublisher {
 mod tests {
     use super::*;
     use rdkafka::config::ClientConfig;
-    use tips_core::{Bundle, BundleWithMetadata};
+    use tips_core::{Bundle, BundleWithMetadata, MeterBundleResponse};
     use tokio::time::{Duration, Instant};
 
     fn create_test_bundle() -> Bundle {
@@ -93,7 +93,8 @@ mod tests {
 
         let publisher = KafkaQueuePublisher::new(producer, "tips-ingress-rpc".to_string());
         let bundle = create_test_bundle();
-        let bundle_with_metadata = BundleWithMetadata::load(bundle.clone()).unwrap();
+        let bundle_with_metadata =
+            BundleWithMetadata::load(bundle.clone(), MeterBundleResponse::default()).unwrap();
         let bundle_hash = bundle_with_metadata.bundle_hash();
 
         let start = Instant::now();

crates/ingress-rpc/src/service.rs

@@ -67,8 +67,10 @@ where
     Audit: BundleEventPublisher + Sync + Send + 'static,
 {
     async fn send_bundle(&self, bundle: Bundle) -> RpcResult<BundleHash> {
-        let mut bundle_with_metadata = self.validate_bundle(&bundle).await?;
-        bundle_with_metadata.set_meter_bundle_response(self.meter_bundle(&bundle).await?);
+        self.validate_bundle(&bundle).await?;
+        let meter_bundle_response = self.meter_bundle(&bundle).await?;
+        let bundle_with_metadata = BundleWithMetadata::load(bundle, meter_bundle_response)
+            .map_err(|e| EthApiError::InvalidParams(e.to_string()).into_rpc_err())?;
 
         let bundle_hash = bundle_with_metadata.bundle_hash();
         if let Err(e) = self
@@ -122,9 +124,8 @@ where
         };
         let meter_bundle_response = self.meter_bundle(&bundle).await?;
 
-        let mut bundle_with_metadata = BundleWithMetadata::load(bundle)
+        let bundle_with_metadata = BundleWithMetadata::load(bundle, meter_bundle_response)
             .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
@@ -196,26 +197,24 @@ where
         Ok(transaction)
     }
 
-    async fn validate_bundle(&self, bundle: &Bundle) -> RpcResult<BundleWithMetadata> {
+    async fn validate_bundle(&self, bundle: &Bundle) -> RpcResult<()> {
         if bundle.txs.is_empty() {
             return Err(
                 EthApiError::InvalidParams("Bundle cannot have empty transactions".into())
                     .into_rpc_err(),
             );
         }
 
-        let bundle_with_metadata = BundleWithMetadata::load(bundle.clone())
-            .map_err(|e| EthApiError::InvalidParams(e.to_string()).into_rpc_err())?;
-        let tx_hashes = bundle_with_metadata.txn_hashes();
-
         let mut total_gas = 0u64;
+        let mut tx_hashes = Vec::new();
         for tx_data in &bundle.txs {
             let transaction = self.validate_tx(tx_data).await?;
             total_gas = total_gas.saturating_add(transaction.gas_limit());
+            tx_hashes.push(transaction.tx_hash());
         }
         validate_bundle(bundle, total_gas, tx_hashes)?;
 
-        Ok(bundle_with_metadata)
+        Ok(())
     }
 
     /// `meter_bundle` is used to determine how long a bundle will take to execute. A bundle that