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

iwa/core/pricing.py

@@ -4,9 +4,9 @@ import time
 from datetime import datetime, timedelta
 from typing import Dict, Optional
 
-import requests
 from loguru import logger
 
+from iwa.core.http import create_retry_session
 from iwa.core.secrets import secrets
 
 # Global cache shared across all PriceService instances
@@ -28,28 +28,12 @@ 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)
+        self.session = create_retry_session()
 
     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.
 
@@ -115,9 +99,7 @@ class PriceService:
                     return float(data[token_id][vs_currency])
 
                 # If we got response but price not found, it's likely a wrong ID
-                logger.debug(
-                    f"Price for {token_id} in {vs_currency} not found in response: {data}"
-                )
+                logger.debug(f"Price for {token_id} in {vs_currency} not found in response: {data}")
                 return None
 
             except Exception as e:

iwa/core/rpc_monitor.py

@@ -1,4 +1,5 @@
 """RPC Monitor for tracking API usage."""
+
 import threading
 from collections import defaultdict
 from typing import Dict

iwa/core/services/balance.py

@@ -88,4 +88,3 @@ class BalanceService:
 
         contract = ERC20Contract(chain_name=chain_name, address=token_address)
         return contract.balance_of_wei(account.address)
-

iwa/core/services/safe.py

@@ -1,6 +1,6 @@
 """Safe service module."""
 
-from typing import TYPE_CHECKING, List, Optional, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from loguru import logger
 from safe_eth.eth import EthereumClient
@@ -35,6 +35,7 @@ class SafeService:
         """Initialize SafeService."""
         self.key_storage = key_storage
         self.account_service = account_service
+        self._client_cache: Dict[str, EthereumClient] = {}
 
     def create_safe(
         self,
@@ -102,7 +103,12 @@ class SafeService:
 
         # Use ChainInterface which has proper RPC rotation and parsing
         chain_interface = ChainInterfaces().get(chain_name)
-        return EthereumClient(chain_interface.current_rpc)
+        rpc_url = chain_interface.current_rpc
+
+        if rpc_url not in self._client_cache:
+            self._client_cache[rpc_url] = EthereumClient(rpc_url)
+
+        return self._client_cache[rpc_url]
 
     def _deploy_safe_contract(
         self,

iwa/core/services/safe_executor.py

@@ -52,6 +52,7 @@ class SafeTransactionExecutor:
         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
+        self._client_cache: Dict[str, EthereumClient] = {}
 
     def execute_with_retry(
         self,
@@ -81,17 +82,27 @@ class SafeTransactionExecutor:
             try:
                 # Prepare and execute attempt
                 tx_hash = self._execute_attempt(
-                    safe_address, safe_tx, signer_keys, operation_name, attempt, current_gas, base_estimate
+                    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}")
+                    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}.")
+                logger.error(
+                    f"[{operation_name}] Mined but failed (status 0) on attempt {attempt + 1}."
+                )
                 raise ValueError("Transaction reverted on-chain")
 
             except Exception as e:
@@ -112,7 +123,14 @@ class SafeTransactionExecutor:
         return False, str(last_error), None
 
     def _execute_attempt(
-        self, safe_address, safe_tx, signer_keys, operation_name, attempt, current_gas, base_estimate
+        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
@@ -186,7 +204,12 @@ class SafeTransactionExecutor:
         return status == 1
 
     def _handle_execution_failure(
-        self, error: Exception, safe_address: str, safe_tx: SafeTx, attempt: int, operation_name: str
+        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)
@@ -220,7 +243,9 @@ class SafeTransactionExecutor:
         """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)
+            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
@@ -237,16 +262,17 @@ class SafeTransactionExecutor:
 
     def _recreate_safe_client(self, safe_address: str) -> Safe:
         """Recreate Safe with current (possibly rotated) RPC."""
-        ethereum_client = EthereumClient(self.chain_interface.current_rpc)
+        rpc_url = self.chain_interface.current_rpc
+        if rpc_url not in self._client_cache:
+            self._client_cache[rpc_url] = EthereumClient(rpc_url)
+        ethereum_client = self._client_cache[rpc_url]
         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"
-        ])
+        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.
@@ -257,10 +283,17 @@ class SafeTransactionExecutor:
         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"
-        ])
+        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."""
@@ -283,7 +316,9 @@ class SafeTransactionExecutor:
     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)
+        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"]),
@@ -296,6 +331,7 @@ class SafeTransactionExecutor:
     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:
@@ -311,6 +347,4 @@ class SafeTransactionExecutor:
 
     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}"
-        )
+        logger.warning(f"Safe TX attempt {attempt} failed, strategy: {strategy}. Error: {error}")

