spike from

wlawt · wlawt · commit 30383fd73547 · 2025-10-31T14:02:25.000-04:00
diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs
@@ -6,6 +6,6 @@ pub mod types;
 pub mod test_utils;
 
 pub use types::{
-    BLOCK_TIME, Bundle, BundleHash, BundleProperties, BundleWithMetadata, CancelBundle,
+    BLOCK_TIME, Bundle, BundleHash, BundleTransactions, BundleWithMetadata, CancelBundle,
     MeterBundleResponse,
 };
diff --git a/crates/core/src/types.rs b/crates/core/src/types.rs
@@ -10,8 +10,66 @@ use uuid::Uuid;
 /// Block time in microseconds
 pub const BLOCK_TIME: u128 = 2_000_000;
 
-pub trait BundleProperties {
-    fn bundle_hash(&self) -> B256;
+pub struct BundleTransactions(Vec<Bytes>);
+
+impl From<Vec<Bytes>> for BundleTransactions {
+    fn from(txs: Vec<Bytes>) -> Self {
+        BundleTransactions(txs)
+    }
+}
+
+impl BundleTransactions {
+    pub fn bundle_hash(&self) -> B256 {
+        let mut concatenated = Vec::new();
+        for tx in self.0.iter() {
+            concatenated.extend_from_slice(tx);
+        }
+        keccak256(&concatenated)
+    }
+
+    /// Get transaction hashes for all transactions in the bundle
+    pub fn txn_hashes(&self) -> Result<Vec<TxHash>, String> {
+        self.transactions()?
+            .iter()
+            .map(|t| Ok(t.tx_hash()))
+            .collect()
+    }
+
+    /// Get sender addresses for all transactions in the bundle
+    pub fn senders(&self) -> Result<Vec<Address>, String> {
+        self.transactions()?
+            .iter()
+            .map(|t| {
+                t.recover_signer()
+                    .map_err(|e| format!("failed to recover signer: {e}"))
+            })
+            .collect()
+    }
+
+    /// Get total gas limit for all transactions in the bundle
+    pub fn gas_limit(&self) -> Result<u64, String> {
+        Ok(self.transactions()?.iter().map(|t| t.gas_limit()).sum())
+    }
+
+    /// Get total data availability size for all transactions in the bundle
+    pub fn da_size(&self) -> Result<u64, String> {
+        Ok(self
+            .transactions()?
+            .iter()
+            .map(|t| tx_estimated_size_fjord_bytes(&t.encoded_2718()))
+            .sum())
+    }
+
+    /// Decode all transactions from bytes to OpTxEnvelope
+    pub fn transactions(&self) -> Result<Vec<OpTxEnvelope>, String> {
+        self.0
+            .iter()
+            .map(|b| {
+                OpTxEnvelope::decode_2718_exact(b)
+                    .map_err(|e| format!("failed to decode transaction: {e}"))
+            })
+            .collect()
+    }
 }
 
 #[derive(Default, Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -60,26 +118,6 @@ pub struct Bundle {
     pub dropping_tx_hashes: Vec<TxHash>,
 }
 
