iwa 0.0.0__py3-none-any.whl → 0.0.1a2__py3-none-any.whl

iwa/plugins/olas/tests/test_olas_models.py

@@ -0,0 +1,144 @@
+"""Tests for Olas models and OlasConfig."""
+
+from iwa.plugins.olas.models import OlasConfig, Service, StakingStatus
+
+
+class TestOlasConfig:
+    """Tests for OlasConfig class."""
+
+    def test_add_service(self):
+        """Test add_service adds service to dict."""
+        config = OlasConfig()
+        service = Service(
+            service_name="test",
+            chain_name="gnosis",
+            service_id=456,
+            agent_ids=[25],
+            service_owner_address="0x1234567890123456789012345678901234567890",
+        )
+
+        config.add_service(service)
+
+        assert "gnosis:456" in config.services
+        assert config.services["gnosis:456"] == service
+
+    def test_remove_service_success(self):
+        """Test remove_service removes existing service."""
+        config = OlasConfig()
+        service = Service(
+            service_name="test",
+            chain_name="gnosis",
+            service_id=789,
+            agent_ids=[25],
+            service_owner_address="0x1234567890123456789012345678901234567890",
+        )
+        config.services["gnosis:789"] = service
+
+        result = config.remove_service("gnosis:789")
+
+        assert result is True
+        assert "gnosis:789" not in config.services
+
+    def test_remove_service_not_found(self):
+        """Test remove_service returns False when not found."""
+        config = OlasConfig()
+        result = config.remove_service("gnosis:999")
+        assert result is False
+
+    def test_get_service(self):
+        """Test get_service by chain and id."""
+        config = OlasConfig()
+        service = Service(
+            service_name="test",
+            chain_name="ethereum",
+            service_id=200,
+            agent_ids=[25],
+            service_owner_address="0x1234567890123456789012345678901234567890",
+        )
+        config.services["ethereum:200"] = service
+
+        result = config.get_service("ethereum", 200)
+        assert result is not None
+        assert result.service_id == 200
+
+    def test_get_service_not_found(self):
+        """Test get_service returns None when not found."""
+        config = OlasConfig()
+        result = config.get_service("base", 999)
+        assert result is None
+
+
+class TestStakingStatus:
+    """Tests for StakingStatus model."""
+
+    def test_staking_status_defaults(self):
+        """Test StakingStatus default values."""
+        status = StakingStatus(
+            is_staked=False,
+            staking_state="NOT_STAKED",
+        )
+
+        assert status.is_staked is False
+        assert status.staking_state == "NOT_STAKED"
+        assert status.mech_requests_this_epoch == 0
+        assert status.required_mech_requests == 0
+        assert status.remaining_mech_requests == 0
+        assert status.has_enough_requests is False
+        assert status.liveness_ratio_passed is False
+        assert status.accrued_reward_wei == 0
+
+    def test_staking_status_staked(self):
+        """Test StakingStatus when staked."""
+        status = StakingStatus(
+            is_staked=True,
+            staking_state="STAKED",
+            staking_contract_address="0x389B46c259631Acd6a69Bde8B6cEe218230bAE8C",
+            mech_requests_this_epoch=5,
+            required_mech_requests=3,
+            remaining_mech_requests=0,
+            has_enough_requests=True,
+            liveness_ratio_passed=True,
+            accrued_reward_wei=1000000000000000000,
+        )
+
+        assert status.is_staked is True
+        assert status.staking_contract_address == "0x389B46c259631Acd6a69Bde8B6cEe218230bAE8C"
+        assert status.has_enough_requests is True
+
+
+class TestService:
+    """Tests for Service model."""
+
+    def test_service_key_property(self):
+        """Test Service key property generates correct key."""
+        service = Service(
+            service_name="test",
+            chain_name="gnosis",
+            service_id=123,
+            agent_ids=[25],
+            service_owner_address="0x1234567890123456789012345678901234567890",
+        )
+
+        assert service.key == "gnosis:123"
+
+    def test_service_with_optional_fields(self):
+        """Test Service with optional fields set."""
+        # Use valid Ethereum addresses (these are random but valid checksums)
+        # multisig_addr = "0x3f9Dd7c0e0D4D5f9f2F29F3f8A4c5D6e7F890123"  # Corrected invalid chars
+        staking_addr = "0x389B46c259631Acd6a69Bde8B6cEe218230bAE8C"
+        token_addr = "0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f"
+
+        service = Service(
+            service_name="test",
+            chain_name="gnosis",
+            service_id=456,
+            agent_ids=[25],
+            service_owner_address="0x1234567890123456789012345678901234567890",
+            staking_contract_address=staking_addr,
+            token_address=token_addr,
+        )
+
+        # These should be set correctly
+        assert service.staking_contract_address is not None
+        assert service.token_address is not None
+        assert service.key == "gnosis:456"

