iwa 0.0.2__py3-none-any.whl → 0.0.11__py3-none-any.whl

iwa/core/chain/interface.py

@@ -1,5 +1,6 @@
 """ChainInterface class for blockchain interactions."""
 
+import threading
 import time
 from typing import Callable, Dict, Optional, Tuple, TypeVar, Union
 
@@ -45,6 +46,7 @@ class ChainInterface:
             )
 
         self._initial_block = 0
+        self._rotation_lock = threading.Lock()
         self._init_web3()
 
     @property
@@ -154,18 +156,6 @@ class ChainInterface:
         print("╚══════════════════════════════════════════════════╝")
         print("")
 
-    def _init_web3(self):
-        """Initialize Web3 with current RPC."""
-        rpc_url = self.chain.rpcs[self._current_rpc_index] if self.chain.rpcs else ""
-        raw_web3 = Web3(Web3.HTTPProvider(rpc_url, request_kwargs={"timeout": DEFAULT_RPC_TIMEOUT}))
-
-        # Use duck typing to check if current web3 is a RateLimitedWeb3 wrapper
-        # (isinstance check fails when RateLimitedWeb3 is mocked in tests)
-        if hasattr(self, "web3") and hasattr(self.web3, "set_backend"):
-            self.web3.set_backend(raw_web3)
-        else:
-            self.web3 = RateLimitedWeb3(raw_web3, self._rate_limiter, self)
-
     def _is_rate_limit_error(self, error: Exception) -> bool:
         """Check if error is a rate limit (429) error."""
         err_text = str(error).lower()
@@ -269,19 +259,36 @@ class ChainInterface:
 
     def rotate_rpc(self) -> bool:
         """Rotate to the next available RPC."""
-        if not self.chain.rpcs or len(self.chain.rpcs) <= 1:
-            return False
+        with self._rotation_lock:
+            if not self.chain.rpcs or len(self.chain.rpcs) <= 1:
+                return False
+
+            # Simple Round Robin rotation
+            self._current_rpc_index = (self._current_rpc_index + 1) % len(self.chain.rpcs)
+            # Internal call to _init_web3 already expects to be under lock if called from here,
+            # but _init_web3 itself doesn't have a lock. Let's make it consistent.
+            self._init_web3_under_lock()
+
+            logger.info(
+                f"Rotated RPC for {self.chain.name} to index {self._current_rpc_index}: {self.chain.rpcs[self._current_rpc_index]}"
+            )
+            return True
 
-        # Simple Round Robin rotation
-        # We don't check health here because the health check itself might consume rate limits
-        # or fail flakily. Better to just switch and try the operation.
-        self._current_rpc_index = (self._current_rpc_index + 1) % len(self.chain.rpcs)
-        self._init_web3()
+    def _init_web3(self):
+        """Initialize Web3 with current RPC (thread-safe)."""
+        with self._rotation_lock:
+            self._init_web3_under_lock()
 
-        logger.info(
-            f"Rotated RPC for {self.chain.name} to index {self._current_rpc_index}: {self.chain.rpcs[self._current_rpc_index]}"
-        )
-        return True
+    def _init_web3_under_lock(self):
+        """Internal non-thread-safe web3 initialization."""
+        rpc_url = self.chain.rpcs[self._current_rpc_index] if self.chain.rpcs else ""
+        raw_web3 = Web3(Web3.HTTPProvider(rpc_url, request_kwargs={"timeout": DEFAULT_RPC_TIMEOUT}))
+
+        # Use duck typing to check if current web3 is a RateLimitedWeb3 wrapper
+        if hasattr(self, "web3") and hasattr(self.web3, "set_backend"):
+            self.web3.set_backend(raw_web3)
+        else:
+            self.web3 = RateLimitedWeb3(raw_web3, self._rate_limiter, self)
 
     def check_rpc_health(self) -> bool:
         """Check if the current RPC is healthy."""
@@ -358,15 +365,29 @@ class ChainInterface:
         except Exception:
             return address[:6] + "..." + address[-4:]
 
