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

iwa/plugins/olas/tests/test_service_staking.py

@@ -0,0 +1,342 @@
+"""Tests for Olas service staking and unstaking functionality."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from textual.app import App, ComposeResult
+from textual.containers import VerticalScroll
+
+from iwa.plugins.olas.contracts.service import ServiceState
+from iwa.plugins.olas.contracts.staking import StakingState
+from iwa.plugins.olas.models import Service, StakingStatus
+from iwa.plugins.olas.service_manager import ServiceManager
+from iwa.plugins.olas.tui.olas_view import OlasView
+
+VALID_ADDR = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+
+
+@pytest.fixture
+def mock_wallet():
+    """Mock wallet."""
+    w = MagicMock()
+    w.master_account.address = VALID_ADDR
+    w.sign_and_send_transaction.return_value = (True, {"status": 1})
+    w.key_storage = MagicMock()
+    w.key_storage._password = "pass"
+    w.balance_service = MagicMock()
+    w.drain.return_value = {"tx": "0x123"}
+    return w
+
+
+# === SERVICE MANAGER STAKE/UNSTAKE SIMPLE FAILURES ===
+
+
+def test_sm_unstake_not_staked(mock_wallet):
+    """Cover unstake when not staked (lines 736-738)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(
+            service_name="t", chain_name="gnosis", service_id=1, multisig_address=VALID_ADDR
+        )
+
+        mock_staking = MagicMock()
+        mock_staking.get_staking_state.return_value = StakingState.NOT_STAKED
+
+        result = sm.unstake(mock_staking)
+        assert result is False
+
+
+def test_sm_unstake_tx_fails(mock_wallet):
+    """Cover unstake transaction failure (lines 766-768)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(
+            service_name="t", chain_name="gnosis", service_id=1, multisig_address=VALID_ADDR
+        )
+
+        mock_staking = MagicMock()
+        mock_staking.get_staking_state.return_value = StakingState.STAKED
+        mock_staking.get_service_info.return_value = {"ts_start": 1}
+        mock_staking.min_staking_duration = 0
+        mock_staking.prepare_unstake_tx.return_value = {"to": VALID_ADDR}
+
+        mock_wallet.sign_and_send_transaction.return_value = (False, None)
+
+        result = sm.unstake(mock_staking)
+        assert result is False
+
+
+# === SERVICE MANAGER STAKING STATUS EDGE CASES (lines 843-891) ===
+
+
+def test_sm_get_staking_status_no_staking_address(mock_wallet):
+    """Cover get_staking_status with no staking address (lines 831)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(
+            service_name="t", chain_name="gnosis", service_id=1, staking_contract_address=VALID_ADDR
+        )
+
+        # Contract load fails
+        with patch(
+            "iwa.plugins.olas.service_manager.staking.StakingContract",
+            side_effect=Exception("fail"),
+        ):
+            status = sm.get_staking_status()
+            assert status.staking_state == "ERROR"
+
+
+def test_sm_get_staking_status_with_full_info(mock_wallet):
+    """Cover get_staking_status with complete info (lines 866-891)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(
+            service_name="t", chain_name="gnosis", service_id=1, staking_contract_address=VALID_ADDR
+        )
+
+        mock_staking = MagicMock()
+        mock_staking.get_staking_state.return_value = StakingState.STAKED
+        mock_staking.activity_checker_address = VALID_ADDR
+        mock_staking.activity_checker.liveness_ratio = 10
+        mock_staking.get_epoch_counter.return_value = 5
+        mock_staking.min_staking_duration = 86400
+        mock_staking.get_service_info.return_value = {
+            "ts_start": 1000,
+            "mech_requests_this_epoch": 3,
+            "required_mech_requests": 5,
+            "remaining_mech_requests": 2,
+            "has_enough_requests": False,
+            "liveness_ratio_passed": True,
+            "accrued_reward_wei": 1000000,
+            "epoch_end_utc": None,
+            "remaining_epoch_seconds": 3600,
+        }
+
+        with (
+            patch(
+                "iwa.plugins.olas.service_manager.staking.StakingContract",
+                return_value=mock_staking,
+            ),
+            patch("iwa.plugins.olas.service_manager.staking.Web3") as mock_web3,
+        ):
+            mock_web3.from_wei.return_value = 0.001
+            status = sm.get_staking_status()
+            assert status.is_staked is True
+            assert status.epoch_number == 5
+
+
+# === SERVICE MANAGER CLAIM/WITHDRAW (lines 936-979) ===
+
+
+def test_sm_claim_rewards_no_service(mock_wallet):
+    """Cover claim_rewards with no service (lines 936-938)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = None
+
+        success, amount = sm.claim_rewards()
+        assert success is False
+        assert amount == 0
+
+
+def test_sm_claim_rewards_no_staking_address(mock_wallet):
+    """Cover claim_rewards with no staking address (lines 939-943)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(
+            service_name="t", chain_name="gnosis", service_id=1, staking_contract_address=None
+        )
+
+        success, amount = sm.claim_rewards()
+        assert success is False
+
+
+def test_sm_claim_rewards_tx_fails(mock_wallet):
+    """Cover claim_rewards transaction failure (lines 967-968)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(
+            service_name="t",
+            chain_name="gnosis",
+            service_id=1,
+            staking_contract_address=VALID_ADDR,
+            multisig_address=VALID_ADDR,
+        )
+
+        mock_staking = MagicMock()
+        mock_staking.prepare_claim_tx.return_value = {"to": VALID_ADDR}
+
+        mock_wallet.sign_and_send_transaction.return_value = (False, None)
+
+        with patch("iwa.plugins.olas.service_manager.StakingContract", return_value=mock_staking):
+            success, amount = sm.claim_rewards()
+            assert success is False
+
+
+# === SERVICE MANAGER SPIN_UP STATE TRANSITIONS (lines 1188-1241) ===
+
+
+def test_sm_spin_up_state_mismatch_after_activation(mock_wallet):
+    """Cover spin_up state mismatch after activation (lines 1188-1191)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
+
+        mock_reg = MagicMock()
+        # First call: PRE_REGISTRATION, second call: still PRE_REGISTRATION (mismatch)
+        mock_reg.get_service.side_effect = [
+            {"state": ServiceState.PRE_REGISTRATION},
+            {"state": ServiceState.PRE_REGISTRATION},
+        ]
+
+        with (
+            patch.object(sm, "registry", mock_reg),
+            patch.object(sm, "activate_registration", return_value=True),
+        ):
+            result = sm.spin_up()
+            assert result is False
+
+
+def test_sm_spin_up_registration_fails(mock_wallet):
+    """Cover spin_up registration failure (lines 1199-1201)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
+
+        mock_reg = MagicMock()
+        mock_reg.get_service.return_value = {"state": ServiceState.ACTIVE_REGISTRATION}
+
+        with (
+            patch.object(sm, "registry", mock_reg),
+            patch.object(sm, "register_agent", return_value=False),
+        ):
+            result = sm.spin_up()
+            assert result is False
+
+
+def test_sm_spin_up_deploy_fails(mock_wallet):
+    """Cover spin_up deploy failure (lines 1216-1218)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
+
+        mock_reg = MagicMock()
+        mock_reg.get_service.return_value = {"state": ServiceState.FINISHED_REGISTRATION}
+
+        with patch.object(sm, "registry", mock_reg), patch.object(sm, "deploy", return_value=None):
+            result = sm.spin_up()
+            assert result is False
+
+
+# === SERVICE MANAGER WIND DOWN TRANSITIONS (lines 1306-1334) ===
+
+
+def test_sm_wind_down_terminate_fails(mock_wallet):
+    """Cover wind_down terminate failure (lines 1299-1301)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
+
+        mock_reg = MagicMock()
+        mock_reg.get_service.return_value = {"state": ServiceState.DEPLOYED}
+
+        with (
+            patch.object(sm, "registry", mock_reg),
+            patch.object(sm, "terminate", return_value=False),
+        ):
+            result = sm.wind_down()
+            assert result is False
+
+
+def test_sm_wind_down_unbond_fails(mock_wallet):
+    """Cover wind_down unbond failure (lines 1315-1317)."""
+    with patch("iwa.core.models.Config"):
+        sm = ServiceManager(mock_wallet)
+        sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
+
+        mock_reg = MagicMock()
+        mock_reg.get_service.return_value = {"state": ServiceState.TERMINATED_BONDED}
+
+        with patch.object(sm, "registry", mock_reg), patch.object(sm, "unbond", return_value=False):
+            result = sm.wind_down()
+            assert result is False
+
+
+# === OLAS VIEW EDGE CASES (lines 233-257, 319-323) ===
+
+
+class OlasTestApp(App):
+    """Test App for OlasView."""
+
+    def __init__(self, wallet=None):
+        """Initialize test app."""
+        super().__init__()
+        self.wallet = wallet
+
+    def compose(self) -> ComposeResult:
+        """Compose layout."""
+        yield VerticalScroll(OlasView(self.wallet), id="root")
+
+
+@pytest.mark.asyncio
+async def test_view_render_exception(mock_wallet):
+    """Cover _render_services exception handling (lines 233-235)."""
+    with patch("iwa.core.models.Config"):
+        app = OlasTestApp(mock_wallet)
+        async with app.run_test():
+            view = app.query_one(OlasView)
+
+            # Force exception by passing invalid data
+            with patch.object(view, "query_one", side_effect=Exception("test")):
+                # Should not raise, just logs
+                await view._render_services([("k", MagicMock(), None)])
+
+
+@pytest.mark.asyncio
+async def test_view_mount_cards_exception(mock_wallet):
+    """Cover _mount_cards exception handling (lines 239-247)."""
+    with patch("iwa.core.models.Config"):
+        app = OlasTestApp(mock_wallet)
+        async with app.run_test():
+            view = app.query_one(OlasView)
+
+            with patch.object(view, "query_one", side_effect=Exception("test")):
+                # Should not raise
+                view._mount_cards([MagicMock()])
+
+
+@pytest.mark.asyncio
+async def test_view_mount_error_exception(mock_wallet):
+    """Cover _mount_error exception handling (lines 255-257)."""
+    with patch("iwa.core.models.Config"):
+        app = OlasTestApp(mock_wallet)
+        async with app.run_test():
+            view = app.query_one(OlasView)
+
+            with patch.object(view, "query_one", side_effect=Exception("test")):
+                # Should not raise
+                view._mount_error("test error")
+
+
+@pytest.mark.asyncio
+async def test_view_create_service_card_variants(mock_wallet):
+    """Cover _create_service_card with various inputs (lines 319-323)."""
+    with patch("iwa.core.models.Config"):
+        app = OlasTestApp(mock_wallet)
+        async with app.run_test():
+            view = app.query_one(OlasView)
+
+            service = Service(
+                service_name="test", chain_name="gnosis", service_id=1, multisig_address=VALID_ADDR
+            )
+
+            # With staking status
+            status = StakingStatus(
+                is_staked=True, staking_state="STAKED", accrued_reward_wei=1000000
+            )
+            card = view._create_service_card("gnosis:1", service, status)
+            assert card is not None
+
+            # Without staking status
+            card2 = view._create_service_card("gnosis:2", service, None)
+            assert card2 is not None

