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

iwa/plugins/gnosis/tests/test_cow.py

@@ -0,0 +1,227 @@
+"""Tests for CowSwap module."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from iwa.core.chain import SupportedChain
+from iwa.plugins.gnosis.cow import CowSwap, OrderType
+
+
+@pytest.fixture
+def mock_chain():
+    """Mock supported chain."""
+    mock = MagicMock(spec=SupportedChain)
+    mock.chain_id = 100
+    mock.name = "Gnosis"
+    mock.get_token_address.return_value = "0xToken"
+    return mock
+
+
+@pytest.fixture
+def mock_cowpy_modules():
+    """Mock cowpy modules."""
+    with (
+        patch("iwa.plugins.gnosis.cow.swap.get_cowpy_module") as mock_get_swap,
+        patch("iwa.plugins.gnosis.cow.quotes.get_cowpy_module") as mock_get_quotes,
+    ):
+        # Create mocks for all various modules
+        mocks = {
+            "SupportedChainId": MagicMock(),
+            "Chain": MagicMock(),
+            "OrderBookApi": MagicMock(),
+            "OrderBookAPIConfigFactory": MagicMock(),
+            "get_order_quote": AsyncMock(),
+            "OrderQuoteRequest": MagicMock(),
+            "OrderQuoteSide3": MagicMock(),
+            "OrderQuoteSideKindBuy": MagicMock(),
+            "TokenAmount": MagicMock(),
+            "OrderQuoteSide1": MagicMock(),
+            "OrderQuoteSideKindSell": MagicMock(),
+            "Order": MagicMock(),
+            "PreSignSignature": MagicMock(),
+            "SigningScheme": MagicMock(),
+            "sign_order": MagicMock(),
+            "post_order": AsyncMock(),
+            "CompletedOrder": MagicMock(),
+            "swap_tokens": AsyncMock(),
+        }
+
+        # Setup specific returns
+        mocks["get_order_quote"].return_value.quote.sellAmount.root = "100"
+        mocks["get_order_quote"].return_value.quote.buyAmount.root = "90"
+        mocks["get_order_quote"].return_value.quote.validTo = 1234567890
+
+        mocks["post_order"].return_value = "0xOrderUID"
+
+        # Correctly mock Chain iteration for get_chain logic
+        # chain.value[0] == supported_chain_id (which is mocked as MagicMock by default,
+        # but in init it calls SupportedChainId(chain.chain_id))
+
+        # Let's make supported_chain_id return a specific value and chain matching it
+        mock_supported_id = MagicMock()
+        mocks["SupportedChainId"].return_value = mock_supported_id
+
+        mock_chain_enum_item = MagicMock()
+        mock_chain_enum_item.value = [mock_supported_id]
+
+        # Make Chain iterable
+        mocks["Chain"].__iter__.return_value = [mock_chain_enum_item]
+
+        mock_get_swap.side_effect = lambda name: mocks.get(name, MagicMock())
+        mock_get_quotes.side_effect = mock_get_swap.side_effect
+        yield mocks
+
+
+@pytest.fixture
+def cowswap(mock_chain, mock_cowpy_modules):
+    """CowSwap instance fixture."""
+    return CowSwap("0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", mock_chain)
+
+
+def test_init(cowswap, mock_chain):
+    """Test initialization."""
+    assert cowswap.chain == mock_chain
+    assert cowswap.cow_chain is not None
+
+
+@pytest.mark.asyncio
+async def test_get_max_sell_amount_wei(cowswap, mock_cowpy_modules):
+    """Test get_max_sell_amount_wei."""
+    amount = await cowswap.get_max_sell_amount_wei(100, "0xSell", "0xBuy")
+    # mocked sellAmount root is "100", slippage is 0.005 default -> 100 * 1.005 = 100
+    assert amount == 100
+    mock_cowpy_modules["get_order_quote"].assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_get_max_buy_amount_wei(cowswap, mock_cowpy_modules):
+    """Test get_max_buy_amount_wei."""
+    amount = await cowswap.get_max_buy_amount_wei(100, "0xSell", "0xBuy")
+    # mocked buyAmount root is "90", slippage 0.005 -> 90 * 0.995 = 89.55 -> int 89
+    assert amount == 89
+    mock_cowpy_modules["get_order_quote"].assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_swap_defaults(cowswap, mock_cowpy_modules):
+    """Test swap with default settings."""
+    # Test SWAP with default logic (using swap_tokens from module)
+    # We need to make sure global swap_tokens is None or handled.
+    # In test context, we rely on _get_cowpy_module returning the mock.
+
+    mock_cowpy_modules["swap_tokens"].return_value = MagicMock(uid=MagicMock(root="0x123"))
+
+    # Mock verify order to return True immediately to avoid sleep
+    with patch.object(CowSwap, "check_cowswap_order", return_value={"status": "fulfilled"}):
+        result = await cowswap.swap(100, "OLAS", "WXDAI", order_type=OrderType.SELL)
+        assert result is not None
+        mock_cowpy_modules["swap_tokens"].assert_called()
+
+
+@pytest.mark.asyncio
+async def test_swap_buy_order_type(cowswap, mock_cowpy_modules):
+    """Test swap with BUY order type."""
+    # For BUY order type, it uses self.swap_tokens_to_exact_tokens
+    # checking patching of global swap_tokens
+
+    with patch("iwa.plugins.gnosis.cow.swap.swap_tokens", new=None):
+        with patch.object(
+            CowSwap, "swap_tokens_to_exact_tokens", new_callable=AsyncMock
+        ) as mock_custom_swap:
+            mock_custom_swap.return_value = MagicMock(uid=MagicMock(root="0x123"))
+            with patch.object(CowSwap, "check_cowswap_order", return_value={"status": "fulfilled"}):
+                result = await cowswap.swap(100, "OLAS", "WXDAI", order_type=OrderType.BUY)
+                assert result is not None
+                mock_custom_swap.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_swap_tokens_to_exact_tokens(cowswap, mock_cowpy_modules):
+    """Test swap_tokens_to_exact_tokens custom logic."""
+    # Test the custom implementation
+    # It calls get_order_quote, post_order
+
+    mock_cowpy_modules["post_order"].return_value = "0xOrderUID"
+    mock_cowpy_modules["OrderBookApi"].return_value.get_order_link.return_value = "http://link"
+
+    # Mock CompletedOrder to return an object with attributes set from constructor
+    def side_effect(uid, url):
+        m = MagicMock()
+        m.uid = uid
+        m.url = url
+        return m
+
+    mock_cowpy_modules["CompletedOrder"].side_effect = side_effect
+
+    result = await CowSwap.swap_tokens_to_exact_tokens(
+        amount=100,
+        account=MagicMock(address="0xUser"),
+        chain=MagicMock(value=[100]),
+        sell_token="0xSell",
+        buy_token="0xBuy",
+        env="prod",
+    )
+
+    assert result.uid == "0xOrderUID"
+    assert result.url == "http://link"
+    mock_cowpy_modules["get_order_quote"].assert_called()  # Quote needed for sell amount calc
+    mock_cowpy_modules["post_order"].assert_called()
+
+
+@pytest.mark.asyncio
+async def test_check_cowswap_order_success(cowswap):
+    """Test check_cowswap_order success path."""
+    mock_order = MagicMock()
+    mock_order.url = "http://api/order"
+
+    with patch("requests.get") as mock_get:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {
+            "status": "fulfilled",
+            "executedSellAmount": "100",
+            "executedBuyAmount": "90",
+        }
+
+        # Need to mock loop.run_in_executor since check_cowswap_order uses it
+        # Or just let it run if requests.get is mocked?
+        # check_cowswap_order calls loop.run_in_executor(None, lambda: requests.get(...))
+        # This will run the lambda in a thread. The mock should work.
+
+        result = await cowswap.check_cowswap_order(mock_order)
+
+        assert result == {
+            "status": "fulfilled",
+            "executedSellAmount": "100",
+            "executedBuyAmount": "90",
+        }
+
+
+@pytest.mark.asyncio
+async def test_check_cowswap_order_expired(cowswap):
+    """Test check_cowswap_order expiration."""
+    mock_order = MagicMock()
+    mock_order.url = "http://api/order"
+
+    with patch("requests.get") as mock_get:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {"status": "expired"}
+
+        result = await cowswap.check_cowswap_order(mock_order)
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_check_cowswap_order_timeout(cowswap):
+    """Test check_cowswap_order timeout."""
+    mock_order = MagicMock()
+    mock_order.url = "http://api/order"
+
+    with patch("requests.get") as mock_get:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {"status": "open", "executedSellAmount": "0"}
+
+        # Speed up retry sleep (asyncio.sleep)
+        with patch("asyncio.sleep", new_callable=AsyncMock):
+            result = await cowswap.check_cowswap_order(mock_order)
+            assert result is None

iwa/plugins/gnosis/tests/test_safe.py

@@ -0,0 +1,100 @@
+"""Tests for Safe module."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.core.models import StoredSafeAccount
+from iwa.plugins.gnosis.safe import SafeMultisig
+
+
+@pytest.fixture
+def mock_settings():
+    """Mock settings."""
+    with patch("iwa.plugins.gnosis.safe.settings") as mock:
+        mock.gnosis_rpc.get_secret_value.return_value = "http://rpc"
+        yield mock
+
+
+@pytest.fixture
+def mock_safe_eth():
+    """Mock safe_eth module."""
+    with (
+        patch("iwa.plugins.gnosis.safe.EthereumClient") as mock_client,
+        patch("iwa.plugins.gnosis.safe.Safe") as mock_safe,
+    ):
+        yield mock_client, mock_safe
+
+
+@pytest.fixture
+def safe_account():
+    """Mock safe account."""
+    return StoredSafeAccount(
+        address="0x1234567890123456789012345678901234567890",
+        owners=["0x1234567890123456789012345678901234567890"],
+        threshold=1,
+        chains=["gnosis"],
+        tag="mysafe",
+        signers=[],
+    )
+
+
+def test_init(safe_account, mock_settings, mock_safe_eth):
+    """Test initialization."""
+    ms = SafeMultisig(safe_account, "gnosis")
+    assert ms.multisig is not None
+    mock_safe_eth[0].assert_called_with("http://rpc")  # EthereumClient init
+    mock_safe_eth[1].assert_called()  # Safe init
+
+
+def test_init_invalid_chain(safe_account, mock_settings, mock_safe_eth):
+    """Test initialization with invalid chain."""
+    with pytest.raises(ValueError, match="not deployed on chain"):
+        SafeMultisig(safe_account, "ethereum")
+
+
+def test_getters(safe_account, mock_settings, mock_safe_eth):
+    """Test safe property getters."""
+    ms = SafeMultisig(safe_account, "gnosis")
+    mock_safe_instance = mock_safe_eth[1].return_value
+
+    mock_safe_instance.retrieve_owners.return_value = ["0x1"]
+    assert ms.get_owners() == ["0x1"]
+
+    mock_safe_instance.retrieve_threshold.return_value = 2
+    assert ms.get_threshold() == 2
+
+    mock_safe_instance.retrieve_nonce.return_value = 5
+    assert ms.get_nonce() == 5
+
+    mock_safe_instance.retrieve_all_info.return_value = {"info": "test"}
+    assert ms.retrieve_all_info() == {"info": "test"}
+
+
+def test_build_tx(safe_account, mock_settings, mock_safe_eth):
+    """Test build_multisig_tx."""
+    ms = SafeMultisig(safe_account, "gnosis")
+    mock_safe_instance = mock_safe_eth[1].return_value
+    mock_safe_instance.build_multisig_tx.return_value = "0xTx"
+
+    tx = ms.build_tx("0xTo", 100)
+    assert tx == "0xTx"
+
+    mock_safe_instance.build_multisig_tx.assert_called()
+
+
+def test_send_tx(safe_account, mock_settings, mock_safe_eth):
+    """Test send_multisig_tx."""
+    ms = SafeMultisig(safe_account, "gnosis")
+
+    # Mock build_tx just in case (though it delegates)
+    # Actually we can let it delegate to mock_safe_instance which returns "0xSafeTx"
+    mock_safe_instance = mock_safe_eth[1].return_value
+    mock_safe_instance.build_multisig_tx.return_value = "0xSafeTx"
+
+    callback = MagicMock(return_value="0xHash")
+
+    tx_hash = ms.send_tx("0xTo", 100, callback)
+    assert tx_hash == "0xHash"
+
+    callback.assert_called_with("0xSafeTx")