-    def get_token_decimals(self, address: EthereumAddress) -> int:
-        """Get token decimals for an address."""
-        try:
-            from iwa.core.contracts.erc20 import ERC20Contract
+    def get_token_decimals(self, address: EthereumAddress, fallback_to_18: bool = True) -> Optional[int]:
+        """Get token decimals for an address.
 
-            erc20 = ERC20Contract(address, self.chain.name.lower())
-            return erc20.decimals if erc20.decimals is not None else 18
+        Args:
+            address: Token contract address.
+            fallback_to_18: If True, return 18 on error (default).
+                           If False, return None on error (useful for detecting NFTs).
+
+        Returns:
+            Decimals as int, or None if error and fallback_to_18 is False.
+
+        """
+        try:
+            # Call decimals() directly without with_retry to avoid error logging
+            contract = self.web3.eth.contract(
+                address=self.web3.to_checksum_address(address),
+                abi=[{"constant": True, "inputs": [], "name": "decimals", "outputs": [{"type": "uint8"}], "type": "function"}]
+            )
+            return contract.functions.decimals().call()
         except Exception:
-            return 18
+            if fallback_to_18:
+                return 18
+            return None
 
     def get_native_balance_wei(self, address: EthereumAddress):
         """Get the native balance in wei"""

iwa/core/chain/models.py

@@ -78,13 +78,11 @@ class Gnosis(SupportedChain):
         if not self.rpcs and secrets.gnosis_rpc:
             self.rpcs = secrets.gnosis_rpc.get_secret_value().split(",")
 
-        # Defensive: ensure no comma-separated strings in list
+        # Defensive: ensure no comma-separated strings and NO quotes in list
         new_rpcs = []
         for rpc in self.rpcs:
-            if "," in rpc:
-                new_rpcs.extend([r.strip() for r in rpc.split(",") if r.strip()])
-            else:
-                new_rpcs.append(rpc)
+            parts = [r.strip().strip("'\"") for r in rpc.split(",") if r.strip()]
+            new_rpcs.extend(parts)
         self.rpcs = new_rpcs
 
 
@@ -107,13 +105,11 @@ class Ethereum(SupportedChain):
         if not self.rpcs and secrets.ethereum_rpc:
             self.rpcs = secrets.ethereum_rpc.get_secret_value().split(",")
 
-        # Defensive: ensure no comma-separated strings in list
+        # Defensive: ensure no comma-separated strings and NO quotes in list
         new_rpcs = []
         for rpc in self.rpcs:
-            if "," in rpc:
-                new_rpcs.extend([r.strip() for r in rpc.split(",") if r.strip()])
-            else:
-                new_rpcs.append(rpc)
+            parts = [r.strip().strip("'\"") for r in rpc.split(",") if r.strip()]
+            new_rpcs.extend(parts)
         self.rpcs = new_rpcs
 
 
@@ -136,13 +132,11 @@ class Base(SupportedChain):
         if not self.rpcs and secrets.base_rpc:
             self.rpcs = secrets.base_rpc.get_secret_value().split(",")
 
-        # Defensive: ensure no comma-separated strings in list
+        # Defensive: ensure no comma-separated strings and NO quotes in list
         new_rpcs = []
         for rpc in self.rpcs:
-            if "," in rpc:
-                new_rpcs.extend([r.strip() for r in rpc.split(",") if r.strip()])
-            else:
-                new_rpcs.append(rpc)
+            parts = [r.strip().strip("'\"") for r in rpc.split(",") if r.strip()]
+            new_rpcs.extend(parts)
         self.rpcs = new_rpcs
 
 

iwa/core/contracts/contract.py

@@ -190,10 +190,16 @@ class ContractInstance:
             Exception: If the call fails, with decoded error information.
 
         """
-        method = getattr(self.contract.functions, method_name)
         try:
+
+            def do_call():
+                # Re-evaluate self.contract on each retry to get current provider
+                # This is critical for RPC rotation to work correctly
+                method = getattr(self.contract.functions, method_name)
+                return method(*args).call()
+
             return self.chain_interface.with_retry(
-                lambda: method(*args).call(),
+                do_call,
                 operation_name=f"call {method_name} on {self.name}",
             )
         except Exception as e:

iwa/core/pricing.py

@@ -9,17 +9,19 @@ from loguru import logger
 
 from iwa.core.secrets import secrets
 
+# Global cache shared across all PriceService instances
+_PRICE_CACHE: Dict[str, Dict] = {}
+_CACHE_TTL = timedelta(minutes=30)
+
 
 class PriceService:
     """Service to fetch token prices from CoinGecko."""
 
     BASE_URL = "https://api.coingecko.com/api/v3"
 
-    def __init__(self, cache_ttl_minutes: int = 5):
+    def __init__(self):
         """Initialize PriceService."""
         self.secrets = secrets
-        self.cache: Dict[str, Dict] = {}  # {id_currency: {"price": float, "timestamp": datetime}}
-        self.cache_ttl = timedelta(minutes=cache_ttl_minutes)
         self.api_key = (
             self.secrets.coingecko_api_key.get_secret_value()
             if self.secrets.coingecko_api_key
@@ -39,15 +41,15 @@ class PriceService:
         """
         cache_key = f"{token_id}_{vs_currency}"
 