iwa/core/services/transaction.py

@@ -45,19 +45,29 @@ class TransferLogger:
         if tx_hash:
             try:
                 tx = self.chain_interface.web3.eth.get_transaction(tx_hash)
-                native_value = getattr(tx, "value", 0) or tx.get("value", 0) if isinstance(tx, dict) else getattr(tx, "value", 0)
+                native_value = (
+                    getattr(tx, "value", 0) or tx.get("value", 0)
+                    if isinstance(tx, dict)
+                    else getattr(tx, "value", 0)
+                )
                 if native_value and int(native_value) > 0:
-                    from_addr = getattr(tx, "from", "") if hasattr(tx, "from") else tx.get("from", "")
+                    from_addr = (
+                        getattr(tx, "from", "") if hasattr(tx, "from") else tx.get("from", "")
+                    )
                     # Handle AttributeDict's special 'from' attribute
                     if not from_addr and hasattr(tx, "__getitem__"):
                         from_addr = tx["from"]
-                    to_addr = getattr(tx, "to", "") or (tx.get("to", "") if isinstance(tx, dict) else "")
+                    to_addr = getattr(tx, "to", "") or (
+                        tx.get("to", "") if isinstance(tx, dict) else ""
+                    )
                     self._log_native_transfer(from_addr, to_addr, native_value)
             except Exception as e:
                 logger.debug(f"Could not get tx for native transfer logging: {e}")
 
         # Log ERC20 transfers from event logs
-        logs = receipt.get("logs", []) if isinstance(receipt, dict) else getattr(receipt, "logs", [])
+        logs = (
+            receipt.get("logs", []) if isinstance(receipt, dict) else getattr(receipt, "logs", [])
+        )
 
         for log in logs:
             self._process_log(log)
@@ -156,7 +166,9 @@ class TransferLogger:
         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}")
+                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}")
 
@@ -265,9 +277,7 @@ class TransactionService:
             """Inner operation wrapped by with_retry."""
             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
-                )
+                txn_hash = chain_interface.web3.eth.send_raw_transaction(signed_txn.raw_transaction)
                 receipt = chain_interface.web3.eth.wait_for_transaction_receipt(txn_hash)
 
                 status = getattr(receipt, "status", None)
@@ -412,10 +422,12 @@ class TransactionService:
         signer_account: StoredSafeAccount,
         chain_interface,
         chain_name: str,
-        tags: List[str] = None
+        tags: List[str] = None,
     ) -> Tuple[bool, Dict]:
         """Execute transaction via SafeService."""
-        logger.info(f"Routing transaction via Safe {self._resolve_label(signer_account.address, chain_name)}...")
+        logger.info(
+            f"Routing transaction via Safe {self._resolve_label(signer_account.address, chain_name)}..."
+        )
 
         try:
             # Extract basic params
@@ -431,7 +443,7 @@ class TransactionService:
                 to=to_addr,
                 value=value,
                 chain_name=chain_name,
-                data=data
+                data=data,
             )
 
             # Receipt is already waited for inside execute_safe_transaction/executor
@@ -445,7 +457,13 @@ class TransactionService:
             if receipt and status == 1:
                 logger.info(f"Safe transaction executed successfully. Tx Hash: {tx_hash}")
                 self._log_successful_transaction(
-                    receipt, tx, signer_account, chain_name, bytes.fromhex(tx_hash.replace("0x", "")), tags, chain_interface
+                    receipt,
+                    tx,
+                    signer_account,
+                    chain_name,
+                    bytes.fromhex(tx_hash.replace("0x", "")),
+                    tags,
+                    chain_interface,
                 )
                 return True, receipt
             else:
@@ -460,11 +478,13 @@ class TransactionService:
             # Extract hex data from common error patterns
             # Pattern 1: ('execution reverted', '0x...')
             import re
+
             hex_match = re.search(r"0x[0-9a-fA-F]{8,}", error_text)
 
             if hex_match:
                 try:
                     from iwa.core.contracts.decoder import ErrorDecoder
+
                     data = hex_match.group(0)
                     decoded = ErrorDecoder().decode(data)
                     if decoded:

iwa/core/services/transfer/erc20.py

@@ -14,7 +14,6 @@ if TYPE_CHECKING:
     from iwa.core.services.transfer import TransferService
 
 
-
 class ERC20TransferMixin:
     """Mixin for ERC20 token transfers and approvals."""
 

iwa/core/services/transfer/native.py

@@ -91,7 +91,7 @@ class NativeTransferMixin:
                 "from": from_account.address,
                 "to": to_address,
                 "value": amount_wei,
-            }
+            },
         )
 
         # Use unified TransactionService

iwa/core/tests/test_gnosis_fee.py

@@ -41,7 +41,9 @@ class TestGnosisFeeFix(unittest.TestCase):
 
         # CRITICAL ASSERTION: maxPriorityFeePerGas must be >= 1
         # If the fix works, it should be 1. If it fails (old behavior), it would be 0.
-        self.assertEqual(params["maxPriorityFeePerGas"], 1, "Priority fee should be forced to 1 wei")
+        self.assertEqual(
+            params["maxPriorityFeePerGas"], 1, "Priority fee should be forced to 1 wei"
+        )
 
         # Verify max fee calculation: (base * 1.5) + priority
         expected_max_fee = int(5000 * 1.5) + 1
@@ -84,4 +86,6 @@ class TestGnosisFeeFix(unittest.TestCase):
 
         params = eth_interface.calculate_transaction_params(mock_func, {"from": "0x123"})
 
-        self.assertEqual(params["maxPriorityFeePerGas"], 1, "Generic fallback should apply to all chains")
+        self.assertEqual(
+            params["maxPriorityFeePerGas"], 1, "Generic fallback should apply to all chains"
+        )

iwa/core/tests/test_ipfs.py

@@ -61,7 +61,7 @@ def test_push_to_ipfs_sync_uses_session(mock_config, mock_cid_decode):
 
         # Verify second call reuses session
         push_to_ipfs_sync(b"test data 2")
-        mock_session_cls.assert_called_once() # Should still be 1 call
+        mock_session_cls.assert_called_once()  # Should still be 1 call
         assert mock_session.post.call_count == 2
 
 

iwa/core/tests/test_regression_fixes.py

@@ -34,18 +34,14 @@ class TestRegressionFixes(unittest.TestCase):
         # This is what we are testing: get_suggested_fees() provides the safety net
         mock_chain_interface.get_suggested_fees.return_value = {
             "maxFeePerGas": 1500,
-            "maxPriorityFeePerGas": 10
+            "maxPriorityFeePerGas": 10,
         }
 
         with patch("iwa.core.services.transaction.ChainInterfaces") as mock_interfaces:
             mock_interfaces.return_value.get.return_value = mock_chain_interface
 
             # 3. Prepare transaction WITHOUT fees
-            tx = {
-                "to": "0x09312C66A14a024B4e903D986Ca7E2C0dDD06227",
-                "value": 1000,
-                "gas": 21000
-            }
+            tx = {"to": "0x09312C66A14a024B4e903D986Ca7E2C0dDD06227", "value": 1000, "gas": 21000}
 
             # 4. Run internal preparation
             service._prepare_transaction(tx, "signer", mock_chain_interface)
@@ -96,5 +92,6 @@ class TestRegressionFixes(unittest.TestCase):
                     self.assertIsInstance(accounts[key]["address"], str)
                     self.assertEqual(accounts[key]["address"].lower(), addr_str.lower())
 
