mech-client 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

mech_client/marketplace_interact.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------------------------
 #
-#   Copyright 2024 Valory AG
+#   Copyright 2024-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.
@@ -52,6 +52,7 @@ from mech_client.interact import (
 )
 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.safe import EthereumClient, get_safe_nonce, send_safe_tx
 from mech_client.wss import wait_for_receipt, watch_for_marketplace_request_ids
 
 
@@ -61,13 +62,26 @@ class PaymentType(Enum):
 
     NATIVE = "ba699a34be8fe0e7725e93dcbce1701b0211a8ca61330aaeb8a05bf2ec7abed1"  # nosec
     TOKEN = "3679d66ef546e66ce9057c4a052f317b135bc8e8c509638f7966edfd4fcf45e9"  # nosec
+    USDC_TOKEN = (
+        "6406bb5f31a732f898e1ce9fdd988a80a808d36ab5d9a4a4805a8be8d197d5e3"  # nosec
+    )
     NATIVE_NVM = (
         "803dd08fe79d91027fc9024e254a0942372b92f3ccabc1bd19f4a5c2b251c316"  # nosec
     )
-    TOKEN_NVM = (
+    TOKEN_NVM_USDC = (
         "0d6fd99afa9c4c580fab5e341922c2a5c4b61d880da60506193d7bf88944dd14"  # nosec
     )
 
+    @classmethod
+    def get_token_payment_types(cls) -> List[str]:
+        """Get all token-based payment types that require ERC20 approval."""
+        return [cls.TOKEN.value, cls.USDC_TOKEN.value]
+
+    @classmethod
+    def get_prepaid_supported_types(cls) -> List[str]:
+        """Get payment types that support prepaid balances."""
+        return [cls.NATIVE.value, cls.TOKEN.value, cls.USDC_TOKEN.value]
+
 
 IPFS_URL_TEMPLATE = "https://gateway.autonolas.tech/ipfs/f01701220{}"
 MECH_OFFCHAIN_REQUEST_ENDPOINT = "send_signed_requests"
@@ -91,17 +105,18 @@ BALANCE_TRACKER_NVM_TOKEN_ABI_PATH = (
 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.USDC_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,
+    PaymentType.TOKEN_NVM_USDC.value: BALANCE_TRACKER_NVM_TOKEN_ABI_PATH,
 }
 
 CHAIN_TO_PRICE_TOKEN = {
     1: "0x0001A500A6B18995B03f44bb040A5fFc28E45CB0",
     10: "0xFC2E6e6BCbd49ccf3A5f029c79984372DcBFE527",
     100: "0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f",
-    137: "0xFEF5d947472e72Efbb2E388c730B7428406F2F95",
+    137: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
     8453: "0x54330d28ca3357F294334BDC454a032e7f353416",
-    42220: "0xFEF5d947472e72Efbb2E388c730B7428406F2F95",
+    42220: "0x96ffa56a963EC33e5bC7057B9002722D1884fc01",
 }
 
 
@@ -114,6 +129,10 @@ CHAIN_TO_DEFAULT_MECH_MARKETPLACE_REQUEST_CONFIG = {
         "response_timeout": 300,
         "payment_data": "0x",
     },
+    137: {
+        "response_timeout": 300,
+        "payment_data": "0x",
+    },
 }
 
 
@@ -176,7 +195,6 @@ def fetch_mech_info(
             payment_type_bytes
         ).call()
     )
-
     if payment_type not in PaymentType._value2member_map_:  # pylint: disable=W0212
         print("  - Invalid mech type detected.")
         sys.exit(1)
@@ -189,9 +207,12 @@ def fetch_mech_info(
     )
 
 
