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

tests/test_rate_limiter.py

@@ -146,7 +146,7 @@ class TestRateLimitRotationInterplay:
     """Test interaction between rate limiting and RPC rotation."""
 
     def test_rate_limit_triggers_rotation_first(self):
-        """Test that rate limit error triggers RPC rotation before backoff."""
+        """Test that rate limit error triggers RPC rotation and global backoff."""
         from unittest.mock import MagicMock, PropertyMock
 
         from iwa.core.chain import ChainInterface, SupportedChain
@@ -171,8 +171,10 @@ class TestRateLimitRotationInterplay:
                 assert result["rotated"] is True
                 assert result["should_retry"] is True
                 assert ci._current_rpc_index != original_index
-                # Backoff should NOT be triggered since rotation succeeded
-                assert ci._rate_limiter.get_status()["in_backoff"] is False
+                # Global backoff IS triggered to slow other threads briefly
+                assert ci._rate_limiter.get_status()["in_backoff"] is True
+                # The old RPC should be marked in per-RPC backoff
+                assert not ci._is_rpc_healthy(original_index)
 
     def test_rate_limit_triggers_backoff_when_no_rotation(self):
         """Test that rate limit triggers backoff when no other RPCs available."""
@@ -193,7 +195,7 @@ class TestRateLimitRotationInterplay:
             rate_limit_error = Exception("Error 429: Too Many Requests")
             result = ci._handle_rpc_error(rate_limit_error)
 
-            # Should have triggered retry but NO backoff (skipped for single RPC)
+            # Should have triggered retry and global backoff
             assert result["should_retry"] is True
             assert result["rotated"] is False
-            assert ci._rate_limiter.get_status()["in_backoff"] is False
+            assert ci._rate_limiter.get_status()["in_backoff"] is True

tests/test_rate_limiter_retry.py

@@ -1,4 +1,3 @@
-
 from unittest.mock import MagicMock, PropertyMock, patch
 
 import pytest
@@ -12,7 +11,6 @@ class MockChainInterface:
 
 
 class TestRateLimitedEthRetry:
-
     @pytest.fixture
     def mock_deps(self):
         web3_eth = MagicMock()
@@ -21,28 +19,39 @@ class TestRateLimitedEthRetry:
         chain_interface = MockChainInterface()
         return web3_eth, rate_limiter, chain_interface
 
-    def test_read_method_retries_on_failure(self, mock_deps):
-        """Verify that read methods automatically retry on failure."""
+    def test_read_method_retries_on_transient_failure(self, mock_deps):
+        """Verify that read methods retry on transient (connection) errors."""
         web3_eth, rate_limiter, chain_interface = mock_deps
         eth_wrapper = RateLimitedEth(web3_eth, rate_limiter, chain_interface)
 
-        # Mock get_balance to fail twice then succeed
+        # Mock get_balance to fail once with transient error then succeed
         web3_eth.get_balance.side_effect = [
-            ValueError("RPC error 1"),
-            ValueError("RPC error 2"),
-            100  # Success
+            ValueError("connection timeout"),
+            100,  # Success
         ]
 
-        # Use patch to speed up sleep
         with patch("time.sleep") as mock_sleep:
             result = eth_wrapper.get_balance("0x123")
 
         assert result == 100
-        assert web3_eth.get_balance.call_count == 3
-        # Should have slept twice
-        assert mock_sleep.call_count == 2
-        # Verify handle_error was called
-        assert chain_interface._handle_rpc_error.call_count == 2
+        # 1 initial + 1 retry = 2 calls (DEFAULT_READ_RETRIES=1)
+        assert web3_eth.get_balance.call_count == 2
+        assert mock_sleep.call_count == 1
+        # RateLimitedEth no longer calls _handle_rpc_error (that's for with_retry)
+        assert chain_interface._handle_rpc_error.call_count == 0
+
+    def test_read_method_raises_non_transient_immediately(self, mock_deps):
+        """Verify non-transient errors (rate limit, quota) propagate immediately."""
+        web3_eth, rate_limiter, chain_interface = mock_deps
+        eth_wrapper = RateLimitedEth(web3_eth, rate_limiter, chain_interface)
+
+        web3_eth.get_balance.side_effect = ValueError("429 Too Many Requests")
+
+        with pytest.raises(ValueError, match="429"):
+            eth_wrapper.get_balance("0x123")
+
+        # Only 1 attempt, no retry for non-transient errors
+        assert web3_eth.get_balance.call_count == 1
 
     def test_write_method_no_auto_retry(self, mock_deps):
         """Verify that write methods (send_raw_transaction) DO NOT auto-retry."""
@@ -62,23 +71,21 @@ class TestRateLimitedEthRetry:
         # Should verify it was called only once
         assert web3_eth.send_raw_transaction.call_count == 1
         # Chain interface error handler should NOT be called by the wrapper itself
-        # (It might typically be called by the caller)
         assert chain_interface._handle_rpc_error.call_count == 0
 
     def test_retry_respects_max_attempts(self, mock_deps):
-        """Verify that retry logic respects maximum attempts."""
+        """Verify that retry logic respects maximum attempts for transient errors."""
         web3_eth, rate_limiter, chain_interface = mock_deps
         eth_wrapper = RateLimitedEth(web3_eth, rate_limiter, chain_interface)
 
-        # Override default retries for quicker test
-        # Use object.__setattr__ because RateLimitedEth overrides __setattr__
+        # Override default retries
         object.__setattr__(eth_wrapper, "DEFAULT_READ_RETRIES", 2)
 
-        # Mock always failing
-        web3_eth.get_code.side_effect = ValueError("Persistently failing")
+        # Mock always failing with transient error
+        web3_eth.get_code.side_effect = ValueError("connection reset by peer")
 
         with patch("time.sleep"):
-            with pytest.raises(ValueError, match="Persistently failing"):
+            with pytest.raises(ValueError, match="connection reset"):
                 eth_wrapper.get_code("0x123")
 
         # Attempts: initial + 2 retries = 3 total calls
@@ -89,20 +96,14 @@ class TestRateLimitedEthRetry:
         web3_eth, rate_limiter, chain_interface = mock_deps
         eth_wrapper = RateLimitedEth(web3_eth, rate_limiter, chain_interface)
 
-        # Mock property access: fail then succeed
-        # Note: PropertyMock is needed if we were mocking a property on the CLASS,
-        # but here we are mocking the instance attribute access which might be a method call or property.
-        # web3.eth.block_number is a property.
-
-        # We need to set side_effect on the PROPERTY of the mock
-        type(web3_eth).block_number = PropertyMock(side_effect=[
-            ValueError("Fail 1"),
-            12345
-        ])
+        # block_number fails once with transient error then succeeds
+        type(web3_eth).block_number = PropertyMock(
+            side_effect=[ValueError("connection timeout"), 12345]
+        )
 
         with patch("time.sleep"):
             val = eth_wrapper.block_number
 
         assert val == 12345
-        # Verify handle_error called
-        assert chain_interface._handle_rpc_error.call_count == 1
+        # _handle_rpc_error is NOT called by RateLimitedEth anymore
+        assert chain_interface._handle_rpc_error.call_count == 0

tests/test_rpc_efficiency.py

@@ -25,6 +25,7 @@ def mock_chain_interface():
         # Yield both interface and contract mock
         yield mock_interface, mock_contract
 
+
 def test_staking_contract_lazy_loading(mock_chain_interface):
     """Verify StakingContract init does NOT make RPC calls."""
     mock_interface, mock_contract = mock_chain_interface
@@ -55,13 +56,14 @@ def test_staking_contract_lazy_loading(mock_chain_interface):
     # Assert still 1 call (cached)
     assert mock_contract.functions.livenessPeriod.return_value.call.call_count == 1
 
+
 def test_contract_cache_singleton(mock_chain_interface):
     """Verify ContractCache returns same instance and reuses property cache."""
     mock_interface, mock_contract = mock_chain_interface
     ContractCache().clear()
 
     c1 = ContractCache().get_contract(StakingContract, "0xABC", "gnosis")
-    c2 = ContractCache().get_contract(StakingContract, "0xabc", "gnosis") # Check ignore case
+    c2 = ContractCache().get_contract(StakingContract, "0xabc", "gnosis")  # Check ignore case
 
     assert c1 is c2
 
@@ -78,6 +80,7 @@ def test_contract_cache_singleton(mock_chain_interface):
     # Call count should NOT increase
     assert mock_contract.functions.maxNumServices.return_value.call.call_count == 1
 
+
 def test_epoch_aware_caching(mock_chain_interface):
     """Verify ts_checkpoint caching logic."""
     mock_interface, mock_contract = mock_chain_interface

tests/test_rpc_rate_limit.py

@@ -14,8 +14,9 @@ def clean_rate_limiters():
     yield
     _rate_limiters.clear()
 
+
 def test_chain_interface_initializes_strict_limiter(clean_rate_limiters):
-    """Verify ChainInterface initializes with rate=1.0 and burst=1."""
+    """Verify ChainInterface initializes with rate=5.0 and burst=10."""
     # Create a dummy chain
     chain = MagicMock(spec=SupportedChain)
     chain.name = "TestSlowChain"
@@ -29,5 +30,5 @@ def test_chain_interface_initializes_strict_limiter(clean_rate_limiters):
     limiter = ci._rate_limiter
 
     # Assert correct configuration
-    assert limiter.rate == 1.0, f"Expected rate 1.0, got {limiter.rate}"
-    assert limiter.burst == 1, f"Expected burst 1, got {limiter.burst}"
+    assert limiter.rate == 5.0, f"Expected rate 5.0, got {limiter.rate}"
+    assert limiter.burst == 10, f"Expected burst 10, got {limiter.burst}"

tests/test_rpc_rotation.py

@@ -91,7 +91,9 @@ def test_rpc_rotation_updates_provider():
     class MockRateLimitedWeb3:
         def __init__(self, w3, rl, ci):
             self._web3 = w3
-            self.set_backend = MagicMock(side_effect=lambda new_w3: set_backend_calls.append(new_w3))
+            self.set_backend = MagicMock(
+                side_effect=lambda new_w3: set_backend_calls.append(new_w3)
+            )
 
         def __getattr__(self, name):
             return getattr(self._web3, name)
@@ -230,9 +232,7 @@ def test_rotation_applies_to_subsequent_calls():
         mock_web3_class.side_effect = create_web3
         mock_web3_class.HTTPProvider = create_provider
 
-        with patch(
-            "iwa.core.chain.interface.RateLimitedWeb3", side_effect=lambda w3, rl, ci: w3
-        ):
+        with patch("iwa.core.chain.interface.RateLimitedWeb3", side_effect=lambda w3, rl, ci: w3):
             ci = ChainInterface(chain)
 
             # First call uses RPC 1

tests/test_safe_executor.py

@@ -64,10 +64,13 @@ def mock_safe():
 # Test: Basic execution success
 # =============================================================================
 
+
 def test_execute_success_first_try(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """Test successful execution on first attempt."""
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
-        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
         mock_safe_tx.execute.return_value = b"tx_hash"
 
         success, tx_hash, receipt = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
@@ -81,10 +84,13 @@ def test_execute_success_first_try(executor, mock_chain_interface, mock_safe_tx,
 # Test: Tuple vs bytes return handling
 # =============================================================================
 
+
 def test_execute_handles_tuple_return(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """Test that executor handles safe_tx.execute() returning tuple (tx_hash, tx)."""
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
-        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
         # Simulate tuple return: (tx_hash_bytes, tx_data)
         mock_safe_tx.execute.return_value = (b"tx_hash", {"gas": 21000})
 
@@ -96,8 +102,10 @@ def test_execute_handles_tuple_return(executor, mock_chain_interface, mock_safe_
 
 def test_execute_handles_bytes_return(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """Test that executor handles safe_tx.execute() returning raw bytes."""
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
-        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
         mock_safe_tx.execute.return_value = b"raw_hash"
 
         success, tx_hash, receipt = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
@@ -108,8 +116,10 @@ def test_execute_handles_bytes_return(executor, mock_chain_interface, mock_safe_
 
 def test_execute_handles_string_return(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """Test that executor handles safe_tx.execute() returning hex string."""
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
-        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
         mock_safe_tx.execute.return_value = "0xabcdef1234567890"
 
         success, tx_hash, receipt = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
@@ -122,11 +132,12 @@ def test_execute_handles_string_return(executor, mock_chain_interface, mock_safe
 # Test: Signature validation
 # =============================================================================
 
+
 def test_execute_fails_on_empty_signatures(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """Verify we fail immediately if no signatures exist."""
     mock_safe_tx.signatures = b""  # Empty signatures
 
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
         with patch("time.sleep"):
             success, error, _ = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
 
@@ -135,11 +146,13 @@ def test_execute_fails_on_empty_signatures(executor, mock_chain_interface, mock_
     assert mock_safe_tx.execute.call_count == 0  # Never tried to execute
 
 
-def test_execute_fails_on_truncated_signatures(executor, mock_chain_interface, mock_safe_tx, mock_safe):
+def test_execute_fails_on_truncated_signatures(
+    executor, mock_chain_interface, mock_safe_tx, mock_safe
+):
     """Verify we detect signatures shorter than 65 bytes."""
     mock_safe_tx.signatures = b"x" * 30  # Too short (need 65)
 
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
         with patch("time.sleep"):
             success, error, _ = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
 
@@ -151,7 +164,7 @@ def test_execute_fails_on_none_signatures(executor, mock_chain_interface, mock_s
     """Verify we handle None signatures gracefully."""
     mock_safe_tx.signatures = None
 
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
         with patch("time.sleep"):
             success, error, _ = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
 
@@ -163,9 +176,10 @@ def test_execute_fails_on_none_signatures(executor, mock_chain_interface, mock_s
 # Test: Error classification (GS0xx codes)
 # =============================================================================
 
+
 def test_gs020_fails_fast(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """GS020 (signatures too short) should not trigger retries."""
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
         mock_safe_tx.call.side_effect = ValueError("execution reverted: GS020")
 
         with patch("time.sleep"):
@@ -178,7 +192,7 @@ def test_gs020_fails_fast(executor, mock_chain_interface, mock_safe_tx, mock_saf
 
 def test_gs026_fails_fast(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """GS026 (invalid owner) should not trigger retries."""
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
         mock_safe_tx.call.side_effect = ValueError("execution reverted: GS026")
 
         with patch("time.sleep"):
@@ -188,15 +202,18 @@ def test_gs026_fails_fast(executor, mock_chain_interface, mock_safe_tx, mock_saf
         assert "GS026" in error
 
 
-@pytest.mark.parametrize("error_code,is_signature_error", [
-    ("GS020", True),   # Signatures data too short
-    ("GS021", True),   # Invalid signature data pointer
-    ("GS024", True),   # Invalid contract signature
-    ("GS026", True),   # Invalid owner
-    ("GS025", False),  # Invalid nonce (not a signature error)
-    ("GS010", False),  # Not enough gas
-    ("GS013", False),  # Safe transaction failed
-])
+@pytest.mark.parametrize(
+    "error_code,is_signature_error",
+    [
+        ("GS020", True),  # Signatures data too short
+        ("GS021", True),  # Invalid signature data pointer
+        ("GS024", True),  # Invalid contract signature
+        ("GS026", True),  # Invalid owner
+        ("GS025", False),  # Invalid nonce (not a signature error)
+        ("GS010", False),  # Not enough gas
+        ("GS013", False),  # Safe transaction failed
+    ],
+)
 def test_error_classification(executor, error_code, is_signature_error):
     """Verify correct classification of Safe error codes."""
     error = ValueError(f"execution reverted: {error_code}")
@@ -208,18 +225,20 @@ def test_error_classification(executor, error_code, is_signature_error):
 # Test: Retry behavior
 # =============================================================================
 
+
 def test_retry_on_transient_error(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """Test that transient errors trigger retries without modifying tx."""
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
-        mock_safe_tx.execute.side_effect = [
-            ConnectionError("Network timeout"),
-            b"success_hash"
-        ]
-        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        mock_safe_tx.execute.side_effect = [ConnectionError("Network timeout"), b"success_hash"]
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
         mock_chain_interface._is_connection_error.return_value = True
 
         with patch("time.sleep"):
-            success, tx_hash, receipt = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+            success, tx_hash, receipt = executor.execute_with_retry(
+                "0xSafe", mock_safe_tx, ["key1"]
+            )
 
         assert success is True
         assert mock_safe_tx.execute.call_count == 2
@@ -229,12 +248,11 @@ def test_retry_on_transient_error(executor, mock_chain_interface, mock_safe_tx,
 
 def test_retry_on_nonce_error(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """Test nonce refresh on GS025 error."""
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
-        mock_safe_tx.execute.side_effect = [
-            ValueError("GS025: invalid nonce"),
-            b"success_hash"
-        ]
-        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        mock_safe_tx.execute.side_effect = [ValueError("GS025: invalid nonce"), b"success_hash"]
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
 
         new_tx = MagicMock(spec=SafeTx)
         new_tx.signatures = b"x" * 65
@@ -249,13 +267,12 @@ def test_retry_on_nonce_error(executor, mock_chain_interface, mock_safe_tx, mock
 
 def test_retry_on_rpc_error(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """Test RPC rotation on rate limit error."""
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
-        mock_safe_tx.execute.side_effect = [
-            ValueError("Rate limit exceeded"),
-            b"success_hash"
-        ]
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        mock_safe_tx.execute.side_effect = [ValueError("Rate limit exceeded"), b"success_hash"]
         mock_chain_interface._is_rate_limit_error.return_value = True
-        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
 
         with patch("time.sleep"):
             executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
@@ -267,11 +284,13 @@ def test_retry_on_rpc_error(executor, mock_chain_interface, mock_safe_tx, mock_s
 def test_fail_after_max_retries(executor, mock_chain_interface, mock_safe_tx, mock_safe):
     """Test failure after exhausting all retries."""
     executor.max_retries = 2
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
         mock_safe_tx.execute.side_effect = ValueError("Persistent error")
 
         with patch("time.sleep"):
-            success, tx_hash_or_err, receipt = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+            success, tx_hash_or_err, receipt = executor.execute_with_retry(
+                "0xSafe", mock_safe_tx, ["key1"]
+            )
 
         assert success is False
         assert mock_safe_tx.execute.call_count == 3  # 1 initial + 2 retries
@@ -281,7 +300,10 @@ def test_fail_after_max_retries(executor, mock_chain_interface, mock_safe_tx, mo
 # Test: State preservation during retries
 # =============================================================================
 
-def test_retry_preserves_signatures_despite_clearing(executor, mock_chain_interface, mock_safe_tx, mock_safe):
+
+def test_retry_preserves_signatures_despite_clearing(
+    executor, mock_chain_interface, mock_safe_tx, mock_safe
+):
     """Verify that retries don't corrupt/lose signatures even if library clears them."""
     original_signatures = mock_safe_tx.signatures
 
@@ -291,21 +313,23 @@ def test_retry_preserves_signatures_despite_clearing(executor, mock_chain_interf
         mock_safe_tx.signatures = b""
         return b"hash"
 
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
         # Scenario:
         # 1. Execute success (sigs cleared) but Receipt not found (triggering retry)
         # 2. Retry: Execute called again (must have restored sigs) -> Success -> Receipt found
 
         mock_chain_interface.web3.eth.wait_for_transaction_receipt.side_effect = [
             ValueError("Transaction not found"),
-            MagicMock(status=1)
+            MagicMock(status=1),
         ]
 
         mock_safe_tx.execute.side_effect = execute_side_effect
         mock_chain_interface._is_connection_error.return_value = False
 
         with patch("time.sleep"):
-            success, tx_hash, receipt = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+            success, tx_hash, receipt = executor.execute_with_retry(
+                "0xSafe", mock_safe_tx, ["key1"]
+            )
 
         assert success is True
         # Signatures should be restored after the loop (or at least valid during 2nd call)
@@ -324,9 +348,11 @@ def test_retry_preserves_gas(executor, mock_chain_interface, mock_safe_tx, mock_
     """Verify that retries don't modify safe_tx_gas (which would invalidate signatures)."""
     original_gas = mock_safe_tx.safe_tx_gas
 
-    with patch.object(executor, '_recreate_safe_client', return_value=mock_safe):
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
         mock_safe_tx.execute.side_effect = [ConnectionError("timeout"), b"hash"]
-        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
         mock_chain_interface._is_connection_error.return_value = True
 
         with patch("time.sleep"):

tests/test_safe_integration.py

@@ -47,7 +47,12 @@ def real_safe_tx_mock_eth(mock_chain_interface):
     mock_contract = MagicMock()
     # Mock execTransaction function build_transaction
     mock_contract.functions.execTransaction.return_value.build_transaction.return_value = {
-        "to": "0xSafe", "data": b"", "value": 0, "gas": 500000, "nonce": 5, "from": "0xExecutor"
+        "to": "0xSafe",
+        "data": b"",
+        "value": 0,
+        "gas": 500000,
+        "nonce": 5,
+        "from": "0xExecutor",
     }
     # Mock nonce call
     mock_contract.functions.nonce().call.return_value = 5
@@ -64,14 +69,14 @@ def real_safe_tx_mock_eth(mock_chain_interface):
             0,
             b"",
             0,
-            200000, # safe_tx_gas
+            200000,  # safe_tx_gas
             0,
             0,
             None,
             None,
             signatures=MOCK_SIGNATURE,
             safe_nonce=5,
-            chain_id=1
+            chain_id=1,
         )
 
         # HACK: Force initialize properties that rely on cached_property + network
@@ -96,7 +101,7 @@ def test_integration_full_execution_flow(mock_chain_interface, real_safe_tx_mock
     # Use a dummy key (needs to be valid hex for account generation if SafeTx uses it)
     dummy_key = "0x" + "1" * 64
 
-    with patch.object(executor, '_recreate_safe_client', return_value=MagicMock()):
+    with patch.object(executor, "_recreate_safe_client", return_value=MagicMock()):
         # Pre-execution check
         assert len(safe_tx.signatures) == 65
 
@@ -129,12 +134,12 @@ def test_integration_retry_preserves_signatures(mock_chain_interface, real_safe_
     # Second attempt: Success (status 1)
     mock_chain_interface.web3.eth.wait_for_transaction_receipt.side_effect = [
         ValueError("Transaction not found"),
-        MagicMock(status=1)
+        MagicMock(status=1),
     ]
 
     dummy_key = "0x" + "1" * 64
 
-    with patch.object(executor, '_recreate_safe_client', return_value=MagicMock()):
+    with patch.object(executor, "_recreate_safe_client", return_value=MagicMock()):
         with patch("time.sleep"):  # Skip sleep
             success, tx_hash, receipt = executor.execute_with_retry("0xSafe", safe_tx, [dummy_key])