iwa 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

iwa/plugins/olas/contracts/staking.py

@@ -495,3 +495,138 @@ class StakingContract(ContractInstance):
             tx_params={"from": from_address},
         )
         return tx
+
+    def _fetch_events_chunked(
+        self,
+        event_type: str,
+        from_block: int,
+        to_block: int,
+        chunk_size: int = 500,
+    ) -> List:
+        """Fetch events in chunks to handle RPC block range limits.
+
+        Args:
+            event_type: Name of the event (Checkpoint, ServiceInactivityWarning, etc.)
+            from_block: Starting block number.
+            to_block: Ending block number.
+            chunk_size: Max blocks per request (default 500).
+
+        Returns:
+            List of event log entries.
+
+        """
+        all_logs: List = []
+        current_from = from_block
+
+        event = getattr(self.contract.events, event_type, None)
+        if event is None:
+            logger.debug(f"Event {event_type} not found in contract ABI")
+            return []
+
+        while current_from <= to_block:
+            current_to = min(current_from + chunk_size - 1, to_block)
+
+            try:
+                event_filter = event.create_filter(
+                    from_block=current_from, to_block=current_to
+                )
+                logs = event_filter.get_all_entries()
+                all_logs.extend(logs)
+            except Exception as e:
+                error_msg = str(e).lower()
+                # If range too large, try smaller chunks
+                if "range" in error_msg or "limit" in error_msg or "10000" in error_msg:
+                    if chunk_size > 100:
+                        logger.debug(
+                            "Block range too large, retrying with smaller chunks"
+                        )
+                        smaller_logs = self._fetch_events_chunked(
+                            event_type, current_from, current_to, chunk_size // 2
+                        )
+                        all_logs.extend(smaller_logs)
+                    else:
+                        logger.warning(
+                            f"Cannot fetch {event_type} events for blocks "
+                            f"{current_from}-{current_to}: {e}"
+                        )
+                else:
+                    logger.debug(f"Error fetching {event_type} events: {e}")
+
+            current_from = current_to + 1
+
+        return all_logs
+
+    def get_checkpoint_events(
+        self, from_block: int, to_block: Optional[int] = None
+    ) -> Dict:
+        """Get checkpoint-related events from a block range.
+
+        Retrieves Checkpoint, ServiceInactivityWarning, and ServicesEvicted events
+        to determine which services received rewards and which got warnings.
+
+        Uses chunked fetching to handle RPCs that limit block ranges.
+
+        Args:
+            from_block: Starting block number.
+            to_block: Ending block number (defaults to latest).
+
+        Returns:
+            Dict with:
+                - epoch: int, the new epoch number
+                - rewarded_services: Dict[int, int] mapping service_id -> reward (wei)
+                - inactivity_warnings: List[int] of service IDs with warnings
+                - evicted_services: List[int] of evicted service IDs
+                - checkpoint_block: int, block where checkpoint occurred
+
+        """
+        if to_block is None:
+            to_block = self.chain_interface.web3.eth.block_number
+
+        result: Dict = {
+            "epoch": None,
+            "rewarded_services": {},
+            "inactivity_warnings": [],
+            "evicted_services": [],
+            "checkpoint_block": None,
+        }
+
+        try:
+            # Get Checkpoint events
+            checkpoint_logs = self._fetch_events_chunked(
+                "Checkpoint", from_block, to_block
+            )
+
+            if checkpoint_logs:
+                # Take the most recent checkpoint
+                latest = checkpoint_logs[-1]
+                result["epoch"] = latest.args.get("epoch")
+                result["checkpoint_block"] = latest.blockNumber
+
+                # Parse serviceIds and rewards arrays
+                service_ids = latest.args.get("serviceIds", [])
+                rewards = latest.args.get("rewards", [])
+
+                for sid, reward in zip(service_ids, rewards, strict=True):
+                    result["rewarded_services"][sid] = reward
+
+            # Get ServiceInactivityWarning events
+            warning_logs = self._fetch_events_chunked(
+                "ServiceInactivityWarning", from_block, to_block
+            )
+            for log in warning_logs:
+                service_id = log.args.get("serviceId")
+                if service_id is not None:
+                    result["inactivity_warnings"].append(service_id)
+
+            # Get ServicesEvicted events
+            evicted_logs = self._fetch_events_chunked(
+                "ServicesEvicted", from_block, to_block
+            )
+            for log in evicted_logs:
+                evicted_ids = log.args.get("serviceIds", [])
+                result["evicted_services"].extend(evicted_ids)
+
+        except Exception as e:
+            logger.error(f"Error fetching checkpoint events: {e}")
+
+        return result

iwa/plugins/olas/tests/test_staking_integration.py

@@ -271,3 +271,503 @@ def test_staking_contract(tmp_path):  # noqa: C901
                 # Verify new nonces fields
                 assert info["current_safe_nonce"] == 5
                 assert info["current_mech_requests"] == 3
