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

tests/test_safe_executor.py

@@ -0,0 +1,335 @@
+"""Tests for SafeTransactionExecutor."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from safe_eth.safe.safe_tx import SafeTx
+
+from iwa.core.services.safe_executor import (
+    MIN_SIGNATURE_LENGTH,
+    SAFE_TX_STATS,
+    SafeTransactionExecutor,
+)
+
+
+@pytest.fixture(autouse=True)
+def reset_stats():
+    """Reset SAFE_TX_STATS before each test to prevent state leakage."""
+    for key in SAFE_TX_STATS:
+        SAFE_TX_STATS[key] = 0
+    yield
+
+
+@pytest.fixture
+def mock_chain_interface():
+    ci = MagicMock()
+    ci.current_rpc = "http://mock-rpc"
+    ci.DEFAULT_MAX_RETRIES = 6
+    ci._is_rate_limit_error.return_value = False
+    ci._is_connection_error.return_value = False
+    ci._handle_rpc_error.return_value = {"should_retry": True}
+    return ci
+
+
+@pytest.fixture
+def executor(mock_chain_interface):
+    return SafeTransactionExecutor(mock_chain_interface)
+
+
+@pytest.fixture
+def mock_safe_tx():
+    """Mock SafeTx with valid 65-byte signature."""
+    tx = MagicMock(spec=SafeTx)
+    tx.safe_tx_gas = 100000
+    tx.base_gas = 0
+    tx.gas_price = 1000000000
+    tx.to = "0xTo"
+    tx.value = 0
+    tx.data = b""
+    tx.operation = 0
+    # Valid signatures must be >= 65 bytes (one ECDSA signature)
+    tx.signatures = b"x" * 65
+    return tx
+
+
+@pytest.fixture
+def mock_safe():
+    s = MagicMock()
+    s.estimate_tx_gas.return_value = 100000
+    s.retrieve_nonce.return_value = 5
+    return s
+
+
+# =============================================================================
+# 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)
+        mock_safe_tx.execute.return_value = b"tx_hash"
+
+        success, tx_hash, receipt = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+
+        assert success is True
+        assert tx_hash == "0x" + b"tx_hash".hex()
+        assert mock_safe_tx.execute.call_count == 1
+
+
+# =============================================================================
+# 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)
+        # Simulate tuple return: (tx_hash_bytes, tx_data)
+        mock_safe_tx.execute.return_value = (b"tx_hash", {"gas": 21000})
+
+        success, tx_hash, receipt = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+
+        assert success is True
+        assert tx_hash == "0x" + b"tx_hash".hex()
+
+
+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)
+        mock_safe_tx.execute.return_value = b"raw_hash"
+
+        success, tx_hash, receipt = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+
+        assert success is True
+        assert tx_hash.startswith("0x")
+
+
+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)
+        mock_safe_tx.execute.return_value = "0xabcdef1234567890"
+
+        success, tx_hash, receipt = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+
+        assert success is True
+        assert tx_hash == "0xabcdef1234567890"
+
+
+# =============================================================================
+# 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("time.sleep"):
+            success, error, _ = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+
+    assert success is False
+    assert "No valid signatures" in error
+    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):
+    """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("time.sleep"):
+            success, error, _ = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+
+    assert success is False
+    assert "No valid signatures" in error or str(MIN_SIGNATURE_LENGTH) in error
+
+
+def test_execute_fails_on_none_signatures(executor, mock_chain_interface, mock_safe_tx, mock_safe):
+    """Verify we handle None signatures gracefully."""
+    mock_safe_tx.signatures = None
+
+    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"])
+
+    assert success is False
+    assert "No valid signatures" in error
+
+
+# =============================================================================
+# 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):
+        mock_safe_tx.call.side_effect = ValueError("execution reverted: GS020")
+
+        with patch("time.sleep"):
+            success, error, _ = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+
+        assert success is False
+        assert "GS020" in error
+        assert mock_safe_tx.execute.call_count == 0  # Never got to execute
+
+
+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):
+        mock_safe_tx.call.side_effect = ValueError("execution reverted: GS026")
+
+        with patch("time.sleep"):
+            success, error, _ = executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+
+        assert success is False
+        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
+])
+def test_error_classification(executor, error_code, is_signature_error):
+    """Verify correct classification of Safe error codes."""
+    error = ValueError(f"execution reverted: {error_code}")
+    result = executor._is_signature_error(error)
+    assert result == 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)
+        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"])
+
+        assert success is True
+        assert mock_safe_tx.execute.call_count == 2
+        # Gas should NOT have changed (we don't modify after signing)
+        assert mock_safe_tx.safe_tx_gas == 100000
+
+
+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)
+
+        new_tx = MagicMock(spec=SafeTx)
+        new_tx.signatures = b"x" * 65
+        executor._refresh_nonce = MagicMock(return_value=new_tx)
+
+        with patch("time.sleep"):
+            executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+
+        assert executor._refresh_nonce.called
+        assert new_tx.execute.called
+
+
+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"
+        ]
+        mock_chain_interface._is_rate_limit_error.return_value = True
+        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"])
+
+        assert mock_chain_interface._handle_rpc_error.called
+        assert mock_chain_interface._handle_rpc_error.call_count == 1
+
+
+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):
+        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"])
+
+        assert success is False
+        assert mock_safe_tx.execute.call_count == 3  # 1 initial + 2 retries
+
+
+# =============================================================================
+# Test: State preservation during retries
+# =============================================================================
+
+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
+
+    # Define a side effect that clears signatures on success (mimicking safe-eth-py)
+    def execute_side_effect(key, **kwargs):
+        # Simulate library behavior: clears signatures after "executing"
+        mock_safe_tx.signatures = b""
+        return b"hash"
+
+    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)
+        ]
+
+        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"])
+
+        assert success is True
+        # Signatures should be restored after the loop (or at least valid during 2nd call)
+        # We assert they match original at the end because the finally block restores if changed?
+        # Wait, finally restores IF signatures != backup.
+        # If call 2 succeeds, execute() sets signatures to b"" AGAIN at the end of call 2.
+        # So at the end of execution, signatures ARE empty locally if we updated them?
+        # NO, the finally block runs AFTER safe_tx.execute returns.
+        # So after call 2 returns (sigs=b""), finally restores them (sigs=original).
+        # So they should be original.
+        assert mock_safe_tx.signatures == original_signatures
+        assert mock_safe_tx.execute.call_count == 2
+
+
+def test_retry_preserves_gas(executor, mock_chain_interface, mock_safe_tx, mock_safe):
+    """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):
+        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._is_connection_error.return_value = True
+
+        with patch("time.sleep"):
+            executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
+
+        assert mock_safe_tx.safe_tx_gas == original_gas

tests/test_safe_integration.py

@@ -0,0 +1,148 @@
+"""Integration tests for SafeTransactionExecutor using REAL SafeTx class.
+
+These tests do NOT mock SafeTx methods. They use the real SafeTx class from safe-eth-py
+to ensure that we correctly handle its internal state changes (like signature clearing).
+We only mock the EthereumClient/w3 layer to avoid actual network calls.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from hexbytes import HexBytes
+from safe_eth.eth import EthereumClient
+from safe_eth.safe.safe_tx import SafeTx
+
+from iwa.core.services.safe_executor import SafeTransactionExecutor
+
+# Valid 65-byte mock signature
+MOCK_SIGNATURE = b"x" * 65
+MOCK_TX_HASH = HexBytes("0x" + "a" * 64)
+
+
+@pytest.fixture
+def mock_chain_interface():
+    ci = MagicMock()
+    ci.current_rpc = "http://mock-rpc"
+    ci.DEFAULT_MAX_RETRIES = 6
+    ci._is_rate_limit_error.return_value = False
+    ci._is_connection_error.return_value = False
+    ci._handle_rpc_error.return_value = {"should_retry": True}
+
+    # Needs a web3 instance
+    ci.web3 = MagicMock()
+    return ci
+
+
+@pytest.fixture
+def real_safe_tx_mock_eth(mock_chain_interface):
+    """Create a REAL SafeTx object but with mocked EthereumClient."""
+
+    # 1. Setup Mock EthereumClient
+    mock_eth_client = MagicMock(spec=EthereumClient)
+    mock_eth_client.w3 = mock_chain_interface.web3
+
+    # 2. Setup Mock Contract for SafeTx internals
+    # SafeTx calls get_safe_contract(self.w3, address)
+    # We need to mock the contract function calls to avoid errors
+    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"
+    }
+    # Mock nonce call
+    mock_contract.functions.nonce().call.return_value = 5
+    # Mock VERSION call
+    mock_contract.functions.VERSION().call.return_value = "1.3.0"
+
+    # We must patch get_safe_contract to return our mock
+    # because SafeTx uses it internally via @cached_property
+    with patch("safe_eth.safe.safe_tx.get_safe_contract", return_value=mock_contract):
+        safe_tx = SafeTx(
+            mock_eth_client,
+            "0xSafeAddress",
+            "0xTo",
+            0,
+            b"",
+            0,
+            200000, # safe_tx_gas
+            0,
+            0,
+            None,
+            None,
+            signatures=MOCK_SIGNATURE,
+            safe_nonce=5,
+            chain_id=1
+        )
+
+        # HACK: Force initialize properties that rely on cached_property + network
+        # safe_tx.contract calls get_safe_contract (mocked above)
+        _ = safe_tx.contract
+
+        yield safe_tx, mock_eth_client
+
+
+def test_integration_full_execution_flow(mock_chain_interface, real_safe_tx_mock_eth):
+    """
+    Test execution flow using REAL SafeTx.
+    This verifies that our executor handles the SafeTx.execute() side-effects (clearing signatures).
+    """
+    safe_tx, mock_eth_client = real_safe_tx_mock_eth
+    executor = SafeTransactionExecutor(mock_chain_interface)
+
+    # Setup successful broadcast mock
+    mock_eth_client.send_unsigned_transaction.return_value = MOCK_TX_HASH
+    mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+
+    # 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()):
+        # Pre-execution check
+        assert len(safe_tx.signatures) == 65
+
+        success, tx_hash, receipt = executor.execute_with_retry("0xSafe", safe_tx, [dummy_key])
+
+        assert success is True
+        assert tx_hash == "0x" + MOCK_TX_HASH.hex()
+
+        # VITAL CHECK: Signatures must be present after execution!
+        # If backup/restore logic isn't working, this will fail because SafeTx clears them.
+        assert len(safe_tx.signatures) == 65
+        assert safe_tx.signatures == MOCK_SIGNATURE
+
+
+def test_integration_retry_preserves_signatures(mock_chain_interface, real_safe_tx_mock_eth):
+    """
+    Test retry flow with REAL SafeTx.
+    Simulate:
+    1. Exec -> SafeTx clears sigs -> Network sends
+    2. Wait -> Timeout (failure)
+    3. Retry -> Exec again (Needs sigs!) -> Success
+    """
+    safe_tx, mock_eth_client = real_safe_tx_mock_eth
+    executor = SafeTransactionExecutor(mock_chain_interface)
+
+    # Setup mocks
+    mock_eth_client.send_unsigned_transaction.return_value = MOCK_TX_HASH
+
+    # First attempt: Transaction not found (Timeout)
+    # Second attempt: Success (status 1)
+    mock_chain_interface.web3.eth.wait_for_transaction_receipt.side_effect = [
+        ValueError("Transaction not found"),
+        MagicMock(status=1)
+    ]
+
+    dummy_key = "0x" + "1" * 64
+
+    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])
+
+    assert success is True
+
+    # Verify we actually called send twice (retry happened)
+    assert mock_eth_client.send_unsigned_transaction.call_count == 2
+
+    # Verify signatures preserved at the end
+    assert len(safe_tx.signatures) == 65
+    assert safe_tx.signatures == MOCK_SIGNATURE

