Add remove from q logic

Author: Mechanix97

batcher/aligned-batcher/src/lib.rs

@@ -16,7 +16,7 @@ use tokio::time::{timeout, Instant};
 use types::batch_state::BatchState;
 use types::user_state::UserState;
 
-use batch_queue::{calculate_batch_size, try_push_to_queue};
+use batch_queue::{calculate_batch_size, get_lowest_priority_entry};
 use std::collections::HashMap;
 use std::env;
 use std::net::SocketAddr;
@@ -1049,19 +1049,36 @@ impl Batcher {
 
         let max_fee = verification_data.max_fee;
         let nonce = verification_data.nonce;
-        try_push_to_queue(
-            &mut batch_state_lock.batch_queue,
-            BatchQueueEntry::new(
-                verification_data,
-                verification_data_comm,
-                ws_conn_sink,
-                proof_submitter_sig,
-                proof_submitter_addr,
-            ),
-            BatchQueueEntryPriority::new(max_fee, nonce),
-            self.max_batch_byte_size,
-            self.max_batch_proof_qty,
-        )?;
+
+        let batch_queue_len = batch_state_lock.batch_queue.len();
+
+        let new_entry =  BatchQueueEntry::new(
+            verification_data,
+            verification_data_comm,
+            ws_conn_sink,
+            proof_submitter_sig,
+            proof_submitter_addr,
+            );
+        let new_entry_priority = BatchQueueEntryPriority::new(max_fee, nonce) ;
+
+        if  batch_queue_len + 1 > self.max_batch_proof_qty {
+            let (lowest_priority_entry, lowest_priority_entry_priority) = 
+                get_lowest_priority_entry(&batch_state_lock.batch_queue).unwrap();
+                
+            if lowest_priority_entry_priority <  new_entry_priority {
+                if batch_state_lock.batch_queue.remove(&lowest_priority_entry).is_none(){
+                    //err
+                }
+                
+                // todo send msg to the removed entry ws
+
+                batch_state_lock.batch_queue.push(new_entry, new_entry_priority);    
+            } else {
+                // can't accept the new proof
+            }
+        } else {
+            batch_state_lock.batch_queue.push(new_entry, new_entry_priority );
+        }
 
         // Update metrics
         let queue_len = batch_state_lock.batch_queue.len();

batcher/aligned-batcher/src/types/batch_queue.rs

@@ -212,29 +212,23 @@ fn calculate_fee_per_proof(batch_len: usize, gas_price: U256, constant_gas_cost:
     U256::from(gas_per_proof) * gas_price
 }
 
-pub(crate) fn try_push_to_queue(
-    batch_queue: &mut BatchQueue,
-    item: BatchQueueEntry,
-    priority: BatchQueueEntryPriority,
-    max_batch_byte_size: usize,
-    max_batch_proof_qty: usize,
-) -> Result<(), BatcherError> {
-    let queue_len = batch_queue.len();
-    let queue_size_bytes = calculate_batch_size(&batch_queue)?;
-    
-    let verification_data_bytes = 
-        cbor_serialize(&item.nonced_verification_data.verification_data)
-        .map_err(|e|{BatcherError::SerializationError(e.to_string())})?;
-    
-    if queue_len + 1 > max_batch_proof_qty ||
-    queue_size_bytes + verification_data_bytes.len() + CBOR_ARRAY_MAX_OVERHEAD > max_batch_byte_size
-    {
-        // do something
-    } else {
-        batch_queue.push(item, priority);
+pub(crate) fn get_lowest_priority_entry(batch_queue: &BatchQueue) -> Option<(BatchQueueEntry, BatchQueueEntryPriority)> {
+    let mut lowest_fee_entry: Option<(BatchQueueEntry, BatchQueueEntryPriority)> = None;
+
+    for (entry, priority) in batch_queue {
+        match &lowest_fee_entry {
+            Some((e, p)) => {
+                if *priority < *p {
+                    lowest_fee_entry = Some((e.clone(), p.clone()));
+                }
+            }
+            None => {
+                lowest_fee_entry = Some((entry.clone(), priority.clone()));
+            } 
+        }
     }
-
-    Ok(())
+    
+    lowest_fee_entry
 }
 
 #[cfg(test)]