iwa/plugins/olas/__init__.py

@@ -0,0 +1,5 @@
+"""iwa.plugins.olas package."""
+
+from iwa.plugins.olas.plugin import OlasPlugin
+
+__all__ = ["OlasPlugin"]

iwa/plugins/olas/constants.py

@@ -0,0 +1,106 @@
+"""OLAS protocol constants."""
+
+from enum import IntEnum
+from typing import Dict
+
+from iwa.core.models import EthereumAddress
+
+
+class AgentType(IntEnum):
+    """Supported OLAS agent types."""
+
+    TRADER = 25
+
+
+# Mech Marketplace Payment Types (bytes32 hex strings, without 0x prefix)
+# From mech-client/marketplace_interact.py
+PAYMENT_TYPE_NATIVE = "ba699a34be8fe0e7725e93dcbce1701b0211a8ca61330aaeb8a05bf2ec7abed1"
+PAYMENT_TYPE_TOKEN = "3679d66ef546e66ce9057c4a052f317b135bc8e8c509638f7966edfd4fcf45e9"
+PAYMENT_TYPE_NATIVE_NVM = "803dd08fe79d91027fc9024e254a0942372b92f3ccabc1bd19f4a5c2b251c316"
+PAYMENT_TYPE_TOKEN_NVM_USDC = "0d6fd99afa9c4c580fab5e341922c2a5c4b61d880da60506193d7bf88944dd14"
+
+# Mech Factory to Mech Type mappings by chain
+# From mech-client/mech_marketplace_subgraph.py
+MECH_FACTORY_TO_TYPE: Dict[str, Dict[str, str]] = {
+    "gnosis": {
+        "0x8b299c20F87e3fcBfF0e1B86dC0acC06AB6993EF": "Fixed Price Native",
+        "0x31ffDC795FDF36696B8eDF7583A3D115995a45FA": "Fixed Price Token",
+        "0x65fd74C29463afe08c879a3020323DD7DF02DA57": "NvmSubscription Native",
+    },
+    "base": {
+        "0x2E008211f34b25A7d7c102403c6C2C3B665a1abe": "Fixed Price Native",
+        "0x97371B1C0cDA1D04dFc43DFb50a04645b7Bc9BEe": "Fixed Price Token",
+        "0x847bBE8b474e0820215f818858e23F5f5591855A": "NvmSubscription Native",
+        "0x7beD01f8482fF686F025628e7780ca6C1f0559fc": "NvmSubscription Token USDC",
+    },
+}
+
+TRADER_CONFIG_HASH = "108e90795119d6015274ef03af1a669c6d13ab6acc9e2b2978be01ee9ea2ec93"
+DEFAULT_DEPLOY_PAYLOAD = "0x0000000000000000000000000000000000000000{fallback_handler}000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+
+# OLAS Token address on Gnosis chain
+OLAS_TOKEN_ADDRESS_GNOSIS = EthereumAddress("0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f")
+
+
+# OLAS Protocol Contracts categorized by chain
+# See mech_reference.py for comprehensive documentation of the mech ecosystem
+OLAS_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
+    "gnosis": {
+        "OLAS_SERVICE_REGISTRY": EthereumAddress("0x9338b5153AE39BB89f50468E608eD9d764B755fD"),
+        "OLAS_SERVICE_REGISTRY_TOKEN_UTILITY": EthereumAddress(
+            "0xa45E64d13A30a51b91ae0eb182e88a40e9b18eD8"
+        ),
+        "OLAS_SERVICE_MANAGER": EthereumAddress("0x068a4f0946cF8c7f9C1B58a3b5243Ac8843bf473"),
+        # Legacy mech - used by TRADER staking contracts for liveness
+        "OLAS_MECH": EthereumAddress("0x77af31De935740567Cf4fF1986D04B2c964A786a"),
+        # NEW Marketplace (v2) - no staking support yet
+        "OLAS_MECH_MARKETPLACE": EthereumAddress("0x735FAAb1c4Ec41128c367AFb5c3baC73509f70bB"),
+        # OLD Marketplace (v1) - used by Pearl Beta Mech Marketplace staking
+        "OLAS_MECH_MARKETPLACE_OLD": EthereumAddress("0x4554fE75c1f5576c1d7F765B2A036c199Adae329"),
+    },
+    "ethereum": {
+        "OLAS_SERVICE_REGISTRY": EthereumAddress("0x48b6F34dDAf31f94086BFB45e69e0618DDe3677b"),
+        "OLAS_SERVICE_MANAGER": EthereumAddress("0x9C14948a39a9c1A58e3f94639908F0076FA715C6"),
+    },
+    "base": {
+        "OLAS_SERVICE_REGISTRY": EthereumAddress("0x3841C312061daB948332A78F042Ec61Ad09fc3D8"),
+        "OLAS_SERVICE_MANAGER": EthereumAddress("0xF36183B106692DeD8b6e3B2B7347C9665f8a09B1"),
+        "OLAS_MECH_MARKETPLACE": EthereumAddress("0x4554fE75c1f5576c1d7F765B2A036c199Adae329"),
+    },
+}
+
+# TRADER-compatible staking contracts categorized by chain
+# See https://govern.olas.network/contracts
+# NOTE: All TRADER staking contracts use the LEGACY MECH for activity tracking.
+# The activity checker calls agentMech.getRequestsCount(multisig), where agentMech
+# is hardcoded to the legacy mech (0x77af31De935740567Cf4fF1986D04B2c964A786a).
+#
+# This means:
+#   - Legacy mech requests (use_marketplace=False) -> COUNT for liveness rewards
+#   - Marketplace mech requests (use_marketplace=True) -> DO NOT COUNT
+#
+# For staking rewards, services MUST use legacy mech requests.
+OLAS_TRADER_STAKING_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
+    "gnosis": {
+        "Hobbyist 1 (100 OLAS)": EthereumAddress("0x389B46C259631Acd6a69Bde8B6cEe218230bAE8C"),
+        "Hobbyist 2 (500 OLAS)": EthereumAddress("0x238EB6993b90A978ec6AAD7530D6429c949C08DA"),
+        "Expert (1k OLAS)": EthereumAddress("0x5344B7DD311e5d3DdDd46A4f71481Bd7b05AAA3e"),
+        "Expert 2 (1k OLAS)": EthereumAddress("0xb964e44c126410df341ae04B13aB10A985fE3513"),
+        "Expert 3 (2k OLAS)": EthereumAddress("0x80faD33Cadb5F53f9D29F02Db97D682E8B101618"),
+        "Expert 4 (10k OLAS)": EthereumAddress("0xaD9d891134443B443D7F30013c7e14Fe27F2E029"),
+        "Expert 5 (10k OLAS)": EthereumAddress("0xE56dF1E563De1B10715cB313D514af350D207212"),
+        "Expert 6 (1k OLAS)": EthereumAddress("0x2546214aEE7eEa4bEE7689C81231017CA231Dc93"),
+        "Expert 7 (10k OLAS)": EthereumAddress("0xD7A3C8b975f71030135f1a66E9e23164d54fF455"),
+        "Expert 8 (2k OLAS)": EthereumAddress("0x356C108D49C5eebd21c84c04E9162de41933030c"),
+        "Expert 9 (10k OLAS)": EthereumAddress("0x17dBAe44BC5618Cc254055B386A29576b4F87015"),
+        "Expert 10 (10k OLAS)": EthereumAddress("0xB0ef657b8302bd2c74B6E6D9B2b4b39145b19c6f"),
+        "Expert 11 (10k OLAS)": EthereumAddress("0x3112c1613eAC3dBAE3D4E38CeF023eb9E2C91CF7"),
+        "Expert 12 (10k OLAS)": EthereumAddress("0xF4a75F476801B3fBB2e7093aCDcc3576593Cc1fc"),
+        "Expert 15 (10k OLAS)": EthereumAddress("0x88eB38FF79fBa8C19943C0e5Acfa67D5876AdCC1"),
+        "Expert 16 (10k OLAS)": EthereumAddress("0x6c65430515c70a3f5E62107CC301685B7D46f991"),
+        "Expert 17 (10k OLAS)": EthereumAddress("0x1430107A785C3A36a0C1FC0ee09B9631e2E72aFf"),
+        "Expert 18 (10k OLAS)": EthereumAddress("0x041e679d04Fc0D4f75Eb937Dea729Df09a58e454"),
+    },
+    "ethereum": {},
+    "base": {},
+}