tests/test_safe_service.py

@@ -126,7 +126,7 @@ def test_create_safe_standard(mock_key_storage, mock_account_service, mock_depen
     assert tx_hash == "0xTxHash"
 
     mock_dependencies["safe"].create.assert_called_once()
-    mock_key_storage.save.assert_called_once()
+    mock_key_storage.register_account.assert_called_once()
 
 
 def test_create_safe_with_salt(mock_key_storage, mock_account_service, mock_dependencies):

tests/test_transfer_swap_unit.py

@@ -151,5 +151,9 @@ async def test_swap_full_balance(transfer_service, mock_chain_interfaces, mock_c
 
     # Verify correct amount passed to swap
     cow_instance.swap.assert_called_with(
-        amount_wei=500, sell_token_name="WETH", buy_token_name="USDC", order_type=OrderType.SELL
+        amount_wei=500,
+        sell_token_name="WETH",
+        buy_token_name="USDC",
+        order_type=OrderType.SELL,
+        wait_for_execution=True,
     )

tests/test_pricing.py

@@ -1,160 +0,0 @@
-from datetime import timedelta
-from unittest.mock import patch
-
-import pytest
-
-from iwa.core.pricing import PriceService
-
-
-@pytest.fixture
-def mock_secrets():
-    with patch("iwa.core.pricing.secrets") as mock:
-        mock.coingecko_api_key.get_secret_value.return_value = "test_api_key"
-        yield mock
-
-
-@pytest.fixture
-def price_service(mock_secrets):
-    return PriceService()
-
-
-@pytest.fixture(autouse=True)
-def clear_cache():
-    """Clear global cache before each test to ensure isolation."""
-    with patch("iwa.core.pricing._PRICE_CACHE", {}):
-        yield
-
-
-def test_get_token_price_success(price_service):
-    with patch("iwa.core.pricing.requests.get") as mock_get:
-        mock_get.return_value.status_code = 200
-        mock_get.return_value.json.return_value = {"ethereum": {"eur": 2000.50}}
-
-        price = price_service.get_token_price("ethereum", "eur")
-
-        assert price == 2000.50
-        mock_get.assert_called_once()
-        # Verify API key in headers
-        args, kwargs = mock_get.call_args
-        assert kwargs["headers"]["x-cg-demo-api-key"] == "test_api_key"
-
-
-def test_get_token_price_cached(price_service):
-    # Pre-populate cache
-    from datetime import datetime
-
-    cache_data = {
-        "ethereum_eur": {"price": 100.0, "timestamp": datetime.now()}
-    }
-
-    with patch.dict("iwa.core.pricing._PRICE_CACHE", cache_data):
-        with patch("iwa.core.pricing.requests.get") as mock_get:
-            price = price_service.get_token_price("ethereum", "eur")
-            assert price == 100.0
-            mock_get.assert_not_called()
-
-
-def test_get_token_price_cache_expired(price_service):
-    # Pre-populate expired cache
-    from datetime import datetime
-
-    cache_data = {
-        "ethereum_eur": {
-            "price": 100.0,
-            "timestamp": datetime.now() - timedelta(minutes=60), # > 30 min TTL
-        }
-    }
-
-    with patch.dict("iwa.core.pricing._PRICE_CACHE", cache_data):
-        with patch("iwa.core.pricing.requests.get") as mock_get:
-            mock_get.return_value.status_code = 200
-            mock_get.return_value.json.return_value = {"ethereum": {"eur": 200.0}}
-
-            price = price_service.get_token_price("ethereum", "eur")
-            assert price == 200.0
-            mock_get.assert_called_once()
-
-
-def test_get_token_price_api_error(price_service):
-    with patch("iwa.core.pricing.requests.get") as mock_get:
-        mock_get.side_effect = Exception("API Error")
-
-        price = price_service.get_token_price("ethereum", "eur")
-        assert price is None
-
-
-def test_get_token_price_key_not_found(price_service):
-    with patch("iwa.core.pricing.requests.get") as mock_get:
-        mock_get.return_value.status_code = 200
-        mock_get.return_value.json.return_value = {}  # Empty response
-
-        price = price_service.get_token_price("ethereum", "eur")
-        assert price is None
-
-
-def test_get_token_price_rate_limit():
-    """Test rate limit (429) handling with retries."""
-    with patch("iwa.core.pricing.secrets") as mock_secrets:
-        mock_secrets.coingecko_api_key = None
-
-        # Need to re-instantiate or patch secrets on instance since it's read in __init__
-        service = PriceService()
-        service.api_key = None
-
-        with patch("iwa.core.pricing.requests.get") as mock_get, patch("time.sleep"):
-            # Return 429 for all attempts
-            mock_response = type("Response", (), {"status_code": 429})()
-            mock_get.return_value = mock_response
-
-            price = service.get_token_price("ethereum", "eur")
-
-            assert price is None
-            # Should have tried max_retries + 1 times (3 total)
-            assert mock_get.call_count == 3
-
-
-def test_get_token_price_rate_limit_then_success():
-    """Test rate limit recovery on retry."""
-    from unittest.mock import MagicMock
-
-    with patch("iwa.core.pricing.secrets") as mock_secrets:
-        mock_secrets.coingecko_api_key = None
-
-        service = PriceService()
-        service.api_key = None
-
-        with patch("iwa.core.pricing.requests.get") as mock_get, patch("time.sleep"):
-            # First call returns 429, second succeeds
-            mock_429 = MagicMock()
-            mock_429.status_code = 429
-
-            mock_ok = MagicMock()
-            mock_ok.status_code = 200
-            mock_ok.json.return_value = {"ethereum": {"eur": 1500.0}}
-
-            mock_get.side_effect = [mock_429, mock_ok]
-
-            price = service.get_token_price("ethereum", "eur")
-
-            assert price == 1500.0
-            assert mock_get.call_count == 2
-
-
-def test_get_token_price_no_api_key():
-    """Test getting price without API key."""
-    with patch("iwa.core.pricing.secrets") as mock_secrets:
-        mock_secrets.coingecko_api_key = None
-
-        service = PriceService()
-        service.api_key = None
-
-        with patch("iwa.core.pricing.requests.get") as mock_get:
-            mock_get.return_value.status_code = 200
-            mock_get.return_value.json.return_value = {"gnosis": {"eur": 100.0}}
-
-            price = service.get_token_price("gnosis", "eur")
-
-            assert price == 100.0
-            # Verify no API key header
-            args, kwargs = mock_get.call_args
-            assert "x-cg-demo-api-key" not in kwargs.get("headers", {})