-impl BundleProperties for Bundle {
-    fn bundle_hash(&self) -> B256 {
-        let transactions: Vec<OpTxEnvelope> = self
-            .txs
-            .iter()
-            .map(|b| {
-                OpTxEnvelope::decode_2718_exact(b)
-                    .map_err(|e| format!("failed to decode transaction: {e}"))
-            })
-            .collect::<Result<Vec<_>, _>>()
-            .expect("failed to decode transactions");
-
-        let mut concatenated = Vec::new();
-        for tx in transactions {
-            concatenated.extend_from_slice(tx.tx_hash().as_slice());
-        }
-        keccak256(&concatenated)
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct BundleHash {
@@ -131,45 +169,13 @@ impl BundleWithMetadata {
         })
     }
 
-    pub fn transactions(&self) -> &[OpTxEnvelope] {
-        self.transactions.as_slice()
-    }
-
     pub fn uuid(&self) -> &Uuid {
         &self.uuid
     }
 
-    pub fn txn_hashes(&self) -> Vec<TxHash> {
-        self.transactions().iter().map(|t| t.tx_hash()).collect()
-    }
-
     pub fn bundle(&self) -> &Bundle {
         &self.bundle
     }
-
-    pub fn senders(&self) -> Vec<Address> {
-        self.transactions()
-            .iter()
-            .map(|t| t.recover_signer().unwrap())
-            .collect()
-    }
-
-    pub fn gas_limit(&self) -> u64 {
-        self.transactions.iter().map(|t| t.gas_limit()).sum()
-    }
-
-    pub fn da_size(&self) -> u64 {
-        self.transactions
-            .iter()
-            .map(|t| tx_estimated_size_fjord_bytes(&t.encoded_2718()))
-            .sum()
-    }
-}
-
-impl BundleProperties for BundleWithMetadata {
-    fn bundle_hash(&self) -> B256 {
-        self.bundle.bundle_hash()
-    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -243,10 +249,11 @@ mod tests {
             bundle.bundle.replacement_uuid,
             Some(bundle.uuid().to_string())
         );
-        assert_eq!(bundle.txn_hashes().len(), 1);
-        assert_eq!(bundle.txn_hashes()[0], tx1.tx_hash());
-        assert_eq!(bundle.senders().len(), 1);
-        assert_eq!(bundle.senders()[0], alice.address());
+        let bundle_txs: BundleTransactions = bundle.bundle().txs.clone().into();
+        assert_eq!(bundle_txs.txn_hashes().unwrap().len(), 1);
+        assert_eq!(bundle_txs.txn_hashes().unwrap()[0], tx1.tx_hash());
+        assert_eq!(bundle_txs.senders().unwrap().len(), 1);
+        assert_eq!(bundle_txs.senders().unwrap()[0], alice.address());
 
         // Bundle hashes are keccack256(...txnHashes)
         let expected_bundle_hash_single = {
@@ -255,7 +262,7 @@ mod tests {
             hasher.finalize()
         };
 
-        assert_eq!(bundle.bundle_hash(), expected_bundle_hash_single);
+        assert_eq!(bundle_txs.bundle_hash(), expected_bundle_hash_single);
 
         let uuid = Uuid::new_v4();
         let bundle = BundleWithMetadata::load(
@@ -271,12 +278,13 @@ mod tests {
 
         assert_eq!(*bundle.uuid(), uuid);
         assert_eq!(bundle.bundle.replacement_uuid, Some(uuid.to_string()));
-        assert_eq!(bundle.txn_hashes().len(), 2);
-        assert_eq!(bundle.txn_hashes()[0], tx1.tx_hash());
-        assert_eq!(bundle.txn_hashes()[1], tx2.tx_hash());
-        assert_eq!(bundle.senders().len(), 2);
-        assert_eq!(bundle.senders()[0], alice.address());
-        assert_eq!(bundle.senders()[1], alice.address());
+        let bundle_txs2: BundleTransactions = bundle.bundle().txs.clone().into();
+        assert_eq!(bundle_txs2.txn_hashes().unwrap().len(), 2);
+        assert_eq!(bundle_txs2.txn_hashes().unwrap()[0], tx1.tx_hash());
+        assert_eq!(bundle_txs2.txn_hashes().unwrap()[1], tx2.tx_hash());
+        assert_eq!(bundle_txs2.senders().unwrap().len(), 2);
+        assert_eq!(bundle_txs2.senders().unwrap()[0], alice.address());
+        assert_eq!(bundle_txs2.senders().unwrap()[1], alice.address());
 
         let expected_bundle_hash_double = {
             let mut hasher = Keccak256::default();
@@ -285,7 +293,7 @@ mod tests {
             hasher.finalize()
         };
 
-        assert_eq!(bundle.bundle_hash(), expected_bundle_hash_double);
+        assert_eq!(bundle_txs2.bundle_hash(), expected_bundle_hash_double);
     }
 
     #[test]
diff --git a/crates/ingress-rpc/src/queue.rs b/crates/ingress-rpc/src/queue.rs
@@ -76,7 +76,8 @@ mod tests {
     use super::*;
     use rdkafka::config::ClientConfig;
     use tips_core::{
-        Bundle, BundleProperties, BundleWithMetadata, test_utils::create_test_meter_bundle_response,
+        Bundle, BundleTransactions, BundleWithMetadata,
+        test_utils::create_test_meter_bundle_response,
     };
     use tokio::time::{Duration, Instant};
 
@@ -97,7 +98,8 @@ mod tests {
         let bundle = create_test_bundle();
         let bundle_with_metadata =
             BundleWithMetadata::load(bundle.clone(), create_test_meter_bundle_response()).unwrap();
-        let bundle_hash = bundle_with_metadata.bundle_hash();
+        let bundle_txs: BundleTransactions = bundle.txs.into();
+        let bundle_hash = bundle_txs.bundle_hash();
 
         let start = Instant::now();
         let result = publisher.publish(&bundle_with_metadata, &bundle_hash).await;
diff --git a/crates/ingress-rpc/src/service.rs b/crates/ingress-rpc/src/service.rs
@@ -12,7 +12,7 @@ use reth_rpc_eth_types::EthApiError;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tips_audit::{BundleEvent, BundleEventPublisher};
 use tips_core::{
-    BLOCK_TIME, Bundle, BundleHash, BundleProperties, BundleWithMetadata, CancelBundle,
+    BLOCK_TIME, Bundle, BundleHash, BundleTransactions, BundleWithMetadata, CancelBundle,
     MeterBundleResponse,
 };
 use tracing::{info, warn};
@@ -73,7 +73,8 @@ where
         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();
+        let bundle_txs: BundleTransactions = bundle_with_metadata.bundle().txs.clone().into();
+        let bundle_hash = bundle_txs.bundle_hash();
         if let Err(e) = self
             .bundle_queue
             .publish(&bundle_with_metadata, &bundle_hash)
@@ -86,7 +87,6 @@ where
         info!(
             message = "queued bundle",
             bundle_hash = %bundle_hash,
-            tx_count = bundle_with_metadata.transactions().len(),
         );
 
         let audit_event = BundleEvent::Received {
@@ -125,9 +125,10 @@ where
         };
         let meter_bundle_response = self.meter_bundle(&bundle).await?;
 
-        let bundle_with_metadata = BundleWithMetadata::load(bundle, meter_bundle_response)
+        let bundle_with_metadata = BundleWithMetadata::load(bundle.clone(), meter_bundle_response)
             .map_err(|e| EthApiError::InvalidParams(e.to_string()).into_rpc_err())?;
-        let bundle_hash = bundle_with_metadata.bundle_hash();
+        let bundle_txs: BundleTransactions = bundle.txs.into();
+        let bundle_hash = bundle_txs.bundle_hash();
 
         if let Err(e) = self
             .bundle_queue