iwa/plugins/olas/contracts/activity_checker.py

@@ -0,0 +1,93 @@
+"""Activity checker contract interaction.
+
+The MechActivityChecker contract tracks liveness for staked services by monitoring:
+- Safe multisig transaction nonces
+- Mech request counts
+
+The liveness check (isRatioPass) verifies that the service is making enough mech
+requests relative to the time elapsed since the last checkpoint.
+"""
+
+from typing import Tuple
+
+from iwa.core.constants import DEFAULT_MECH_CONTRACT_ADDRESS
+from iwa.core.types import EthereumAddress
+from iwa.plugins.olas.contracts.base import OLAS_ABI_PATH, ContractInstance
+
+
+class ActivityCheckerContract(ContractInstance):
+    """Class to interact with the MechActivityChecker contract.
+
+    This contract tracks mech request activity for staked services and determines
+    if they meet the liveness requirements for staking rewards.
+
+    The getMultisigNonces() function returns an array with two values:
+        - nonces[0]: Safe multisig nonce (total transaction count)
+        - nonces[1]: Mech requests count (from AgentMech.getRequestsCount)
+
+    The isRatioPass() function checks if:
+        1. diffRequestsCounts <= diffNonces (requests can't exceed txs)
+        2. ratio = (diffRequestsCounts * 1e18) / time >= livenessRatio
+    """
+
+    name = "activity_checker"
+    abi_path = OLAS_ABI_PATH / "activity_checker.json"
+
+    def __init__(self, address: EthereumAddress, chain_name: str = "gnosis"):
+        """Initialize ActivityCheckerContract.
+
+        Args:
+            address: The activity checker contract address.
+            chain_name: The chain name (default: gnosis).
+
+        """
+        super().__init__(address, chain_name=chain_name)
+
+        # Get the mech address this checker tracks
+        agent_mech_function = getattr(self.contract.functions, "agentMech", None)
+        self.agent_mech = (
+            agent_mech_function().call() if agent_mech_function else DEFAULT_MECH_CONTRACT_ADDRESS
+        )
+
+        # Get liveness ratio (requests per second * 1e18)
+        self.liveness_ratio = self.contract.functions.livenessRatio().call()
+
+    def get_multisig_nonces(self, multisig: EthereumAddress) -> Tuple[int, int]:
+        """Get the nonces for a multisig address.
+
+        Args:
+            multisig: The multisig address to check.
+
+        Returns:
+            Tuple of (safe_nonce, mech_requests_count):
+                - safe_nonce: Total Safe transaction count
+                - mech_requests_count: Total mech requests made
+
+        """
+        nonces = self.contract.functions.getMultisigNonces(multisig).call()
+        return (nonces[0], nonces[1])
+
+    def is_ratio_pass(
+        self,
+        current_nonces: Tuple[int, int],
+        last_nonces: Tuple[int, int],
+        ts_diff: int,
+    ) -> bool:
+        """Check if the liveness ratio requirement is passed.
+
+        The formula checks:
+        1. diffRequestsCounts <= diffNonces (mech requests can't exceed total txs)
+        2. ratio = (diffRequestsCounts * 1e18) / ts_diff >= livenessRatio
+
+        Args:
+            current_nonces: Current (safe_nonce, mech_requests_count).
+            last_nonces: Nonces at last checkpoint (safe_nonce, mech_requests_count).
+            ts_diff: Time difference in seconds since last checkpoint.
+
+        Returns:
+            True if liveness requirements are met.
+
+        """
+        return self.contract.functions.isRatioPass(
+            list(current_nonces), list(last_nonces), ts_diff
+        ).call()

