iwa 0.0.32__py3-none-any.whl → 0.0.58__py3-none-any.whl

iwa/core/pricing.py

@@ -28,6 +28,27 @@ class PriceService:
             if self.secrets.coingecko_api_key
             else None
         )
+        self.session = requests.Session()
+        # Configure retry strategy
+        from requests.adapters import HTTPAdapter
+        from urllib3.util.retry import Retry
+
+        retry_strategy = Retry(
+            total=3,
+            backoff_factor=1,
+            status_forcelist=[429, 500, 502, 503, 504],
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.session.mount("https://", adapter)
+        self.session.mount("http://", adapter)
+
+    def close(self):
+        """Close the session."""
+        self.session.close()
+
+    def __del__(self):
+        """Cleanup on deletion."""
+        self.close()
 
     def get_token_price(self, token_id: str, vs_currency: str = "eur") -> Optional[float]:
         """Get token price in specified currency.
@@ -66,7 +87,8 @@ class PriceService:
                 if self.api_key:
                     headers["x-cg-demo-api-key"] = self.api_key
 
-                response = requests.get(url, params=params, headers=headers, timeout=10)
+                # Use session instead of direct requests
+                response = self.session.get(url, params=params, headers=headers, timeout=10)
 
                 if response.status_code == 401 and self.api_key:
                     logger.warning("CoinGecko API key invalid (401). Retrying without key...")
@@ -74,7 +96,7 @@ class PriceService:
                     headers.pop("x-cg-demo-api-key", None)
                     # Re-run with base URL
                     url = f"{self.BASE_URL}/simple/price"
-                    response = requests.get(url, params=params, headers=headers, timeout=10)
+                    response = self.session.get(url, params=params, headers=headers, timeout=10)
 
                 if response.status_code == 429:
                     logger.warning(

iwa/core/secrets.py

@@ -72,6 +72,33 @@ class Secrets(BaseSettings):
 
         return self
 
+    @model_validator(mode="after")
+    def strip_quotes_from_secrets(self) -> "Secrets":
+        """Strip leading/trailing quotes from SecretStr fields.
+
+        Docker env_file often preserves quotes (e.g. KEY="val" -> "val"),
+        which causes API authentication failures.
+        """
+        for field_name, field_value in self:
+            if isinstance(field_value, SecretStr):
+                raw_value = field_value.get_secret_value()
+                # Check for matching quotes at start and end
+                if len(raw_value) >= 2 and (
+                    (raw_value.startswith('"') and raw_value.endswith('"'))
+                    or (raw_value.startswith("'") and raw_value.endswith("'"))
+                ):
+                    clean_value = raw_value[1:-1]
+                    setattr(self, field_name, SecretStr(clean_value))
+            elif isinstance(field_value, str):
+                # Also strip quotes from plain string fields (like health_url)
+                if len(field_value) >= 2 and (
+                    (field_value.startswith('"') and field_value.endswith('"'))
+                    or (field_value.startswith("'") and field_value.endswith("'"))
+                ):
+                    clean_value = field_value[1:-1]
+                    setattr(self, field_name, clean_value)
+        return self
+
 
 # Global secrets instance
 secrets = Secrets()

iwa/core/services/account.py

@@ -20,7 +20,7 @@ class AccountService:
         self.key_storage = key_storage
 
     @property
-    def master_account(self) -> Optional[StoredSafeAccount]:
+    def master_account(self) -> Optional[Union["EncryptedAccount", StoredSafeAccount]]:
         """Get master account."""
         return self.key_storage.master_account
 

iwa/core/services/balance.py

@@ -1,9 +1,7 @@
 """Balance service module."""
 
-import time
 from typing import TYPE_CHECKING, Optional, Union
 
-from loguru import logger
 from web3.types import Wei
 
 from iwa.core.chain import ChainInterfaces
@@ -91,23 +89,3 @@ class BalanceService:
         contract = ERC20Contract(chain_name=chain_name, address=token_address)
         return contract.balance_of_wei(account.address)
 
-    def get_erc20_balance_with_retry(
-        self,
-        account_address: str,
-        token_address_or_name: str,
-        chain_name: str = "gnosis",
-        retries: int = 3,
-    ) -> Optional[float]:
-        """Fetch balance with retry logic."""
-        for attempt in range(retries):
-            try:
-                return self.get_erc20_balance_eth(
-                    account_address, token_address_or_name, chain_name
-                )
-            except Exception as e:
-                if attempt == retries - 1:
-                    logger.error(
-                        f"Failed to fetch balance for {token_address_or_name} after {retries} attempts: {e}"
-                    )
-                time.sleep(1)
-        return None

iwa/core/services/safe.py

@@ -222,25 +222,25 @@ class SafeService:
         threshold: int,
         tag: Optional[str],
     ) -> StoredSafeAccount:
-        # Check if already exists
-        accounts = self.key_storage.accounts
-        if contract_address in accounts and isinstance(
-            accounts[contract_address], StoredSafeAccount
-        ):
-            safe_account = accounts[contract_address]
-            if chain_name not in safe_account.chains:
-                safe_account.chains.append(chain_name)
-        else:
-            safe_account = StoredSafeAccount(
-                tag=tag or f"Safe {contract_address[:6]}",
-                address=contract_address,
-                chains=[chain_name],
-                threshold=threshold,
-                signers=owner_addresses,
-            )
-            accounts[contract_address] = safe_account
+        # Check if already exists (by address)
+        existing = self.key_storage.find_stored_account(contract_address)
+        if existing and isinstance(existing, StoredSafeAccount):
+            if chain_name not in existing.chains:
+                existing.chains.append(chain_name)
+            self.key_storage.save()
+            return existing
+
+        # Create new Safe account object
+        safe_account = StoredSafeAccount(
+            tag=tag or f"Safe {contract_address[:6]}",
+            address=contract_address,
+            chains=[chain_name],
+            threshold=threshold,
+            signers=owner_addresses,
+        )
 
-        self.key_storage.save()
+        # Register via centralized method (enforces tag uniqueness)
+        self.key_storage.register_account(safe_account)
         return safe_account
 
     def redeploy_safes(self):
@@ -290,30 +290,51 @@ class SafeService:
 
         return signer_pkeys
 
-    def _sign_and_execute_safe_tx(self, safe_tx: SafeTx, signer_keys: List[str]) -> str:
+    def _sign_and_execute_safe_tx(
+        self,
+        safe_tx: SafeTx,
+        signer_keys: List[str],
+        chain_name: str,
+        safe_address: str,
+    ) -> str:
         """Sign and execute a SafeTx internally (INTERNAL USE ONLY).
 
         This method handles the signing and execution of a Safe transaction,
         keeping private keys internal to SafeService.
 
+        Uses SafeTransactionExecutor for retry logic and gas handling.
+
         SECURITY: Keys are overwritten with zeros and cleared after use.
         """
+        from iwa.core.chain import ChainInterfaces
+        from iwa.core.services.safe_executor import SafeTransactionExecutor
+
         try:
-            # Sign with all available signers
+            # Sign with all available signers (local operation)
             for pk in signer_keys:
-                safe_tx.sign(pk)
+                if pk:
+                    safe_tx.sign(pk)
+
+            chain_interface = ChainInterfaces().get(chain_name)
+            executor = SafeTransactionExecutor(chain_interface)
 
-            # Verify the transaction will succeed
-            safe_tx.call()
+            success, tx_hash_or_error, receipt = executor.execute_with_retry(
+                safe_address=safe_address,
+                safe_tx=safe_tx,
+                signer_keys=signer_keys,
+                operation_name=f"safe_tx_{safe_address[:10]}",
+            )
 
-            # Execute using the first signer
-            safe_tx.execute(signer_keys[0])
+            if success:
+                return tx_hash_or_error
+            else:
+                raise ValueError(f"Safe transaction failed: {tx_hash_or_error}")
 
-            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)):
-                signer_keys[i] = "0" * len(signer_keys[i]) if signer_keys[i] else ""
+                if signer_keys[i]:
+                    signer_keys[i] = "0" * len(signer_keys[i])
             signer_keys.clear()
 
     def execute_safe_transaction(
@@ -358,17 +379,16 @@ class SafeService:
 
         # Get signer keys, execute, and immediately clear
         signer_keys = self._get_signer_keys(safe_account)
-        try:
-            tx_hash = self._sign_and_execute_safe_tx(safe_tx, signer_keys)
-            logger.info(f"Safe transaction executed. Tx Hash: {tx_hash}")
-            return tx_hash
-        finally:
-            # Clear keys from memory (best effort)
-            for i in range(len(signer_keys)):
-                signer_keys[i] = None
-            del signer_keys
+        tx_hash = self._sign_and_execute_safe_tx(
+            safe_tx=safe_tx,
+            signer_keys=signer_keys,
+            chain_name=chain_name,
+            safe_address=safe_account.address,
+        )
+        logger.info(f"Safe transaction executed. Tx Hash: {tx_hash}")
+        return tx_hash
 
-    def get_sign_and_execute_callback(self, safe_address_or_tag: str):
+    def get_sign_and_execute_callback(self, safe_address_or_tag: str, chain_name: str):
         """Get a callback function that signs and executes a SafeTx.
 
         This method returns a callback that can be passed to SafeMultisig.send_tx().
@@ -376,6 +396,7 @@ class SafeService:
 
         Args:
             safe_address_or_tag: The Safe account address or tag
+            chain_name: The chain name for context
 
         Returns:
             A callable that takes a SafeTx and returns the transaction hash
@@ -387,11 +408,11 @@ class SafeService:
 
         def _sign_and_execute(safe_tx: SafeTx) -> str:
             signer_keys = self._get_signer_keys(safe_account)
-            try:
-                return self._sign_and_execute_safe_tx(safe_tx, signer_keys)
-            finally:
-                for i in range(len(signer_keys)):
-                    signer_keys[i] = None
-                del signer_keys
+            return self._sign_and_execute_safe_tx(
+                safe_tx=safe_tx,
+                signer_keys=signer_keys,
+                chain_name=chain_name,
+                safe_address=safe_account.address,
+            )
 
         return _sign_and_execute

iwa/core/services/safe_executor.py

@@ -0,0 +1,316 @@
+"""Safe transaction executor with retry logic and gas handling."""
+
+import time
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
+
+from loguru import logger
+from safe_eth.eth import EthereumClient, TxSpeed
+from safe_eth.safe import Safe
+from safe_eth.safe.safe_tx import SafeTx
+
+from iwa.core.contracts.decoder import ErrorDecoder
+from iwa.core.models import Config
+
+if TYPE_CHECKING:
+    from iwa.core.chain import ChainInterface
+
+
+# Simple in-memory counters for debugging
+SAFE_TX_STATS = {
+    "total_attempts": 0,
+    "gas_retries": 0,
+    "nonce_retries": 0,
+    "rpc_rotations": 0,
+    "final_successes": 0,
+    "final_failures": 0,
+    "signature_errors": 0,
+}
+
+# Minimum signature length (65 bytes per signature for ECDSA)
+MIN_SIGNATURE_LENGTH = 65
+
+
+class SafeTransactionExecutor:
+    """Execute Safe transactions with retry, gas estimation, and RPC rotation."""
+
+    DEFAULT_MAX_RETRIES = 6
+    DEFAULT_RETRY_DELAY = 1.0
+    GAS_BUFFER_PERCENTAGE = 1.5  # 50% buffer
+    MAX_GAS_MULTIPLIER = 10  # Hard cap: never exceed 10x original estimate
+    DEFAULT_FALLBACK_GAS = 500_000  # Fallback when estimation fails
+
+    def __init__(
+        self,
+        chain_interface: "ChainInterface",
+        max_retries: Optional[int] = None,
+        gas_buffer: Optional[float] = None,
+    ):
+        """Initialize the executor."""
+        self.chain_interface = chain_interface
+
+        # Use centralized config with fallbacks
+        config = Config().core
+        self.max_retries = max_retries or config.safe_tx_max_retries
+        self.gas_buffer = gas_buffer or config.safe_tx_gas_buffer
+
+    def execute_with_retry(
+        self,
+        safe_address: str,
+        safe_tx: SafeTx,
+        signer_keys: List[str],
+        operation_name: str = "safe_tx",
+    ) -> Tuple[bool, str, Optional[Dict]]:
+        """Execute SafeTx with full retry mechanism.
+
+        Args:
+            safe_address: The address of the Safe.
+            safe_tx: The Safe transaction object.
+            signer_keys: List of private keys for signing.
+            operation_name: Name for logging purposes.
+
+        Returns:
+            Tuple of (success, tx_hash_or_error, receipt)
+
+        """
+        last_error = None
+        current_gas = safe_tx.safe_tx_gas
+        base_estimate = current_gas if current_gas > 0 else 0
+
+        for attempt in range(self.max_retries + 1):
+            SAFE_TX_STATS["total_attempts"] += 1
+            try:
+                # Prepare and execute attempt
+                tx_hash = self._execute_attempt(
+                    safe_address, safe_tx, signer_keys, operation_name, attempt, current_gas, base_estimate
+                )
+
+                # Check receipt
+                receipt = self.chain_interface.web3.eth.wait_for_transaction_receipt(tx_hash)
+                if self._check_receipt_status(receipt):
+                    SAFE_TX_STATS["final_successes"] += 1
+                    logger.info(f"[{operation_name}] Success on attempt {attempt + 1}. Tx Hash: {tx_hash}")
+                    return True, tx_hash, receipt
+
+                logger.error(f"[{operation_name}] Mined but failed (status 0) on attempt {attempt + 1}.")
+                raise ValueError("Transaction reverted on-chain")
+
+            except Exception as e:
+                updated_tx, should_retry = self._handle_execution_failure(
+                    e, safe_address, safe_tx, attempt, operation_name
+                )
+                last_error = e
+                if not should_retry:
+                    break
+
+                # Update gas/nonce for next loop if needed
+                safe_tx = updated_tx
+                # If gas error, gas is recalculated in next _execute_attempt via fresh estimation
+
+                delay = self.DEFAULT_RETRY_DELAY * (2**attempt)
+                time.sleep(delay)
+
+        return False, str(last_error), None
+
+    def _execute_attempt(
+        self, safe_address, safe_tx, signer_keys, operation_name, attempt, current_gas, base_estimate
+    ) -> str:
+        """Prepare client, estimate gas, simulate, and execute."""
+        # 1. (Re)Create Safe client
+        self._recreate_safe_client(safe_address)
+
+        # NOTE: We do NOT modify safe_tx_gas here because the transaction is already signed.
+        # The Safe tx hash includes safe_tx_gas, so changing it would invalidate all signatures.
+        # Gas estimation must happen BEFORE signing in SafeService.
+
+        # 2. Validate signatures exist before any operation
+        sig_len = len(safe_tx.signatures) if safe_tx.signatures else 0
+        if sig_len < MIN_SIGNATURE_LENGTH:
+            SAFE_TX_STATS["signature_errors"] += 1
+            raise ValueError(
+                f"No valid signatures on transaction (have {sig_len} bytes, need >= {MIN_SIGNATURE_LENGTH})"
+            )
+
+        # 3. Simulate locally
+        try:
+            safe_tx.call()
+        except Exception as e:
+            classification = self._classify_error(e)
+            # Signature errors (GS020, GS026) are not recoverable - fail immediately
+            if classification["is_signature_error"]:
+                SAFE_TX_STATS["signature_errors"] += 1
+                reason = self._decode_revert_reason(e)
+                logger.error(f"[{operation_name}] Signature error (not retryable): {reason or e}")
+                raise e
+            if classification["is_revert"] and not classification["is_nonce_error"]:
+                reason = self._decode_revert_reason(e)
+                logger.error(f"[{operation_name}] Simulation reverted: {reason or e}")
+                raise e
+            raise
+
+        # 4. Execute
+        # IMPORTANT: safe-eth-py's execute() method CLEARS signatures after execution.
+        # We must backup and restore them to support retries if something goes wrong (e.g. timeout after broadcast).
+        signatures_backup = safe_tx.signatures
+
+        try:
+            # Always pass the first signer key as the executor (gas payer).
+            # Note: This method does NOT re-sign the Safe hash if signatures are already present.
+            # Use EIP-1559 'FAST' to ensure adequate priority fee (fixes Gnosis FeeTooLow)
+            result = safe_tx.execute(signer_keys[0], eip1559_speed=TxSpeed.FAST)
+
+            # Handle both tuple return (tx_hash, tx) and bytes return
+            if isinstance(result, tuple):
+                tx_hash_bytes = result[0]
+            else:
+                tx_hash_bytes = result
+
+            # Handle both bytes and hex string returns
+            if isinstance(tx_hash_bytes, bytes):
+                return f"0x{tx_hash_bytes.hex()}"
+            elif isinstance(tx_hash_bytes, str):
+                return tx_hash_bytes if tx_hash_bytes.startswith("0x") else f"0x{tx_hash_bytes}"
+            else:
+                return str(tx_hash_bytes)
+
+        finally:
+            # Restore signatures for next attempt if needed
+            # (execute() clears them on lines 407-409 of safe_eth/safe/safe_tx.py)
+            if safe_tx.signatures != signatures_backup:
+                safe_tx.signatures = signatures_backup
+
+    def _check_receipt_status(self, receipt) -> bool:
+        """Check if receipt has successful status."""
+        status = getattr(receipt, "status", None)
+        if status is None and isinstance(receipt, dict):
+            status = receipt.get("status")
+        return status == 1
+
+    def _handle_execution_failure(
+        self, error: Exception, safe_address: str, safe_tx: SafeTx, attempt: int, operation_name: str
+    ) -> Tuple[SafeTx, bool]:
+        """Handle execution failure and determine next steps."""
+        classification = self._classify_error(error)
+
+        if attempt >= self.max_retries:
+            SAFE_TX_STATS["final_failures"] += 1
+            logger.error(f"[{operation_name}] Failed after {attempt + 1} attempts: {error}")
+            return safe_tx, False
+
+        strategy = "retry"
+        safe = self._recreate_safe_client(safe_address)
+
+        if classification["is_nonce_error"]:
+            strategy = "nonce refresh"
+            SAFE_TX_STATS["nonce_retries"] += 1
+            safe_tx = self._refresh_nonce(safe, safe_tx)
+        elif classification["is_rpc_error"]:
+            strategy = "RPC rotation"
+            SAFE_TX_STATS["rpc_rotations"] += 1
+            result = self.chain_interface._handle_rpc_error(error)
+            if not result["should_retry"]:
+                return safe_tx, False
+        elif classification["is_gas_error"]:
+            strategy = "gas increase"
+            # Gas increase handled in next attempt loop
+
+        self._log_retry(attempt + 1, error, strategy)
+        return safe_tx, True
+
+    def _estimate_safe_tx_gas(self, safe: Safe, safe_tx: SafeTx, base_estimate: int = 0) -> int:
+        """Estimate gas for a Safe transaction with buffer and hard cap."""
+        try:
+            # Use on-chain simulation via safe-eth-py
+            estimated = safe.estimate_tx_gas(safe_tx.to, safe_tx.value, safe_tx.data, safe_tx.operation)
+            with_buffer = int(estimated * self.gas_buffer)
+
+            # Apply x10 hard cap if we have a base estimate
+            if base_estimate > 0:
+                max_allowed = base_estimate * self.MAX_GAS_MULTIPLIER
+                if with_buffer > max_allowed:
+                    logger.warning(f"Gas {with_buffer} exceeds x10 cap, capping to {max_allowed}")
+                    return max_allowed
+
+            return with_buffer
+        except Exception as e:
+            logger.warning(f"Gas estimation failed, using fallback: {e}")
+            return self.DEFAULT_FALLBACK_GAS
+
+    def _recreate_safe_client(self, safe_address: str) -> Safe:
+        """Recreate Safe with current (possibly rotated) RPC."""
+        ethereum_client = EthereumClient(self.chain_interface.current_rpc)
+        return Safe(safe_address, ethereum_client)
+
+    def _is_nonce_error(self, error: Exception) -> bool:
+        """Check if error is due to Safe nonce conflict."""
+        error_text = str(error).lower()
+        # GS025 = Invalid nonce (NOT GS026 which is invalid signatures)
+        return any(x in error_text for x in [
+            "nonce", "gs025", "already executed", "duplicate"
+        ])
+
+    def _is_signature_error(self, error: Exception) -> bool:
+        """Check if error is due to invalid Safe signatures.
+
+        GS020 = Signatures data too short
+        GS021 = Invalid signature data pointer
+        GS024 = Invalid contract signature
+        GS026 = Invalid owner (signature from non-owner)
+        """
+        error_text = str(error).lower()
+        return any(x in error_text for x in [
+            "gs020", "gs021", "gs024", "gs026",
+            "invalid signatures", "signatures data too short"
+        ])
+
+    def _refresh_nonce(self, safe: Safe, safe_tx: SafeTx) -> SafeTx:
+        """Re-fetch nonce and rebuild transaction."""
+        current_nonce = safe.retrieve_nonce()
+        logger.info(f"Refreshing Safe nonce to {current_nonce}")
+        return safe.build_multisig_tx(
+            safe_tx.to,
+            safe_tx.value,
+            safe_tx.data,
+            safe_tx.operation,
+            safe_tx_gas=safe_tx.safe_tx_gas,
+            base_gas=safe_tx.base_gas,
+            gas_price=safe_tx.gas_price,
+            gas_token=safe_tx.gas_token,
+            refund_receiver=safe_tx.refund_receiver,
+            # Note: signatures are NOT copied - tx hash changes with new nonce
+            safe_nonce=current_nonce,
+        )
+
+    def _classify_error(self, error: Exception) -> dict:
+        """Classify Safe transaction errors for retry decisions."""
+        err_text = str(error).lower()
+        is_rpc = self.chain_interface._is_rate_limit_error(error) or self.chain_interface._is_connection_error(error)
+
+        return {
+            "is_gas_error": any(x in err_text for x in ["gas", "out of gas", "intrinsic"]),
+            "is_nonce_error": self._is_nonce_error(error),
+            "is_rpc_error": is_rpc,
+            "is_revert": "revert" in err_text or "execution reverted" in err_text,
+            "is_signature_error": self._is_signature_error(error),
+        }
+
+    def _decode_revert_reason(self, error: Exception) -> Optional[str]:
+        """Attempt to decode the revert reason."""
+        import re
+        error_text = str(error)
+        hex_match = re.search(r"0x[0-9a-fA-F]{8,}", error_text)
+        if hex_match:
+            try:
+                data = hex_match.group(0)
+                decoded = ErrorDecoder().decode(data)
+                if decoded:
+                    name, msg, source = decoded[0]
+                    return f"{msg} (from {source})"
+            except Exception:
+                pass
+        return None
+
+    def _log_retry(self, attempt: int, error: Exception, strategy: str):
+        """Log a retry attempt."""
+        logger.warning(
+            f"Safe TX attempt {attempt} failed, strategy: {strategy}. Error: {error}"
+        )

iwa/core/services/transaction.py

@@ -320,6 +320,15 @@ class TransactionService:
 
         if "chainId" not in tx:
             tx["chainId"] = chain_interface.chain.chain_id
+
+        # Safety net: Ensure fees are set if missing (prevents FeeTooLow on Gnosis)
+        if "gasPrice" not in tx and "maxFeePerGas" not in tx:
+            try:
+                fees = chain_interface.get_suggested_fees()
+                tx.update(fees)
+            except Exception as e:
+                logger.debug(f"Failed to auto-fill fees in _prepare_transaction: {e}")
+
         return True
 
     def _handle_gas_retry(self, e: Exception, tx: dict, state: dict) -> None:
@@ -425,7 +434,8 @@ class TransactionService:
                 data=data
             )
 
-            # Wait for receipt
+            # Receipt is already waited for inside execute_safe_transaction/executor
+            # but we can fetch it again here to be safe and continue with Olas logging
             receipt = chain_interface.web3.eth.wait_for_transaction_receipt(tx_hash)
 
             status = getattr(receipt, "status", None)

iwa/core/services/transfer/erc20.py

@@ -57,11 +57,23 @@ class ERC20TransferMixin:
             chain_name=chain_name,
             data=transaction["data"],
         )
-        # Get receipt for gas calculation
+        # Get receipt for gas calculation with retry
         receipt = None
         try:
             interface = ChainInterfaces().get(chain_name)
-            receipt = interface.web3.eth.get_transaction_receipt(tx_hash)
+            import time
+
+            for _ in range(5):
+                try:
+                    receipt = interface.web3.eth.get_transaction_receipt(tx_hash)
+                    if receipt:
+                        break
+                except Exception:
+                    pass
+                time.sleep(2)
+
+            if not receipt:
+                logger.warning(f"Could not get receipt for Safe tx {tx_hash} after retries")
         except Exception as e:
             logger.warning(f"Could not get receipt for Safe tx {tx_hash}: {e}")