refactor(verify-era-proof-attestation): modularize and restructure proof verification logic

- Split `verify-era-proof-attestation` into modular subcomponents for maintainability.
- Moved client, proof handling, and core types into dedicated modules.

bin/verify-era-proof-attestation/src/processor/one_shot_processor.rs

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2023-2025 Matter Labs
+
+//! One-shot batch processor for verifying a single batch or a range of batches
+
+use crate::error;
+use tokio::sync::watch;
+use zksync_basic_types::L1BatchNumber;
+
+use crate::{
+    core::{VerificationResult, VerifierConfig},
+    processor::BatchProcessor,
+};
+
+/// Processes a specific range of batches and then exits
+pub struct OneShotProcessor {
+    batch_processor: BatchProcessor,
+    start_batch: L1BatchNumber,
+    end_batch: L1BatchNumber,
+}
+
+impl OneShotProcessor {
+    /// Create a new one-shot processor for the given batch range
+    pub fn new(
+        config: VerifierConfig,
+        start_batch: L1BatchNumber,
+        end_batch: L1BatchNumber,
+    ) -> error::Result<Self> {
+        let batch_processor = BatchProcessor::new(config)?;
+
+        Ok(Self {
+            batch_processor,
+            start_batch,
+            end_batch,
+        })
+    }
+
+    /// Run the processor until completion or interruption
+    pub async fn run(
+        &self,
+        mut stop_receiver: watch::Receiver<bool>,
+    ) -> error::Result<Vec<(u32, VerificationResult)>> {
+        tracing::info!(
+            "Starting one-shot verification of batches {} to {}",
+            self.start_batch.0,
+            self.end_batch.0
+        );
+
+        let mut results = Vec::new();
+        let mut success_count = 0;
+        let mut failure_count = 0;
+
+        for batch_number in self.start_batch.0..=self.end_batch.0 {
+            let batch = L1BatchNumber(batch_number);
+            let result = self
+                .batch_processor
+                .process_batch(&mut stop_receiver, batch)
+                .await?;
+
+            match result {
+                VerificationResult::Success => success_count += 1,
+                VerificationResult::PartialSuccess { .. } => success_count += 1,
+                VerificationResult::Failure => failure_count += 1,
+                VerificationResult::Interrupted => {
+                    results.push((batch_number, result));
+                    break;
+                }
+                VerificationResult::NoProofsFound => {}
+            }
+
+            results.push((batch_number, result));
+        }
+
+        // Log overall results
+        BatchProcessor::log_overall_results(success_count, failure_count);
+
+        Ok(results)
+    }
+}