fix: improve error handling in available_senders with logging and deduplication

crates/wallets/src/wallet_signer.rs

@@ -9,7 +9,8 @@ use alloy_signer_local::{MnemonicBuilder, PrivateKeySigner, coins_bip39::English
 use alloy_signer_trezor::{HDPath as TrezorHDPath, TrezorSigner};
 use alloy_sol_types::{Eip712Domain, SolStruct};
 use async_trait::async_trait;
-use std::path::PathBuf;
+use std::{collections::HashSet, path::PathBuf};
+use tracing::warn;
 
 #[cfg(feature = "aws-kms")]
 use alloy_signer_aws::{AwsSigner, aws_config::BehaviorVersion, aws_sdk_kms::Client as AwsClient};
@@ -129,47 +130,61 @@ impl WalletSigner {
     /// - the result for Ledger signers includes addresses available for both LedgerLive and Legacy
     ///   derivation paths
     /// - for Local and AWS signers the result contains a single address
+    /// - errors when retrieving addresses are logged but do not prevent returning available
+    ///   addresses
     pub async fn available_senders(&self, max: usize) -> Result<Vec<Address>> {
-        let mut senders = Vec::new();
+        let mut senders = HashSet::new();
+
         match self {
             Self::Local(local) => {
-                senders.push(local.address());
+                senders.insert(local.address());
             }
             Self::Ledger(ledger) => {
+                // Try LedgerLive derivation path
                 for i in 0..max {
-                    if let Ok(address) =
-                        ledger.get_address_with_path(&LedgerHDPath::LedgerLive(i)).await
-                    {
-                        senders.push(address);
+                    match ledger.get_address_with_path(&LedgerHDPath::LedgerLive(i)).await {
+                        Ok(address) => {
+                            senders.insert(address);
+                        }
+                        Err(e) => {
+                            warn!("Failed to get Ledger address at index {i} (LedgerLive): {e}");
+                        }
                     }
                 }
+                // Try Legacy derivation path
                 for i in 0..max {
-                    if let Ok(address) =
-                        ledger.get_address_with_path(&LedgerHDPath::Legacy(i)).await
-                    {
-                        senders.push(address);
+                    match ledger.get_address_with_path(&LedgerHDPath::Legacy(i)).await {
+                        Ok(address) => {
+                            senders.insert(address);
+                        }
+                        Err(e) => {
+                            warn!("Failed to get Ledger address at index {i} (Legacy): {e}");
+                        }
                     }
                 }
             }
             Self::Trezor(trezor) => {
                 for i in 0..max {
-                    if let Ok(address) =
-                        trezor.get_address_with_path(&TrezorHDPath::TrezorLive(i)).await
-                    {
-                        senders.push(address);
+                    match trezor.get_address_with_path(&TrezorHDPath::TrezorLive(i)).await {
+                        Ok(address) => {
+                            senders.insert(address);
+                        }
+                        Err(e) => {
+                            warn!("Failed to get Trezor address at index {i} (TrezorLive): {e}",);
+                        }
                     }
                 }
             }
             #[cfg(feature = "aws-kms")]
             Self::Aws(aws) => {
-                senders.push(alloy_signer::Signer::address(aws));
+                senders.insert(alloy_signer::Signer::address(aws));
             }
             #[cfg(feature = "gcp-kms")]
             Self::Gcp(gcp) => {
-                senders.push(alloy_signer::Signer::address(gcp));
+                senders.insert(alloy_signer::Signer::address(gcp));
             }
         }
-        Ok(senders)
+        Ok(senders.into_iter().collect())
     }
 
     pub fn from_mnemonic(