iwa/plugins/olas/tests/test_staking_integration.py

@@ -0,0 +1,269 @@
+"""Integration tests for Olas staking contracts."""
+
+import builtins
+import json
+from unittest.mock import MagicMock, mock_open, patch
+
+from eth_account import Account
+
+from iwa.plugins.olas.contracts.service import (
+    ServiceManagerContract,
+    ServiceRegistryContract,
+    get_deployment_payload,
+)
+from iwa.plugins.olas.contracts.staking import StakingContract, StakingState
+
+# --- Helpers ---
+VALID_ADDR_1 = Account.create().address
+VALID_ADDR_2 = Account.create().address
+VALID_ADDR_3 = Account.create().address
+VALID_ADDR_4 = Account.create().address
+
+original_open = builtins.open
+
+# Minimal ABI
+MINIMAL_ABI = [
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "agentMech",
+        "outputs": [{"name": "", "type": "address"}],
+        "payable": False,
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "livenessRatio",
+        "outputs": [{"name": "", "type": "uint256"}],
+        "payable": False,
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [{"name": "_multisig", "type": "address"}],
+        "name": "getMultisigNonces",
+        "outputs": [{"name": "", "type": "uint256[]"}],
+        "payable": False,
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [
+            {"name": "currentNonces", "type": "uint256"},
+            {"name": "lastNonces", "type": "uint256"},
+            {"name": "timestamp", "type": "uint256"},
+        ],
+        "name": "isRatioPass",
+        "outputs": [{"name": "", "type": "bool"}],
+        "payable": False,
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "name": "create",
+        "type": "function",
+        "inputs": [{"name": "", "type": "address"}] * 6,
+        "outputs": [],
+    },
+    {
+        "name": "activateRegistration",
+        "type": "function",
+        "inputs": [{"name": "", "type": "uint256"}],
+        "outputs": [],
+    },
+    {
+        "name": "registerAgents",
+        "type": "function",
+        "inputs": [
+            {"name": "", "type": "uint256"},
+            {"name": "", "type": "address[]"},
+            {"name": "", "type": "uint256[]"},
+        ],
+        "outputs": [],
+    },
+    {
+        "name": "deploy",
+        "type": "function",
+        "inputs": [
+            {"name": "", "type": "uint256"},
+            {"name": "", "type": "address"},
+            {"name": "", "type": "bytes"},
+        ],
+        "outputs": [],
+    },
+    {
+        "name": "terminate",
+        "type": "function",
+        "inputs": [{"name": "", "type": "uint256"}],
+        "outputs": [],
+    },
+    {
+        "name": "unbond",
+        "type": "function",
+        "inputs": [{"name": "", "type": "uint256"}],
+        "outputs": [],
+    },
+]
+
+
+def side_effect_open(*args, **kwargs):
+    """Side effect for open() to return mock ABI content."""
+    filename = args[0] if args else kwargs.get("file")
+    s_file = str(filename)
+
+    if (
+        "service_registry.json" in s_file
+        or "service_manager.json" in s_file
+        or "staking.json" in s_file
+        or "activity_checker.json" in s_file
+    ):
+        return mock_open(read_data=json.dumps(MINIMAL_ABI))(*args, **kwargs)
+
+    return original_open(*args, **kwargs)
+
+
+# --- Contract Tests ---
+
+
+def test_service_contracts():
+    """Test ServiceRegistry and ServiceManager contract interactions."""
+    with patch("builtins.open", side_effect=side_effect_open):
+        registry = ServiceRegistryContract(VALID_ADDR_1)
+
+        # Test get_service
+        with patch.object(registry, "call") as mock_call:
+            mock_call.return_value = (100, VALID_ADDR_2, b"hash", 3, 4, 4, 4, [1, 2])
+            data = registry.get_service(1)
+            assert data["state"].name == "DEPLOYED"
+            assert data["config_hash"] == b"hash".hex()
+
+        # Test prepare_approve_tx
+        with patch.object(registry, "prepare_transaction") as mock_prep:
+            mock_prep.return_value = {"data": "0xTx"}
+            tx = registry.prepare_approve_tx(VALID_ADDR_2, VALID_ADDR_3, 1)
+            assert tx == {"data": "0xTx"}
+
+        manager = ServiceManagerContract(VALID_ADDR_1)
+
+        # Mock ChainInterfaces for get_contract_address
+        with patch.object(manager.chain_interface, "get_contract_address") as mock_get_addr:
+            mock_get_addr.return_value = VALID_ADDR_4
+
+            # Test prepare methods
+            with patch.object(manager, "prepare_transaction") as mock_prep:
+                mock_prep.return_value = {}
+
+                manager.prepare_create_tx(
+                    VALID_ADDR_2, VALID_ADDR_3, VALID_ADDR_1, "hash", [], [], 3
+                )
+                assert mock_prep.called
+                mock_prep.reset_mock()
+
+                manager.prepare_activate_registration_tx(VALID_ADDR_2, 1)
+                assert mock_prep.called
+                mock_prep.reset_mock()
+
+                manager.prepare_register_agents_tx(VALID_ADDR_2, 1, [], [])
+                assert mock_prep.called
+                mock_prep.reset_mock()
+
+                manager.prepare_deploy_tx(VALID_ADDR_2, 1)
+                assert mock_prep.called
+                mock_prep.reset_mock()
+
+                manager.prepare_terminate_tx(VALID_ADDR_2, 1)
+                assert mock_prep.called
+                mock_prep.reset_mock()
+
+                manager.prepare_unbond_tx(VALID_ADDR_2, 1)
+                assert mock_prep.called
+
+        # Test get_deployment_payload
+        payload = get_deployment_payload(VALID_ADDR_4)
+        assert isinstance(payload, str)
+
+
+def test_staking_contract(tmp_path):  # noqa: C901
+    """Test StakingContract logic and integration."""
+    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
+            mock_web3 = MagicMock()
+            mock_chain.web3 = mock_web3
+
+            # Mock contract factory
+            mock_contract = MagicMock()
+            mock_web3.eth.contract.return_value = mock_contract
+
+            # Mock function calls (ActivityChecker)
+            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:
+                # Initialization side effect
+                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)
+
+                # Logic side effect
+                def logic_side_effect(method, *args):
+                    if method == "getServiceInfo":
+                        # Returns: (multisig, owner, nonces_on_last_checkpoint, ts_start, accrued_reward, inactivity)
+                        # nonces_on_last_checkpoint must be [safe_nonce, mech_requests]
+                        return (VALID_ADDR_2, VALID_ADDR_3, [1, 1], 1000, 50, 0)
+                    if method == "getNextRewardCheckpointTimestamp":
+                        return 4700000000  # Timestamp in future
+                    if method == "calculateStakingLastReward":
+                        return 50
+                    if method == "calculateStakingReward":
+                        return 50
+                    if method == "getStakingState":
+                        return 1
+                    return 0
+
+                mock_call_base.side_effect = logic_side_effect
+
+                # Test methods
+                # Note: logic_side_effect handles different calls now
+                assert staking.calculate_accrued_staking_reward(1) == 50
+                assert staking.calculate_staking_reward(1) == 50
+                assert staking.get_staking_state(1) == StakingState.STAKED
+                assert staking.call("nonexistent") == 0
+
+                # Activity checker interactions - nonces now returns [safe_nonce, mech_requests]
+                mock_contract.functions.getMultisigNonces.return_value.call.return_value = [5, 3]
+                staking.activity_checker.contract = mock_contract
+
+                staking.ts_checkpoint = MagicMock(return_value=0)
+
+                # Trigger original_open hit
+                try:
+                    test_file = tmp_path / "test_lookup.txt"
+                    with builtins.open(str(test_file), "w") as f:
+                        f.write("test")
+                except Exception:
+                    pass
+
+                info = staking.get_service_info(1)
+                assert info["owner_address"] == VALID_ADDR_3
+                assert "remaining_epoch_seconds" in info
+                assert info["remaining_epoch_seconds"] > 0
+                # Verify new nonces fields
+                assert info["current_safe_nonce"] == 5
+                assert info["current_mech_requests"] == 3