iwa 0.0.2__py3-none-any.whl → 0.0.11__py3-none-any.whl

tests/test_contract.py

@@ -195,3 +195,168 @@ def test_extract_events_edge_cases(mock_chain_interface):
 
     events = contract.extract_events(receipt)
     assert len(events) == 0
+
+
+# =============================================================================
+# RPC ROTATION TESTS - Verify fix for contract.call() re-evaluating on retry
+# =============================================================================
+
+
+def test_call_reevaluates_contract_on_retry(mock_chain_interface, mock_abi_file):
+    """Verify that self.contract is re-evaluated on each retry attempt.
+
+    This test verifies the fix for the bug where the contract method was
+    captured once outside the retry lambda, causing retries to use the
+    stale provider after RPC rotation.
+    """
+    contract = MockContract("0xAddress", "gnosis")
+
+    # Track how many times web3.eth.contract is called (proxy for contract property access)
+    contract_creation_count = [0]
+
+    def counting_contract_factory(address, abi):
+        contract_creation_count[0] += 1
+        mock = MagicMock()
+        # First call fails, second succeeds
+        if contract_creation_count[0] == 1:
+            mock.functions.testFunc.return_value.call.side_effect = Exception(
+                "429 Too Many Requests"
+            )
+        else:
+            mock.functions.testFunc.return_value.call.return_value = "success"
+        return mock
+
+    mock_chain_interface.web3.eth.contract.side_effect = counting_contract_factory
+
+    # Implement with_retry that actually retries on 429
+    def real_with_retry(fn, max_retries=6, operation_name="operation"):
+        for attempt in range(max_retries + 1):
+            try:
+                return fn()
+            except Exception as e:
+                if "429" in str(e) and attempt < max_retries:
+                    continue
+                raise
+
+    mock_chain_interface.with_retry.side_effect = real_with_retry
+
+    # Execute - should fail first, then succeed
+    result = contract.call("testFunc")
+
+    assert result == "success"
+    # KEY ASSERTION: contract property (and thus web3.eth.contract) should be called
+    # once per attempt. With the fix, this should be 2. Before the fix, it would be 1.
+    assert contract_creation_count[0] == 2, (
+        f"Expected contract to be created 2 times (once per retry attempt), "
+        f"but was created {contract_creation_count[0]} times. "
+        "This suggests the fix for re-evaluating self.contract on retry is not working."
+    )
+
+
+def test_call_uses_fresh_provider_after_rotation(mock_chain_interface, mock_abi_file):
+    """Verify that after RPC rotation, the contract uses the new provider.
+
+    This simulates the scenario where:
+    1. First call fails with 429
+    2. RPC rotates to new provider
+    3. Retry should use the NEW provider, not the old one
+    """
+    contract = MockContract("0xAddress", "gnosis")
+
+    # Track which provider version is being used
+    provider_versions = []
+    current_provider_version = [1]  # Mutable to track version changes
+
+    def mock_contract_factory(address, abi):
+        mock = MagicMock()
+        # Capture which provider version was used when this contract was created
+        mock._provider_version = current_provider_version[0]
+        provider_versions.append(current_provider_version[0])
+        return mock
+
+    mock_chain_interface.web3.eth.contract.side_effect = mock_contract_factory
+
+    # Simulate RPC rotation by incrementing provider version
+    def simulate_rotation():
+        current_provider_version[0] += 1
+        return True
+
+    mock_chain_interface.rotate_rpc = simulate_rotation
+
+    # Make with_retry call rotation between attempts
+    attempt_count = [0]
+
+    def mock_with_retry(fn, **kwargs):
+        attempt_count[0] += 1
+        if attempt_count[0] == 1:
+            # First attempt: simulate 429 then rotation
+            simulate_rotation()
+            # Call again after rotation
+            return fn()
+        return fn()
+
+    mock_chain_interface.with_retry.side_effect = mock_with_retry
+
+    # Execute call (this should access contract property, which creates new contract)
+    contract.call("testFunc")
+
+    # Verify: contract was created at least once with the rotated provider
+    # If the fix works, the provider_versions list should show provider version 2
+    # (because rotation happened before the successful call)
+    assert len(provider_versions) >= 1
+    # The last contract should have been created with the rotated provider
+    assert provider_versions[-1] == 2, f"Expected provider version 2, got {provider_versions}"
+
+
+def test_call_with_429_triggers_retry_with_new_contract(mock_chain_interface, mock_abi_file):
+    """Integration test: 429 error should trigger retry which uses fresh contract.
+
+    This test verifies the complete flow:
+    1. Call fails with 429
+    2. with_retry handles it and retries
+    3. The retry uses a fresh contract instance (new provider)
+    """
+    contract = MockContract("0xAddress", "gnosis")
+
+    # Create distinct mock contracts for each call
+    mock_contract_1 = MagicMock()
+    mock_contract_1.functions.testFunc.return_value.call.side_effect = Exception(
+        "429 Too Many Requests"
+    )
+
+    mock_contract_2 = MagicMock()
+    mock_contract_2.functions.testFunc.return_value.call.return_value = "success_from_rotated_rpc"
+
+    contracts_returned = [mock_contract_1, mock_contract_2]
+    contract_call_count = [0]
+
+    def mock_contract_factory(address, abi):
+        result = contracts_returned[min(contract_call_count[0], len(contracts_returned) - 1)]
+        contract_call_count[0] += 1
+        return result
+
+    mock_chain_interface.web3.eth.contract.side_effect = mock_contract_factory
+
+    # Implement with_retry that actually retries
+    def real_with_retry(fn, max_retries=6, operation_name="operation"):
+        last_error = None
+        for attempt in range(max_retries + 1):
+            try:
+                return fn()
+            except Exception as e:
+                last_error = e
+                if "429" in str(e) and attempt < max_retries:
+                    continue  # Retry
+                raise
+        raise last_error
+
+    mock_chain_interface.with_retry.side_effect = real_with_retry
+
+    # Execute - should succeed on second attempt with rotated RPC
+    result = contract.call("testFunc")
+
+    assert result == "success_from_rotated_rpc"
+    # Verify we created 2 contract instances (one per attempt)
+    assert contract_call_count[0] == 2, (
+        f"Expected 2 contract creations, got {contract_call_count[0]}"
+    )