+
+
+def test_get_checkpoint_events():
+    """Test get_checkpoint_events method."""
+    with patch("builtins.open", side_effect=side_effect_open):
+        with patch("iwa.core.contracts.contract.ChainInterfaces") as mock_interfaces:
+            mock_chain = MagicMock()
+            mock_interfaces.return_value.get.return_value = mock_chain
+
+            mock_web3 = MagicMock()
+            mock_chain.web3 = mock_web3
+            mock_chain.web3._web3 = mock_web3
+            mock_web3.eth.block_number = 1000
+
+            mock_contract = MagicMock()
+            mock_web3.eth.contract.return_value = mock_contract
+
+            # Mock ActivityChecker calls
+            mock_contract.functions.agentMech.return_value.call.return_value = VALID_ADDR_2
+            mock_contract.functions.livenessRatio.return_value.call.return_value = 10**18
+
+            with patch(
+                "iwa.plugins.olas.contracts.staking.ContractInstance.call"
+            ) as mock_call_base:
+
+                def init_side_effect(method, *args):
+                    if method == "activityChecker":
+                        return VALID_ADDR_4
+                    if method == "stakingToken":
+                        return VALID_ADDR_2
+                    return 0
+
+                mock_call_base.side_effect = init_side_effect
+
+                staking = StakingContract(VALID_ADDR_1)
+
+                # Test 1: Checkpoint event with rewarded services
+                mock_checkpoint_log = MagicMock()
+                mock_checkpoint_log.args = {
+                    "epoch": 42,
+                    "serviceIds": [101, 102, 103],
+                    "rewards": [1000, 2000, 3000],
+                }
+                mock_checkpoint_log.blockNumber = 999
+
+                mock_checkpoint_filter = MagicMock()
+                mock_checkpoint_filter.get_all_entries.return_value = [mock_checkpoint_log]
+                mock_contract.events.Checkpoint.create_filter.return_value = (
+                    mock_checkpoint_filter
+                )
+
+                # No warnings or evictions
+                mock_warning_filter = MagicMock()
+                mock_warning_filter.get_all_entries.return_value = []
+                mock_contract.events.ServiceInactivityWarning.create_filter.return_value = (
+                    mock_warning_filter
+                )
+
+                mock_evicted_filter = MagicMock()
+                mock_evicted_filter.get_all_entries.return_value = []
+                mock_contract.events.ServicesEvicted.create_filter.return_value = (
+                    mock_evicted_filter
+                )
+
+                result = staking.get_checkpoint_events(from_block=900, to_block=1000)
+
+                assert result["epoch"] == 42
+                assert result["checkpoint_block"] == 999
+                assert result["rewarded_services"] == {101: 1000, 102: 2000, 103: 3000}
+                assert result["inactivity_warnings"] == []
+                assert result["evicted_services"] == []
+
+
+def test_get_checkpoint_events_with_warnings():
+    """Test get_checkpoint_events with inactivity warnings."""
+    with patch("builtins.open", side_effect=side_effect_open):
+        with patch("iwa.core.contracts.contract.ChainInterfaces") as mock_interfaces:
+            mock_chain = MagicMock()
+            mock_interfaces.return_value.get.return_value = mock_chain
+
+            mock_web3 = MagicMock()
+            mock_chain.web3 = mock_web3
+            mock_chain.web3._web3 = mock_web3
+            mock_web3.eth.block_number = 1000
+
+            mock_contract = MagicMock()
+            mock_web3.eth.contract.return_value = mock_contract
+
+            mock_contract.functions.agentMech.return_value.call.return_value = VALID_ADDR_2
+            mock_contract.functions.livenessRatio.return_value.call.return_value = 10**18
+
+            with patch(
+                "iwa.plugins.olas.contracts.staking.ContractInstance.call"
+            ) as mock_call_base:
+
+                def init_side_effect(method, *args):
+                    if method == "activityChecker":
+                        return VALID_ADDR_4
+                    if method == "stakingToken":
+                        return VALID_ADDR_2
+                    return 0
+
+                mock_call_base.side_effect = init_side_effect
+
+                staking = StakingContract(VALID_ADDR_1)
+
+                # Checkpoint event
+                mock_checkpoint_log = MagicMock()
+                mock_checkpoint_log.args = {
+                    "epoch": 10,
+                    "serviceIds": [101, 102],
+                    "rewards": [1000, 2000],
+                }
+                mock_checkpoint_log.blockNumber = 999
+
+                mock_checkpoint_filter = MagicMock()
+                mock_checkpoint_filter.get_all_entries.return_value = [mock_checkpoint_log]
+                mock_contract.events.Checkpoint.create_filter.return_value = (
+                    mock_checkpoint_filter
+                )
+
+                # Inactivity warnings
+                mock_warning_log_1 = MagicMock()
+                mock_warning_log_1.args = {"serviceId": 101}
+                mock_warning_log_2 = MagicMock()
+                mock_warning_log_2.args = {"serviceId": 103}
+
+                mock_warning_filter = MagicMock()
+                mock_warning_filter.get_all_entries.return_value = [
+                    mock_warning_log_1,
+                    mock_warning_log_2,
+                ]
+                mock_contract.events.ServiceInactivityWarning.create_filter.return_value = (
+                    mock_warning_filter
+                )
+
+                mock_evicted_filter = MagicMock()
+                mock_evicted_filter.get_all_entries.return_value = []
+                mock_contract.events.ServicesEvicted.create_filter.return_value = (
+                    mock_evicted_filter
+                )
+
+                result = staking.get_checkpoint_events(from_block=900)
+
+                assert result["epoch"] == 10
+                assert result["inactivity_warnings"] == [101, 103]
+                assert result["evicted_services"] == []
+
+
+def test_get_checkpoint_events_with_evictions():
+    """Test get_checkpoint_events with evicted services."""
+    with patch("builtins.open", side_effect=side_effect_open):
+        with patch("iwa.core.contracts.contract.ChainInterfaces") as mock_interfaces:
+            mock_chain = MagicMock()
+            mock_interfaces.return_value.get.return_value = mock_chain
+
+            mock_web3 = MagicMock()
+            mock_chain.web3 = mock_web3
+            mock_chain.web3._web3 = mock_web3
+            mock_web3.eth.block_number = 1000
+
+            mock_contract = MagicMock()
+            mock_web3.eth.contract.return_value = mock_contract
+
+            mock_contract.functions.agentMech.return_value.call.return_value = VALID_ADDR_2
+            mock_contract.functions.livenessRatio.return_value.call.return_value = 10**18
+
+            with patch(
+                "iwa.plugins.olas.contracts.staking.ContractInstance.call"
+            ) as mock_call_base:
+
+                def init_side_effect(method, *args):
+                    if method == "activityChecker":
+                        return VALID_ADDR_4
+                    if method == "stakingToken":
+                        return VALID_ADDR_2
+                    return 0
+
+                mock_call_base.side_effect = init_side_effect
+
+                staking = StakingContract(VALID_ADDR_1)
+
+                # Checkpoint event
+                mock_checkpoint_log = MagicMock()
+                mock_checkpoint_log.args = {
+                    "epoch": 5,
+                    "serviceIds": [102],
+                    "rewards": [5000],
+                }
+                mock_checkpoint_log.blockNumber = 888
+
+                mock_checkpoint_filter = MagicMock()
+                mock_checkpoint_filter.get_all_entries.return_value = [mock_checkpoint_log]
+                mock_contract.events.Checkpoint.create_filter.return_value = (
+                    mock_checkpoint_filter
+                )
+
+                # No warnings
+                mock_warning_filter = MagicMock()
+                mock_warning_filter.get_all_entries.return_value = []
+                mock_contract.events.ServiceInactivityWarning.create_filter.return_value = (
+                    mock_warning_filter
+                )
+
+                # Evictions
+                mock_evicted_log = MagicMock()
+                mock_evicted_log.args = {"serviceIds": [101, 104]}
+
+                mock_evicted_filter = MagicMock()
+                mock_evicted_filter.get_all_entries.return_value = [mock_evicted_log]
+                mock_contract.events.ServicesEvicted.create_filter.return_value = (
+                    mock_evicted_filter
+                )
+
+                result = staking.get_checkpoint_events(from_block=800)
+
+                assert result["epoch"] == 5
+                assert result["checkpoint_block"] == 888
+                assert result["rewarded_services"] == {102: 5000}
+                assert result["evicted_services"] == [101, 104]
+
+
+def test_get_checkpoint_events_no_events():
+    """Test get_checkpoint_events when no checkpoint events found."""
+    with patch("builtins.open", side_effect=side_effect_open):
+        with patch("iwa.core.contracts.contract.ChainInterfaces") as mock_interfaces:
+            mock_chain = MagicMock()
+            mock_interfaces.return_value.get.return_value = mock_chain
+
+            mock_web3 = MagicMock()
+            mock_chain.web3 = mock_web3
+            mock_chain.web3._web3 = mock_web3
+            mock_web3.eth.block_number = 1000
+
+            mock_contract = MagicMock()
+            mock_web3.eth.contract.return_value = mock_contract
+
+            mock_contract.functions.agentMech.return_value.call.return_value = VALID_ADDR_2
+            mock_contract.functions.livenessRatio.return_value.call.return_value = 10**18
+
+            with patch(
+                "iwa.plugins.olas.contracts.staking.ContractInstance.call"
+            ) as mock_call_base:
+
+                def init_side_effect(method, *args):
+                    if method == "activityChecker":
+                        return VALID_ADDR_4
+                    if method == "stakingToken":
+                        return VALID_ADDR_2
+                    return 0
+
+                mock_call_base.side_effect = init_side_effect
+
+                staking = StakingContract(VALID_ADDR_1)
+
+                # No checkpoint events
+                mock_checkpoint_filter = MagicMock()
+                mock_checkpoint_filter.get_all_entries.return_value = []
+                mock_contract.events.Checkpoint.create_filter.return_value = (
+                    mock_checkpoint_filter
+                )
+
+                mock_warning_filter = MagicMock()
+                mock_warning_filter.get_all_entries.return_value = []
+                mock_contract.events.ServiceInactivityWarning.create_filter.return_value = (
+                    mock_warning_filter
+                )
+
+                mock_evicted_filter = MagicMock()
+                mock_evicted_filter.get_all_entries.return_value = []
+                mock_contract.events.ServicesEvicted.create_filter.return_value = (
+                    mock_evicted_filter
+                )
+
+                result = staking.get_checkpoint_events(from_block=900)
+
+                assert result["epoch"] is None
+                assert result["checkpoint_block"] is None
+                assert result["rewarded_services"] == {}
+                assert result["inactivity_warnings"] == []
+                assert result["evicted_services"] == []
+
+
+def test_get_checkpoint_events_handles_exceptions():
+    """Test get_checkpoint_events handles exceptions gracefully."""
+    with patch("builtins.open", side_effect=side_effect_open):
+        with patch("iwa.core.contracts.contract.ChainInterfaces") as mock_interfaces:
+            mock_chain = MagicMock()
+            mock_interfaces.return_value.get.return_value = mock_chain
+
+            mock_web3 = MagicMock()
+            mock_chain.web3 = mock_web3
+            mock_chain.web3._web3 = mock_web3
+            mock_web3.eth.block_number = 1000
+
+            mock_contract = MagicMock()
+            mock_web3.eth.contract.return_value = mock_contract
+
+            mock_contract.functions.agentMech.return_value.call.return_value = VALID_ADDR_2
+            mock_contract.functions.livenessRatio.return_value.call.return_value = 10**18
+
+            with patch(
+                "iwa.plugins.olas.contracts.staking.ContractInstance.call"
+            ) as mock_call_base:
+
+                def init_side_effect(method, *args):
+                    if method == "activityChecker":
+                        return VALID_ADDR_4
+                    if method == "stakingToken":
+                        return VALID_ADDR_2
+                    return 0
+
+                mock_call_base.side_effect = init_side_effect
+
+                staking = StakingContract(VALID_ADDR_1)
+
+                # Checkpoint filter raises an exception
+                mock_contract.events.Checkpoint.create_filter.side_effect = Exception(
+                    "RPC error"
+                )
+
+                result = staking.get_checkpoint_events(from_block=900)
+
+                # Should return default empty result
+                assert result["epoch"] is None
+                assert result["rewarded_services"] == {}
+                assert result["inactivity_warnings"] == []
+                assert result["evicted_services"] == []
+
+
+def test_fetch_events_chunked_splits_large_range():
+    """Test that _fetch_events_chunked splits large block ranges into chunks."""
+    with patch("builtins.open", side_effect=side_effect_open):
+        with patch("iwa.core.contracts.contract.ChainInterfaces") as mock_interfaces:
+            mock_chain = MagicMock()
+            mock_interfaces.return_value.get.return_value = mock_chain
+
+            mock_web3 = MagicMock()
+            mock_chain.web3 = mock_web3
+            mock_chain.web3._web3 = mock_web3
+            mock_web3.eth.block_number = 2000
+
+            mock_contract = MagicMock()
+            mock_web3.eth.contract.return_value = mock_contract
+
+            mock_contract.functions.agentMech.return_value.call.return_value = VALID_ADDR_2
+            mock_contract.functions.livenessRatio.return_value.call.return_value = 10**18
+
+            with patch(
+                "iwa.plugins.olas.contracts.staking.ContractInstance.call"
+            ) as mock_call_base:
+
+                def init_side_effect(method, *args):
+                    if method == "activityChecker":
+                        return VALID_ADDR_4
+                    if method == "stakingToken":
+                        return VALID_ADDR_2
+                    return 0
+
+                mock_call_base.side_effect = init_side_effect
+
+                staking = StakingContract(VALID_ADDR_1)
+
+                # Track calls to create_filter
+                call_ranges = []
+
+                def track_filter_calls(from_block, to_block):
+                    call_ranges.append((from_block, to_block))
+                    mock_filter = MagicMock()
+                    mock_filter.get_all_entries.return_value = []
+                    return mock_filter
+
+                mock_contract.events.Checkpoint.create_filter.side_effect = (
+                    track_filter_calls
+                )
+
+                # Fetch 1200 blocks with chunk_size=500 -> should make 3 calls
+                staking._fetch_events_chunked("Checkpoint", 0, 1199, chunk_size=500)
+
+                assert len(call_ranges) == 3
+                assert call_ranges[0] == (0, 499)
+                assert call_ranges[1] == (500, 999)
+                assert call_ranges[2] == (1000, 1199)
+
+
+def test_fetch_events_chunked_retries_with_smaller_chunks():
+    """Test that _fetch_events_chunked retries with smaller chunks on range error."""
+    with patch("builtins.open", side_effect=side_effect_open):
+        with patch("iwa.core.contracts.contract.ChainInterfaces") as mock_interfaces:
+            mock_chain = MagicMock()
+            mock_interfaces.return_value.get.return_value = mock_chain
+
+            mock_web3 = MagicMock()
+            mock_chain.web3 = mock_web3
+            mock_chain.web3._web3 = mock_web3
+            mock_web3.eth.block_number = 1000
+
+            mock_contract = MagicMock()
+            mock_web3.eth.contract.return_value = mock_contract
+
+            mock_contract.functions.agentMech.return_value.call.return_value = VALID_ADDR_2
+            mock_contract.functions.livenessRatio.return_value.call.return_value = 10**18
+
+            with patch(
+                "iwa.plugins.olas.contracts.staking.ContractInstance.call"
+            ) as mock_call_base:
+
+                def init_side_effect(method, *args):
+                    if method == "activityChecker":
+                        return VALID_ADDR_4
+                    if method == "stakingToken":
+                        return VALID_ADDR_2
+                    return 0
+
+                mock_call_base.side_effect = init_side_effect
+
+                staking = StakingContract(VALID_ADDR_1)
+
+                call_count = [0]
+
+                def fail_then_succeed(from_block, to_block):
+                    call_count[0] += 1
+                    # First call fails with range error, subsequent calls succeed
+                    if call_count[0] == 1:
+                        raise Exception("block range too large")
+                    mock_filter = MagicMock()
+                    mock_filter.get_all_entries.return_value = []
+                    return mock_filter
+
+                mock_contract.events.Checkpoint.create_filter.side_effect = (
+                    fail_then_succeed
+                )
+
+                # Should retry with smaller chunks
+                result = staking._fetch_events_chunked(
+                    "Checkpoint", 0, 499, chunk_size=500
+                )
+
+                # First call fails, then retries with chunk_size=250 (2 calls)
+                assert call_count[0] >= 2
+                assert result == []
+
+
+def test_fetch_events_chunked_aggregates_results():
+    """Test that _fetch_events_chunked aggregates events from all chunks."""
+    with patch("builtins.open", side_effect=side_effect_open):
+        with patch("iwa.core.contracts.contract.ChainInterfaces") as mock_interfaces:
+            mock_chain = MagicMock()
+            mock_interfaces.return_value.get.return_value = mock_chain
+
+            mock_web3 = MagicMock()
+            mock_chain.web3 = mock_web3
+            mock_chain.web3._web3 = mock_web3
+            mock_web3.eth.block_number = 1000
+
+            mock_contract = MagicMock()
+            mock_web3.eth.contract.return_value = mock_contract
+
+            mock_contract.functions.agentMech.return_value.call.return_value = VALID_ADDR_2
+            mock_contract.functions.livenessRatio.return_value.call.return_value = 10**18
+
+            with patch(
+                "iwa.plugins.olas.contracts.staking.ContractInstance.call"
+            ) as mock_call_base:
+
+                def init_side_effect(method, *args):
+                    if method == "activityChecker":
+                        return VALID_ADDR_4
+                    if method == "stakingToken":
+                        return VALID_ADDR_2
+                    return 0
+
+                mock_call_base.side_effect = init_side_effect
+
+                staking = StakingContract(VALID_ADDR_1)
+
+                chunk_num = [0]
+
+                def return_different_events(from_block, to_block):
+                    chunk_num[0] += 1
+                    mock_filter = MagicMock()
+                    # Each chunk returns a different event
+                    event = MagicMock()
+                    event.args = {"serviceId": 100 + chunk_num[0]}
+                    mock_filter.get_all_entries.return_value = [event]
+                    return mock_filter
+
+                mock_contract.events.ServiceInactivityWarning.create_filter.side_effect = (
+                    return_different_events
+                )
+
+                # Fetch 600 blocks with chunk_size=200 -> 3 chunks
+                result = staking._fetch_events_chunked(
+                    "ServiceInactivityWarning", 0, 599, chunk_size=200
+                )
+
+                # Should have 3 events aggregated
+                assert len(result) == 3
+                service_ids = [e.args["serviceId"] for e in result]
+                assert service_ids == [101, 102, 103]