iwa/plugins/olas/contracts/base.py

@@ -0,0 +1,10 @@
+"""Base contract class."""
+
+from pathlib import Path
+
+from iwa.core.contracts.contract import ContractInstance
+
+# OLAS plugin-specific ABI path
+OLAS_ABI_PATH = Path(__file__).parent / "abis"
+
+__all__ = ["ContractInstance", "OLAS_ABI_PATH"]

iwa/plugins/olas/contracts/mech.py

@@ -0,0 +1,49 @@
+"""Mech contract interaction."""
+
+from typing import Dict, Optional
+
+from iwa.core.contracts.contract import ContractInstance
+from iwa.core.types import EthereumAddress
+from iwa.plugins.olas.contracts.base import OLAS_ABI_PATH
+
+
+class MechContract(ContractInstance):
+    """Class to interact with the Mech contract."""
+
+    def __init__(
+        self,
+        address: EthereumAddress,
+        chain_name: str,
+        use_new_abi: bool = False,
+    ):
+        """Initialize the contract."""
+        self.use_new_abi = use_new_abi
+        if use_new_abi:
+            self.abi_path = OLAS_ABI_PATH / "mech_new.json"
+        else:
+            self.abi_path = OLAS_ABI_PATH / "mech.json"
+        super().__init__(address, chain_name)
+
+    def get_price(self) -> int:
+        """Get the current price for a request."""
+        try:
+            return self.call("price")
+        except Exception:
+            # Fallback for new ABIs if price() is not there
+            return 10**16  # 0.01 xDAI
+
+    def prepare_request_tx(
+        self,
+        from_address: EthereumAddress,
+        data: bytes,
+        value: Optional[int] = None,
+    ) -> Optional[Dict]:
+        """Prepare a request transaction."""
+        if value is None:
+            value = self.get_price()
+
+        return self.prepare_transaction(
+            method_name="request",
+            method_kwargs={"data": data},
+            tx_params={"from": from_address, "value": value},
+        )