-        # Check cache
-        if cache_key in self.cache:
-            entry = self.cache[cache_key]
-            if datetime.now() - entry["timestamp"] < self.cache_ttl:
+        # Check global cache
+        if cache_key in _PRICE_CACHE:
+            entry = _PRICE_CACHE[cache_key]
+            if datetime.now() - entry["timestamp"] < _CACHE_TTL:
                 return entry["price"]
 
         price = self._fetch_price_from_api(token_id, vs_currency)
         if price is not None:
-            self.cache[cache_key] = {"price": price, "timestamp": datetime.now()}
+            _PRICE_CACHE[cache_key] = {"price": price, "timestamp": datetime.now()}
         return price
 
     def _fetch_price_from_api(self, token_id: str, vs_currency: str) -> Optional[float]:

iwa/core/services/safe.py

@@ -11,7 +11,6 @@ from safe_eth.safe.safe_tx import SafeTx
 from iwa.core.constants import ZERO_ADDRESS
 from iwa.core.db import log_transaction
 from iwa.core.models import StoredSafeAccount
-from iwa.core.secrets import secrets
 from iwa.core.utils import (
     get_safe_master_copy_address,
     get_safe_proxy_factory_address,
@@ -99,8 +98,11 @@ class SafeService:
         return owner_addresses
 
     def _get_ethereum_client(self, chain_name: str) -> EthereumClient:
-        rpc_secret = getattr(secrets, f"{chain_name}_rpc")
-        return EthereumClient(rpc_secret.get_secret_value())
+        from iwa.core.chain import ChainInterfaces
+
+        # Use ChainInterface which has proper RPC rotation and parsing
+        chain_interface = ChainInterfaces().get(chain_name)
+        return EthereumClient(chain_interface.chain.rpc)
 
     def _deploy_safe_contract(
         self,
@@ -141,7 +143,7 @@ class SafeService:
                 gas=5_000_000,
                 gas_price=gas_price,
             )
-            return tx_sent.contract_address, tx_sent.tx_hash.hex()
+            return tx_sent.contract_address, f"0x{tx_sent.tx_hash.hex()}"
 
         else:
             # Standard random salt via Safe.create
@@ -153,7 +155,7 @@ class SafeService:
                 threshold=threshold,
                 proxy_factory_address=proxy_factory_address,
             )
