works

Author: PatStiles

batcher/aligned-batcher/src/lib.rs

@@ -658,6 +658,7 @@ impl Batcher {
         if self.user_balance_is_unlocked(&addr).await {
             send_message(
                 ws_conn_sink.clone(),
+                // last_valid_nonce = client_msg.verification_data.nonce - 1. 
                 SubmitProofResponseMessage::InsufficientBalance(addr, nonced_verification_data.nonce),
             )
             .await;
@@ -750,7 +751,8 @@ impl Batcher {
             std::mem::drop(batch_state_lock);
             send_message(
                 ws_conn_sink.clone(),
-                SubmitProofResponseMessage::InsufficientBalance(addr, nonced_verification_data.nonce),
+                // last_valid_nonce = client_msg.verification_data.nonce - 1. 
+                SubmitProofResponseMessage::InsufficientBalance(addr, nonced_verification_data.nonce - 1),
             )
             .await;
             self.metrics.user_error(&["insufficient_balance", ""]);
@@ -1685,7 +1687,8 @@ impl Batcher {
             error!("Could not get balance for non-paying address {replacement_addr:?}");
             send_message(
                 ws_sink.clone(),
-                SubmitProofResponseMessage::InsufficientBalance(replacement_addr, client_msg.verification_data.nonce),
+                // last_valid_nonce = client_msg.verification_data.nonce - 1. 
+                SubmitProofResponseMessage::InsufficientBalance(replacement_addr, client_msg.verification_data.nonce - 1),
             )
             .await;
             return Ok(());
@@ -1695,7 +1698,8 @@ impl Batcher {
             error!("Insufficient funds for non-paying address {replacement_addr:?}");
             send_message(
                 ws_sink.clone(),
-                SubmitProofResponseMessage::InsufficientBalance(replacement_addr, client_msg.verification_data.nonce),
+                // last_valid_nonce = client_msg.verification_data.nonce - 1. 
+                SubmitProofResponseMessage::InsufficientBalance(replacement_addr, client_msg.verification_data.nonce - 1),
             )
             .await;
             return Ok(());

batcher/aligned-sdk/src/communication/messaging.rs

@@ -95,11 +95,14 @@ pub async fn send_messages(
 pub async fn receive(
     response_stream: Arc<Mutex<ResponseStream>>,
     mut sent_verification_data_rev: Vec<Result<NoncedVerificationData, SubmitError>>,
+    first_nonce: U256,
 ) -> Vec<Result<AlignedVerificationData, SubmitError>> {
     // Responses are filtered to only admit binary or close messages.
     let mut response_stream = response_stream.lock().await;
     let mut aligned_submitted_data: Vec<Result<AlignedVerificationData, SubmitError>> = Vec::new();
-    let mut last_proof_nonce = get_biggest_nonce(&sent_verification_data_rev);
+    let last_sent_proof_nonce = get_biggest_nonce(&sent_verification_data_rev);
+    let mut last_proof_nonce = last_sent_proof_nonce;
+    info!("last_sent_proof_nonce: {}", last_sent_proof_nonce);
 
     // read from WS
     while let Some(Ok(msg)) = response_stream.next().await {
@@ -123,18 +126,25 @@ pub async fn receive(
         let batch_inclusion_data_message = match handle_batcher_response(msg).await {
             Ok(data) => data,
             Err(e) => {
-                // In the case of an insufficient balance we still want to read and return the proofs.
+                warn!("Error while handling batcher response: {:?}", e);
+                // In the case of submitting multiple proofs we can have an multiple proofs be submitted but there 
+                // insufficient balance we still want to read and return the `batch_inclusion_data` of the proofs that were approved.
                 // `last_valid_nonce` corresponds to the nonce of the proof that triggered InsufficientBalance. 
                 // Therefore the other proofs are in order and we set the last_proof_nonce to the nonce of the InsufficientBalance.
                 if let SubmitError::InsufficientBalance(_, last_valid_nonce) = e {
                     aligned_submitted_data.push(Err(e));
-                    last_proof_nonce = last_valid_nonce - 1;
+                    // last_valid_nonce = last_nonce - 1. In the case 
+                    info!("last_proof_nonce: {}", last_proof_nonce);
+                    info!("last_valid_nonce: {}", last_valid_nonce);
+                    // In the case all proofs are insufficient balance we go over them.
+                    last_proof_nonce -= U256::from(1);
+                    if last_proof_nonce <= first_nonce {
+                        break;
+                    }
                     continue;
-                } else {
-                    warn!("Error while handling batcher response: {:?}", e);
-                    aligned_submitted_data.push(Err(e));
-                    break;
                 }
+                aligned_submitted_data.push(Err(e));
+                break;
             }
         };
 
@@ -168,6 +178,9 @@ pub async fn receive(
         aligned_submitted_data.push(Ok(aligned_verification_data));
         debug!("Message response handled successfully");
 
+        info!("last_proof_nonce: {}", last_proof_nonce);
+        info!("batch_inclusion_data_message.user_nonce: {}", batch_inclusion_data_message.user_nonce);
+
         if batch_inclusion_data_message.user_nonce == last_proof_nonce {
             break;
         }
@@ -314,4 +327,4 @@ fn get_biggest_nonce(
         }
     }
     biggest_nonce
-}
+}

batcher/aligned-sdk/src/sdk.rs

@@ -340,7 +340,7 @@ async fn _submit_multiple(
             nonce,
         )
         .await;
-        receive(response_stream, sent_verification_data_rev).await
+        receive(response_stream, sent_verification_data_rev, nonce).await
     }
     .await;
 

batcher/aligned/src/main.rs

@@ -392,8 +392,14 @@ async fn main() -> Result<(), AlignedError> {
                     }
                     Err(e) => {
                         warn!("Error while submitting proof: {:?}", e);
-                        handle_submit_err(e).await;
-                        return Ok(());
+                        handle_submit_err(&e).await;
+                        // In the case of an InsufficientBalance error we record and process the entire msg queue.
+                        // This covers the case of multiple submissions that succeed but fail for a comulative balance of all max_fee's.
+                        if let SubmitError::InsufficientBalance(_,_) = e {
+                            continue;
+                        } else {
+                            return Ok(());
+                        }
                     }
                 };
             }
@@ -601,7 +607,7 @@ fn verification_data_from_args(args: &SubmitArgs) -> Result<VerificationData, Su
     })
 }
 
-async fn handle_submit_err(err: SubmitError) {
+async fn handle_submit_err(err: &SubmitError) {
     match err {
         SubmitError::InvalidNonce => {
             error!("Invalid nonce. try again");