refactor: batcher errors

Author: MarcosNicolau

crates/batcher/src/lib.rs

@@ -203,7 +203,7 @@ impl BatchState {
     pub(crate) fn replacement_entry_is_valid(
         &mut self,
         replacement_entry: &BatchQueueEntry,
-    ) -> bool {
+    ) -> Result<(), (U256, U256)> {
         let replacement_max_fee = replacement_entry.nonced_verification_data.max_fee;
         let nonce = replacement_entry.nonced_verification_data.nonce;
         let sender = replacement_entry.sender;
@@ -214,11 +214,18 @@ impl BatchState {
         );
 
         // it is a valid entry only if there is no entry with the same sender, lower nonce and a lower fee
-        !self.batch_queue.iter().any(|(entry, _)| {
+        if let Some((entry, _)) = self.batch_queue.iter().find(|(entry, _)| {
             entry.sender == sender
                 && entry.nonced_verification_data.nonce < nonce
                 && entry.nonced_verification_data.max_fee < replacement_max_fee
-        })
+        }) {
+            Err((
+                entry.nonced_verification_data.nonce,
+                entry.nonced_verification_data.max_fee,
+            ))
+        } else {
+            Ok(())
+        }
     }
 
     /// Updates or removes a user's state when their latest proof entry is removed from the batch queue.

crates/batcher/src/types/batch_state.rs

@@ -504,7 +504,7 @@ async fn main() -> Result<(), AlignedError> {
                 PathBuf::from(&submit_args.batch_inclusion_data_directory_path);
 
             std::fs::create_dir_all(&batch_inclusion_data_directory_path).map_err(|e| {
-                SubmitError::IoError(batch_inclusion_data_directory_path.clone(), e)
+                SubmitError::IoError(batch_inclusion_data_directory_path.clone(), e.to_string())
             })?;
 
             let eth_rpc_url = submit_args.eth_rpc_url.clone();
@@ -542,22 +542,22 @@ async fn main() -> Result<(), AlignedError> {
             wallet = wallet.with_chain_id(chain_id);
 
             let nonce = match &submit_args.nonce {
-                Some(nonce) => U256::from_dec_str(nonce).map_err(|_| SubmitError::InvalidNonce)?,
+                Some(nonce) => U256::from_dec_str(nonce).expect("A valid nonce number"),
                 None => {
                     get_nonce_from_batcher(submit_args.network.clone().into(), wallet.address())
                         .await
                         .map_err(|e| match e {
                             aligned_sdk::common::errors::GetNonceError::EthRpcError(e) => {
-                                SubmitError::GetNonceError(e)
+                                SubmitError::EthereumProviderError(e)
                             }
                             aligned_sdk::common::errors::GetNonceError::ConnectionFailed(e) => {
-                                SubmitError::GenericError(e)
+                                SubmitError::WebSocketConnectionError(e)
                             }
                             aligned_sdk::common::errors::GetNonceError::InvalidRequest(e) => {
                                 SubmitError::GenericError(e)
                             }
                             aligned_sdk::common::errors::GetNonceError::SerializationError(e) => {
-                                SubmitError::GenericError(e)
+                                SubmitError::SerializationError(e)
                             }
                             aligned_sdk::common::errors::GetNonceError::ProtocolMismatch {
                                 current,
@@ -612,8 +612,7 @@ async fn main() -> Result<(), AlignedError> {
                             .insert(aligned_verification_data.batch_merkle_root);
                     }
                     Err(e) => {
-                        warn!("Error while submitting proof: {:?}", e);
-                        handle_submit_err(e).await;
+                        warn!("Error while submitting proof: {}", e);
                         return Ok(());
                     }
                 };
@@ -646,13 +645,16 @@ async fn main() -> Result<(), AlignedError> {
         VerifyProofOnchain(verify_inclusion_args) => {
             let batch_inclusion_file =
                 File::open(verify_inclusion_args.batch_inclusion_data.clone()).map_err(|e| {
-                    SubmitError::IoError(verify_inclusion_args.batch_inclusion_data.clone(), e)
+                    SubmitError::IoError(
+                        verify_inclusion_args.batch_inclusion_data.clone(),
+                        e.to_string(),
+                    )
                 })?;
 
             let reader = BufReader::new(batch_inclusion_file);
 
-            let aligned_verification_data: AlignedVerificationData =
-                cbor_deserialize(reader).map_err(SubmitError::SerializationError)?;
+            let aligned_verification_data: AlignedVerificationData = cbor_deserialize(reader)
+                .map_err(|e| SubmitError::SerializationError(e.to_string()))?;
 
             info!("Verifying response data matches sent proof data...");
             let response = verification_layer::is_proof_verified(
@@ -677,10 +679,10 @@ async fn main() -> Result<(), AlignedError> {
             info!("Commitment: {}", hex::encode(vk_commitment));
             if let Some(output_file) = args.output_file {
                 let mut file = File::create(output_file.clone())
-                    .map_err(|e| SubmitError::IoError(output_file.clone(), e))?;
+                    .map_err(|e| SubmitError::IoError(output_file.clone(), e.to_string()))?;
 
                 file.write_all(hex::encode(vk_commitment).as_bytes())
-                    .map_err(|e| SubmitError::IoError(output_file.clone(), e))?;
+                    .map_err(|e| SubmitError::IoError(output_file.clone(), e.to_string()))?;
             }
         }
         DepositToBatcher(deposit_to_batcher_args) => {
@@ -940,27 +942,8 @@ fn verification_data_from_args(args: &SubmitArgs) -> Result<VerificationData, Su
     })
 }
 
-async fn handle_submit_err(err: SubmitError) {
-    match err {
-        SubmitError::InvalidNonce => {
-            error!("Invalid nonce. try again");
-        }
-        SubmitError::ProofQueueFlushed => {
-            error!("Batch was reset. try resubmitting the proof");
-        }
-        SubmitError::InvalidProof(reason) => error!("Submitted proof is invalid: {}", reason),
-        SubmitError::InsufficientBalance(sender_address) => {
-            error!(
-                "Insufficient balance to pay for the transaction, address: {}",
-                sender_address
-            )
-        }
-        _ => {}
-    }
-}
-
 fn read_file(file_name: PathBuf) -> Result<Vec<u8>, SubmitError> {
-    std::fs::read(&file_name).map_err(|e| SubmitError::IoError(file_name, e))
+    std::fs::read(&file_name).map_err(|e| SubmitError::IoError(file_name, e.to_string()))
 }
 
 fn read_file_option(param_name: &str, file_name: Option<PathBuf>) -> Result<Vec<u8>, SubmitError> {

crates/cli/src/main.rs

@@ -2,13 +2,12 @@ use core::fmt;
 use ethers::providers::ProviderError;
 use ethers::signers::WalletError;
 use ethers::types::transaction::eip712::Eip712Error;
-use ethers::types::{SignatureError, H160};
+use ethers::types::{SignatureError, H160, U256};
+use ethers::utils::format_ether;
 use serde::{Deserialize, Serialize};
+use std::fmt::Display;
 use std::io;
 use std::path::PathBuf;
-use tokio_tungstenite::tungstenite::protocol::CloseFrame;
-
-use crate::communication::serialization::SerializationError;
 
 use super::types::ProofInvalidReason;
 
@@ -63,12 +62,14 @@ impl fmt::Display for AlignedError {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum SubmitError {
-    WebSocketConnectionError(tokio_tungstenite::tungstenite::Error),
-    WebSocketClosedUnexpectedlyError(CloseFrame<'static>),
-    IoError(PathBuf, io::Error),
-    SerializationError(SerializationError),
+    // TODO: remove the GenericError and create an error for each case
+    GenericError(String),
+    WebSocketConnectionError(String),
+    WebSocketClosedUnexpectedlyError(String),
+    IoError(PathBuf, String),
+    SerializationError(String),
     EthereumProviderError(String),
     HexDecodingError(String),
     WalletSignerError(String),
@@ -82,33 +83,52 @@ pub enum SubmitError {
     UnexpectedBatcherResponse(String),
     EmptyVerificationDataCommitments,
     EmptyVerificationDataList,
-    InvalidNonce,
-    InvalidMaxFee,
+    InvalidNonce { sent: U256, expected: U256 },
+    InvalidMaxFee { sent: U256, required: U256 },
     ProofQueueFlushed,
     InvalidSignature,
     InvalidChainId,
     InvalidProof(ProofInvalidReason),
-    ProofTooLarge,
-    InvalidReplacementMessage,
-    InsufficientBalance(H160),
-    InvalidPaymentServiceAddress(H160, H160),
+    InvalidReplacementMessage(ReplacementInvalidReason),
+    InsufficientBalance { available: U256, required: U256 },
+    BalanceUnlocked,
+    InvalidPaymentServiceAddress { expected: H160, received: H160 },
     BatchSubmissionFailed(String),
-    AddToBatchError,
     InvalidProofInclusionData,
-    GetNonceError(String),
-    BatchQueueLimitExceededError,
-    GenericError(String),
+    BatchQueueLimitExceeded,
+    BatcherUnexpectedError,
 }
 
-impl From<tokio_tungstenite::tungstenite::Error> for SubmitError {
-    fn from(e: tokio_tungstenite::tungstenite::Error) -> Self {
-        SubmitError::WebSocketConnectionError(e)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum ReplacementInvalidReason {
+    EntryNotFound,
+    UnderpricedMaxFee { sent: U256, min_bump_required: U256 },
+    ReplacementConflictWithPendingEntry { nonce: U256, max_fee: U256 },
+}
+
+impl Display for ReplacementInvalidReason {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self {
+            Self::EntryNotFound => write!(f, "Entry not found in state"),
+            Self::UnderpricedMaxFee {
+                sent,
+                min_bump_required,
+            } => write!(
+                f,
+                "Max fee does not cover replacement, sent: {}ether, min bump required {}ether",
+                format_ether(*sent),
+                format_ether(*min_bump_required),
+            ),
+            Self::ReplacementConflictWithPendingEntry { nonce, max_fee } => {
+                write!(f, "Replacement rejected: a pending entry from the same sender exists with a lower nonce and higher max fee (nonce: {}, fee: {}).", nonce, format_ether(*max_fee))
+            }
+        }
     }
 }
 
-impl From<SerializationError> for SubmitError {
-    fn from(e: SerializationError) -> Self {
-        SubmitError::SerializationError(e)
+impl From<tokio_tungstenite::tungstenite::Error> for SubmitError {
+    fn from(e: tokio_tungstenite::tungstenite::Error) -> Self {
+        SubmitError::WebSocketConnectionError(e.to_string())
     }
 }
 
@@ -140,31 +160,82 @@ impl From<VerificationError> for SubmitError {
 impl fmt::Display for SubmitError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
+            // General System-level Errors
+            SubmitError::GenericError(e) => write!(f, "Generic error: {}", e),
             SubmitError::WebSocketConnectionError(e) => {
                 write!(f, "WebSocket connection error: {}", e)
             }
             SubmitError::WebSocketClosedUnexpectedlyError(close_frame) => {
                 write!(f, "WebSocket closed unexpectedly: {}", close_frame)
             }
+
+            // Serialization Networking Errors
             SubmitError::IoError(path, e) => write!(f, "IO error: {}: {}", path.display(), e),
             SubmitError::SerializationError(e) => write!(f, "Serialization error: {}", e),
+
+            // Ethereum Cryptographic Errors
             SubmitError::EthereumProviderError(e) => write!(f, "Ethereum provider error: {}", e),
             SubmitError::HexDecodingError(e) => write!(f, "Hex decoding error: {}", e),
             SubmitError::WalletSignerError(e) => write!(f, "Wallet signer error: {}", e),
+            SubmitError::InvalidEthereumAddress(address) => {
+                write!(f, "Invalid Ethereum address: {}", address)
+            }
+            SubmitError::InvalidSignature => write!(f, "Invalid Signature"),
+            SubmitError::InvalidChainId => write!(f, "Invalid chain Id"),
+
+            // User Input Parameter Validation
             SubmitError::MissingRequiredParameter(param) => {
                 write!(f, "Missing required parameter: {}", param)
             }
             SubmitError::UnsupportedProvingSystem(proving_system) => {
                 write!(f, "Unsupported proving system: {}", proving_system)
             }
-            SubmitError::InvalidEthereumAddress(address) => {
-                write!(f, "Invalid Ethereum address: {}", address)
-            }
             SubmitError::ProtocolVersionMismatch { current, expected } => write!(
                 f,
                 "Protocol version mismatch: current={}, expected={}",
                 current, expected
             ),
+            SubmitError::InvalidNonce { sent, expected } => {
+                write!(f, "Invalid nonce, sent: {}, required: {}", sent, expected)
+            }
+            SubmitError::InvalidMaxFee { sent, required } => write!(
+                f,
+                "Invalid max fee, sent: {}ether, required: {}ether",
+                format_ether(*sent),
+                format_ether(*required)
+            ),
+            SubmitError::InsufficientBalance {
+                available,
+                required,
+            } => {
+                write!(
+                    f,
+                    "Insufficient balance, available: {}ether, required {}ether",
+                    format_ether(*available),
+                    format_ether(*required)
+                )
+            }
+            SubmitError::BalanceUnlocked => {
+                write!(f, "Balance is in batcher payment contract is unlocked")
+            }
+            SubmitError::InvalidProof(reason) => {
+                write!(f, "Invalid proof, reason: {}", reason)
+            }
+            SubmitError::InvalidReplacementMessage(reason) => {
+                write!(f, "Invalid replacement message, reason: {}", reason)
+            }
+            SubmitError::InvalidPaymentServiceAddress {
+                received: received_addr,
+                expected: expected_addr,
+            } => {
+                write!(
+                    f,
+                    "Invalid payment service address, received: {}, expected: {}",
+                    received_addr, expected_addr
+                )
+            }
+
+            // Batcher-related Errors
             SubmitError::BatchVerifiedEventStreamError(e) => {
                 write!(f, "Batch verified event stream error: {}", e)
             }
@@ -182,40 +253,27 @@ impl fmt::Display for SubmitError {
             SubmitError::EmptyVerificationDataCommitments => {
                 write!(f, "Verification data commitments are empty")
             }
-            SubmitError::EmptyVerificationDataList => write!(f, "Verification data list is empty"),
-            SubmitError::InvalidNonce => write!(f, "Invalid nonce"),
-            SubmitError::InvalidMaxFee => write!(f, "Invalid max fee"),
+            SubmitError::EmptyVerificationDataList => {
+                write!(f, "Verification data list is empty")
+            }
             SubmitError::BatchSubmissionFailed(merkle_root) => write!(
                 f,
                 "Could not create task with batch merkle root {}",
                 merkle_root
             ),
-            SubmitError::GenericError(e) => write!(f, "Generic error: {}", e),
-            SubmitError::InvalidSignature => write!(f, "Invalid Signature"),
-            SubmitError::InvalidChainId => write!(f, "Invalid chain Id"),
-            SubmitError::InvalidProof(reason) => write!(f, "Invalid proof {}", reason),
-            SubmitError::ProofTooLarge => write!(f, "Proof too Large"),
-            SubmitError::InvalidReplacementMessage => write!(f, "Invalid replacement message"),
-            SubmitError::InsufficientBalance(addr) => {
-                write!(f, "Insufficient balance, address: {}", addr)
+            SubmitError::ProofQueueFlushed => write!(f, "Batch reset"),
+            SubmitError::InvalidProofInclusionData => {
+                write!(f, "Batcher responded with invalid batch inclusion data. Can't verify your proof was correctly included in the batch.")
             }
-            SubmitError::InvalidPaymentServiceAddress(received_addr, expected_addr) => {
+            SubmitError::BatchQueueLimitExceeded => {
                 write!(
                     f,
-                    "Invalid payment service address, received: {}, expected: {}",
-                    received_addr, expected_addr
+                    "Error while adding entry to batch, queue limit exceeded."
                 )
             }
-            SubmitError::ProofQueueFlushed => write!(f, "Batch reset"),
-            SubmitError::AddToBatchError => write!(f, "Error while adding entry to batch"),
-            SubmitError::InvalidProofInclusionData => {
-                write!(f, "Batcher responded with invalid batch inclusion data. Can't verify your proof was correctly included in the batch.")
-            }
-            SubmitError::BatchQueueLimitExceededError => {
-                write!(f, "Error while adding entry to batch, queue limit exeeded.")
+            SubmitError::BatcherUnexpectedError => {
+                write!(f, "Batcher responded with an unexpected error")
             }
-
-            SubmitError::GetNonceError(e) => write!(f, "Error while getting nonce {}", e),
         }
     }
 }
@@ -338,13 +396,7 @@ pub enum BalanceError {
 #[derive(Debug)]
 pub enum FileError {
     IoError(PathBuf, io::Error),
-    SerializationError(SerializationError),
-}
-
-impl From<SerializationError> for FileError {
-    fn from(e: SerializationError) -> Self {
-        FileError::SerializationError(e)
-    }
+    SerializationError(String),
 }
 
 impl From<io::Error> for FileError {