-            return create_tx.contract_address, create_tx.tx_hash.hex()
+            return create_tx.contract_address, f"0x{create_tx.tx_hash.hex()}"
 
     def _log_safe_deployment(
         self,
@@ -248,8 +250,11 @@ class SafeService:
                 continue
 
             for chain in account.chains:
-                rpc_secret = getattr(secrets, f"{chain}_rpc")
-                ethereum_client = EthereumClient(rpc_secret.get_secret_value())
+                from iwa.core.chain import ChainInterfaces
+
+                # Use ChainInterface which has proper RPC rotation and parsing
+                chain_interface = ChainInterfaces().get(chain)
+                ethereum_client = EthereumClient(chain_interface.chain.rpc)
 
                 code = ethereum_client.w3.eth.get_code(account.address)
 
@@ -304,7 +309,7 @@ class SafeService:
             # Execute using the first signer
             safe_tx.execute(signer_keys[0])
 
-            return safe_tx.tx_hash.hex()
+            return f"0x{safe_tx.tx_hash.hex()}"
         finally:
             # SECURITY: Overwrite keys with zeros before clearing (best effort)
             for i in range(len(signer_keys)):

iwa/core/services/transaction.py

@@ -1,9 +1,10 @@
 """Transaction service module."""
 
 import time
-from typing import Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from loguru import logger
+from web3 import Web3
 from web3 import exceptions as web3_exceptions
 
 from iwa.core.chain import ChainInterfaces
@@ -11,6 +12,191 @@ from iwa.core.db import log_transaction
 from iwa.core.keys import KeyStorage
 from iwa.core.services.account import AccountService
 
+if TYPE_CHECKING:
+    from iwa.core.chain import ChainInterface
+
+# ERC20 Transfer event signature: Transfer(address indexed from, address indexed to, uint256 value)
+TRANSFER_EVENT_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
+
+
+class TransferLogger:
+    """Parse and log transfer events from transaction receipts."""
+
+    def __init__(
+        self,
+        account_service: AccountService,
+        chain_interface: "ChainInterface",
+    ):
+        """Initialize TransferLogger."""
+        self.account_service = account_service
+        self.chain_interface = chain_interface
+
+    def log_transfers(self, receipt: Dict, tx: Dict) -> None:
+        """Log all transfers (ERC20 and native) from a transaction receipt.
+
+        Args:
+            receipt: Transaction receipt containing logs.
+            tx: Original transaction dict.
+
+        """
+        # Log native value transfer if present
+        native_value = tx.get("value", 0)
+        if native_value and int(native_value) > 0:
+            self._log_native_transfer(tx, native_value)
+
+        # Log ERC20 transfers from event logs
+        logs = receipt.get("logs", [])
+        if hasattr(receipt, "logs"):
+            logs = receipt.logs
+
+        for log in logs:
+            self._process_log(log)
+
+    def _log_native_transfer(self, tx: Dict, value_wei: int) -> None:
+        """Log a native currency transfer."""
+        from_addr = tx.get("from", "")
+        to_addr = tx.get("to", "")
+
+        from_label = self._resolve_address_label(from_addr)
+        to_label = self._resolve_address_label(to_addr)
+
+        native_symbol = self.chain_interface.chain.native_currency
+        amount_eth = Web3.from_wei(value_wei, "ether")
+
+        logger.info(f"[TRANSFER] {amount_eth:.6g} {native_symbol}: {from_label} → {to_label}")
+
+    def _process_log(self, log) -> None:
+        """Process a single log entry for Transfer events."""
+        # Get topics - handle both dict and AttributeDict
+        topics = log.get("topics", []) if isinstance(log, dict) else getattr(log, "topics", [])
+
+        if not topics:
+            return
+
+        # Check if this is a Transfer event
+        first_topic = topics[0]
+        if isinstance(first_topic, bytes):
+            first_topic = "0x" + first_topic.hex()
+        elif hasattr(first_topic, "hex"):
+            first_topic = first_topic.hex()
+            if not first_topic.startswith("0x"):
+                first_topic = "0x" + first_topic
+
+        if first_topic.lower() != TRANSFER_EVENT_TOPIC.lower():
+            return
+
+        # Need at least 3 topics for indexed from/to
+        if len(topics) < 3:
+            return
+
+        try:
+            # Extract from/to from indexed topics (last 20 bytes of 32-byte topic)
+            from_topic = topics[1]
+            to_topic = topics[2]
+
+            from_addr = self._topic_to_address(from_topic)
+            to_addr = self._topic_to_address(to_topic)
+
+            # Extract amount from data
+            data = log.get("data", b"") if isinstance(log, dict) else getattr(log, "data", b"")
+            if isinstance(data, str):
+                data = bytes.fromhex(data.replace("0x", ""))
+
+            amount = int.from_bytes(data, "big") if data else 0
+
+            # Get token address
+            token_addr = (
+                log.get("address", "") if isinstance(log, dict) else getattr(log, "address", "")
+            )
+
+            self._log_erc20_transfer(token_addr, from_addr, to_addr, amount)
+
+        except Exception as e:
+            logger.debug(f"Failed to parse Transfer event: {e}")
+
+    def _topic_to_address(self, topic) -> str:
+        """Convert a 32-byte topic to a 20-byte address."""
+        if isinstance(topic, bytes):
+            # Last 20 bytes
+            addr_bytes = topic[-20:]
+            return Web3.to_checksum_address("0x" + addr_bytes.hex())
+        elif hasattr(topic, "hex"):
+            hex_str = topic.hex()
+            if not hex_str.startswith("0x"):
+                hex_str = "0x" + hex_str
+            # Last 40 chars (20 bytes)
+            return Web3.to_checksum_address("0x" + hex_str[-40:])
+        elif isinstance(topic, str):
+            if topic.startswith("0x"):
+                topic = topic[2:]
+            return Web3.to_checksum_address("0x" + topic[-40:])
+        return ""
+
+    def _log_erc20_transfer(
+        self, token_addr: str, from_addr: str, to_addr: str, amount_wei: int
+    ) -> None:
+        """Log an ERC20 transfer (or NFT transfer if detected)."""
+        from_label = self._resolve_address_label(from_addr)
+        to_label = self._resolve_address_label(to_addr)
+        token_label = self._resolve_token_label(token_addr)
+
+        # Try to get decimals - if None, it's an NFT (ERC721)
+        decimals = self.chain_interface.get_token_decimals(token_addr, fallback_to_18=False)
+
+        if decimals is not None:
+            amount = amount_wei / (10**decimals)
+            logger.info(f"[TRANSFER] {amount:.6g} {token_label}: {from_label} → {to_label}")
+        else:
+            # Likely an NFT (ERC721) - the amount is the token ID
+            if amount_wei > 0:
+                logger.info(f"[NFT TRANSFER] Token #{amount_wei} {token_label}: {from_label} → {to_label}")
+            else:
+                logger.debug(f"[NFT TRANSFER] {token_label}: {from_label} → {to_label}")
+
+    def _resolve_address_label(self, address: str) -> str:
+        """Resolve an address to a human-readable label.
+
+        Priority:
+        1. Known wallet tag (from wallets.json)
+        2. Known token name (it's a token contract)
+        3. Abbreviated address
+
+        """
+        if not address:
+            return "unknown"
+
+        # 1. Check known wallets
+        tag = self.account_service.get_tag_by_address(address)
+        if tag:
+            return tag
+
+        # 2. Check if it's a known token contract
+        token_name = self.chain_interface.chain.get_token_name(address)
+        if token_name:
+            return f"{token_name}_contract"
+
+        # 3. Fallback to abbreviated address
+        return f"{address[:6]}...{address[-4:]}"
+
+    def _resolve_token_label(self, token_addr: str) -> str:
+        """Resolve a token address to its symbol.
+
+        Priority:
+        1. Known token from chain config
+        2. Abbreviated address
+
+        """
+        if not token_addr:
+            return "UNKNOWN"
+
+        # Check known tokens
+        token_name = self.chain_interface.chain.get_token_name(token_addr)
+        if token_name:
+            return token_name
+
+        # Fallback to abbreviated address
+        return f"{token_addr[:6]}...{token_addr[-4:]}"
+
 
 class TransactionService:
     """Manages transaction lifecycle: signing, sending, retrying."""
@@ -30,7 +216,7 @@ class TransactionService:
         """Sign and send a transaction with retry logic for gas."""
         chain_interface = ChainInterfaces().get(chain_name)
         tx = dict(transaction)
-        max_retries = 3
+        max_retries = 10
 
         if not self._prepare_transaction(tx, signer_address_or_tag, chain_interface):
             return False, {}
@@ -39,7 +225,14 @@ class TransactionService:
             try:
                 signed_txn = self.key_storage.sign_transaction(tx, signer_address_or_tag)
                 txn_hash = chain_interface.web3.eth.send_raw_transaction(signed_txn.raw_transaction)
-                receipt = chain_interface.web3.eth.wait_for_transaction_receipt(txn_hash)
+
+                # Use chain_interface.with_retry for waiting for receipt to handle timeouts/RPC errors
+                def wait_for_receipt(tx_h=txn_hash):
+                    return chain_interface.web3.eth.wait_for_transaction_receipt(tx_h)
+
+                receipt = chain_interface.with_retry(
+                    wait_for_receipt, operation_name="wait_for_receipt"
+                )
 
                 if receipt and getattr(receipt, "status", None) == 1:
                     signer_account = self.account_service.resolve_account(signer_address_or_tag)
@@ -47,7 +240,7 @@ class TransactionService:
                     logger.info(f"Transaction sent successfully. Tx Hash: {txn_hash.hex()}")
 
                     self._log_successful_transaction(
-                        receipt, tx, signer_account, chain_name, txn_hash, tags
+                        receipt, tx, signer_account, chain_name, txn_hash, tags, chain_interface
                     )
                     return True, receipt
 
@@ -89,7 +282,9 @@ class TransactionService:
             )
             current_gas = int(tx.get("gas", 30_000))
             tx["gas"] = int(current_gas * 1.5)