iwa/plugins/olas/contracts/mech_marketplace.py

@@ -0,0 +1,43 @@
+"""Mech Marketplace contract interaction."""
+
+from typing import Dict, Optional
+
+from iwa.core.contracts.contract import ContractInstance
+from iwa.core.types import EthereumAddress
+from iwa.plugins.olas.contracts.base import OLAS_ABI_PATH
+
+
+class MechMarketplaceContract(ContractInstance):
+    """Class to interact with the Mech Marketplace contract."""
+
+    name = "mech_marketplace"
+    abi_path = OLAS_ABI_PATH / "mech_marketplace.json"
+
+    def prepare_request_tx(
+        self,
+        from_address: EthereumAddress,
+        request_data: bytes,
+        priority_mech: EthereumAddress,
+        response_timeout: int = 300,
+        max_delivery_rate: int = 10_000,
+        payment_type: bytes = b"\x00" * 32,
+        payment_data: bytes = b"",
+        value: int = 10_000_000_000_000_000,  # Default 0.01 xDAI
+    ) -> Optional[Dict]:
+        """Prepare a marketplace request transaction.
+
+        Matches ABI:
+        request(bytes requestData, uint256 maxDeliveryRate, bytes32 paymentType, address priorityMech, uint256 responseTimeout, bytes paymentData)
+        """
+        return self.prepare_transaction(
+            method_name="request",
+            method_kwargs={
+                "requestData": request_data,
+                "maxDeliveryRate": max_delivery_rate,
+                "paymentType": payment_type,
+                "priorityMech": priority_mech,
+                "responseTimeout": response_timeout,
+                "paymentData": payment_data,
+            },
+            tx_params={"from": from_address, "value": value},
+        )