Add validation and update user_state

Author: Mechanix97

batcher/aligned-batcher/src/lib.rs

@@ -704,7 +704,7 @@ impl Batcher {
         // This is needed because we need to query the user state to make validations and
         // finally add the proof to the batch queue.
 
-        let batch_state_lock = self.batch_state.lock().await;
+        let mut batch_state_lock = self.batch_state.lock().await;
 
         let msg_max_fee = nonced_verification_data.max_fee;
         let Some(user_last_max_fee_limit) =
@@ -800,17 +800,38 @@ impl Batcher {
         // *        Perform validation over batcher queue                         *
         // * ---------------------------------------------------------------------*
 
-        // if max batch qty exceded, remove least priority element
         if batch_state_lock.batch_queue.len() == self.max_queue_size {
-            info!("Queue limit exceded, removing least priority element");
-
-            // if let Some(lowest_priority_entry) = batch_state_lock.batch_queue.pop() {
-            //     send_message(
-            //         lowest_priority_entry.0.messaging_sink.unwrap(),
-            //         SubmitProofResponseMessage::BatchQueueLimitExceededError,
-            //     )
-            //     .await;
-            // }
+            // Check if the new proof have more priority than the lowest pirority entry
+            if let Some((_, lowest_priority_entry_priority)) = batch_state_lock.batch_queue.peek() {
+                if *lowest_priority_entry_priority
+                    > BatchQueueEntryPriority::new(
+                        nonced_verification_data.max_fee,
+                        nonced_verification_data.nonce,
+                    )
+                {
+                    let (removed_entry, _) = batch_state_lock.batch_queue.pop().unwrap();
+                    info!(
+                        "Removing proof from entry. Sender {}, Nonce {}.",
+                        removed_entry.sender, removed_entry.nonced_verification_data.nonce
+                    );
+
+                    batch_state_lock.remove_entry_from_user_state(&removed_entry);
+                    send_message(
+                        removed_entry.messaging_sink.unwrap(),
+                        SubmitProofResponseMessage::BatchQueueLimitExceededError,
+                    )
+                    .await;
+                } else {
+                    // Can't add new entry with less priority to the batch queue
+                    info!("Can't add new entry, the batcher queue is full");
+                    send_message(
+                        ws_conn_sink.clone(),
+                        SubmitProofResponseMessage::BatchQueueLimitExceededError,
+                    )
+                    .await;
+                    return Ok(());
+                }
+            }
         }
 
         // * ---------------------------------------------------------------------*

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

@@ -6,6 +6,7 @@ use super::{
 };
 use ethers::types::{Address, U256};
 use log::debug;
+use log::{error, info, warn};
 
 pub(crate) struct BatchState {
     pub(crate) batch_queue: BatchQueue,
@@ -214,4 +215,40 @@ impl BatchState {
                 && entry.nonced_verification_data.max_fee < replacement_max_fee
         })
     }
+
+    // removes a proof from a user state
+    pub(crate) fn remove_entry_from_user_state(&mut self, entry: &BatchQueueEntry) {
+        let addr = entry.sender;
+
+        if entry.nonced_verification_data.nonce == U256::zero() {
+            self.user_states.remove(&addr);
+            return;
+        }
+        let nonce = entry.nonced_verification_data.nonce - U256::one();
+
+        match self
+            .batch_queue
+            .iter()
+            .map(|(e, _)| e)
+            .find(|e| e.sender == addr && e.nonced_verification_data.nonce == nonce)
+        {
+            Some(last_entry) => {
+                if let Entry::Occupied(mut user_state) = self.user_states.entry(addr) {
+                    user_state.get_mut().proofs_in_batch -= 1;
+                    user_state.get_mut().nonce -= U256::one();
+                    user_state.get_mut().total_fees_in_queue -= U256::one();
+                    user_state.get_mut().last_max_fee_limit =
+                        last_entry.nonced_verification_data.max_fee;
+                }
+            }
+            None => {
+                if let Entry::Occupied(mut user_state) = self.user_states.entry(addr) {
+                    user_state.get_mut().proofs_in_batch = 0;
+                    user_state.get_mut().nonce -= U256::one();
+                    user_state.get_mut().total_fees_in_queue = U256::zero();
+                    user_state.get_mut().last_max_fee_limit = U256::max_value();
+                }
+            }
+        }
+    }
 }