-            time.sleep(0.5 * attempt)
+            tx["gas"] = int(current_gas * 1.5)
+            # Exponential backoff for gas errors
+            time.sleep(min(2**attempt, 30))
             return True
         logger.exception(f"Error sending transaction: {e}")
         return False
@@ -97,14 +292,18 @@ class TransactionService:
     def _handle_generic_error(self, e, chain_interface, attempt, max_retries) -> bool:
         if attempt < max_retries:
             logger.warning(f"Error encountered: {e}. Attempting to rotate RPC...")
+
             if chain_interface.rotate_rpc():
                 logger.info("Retrying with new RPC...")
-                time.sleep(0.5 * attempt)
+                # Exponential backoff
+                time.sleep(min(2**attempt, 30))
                 return True
         logger.exception(f"Unexpected error sending transaction: {e}")
         return False
 
-    def _log_successful_transaction(self, receipt, tx, signer_account, chain_name, txn_hash, tags):
+    def _log_successful_transaction(
+        self, receipt, tx, signer_account, chain_name, txn_hash, tags, chain_interface
+    ):
         try:
             gas_cost_wei, gas_value_eur = self._calculate_gas_cost(receipt, tx, chain_name)
             final_tags = self._determine_tags(tx, tags)
@@ -121,6 +320,11 @@ class TransactionService:
                 gas_value_eur=gas_value_eur,
                 tags=final_tags if final_tags else None,
             )