iwa/plugins/olas/tests/test_olas_view.py

@@ -0,0 +1,258 @@
+"""Tests for Olas TUI View."""
+
+from unittest.mock import patch
+
+import pytest
+from textual.app import App, ComposeResult
+from textual.widgets import Select
+
+from iwa.plugins.olas.models import StakingStatus
+from iwa.plugins.olas.tui.olas_view import OlasView
+from iwa.tui.modals.base import CreateServiceModal, FundServiceModal
+
+VALID_ADDR_1 = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+VALID_ADDR_2 = "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D"
+VALID_ADDR_3 = "0x1111111111111111111111111111111111111111"
+
+
+class OlasTestApp(App):
+    """Test app to host OlasView."""
+
+    def __init__(self, wallet=None):
+        """Initialize test app."""
+        super().__init__()
+        self.wallet = wallet
+
+    def compose(self) -> ComposeResult:
+        """Compose layout."""
+        yield OlasView(self.wallet)
+
+
+@pytest.mark.asyncio
+async def test_olas_view_initial_load(mock_wallet, mock_olas_config):
+    """Test OlasView initial loading and rendering."""
+    with patch("iwa.core.models.Config") as mock_config_cls:
+        mock_config = mock_config_cls.return_value
+        mock_config.plugins = {"olas": mock_olas_config.model_dump()}
+
+        with (
+            patch("iwa.plugins.olas.service_manager.ServiceManager") as mock_sm_cls,
+            patch("iwa.core.pricing.PriceService") as mock_price_cls,
+        ):
+            mock_sm = mock_sm_cls.return_value
+            # Default mock return value to avoid TypeErrors in background thread
+            mock_sm.get_staking_status.return_value = StakingStatus(
+                is_staked=False, staking_state="NOT_STAKED", remaining_epoch_seconds=3600
+            )
+
+            mock_sm.get_staking_status.return_value = StakingStatus(
+                is_staked=True,
+                staking_state="STAKED",
+                staking_contract_address="0xStaking",
+                staking_contract_name="Trader Staking",
+                accrued_reward_wei=500000000000000000,
+                liveness_ratio_passed=True,
+                remaining_epoch_seconds=3600,
+                epoch_number=1,
+                unstake_available_at="2025-12-24T12:00:00Z",
+            )
+            mock_sm.get_service_state.return_value = "DEPLOYED"
+            mock_price_cls.return_value.get_token_price.return_value = 1.23
+
+            app = OlasTestApp(mock_wallet)
+            async with app.run_test() as pilot:
+                view = app.query_one(OlasView)
+                assert view._chain == "gnosis"
+
+                # Wait for loading worker
+                await pilot.pause()
+
+                # Verify service card exists
+                assert bool(app.query("#card-gnosis_1"))
+                # Label content check
+                label = app.query_one(".service-title")
+                assert "Test Service #1" in label.render().plain
+
+
+@pytest.mark.asyncio
+async def test_olas_view_chain_change(mock_wallet, mock_olas_config):
+    """Test changing chain in OlasView."""
+    with patch("iwa.core.models.Config") as mock_config_cls:
+        mock_config = mock_config_cls.return_value
+        mock_config.plugins = {"olas": mock_olas_config.model_dump()}
+
+        with (
+            patch("iwa.plugins.olas.service_manager.ServiceManager") as mock_sm_cls,
+            patch("iwa.plugins.olas.constants.OLAS_TRADER_STAKING_CONTRACTS", {"ethereum": []}),
+            patch("iwa.core.pricing.PriceService"),
+        ):
+            mock_sm = mock_sm_cls.return_value
+            mock_sm.get_services_full.return_value = []
+            mock_sm.get_staking_status.return_value = StakingStatus(
+                is_staked=False, staking_state="NOT_STAKED", remaining_epoch_seconds=3600
+            )
+            mock_sm.get_service_state.return_value = "DEPLOYED"
+            app = OlasTestApp(mock_wallet)
+            async with app.run_test() as pilot:
+                view = app.query_one(OlasView)
+
+                # Wait for initial load to finish
+                await pilot.pause(0.5)
+                for _ in range(50):
+                    if not any(w.name == "load_services" for w in view.workers):
+                        break
+                    await pilot.pause(0.1)
+
+                # Change chain
+                select = app.query_one("#olas-chain-select", Select)
+                select.value = "ethereum"
+                await pilot.pause()
+                # Select.Changed will trigger load_services worker
+                await pilot.pause()
+
+                # Wait for worker to start and finish
+                await pilot.pause(0.5)
+                for _ in range(50):
+                    if not any(w.name == "load_services" for w in view.workers):
+                        break
+                    await pilot.pause(0.1)
+
+                # Ensure call_from_thread tasks are also finished
+                await pilot.pause(0.5)
+
+                assert view._chain == "ethereum"
+                # Should show empty state since no eth services in mock
+                assert len(view.query(".empty-state")) > 0
+
+
+@pytest.mark.asyncio
+async def test_olas_view_actions(mock_wallet, mock_olas_config):
+    """Test button actions in OlasView."""
+    with patch("iwa.core.models.Config") as mock_config_cls:
+        mock_config = mock_config_cls.return_value
+        mock_config.plugins = {"olas": mock_olas_config.model_dump()}
+
+        with (
+            patch("iwa.plugins.olas.service_manager.ServiceManager") as mock_sm_cls,
+            patch("iwa.core.pricing.PriceService"),
+        ):
+            mock_sm = mock_sm_cls.return_value
+            mock_sm.get_staking_status.return_value = StakingStatus(
+                is_staked=True,
+                staking_state="STAKED",
+                accrued_reward_wei=10**18,
+                remaining_epoch_seconds=0,  # Checkpoint pending
+            )
+            mock_sm.get_service_state.return_value = "DEPLOYED"
+
+            app = OlasTestApp(mock_wallet)
+            async with app.run_test() as pilot:
+                await pilot.pause()
+
+                # 1. Test Claim
+                with patch.object(OlasView, "claim_rewards") as mock_claim:
+                    await pilot.click("#claim-gnosis_1")
+                    mock_claim.assert_called_with("gnosis:1")
+
+                # 2. Test Unstake
+                with patch.object(OlasView, "unstake_service") as mock_unstake:
+                    await pilot.click("#unstake-gnosis_1")
+                    mock_unstake.assert_called_with("gnosis:1")
+
+                # 3. Test Checkpoint
+                with patch.object(OlasView, "checkpoint_service") as mock_checkpoint:
+                    await pilot.click("#checkpoint-gnosis_1")
+                    mock_checkpoint.assert_called_with("gnosis:1")
+
+
+@pytest.mark.asyncio
+async def test_olas_view_create_service(mock_wallet, mock_olas_config):
+    """Test clicking Create Service button."""
+    with patch("iwa.core.models.Config") as mock_config_cls:
+        mock_config = mock_config_cls.return_value
+        mock_config.plugins = {"olas": mock_olas_config.model_dump()}
+
+        with (
+            patch("iwa.plugins.olas.service_manager.ServiceManager") as mock_sm_cls,
+            patch("iwa.core.pricing.PriceService"),
+        ):
+            mock_sm = mock_sm_cls.return_value
+            mock_sm.get_staking_status.return_value = StakingStatus(
+                is_staked=False, staking_state="NOT_STAKED"
+            )
+            mock_sm.get_service_state.return_value = "DEPLOYED"
+
+            app = OlasTestApp(mock_wallet)
+            async with app.run_test() as pilot:
+                # Wait for worker
+                view = app.query_one(OlasView)
+                for _ in range(10):
+                    if not any(w.name == "load_services" for w in view.workers):
+                        break
+                    await pilot.pause(0.1)
+
+                # Patch push_screen on the app instance
+                with patch.object(app, "push_screen") as mock_push:
+                    await pilot.click("#olas-create-service-btn")
+                    await pilot.pause()
+
+                    # Verify push_screen was called with a CreateServiceModal
+                    assert mock_push.called
+                    modal = mock_push.call_args[0][0]
+                    assert isinstance(modal, CreateServiceModal)
+
+
+@pytest.mark.asyncio
+async def test_olas_view_fund_service(mock_wallet, mock_olas_config):
+    """Test showing fund service modal."""
+    with patch("iwa.core.models.Config") as mock_config_cls:
+        mock_config = mock_config_cls.return_value
+        mock_config.plugins = {"olas": mock_olas_config.model_dump()}
+
+        with (
+            patch("iwa.plugins.olas.service_manager.ServiceManager") as mock_sm_cls,
+            patch("iwa.core.pricing.PriceService"),
+        ):
+            mock_sm = mock_sm_cls.return_value
+            mock_sm.get_staking_status.return_value = StakingStatus(
+                is_staked=False, staking_state="NOT_STAKED"
+            )
+            mock_sm.get_service_state.return_value = "DEPLOYED"
+
+            app = OlasTestApp(mock_wallet)
+            async with app.run_test() as pilot:
+                # Wait for worker
+                view = app.query_one(OlasView)
+                for _ in range(10):
+                    if not any(w.name == "load_services" for w in view.workers):
+                        break
+                    await pilot.pause(0.1)
+
+                # Patch push_screen on the app instance
+                with patch.object(app, "push_screen") as mock_push:
+                    await pilot.click("#fund-gnosis_1")
+                    await pilot.pause()
+
+                    # Verify push_screen was called with a FundServiceModal
+                    assert mock_push.called
+                    modal = mock_push.call_args[0][0]
+                    assert isinstance(modal, FundServiceModal)
+
+
+@pytest.mark.asyncio
+async def test_olas_view_error_states(mock_wallet):
+    """Test OlasView error handling."""
+    # 1. No wallet
+    app = OlasTestApp(None)
+    async with app.run_test():
+        label = app.query_one(".empty-state")
+        assert "Wallet not available" in label.render().plain
+
+    # 2. No Olas configured
+    with patch("iwa.core.models.Config") as mock_config_cls:
+        mock_config = mock_config_cls.return_value
+        mock_config.plugins = {}
+        app = OlasTestApp(mock_wallet)
+        async with app.run_test():
+            label = app.query_one(".empty-state")
+            assert "No Olas services configured" in label.render().plain

