mech-client 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

scripts/deposit_token.py

@@ -0,0 +1,187 @@
+# -*- 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.
+#
+# ------------------------------------------------------------------------------
+
+
+import sys
+from pathlib import Path
+from typing import Optional
+from aea_ledger_ethereum import EthereumApi, EthereumCrypto
+from dataclasses import asdict
+from web3.contract import Contract as Web3Contract
+
+
+from mech_client.interact import (
+    get_mech_config,
+    PRIVATE_KEY_FILE_PATH,
+)
+from .utils import (
+    print_title,
+    get_token_contract,
+    get_token_balance_tracker_contract,
+)
+from mech_client.wss import wait_for_receipt
+
+
+def check_token_balance(token_contract: Web3Contract, sender: str, amount: int) -> None:
+    try:
+        print("Fetching user balance")
+        user_token_balance = token_contract.functions.balanceOf(sender).call()
+        if user_token_balance < amount:
+            formatted_user_balance = user_token_balance / 1e18
+            formatted_amount = amount / 1e18
+            print("User balance low!!")
+            print(f"Balance: {formatted_user_balance}")
+            print(f"Want to Deposit: {formatted_amount}")
+            sys.exit(1)
+    except Exception as e:
+        print(f"Error occured while fetching user balance: {e}")
+
+
+def approve(
+    crypto: EthereumCrypto,
+    ledger_api: EthereumApi,
+    token_contract: Web3Contract,
+    token_balance_tracker_contract: Web3Contract,
+    amount: int,
+) -> str:
+    sender = crypto.address
+
+    print("Sending approve tx")
+    try:
+        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": token_balance_tracker_contract.address,
+                "_value": amount,
+            },
+            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
+    except Exception as e:  # pylint: disable=broad-except
+        print(f"Error occured while sending the transaction: {e}")
+        return str(e)
+
+
+def deposit(
+    ledger_api: EthereumApi,
+    crypto: EthereumCrypto,
+    token_balance_tracker_contract: Web3Contract,
+    amount: int,
+) -> str:
+    sender = crypto.address
+
+    print("Sending deposit tx")
+    try:
+        tx_args = {"sender_address": sender, "value": 0, "gas": 100000}
+        raw_transaction = ledger_api.build_transaction(
+            contract_instance=token_balance_tracker_contract,
+            method_name="deposit",
+            method_args={"amount": amount},
+            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
+    except Exception as e:  # pylint: disable=broad-except
+        print(f"Error occured while sending the transaction: {e}")
+        return str(e)
+
+
+def main(
+    amount: str,
+    private_key_path: Optional[str] = None,
+    chain_config: Optional[str] = None,
+) -> None:
+    """Runs the deposit functionality for the token mech type"""
+    print_title("Token Deposit")
+    print("This script will assist you in depositing token balance for mech requests.")
+    print()
+
+    amount_to_deposit = int(float(amount) * 10**18)
+    private_key_path = private_key_path or PRIVATE_KEY_FILE_PATH
+
+    mech_config = get_mech_config(chain_config)
+    ledger_config = mech_config.ledger_config
+    ledger_api = EthereumApi(**asdict(ledger_config))
+
+    if not Path(private_key_path).exists():
+        raise FileNotFoundError(
+            f"Private key file `{private_key_path}` does not exist!"
+        )
+    crypto = EthereumCrypto(private_key_path=private_key_path)
+
+    print(f"Sender address: {crypto.address}")
+
+    chain_id = mech_config.ledger_config.chain_id
+    token_balance_tracker_contract = get_token_balance_tracker_contract(
+        ledger_api, chain_id
+    )
+    token_contract = get_token_contract(ledger_api, chain_id)
+
+    check_token_balance(token_contract, crypto.address, amount_to_deposit)
+
+    approve_tx = approve(
+        crypto,
+        ledger_api,
+        token_contract,
+        token_balance_tracker_contract,
+        amount_to_deposit,
+    )
+    if not approve_tx:
+        print("Unable to approve")
+        sys.exit(1)
+
+    transaction_url_formatted = mech_config.transaction_url.format(
+        transaction_digest=approve_tx
+    )
+    print(f" - Transaction sent: {transaction_url_formatted}")
+    print(" - Waiting for transaction receipt...")
+    wait_for_receipt(approve_tx, ledger_api)
+
+    deposit_tx = deposit(
+        ledger_api,
+        crypto,
+        token_balance_tracker_contract,
+        amount_to_deposit,
+    )
+    if not deposit_tx:
+        print("Unable to deposit")
+        sys.exit(1)
+
+    transaction_url_formatted = mech_config.transaction_url.format(
+        transaction_digest=deposit_tx
+    )
+    print(f" - Transaction sent: {transaction_url_formatted}")
+    print(" - Waiting for transaction receipt...")
+    wait_for_receipt(deposit_tx, ledger_api)
+
+    print("")
+    print("Deposit Successful")

scripts/nvm_subscribe.py

@@ -0,0 +1,51 @@
+import os
+import sys
+from dotenv import load_dotenv
+from typing import Optional, Dict
+from pathlib import Path
+from mech_client.interact import PRIVATE_KEY_FILE_PATH
+from web3 import Web3
+from scripts.nvm_subscription.manager import NVMSubscriptionManager
+
+BASE_ENV_PATH = Path(__file__).parent / "nvm_subscription" / "envs"
+
+CHAIN_TO_ENVS: Dict[str, Path] = {
+    "gnosis": BASE_ENV_PATH / "gnosis.env",
+    "base": BASE_ENV_PATH / "base.env",
+}
+
+
+def main(
+    private_key_path: str,
+    chain_config: str,
+) -> None:
+
+    chain_env = CHAIN_TO_ENVS.get(chain_config)
+    if chain_env:
+        load_dotenv(chain_env)
+    else:
+        print(f"{chain_config} network not supported")
+        sys.exit(1)
+
+    private_key_path = private_key_path or PRIVATE_KEY_FILE_PATH
+    if not Path(private_key_path).exists():
+        raise FileNotFoundError(
+            f"Private key file `{private_key_path}` does not exist!"
+        )
+
+    with open(private_key_path, "r") as file:
+        content = file.read()
+
+    WALLET_PVT_KEY = content
+    PLAN_DID = os.environ["PLAN_DID"]
+    NETWORK = os.environ["NETWORK_NAME"]
+    CHAIN_ID = int(os.environ["CHAIN_ID"])
+    SENDER = Web3().eth.account.from_key(WALLET_PVT_KEY).address
+
+    print(f"Sender address: {SENDER}")
+
+    manager = NVMSubscriptionManager(NETWORK, WALLET_PVT_KEY)
+    tx_receipt = manager.create_subscription(PLAN_DID, WALLET_PVT_KEY, CHAIN_ID)
+
+    print("Subscription created successfully")
+    print(tx_receipt)

scripts/nvm_subscription/contracts/agreement_manager.py

@@ -0,0 +1,44 @@
+# subscription/contracts/lock_payment.py
+import logging
+from typing import List, Union
+from web3 import Web3
+from eth_typing import ChecksumAddress
+from web3.types import ENS
+
+from .base_contract import BaseContract
+
+logger = logging.getLogger(__name__)
+
+
+class AgreementStorageManagerContract(BaseContract):
+    """
+    Wrapper class for the LockPaymentCondition smart contract.
+    Provides methods for computing hash and generating IDs.
+    """
+
+    def __init__(self, w3: Web3):
+        """
+        Initialize the LockPaymentConditionContract.
+
+        Args:
+            w3 (Web3): An instance of Web3 connected to the target Ethereum network.
+        """
+        logger.debug("Initializing AgreementStoreManager")
+        super().__init__(w3, name="AgreementStoreManager")
+        logger.info("AgreementStoreManagerContract initialized")
+
+    def agreement_id(self, agreement_id_seed: str, subscriber: str) -> bytes:
+        """
+        Generate a condition ID for a given agreement ID and hash.
+
+        Args:
+            agreement_id_seed (str): Seed for the agreement ID.
+            subscriber (str): Address of the subscriber.
+
+        Returns:
+            bytes: The condition ID.
+        """
+        logger.debug("Generating condition ID from agreement ID and hash")
+        agreement_id = self.functions().agreementId(agreement_id_seed, subscriber).call()
+        logger.info(f"Generated condition ID: {agreement_id.hex()}")
+        return agreement_id

scripts/nvm_subscription/contracts/base_contract.py

@@ -0,0 +1,75 @@
+# subscription/contracts/base_contract.py
+import os
+import json
+import logging
+from typing import Any, Dict
+from web3 import Web3
+from web3.contract import Contract
+
+# Configure module-level logger
+logger = logging.getLogger(__name__)
+
+
+class BaseContract:
+    """
+    Base class to interact with Ethereum smart contracts. Handles loading of contract
+    ABI and instantiating a Web3 contract instance.
+    """
+
+    def __init__(self, w3: Web3, name: str):
+        """
+        Initialize the base contract wrapper.
+
+        Args:
+            w3 (Web3): An instance of Web3 connected to the desired network.
+            name (str): The name of the contract artifact file (without extension).
+        """
+        self.w3 = w3
+        self.name = name
+        self.chain_id = self.w3.eth.chain_id
+        self.chain_name = "gnosis" if self.chain_id == 100 else "base"
+        logger.debug(f"Initializing contract wrapper for '{self.name}'")
+        self.contract = self._load_contract()  # Load contract from artifact
+
+        self.address = self.contract.address
+        logger.info(f"Contract '{self.name}' loaded successfully")
+
+    def _load_contract_info(self) -> Dict[str, Any]:
+        """
+        Load contract metadata (ABI and address) from the artifacts directory.
+
+        Returns:
+            dict: A dictionary containing the contract address and ABI.
+        """
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        root_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
+        path = os.path.join(root_dir, 'mech_client', 'abis', f'{self.name}.{self.chain_name}.json')
+        logger.debug(f"Loading contract info from: {path}")
+        with open(path, 'r', encoding='utf-8') as f:
+            info = json.load(f)  # Parse JSON containing ABI and address
+        logger.debug(f"Loaded contract address: {info.get('address')}")
+        return info
+
+    def _load_contract(self) -> Contract:
+        """
+        Instantiate a Web3 contract object using the loaded contract info.
+
+        Returns:
+            Contract: A Web3 contract instance bound to the deployed address.
+        """
+        info = self._load_contract_info()
+        address = self.w3.to_checksum_address(info['address'])  # Ensure correct checksum
+        logger.debug(f"Creating contract instance at address: {address}")
+        contract = self.w3.eth.contract(address=address, abi=info['abi'])
+        logger.info("Contract instance created successfully")
+        return contract
+
+    def functions(self) -> Any:
+        """
+        Access the functions of the loaded contract. Acts as a proxy to contract.functions.
+
+        Returns:
+            Any: The contract.functions interface for calling or building transactions.
+        """
+        logger.debug(f"Accessing contract functions for '{self.name}'")
+        return self.contract.functions

scripts/nvm_subscription/contracts/did_registry.py

@@ -0,0 +1,91 @@
+# subscription/contracts/did_registry.py
+import logging
+from typing import Dict, Any
+from web3 import Web3
+from web3.constants import ADDRESS_ZERO
+
+from .base_contract import BaseContract
+
+logger = logging.getLogger(__name__)
+
+
+class DIDRegistryContract(BaseContract):
+    """
+    Wrapper class for the DIDRegistry smart contract.
+    Provides methods to interact with DID-related functionality.
+    """
+
+    def __init__(self, w3: Web3):
+        """
+        Initialize the DIDRegistryContract with a Web3 instance.
+
+        Args:
+            w3 (Web3): Web3 instance connected to the desired Ethereum network.
+        """
+        super().__init__(w3, name="DIDRegistry")
+
+    def get_ddo(self, did: str) -> Dict[str, Any]:
+        """
+        Retrieve the DDO (Decentralized Document Object) for a given DID.
+
+        Args:
+            did (str): Decentralized identifier (DID) to look up.
+
+        Returns:
+            Dict[str, Any]: Parsed DDO object.
+        """
+        logger.debug(f"Fetching DDO for DID: {did}")
+        registered_values = self.functions().getDIDRegister(did).call()
+        service_endpoint = registered_values[2]
+
+        logger.debug(f"Resolved service endpoint: {service_endpoint}")
+        response = self._fetch_ddo_from_endpoint(service_endpoint)
+
+        ddo = {
+            "did": f"did:nv:{did}",
+            "serviceEndpoint": registered_values[2],
+            "checksum": registered_values[1],
+            "owner": registered_values[0],
+            "providers": registered_values[5],
+            "royalties": registered_values[6],
+            "immutableUrl": registered_values[7],
+            "nftInitialized": registered_values[8],
+            "service": response.get("service", []),
+            "proof": response.get("proof", [])
+        }
+
+        non_zero_providers = [
+            addr
+            for addr in ddo["providers"]
+            if addr.lower() != ADDRESS_ZERO
+        ]
+        print("================ SUBSCRIBGING TO NVM OLAS PLAN =======================")
+        print(f"PLAN : {ddo['did']}")
+        print(f"OWNER: {ddo['owner']}")
+        print(f"PROVIDERS: {non_zero_providers}")
+        logger.info(f"ROYALTIES: {ddo['royalties']}")
+        logger.info(f"IMMUTABLE URL: {ddo['immutableUrl']}")
+        logger.info(f"NFT INITIALIZED: {ddo['nftInitialized']}")
+        logger.info(f"DDO fetched successfully for DID: {did}")
+        return ddo
+
+    def _fetch_ddo_from_endpoint(self, endpoint: str) -> Dict[str, Any]:
+        """
+        Helper method to fetch the DDO JSON from a service endpoint.
+
+        Args:
+            endpoint (str): URL to fetch DDO data from.
+
+        Returns:
+            Dict[str, Any]: Parsed JSON response.
+        """
+        import requests
+
+        try:
+            response = requests.get(endpoint, timeout=10)
+            response.raise_for_status()
+            logger.debug(f"Received response from DDO endpoint: {response.status_code}")
+            return response.json()
+        except requests.RequestException as e:
+            logger.error(f"Failed to fetch DDO from {endpoint}: {e}")
+            return {}

scripts/nvm_subscription/contracts/escrow_payment.py

@@ -0,0 +1,85 @@
+# subscription/contracts/escrow_payment.py
+import logging
+from typing import List, Union
+from web3 import Web3
+from eth_typing import ChecksumAddress
+from web3.types import ENS
+
+from .base_contract import BaseContract
+
+logger = logging.getLogger(__name__)
+
+
+class EscrowPaymentConditionContract(BaseContract):
+    """
+    Wrapper for the EscrowPaymentCondition smart contract.
+    Provides methods to hash values and generate condition IDs.
+    """
+
+    def __init__(self, w3: Web3):
+        """
+        Initialize the EscrowPaymentConditionContract.
+
+        Args:
+            w3 (Web3): A connected Web3 instance.
+        """
+        logger.debug("Initializing EscrowPaymentConditionContract")
+        super().__init__(w3, name="EscrowPaymentCondition")
+        logger.info("EscrowPaymentConditionContract initialized")
+
+    def hash_values(
+        self,
+        did: str,
+        amounts: List[int],
+        receivers: List[Union[ChecksumAddress, ENS]],
+        sender: Union[ChecksumAddress, ENS],
+        receiver: Union[ChecksumAddress, ENS],
+        token_address: Union[ChecksumAddress, ENS],
+        lock_condition_id: bytes,
+        release_condition_id: bytes
+    ) -> bytes:
+        """
+        Compute the hash of parameters for escrow condition.
+
+        Args:
+            did (str): Decentralized identifier.
+            amounts (List[int]): Payment amounts.
+            receivers (List[ChecksumAddress | ENS]): Receiver addresses.
+            sender (ChecksumAddress | ENS): Sender address.
+            receiver (ChecksumAddress | ENS): Receiver address.
+            token_address (ChecksumAddress | ENS): Token contract address.
+            lock_condition_id (bytes): ID of the lock payment condition.
+            release_condition_id (bytes): ID of the release condition.
+
+        Returns:
+            bytes: Hashed values.
+        """
+        logger.debug("Computing hash for escrow payment condition")
+        hash_ = self.functions().hashValues(
+            did,
+            amounts,
+            receivers,
+            sender,
+            receiver,
+            token_address,
+            lock_condition_id,
+            release_condition_id
+        ).call()
+        logger.debug(f"Escrow payment hash: {hash_.hex()}")
+        return hash_
+
+    def generate_id(self, agreement_id: bytes, hash_value: bytes) -> bytes:
+        """
+        Generate the condition ID for the escrow payment.
+
+        Args:
+            agreement_id (str): Agreement identifier.
+            hash_value (bytes): Hash of condition inputs.
+
+        Returns:
+            bytes: Generated condition ID.
+        """
+        logger.debug("Generating escrow payment condition ID")
+        condition_id = self.functions().generateId(agreement_id, hash_value).call()
+        logger.info(f"Escrow payment condition ID: {condition_id.hex()}")
+        return condition_id

scripts/nvm_subscription/contracts/lock_payment.py

@@ -0,0 +1,76 @@
+# subscription/contracts/lock_payment.py
+import logging
+from typing import List, Union
+from web3 import Web3
+from eth_typing import ChecksumAddress
+from web3.types import ENS
+
+from .base_contract import BaseContract
+
+logger = logging.getLogger(__name__)
+
+
+class LockPaymentConditionContract(BaseContract):
+    """
+    Wrapper class for the LockPaymentCondition smart contract.
+    Provides methods for computing hash and generating IDs.
+    """
+
+    def __init__(self, w3: Web3):
+        """
+        Initialize the LockPaymentConditionContract.
+
+        Args:
+            w3 (Web3): An instance of Web3 connected to the target Ethereum network.
+        """
+        logger.debug("Initializing LockPaymentConditionContract")
+        super().__init__(w3, name="LockPaymentCondition")
+        logger.info("LockPaymentConditionContract initialized")
+
+    def hash_values(
+        self,
+        did: str,
+        reward_address: Union[ChecksumAddress, ENS],
+        token_address: Union[ChecksumAddress, ENS],
+        amounts: List[int],
+        receivers: List[Union[ChecksumAddress, ENS]]
+    ) -> bytes:
+        """
+        Compute the hash of the condition parameters.
+
+        Args:
+            did (str): The decentralized identifier.
+            reward_address (ChecksumAddress | ENS): Address to receive the reward.
+            token_address (ChecksumAddress | ENS): ERC20 token address.
+            amounts (List[int]): List of amounts for each receiver.
+            receivers (List[ChecksumAddress | ENS]): List of receiver addresses.
+
+        Returns:
+            bytes: The keccak256 hash of the encoded values.
+        """
+        logger.debug("Computing hash for lock payment condition")
+        hash_ = self.functions().hashValues(
+            did,
+            reward_address,
+            token_address,
+            amounts,
+            receivers
+        ).call()
+        logger.debug(f"Computed hash: {hash_.hex()}")
+        return hash_
+
+    def generate_id(self, agreement_id: bytes, hash_value: bytes) -> bytes:
+        """
+        Generate a condition ID for a given agreement ID and hash.
+
+        Args:
+            agreement_id (str): ID of the agreement.
+            hash_value (bytes): Hashed condition parameters.
+
+        Returns:
+            bytes: The condition ID.
+        """
+        logger.debug("Generating condition ID from agreement ID and hash")
+        condition_id = self.functions().generateId(agreement_id, hash_value).call()
+        logger.info(f"Generated condition ID: {condition_id.hex()}")
+        return condition_id

scripts/nvm_subscription/contracts/nft.py

@@ -0,0 +1,47 @@
+# subscription/contracts/transfer_nft.py
+import logging
+from typing import Union
+from web3 import Web3
+from eth_typing import ChecksumAddress
+from web3.types import ENS
+
+from .base_contract import BaseContract
+
+logger = logging.getLogger(__name__)
+
+
+class SubscriptionNFT(BaseContract):
+    """
+    Wrapper for the Token smart contract. Supports token balance
+    """
+
+    def __init__(self, w3: Web3):
+        """
+        Initialize the Subscription NFT instance.
+
+        Args:
+            w3 (Web3): A connected Web3 instance.
+        """
+        logger.debug("Initializing Subscription NFT")
+        super().__init__(w3, name="SubscriptionNFT")
+        logger.info("Subscription NFT initialized")
+
+    def get_balance(
+        self, sender: Union[ChecksumAddress, ENS], subscription_id: str
+    ) -> int:
+        """
+        Gets the user subscription credit balance.
+
+        Args:
+            sender (ChecksumAddress | ENS): User address.
+
+        Returns:
+            int: The user's credit balance.
+        """
+        sender_address: ChecksumAddress = self.w3.to_checksum_address(sender)
+
+        balance = (
+            self.functions().balanceOf(sender_address, int(subscription_id)).call()
+        )
+        logger.debug(f"Fetched Balance: {balance}")
+        return balance