iwa/web/dependencies.py

@@ -9,8 +9,42 @@ from loguru import logger
 
 from iwa.core.wallet import Wallet
 
-# Singleton wallet instance for the web app
-wallet = Wallet()
+# Singleton wallet instance (lazy-initialized or injected)
+_wallet: Optional[Wallet] = None
+
+
+def get_wallet() -> Wallet:
+    """Get the wallet instance (lazy initialization or injected).
+
+    Returns the injected wallet if set_wallet() was called,
+    otherwise creates a new Wallet on first access.
+    """
+    global _wallet
+    if _wallet is None:
+        _wallet = Wallet()
+    return _wallet
+
+
+def set_wallet(wallet: Wallet) -> None:
+    """Inject an external wallet instance.
+
+    Call this BEFORE importing routers to share a wallet
+    with an external application (e.g., Triton).
+    """
+    global _wallet
+    _wallet = wallet
+
+
+# Backwards compatibility: module-level wallet property
+# Deprecated: use get_wallet() instead
+class _WalletProxy:
+    """Proxy that redirects to get_wallet() for backwards compatibility."""
+
+    def __getattr__(self, name: str):
+        return getattr(get_wallet(), name)
+
+
+wallet = _WalletProxy()
 
 # Authentication
 api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)

iwa/web/server.py