+
 if __name__ == "__main__":
     unittest.main()

iwa/core/utils.py

@@ -85,9 +85,11 @@ def configure_logger():
     configure_logger.configured = True
     return logger
 
+
 def get_version(package_name: str) -> str:
     """Get package version."""
     from importlib.metadata import PackageNotFoundError, version
+
     try:
         return version(package_name)
     except PackageNotFoundError:

iwa/core/wallet.py

@@ -37,7 +37,9 @@ class Wallet:
         self.balance_service = BalanceService(self.key_storage, self.account_service)
         self.safe_service = SafeService(self.key_storage, self.account_service)
         # self.transaction_manager = TransactionManager(self.key_storage, self.account_service)
-        self.transaction_service = TransactionService(self.key_storage, self.account_service, self.safe_service)
+        self.transaction_service = TransactionService(
+            self.key_storage, self.account_service, self.safe_service
+        )
 
         self.transfer_service = TransferService(
             self.key_storage,

iwa/plugins/olas/constants.py

@@ -92,8 +92,12 @@ OLAS_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
 OLAS_TRADER_STAKING_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
     "gnosis": {
         # === LEGACY (no marketplace) ===
-        "Hobbyist 1 Legacy (100 OLAS)": EthereumAddress("0x389B46C259631Acd6a69Bde8B6cEe218230bAE8C"),
-        "Hobbyist 2 Legacy (500 OLAS)": EthereumAddress("0x238EB6993b90A978ec6AAD7530D6429c949C08DA"),
+        "Hobbyist 1 Legacy (100 OLAS)": EthereumAddress(
+            "0x389B46C259631Acd6a69Bde8B6cEe218230bAE8C"
+        ),
+        "Hobbyist 2 Legacy (500 OLAS)": EthereumAddress(
+            "0x238EB6993b90A978ec6AAD7530D6429c949C08DA"
+        ),
         "Expert Legacy (1k OLAS)": EthereumAddress("0x5344B7DD311e5d3DdDd46A4f71481Bd7b05AAA3e"),
         "Expert 2 Legacy (1k OLAS)": EthereumAddress("0xb964e44c126410df341ae04B13aB10A985fE3513"),
         "Expert 3 Legacy (2k OLAS)": EthereumAddress("0x80faD33Cadb5F53f9D29F02Db97D682E8B101618"),
@@ -103,9 +107,15 @@ OLAS_TRADER_STAKING_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
         "Expert 7 Legacy (10k OLAS)": EthereumAddress("0xD7A3C8b975f71030135f1a66E9e23164d54fF455"),
         "Expert 8 Legacy (2k OLAS)": EthereumAddress("0x356C108D49C5eebd21c84c04E9162de41933030c"),
         "Expert 9 Legacy (10k OLAS)": EthereumAddress("0x17dBAe44BC5618Cc254055B386A29576b4F87015"),
-        "Expert 10 Legacy (10k OLAS)": EthereumAddress("0xB0ef657b8302bd2c74B6E6D9B2b4b39145b19c6f"),
-        "Expert 11 Legacy (10k OLAS)": EthereumAddress("0x3112c1613eAC3dBAE3D4E38CeF023eb9E2C91CF7"),
-        "Expert 12 Legacy (10k OLAS)": EthereumAddress("0xF4a75F476801B3fBB2e7093aCDcc3576593Cc1fc"),
+        "Expert 10 Legacy (10k OLAS)": EthereumAddress(
+            "0xB0ef657b8302bd2c74B6E6D9B2b4b39145b19c6f"
+        ),
+        "Expert 11 Legacy (10k OLAS)": EthereumAddress(
+            "0x3112c1613eAC3dBAE3D4E38CeF023eb9E2C91CF7"
+        ),
+        "Expert 12 Legacy (10k OLAS)": EthereumAddress(
+            "0xF4a75F476801B3fBB2e7093aCDcc3576593Cc1fc"
+        ),
         # === MM v1 (old marketplace 0x4554fE75...) ===
         "Expert 15 MM v1 (10k OLAS)": EthereumAddress("0x88eB38FF79fBa8C19943C0e5Acfa67D5876AdCC1"),
         "Expert 16 MM v1 (10k OLAS)": EthereumAddress("0x6c65430515c70a3f5E62107CC301685B7D46f991"),

iwa/plugins/olas/contracts/activity_checker.py

@@ -48,7 +48,6 @@ class ActivityCheckerContract(ContractInstance):
         self._agent_mech: Optional[EthereumAddress] = None
         self._liveness_ratio: Optional[int] = None
 
-
     def get_multisig_nonces(self, multisig: EthereumAddress) -> Tuple[int, int]:
         """Get the nonces for a multisig address.
 
@@ -64,7 +63,6 @@ class ActivityCheckerContract(ContractInstance):
         nonces = self.contract.functions.getMultisigNonces(multisig).call()
         return (nonces[0], nonces[1])
 
-
     @property
     def mech_marketplace(self) -> Optional[EthereumAddress]:
         """Get the mech marketplace address."""
@@ -83,7 +81,9 @@ class ActivityCheckerContract(ContractInstance):
             try:
                 agent_mech_function = getattr(self.contract.functions, "agentMech", None)
                 self._agent_mech = (
-                    agent_mech_function().call() if agent_mech_function else DEFAULT_MECH_CONTRACT_ADDRESS
+                    agent_mech_function().call()
+                    if agent_mech_function
+                    else DEFAULT_MECH_CONTRACT_ADDRESS
                 )
             except Exception:
                 self._agent_mech = DEFAULT_MECH_CONTRACT_ADDRESS

iwa/plugins/olas/contracts/staking.py

@@ -82,7 +82,6 @@ class StakingContract(ContractInstance):
         self._activity_checker: Optional[ActivityCheckerContract] = None
         self._activity_checker_address: Optional[EthereumAddress] = None
 
-
     def get_requirements(self) -> Dict[str, Union[str, int]]:
         """Get the contract requirements for token and deposits.
 

iwa/plugins/olas/events.py

@@ -1,6 +1,5 @@
 """Event-based cache invalidation for Olas contracts."""
 
-
 from loguru import logger
 
 from iwa.core.contracts.cache import ContractCache
@@ -75,7 +74,7 @@ class OlasEventInvalidator:
             except Exception as e:
                 logger.error(f"Error in OlasEventInvalidator: {e}")
 
-            time.sleep(10) # check every 10 seconds
+            time.sleep(10)  # check every 10 seconds
 
     def _check_events(self, from_block: int, to_block: int):
         """Check for relevant events in the block range."""
@@ -101,14 +100,19 @@ class OlasEventInvalidator:
                 StakingContract, self.staking_addresses[0], self.chain_name
             )
 
-
-            logs = self.web3.eth.get_logs({
-                "fromBlock": from_block,
-                "toBlock": to_block,
-                "address": self.staking_addresses,
-                "topics": [self.web3.keccak(text="Checkpoint(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)").hex()]
-                # Note: signature might vary, safer to use the event object if ABI allows
-            })
+            logs = self.web3.eth.get_logs(
+                {
+                    "fromBlock": from_block,
+                    "toBlock": to_block,
+                    "address": self.staking_addresses,
+                    "topics": [
+                        self.web3.keccak(
+                            text="Checkpoint(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)"
+                        ).hex()
+                    ],
+                    # Note: signature might vary, safer to use the event object if ABI allows
+                }
+            )
 
             # If we used the contract event object to filter, it handles the topic generation:
             # logs = checkpoint_event_abi.get_logs(fromBlock=from_block, toBlock=to_block)
@@ -130,9 +134,7 @@ class OlasEventInvalidator:
                 # self.contract_cache.invalidate(StakingContract, addr, self.chain_name)
 
                 # Option B: Get instance and clear specific cache (safe public access)
-                instance = self.contract_cache.get_if_cached(
-                    StakingContract, addr, self.chain_name
-                )
+                instance = self.contract_cache.get_if_cached(StakingContract, addr, self.chain_name)
                 if instance:
                     instance.clear_epoch_cache()
                     logger.debug(f"Cleared epoch cache for {addr}")