tests/test_keys.py

@@ -67,7 +67,8 @@ def mock_account():
         def from_key_side_effect(private_key):
             # 1. Handle the master private key
             if (
-                private_key == "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"  # gitleaks:allow
+                private_key
+                == "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"  # gitleaks:allow
             ):
                 addr = "0x5B38Da6a701c568545dCfcB03FcB875f56beddC4"
             # 2. Handle our mock key format

tests/test_legacy_wallet.py

@@ -39,6 +39,17 @@ def mock_transaction_service():
         yield instance
 
 
+@pytest.fixture(autouse=True)
+def mock_chain_sleeps():
+    """Mock time.sleep in chain modules to speed up tests."""
+    with (
+        patch("iwa.core.chain.interface.time.sleep"),
+        patch("iwa.core.chain.rate_limiter.time.sleep"),
+        patch("time.sleep"),
+    ):
+        yield
+
+
 @pytest.fixture
 def mock_key_storage():
     with patch("iwa.core.wallet.KeyStorage") as mock:

tests/test_pricing.py

@@ -18,6 +18,13 @@ 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
@@ -36,30 +43,36 @@ def test_get_token_price_cached(price_service):
     # Pre-populate cache
     from datetime import datetime
 
-    price_service.cache["ethereum_eur"] = {"price": 100.0, "timestamp": datetime.now()}
+    cache_data = {
+        "ethereum_eur": {"price": 100.0, "timestamp": datetime.now()}
+    }
 
-    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()
+    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
 
-    price_service.cache["ethereum_eur"] = {
-        "price": 100.0,
-        "timestamp": datetime.now() - timedelta(minutes=10),
+    cache_data = {
+        "ethereum_eur": {
+            "price": 100.0,
+            "timestamp": datetime.now() - timedelta(minutes=60), # > 30 min TTL
+        }
     }
 
-    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}}
+    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()
+            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):
@@ -84,7 +97,9 @@ def test_get_token_price_rate_limit():
     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
@@ -94,7 +109,7 @@ def test_get_token_price_rate_limit():
             price = service.get_token_price("ethereum", "eur")
 
             assert price is None
-            # Should have tried max_retries + 1 times
+            # Should have tried max_retries + 1 times (3 total)
             assert mock_get.call_count == 3
 
 
@@ -106,6 +121,7 @@ def test_get_token_price_rate_limit_then_success():
         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
@@ -130,6 +146,7 @@ def test_get_token_price_no_api_key():
         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

tests/test_safe_coverage.py

@@ -56,7 +56,7 @@ def test_execute_safe_transaction_success(safe_service, mock_deps):
         mock_safe_instance = mock_safe_multisig_cls.return_value
         mock_safe_tx = MagicMock()
         mock_safe_instance.build_tx.return_value = mock_safe_tx
-        mock_safe_tx.tx_hash.hex.return_value = "0xTxHash"
+        mock_safe_tx.tx_hash.hex.return_value = "TxHash"
 
         # Execute
         tx_hash = safe_service.execute_safe_transaction(safe_address, to_address, value, chain_name)
@@ -90,7 +90,7 @@ def test_get_sign_and_execute_callback(safe_service, mock_deps):
 
     # Test executing callback
     mock_safe_tx = MagicMock()