@@ -147,11 +147,28 @@ async def root():
 
 
 def run_server(host: str = "127.0.0.1", port: int = 8000):
-    """Run the web server using uvicorn."""
+    """Run the web server using uvicorn (blocking)."""
     import uvicorn
 
     uvicorn.run(app, host=host, port=port)
 
 
+async def run_server_async(host: str = "127.0.0.1", port: int = 8000):
+    """Run the web server in an async context (non-blocking).
+
+    Use this to embed the web server in another async application.
+    The server runs until cancelled.
+
+    Args:
+        host: Bind address. Default "127.0.0.1" (localhost only for security).
+        port: Port number. Default 8000.
+    """
+    import uvicorn
+
+    config = uvicorn.Config(app, host=host, port=port, log_level="warning")
+    server = uvicorn.Server(config)
+    await server.serve()
+
+
 if __name__ == "__main__":
     run_server()

iwa/web/tests/test_wallet_injection.py

@@ -0,0 +1,204 @@
+"""Tests for wallet injection in web dependencies."""
+
+from unittest.mock import MagicMock, patch
+
+
+class TestWalletInjection:
+    """Tests for get_wallet, set_wallet, and _WalletProxy."""
+
+    def setup_method(self):
+        """Reset the global wallet state before each test."""
+        # Import fresh to reset state
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+    def test_get_wallet_lazy_initialization(self):
+        """get_wallet() creates a Wallet on first call if none injected."""
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+        with patch.object(deps, "Wallet") as mock_wallet_cls:
+            mock_wallet_cls.return_value = MagicMock(name="LazyWallet")
+
+            result = deps.get_wallet()
+
+            mock_wallet_cls.assert_called_once()
+            assert result == mock_wallet_cls.return_value
+
+    def test_get_wallet_returns_same_instance(self):
+        """get_wallet() returns the same instance on subsequent calls."""
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+        with patch.object(deps, "Wallet") as mock_wallet_cls:
+            mock_wallet_cls.return_value = MagicMock(name="SingletonWallet")
+
+            first = deps.get_wallet()
+            second = deps.get_wallet()
+
+            # Should only create once
+            mock_wallet_cls.assert_called_once()
+            assert first is second
+
+    def test_set_wallet_injects_external_wallet(self):
+        """set_wallet() allows injecting an external wallet instance."""
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+        external_wallet = MagicMock(name="ExternalWallet")
+        deps.set_wallet(external_wallet)
+
+        result = deps.get_wallet()
+
+        assert result is external_wallet
+
+    def test_set_wallet_prevents_lazy_init(self):
+        """set_wallet() prevents Wallet() from being called."""
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+        with patch.object(deps, "Wallet") as mock_wallet_cls:
+            external_wallet = MagicMock(name="InjectedWallet")
+            deps.set_wallet(external_wallet)
+
+            result = deps.get_wallet()
+
+            # Wallet() should NOT be called
+            mock_wallet_cls.assert_not_called()
+            assert result is external_wallet
+
+    def test_set_wallet_overrides_existing(self):
+        """set_wallet() can override a previously set wallet."""
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+        wallet1 = MagicMock(name="Wallet1")
+        wallet2 = MagicMock(name="Wallet2")
+
+        deps.set_wallet(wallet1)
+        assert deps.get_wallet() is wallet1
+
+        deps.set_wallet(wallet2)
+        assert deps.get_wallet() is wallet2
+
+
+class TestWalletProxy:
+    """Tests for _WalletProxy backwards compatibility."""
+
+    def setup_method(self):
+        """Reset the global wallet state before each test."""
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+    def test_wallet_proxy_forwards_attribute_access(self):
+        """wallet.attribute forwards to get_wallet().attribute."""
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+        mock_wallet = MagicMock()
+        mock_wallet.balance_service = MagicMock(name="BalanceService")
+        deps.set_wallet(mock_wallet)
+
+        # Access through the proxy
+        result = deps.wallet.balance_service
+
+        assert result is mock_wallet.balance_service
+
+    def test_wallet_proxy_forwards_method_calls(self):
+        """wallet.method() forwards to get_wallet().method()."""
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+        mock_wallet = MagicMock()
+        mock_wallet.get_accounts_balances.return_value = ({"0x1": {}}, {"0x1": {}})
+        deps.set_wallet(mock_wallet)
+
+        # Call method through proxy
+        result = deps.wallet.get_accounts_balances("gnosis", ["native"])
+
+        mock_wallet.get_accounts_balances.assert_called_once_with("gnosis", ["native"])
+        assert result == ({"0x1": {}}, {"0x1": {}})
+
+    def test_wallet_proxy_triggers_lazy_init(self):
+        """Accessing wallet.attr when no wallet set triggers lazy init."""
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+        with patch.object(deps, "Wallet") as mock_wallet_cls:
+            mock_instance = MagicMock()
+            mock_instance.key_storage = MagicMock(name="KeyStorage")
+            mock_wallet_cls.return_value = mock_instance
+
+            # Access through proxy should trigger lazy init
+            result = deps.wallet.key_storage
+
+            mock_wallet_cls.assert_called_once()
+            assert result is mock_instance.key_storage
+
+
+class TestIntegrationWithRouters:
+    """Integration tests for wallet injection with routers."""
+
+    def setup_method(self):
+        """Reset the global wallet state before each test."""
+        import iwa.web.dependencies as deps
+
+        deps._wallet = None
+
+    def test_injected_wallet_used_by_routers(self):
+        """Routers using 'wallet' get the injected instance."""
+        import iwa.web.dependencies as deps
+
+        # Inject a mock wallet BEFORE routers access it
+        mock_wallet = MagicMock()
+        mock_wallet.key_storage = MagicMock()
+        mock_wallet.key_storage.accounts = {}
+        deps.set_wallet(mock_wallet)
+
+        # Simulate what a router does
+        from iwa.web.dependencies import wallet
+
+        # Access through the module-level wallet (proxy)
+        accounts = wallet.key_storage.accounts
+
+        assert accounts == {}
+        # Verify it's using our injected wallet
+        assert deps.get_wallet() is mock_wallet
+
+
+class TestServerAsync:
+    """Tests for run_server_async function."""
+
+    def test_run_server_async_source_has_localhost_default(self):
+        """run_server_async defaults to localhost for security (source check)."""
+        import pathlib
+
+        # Read the source file directly to verify default
+        server_path = pathlib.Path(__file__).parent.parent / "server.py"
+        source = server_path.read_text()
+
+        # Verify the function signature has localhost default
+        assert 'async def run_server_async(host: str = "127.0.0.1"' in source
+
+    def test_run_server_source_has_async_function(self):
+        """run_server_async function exists in server.py source."""
+        import pathlib
+
+        server_path = pathlib.Path(__file__).parent.parent / "server.py"
+        source = server_path.read_text()
+
+        # Verify the async function exists
+        assert "async def run_server_async" in source
+        assert "uvicorn.Config" in source
+        assert "uvicorn.Server" in source
+        assert "await server.serve()" in source