-def approve_price_tokens(
+def approve_price_tokens(  # pylint: disable=too-many-arguments, too-many-locals
     crypto: EthereumCrypto,
     ledger_api: EthereumApi,
+    ethereum_client: EthereumClient,
+    agent_mode: bool,
+    safe_address: str,
     wrapped_token: str,
     mech_payment_balance_tracker: str,
     price: int,
@@ -203,6 +224,12 @@ def approve_price_tokens(
     :type crypto: EthereumCrypto
     :param ledger_api: The Ethereum API used for interacting with the ledger.
     :type ledger_api: EthereumApi
+    :param ethereum_client: The Ethereum Client used for interacting with the safe.
+    :type ethereum_client: EthereumClient
+    :param agent_mode: Specifies whether agent mode is active or not.
+    :type agent_mode: bool
+    :param safe_address: Specifies the safe address related to the configured service, empty is client mode.
+    :type safe_address: str
     :param wrapped_token: The wrapped token contract address.
     :type wrapped_token: str
     :param mech_payment_balance_tracker: Requested mech's balance tracker contract address
@@ -212,7 +239,9 @@ def approve_price_tokens(
     :return: The transaction digest.
     :rtype: str
     """
-    sender = crypto.address
+    # Tokens will be on the safe and EOA pays for gas
+    # so for agent mode, sender has to be safe
+    sender = safe_address or crypto.address
 
     with open(ITOKEN_ABI_PATH, encoding="utf-8") as f:
         abi = json.load(f)
@@ -230,19 +259,41 @@ def approve_price_tokens(
         sys.exit(1)
 
     tx_args = {"sender_address": sender, "value": 0, "gas": 60000}
-    raw_transaction = ledger_api.build_transaction(
-        contract_instance=token_contract,
-        method_name="approve",
-        method_args={"_to": mech_payment_balance_tracker, "_value": price},
-        tx_args=tx_args,
-        raise_on_try=True,
+    method_name = "approve"
+    method_args = {"_to": mech_payment_balance_tracker, "_value": price}
+
+    if not agent_mode:
+        raw_transaction = ledger_api.build_transaction(
+            contract_instance=token_contract,
+            method_name=method_name,
+            method_args=method_args,
+            tx_args=tx_args,
+            raise_on_try=True,
+        )
+        signed_transaction = crypto.sign_transaction(raw_transaction)
+        transaction_digest = ledger_api.send_signed_transaction(
+            signed_transaction,
+            raise_on_try=True,
+        )
+        return transaction_digest
+
+    function = token_contract.functions[method_name](**method_args)
+    transaction = function.build_transaction(
+        {
+            "chainId": int(ledger_api._chain_id),  # pylint: disable=protected-access
+            "gas": 0,
+            "nonce": get_safe_nonce(ethereum_client, safe_address),
+        }
     )
-    signed_transaction = crypto.sign_transaction(raw_transaction)
-    transaction_digest = ledger_api.send_signed_transaction(
-        signed_transaction,
-        raise_on_try=True,
+    transaction_digest = send_safe_tx(
+        ethereum_client=ethereum_client,
+        tx_data=transaction["data"],
+        to_adress=token_contract.address,
+        safe_address=safe_address,
+        signer_pkey=crypto.private_key,
+        value=0,
     )
-    return transaction_digest
+    return transaction_digest.hex()
 
 
 def fetch_requester_nvm_subscription_balance(
@@ -300,10 +351,13 @@ def fetch_requester_nvm_subscription_balance(
 def send_marketplace_request(  # pylint: disable=too-many-arguments,too-many-locals
     crypto: EthereumCrypto,
     ledger_api: EthereumApi,
+    ethereum_client: EthereumClient,
     marketplace_contract: Web3Contract,
     gas_limit: int,
     prompts: tuple,
     tools: tuple,
+    agent_mode: bool,
+    safe_address: str,
     method_args_data: MechMarketplaceRequestConfig,
     extra_attributes: Optional[Dict[str, Any]] = None,
     price: int = 10_000_000_000_000_000,
@@ -318,6 +372,8 @@ def send_marketplace_request(  # pylint: disable=too-many-arguments,too-many-loc
     :type crypto: EthereumCrypto
     :param ledger_api: The Ethereum API used for interacting with the ledger.
     :type ledger_api: EthereumApi
+    :param ethereum_client: The Ethereum Client used for interacting with the safe.
+    :type ethereum_client: EthereumClient
     :param marketplace_contract: The mech marketplace contract instance.
     :type marketplace_contract: Web3Contract
     :param gas_limit: Gas limit.
@@ -326,6 +382,10 @@ def send_marketplace_request(  # pylint: disable=too-many-arguments,too-many-loc
     :type prompts: tuple
     :param tools: The requested tools.
     :type tools: tuple
+    :param agent_mode: Specifies whether agent mode is active or not.
+    :type agent_mode: bool
+    :param safe_address: Specifies the safe address related to the configured service, empty is client mode.
+    :type safe_address: str
     :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.
@@ -390,19 +450,40 @@ def send_marketplace_request(  # pylint: disable=too-many-arguments,too-many-loc
     while tries < retries and datetime.now().timestamp() < deadline:
         tries += 1
         try:
-            raw_transaction = ledger_api.build_transaction(
-                contract_instance=marketplace_contract,
-                method_name=method_name,
-                method_args=method_args,
-                tx_args=tx_args,
-                raise_on_try=True,
+            if not agent_mode:
+                raw_transaction = ledger_api.build_transaction(
+                    contract_instance=marketplace_contract,
+                    method_name=method_name,
+                    method_args=method_args,
+                    tx_args=tx_args,
+                    raise_on_try=True,
+                )
+                signed_transaction = crypto.sign_transaction(raw_transaction)
+                transaction_digest = ledger_api.send_signed_transaction(
+                    signed_transaction,
+                    raise_on_try=True,
+                )
+                return transaction_digest
+
+            function = marketplace_contract.functions[method_name](**method_args)
+            transaction = function.build_transaction(
+                {
+                    "chainId": int(
+                        ledger_api._chain_id  # pylint: disable=protected-access
+                    ),
+                    "gas": 0,
+                    "nonce": get_safe_nonce(ethereum_client, safe_address),
+                }
             )
-            signed_transaction = crypto.sign_transaction(raw_transaction)
-            transaction_digest = ledger_api.send_signed_transaction(
-                signed_transaction,
-                raise_on_try=True,
+            transaction_digest = send_safe_tx(
+                ethereum_client=ethereum_client,
+                tx_data=transaction["data"],
+                to_adress=marketplace_contract.address,
+                safe_address=safe_address,
+                signer_pkey=crypto.private_key,
+                value=price,
             )
-            return transaction_digest
+            return transaction_digest.hex()
         except Exception as e:  # pylint: disable=broad-except
             print(
                 f"Error occured while sending the transaction: {e}; Retrying in {sleep}"
@@ -616,9 +697,10 @@ def wait_for_offchain_marketplace_data(mech_offchain_url: str, request_id: str)
             time.sleep(WAIT_SLEEP)
 
 
-def check_prepaid_balances(
+def check_prepaid_balances(  # pylint: disable=too-many-arguments
     crypto: Crypto,
     ledger_api: EthereumApi,
+    safe_address: str,
     mech_payment_balance_tracker: str,
     payment_type: str,
     max_delivery_rate: int,
@@ -630,6 +712,8 @@ def check_prepaid_balances(
     :type crypto: Crypto
     :param ledger_api: The Ethereum API used for interacting with the ledger.
     :type ledger_api: EthereumApi
+    :param safe_address: Specifies the safe address related to the configured service, empty is client mode.
+    :type safe_address: str
     :param mech_payment_balance_tracker: The mech's balance tracker contract address.
     :type mech_payment_balance_tracker: str
     :param payment_type: The payment type of the mech.
@@ -637,9 +721,9 @@ def check_prepaid_balances(
     :param max_delivery_rate: The max_delivery_rate of the mech
     :type max_delivery_rate: int
     """
-    requester = crypto.address
+    requester = safe_address or crypto.address
 
-    if payment_type in [PaymentType.NATIVE.value, PaymentType.TOKEN.value]:
+    if payment_type in PaymentType.get_prepaid_supported_types():
         payment_type_name = PaymentType(payment_type).name.lower()
         payment_type_abi_path = PAYMENT_TYPE_TO_ABI_PATH[payment_type]
 
@@ -680,7 +764,6 @@ def verify_tools(tools: tuple, service_id: int, chain_config: Optional[str]) ->
     mech_tools_data = get_mech_tools(service_id=service_id, chain_config=chain_config)
     if not mech_tools_data:
         raise ValueError("Error while fetching mech tools data")
-
     mech_tools = mech_tools_data.get("tools", [])
     invalid_tools = [tool for tool in tools if tool not in mech_tools]
     if invalid_tools:
@@ -692,12 +775,15 @@ def verify_tools(tools: tuple, service_id: int, chain_config: Optional[str]) ->
 def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals, too-many-statements, too-many-return-statements
     prompts: tuple,
     priority_mech: str,
+    agent_mode: bool,
+    safe_address: str,
     use_prepaid: bool = False,
     use_offchain: bool = False,
     mech_offchain_url: str = "",
     tools: tuple = (),
     extra_attributes: Optional[Dict[str, Any]] = None,
     private_key_path: Optional[str] = None,
+    private_key_password: Optional[str] = None,
     retries: Optional[int] = None,
     timeout: Optional[float] = None,
     sleep: Optional[float] = None,
@@ -708,8 +794,12 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
 
     :param prompts: The interaction prompts.
     :type prompts: tuple
-    :param priority_mech: Priority mech address to use (Optional)
+    :param priority_mech: Priority mech address to use
     :type priority_mech: str
+    :param agent_mode: Specifies whether agent mode is active or not.
+    :type agent_mode: bool
+    :param safe_address: Specifies the safe address related to the configured service, empty is client mode.
+    :type safe_address: 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.
@@ -722,6 +812,8 @@ 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 private_key_password: Password to decrypt the keystore (if encrypted).
+    :type private_key_password: Optional[str]
     :return: The data received from on-chain/off-chain.
     :param retries: Number of retries for sending a transaction
     :type retries: int
@@ -735,6 +827,8 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
     """
 
     mech_config = get_mech_config(chain_config)
+    ledger_rpc = mech_config.ledger_config.address
+    ethereum_client = EthereumClient(ledger_rpc)
     ledger_config = mech_config.ledger_config
     priority_mech_address = priority_mech
     mech_marketplace_contract = mech_config.mech_marketplace_contract
@@ -770,8 +864,9 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
         raise FileNotFoundError(
             f"Private key file `{private_key_path}` does not exist!"
         )
-
-    crypto = EthereumCrypto(private_key_path=private_key_path)
+    crypto = EthereumCrypto(
+        private_key_path=private_key_path, password=private_key_password
+    )
     ledger_api = EthereumApi(**asdict(ledger_config))
 
     with open(MARKETPLACE_ABI_PATH, encoding="utf-8") as f:
@@ -801,16 +896,35 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
     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:
-            print("Token Mech detected, approving wrapped token for price payment...")
+        if payment_type == PaymentType.NATIVE.value:
+            print(
+                "Native Mech detected, fetching user native balance for price payment..."
+            )
+            sender = safe_address or crypto.address
+            balance = ledger_api.get_balance(sender)
+            if balance < price:
+                print(
+                    f"  - Sender Native balance low. Needed: {price}, Actual: {balance}"
+                )
+                print(f"  - Sender Address: {sender}")
+                sys.exit(1)
+        if payment_type in PaymentType.get_token_payment_types():
             price_token = CHAIN_TO_PRICE_TOKEN[chain_id]
+            print(
+                f"Token Mech detected, approving token {price_token} for price payment..."
+            )
             approve_tx = approve_price_tokens(
-                crypto, ledger_api, price_token, mech_payment_balance_tracker, price
+                crypto,
+                ledger_api,
+                ethereum_client,
+                agent_mode,
+                safe_address,
+                price_token,
+                mech_payment_balance_tracker,
+                price,
             )
             if not approve_tx:
                 print("Unable to approve allowance")
@@ -832,6 +946,7 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
         check_prepaid_balances(
             crypto,
             ledger_api,
+            safe_address,
             mech_payment_balance_tracker,
             payment_type,
             max_delivery_rate,
@@ -839,7 +954,7 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
 
     is_nvm_mech = payment_type in [
         PaymentType.NATIVE_NVM.value,
-        PaymentType.TOKEN_NVM.value,
+        PaymentType.TOKEN_NVM_USDC.value,
     ]
     if is_nvm_mech:
         nvm_mech_type = PaymentType(payment_type).name.lower()
@@ -874,11 +989,14 @@ def marketplace_interact(  # pylint: disable=too-many-arguments, too-many-locals
         transaction_digest = send_marketplace_request(
             crypto=crypto,
             ledger_api=ledger_api,
+            ethereum_client=ethereum_client,
             marketplace_contract=mech_marketplace_contract,
             gas_limit=mech_config.gas_limit,
             price=price,
             prompts=prompts,
             tools=tools,
+            agent_mode=agent_mode,
+            safe_address=safe_address,
             method_args_data=mech_marketplace_request_config,
             extra_attributes=extra_attributes,
             retries=retries,

mech_client/safe.py

@@ -0,0 +1,73 @@
+# -*- 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.
+#
+# ------------------------------------------------------------------------------
+
+"""Mech client Safe Module."""
+from typing import Optional
+
+from hexbytes import HexBytes
+from safe_eth.eth import EthereumClient  # pylint:disable=import-error
+from safe_eth.safe import Safe  # pylint:disable=import-error
+from web3.constants import ADDRESS_ZERO
+
+
+def send_safe_tx(  # pylint: disable=too-many-arguments
+    ethereum_client: EthereumClient,
+    tx_data: str,
+    to_adress: str,
+    safe_address: str,
+    signer_pkey: str,
+    value: int = 0,
+) -> Optional[HexBytes]:
+    """Send a Safe transaction"""
+    # Get the safe
+    safe = Safe(  # pylint:disable=abstract-class-instantiated
+        safe_address, ethereum_client
+    )
+
+    estimated_gas = safe.estimate_tx_gas_with_safe(
+        to=to_adress, value=value, data=bytes.fromhex(tx_data[2:]), operation=0
+    )
+
+    # Build, sign and send the safe transaction
+    safe_tx = safe.build_multisig_tx(
+        to=to_adress,
+        value=value,
+        data=bytes.fromhex(tx_data[2:]),
+        operation=0,
+        safe_tx_gas=estimated_gas,
+        base_gas=0,
+        gas_price=0,
+        gas_token=ADDRESS_ZERO,
+        refund_receiver=ADDRESS_ZERO,
+    )
+    safe_tx.sign(signer_pkey)
+    try:
+        tx_hash, _ = safe_tx.execute(signer_pkey)
+        return tx_hash
+    except Exception as e:  # pylint: disable=broad-except
+        print(f"Exception while sending a safe transaction: {e}")
+        return None
+
+
+def get_safe_nonce(ethereum_client: EthereumClient, safe_address: str) -> int:
+    """Get the Safe nonce"""
+    safe = Safe(  # pylint:disable=abstract-class-instantiated
+        safe_address, ethereum_client
+    )
+    return safe.retrieve_nonce()

mech_client/subgraph.py

@@ -35,21 +35,10 @@ AGENT_QUERY_TEMPLATE = Template(
 DEFAULT_TIMEOUT = 600.0
 CHAIN_TO_ADDRESSES = {
     "gnosis": {
-        3: "0xFf82123dFB52ab75C417195c5fDB87630145ae81",
         6: "0x77af31De935740567Cf4fF1986D04B2c964A786a",
         9: "0x552cea7bc33cbbeb9f1d90c1d11d2c6daeffd053",
-        11: "0x9aDe7A78A39B39a44b7a084923E93AA0B19Fd690",
         19: "0x45b73d649c7b982548d5a6dd3d35e1c5c48997d0",
     },
-    "base": {
-        1: "0x37C484cc34408d0F827DB4d7B6e54b8837Bf8BDA",
-        2: "0x111D7DB1B752AB4D2cC0286983D9bd73a49bac6c",
-        3: "0x111D7DB1B752AB4D2cC0286983D9bd73a49bac6c",
-    },
-    "arbitrum": {2: "0x1FDAD3a5af5E96e5a64Fc0662B1814458F114597"},
-    "polygon": {2: "0xbF92568718982bf65ee4af4F7020205dE2331a8a"},
-    "celo": {2: "0x230eD015735c0D01EA0AaD2786Ed6Bd3C6e75912"},
-    "optimism": {2: "0xDd40E7D93c37eFD860Bd53Ab90b2b0a8D05cf71a"},
 }