-    mock_safe_tx.tx_hash.hex.return_value = "0xTxHash"
+    mock_safe_tx.tx_hash.hex.return_value = "TxHash"
 
     result = callback(mock_safe_tx)
 
@@ -119,7 +119,7 @@ def test_redeploy_safes(safe_service, mock_deps):
 
     mock_deps["key_storage"].accounts = {"0xSafe1": account1}
 
-    with patch("iwa.core.services.safe.secrets") as mock_settings:
+    with patch("iwa.core.chain.models.secrets") as mock_settings:
         mock_settings.gnosis_rpc.get_secret_value.return_value = "http://rpc"
 
         with patch("iwa.core.services.safe.EthereumClient") as mock_eth_client:

tests/test_safe_service.py

@@ -53,18 +53,16 @@ def mock_dependencies():
         patch("iwa.core.services.safe.EthereumClient") as mock_client,
         patch("iwa.core.services.safe.Safe") as mock_safe,
         patch("iwa.core.services.safe.ProxyFactory") as mock_proxy_factory,
-        patch("iwa.core.services.safe.secrets") as mock_secrets,
         patch("iwa.core.services.safe.log_transaction") as mock_log,
         patch("iwa.core.services.safe.get_safe_master_copy_address") as mock_master,
         patch("iwa.core.services.safe.get_safe_proxy_factory_address") as mock_factory,
+        patch("time.sleep"),  # Avoid any retry delays
     ):
-        mock_secrets.gnosis_rpc.get_secret_value.return_value = "http://rpc"
-
         # Setup Safe creation return
         mock_create_tx = MagicMock()
         # Valid Checksum Address - New Safe (Matches Pydantic output)
         mock_create_tx.contract_address = "0xbEC49fa140ACaa83533f900357DCD37866d50618"
-        mock_create_tx.tx_hash.hex.return_value = "0xTxHash"
+        mock_create_tx.tx_hash.hex.return_value = "TxHash"
 
         mock_safe.create.return_value = mock_create_tx
 
@@ -72,7 +70,7 @@ def mock_dependencies():
         mock_deploy_tx = MagicMock()
         # Valid checksum address - Salted Safe
         mock_deploy_tx.contract_address = "0xDAFEA492D9c6733ae3d56b7Ed1ADB60692c98Bc5"
