mech-client 0.12.1__tar.gz → 0.14.0__tar.gz

{mech_client-0.12.1 → mech_client-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mech-client
-Version: 0.12.1
+Version: 0.14.0
 Summary: Basic client to interact with a mech
 License: Apache-2.0
 Author: David Minarsch

mech_client-0.14.0/mech_client/__init__.py

@@ -0,0 +1,3 @@
+"""Mech client."""
+
+__version__ = "0.14.0"

{mech_client-0.12.1 → mech_client-0.14.0}/mech_client/cli.py

@@ -180,11 +180,6 @@ def interact(  # pylint: disable=too-many-arguments,too-many-locals
                 private_key_path=key,
                 tools=tools,
                 extra_attributes=extra_attributes_dict,
-                confirmation_type=(
-                    ConfirmationType(confirm)
-                    if confirm is not None
-                    else ConfirmationType.WAIT_FOR_BOTH
-                ),
                 retries=retries,
                 timeout=timeout,
                 sleep=sleep,

mech_client-0.14.0/mech_client/delivery.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2025 Valory AG
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+# ------------------------------------------------------------------------------
+
+"""Onchain delivery helpers."""
+
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+from aea_ledger_ethereum import EthereumApi
+from eth_abi import decode
+from web3.constants import ADDRESS_ZERO
+from web3.contract import Contract as Web3Contract
+
+
+WAIT_SLEEP = 3.0
+DELIVERY_MECH_INDEX = 1
+DEFAULT_TIMEOUT = 900.0  # 15mins
+IPFS_URL_TEMPLATE = "https://gateway.autonolas.tech/ipfs/f01701220{}"
+
+
+async def watch_for_marketplace_data(  # pylint: disable=too-many-arguments, unused-argument, too-many-locals
+    request_ids: List[str],
+    marketplace_contract: Web3Contract,
+    timeout: Optional[float] = None,
+) -> Any:
+    """
+    Watches for data on-chain.
+
+    :param request_ids: The IDs of the request.
+    :type request_ids: List[str]
+    :param marketplace_contract: The marketplace contract instance.
+    :type marketplace_contract: Web3Contract
+    :param timeout: Timeout to wait for the onchain data
+    :type timeout: float
+    :return: The data received from on-chain.
+    :rtype: Any
+    """
+    request_ids_data: Dict = {}
+    start_time = time.time()
+    # either use the timeout supplied by user or the default timeout of 15mins
+    timeout = timeout or DEFAULT_TIMEOUT
+    while True:
+        for request_id in request_ids:
+            request_id_info = marketplace_contract.functions.mapRequestIdInfos(
+                bytes.fromhex(request_id)
+            ).call()
+
+            # return empty data which is handled in the main method
+            if len(request_id_info) <= DELIVERY_MECH_INDEX:
+                return request_ids_data
+
+            delivery_mech = request_id_info[DELIVERY_MECH_INDEX]
+            if not isinstance(delivery_mech, str) or not delivery_mech.startswith("0x"):
+                return request_id_info
+
+            if delivery_mech != ADDRESS_ZERO:
+                request_ids_data.update({request_id: delivery_mech})
+
+            time.sleep(WAIT_SLEEP)
+
+            elapsed_time = time.time() - start_time
+            if elapsed_time >= timeout:
+                print("Timeout reached. Breaking the loop and returning empty data.")
+                return request_ids_data
+
+        if len(request_ids_data) == len(request_ids):
+            return request_ids_data
+
+
+async def watch_for_mech_data_url(  # pylint: disable=too-many-arguments, unused-argument, too-many-locals
+    request_ids: List[str],
+    from_block: int,
+    mech_contract_address: str,
+    mech_deliver_signature: str,
+    ledger_api: EthereumApi,
+    timeout: Optional[float] = None,
+) -> Any:
+    """
+    Watches for data on-chain.
+
+    :param request_ids: The IDs of the request.
+    :type request_ids: List[str]
+    :param from_block: The from block to start searching logs.
+    :type from_block: int
+    :param mech_contract_address: The mech contract instance.
+    :type mech_contract_address: str
+    :param mech_deliver_signature: Topic signature for Deliver event
+    :type mech_deliver_signature: str
+    :param ledger_api: The Ethereum API used for interacting with the ledger.
+    :type ledger_api: EthereumApi
+    :param timeout: Timeout to wait for the onchain data
+    :type timeout: float
+    :return: The data received from on-chain.
+    :rtype: Any
+    """
+
+    results = {}
+    start_time = time.time()
+    # either use the timeout supplied by user or the default timeout of 15mins
+    timeout = timeout or DEFAULT_TIMEOUT
+
+    def get_logs(from_block_: int) -> List:
+        logs = ledger_api.api.eth.get_logs(
+            {
+                "fromBlock": from_block_,
+                "toBlock": "latest",
+                "address": mech_contract_address,
+                "topics": ["0x" + mech_deliver_signature],
+            }
+        )
+        return logs
+
+    def get_event_data(log: Dict) -> Tuple:
+        data_types = ["bytes32", "uint256", "bytes"]
+        data_bytes = bytes(log["data"])
+        request_id_bytes, _, delivery_data_bytes = decode(data_types, data_bytes)
+        return request_id_bytes, delivery_data_bytes
+
+    while True:
+        logs = get_logs(from_block)
+        latest_block = from_block
+        for log in logs:
+            latest_block = max(latest_block, log["blockNumber"])
+            event_data = get_event_data(log)
+            request_id, delivery_data = (data.hex() for data in event_data)
+            if request_id in results:
+                continue
+
+            if request_id in request_ids:
+                results[request_id] = IPFS_URL_TEMPLATE.format(delivery_data)
+
+            if len(results) == len(request_ids):
+                return results
+
+        from_block = latest_block + 1
+        time.sleep(WAIT_SLEEP)
+        elapsed_time = time.time() - start_time
+        if elapsed_time >= timeout:
+            print("Timeout reached. Breaking the loop and returning empty data.")
+            return results

{mech_client-0.12.1 → mech_client-0.14.0}/mech_client/interact.py

@@ -200,7 +200,7 @@ def calculate_topic_id(event: Dict) -> str:
     return Web3.keccak(text=text).hex()
 
 
-def get_event_signatures(abi: List) -> Tuple[str, str]:
+def get_mech_event_signatures(abi: List) -> Tuple[str, str]:
     """Calculate `Request` and `Deliver` event topics"""
     request, deliver = "", ""
     for obj in abi:
@@ -576,13 +576,16 @@ def interact(  # pylint: disable=too-many-arguments,too-many-locals
     mech_contract = get_contract(
         contract_address=contract_address, abi=abi, ledger_api=ledger_api
     )
-    request_event_signature, deliver_event_signature = get_event_signatures(abi=abi)
+    request_event_signature, deliver_event_signature = get_mech_event_signatures(
+        abi=abi
+    )
     register_event_handlers(
         wss=wss,
-        contract_address=contract_address,
+        mech_contract_address=contract_address,
+        marketplace_contract_address=contract_address,
         crypto=crypto,
-        request_signature=request_event_signature,
-        deliver_signature=deliver_event_signature,
+        mech_request_signature=request_event_signature,
+        marketplace_deliver_signature=deliver_event_signature,
     )
     print("Sending Mech request...")
     price = mech_config.price or 10_000_000_000_000_000

{mech_client-0.12.1 → mech_client-0.14.0}/mech_client/marketplace_interact.py

@@ -24,40 +24,35 @@ import asyncio
 import json
 import sys
 import time
+from collections import defaultdict
 from dataclasses import asdict, make_dataclass
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, Optional, Tuple, cast
+from typing import Any, Dict, List, Optional, Tuple, cast
 
 import requests
-import websocket
 from aea.crypto.base import Crypto
 from aea_ledger_ethereum import EthereumApi, EthereumCrypto
 from eth_utils import to_checksum_address
+from web3._utils.events import event_abi_to_log_topic
 from web3.constants import ADDRESS_ZERO
 from web3.contract import Contract as Web3Contract
 
+from mech_client.delivery import watch_for_marketplace_data, watch_for_mech_data_url
 from mech_client.fetch_ipfs_hash import fetch_ipfs_hash
 from mech_client.interact import (
-    ConfirmationType,
     MAX_RETRIES,
     MechMarketplaceRequestConfig,
     PRIVATE_KEY_FILE_PATH,
     TIMEOUT,
     WAIT_SLEEP,
     get_contract,
-    get_event_signatures,
     get_mech_config,
 )
 from mech_client.mech_marketplace_tool_management import get_mech_tools
 from mech_client.prompt_to_ipfs import push_metadata_to_ipfs
-from mech_client.wss import (
-    register_event_handlers,
-    wait_for_receipt,
-    watch_for_marketplace_data_url_from_wss,
-    watch_for_marketplace_request_ids,
-)
+from mech_client.wss import wait_for_receipt, watch_for_marketplace_request_ids
 
 
 # false positives for [B105:hardcoded_password_string] Possible hardcoded password
@@ -122,11 +117,36 @@ CHAIN_TO_DEFAULT_MECH_MARKETPLACE_REQUEST_CONFIG = {
 }
 
 
+def fetch_mech_deliver_event_signature(
+    ledger_api: EthereumApi,
+    priority_mech_address: str,
+) -> str:
+    """
+    Fetchs the mech's deliver event signature.
+
+    :param ledger_api: The Ethereum API used for interacting with the ledger.
+    :type ledger_api: EthereumApi
+    :param priority_mech_address: Requested mech address
+    :type priority_mech_address: str
+    :return: The event signature.
+    :rtype: str
+    """
+    with open(IMECH_ABI_PATH, encoding="utf-8") as f:
+        abi = json.load(f)
+
+    mech_contract = get_contract(
+        contract_address=priority_mech_address, abi=abi, ledger_api=ledger_api
+    )
+    deliver_event_abi = mech_contract.events.Deliver().abi
+    mech_deliver_event_signature = event_abi_to_log_topic(deliver_event_abi)
+    return mech_deliver_event_signature.hex()
+
+
 def fetch_mech_info(
     ledger_api: EthereumApi,
     mech_marketplace_contract: Web3Contract,
     priority_mech_address: str,
-) -> Tuple[str, int, int, str, Web3Contract]:
+) -> Tuple[str, int, int, str]:
     """
     Fetchs the info of the requested mech.
 
@@ -136,8 +156,8 @@ def fetch_mech_info(
     :type mech_marketplace_contract: Web3Contract
     :param priority_mech_address: Requested mech address
     :type priority_mech_address: str
-    :return: The mech info containing payment_type, service_id, max_delivery_rate, mech_payment_balance_tracker and Mech contract.
-    :rtype: Tuple[str, int, int, str, Contract]
+    :return: The mech info containing payment_type, service_id, max_delivery_rate and mech_payment_balance_tracker.
+    :rtype: Tuple[str, int, int, str]
     """
 
     with open(IMECH_ABI_PATH, encoding="utf-8") as f:
@@ -166,7 +186,6 @@ def fetch_mech_info(
         service_id,
         max_delivery_rate,
         mech_payment_balance_tracker,
-        mech_contract,
     )
 
 
@@ -495,80 +514,80 @@ def send_offchain_marketplace_request(  # pylint: disable=too-many-arguments,too
 
 
 def wait_for_marketplace_data_url(  # pylint: disable=too-many-arguments, unused-argument
-    request_id: str,
-    wss: websocket.WebSocket,
-    mech_contract: Web3Contract,
-    subgraph_url: str,
+    request_ids: List[str],
+    from_block: int,
+    marketplace_contract: Web3Contract,
     deliver_signature: str,
     ledger_api: EthereumApi,
-    crypto: Crypto,
-    confirmation_type: ConfirmationType = ConfirmationType.WAIT_FOR_BOTH,
+    timeout: Optional[float] = None,
 ) -> Any:
     """
     Wait for data from on-chain/off-chain.
 
-    :param request_id: The ID of the request.
-    :type request_id: str
-    :param wss: The WebSocket connection object.
-    :type wss: websocket.WebSocket
-    :param mech_contract: The mech contract instance.
-    :type mech_contract: Web3Contract
-    :param subgraph_url: Subgraph URL.
-    :type subgraph_url: str
-    :param deliver_signature: Topic signature for MarketplaceDeliver event
+    :param request_ids: The IDs of the request.
+    :type request_ids: List[str]
+    :param from_block: The from block to start searching logs.
+    :type from_block: int
+    :param marketplace_contract: The mech contract instance.
+    :type marketplace_contract: Web3Contract
+    :param deliver_signature: Topic signature for Deliver event
     :type deliver_signature: str
     :param ledger_api: The Ethereum API used for interacting with the ledger.
     :type ledger_api: EthereumApi
-    :param crypto: The cryptographic object.
-    :type crypto: Crypto
-    :param confirmation_type: The confirmation type for the interaction (default: ConfirmationType.WAIT_FOR_BOTH).
-    :type confirmation_type: ConfirmationType
-    :return: The data received from on-chain/off-chain.
+    :param timeout: Timeout to wait for the onchain data
+    :type timeout: float
+    :return: The data received from on-chain.
     :rtype: Any
     """
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
-    tasks = []
-
-    if confirmation_type in (
-        ConfirmationType.OFF_CHAIN,
-        ConfirmationType.WAIT_FOR_BOTH,
-    ):
-        print("Off chain to be implemented")
-
-    if confirmation_type in (
-        ConfirmationType.ON_CHAIN,
-        ConfirmationType.WAIT_FOR_BOTH,
-    ):
-        on_chain_task = loop.create_task(
-            watch_for_marketplace_data_url_from_wss(
-                request_id=request_id,
-                wss=wss,
-                mech_contract=mech_contract,
-                deliver_signature=deliver_signature,
+
+    async def _wait_for_marketplace_delivery_event() -> Any:  # type: ignore
+        data = await watch_for_marketplace_data(
+            request_ids=request_ids,
+            marketplace_contract=marketplace_contract,
+            timeout=timeout,
+        )
+        return data
+
+    async def _wait_for_mech_data(future) -> Any:  # type: ignore
+        marketplace_data_result = await future
+        requests_by_delivery_mech = defaultdict(list)
+        results: Dict = {}
+
+        # return with empty data is result is unexpected
+        if len(marketplace_data_result) == 0:
+            return results
+
+        for request_id, delivery_mech in marketplace_data_result.items():
+            requests_by_delivery_mech[delivery_mech].append(request_id)
+
+        for delivery_mech, request_ids in requests_by_delivery_mech.items():
+            data = await watch_for_mech_data_url(
+                request_ids=request_ids,
+                from_block=from_block,
+                mech_contract_address=delivery_mech,
+                mech_deliver_signature=deliver_signature,
                 ledger_api=ledger_api,
-                loop=loop,
+                timeout=timeout,
             )
-        )
-        tasks.append(on_chain_task)
+            results.update(data)
 
-        if subgraph_url:
-            print("Subgraph to be implemented")
+        return results
 
-    async def _wait_for_tasks() -> Any:  # type: ignore
-        """Wait for tasks to finish."""
-        (finished, *_), unfinished = await asyncio.wait(
-            tasks,
-            return_when=asyncio.FIRST_COMPLETED,
-        )
-        for task in unfinished:
-            task.cancel()
-        if unfinished:
-            await asyncio.wait(unfinished)
-        return finished.result()
+    marketplace_delivery_event_future = loop.create_task(
+        _wait_for_marketplace_delivery_event()
+    )
+    mech_data_future = loop.create_task(
+        _wait_for_mech_data(marketplace_delivery_event_future)
+    )
+
+    loop.run_until_complete(
+        asyncio.gather(marketplace_delivery_event_future, mech_data_future)
+    )
+    loop.close()
 
-    result = loop.run_until_complete(_wait_for_tasks())
-    return result
+    return mech_data_future.result()
 
 
 def wait_for_offchain_marketplace_data(mech_offchain_url: str, request_id: str) -> Any:
@@ -679,7 +698,6 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
     tools: tuple = (),
     extra_attributes: Optional[Dict[str, Any]] = None,
     private_key_path: Optional[str] = None,
-    confirmation_type: ConfirmationType = ConfirmationType.WAIT_FOR_BOTH,
     retries: Optional[int] = None,
     timeout: Optional[float] = None,
     sleep: Optional[float] = None,
@@ -704,8 +722,6 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
     :type extra_attributes: Optional[Dict[str, Any]]
     :param private_key_path: The path to the private key file (optional).
     :type private_key_path: Optional[str]
-    :param confirmation_type: The confirmation type for the interaction (default: ConfirmationType.WAIT_FOR_BOTH).
-    :type confirmation_type: ConfirmationType
     :return: The data received from on-chain/off-chain.
     :param retries: Number of retries for sending a transaction
     :type retries: int
@@ -745,7 +761,7 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
         ((k, type(v)) for k, v in config_values.items()),
     )(**config_values)
 
-    contract_address = cast(
+    marketplace_contract_address = cast(
         str, mech_marketplace_request_config.mech_marketplace_contract
     )
 
@@ -755,7 +771,6 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
             f"Private key file `{private_key_path}` does not exist!"
         )
 
-    wss = websocket.create_connection(mech_config.wss_endpoint)
     crypto = EthereumCrypto(private_key_path=private_key_path)
     ledger_api = EthereumApi(**asdict(ledger_config))
 
@@ -763,7 +778,7 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
         abi = json.load(f)
 
     mech_marketplace_contract = get_contract(
-        contract_address=contract_address, abi=abi, ledger_api=ledger_api
+        contract_address=marketplace_contract_address, abi=abi, ledger_api=ledger_api
     )
 
     print("Fetching Mech Info...")
@@ -775,7 +790,6 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
         service_id,
         max_delivery_rate,
         mech_payment_balance_tracker,
-        mech_contract,
     ) = fetch_mech_info(
         ledger_api,
         mech_marketplace_contract,
@@ -784,23 +798,12 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
     mech_marketplace_request_config.delivery_rate = max_delivery_rate
     mech_marketplace_request_config.payment_type = payment_type
 
-    verify_tools(tools, service_id, chain_config)
-
-    with open(IMECH_ABI_PATH, encoding="utf-8") as f:
-        abi = json.load(f)
-
-    (
-        marketplace_request_event_signature,
-        marketplace_deliver_event_signature,
-    ) = get_event_signatures(abi=abi)
-    register_event_handlers(
-        wss=wss,
-        contract_address=priority_mech_address,
-        crypto=crypto,
-        request_signature=marketplace_request_event_signature,
-        deliver_signature=marketplace_deliver_event_signature,
+    mech_deliver_event_signature = fetch_mech_deliver_event_signature(
+        ledger_api, priority_mech_address
     )
 
+    verify_tools(tools, service_id, chain_config)
+
     if not use_prepaid:
         price = max_delivery_rate * num_requests
         if payment_type == PaymentType.TOKEN.value:
@@ -860,6 +863,12 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
         # set price 0 to not send any msg.value in request transaction for nvm type mech
         price = 0
 
+    # from block to be used to search for onchain events
+    # and is selected before the request is sent
+    # so searching for deliver events in the logs will not be missed
+    w3 = ledger_api.api.eth
+    latest_block = w3.block_number
+
     if not use_offchain:
         print("Sending Mech Marketplace request...")
         transaction_digest = send_marketplace_request(
@@ -904,36 +913,36 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
             )
         print("")
 
-        for request_id, request_id_int in zip(request_ids, request_id_ints):
-            data_url = wait_for_marketplace_data_url(
-                request_id=request_id,
-                wss=wss,
-                mech_contract=mech_contract,
-                subgraph_url=mech_config.subgraph_url,
-                deliver_signature=marketplace_deliver_event_signature,
-                ledger_api=ledger_api,
-                crypto=crypto,
-                confirmation_type=confirmation_type,
+        data_urls = wait_for_marketplace_data_url(
+            request_ids=request_ids,
+            from_block=latest_block,
+            marketplace_contract=mech_marketplace_contract,
+            deliver_signature=mech_deliver_event_signature,
+            ledger_api=ledger_api,
+            timeout=timeout,
+        )
+
+        if not data_urls:
+            print("Cannot find any data urls for the request(s)")
+            return None
+
+        if is_nvm_mech:
+            requester_total_balance_after = fetch_requester_nvm_subscription_balance(
+                requester,
+                ledger_api,
+                mech_payment_balance_tracker,
+                payment_type,
+            )
+            print(
+                f"  - Sender Subscription balance after delivery: {requester_total_balance_after}"
             )
 
-            if data_url:
-                if is_nvm_mech:
-                    requester_total_balance_after = (
-                        fetch_requester_nvm_subscription_balance(
-                            requester,
-                            ledger_api,
-                            mech_payment_balance_tracker,
-                            payment_type,
-                        )
-                    )
-                    print(
-                        f"  - Sender Subscription balance after delivery: {requester_total_balance_after}"
-                    )
-
-                print(f"  - Data arrived: {data_url}")
-                data = requests.get(f"{data_url}/{request_id_int}", timeout=30).json()
-                print("  - Data from agent:")
-                print(json.dumps(data, indent=2))
+        for request_id, data_url in data_urls.items():
+            request_id_int = int.from_bytes(bytes.fromhex(request_id), byteorder="big")
+            print(f"  - Data arrived: {data_url}")
+            data = requests.get(f"{data_url}/{request_id_int}", timeout=30).json()
+            print("  - Data from agent:")
+            print(json.dumps(data, indent=2))
         return None
 
     print("Sending Offchain Mech Marketplace request...")

{mech_client-0.12.1 → mech_client-0.14.0}/mech_client/wss.py

@@ -31,26 +31,32 @@ from aea_ledger_ethereum import EthereumApi
 from web3.contract import Contract as Web3Contract
 
 
-def register_event_handlers(
+IPFS_URL_TEMPLATE = "https://gateway.autonolas.tech/ipfs/f01701220{}"
+
+
+def register_event_handlers(  # pylint: disable=too-many-arguments
     wss: websocket.WebSocket,
-    contract_address: str,
+    mech_contract_address: str,
+    marketplace_contract_address: str,
     crypto: Crypto,
-    request_signature: str,
-    deliver_signature: str,
+    mech_request_signature: str,
+    marketplace_deliver_signature: str,
 ) -> None:
     """
     Register event handlers.
 
     :param wss: The WebSocket connection object.
     :type wss: websocket.WebSocket
-    :param contract_address: The address of the contract.
-    :type contract_address: str
+    :param mech_contract_address: The address of the mech contract.
+    :type mech_contract_address: str
+    :param marketplace_contract_address: The address of the marketplace contract.
+    :type marketplace_contract_address: str
     :param crypto: The cryptographic object.
     :type crypto: Crypto
-    :param request_signature: Topic signature for Request event
-    :type request_signature: str
-    :param deliver_signature: Topic signature for Deliver event
-    :type deliver_signature: str
+    :param mech_request_signature: Topic signature for Request event
+    :type mech_request_signature: str
+    :param marketplace_deliver_signature: Topic signature for MarketplaceDelivery event
+    :type marketplace_deliver_signature: str
     """
 
     subscription_request = {
@@ -60,9 +66,9 @@ def register_event_handlers(
         "params": [
             "logs",
             {
-                "address": contract_address,
+                "address": mech_contract_address,
                 "topics": [
-                    request_signature,
+                    mech_request_signature,
                     ["0x" + "0" * 24 + crypto.address[2:]],
                 ],
             },
@@ -73,16 +79,20 @@ def register_event_handlers(
 
     # registration confirmation
     _ = wss.recv()
-    subscription_deliver = {
+
+    marketplace_subscription_deliver = {
         "jsonrpc": "2.0",
         "id": 1,
         "method": "eth_subscribe",
         "params": [
             "logs",
-            {"address": contract_address, "topics": [deliver_signature]},
+            {
+                "address": marketplace_contract_address,
+                "topics": [marketplace_deliver_signature],
+            },
         ],
     }
-    content = bytes(json.dumps(subscription_deliver), "utf-8")
+    content = bytes(json.dumps(marketplace_subscription_deliver), "utf-8")
     wss.send(content)
 
     # registration confirmation
@@ -224,62 +234,3 @@ async def watch_for_data_url_from_wss(  # pylint: disable=too-many-arguments
                 "Error: The WSS connection was likely closed by the remote party. Please, try using another WSS provider."
             )
             return None
-
-
-async def watch_for_marketplace_data_url_from_wss(  # pylint: disable=too-many-arguments, unused-argument
-    request_id: str,
-    wss: websocket.WebSocket,
-    mech_contract: Web3Contract,
-    deliver_signature: str,
-    ledger_api: EthereumApi,
-    loop: asyncio.AbstractEventLoop,
-) -> Any:
-    """
-    Watches for data on-chain.
-
-    :param request_id: The ID of the request.
-    :type request_id: str
-    :param wss: The WebSocket connection object.
-    :type wss: websocket.WebSocket
-    :param mech_contract: The mech contract instance.
-    :type mech_contract: Web3Contract
-    :param deliver_signature: Topic signature for Deliver event
-    :type deliver_signature: str
-    :param ledger_api: The Ethereum API used for interacting with the ledger.
-    :type ledger_api: EthereumApi
-    :param loop: The event loop used for asynchronous operations.
-    :type loop: asyncio.AbstractEventLoop
-    :return: The data received from on-chain.
-    :rtype: Any
-    """
-    with ThreadPoolExecutor() as executor:
-        try:
-            while True:
-                msg = await loop.run_in_executor(executor=executor, func=wss.recv)
-                data = json.loads(msg)
-                tx_hash = data["params"]["result"]["transactionHash"]
-                tx_receipt = await loop.run_in_executor(
-                    executor, wait_for_receipt, tx_hash, ledger_api
-                )
-
-                rich_logs = mech_contract.events.Deliver().process_receipt(tx_receipt)
-                if len(rich_logs) == 0:
-                    print("Empty logs")
-                    return None
-
-                data = rich_logs[0]["args"]
-                tx_request_id = data["requestId"]
-                deliver_data = data["data"]
-
-                if request_id != tx_request_id.hex():
-                    continue
-
-                return (
-                    f"https://gateway.autonolas.tech/ipfs/f01701220{deliver_data.hex()}"
-                )
-        except websocket.WebSocketConnectionClosedException as e:
-            print(f"WebSocketConnectionClosedException {repr(e)}")
-            print(
-                "Error: The WSS connection was likely closed by the remote party. Please, try using another WSS provider."
-            )
-            return None

{mech_client-0.12.1 → mech_client-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "mech-client"
-version = "0.12.1"
+version = "0.14.0"
 description = "Basic client to interact with a mech"
 authors = ["David Minarsch <david.minarsch@googlemail.com>"]
 readme = "README.md"

mech_client-0.12.1/mech_client/__init__.py

@@ -1,3 +0,0 @@
-"""Mech client."""
-
-__version__ = "0.12.1"