refactor: consolidate ValidityResponseMessage into ResponseMessage

Author: uri-99

batcher/aligned-batcher/src/lib.rs

@@ -21,8 +21,7 @@ use aligned_sdk::core::constants::{
 };
 use aligned_sdk::core::types::{
     ClientMessage, NoncedVerificationData, ProofInvalidReason, ProvingSystemId, ResponseMessage,
-    ValidityResponseMessage, VerificationCommitmentBatch, VerificationData,
-    VerificationDataCommitment,
+    VerificationCommitmentBatch, VerificationData, VerificationDataCommitment,
 };
 
 use aws_sdk_s3::client::Client as S3Client;
@@ -371,7 +370,7 @@ impl Batcher {
             warn!("Received message with incorrect chain id: {msg_chain_id}");
             send_message(
                 ws_conn_sink.clone(),
-                ValidityResponseMessage::InvalidChainId,
+                ResponseMessage::InvalidChainId,
             )
             .await;
 
@@ -384,7 +383,7 @@ impl Batcher {
             warn!("Received message with incorrect payment service address: {msg_payment_service_addr}");
             send_message(
                 ws_conn_sink.clone(),
-                ValidityResponseMessage::InvalidPaymentServiceAddress(
+                ResponseMessage::InvalidPaymentServiceAddress(
                     msg_payment_service_addr,
                     self.payment_service.address(),
                 ),
@@ -399,7 +398,7 @@ impl Batcher {
             error!("Signature verification error");
             send_message(
                 ws_conn_sink.clone(),
-                ValidityResponseMessage::InvalidSignature,
+                ResponseMessage::InvalidSignature,
             )
             .await;
             return Ok(());
@@ -409,7 +408,7 @@ impl Batcher {
         let proof_size = client_msg.verification_data.verification_data.proof.len();
         if proof_size > self.max_proof_size {
             error!("Proof size exceeds the maximum allowed size.");
-            send_message(ws_conn_sink.clone(), ValidityResponseMessage::ProofTooLarge).await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::ProofTooLarge).await;
             return Ok(());
         }
 
@@ -428,7 +427,7 @@ impl Batcher {
                 );
                 send_message(
                     ws_conn_sink.clone(),
-                    ValidityResponseMessage::InvalidProof(ProofInvalidReason::DisabledVerifier(
+                    ResponseMessage::InvalidProof(ProofInvalidReason::DisabledVerifier(
                         verification_data.proving_system,
                     )),
                 )
@@ -440,7 +439,7 @@ impl Batcher {
                 error!("Invalid proof detected. Verification failed");
                 send_message(
                     ws_conn_sink.clone(),
-                    ValidityResponseMessage::InvalidProof(ProofInvalidReason::RejectedProof),
+                    ResponseMessage::InvalidProof(ProofInvalidReason::RejectedProof),
                 )
                 .await;
                 return Ok(());
@@ -461,7 +460,7 @@ impl Batcher {
         if self.user_balance_is_unlocked(&addr).await {
             send_message(
                 ws_conn_sink.clone(),
-                ValidityResponseMessage::InsufficientBalance(addr),
+                ResponseMessage::InsufficientBalance(addr),
             )
             .await;
             return Ok(());
@@ -471,7 +470,7 @@ impl Batcher {
         let max_fee = nonced_verification_data.max_fee;
         if max_fee < U256::from(MIN_FEE_PER_PROOF) {
             error!("The max fee signed in the message is less than the accepted minimum fee to be included in the batch.");
-            send_message(ws_conn_sink.clone(), ValidityResponseMessage::InvalidMaxFee).await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::InvalidMaxFee).await;
             return Ok(());
         }
 
@@ -494,7 +493,7 @@ impl Batcher {
                     error!(
                         "Failed to get user nonce from Ethereum for address {addr:?}. Error: {e:?}"
                     );
-                    send_message(ws_conn_sink.clone(), ValidityResponseMessage::InvalidNonce).await;
+                    send_message(ws_conn_sink.clone(), ResponseMessage::InvalidNonce).await;
                     return Ok(());
                 }
             };
@@ -512,7 +511,7 @@ impl Batcher {
 
         let Some(user_balance) = self.get_user_balance(&addr).await else {
             error!("Could not get balance for address {addr:?}");
-            send_message(ws_conn_sink.clone(), ValidityResponseMessage::EthRpcError).await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::EthRpcError).await;
             return Ok(());
         };
 
@@ -524,15 +523,15 @@ impl Batcher {
         let Some(proofs_in_batch) = batch_state_lock.get_user_proof_count(&addr).await else {
             error!("Failed to get user proof count: User not found in user states, but it should have been already inserted");
             std::mem::drop(batch_state_lock);
-            send_message(ws_conn_sink.clone(), ValidityResponseMessage::InvalidNonce).await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::InvalidNonce).await;
             return Ok(());
         };
 
         if !self.check_min_balance(proofs_in_batch + 1, user_balance) {
             std::mem::drop(batch_state_lock);
             send_message(
                 ws_conn_sink.clone(),
-                ValidityResponseMessage::InsufficientBalance(addr),
+                ResponseMessage::InsufficientBalance(addr),
             )
             .await;
             return Ok(());
@@ -542,14 +541,14 @@ impl Batcher {
         let Some(expected_nonce) = cached_user_nonce else {
             error!("Failed to get cached user nonce: User not found in user states, but it should have been already inserted");
             std::mem::drop(batch_state_lock);
-            send_message(ws_conn_sink.clone(), ValidityResponseMessage::InvalidNonce).await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::InvalidNonce).await;
             return Ok(());
         };
 
         if expected_nonce < msg_nonce {
             std::mem::drop(batch_state_lock);
             warn!("Invalid nonce for address {addr}, had nonce {expected_nonce:?} < {msg_nonce:?}");
-            send_message(ws_conn_sink.clone(), ValidityResponseMessage::InvalidNonce).await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::InvalidNonce).await;
             return Ok(());
         }
 
@@ -572,14 +571,14 @@ impl Batcher {
         let msg_max_fee = nonced_verification_data.max_fee;
         let Some(user_min_fee) = batch_state_lock.get_user_min_fee(&addr).await else {
             std::mem::drop(batch_state_lock);
-            send_message(ws_conn_sink.clone(), ValidityResponseMessage::InvalidNonce).await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::InvalidNonce).await;
             return Ok(());
         };
 
         if msg_max_fee > user_min_fee {
             std::mem::drop(batch_state_lock);
             warn!("Invalid max fee for address {addr}, had fee {user_min_fee:?} < {msg_max_fee:?}");
-            send_message(ws_conn_sink.clone(), ValidityResponseMessage::InvalidMaxFee).await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::InvalidMaxFee).await;
             return Ok(());
         }
 
@@ -598,12 +597,12 @@ impl Batcher {
             .await
         {
             error!("Error while adding entry to batch: {e:?}");
-            send_message(ws_conn_sink, ValidityResponseMessage::AddToBatchError).await;
+            send_message(ws_conn_sink, ResponseMessage::AddToBatchError).await;
             return Ok(());
         };
 
         info!("Verification data message handled");
-        send_message(ws_conn_sink, ValidityResponseMessage::Valid).await;
+        send_message(ws_conn_sink, ResponseMessage::Valid).await;
         Ok(())
     }
 
@@ -638,7 +637,7 @@ impl Batcher {
         let Some(entry) = batch_state_lock.get_entry(addr, nonce) else {
             std::mem::drop(batch_state_lock);
             warn!("Invalid nonce for address {addr}. Queue entry with nonce {nonce} not found");
-            send_message(ws_conn_sink.clone(), ValidityResponseMessage::InvalidNonce).await;
+            send_message(ws_conn_sink.clone(), ResponseMessage::InvalidNonce).await;
             return;
         };
 
@@ -648,7 +647,7 @@ impl Batcher {
             warn!("Invalid replacement message for address {addr}, had fee {original_max_fee:?} < {replacement_max_fee:?}");
             send_message(
                 ws_conn_sink.clone(),
-                ValidityResponseMessage::InvalidReplacementMessage,
+                ResponseMessage::InvalidReplacementMessage,
             )
             .await;
 
@@ -685,7 +684,7 @@ impl Batcher {
             warn!("Invalid replacement message");
             send_message(
                 ws_conn_sink.clone(),
-                ValidityResponseMessage::InvalidReplacementMessage,
+                ResponseMessage::InvalidReplacementMessage,
             )
             .await;
             return;
@@ -1201,7 +1200,7 @@ impl Batcher {
         info!("Handling nonpaying message");
         let Some(non_paying_config) = self.non_paying_config.as_ref() else {
             warn!("There isn't a non-paying configuration loaded. This message will be ignored");
-            send_message(ws_sink.clone(), ValidityResponseMessage::InvalidNonce).await;
+            send_message(ws_sink.clone(), ResponseMessage::InvalidNonce).await;
             return Ok(());
         };
 
@@ -1210,7 +1209,7 @@ impl Batcher {
             error!("Could not get balance for non-paying address {replacement_addr:?}");
             send_message(
                 ws_sink.clone(),
-                ValidityResponseMessage::InsufficientBalance(replacement_addr),
+                ResponseMessage::InsufficientBalance(replacement_addr),
             )
             .await;
             return Ok(());
@@ -1220,7 +1219,7 @@ impl Batcher {
             error!("Insufficient funds for non-paying address {replacement_addr:?}");
             send_message(
                 ws_sink.clone(),
-                ValidityResponseMessage::InsufficientBalance(replacement_addr),
+                ResponseMessage::InsufficientBalance(replacement_addr),
             )
             .await;
             return Ok(());
@@ -1231,7 +1230,7 @@ impl Batcher {
         else {
             std::mem::drop(batch_state_lock);
             error!("Nonce for non-paying address {replacement_addr:?} not found in cache.");
-            send_message(ws_sink.clone(), ValidityResponseMessage::EthRpcError).await;
+            send_message(ws_sink.clone(), ResponseMessage::EthRpcError).await;
             return Ok(());
         };
 
@@ -1263,12 +1262,12 @@ impl Batcher {
             .await
         {
             info!("Error while adding nonpaying address entry to batch: {e:?}");
-            send_message(ws_sink, ValidityResponseMessage::AddToBatchError).await;
+            send_message(ws_sink, ResponseMessage::AddToBatchError).await;
             return Ok(());
         };
 
         info!("Non-paying verification data message handled");
-        send_message(ws_sink, ValidityResponseMessage::Valid).await;
+        send_message(ws_sink, ResponseMessage::Valid).await;
         Ok(())
     }
 

batcher/aligned-sdk/src/core/types.rs

@@ -329,24 +329,6 @@ impl AlignedVerificationData {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum ValidityResponseMessage {
-    Valid,
-    InvalidNonce,
-    InvalidSignature,
-    InvalidChainId,
-    InvalidProof(ProofInvalidReason),
-    InvalidMaxFee,
-    InvalidReplacementMessage,
-    AddToBatchError,
-    ProofTooLarge,
-    InsufficientBalance(Address),
-    EthRpcError,
-    InvalidPaymentServiceAddress(Address, Address),
-    BatchInclusionData(BatchInclusionData),
-    CreateNewTaskError(String, String), //merkle-root, error
-
-}
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum ProofInvalidReason {
@@ -355,39 +337,6 @@ pub enum ProofInvalidReason {
     DisabledVerifier(ProvingSystemId),
 }
 
-impl Display for ValidityResponseMessage {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            ValidityResponseMessage::Valid => write!(f, "Valid"),
-            ValidityResponseMessage::InvalidNonce => write!(f, "Invalid nonce"),
-            ValidityResponseMessage::InvalidSignature => write!(f, "Invalid signature"),
-            ValidityResponseMessage::InvalidChainId => write!(f, "Invalid chain id"),
-            ValidityResponseMessage::InvalidProof(reason) => {
-                write!(f, "Invalid proof: {}", reason)
-            }
-            ValidityResponseMessage::InvalidMaxFee => write!(f, "Invalid max fee"),
-            ValidityResponseMessage::InvalidReplacementMessage => {
-                write!(f, "Invalid replacement message")
-            }
-            ValidityResponseMessage::AddToBatchError => write!(f, "Add to batch error"),
-            ValidityResponseMessage::ProofTooLarge => write!(f, "Proof too large"),
-            ValidityResponseMessage::InsufficientBalance(addr) => {
-                write!(f, "Insufficient balance for address {}", addr)
-            }
-            ValidityResponseMessage::EthRpcError => write!(f, "Eth RPC error"),
-            ValidityResponseMessage::InvalidPaymentServiceAddress(addr, expected) => {
-                write!(
-                    f,
-                    "Invalid payment service address: {}, expected: {}",
-                    addr, expected
-                )
-            }
-            ValidityResponseMessage::BatchInclusionData(data) => write!(f, "Received Batch inclusion data, this means the task was processed: {:?}", data),
-            ValidityResponseMessage::CreateNewTaskError(merkle_root, error) => write!(f, "Create new task error: merkle root: {}, error: {}", merkle_root, error)
-        }
-    }
-}
-
 impl Display for ProofInvalidReason {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
@@ -408,6 +357,16 @@ pub enum ResponseMessage {
     InvalidProof(ProofInvalidReason),
     BatchReset,
     Error(String),
+    InvalidNonce,
+    InvalidSignature,
+    ProofTooLarge,
+    InvalidMaxFee,
+    InsufficientBalance,
+    InvalidChainId,
+    InvalidReplacementMessage,
+    AddToBatchError,
+    EthRpcError,
+    InvalidPaymentServiceAddress(Address, Address)
 }
 
 #[derive(Debug, Clone, Copy)]