-        mock_deploy_tx.tx_hash.hex.return_value = "0xTxHashSalted"
+        mock_deploy_tx.tx_hash.hex.return_value = "TxHashSalted"
 
         mock_proxy_factory.return_value.deploy_proxy_contract_with_nonce.return_value = (
             mock_deploy_tx
@@ -104,7 +102,6 @@ def mock_dependencies():
             "client": mock_client,
             "safe": mock_safe,
             "proxy_factory": mock_proxy_factory,
-            "secrets": mock_secrets,
             "log": mock_log,
             "master": mock_master,
             "factory": mock_factory,

tests/test_service_transaction.py

@@ -17,6 +17,10 @@ def mock_chain_interfaces():
         gnosis_interface.chain = mock_chain
         gnosis_interface.web3 = MagicMock()
         instance.get.return_value = gnosis_interface
+
+        # Mock with_retry to execute the operation
+        gnosis_interface.with_retry.side_effect = lambda op, **kwargs: op()
+
         yield instance
 
 
@@ -115,8 +119,8 @@ def test_sign_and_send_max_retries_exhausted(
     # Should fail after max retries
     assert success is False
     assert receipt == {}  # Returns empty dict on failure
-    # Should have tried 3 times (max_retries)
-    assert chain_interface.web3.eth.send_raw_transaction.call_count == 3
+    # Should have tried 10 times (max_retries)
+    assert chain_interface.web3.eth.send_raw_transaction.call_count == 10
 
 
 def test_sign_and_send_transaction_reverted(
@@ -170,7 +174,8 @@ def test_sign_and_send_signer_not_found(
     # Signing raises ValueError for unknown account
     mock_key_storage.sign_transaction.side_effect = ValueError("Account not found")
 
-    success, receipt = transaction_service.sign_and_send(tx, "unknown_signer")
+    with patch("time.sleep"):  # Avoid real retry delays
+        success, receipt = transaction_service.sign_and_send(tx, "unknown_signer")
 
     assert success is False
     assert receipt == {}  # Returns empty dict on failure

tests/test_staking_router.py

@@ -19,10 +19,13 @@ def test_check_availability_exception():
     """Test _check_availability handles contract call failures."""
     from iwa.web.routers.olas.staking import _check_availability
 
-    mock_w3 = MagicMock()
-    mock_w3.eth.contract.side_effect = Exception("Contract error")
+    mock_interface = MagicMock()
+    mock_interface.chain.name = "gnosis"
+
+    with patch("iwa.plugins.olas.contracts.staking.StakingContract") as mock_contract_cls:
+        mock_contract_cls.side_effect = Exception("Contract error")
+        result = _check_availability("Test", "0xAddr", mock_interface)
 
-    result = _check_availability("Test", "0xAddr", mock_w3, [])
     assert result["name"] == "Test"
     assert result["usage"] is None
 

tests/test_transaction_service.py

@@ -55,6 +55,10 @@ def mock_chain_interfaces():
         gnosis_interface.web3.eth.wait_for_transaction_receipt.return_value = mock_receipt
 
         instance.get.return_value = gnosis_interface
+
+        # Mock with_retry to execute the operation
+        gnosis_interface.with_retry.side_effect = lambda op, **kwargs: op()
+
         yield instance
 
 

tools/create_and_stake_service.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Create a service with correct bond and stake it in Expert 7 MM contract.
+
+This script demonstrates the minimum steps to:
+1. Get the required bond amount from the staking contract
+2. Create a service with that bond (NOT 1 wei)
+3. Spin up the service (activate → register → deploy)
+4. Stake the service in the staking contract
+
+IMPORTANT: The service MUST be created with the correct bond amount
+specified by the staking contract. Creating with bond=1 wei will
+cause staking to fail because the on-chain bond won't match requirements.
+"""
+
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from iwa.core.wallet import Wallet
+from iwa.plugins.olas.constants import OLAS_TRADER_STAKING_CONTRACTS
+from iwa.plugins.olas.contracts.staking import StakingContract
+from iwa.plugins.olas.service_manager import ServiceManager
+
+
+def main():
+    """Create and stake a service in Expert 7 MM contract."""
+    print("=" * 60)
+    print("  Create & Stake Service - Expert 7 MM (10k OLAS)")
+    print("=" * 60)
+
+    # 1. Initialize wallet
+    print("\n[1] Initializing Wallet...")
+    wallet = Wallet()
+    master_address = wallet.master_account.address if wallet.master_account else "N/A"
+    print(f"  OK: Master account: {master_address}")
+
+    # 2. Get the staking contract
+    print("\n[2] Loading staking contract...")
+    staking_address = OLAS_TRADER_STAKING_CONTRACTS["gnosis"]["Expert 7 MM (10k OLAS)"]
+    staking_contract = StakingContract(staking_address, chain_name="gnosis")
+    print(f"  OK: Staking contract: {staking_address}")
+
+    # 3. Get the required bond amount from the staking contract
+    print("\n[3] Getting staking requirements...")
+    requirements = staking_contract.get_requirements()
+    required_bond = requirements["required_agent_bond"]
+    min_deposit = requirements["min_staking_deposit"]
+    staking_token = str(requirements["staking_token"])
+    print(f"  - Required agent bond: {required_bond} wei")
+    print(f"  - Min staking deposit: {min_deposit} wei")
+    print(f"  - Staking token: {staking_token}")
+
+    # 4. Create service with the correct bond amount
+    print("\n[4] Creating Service with correct bond...")
+    manager = ServiceManager(wallet)
+    service_id = manager.create(
+        chain_name="gnosis",
+        service_name="staked_service_7mm",
+        token_address_or_tag=staking_token,  # Use OLAS token
+        bond_amount_wei=required_bond,  # THIS IS THE KEY: use required bond, not 1 wei
+    )
+
+    if not service_id:
+        print("  FAIL: Failed to create service")
+        return False
+
+    print(f"  OK: Service created with ID: {service_id}")
+
+    # 5. Spin up the service (activate -> register -> deploy -> stake)
+    print("\n[5] Spinning up and staking Service...")
+    success = manager.spin_up(
+        bond_amount_wei=required_bond,
+        staking_contract=staking_contract,  # spin_up handles staking automatically
+    )
+    if not success:
+        print("  FAIL: Failed to spin up/stake service")
+        return False
+
+    print("  OK: Service deployed and staked!")
+    print(f"     - Agent: {manager.service.agent_address}")
+    print(f"     - Multisig: {manager.service.multisig_address}")
+
+    print("\n" + "=" * 60)
+    print("  SUCCESS: Service created and staked!")
+    print("=" * 60)
+    print(f"\nService ID: {service_id}")
+    print("Staking Contract: Expert 7 MM (10k OLAS)")
+    print(f"Contract Address: {staking_address}")
+    return True
+
+
+if __name__ == "__main__":
+    try:
+        success = main()
+        sys.exit(0 if success else 1)
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)

tools/verify_drain.py

@@ -1,14 +1,11 @@
 """Verification script for draining services."""
 
-import logging
 import subprocess  # nosec: B404
 import sys
 import time
 from typing import List
 
-# Configure logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-logger = logging.getLogger(__name__)
+from loguru import logger
 
 
 def run_command(command: List[str]):  # noqa: D103