mech-client 0.3.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

mech_client/marketplace_interact.py

@@ -26,8 +26,9 @@ import sys
 import time
 from dataclasses import asdict, make_dataclass
 from datetime import datetime
+from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, cast
+from typing import Any, Dict, Optional, Tuple, cast
 
 import requests
 import websocket
@@ -45,8 +46,8 @@ from mech_client.interact import (
     PRIVATE_KEY_FILE_PATH,
     TIMEOUT,
     WAIT_SLEEP,
-    calculate_topic_id,
     get_contract,
+    get_event_signatures,
     get_mech_config,
 )
 from mech_client.prompt_to_ipfs import push_metadata_to_ipfs
@@ -54,54 +55,70 @@ from mech_client.wss import (
     register_event_handlers,
     wait_for_receipt,
     watch_for_marketplace_data_url_from_wss,
-    watch_for_marketplace_request_id,
+    watch_for_marketplace_request_ids,
 )
 
 
 # false positives for [B105:hardcoded_password_string] Possible hardcoded password
-PAYMENT_TYPE_NATIVE = (
-    "ba699a34be8fe0e7725e93dcbce1701b0211a8ca61330aaeb8a05bf2ec7abed1"  # nosec
-)
-PAYMENT_TYPE_TOKEN = (
-    "3679d66ef546e66ce9057c4a052f317b135bc8e8c509638f7966edfd4fcf45e9"  # nosec
+class PaymentType(Enum):
+    """Payment type."""
+
+    NATIVE = "ba699a34be8fe0e7725e93dcbce1701b0211a8ca61330aaeb8a05bf2ec7abed1"  # nosec
+    TOKEN = "3679d66ef546e66ce9057c4a052f317b135bc8e8c509638f7966edfd4fcf45e9"  # nosec
+    NATIVE_NVM = (
+        "803dd08fe79d91027fc9024e254a0942372b92f3ccabc1bd19f4a5c2b251c316"  # nosec
+    )
+    TOKEN_NVM = (
+        "0d6fd99afa9c4c580fab5e341922c2a5c4b61d880da60506193d7bf88944dd14"  # nosec
+    )
+
+
+IPFS_URL_TEMPLATE = "https://gateway.autonolas.tech/ipfs/f01701220{}"
+ABI_DIR_PATH = Path(__file__).parent / "abis"
+IMECH_ABI_PATH = ABI_DIR_PATH / "IMech.json"
+ITOKEN_ABI_PATH = ABI_DIR_PATH / "IToken.json"
+IERC1155_ABI_PATH = ABI_DIR_PATH / "IERC1155.json"
+MARKETPLACE_ABI_PATH = ABI_DIR_PATH / "MechMarketplace.json"
+
+BALANCE_TRACKER_NATIVE_ABI_PATH = ABI_DIR_PATH / "BalanceTrackerFixedPriceNative.json"
+BALANCE_TRACKER_TOKEN_ABI_PATH = ABI_DIR_PATH / "BalanceTrackerFixedPriceToken.json"
+BALANCE_TRACKER_NVM_NATIVE_ABI_PATH = (
+    ABI_DIR_PATH / "BalanceTrackerNvmSubscriptionNative.json"
 )
-PAYMENT_TYPE_NVM = (
-    "803dd08fe79d91027fc9024e254a0942372b92f3ccabc1bd19f4a5c2b251c316"  # nosec
+BALANCE_TRACKER_NVM_TOKEN_ABI_PATH = (
+    ABI_DIR_PATH / "BalanceTrackerNvmSubscriptionToken.json"
 )
 
-CHAIN_TO_WRAPPED_TOKEN = {
-    1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    10: "0x4200000000000000000000000000000000000006",
-    100: "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d",
-    137: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-    8453: "0x4200000000000000000000000000000000000006",
-    42220: "0x471EcE3750Da237f93B8E339c536989b8978a438",
+
+PAYMENT_TYPE_TO_ABI_PATH: Dict[str, Path] = {
+    PaymentType.NATIVE.value: BALANCE_TRACKER_NATIVE_ABI_PATH,
+    PaymentType.TOKEN.value: BALANCE_TRACKER_TOKEN_ABI_PATH,
+    PaymentType.NATIVE_NVM.value: BALANCE_TRACKER_NVM_NATIVE_ABI_PATH,
+    PaymentType.TOKEN_NVM.value: BALANCE_TRACKER_NVM_TOKEN_ABI_PATH,
+}
+
+CHAIN_TO_PRICE_TOKEN = {
+    1: "0x0001A500A6B18995B03f44bb040A5fFc28E45CB0",
+    10: "0xFC2E6e6BCbd49ccf3A5f029c79984372DcBFE527",
+    100: "0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f",
+    137: "0xFEF5d947472e72Efbb2E388c730B7428406F2F95",
+    8453: "0x54330d28ca3357F294334BDC454a032e7f353416",
+    42220: "0xFEF5d947472e72Efbb2E388c730B7428406F2F95",
 }
 
 
 CHAIN_TO_DEFAULT_MECH_MARKETPLACE_REQUEST_CONFIG = {
     100: {
-        "mech_marketplace_contract": "0x735FAAb1c4Ec41128c367AFb5c3baC73509f70bB",
-        "priority_mech_address": "0x478ad20eD958dCC5AD4ABa6F4E4cc51e07a840E4",
         "response_timeout": 300,
         "payment_data": "0x",
-    }
+    },
+    8453: {
+        "response_timeout": 300,
+        "payment_data": "0x",
+    },
 }
 
 
-def get_event_signatures(abi: List) -> Tuple[str, str]:
-    """Calculate `Marketplace Request` and `Marketplace Deliver` event topics"""
-    marketplace_request, marketplace_deliver = "", ""
-    for obj in abi:
-        if obj["type"] != "event":
-            continue
-        if obj["name"] == "MarketplaceDeliver":
-            marketplace_deliver = calculate_topic_id(event=obj)
-        if obj["name"] == "MarketplaceRequest":
-            marketplace_request = calculate_topic_id(event=obj)
-    return marketplace_request, marketplace_deliver
-
-
 def fetch_mech_info(
     ledger_api: EthereumApi,
     mech_marketplace_contract: Web3Contract,
@@ -120,7 +137,7 @@ def fetch_mech_info(
     :rtype: Tuple[str, int, int, str, Contract]
     """
 
-    with open(Path(__file__).parent / "abis" / "IMech.json", encoding="utf-8") as f:
+    with open(IMECH_ABI_PATH, encoding="utf-8") as f:
         abi = json.load(f)
 
     mech_contract = get_contract(
@@ -137,7 +154,7 @@ def fetch_mech_info(
         ).call()
     )
 
-    if payment_type not in [PAYMENT_TYPE_NATIVE, PAYMENT_TYPE_TOKEN, PAYMENT_TYPE_NVM]:
+    if payment_type not in PaymentType._value2member_map_:  # pylint: disable=W0212
         print("  - Invalid mech type detected.")
         sys.exit(1)
 
@@ -175,7 +192,7 @@ def approve_price_tokens(
     """
     sender = crypto.address
 
-    with open(Path(__file__).parent / "abis" / "IToken.json", encoding="utf-8") as f:
+    with open(ITOKEN_ABI_PATH, encoding="utf-8") as f:
         abi = json.load(f)
 
     token_contract = get_contract(
@@ -210,6 +227,7 @@ def fetch_requester_nvm_subscription_balance(
     requester: str,
     ledger_api: EthereumApi,
     mech_payment_balance_tracker: str,
+    payment_type: str,
 ) -> int:
     """
     Fetches the requester nvm subscription balance.
@@ -220,11 +238,13 @@ def fetch_requester_nvm_subscription_balance(
     :type ledger_api: EthereumApi
     :param mech_payment_balance_tracker: Requested mech's balance tracker contract address
     :type mech_payment_balance_tracker: str
+    :param payment_type: Requested mech's payment type
+    :type payment_type: str
     :return: The requester balance.
     :rtype: int
     """
     with open(
-        Path(__file__).parent / "abis" / "BalanceTrackerNvmSubscriptionNative.json",
+        PAYMENT_TYPE_TO_ABI_PATH[payment_type],
         encoding="utf-8",
     ) as f:
         abi = json.load(f)
@@ -239,10 +259,7 @@ def fetch_requester_nvm_subscription_balance(
         nvm_balance_tracker_contract.functions.subscriptionTokenId().call()
     )
 
-    with open(
-        Path(__file__).parent / "abis" / "IERC1155.json",
-        encoding="utf-8",
-    ) as f:
+    with open(IERC1155_ABI_PATH, encoding="utf-8") as f:
         abi = json.load(f)
 
     subscription_nft_contract = get_contract(
@@ -260,8 +277,8 @@ def send_marketplace_request(  # pylint: disable=too-many-arguments,too-many-loc
     ledger_api: EthereumApi,
     marketplace_contract: Web3Contract,
     gas_limit: int,
-    prompt: str,
-    tool: str,
+    prompts: tuple,
+    tools: tuple,
     method_args_data: MechMarketplaceRequestConfig,
     extra_attributes: Optional[Dict[str, Any]] = None,
     price: int = 10_000_000_000_000_000,
@@ -280,10 +297,10 @@ def send_marketplace_request(  # pylint: disable=too-many-arguments,too-many-loc
     :type marketplace_contract: Web3Contract
     :param gas_limit: Gas limit.
     :type gas_limit: int
-    :param prompt: The request prompt.
-    :type prompt: str
-    :param tool: The requested tool.
-    :type tool: str
+    :param prompts: The request prompts.
+    :type prompts: tuple
+    :param tools: The requested tools.
+    :type tools: tuple
     :param method_args_data: Method data to use to call the marketplace contract request
     :type method_args_data: MechMarketplaceRequestConfig
     :param extra_attributes: Extra attributes to be included in the request metadata.
@@ -299,21 +316,40 @@ def send_marketplace_request(  # pylint: disable=too-many-arguments,too-many-loc
     :return: The transaction hash.
     :rtype: Optional[str]
     """
-    v1_file_hash_hex_truncated, v1_file_hash_hex = push_metadata_to_ipfs(
-        prompt, tool, extra_attributes
-    )
-    print(
-        f"  - Prompt uploaded: https://gateway.autonolas.tech/ipfs/{v1_file_hash_hex}"
-    )
-    method_name = "request"
+    num_requests = len(prompts)
+
     method_args = {
-        "requestData": v1_file_hash_hex_truncated,
         "maxDeliveryRate": method_args_data.delivery_rate,
         "paymentType": "0x" + cast(str, method_args_data.payment_type),
         "priorityMech": to_checksum_address(method_args_data.priority_mech_address),
         "responseTimeout": method_args_data.response_timeout,
         "paymentData": method_args_data.payment_data,
     }
+
+    if num_requests == 1:
+        v1_file_hash_hex_truncated, v1_file_hash_hex = push_metadata_to_ipfs(
+            prompts[0], tools[0], extra_attributes
+        )
+        print(
+            f"  - Prompt uploaded: https://gateway.autonolas.tech/ipfs/{v1_file_hash_hex}"
+        )
+        method_name = "request"
+        method_args["requestData"] = v1_file_hash_hex_truncated
+
+    else:
+        request_datas = []
+        for prompt, tool in zip(prompts, tools):
+            v1_file_hash_hex_truncated, v1_file_hash_hex = push_metadata_to_ipfs(
+                prompt, tool, extra_attributes
+            )
+            print(
+                f"  - Prompt uploaded: https://gateway.autonolas.tech/ipfs/{v1_file_hash_hex}"
+            )
+            request_datas.append(v1_file_hash_hex_truncated)
+
+        method_name = "requestBatch"
+        method_args["requestDatas"] = request_datas
+
     tx_args = {
         "sender_address": crypto.address,
         "value": price,
@@ -356,6 +392,7 @@ def send_offchain_marketplace_request(  # pylint: disable=too-many-arguments,too
     prompt: str,
     tool: str,
     method_args_data: MechMarketplaceRequestConfig,
+    nonce: int,
     extra_attributes: Optional[Dict[str, Any]] = None,
     retries: Optional[int] = None,
     timeout: Optional[float] = None,
@@ -374,6 +411,8 @@ def send_offchain_marketplace_request(  # pylint: disable=too-many-arguments,too
     :type tool: str
     :param method_args_data: Method data to use to call the marketplace contract request
     :type method_args_data: MechMarketplaceRequestConfig
+    :param nonce: Nonce to use to order offchain tasks
+    :type nonce: int
     :param extra_attributes: Extra attributes to be included in the request metadata.
     :type extra_attributes: Optional[Dict[str,Any]]
     :param retries: Number of retries for sending a transaction
@@ -409,7 +448,6 @@ def send_offchain_marketplace_request(  # pylint: disable=too-many-arguments,too
     while tries < retries and datetime.now().timestamp() < deadline:
         tries += 1
         try:
-            nonce = marketplace_contract.functions.mapNonces(crypto.address).call()
             delivery_rate = method_args["maxDeliveryRate"]
             request_id = marketplace_contract.functions.getRequestId(
                 method_args["priorityMech"],
@@ -568,34 +606,12 @@ def check_prepaid_balances(
     :type max_delivery_rate: int
     """
     requester = crypto.address
-    if payment_type == PAYMENT_TYPE_NATIVE:
-        with open(
-            Path(__file__).parent / "abis" / "BalanceTrackerFixedPriceNative.json",
-            encoding="utf-8",
-        ) as f:
-            abi = json.load(f)
 
-        balance_tracker_contract = get_contract(
-            contract_address=mech_payment_balance_tracker,
-            abi=abi,
-            ledger_api=ledger_api,
-        )
-        requester_balance = balance_tracker_contract.functions.mapRequesterBalances(
-            requester
-        ).call()
-        if requester_balance < max_delivery_rate:
-            print(
-                f"  - Sender Native deposited balance low. Needed: {max_delivery_rate}, Actual: {requester_balance}"
-            )
-            print(f"  - Sender Address: {requester}")
-            print("  - Please use scripts/deposit_native.py to add balance")
-            sys.exit(1)
+    if payment_type in [PaymentType.NATIVE.value, PaymentType.TOKEN.value]:
+        payment_type_name = PaymentType(payment_type).name.lower()
+        payment_type_abi_path = PAYMENT_TYPE_TO_ABI_PATH[payment_type]
 
-    if payment_type == PAYMENT_TYPE_TOKEN:
-        with open(
-            Path(__file__).parent / "abis" / "BalanceTrackerFixedPriceToken.json",
-            encoding="utf-8",
-        ) as f:
+        with open(payment_type_abi_path, encoding="utf-8") as f:
             abi = json.load(f)
 
         balance_tracker_contract = get_contract(
@@ -608,19 +624,21 @@ def check_prepaid_balances(
         ).call()
         if requester_balance < max_delivery_rate:
             print(
-                f"  - Sender Token deposited balance low. Needed: {max_delivery_rate}, Actual: {requester_balance}"
+                f"  - Sender {payment_type_name} deposited balance low. Needed: {max_delivery_rate}, Actual: {requester_balance}"
             )
             print(f"  - Sender Address: {requester}")
-            print("  - Please use scripts/deposit_token.py to add balance")
+            print(
+                f"  - Please use scripts/deposit_{payment_type_name}.py to add balance"
+            )
             sys.exit(1)
 
 
 def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals, too-many-statements, too-many-return-statements
-    prompt: str,
+    prompts: tuple,
     priority_mech: str,
     use_prepaid: bool = False,
     use_offchain: bool = False,
-    tool: str = "",
+    tools: tuple = (),
     extra_attributes: Optional[Dict[str, Any]] = None,
     private_key_path: Optional[str] = None,
     confirmation_type: ConfirmationType = ConfirmationType.WAIT_FOR_BOTH,
@@ -632,16 +650,16 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
     """
     Interact with mech marketplace contract.
 
-    :param prompt: The interaction prompt.
-    :type prompt: str
+    :param prompts: The interaction prompts.
+    :type prompts: tuple
     :param priority_mech: Priority mech address to use (Optional)
     :type priority_mech: str
     :param use_prepaid: Whether to use prepaid model or not.
     :type use_prepaid: bool
     :param use_offchain: Whether to use offchain model or not.
     :type use_offchain: bool
-    :param tool: The tool to interact with (optional).
-    :type tool: str
+    :param tools: The tools to interact with (optional).
+    :type tools: tuple
     :param extra_attributes: Extra attributes to be included in the request metadata (optional).
     :type extra_attributes: Optional[Dict[str, Any]]
     :param private_key_path: The path to the private key file (optional).
@@ -665,21 +683,23 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
     priority_mech_address = priority_mech
     mech_marketplace_contract = mech_config.mech_marketplace_contract
     chain_id = ledger_config.chain_id
+    num_requests = len(prompts)
 
     if mech_marketplace_contract == ADDRESS_ZERO:
         print(f"Mech Marketplace not yet supported on {chain_config}")
         return None
 
     config_values = CHAIN_TO_DEFAULT_MECH_MARKETPLACE_REQUEST_CONFIG[chain_id].copy()
-    if priority_mech_address is not None:
-        print("Custom Mech detected")
-        config_values.update(
-            {
-                "priority_mech_address": priority_mech_address,
-                "mech_marketplace_contract": mech_marketplace_contract,
-            }
-        )
+    if priority_mech_address is None:
+        print("Priority Mech Address not provided")
+        return None
 
+    config_values.update(
+        {
+            "priority_mech_address": priority_mech_address,
+            "mech_marketplace_contract": mech_marketplace_contract,
+        }
+    )
     mech_marketplace_request_config: MechMarketplaceRequestConfig = make_dataclass(
         "MechMarketplaceRequestConfig",
         ((k, type(v)) for k, v in config_values.items()),
@@ -699,9 +719,7 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
     crypto = EthereumCrypto(private_key_path=private_key_path)
     ledger_api = EthereumApi(**asdict(ledger_config))
 
-    with open(
-        Path(__file__).parent / "abis" / "MechMarketplace.json", encoding="utf-8"
-    ) as f:
+    with open(MARKETPLACE_ABI_PATH, encoding="utf-8") as f:
         abi = json.load(f)
 
     mech_marketplace_contract = get_contract(
@@ -726,26 +744,28 @@ 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
 
+    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=contract_address,
+        contract_address=priority_mech_address,
         crypto=crypto,
         request_signature=marketplace_request_event_signature,
         deliver_signature=marketplace_deliver_event_signature,
     )
 
     if not use_prepaid:
-        price = max_delivery_rate
-        if payment_type == PAYMENT_TYPE_TOKEN:
+        price = max_delivery_rate * num_requests
+        if payment_type == PaymentType.TOKEN.value:
             print("Token Mech detected, approving wrapped token for price payment...")
-            wxdai = CHAIN_TO_WRAPPED_TOKEN[chain_id]
+            price_token = CHAIN_TO_PRICE_TOKEN[chain_id]
             approve_tx = approve_price_tokens(
-                crypto, ledger_api, wxdai, mech_payment_balance_tracker, price
+                crypto, ledger_api, price_token, mech_payment_balance_tracker, price
             )
             if not approve_tx:
                 print("Unable to approve allowance")
@@ -772,11 +792,14 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
             max_delivery_rate,
         )
 
-    if payment_type == PAYMENT_TYPE_NVM:
-        print("Nevermined Mech detected, subscription credits to be used")
+    if payment_type in [PaymentType.NATIVE_NVM.value, PaymentType.TOKEN_NVM.value]:
+        nvm_mech_type = PaymentType(payment_type).name.lower()
+        print(
+            f"{nvm_mech_type} Nevermined Mech detected, subscription credits to be used"
+        )
         requester = crypto.address
         requester_balance = fetch_requester_nvm_subscription_balance(
-            requester, ledger_api, mech_payment_balance_tracker
+            requester, ledger_api, mech_payment_balance_tracker, payment_type
         )
         if requester_balance < price:
             print(
@@ -796,8 +819,8 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
             marketplace_contract=mech_marketplace_contract,
             gas_limit=mech_config.gas_limit,
             price=price,
-            prompt=prompt,
-            tool=tool,
+            prompts=prompts,
+            tools=tools,
             method_args_data=mech_marketplace_request_config,
             extra_attributes=extra_attributes,
             retries=retries,
@@ -815,66 +838,86 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
         print(f"  - Transaction sent: {transaction_url_formatted}")
         print("  - Waiting for transaction receipt...")
 
-        request_id = watch_for_marketplace_request_id(
+        request_ids = watch_for_marketplace_request_ids(
             marketplace_contract=mech_marketplace_contract,
             ledger_api=ledger_api,
             tx_hash=transaction_digest,
         )
-        request_id_int = int.from_bytes(bytes.fromhex(request_id), byteorder="big")
-        print(f"  - Created on-chain request with ID {request_id_int}")
+        request_id_ints = [
+            int.from_bytes(bytes.fromhex(request_id), byteorder="big")
+            for request_id in request_ids
+        ]
+        if len(request_id_ints) == 1:
+            print(f"  - Created on-chain request with ID {request_id_ints[0]}")
+        else:
+            print(
+                f"  - Created on-chain requests with IDs: {', '.join(str(rid) for rid in request_id_ints)}"
+            )
         print("")
 
-        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,
-        )
+        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,
+            )
 
-        if data_url:
-            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 data
+            if data_url:
+                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...")
-    response = send_offchain_marketplace_request(
-        crypto=crypto,
-        marketplace_contract=mech_marketplace_contract,
-        prompt=prompt,
-        tool=tool,
-        method_args_data=mech_marketplace_request_config,
-        extra_attributes=extra_attributes,
-        retries=retries,
-        timeout=timeout,
-        sleep=sleep,
-    )
+    curr_nonce = mech_marketplace_contract.functions.mapNonces(crypto.address).call()  # type: ignore
+    responses = []
 
-    if not response:
+    for i in range(num_requests):
+        response = send_offchain_marketplace_request(
+            crypto=crypto,
+            marketplace_contract=mech_marketplace_contract,
+            prompt=prompts[0],
+            tool=tools[0],
+            method_args_data=mech_marketplace_request_config,
+            nonce=curr_nonce + i,
+            extra_attributes=extra_attributes,
+            retries=retries,
+            timeout=timeout,
+            sleep=sleep,
+        )
+        responses.append(response)
+
+    if not responses and len(responses) != num_requests:
         return None
 
-    request_id = response["request_id"]
-    print(f"  - Created off-chain request with ID {request_id}")
+    request_ids = [resp["request_id"] for resp in responses if resp is not None]
+    if len(request_ids) == 1:
+        print(f"  - Created off-chain request with ID {request_ids[0]}")
+    else:
+        print(
+            f"  - Created off-chain requests with IDs: {', '.join(str(rid) for rid in request_ids)}"
+        )
     print("")
 
     # @note as we are directly querying data from done task list, we get the full data instead of the ipfs hash
     print("Waiting for Offchain Mech Marketplace deliver...")
-    data = wait_for_offchain_marketplace_data(
-        request_id=request_id,
-    )
 
-    if data:
-        task_result = data["task_result"]
-        data_url = f"https://gateway.autonolas.tech/ipfs/f01701220{task_result}"
-        print(f"  - Data arrived: {data_url}")
-        data = requests.get(f"{data_url}/{request_id}", timeout=30).json()
-        print("  - Data from agent:")
-        print(json.dumps(data, indent=2))
-        return data
+    for request_id in request_ids:
+        data = wait_for_offchain_marketplace_data(
+            request_id=request_id,
+        )
+
+        if data:
+            task_result = data["task_result"]
+            data_url = IPFS_URL_TEMPLATE.format(task_result)
+            print(f"  - Data arrived: {data_url}")
+            data = requests.get(f"{data_url}/{request_id}", timeout=30).json()
+            print("  - Data from agent:")
+            print(json.dumps(data, indent=2))
     return None

mech_client/mech_tool_management.py

@@ -7,7 +7,13 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 import requests
 from aea_ledger_ethereum import EthereumApi
 
-from mech_client.interact import fetch_tools, get_abi, get_contract, get_mech_config
+from mech_client.interact import (
+    AGENT_REGISTRY_ABI_PATH,
+    fetch_tools,
+    get_abi,
+    get_contract,
+    get_mech_config,
+)
 
 
 def get_total_supply(chain_config: str = "gnosis") -> int:
@@ -27,7 +33,7 @@ def get_total_supply(chain_config: str = "gnosis") -> int:
     ledger_api = EthereumApi(**asdict(ledger_config))
 
     # Fetch ABI and create contract instance
-    abi = get_abi(mech_config.agent_registry_contract, mech_config.contract_abi_url)
+    abi = get_abi(AGENT_REGISTRY_ABI_PATH)
     contract = get_contract(mech_config.agent_registry_contract, abi, ledger_api)
 
     # Call the totalSupply function
@@ -58,7 +64,7 @@ def get_agent_tools(
             agent_id=agent_id,
             ledger_api=ledger_api,
             agent_registry_contract=mech_config.agent_registry_contract,
-            contract_abi_url=mech_config.contract_abi_url,
+            contract_abi_path=AGENT_REGISTRY_ABI_PATH,
             include_metadata=include_metadata,
         )
     except (requests.exceptions.RequestException, json.JSONDecodeError, KeyError) as e:
@@ -155,7 +161,7 @@ def get_tool_description(unique_identifier: str, chain_config: str = "gnosis") -
         agent_id=agent_id,
         ledger_api=ledger_api,
         agent_registry_contract=mech_config.agent_registry_contract,
-        contract_abi_url=mech_config.contract_abi_url,
+        contract_abi_path=AGENT_REGISTRY_ABI_PATH,
         include_metadata=True,
     )
     if isinstance(tools_result, tuple) and len(tools_result) == 2:
@@ -188,7 +194,7 @@ def get_tool_io_schema(
         agent_id=agent_id,
         ledger_api=ledger_api,
         agent_registry_contract=mech_config.agent_registry_contract,
-        contract_abi_url=mech_config.contract_abi_url,
+        contract_abi_path=AGENT_REGISTRY_ABI_PATH,
         include_metadata=True,
     )
     if isinstance(tools_result, tuple) and len(tools_result) == 2: