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

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])