fix conflict

Author: diegomrsantos

.githooks/pre-commit

@@ -3,7 +3,7 @@ echo "Running cargo fmt --all..."
 cargo +nightly fmt --all || exit 1
 
 echo "Running cargo clippy --all..."
-#cargo clippy --all || exit 1
+cargo clippy --all || exit 1
 
 echo "Running cargo sort workspace..."
 cargo sort --workspace || exit 1

anchor/common/ssv_types/src/util.rs

@@ -18,12 +18,6 @@ pub enum RsaParseError {
     },
 }
 
-impl From<RsaParseError> for String {
-    fn from(error: RsaParseError) -> Self {
-        error.to_string()
-    }
-}
-
 // Parse from a RSA public key string into the associated RSA representation
 pub fn parse_rsa(pem_data: &str) -> Result<Rsa<Public>, RsaParseError> {
     // First decode the base64 data

anchor/eth/src/error.rs

@@ -1,5 +1,7 @@
 use thiserror::Error;
 
+use crate::util::ShareParseError;
+
 // Custom execution integration layer errors
 #[derive(Debug, Error)]
 pub enum ExecutionError {
@@ -59,6 +61,9 @@ pub enum ExecutionError {
 
     #[error("Database error: {0}")]
     Database(String),
+
+    #[error("Share parse error: {0}")]
+    ShareParseError(#[from] ShareParseError),
 }
 
 impl ExecutionError {

anchor/eth/src/event_processor.rs

@@ -1,17 +1,5 @@
 use std::sync::Arc;
 
-/// Simple wrapper to make String compatible with Error trait
-#[derive(Debug)]
-struct StringError(String);
-
-impl std::fmt::Display for StringError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl std::error::Error for StringError {}
-
 use alloy::{primitives::Address, rpc::types::Log, sol_types::SolEvent};
 use database::{NetworkDatabase, UniqueIndex};
 use eth2::types::PublicKeyBytes;
@@ -319,7 +307,7 @@ impl EventProcessor {
                 Some(validator_pubkey.to_string()),
                 Some(cluster_id),
                 "Failed to parse shares",
-                Some(Box::new(StringError(e))),
+                Some(Box::new(e)),
             )
         })?;
 
@@ -582,7 +570,7 @@ impl EventProcessor {
 
         let block_timestamp = log
             .block_timestamp
-            .ok_or_else(|| ExecutionError::InvalidEvent("Block timestamp not set".to_string()))?;
+            .ok_or_else(|| ExecutionError::invalid_event("Block timestamp not set", None))?;
 
         let validator_index = match self.get_validator_index(&validator_pubkey) {
             Ok(Some(value)) => value,

anchor/eth/src/sync.rs

@@ -130,7 +130,7 @@ impl SsvEventSyncer {
         exit_tx: ExitTx,
         config: Config,
     ) -> Result<Self, ExecutionError> {
-        info!("Creating new SSV Event Syncer");
+        debug!("Creating new SSV Event Syncer");
 
         // Construct the rpc provider
         let rpc_client = http_with_timeout_and_fallback(&config.http_urls);
@@ -576,9 +576,9 @@ impl SsvEventSyncer {
                 continue;
             }
 
-            let block_number = log.block_number.ok_or_else(|| {
-                ExecutionError::InvalidEvent("Block number not available".to_string())
-            })?;
+            let block_number = log
+                .block_number
+                .ok_or_else(|| ExecutionError::invalid_event("Block number not available", None))?;
 
             if let Some(timestamp) = block_timestamp_cache.get(&block_number) {
                 log.block_timestamp = Some(*timestamp);
@@ -595,7 +595,7 @@ impl SsvEventSyncer {
                         block
                     }
                     Ok(None) => {
-                        return Err(ExecutionError::InvalidEvent("Block not found".to_string()));
+                        return Err(ExecutionError::invalid_event("Block not found", None));
                     }
                     Err(e) => {
                         return Err(ExecutionError::RpcError(format!(

anchor/eth/src/util.rs

@@ -10,28 +10,30 @@ use database::NetworkState;
 use reqwest::Client;
 use sensitive_url::SensitiveUrl;
 use ssv_types::{ClusterId, ENCRYPTED_KEY_LENGTH, OperatorId, Share, ValidatorMetadata};
+use thiserror::Error;
 use tower::ServiceBuilder;
 use tracing::debug;
 use types::{Graffiti, PublicKeyBytes, Signature};
 
-use crate::{error::ExecutionError, sync::MAX_OPERATORS};
+use crate::{error::ExecutionError, sync::MAX_OPERATORS, util::ShareParseError::InvalidLength};
 
 // phase0.SignatureLength
 const SIGNATURE_LENGTH: usize = 96;
 // phase0.PublicKeyLength
 const PUBLIC_KEY_LENGTH: usize = 48;
 
-// Simple wrapper to make String compatible with Error trait
-#[derive(Debug)]
-struct StringError(String);
+/// Errors that can occur during share parsing
+#[derive(Error, Debug)]
+pub enum ShareParseError {
+    #[error("Share data has invalid length: expected {expected}, got {actual}")]
+    InvalidLength { expected: usize, actual: usize },
 
-impl std::fmt::Display for StringError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
+    #[error("Failed to create public key: {0}")]
+    PublicKeyCreation(String),
 
-impl std::error::Error for StringError {}
+    #[error("Encrypted key has wrong length")]
+    EncryptedKeyLength,
+}
 
 // Parses shares from a ValidatorAdded event
 // Event contains a bytes stream of the form
@@ -41,7 +43,7 @@ pub fn parse_shares(
     operator_ids: &[OperatorId],
     cluster_id: &ClusterId,
     validator_pubkey: &PublicKeyBytes,
-) -> Result<(Vec<u8>, Vec<Share>), String> {
+) -> Result<(Vec<u8>, Vec<Share>), ShareParseError> {
     let operator_count = operator_ids.len();
 
     // Calculate offsets for different components within the shares
@@ -51,11 +53,10 @@ pub fn parse_shares(
 
     // Validate total length of shares
     if shares_expected_length != shares.len() {
-        return Err(format!(
-            "Share data has invalid length: expected {}, got {}",
-            shares_expected_length,
-            shares.len()
-        ));
+        return Err(InvalidLength {
+            expected: shares_expected_length,
+            actual: shares.len(),
+        });
     }
 
     // Extract all of the components
@@ -78,12 +79,12 @@ pub fn parse_shares(
 
             // Create public key
             let share_pubkey = PublicKeyBytes::from_str(&public_key_hex)
-                .map_err(|e| format!("Failed to create public key: {e}"))?;
+                .map_err(ShareParseError::PublicKeyCreation)?;
 
             // Convert encrypted key into fixed array
             let encrypted_array: [u8; 256] = encrypted
                 .try_into()
-                .map_err(|_| "Encrypted key has wrong length".to_string())?;
+                .map_err(|_| ShareParseError::EncryptedKeyLength)?;
 
             Ok(Share {
                 validator_pubkey: *validator_pubkey,
@@ -93,7 +94,7 @@ pub fn parse_shares(
                 encrypted_private_key: encrypted_array,
             })
         })
-        .collect::<Result<Vec<_>, String>>()?;
+        .collect::<Result<Vec<_>, ShareParseError>>()?;
 
     Ok((signature, shares))
 }
@@ -216,18 +217,15 @@ pub fn validate_operators(
 }
 
 /// Helper function to parse validator public keys
-pub fn parse_validator_pubkey(pubkey: &Bytes) -> Result<PublicKeyBytes, ExecutionError> {
+pub fn parse_validator_pubkey(pubkey: &Bytes) -> Result<PublicKeyBytes, ShareParseError> {
     let pubkey_str = pubkey.to_string();
     PublicKeyBytes::from_str(&pubkey_str).map_err(|e| {
         debug!(
             validator_pubkey = %pubkey_str,
             error = %e,
             "Failed to parse validator public key"
         );
-        ExecutionError::invalid_event(
-            format!("Failed to parse validator public key: {e}"),
-            Some(Box::new(StringError(e.to_string()))),
-        )
+        ShareParseError::PublicKeyCreation(e)
     })
 }