{iwa-0.1.2.dist-info → iwa-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.1.2
+Version: 0.1.4
 Summary: A secure, modular, and plugin-based framework for crypto agents and ops
 Requires-Python: <4.0,>=3.12
 Description-Content-Type: text/markdown

{iwa-0.1.2.dist-info → iwa-0.1.4.dist-info}/RECORD

@@ -78,7 +78,7 @@ iwa/plugins/olas/contracts/mech.py,sha256=dXYtyORc-oiu9ga5PtTquOFkoakb6BLGKvlUst
 iwa/plugins/olas/contracts/mech_marketplace.py,sha256=hMADl5MQGvT2wLRKu4vHGe4RrAZVq8Y2M_EvXWWz528,1554
 iwa/plugins/olas/contracts/mech_marketplace_v1.py,sha256=ooF5uw1wxwYsoriGUGGxXxmaD8DtWZtK4TJBCUNTGtI,2501
 iwa/plugins/olas/contracts/service.py,sha256=BDQKeCTCnBNrwKD1a8rrlLytpKG3CAdjr-s0ec-dsFY,8243
-iwa/plugins/olas/contracts/staking.py,sha256=kKF4Uc2cFr9_drKG5OzFgzKTdgGyHIM_PUa-L0LX9gU,18486
+iwa/plugins/olas/contracts/staking.py,sha256=Qkr6yS3an-yZe560Dwer_g1wyOL3e1VIAGaeSZLCgfs,23512
 iwa/plugins/olas/contracts/abis/activity_checker.json,sha256=HT0IMbyTLMO71ITBKwoS950rHe772suPP4b8eDAodJ0,2230
 iwa/plugins/olas/contracts/abis/mech.json,sha256=bMMCXInjE_2PTPnc_sIyS_H8pod5Sm_e-xTbKgZppKc,16369
 iwa/plugins/olas/contracts/abis/mech_marketplace.json,sha256=KPnF-H_UATb3wdb_7o6ky_hSp5xwgvckD-QqylsWJLg,32468
@@ -118,7 +118,7 @@ iwa/plugins/olas/tests/test_service_manager_mech.py,sha256=qG6qu5IPRNypXUsblU2OE
 iwa/plugins/olas/tests/test_service_manager_rewards.py,sha256=2YCrXBU5bEkPuhBoGBhjnO1nA2qwHxn5Ivrror18FHM,12248
 iwa/plugins/olas/tests/test_service_manager_validation.py,sha256=ajlfH5uc4mAHf8A7GLE5cW7X8utM2vUilM0JdGDdlVg,5382
 iwa/plugins/olas/tests/test_service_staking.py,sha256=exxWsile_wG_0rz_cGbCPG-_Ubq01Ofl4D_pi0plj5Y,18332
-iwa/plugins/olas/tests/test_staking_integration.py,sha256=QCBQf6P2ZmmsEGt2k8W2r53lG2aVRuoMJE-aFxVDLss,9701
+iwa/plugins/olas/tests/test_staking_integration.py,sha256=q7zLQLrUyhtcnZf6MMymx2cX0Gmqaa7i1mRh1clnyj4,30198
 iwa/plugins/olas/tests/test_staking_validation.py,sha256=uug64jFcXYJ3Nw_lNa3O4fnhNr5wAWHHIrchSbR2MVE,4020
 iwa/plugins/olas/tui/__init__.py,sha256=5ZRsbC7J3z1xfkZRiwr4bLEklf78rNVjdswe2p7SlS8,28
 iwa/plugins/olas/tui/olas_view.py,sha256=dgZjfXCWsRRdHpygHfSOCJZFWZrgrVyieq-iYgDkK3w,37404
@@ -146,9 +146,9 @@ iwa/tui/tests/test_wallets_refactor.py,sha256=71G3HLbhTtgDy3ffVbYv0MFYRgdYd-NWGB
 iwa/tui/tests/test_widgets.py,sha256=C9UgIGeWRaQ459JygFEQx-7hOi9mWrSUDDIMZH1ge50,3994
 iwa/tui/widgets/__init__.py,sha256=UzD6nJbwv9hOtkWl9I7faXm1a-rcu4xFRxrf4KBwwY4,161
 iwa/tui/widgets/base.py,sha256=Z8FigMhsfD76PkFVERqMaotd-xwXfuFZm_8TmCMOsl4,3381
-iwa/web/dependencies.py,sha256=0_dAJlRh6gKrUDRPKUe92eshFsg572yx_H0lQgSqGDA,2103
+iwa/web/dependencies.py,sha256=iTvdCSuETFLeQPtFydi21s1EKA_a80rbA57s-994fMQ,2980
 iwa/web/models.py,sha256=MSD9WPy_Nz_amWgoo2KSDTn4ZLv_AV0o0amuNtSf-68,3035
-iwa/web/server.py,sha256=4ZLVFEKoGs_NoCcXMeyYzDNdxUXazjwHQaX7CR1pwHE,5239
+iwa/web/server.py,sha256=BcaLtmyPSsVehUtbWf4fbEGJ4E0bDlY_PzVq479HoZM,5786
 iwa/web/routers/accounts.py,sha256=VhCHrwzRWqZcSW-tTEqFWT5hFl-IYEWpqXeuN8xM3-4,3922
 iwa/web/routers/state.py,sha256=wsBAOIWZeMWjMwLiiWVhuEXHAceI0IIq6CPpmh7SbIc,2469
 iwa/web/routers/swap.py,sha256=8xycAytquR29ELxW3vx428W8s9bI_w_x2kpRhhJ0KXY,22630
@@ -162,11 +162,12 @@ iwa/web/routers/olas/staking.py,sha256=jktJ2C1Q9X4aC0tWJByN3sHpEXY0EIvr3rr4N0MtX
 iwa/web/static/app.js,sha256=VCm9zPJERb9pX6zbFQ_7D47UnztGdibrkZ1dmwhsvdc,114949
 iwa/web/static/index.html,sha256=Qg06MFK__2KxwWTr8hhjX_GwsoN53QsLCTypu4fBR-Q,28516
 iwa/web/static/style.css,sha256=7i6T96pS7gXSLDZfyp_87gRlyB9rpsFWJEHJ-dRY1ug,24371
+iwa/web/tests/test_wallet_injection.py,sha256=YjoQh1FMwroswF6O_XZOwYXzanv-JYElNTDNKxAS77g,6751
 iwa/web/tests/test_web_endpoints.py,sha256=vA25YghHNB23sbmhD4ciesn_f_okSq0tjlkrSiKZ0rs,24007
 iwa/web/tests/test_web_olas.py,sha256=GunKEAzcbzL7FoUGMtEl8wqiqwYwA5lB9sOhfCNj0TA,16312
 iwa/web/tests/test_web_swap.py,sha256=7A4gBJFL01kIXPtW1E1J17SCsVc_0DmUn-R8kKrnnVA,2974
 iwa/web/tests/test_web_swap_coverage.py,sha256=zGNrzlhZ_vWDCvWmLcoUwFgqxnrp_ACbo49AtWBS_Kw,5584
-iwa-0.1.2.dist-info/licenses/LICENSE,sha256=eIubm_IlBHPYRQlLNZKbBNKhJUUP3JH0A2miZUhAVfI,1078
+iwa-0.1.4.dist-info/licenses/LICENSE,sha256=eIubm_IlBHPYRQlLNZKbBNKhJUUP3JH0A2miZUhAVfI,1078
 tests/legacy_cow.py,sha256=oOkZvIxL70ReEoD9oHQbOD5GpjIr6AGNHcOCgfPlerU,8389
 tests/legacy_safe.py,sha256=AssM2g13E74dNGODu_H0Q0y412lgqsrYnEzI97nm_Ts,2972
 tests/legacy_transaction_retry_logic.py,sha256=D9RqZ7DBu61Xr2djBAodU2p9UE939LL-DnQXswX5iQk,1497
@@ -224,8 +225,8 @@ tests/test_utils.py,sha256=vkP49rYNI8BRzLpWR3WnKdDr8upeZjZcs7Rx0pjbQMo,1292
 tests/test_workers.py,sha256=MInwdkFY5LdmFB3o1odIaSD7AQZb3263hNafO1De5PE,2793
 tools/create_and_stake_service.py,sha256=1xwy_bJQI1j9yIQ968Oc9Db_F6mk1659LuuZntTASDE,3742
 tools/verify_drain.py,sha256=PkMjblyOOAuQge88FwfEzRtCYeEtJxXhPBmtQYCoQ-8,6743
-iwa-0.1.2.dist-info/METADATA,sha256=5YMpXIjANu_J3sb6-iP2cCGT0cFTMTVKg6qRw9RMVqg,7336
-iwa-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-iwa-0.1.2.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
-iwa-0.1.2.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
-iwa-0.1.2.dist-info/RECORD,,
+iwa-0.1.4.dist-info/METADATA,sha256=a0L36sHev8jqTBgB7MfGHSz46nAvG9J3OrkHNE1FpvM,7336
+iwa-0.1.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+iwa-0.1.4.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
+iwa-0.1.4.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
+iwa-0.1.4.dist-info/RECORD,,