perf(batcher): do not serialize to cbor on batch size calculation

Author: JuArce

crates/batcher/src/types/batch_queue.rs

@@ -3,7 +3,6 @@ use aligned_sdk::{
         constants::CBOR_ARRAY_MAX_OVERHEAD,
         types::{NoncedVerificationData, VerificationDataCommitment},
     },
-    communication::serialization::cbor_serialize,
 };
 use ethers::types::{Address, Signature, U256};
 use priority_queue::PriorityQueue;
@@ -124,14 +123,9 @@ pub(crate) type BatchQueue = PriorityQueue<BatchQueueEntry, BatchQueueEntryPrior
 /// Calculates the size of the batch represented by the given batch queue.
 pub(crate) fn calculate_batch_size(batch_queue: &BatchQueue) -> Result<usize, BatcherError> {
     let folded_result = batch_queue.iter().try_fold(0, |acc, (entry, _)| {
-        if let Ok(verification_data_bytes) =
-            cbor_serialize(&entry.nonced_verification_data.verification_data)
-        {
-            let current_batch_size = acc + verification_data_bytes.len();
-            ControlFlow::Continue(current_batch_size)
-        } else {
-            ControlFlow::Break(())
-        }
+        let verification_data_size = entry.nonced_verification_data.cbor_size_upper_bound();
+        let current_batch_size = acc + verification_data_size;
+        ControlFlow::Continue(current_batch_size)
     });
 
     if let ControlFlow::Continue(batch_size) = folded_result {
@@ -178,10 +172,7 @@ pub(crate) fn extract_batch_directly(
             let (rejected_entry, rejected_priority) = batch_queue.pop().unwrap();
 
             // Update batch size
-            let verification_data_size =
-                cbor_serialize(&rejected_entry.nonced_verification_data.verification_data)
-                    .unwrap()
-                    .len();
+            let verification_data_size = rejected_entry.nonced_verification_data.cbor_size_upper_bound();
             batch_size -= verification_data_size;
 
             rejected_entries.push((rejected_entry, rejected_priority));

crates/sdk/src/common/types.rs

@@ -72,6 +72,7 @@ pub struct VerificationData {
     pub proof_generator_addr: Address,
 }
 
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct NoncedVerificationData {
     pub verification_data: VerificationData,
@@ -97,6 +98,34 @@ impl NoncedVerificationData {
             payment_service_addr,
         }
     }
+
+    /// Returns an upper bound for the CBOR encoding size without performing serialization.
+    /// Sums the length of all Vec<u8> fields in the inner VerificationData and adds 256 bytes as overhead.
+    pub fn cbor_size_upper_bound(&self) -> usize {
+        const CBOR_OVERHEAD_BYTES: usize = 256;
+        let mut total_size = 0;
+        
+        // Add length of proof Vec<u8>
+        total_size += self.verification_data.proof.len();
+        
+        // Add length of pub_input Option<Vec<u8>>
+        if let Some(ref pub_input) = self.verification_data.pub_input {
+            total_size += pub_input.len();
+        }
+        
+        // Add length of verification_key Option<Vec<u8>>
+        if let Some(ref verification_key) = self.verification_data.verification_key {
+            total_size += verification_key.len();
+        }
+        
+        // Add length of vm_program_code Option<Vec<u8>>
+        if let Some(ref vm_program_code) = self.verification_data.vm_program_code {
+            total_size += vm_program_code.len();
+        }
+        
+        // Add overhead bytes for the full NoncedVerificationData structure
+        total_size + CBOR_OVERHEAD_BYTES
+    }
 }
 
 // Defines a price estimate type for the user.