+
+            # Log transfer events (ERC20 and native value)
+            transfer_logger = TransferLogger(self.account_service, chain_interface)
+            transfer_logger.log_transfers(receipt, tx)
+
         except Exception as log_err:
             logger.warning(f"Failed to log transaction: {log_err}")
 

iwa/core/utils.py

@@ -38,24 +38,46 @@ def get_safe_proxy_factory_address(target_version: str = "1.4.1") -> str:
     raise ValueError(f"Did not find proxy factory for version {target_version}")
 
 
+def get_tx_hash(receipt: dict) -> str:
+    """Safely extract transaction hash from receipt (handles bytes/str/None)."""
+    if not receipt:
+        return "unknown"
+
+    tx_hash = receipt.get("transactionHash", "")
+    if hasattr(tx_hash, "hex"):
+        return tx_hash.hex()
+    return str(tx_hash) if tx_hash else "unknown"
+
+
 def configure_logger():
     """Configure the logger for the application."""
     if hasattr(configure_logger, "configured"):
         return logger
 
+    import logging
+
     from iwa.core.constants import DATA_DIR
 
+    # Silence noisy third-party loggers (these use stdlib logging, not loguru)
+    logging.getLogger("apscheduler.scheduler").setLevel(logging.WARNING)
+    logging.getLogger("apscheduler.executors.default").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+
     logger.remove()
 
     # Ensure data directory exists
     DATA_DIR.mkdir(parents=True, exist_ok=True)
 
+    import sys
+
     logger.add(
         DATA_DIR / "iwa.log",
         rotation="10 MB",
         level="INFO",
         format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}",
     )
+    # Restore console logging (stderr) so logs are visible in docker/systemd/frontend streams
+    logger.add(sys.stderr, level="INFO")
     # Also keep stderr for console if needed, but Textual captures it?
     # Textual usually captures stderr. Writing to file is safer for debugging.
     # Users previous logs show stdout format?

iwa/core/wallet.py

@@ -92,7 +92,8 @@ class Wallet:
                 return addr, t_name, 0.0
 
         # Use ThreadPoolExecutor for parallel balance fetching
-        with ThreadPoolExecutor(max_workers=20) as executor:
+        # Limited to 4 workers to avoid overwhelming RPC endpoints
+        with ThreadPoolExecutor(max_workers=4) as executor:
             tasks = []
             for addr in accounts_data.keys():
                 for t_name in token_names:

iwa/plugins/gnosis/safe.py

@@ -8,7 +8,6 @@ from safe_eth.safe import Safe, SafeOperationEnum
 from safe_eth.safe.safe_tx import SafeTx
 
 from iwa.core.models import StoredSafeAccount
-from iwa.core.secrets import secrets
 from iwa.core.utils import configure_logger
 
 logger = configure_logger()
@@ -28,8 +27,10 @@ class SafeMultisig:
         if chain_name.lower() not in normalized_chains:
             raise ValueError(f"Safe account is not deployed on chain: {chain_name}")
 
-        rpc_secret = getattr(secrets, f"{chain_name.lower()}_rpc")
-        ethereum_client = EthereumClient(rpc_secret.get_secret_value())
+        from iwa.core.chain import ChainInterfaces
+
+        chain_interface = ChainInterfaces().get(chain_name.lower())
+        ethereum_client = EthereumClient(chain_interface.chain.rpc)
         self.multisig = Safe(safe_account.address, ethereum_client)
         self.ethereum_client = ethereum_client