iwa/plugins/olas/tests/test_olas_view_actions.py

@@ -0,0 +1,137 @@
+"""Tests for Olas TUI View actions."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from textual.app import App, ComposeResult
+
+from iwa.plugins.olas.models import OlasConfig, Service, StakingStatus
+from iwa.plugins.olas.tui.olas_view import OlasView
+
+VALID_ADDR_1 = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+VALID_ADDR_2 = "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D"
+VALID_ADDR_3 = "0x1111111111111111111111111111111111111111"
+
+
+@pytest.fixture
+def mock_wallet():
+    """Mock wallet for testing."""
+    wallet = MagicMock()
+    wallet.balance_service = MagicMock()
+    wallet.key_storage = MagicMock()
+    wallet.get_native_balance_eth.return_value = 1.0
+    wallet.balance_service.get_erc20_balance_wei.return_value = 10**18
+    wallet.key_storage.find_stored_account.return_value = None
+    wallet.master_account.address = VALID_ADDR_1
+    return wallet
+
+
+@pytest.fixture
+def mock_olas_config():
+    """Mock Olas configuration."""
+    service = Service(
+        service_id=1,
+        service_name="Test Service",
+        chain_name="gnosis",
+        agent_address=VALID_ADDR_1,
+        multisig_address=VALID_ADDR_2,
+        service_owner_address=VALID_ADDR_3,
+        staking_contract_address=VALID_ADDR_1,
+    )
+    config = OlasConfig(services={"gnosis:1": service})
+    return config
+
+
+class OlasTestApp(App):
+    """Test app to host OlasView."""
+
+    def __init__(self, wallet=None):
+        """Initialize test app."""
+        super().__init__()
+        self.wallet = wallet
+
+    def compose(self) -> ComposeResult:
+        """Compose layout."""
+        yield OlasView(self.wallet)
+
+
+async def wait_for_workers(view, pilot):
+    """Wait for all workers in OlasView to finish."""
+    for _ in range(50):
+        if not view.workers:
+            break
+        await pilot.pause(0.05)
+
+
+@pytest.mark.asyncio
+async def test_olas_view_actions_suite(mock_wallet, mock_olas_config):
+    """Unified test for OlasView actions with robust mocking and synchronization."""
+    with patch("iwa.core.models.Config") as mock_conf_cls:
+        mock_conf = mock_conf_cls.return_value
+        mock_conf.plugins = {"olas": mock_olas_config.model_dump()}
+
+        # Patch both ServiceManager and StakingContract globally for the view
+        with (
+            patch("iwa.plugins.olas.service_manager.ServiceManager") as mock_sm_cls,
+            patch("iwa.plugins.olas.contracts.staking.StakingContract"),
+        ):
+            mock_sm = mock_sm_cls.return_value
+            # Default staking status to avoid TypeErrors during cards rendering
+            mock_sm.get_staking_status.return_value = StakingStatus(
+                is_staked=True,
+                staking_state="STAKED",
+                remaining_epoch_seconds=3600,
+                accrued_reward_wei=10**18,
+            )
+
+            app = OlasTestApp(mock_wallet)
+            async with app.run_test() as pilot:
+                view = app.query_one(OlasView)
+                await wait_for_workers(view, pilot)
+
+                # 1. Claim Rewards
+                mock_sm.claim_rewards.return_value = (True, 10**18)
+                view.claim_rewards("gnosis:1")
+                mock_sm.claim_rewards.assert_called_once()
+                await wait_for_workers(view, pilot)  # success calls load_services
+
+                # 2. Unstake
+                mock_sm.unstake.return_value = True
+                view.unstake_service("gnosis:1")
+                mock_sm.unstake.assert_called_once()
+                await wait_for_workers(view, pilot)
+
+                # 3. Checkpoint
+                mock_sm.call_checkpoint.return_value = True
+                view.checkpoint_service("gnosis:1")
+                mock_sm.call_checkpoint.assert_called_once()
+                await wait_for_workers(view, pilot)
+
+                # 4. Drain
+                mock_sm.drain_service.return_value = {"safe": {"native": 1.0}}
+                view.drain_service("gnosis:1")
+                mock_sm.drain_service.assert_called_once()
+                await wait_for_workers(view, pilot)
+
+                # 5. Terminate (Wind Down)
+                mock_sm.wind_down.return_value = True
+                view.terminate_service("gnosis:1")
+                mock_sm.wind_down.assert_called_once()
+                await wait_for_workers(view, pilot)
+
+                # 6. Stake (via modal simulation)
+                from iwa.plugins.olas.constants import OLAS_TRADER_STAKING_CONTRACTS
+
+                with patch.dict(
+                    OLAS_TRADER_STAKING_CONTRACTS, {"gnosis": {"Contract": VALID_ADDR_1}}
+                ):
+                    with patch.object(app, "push_screen") as mock_push:
+                        view.stake_service("gnosis:1")
+                        assert mock_push.called
+
+                        # Get callback from push_screen
+                        callback = mock_push.call_args[0][1]  # modal, callback
+                        mock_sm.stake.return_value = True
+                        callback(VALID_ADDR_1)
+                        mock_sm.stake.assert_called_once()
+                        await wait_for_workers(view, pilot)

iwa/plugins/olas/tests/test_olas_view_modals.py

@@ -0,0 +1,120 @@
+"""Modal callback tests for OlasView."""
+
+from unittest.mock import MagicMock, PropertyMock, patch
+
+import pytest
+
+from iwa.plugins.olas.tui.olas_view import OlasView
+
+
+@pytest.mark.asyncio
+async def test_olas_view_modal_callbacks_full(mock_wallet):
+    """Test OlasView modal callbacks directly for coverage."""
+    # Patch ServiceManager globally for the view init
+    with patch("iwa.plugins.olas.service_manager.ServiceManager"):
+        view = OlasView(wallet=mock_wallet)
+        view.load_services = MagicMock()
+        view.notify = MagicMock()
+        mock_app = MagicMock()
+
+        # Patch the read-only property 'app'
+        with patch.object(OlasView, "app", new_callable=PropertyMock) as mock_app_prop:
+            mock_app_prop.return_value = mock_app
+
+            # 1. Create Service callback (Full flow)
+            view.show_create_service_modal()
+            assert mock_app.push_screen.called
+            args, kwargs = mock_app.push_screen.call_args
+            callback = kwargs.get("callback") or (args[1] if len(args) > 1 else None)
+
+            if callback:
+                with patch("iwa.plugins.olas.service_manager.ServiceManager") as mock_sm_cls:
+                    mock_sm = mock_sm_cls.return_value
+                    mock_sm.create.return_value = 123
+
+                    # Sub-case: created but deploy failed
+                    mock_sm.spin_up.return_value = False
+                    callback({"chain": "gnosis", "name": "test", "staking_contract": None})
+                    view.notify.assert_any_call(
+                        "Service created (ID: 123) but deployment failed", severity="warning"
+                    )
+
+                    # Sub-case: success with staking
+                    mock_sm.spin_up.return_value = True
+                    callback({"chain": "gnosis", "name": "test", "staking_contract": "0x1"})
+                    view.notify.assert_any_call(
+                        "Service deployed and staked! ID: 123", severity="information"
+                    )
+
+                    # Sub-case: exception
+                    mock_sm.create.side_effect = Exception("creation error")
+                    callback({"chain": "gnosis", "name": "test"})
+                    view.notify.assert_any_call("Error: creation error", severity="error")
+
+            view.load_services.reset_mock()
+            mock_app.push_screen.reset_mock()
+
+            # 2. Fund Service callback (Full flow)
+            view.show_fund_service_modal("gnosis:1")
+            assert mock_app.push_screen.called
+            args, kwargs = mock_app.push_screen.call_args
+            callback = kwargs.get("callback") or (args[1] if len(args) > 1 else None)
+
+            if callback:
+                with patch("iwa.core.models.Config") as mock_conf_cls:
+                    mock_conf_instance = mock_conf_cls.return_value
+                    addr = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+                    mock_conf_instance.plugins = {
+                        "olas": {
+                            "services": {
+                                "gnosis:1": {
+                                    "agent_address": addr,
+                                    "multisig_address": addr,
+                                    "chain_name": "gnosis",
+                                    "service_name": "test",
+                                    "service_id": 1,
+                                }
+                            }
+                        }
+                    }
+                    callback({"agent_amount": 1.0, "safe_amount": 0.5})
+                    assert mock_wallet.send.call_count == 2
+                    view.notify.assert_any_call("Service funded!", severity="information")
+                    view.load_services.assert_called_once()
+
+                    # Sub-case: skip amount 0
+                    mock_wallet.send.reset_mock()
+                    callback({"agent_amount": 0.0, "safe_amount": 0.0})
+                    assert mock_wallet.send.call_count == 0
+
+            view.load_services.reset_mock()
+            mock_app.push_screen.reset_mock()
+
+            # 3. Stake Service callback
+            view._chain = "gnosis"
+            with patch(
+                "iwa.plugins.olas.constants.OLAS_TRADER_STAKING_CONTRACTS",
+                {"gnosis": {"test": "0x1"}},
+            ):
+                view.stake_service("gnosis:1")
+                assert mock_app.push_screen.called
+                args, kwargs = mock_app.push_screen.call_args
+                callback = kwargs.get("callback") or (args[1] if len(args) > 1 else None)
+                if callback:
+                    with (
+                        patch(
+                            "iwa.plugins.olas.service_manager.ServiceManager"
+                        ) as mock_sm_inner_cls,
+                        patch("iwa.core.contracts.contract.ChainInterfaces") as mock_ci,
+                    ):
+                        mock_ci.get_instance.return_value.web3.eth.contract.return_value = (
+                            MagicMock()
+                        )
+                        mock_sm_inner = mock_sm_inner_cls.return_value
+                        mock_sm_inner.stake.return_value = True
+                        try:
+                            # Use a valid checksum address
+                            callback("0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB")
+                        except Exception as e:
+                            pytest.fail(f"Stake callback failed: {e}")
+                        view.load_services.assert_called_once()