mech-client 0.8.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

scripts/nvm_subscription/manager.py

@@ -0,0 +1,265 @@
+# subscription/manager.py
+from enum import Enum
+import json
+import logging
+import os
+import sys
+import requests
+
+import uuid
+from typing import Any, Dict, List, Literal, Union
+from web3 import Web3
+from eth_account import Account
+from eth_typing import ChecksumAddress
+
+from .contracts.did_registry import DIDRegistryContract
+from .contracts.nft_sales import NFTSalesTemplateContract
+from .contracts.lock_payment import LockPaymentConditionContract
+from .contracts.transfer_nft import TransferNFTConditionContract
+from .contracts.escrow_payment import EscrowPaymentConditionContract
+from .contracts.agreement_manager import AgreementStorageManagerContract
+from .contracts.token import SubscriptionToken
+from .contracts.nft import SubscriptionNFT
+from .contracts.subscription_provider import SubscriptionProvider
+
+logger = logging.getLogger(__name__)
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+config_path = os.path.join(BASE_DIR, 'resources', 'networks.json')
+CONFIGS = json.load(open(config_path, 'r'))
+
+class Network(Enum):
+    GNOSIS = "GNOSIS"
+    BASE = "BASE"
+
+
+def get_variable_value(variable: str) -> str:
+    try:
+        var = os.getenv(variable)
+        if var is None:
+            raise ValueError(f"Environment variable {variable} not found")
+        return var
+    except Exception as e:
+        raise e
+
+
+class NVMSubscriptionManager:
+    """
+    Manages the process of creating NFT-based subscription agreements
+    using a series of smart contracts.
+    """
+
+    def __init__(self, network: str, private_key: str):
+        """
+        Initialize the SubscriptionManager, including contract instances
+        and Web3 connection.
+        """
+        self.url = os.getenv("MECHX_CHAIN_RPC", CONFIGS[network]["nvm"]['web3ProviderUri'])
+        self.web3 = Web3(Web3.HTTPProvider(self.url))
+
+        self.account = Account.from_key(private_key)
+        self.sender: ChecksumAddress = self.web3.to_checksum_address(self.account.address)
+
+        self.did_registry = DIDRegistryContract(self.web3)
+        self.nft_sales = NFTSalesTemplateContract(self.web3)
+        self.lock_payment = LockPaymentConditionContract(self.web3)
+        self.transfer_nft = TransferNFTConditionContract(self.web3)
+        self.escrow_payment = EscrowPaymentConditionContract(self.web3)
+        self.subscription_nft = SubscriptionNFT(self.web3)
+        self.subscription_provider = SubscriptionProvider(self.web3)
+
+        # load the subscription token to be used for base
+        if network == 'BASE':
+            self.subscription_token = SubscriptionToken(self.web3)
+
+        self.agreement_storage_manager = AgreementStorageManagerContract(self.web3)
+
+        self.token_address = self.web3.to_checksum_address(get_variable_value("TOKEN_ADDRESS"))
+        self.subscription_nft_address = self.web3.to_checksum_address(get_variable_value("SUBSCRIPTION_NFT_ADDRESS"))
+        self.subscription_credits = int(os.getenv("SUBSCRIPTION_CREDITS", "1"))
+        self.amounts = [int(os.getenv("PLAN_FEE_NVM", "0")), int(os.getenv("PLAN_PRICE_MECHS", "0"))]
+        self.subscription_id = CONFIGS[network]["nvm"]["subscription_id"]
+
+        logger.info("SubscriptionManager initialized")
+
+    def _generate_agreement_id_seed(self, length: int = 64) -> str:
+        """Generate a random hex string prefixed with 0x."""
+        seed = ''
+        while len(seed) < length:
+            seed += uuid.uuid4().hex
+        return '0x' + seed[:length]
+
+    def create_subscription(self, did: str, wallet_pvt_key: str, chain_id: int) -> Dict[str, Any]:
+        """
+        Execute the workflow to create a subscription for the given DID.
+
+        Args:
+            did (str): Decentralized Identifier for the asset.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing transaction status and receipt.
+        """
+        logger.info(f"Creating subscription for DID: {did}")
+
+        did = did.replace("did:nv:", "0x")
+
+        ddo = self.did_registry.get_ddo(did)
+        service = next((s for s in ddo.get("service", []) if s.get("type") == "nft-sales"), None)
+        if not service:
+            logger.error("No nft-sales service found in DDO")
+            return {"status": "error", "message": "No nft-sales service in DDO"}
+
+        self.publisher = service["templateId"]
+
+        conditions = service["attributes"]["serviceAgreementTemplate"]["conditions"]
+        reward_address = self.escrow_payment.address
+        receivers = conditions[0]["parameters"][-1]["value"]
+
+        agreement_id_seed = self._generate_agreement_id_seed()
+        agreement_id = self.agreement_storage_manager.agreement_id(agreement_id_seed, self.sender)
+
+        # Condition hashes
+        lock_hash = self.lock_payment.hash_values(did, reward_address, self.token_address, self.amounts, receivers)
+        lock_id = self.lock_payment.generate_id(agreement_id, lock_hash)
+
+        transfer_hash = self.transfer_nft.hash_values(
+            did,
+            ddo["owner"],
+            self.sender,
+            self.subscription_credits,
+            lock_id,
+            self.subscription_nft_address,
+            False
+        )
+        transfer_id = self.transfer_nft.generate_id(agreement_id, transfer_hash)
+
+        escrow_hash = self.escrow_payment.hash_values(
+            did,
+            self.amounts,
+            receivers,
+            self.sender,
+            reward_address,
+            self.token_address,
+            lock_id,
+            transfer_id
+        )
+        escrow_id = self.escrow_payment.generate_id(agreement_id, escrow_hash)
+
+        user_credit_balance_before = self.subscription_nft.get_balance(
+            self.sender, self.subscription_id
+        )
+        print(f"Sender credits Before Purchase: {user_credit_balance_before}")
+
+        # we set value as xdai is used as subscription for gnosis
+        value_eth = 1
+        if chain_id == 8453:
+            # for base, usdc is used and so we don't send any value
+            value_eth = 0
+
+            approve_tx = self.subscription_token.build_approve_token_tx(
+                sender=self.sender,
+                to=self.lock_payment.address,
+                amount=10**6,
+                chain_id=chain_id,
+            )
+            signed_tx = self.web3.eth.account.sign_transaction(approve_tx, private_key=wallet_pvt_key)
+            tx_hash = self.web3.eth.send_raw_transaction(signed_tx.rawTransaction)
+            receipt = self.web3.eth.wait_for_transaction_receipt(tx_hash)
+
+            if receipt["status"] == 1:
+                logger.info("Approve transaction validated successfully")
+                logger.info({"status": "success", "tx_hash": tx_hash.hex()})
+            else:
+                logger.error("Approve transaction failed")
+                return {"status": "failed", "receipt": dict(receipt)}
+
+        # Build transaction
+        tx = self.nft_sales.build_create_agreement_tx(
+            agreement_id_seed=agreement_id_seed,
+            did=did,
+            condition_seeds=[lock_hash, transfer_hash, escrow_hash],
+            timelocks=[0, 0, 0],
+            timeouts=[0, 90, 0],
+            publisher=self.sender,
+            service_index=0,
+            reward_address=reward_address,
+            token_address=self.token_address,
+            amounts=self.amounts,
+            receivers=receivers,
+            sender=self.sender,
+            value_eth=value_eth,
+            chain_id=chain_id
+        )
+
+        signed_tx = self.web3.eth.account.sign_transaction(tx, private_key=wallet_pvt_key)
+        tx_hash = self.web3.eth.send_raw_transaction(signed_tx.rawTransaction)
+        receipt = self.web3.eth.wait_for_transaction_receipt(transaction_hash=tx_hash)
+
+        if receipt["status"] == 1:
+            logger.info("Subscription transaction validated successfully")
+            logger.info({"status": "success", "tx_hash": tx_hash.hex()})
+        else:
+            logger.error("Subscription transaction failed")
+            return {"status": "failed", "receipt": dict(receipt)}
+
+        fulfill_for_delegate_params = (
+            # nftHolder
+            ddo["owner"],
+            # nftReceiver
+            self.sender,
+            # nftAmount
+            self.subscription_credits,
+            # lockPaymentCondition
+            "0x" + lock_id.hex(),
+            # nftContractAddress
+            self.subscription_nft_address,
+            # transfer
+            False,
+            # expirationBlock
+            0,
+        )
+
+        fulfill_params = (
+            # amounts
+            self.amounts,
+            # receivers
+            receivers,
+            # returnAddress
+            self.sender,
+            # lockPaymentAddress
+            reward_address,
+            # tokenAddress
+            self.token_address,
+            # lockCondition
+            "0x" + lock_id.hex(),
+            # releaseCondition
+            "0x" + transfer_id.hex(),
+        )
+
+        fulfill_tx = self.subscription_provider.build_create_fulfill_tx(
+            agreement_id_seed="0x" + agreement_id.hex(),
+            did=did,
+            fulfill_for_delegate_params=fulfill_for_delegate_params,
+            fulfill_params=fulfill_params,
+            sender=self.sender,
+            value_eth=0,
+            chain_id=chain_id,
+        )
+
+        signed_tx = self.web3.eth.account.sign_transaction(
+            fulfill_tx, private_key=wallet_pvt_key
+        )
+        tx_hash = self.web3.eth.send_raw_transaction(signed_tx.rawTransaction)
+        receipt = self.web3.eth.wait_for_transaction_receipt(transaction_hash=tx_hash)
+
+        user_credit_balance_after = self.subscription_nft.get_balance(
+            self.sender, self.subscription_id
+        )
+        print(f"Sender credits After Purchase: {user_credit_balance_after}")
+
+        if receipt["status"] == 1:
+            logger.info("Subscription purchased transaction successfully")
+            return {"status": "success", "tx_hash": tx_hash.hex()}
+        else:
+            logger.error("Subscription purchase transaction failed")
+            return {"status": "failed", "receipt": dict(receipt)}

scripts/nvm_subscription/resources/networks.json

@@ -0,0 +1,56 @@
+{
+  "BASE": {
+    "envDescription": "The Base production environment where users can interact with Nevermined protocol.",
+    "envUrl": "https://base.nevermined.app/",
+    "envName": "Base",
+    "isProduction": true,
+    "nvm": {
+      "chainId": 8453,
+      "appUrl": "https://base.nevermined.app",
+      "web3ProviderUri": "https://1rpc.io/base",
+      "marketplaceUri": "https://marketplace-api.base.nevermined.app",
+      "graphHttpUri": "https://api.thegraph.com/subgraphs/name/nevermined-io/public",
+      "neverminedNodeUri": "https://node.base.nevermined.app",
+      "neverminedNodeAddress": "0x824dbcE5E9C96C5b8ce2A35a25a5ab87eD1D00b1",
+      "neverminedBackendUri": "https://one-backend.base.nevermined.app",
+      "subscription_id": "50413016362950485991271150743187499870906117744058208429036668344255336389082",
+      "verbose": true
+    },
+    "nativeToken": "ETH",
+    "networkName": "base",
+    "contractsVersion": "3.5.7",
+    "tagName": "public",
+    "etherscanUrl": "https://basescan.org",
+    "erc20TokenAddress": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    "gasMultiplier": 0,
+    "gasPriceMultiplier": 0,
+    "externalNetwork": true
+  },
+  "GNOSIS": {
+    "envDescription": "The Gnosis production environment where users can interact with Nevermined protocol.",
+    "envUrl": "https://gnosis.nevermined.app/",
+    "envName": "Gnosis",
+    "isProduction": true,
+    "nvm": {
+      "chainId": 100,
+      "appUrl": "https://gnosis.nevermined.app",
+      "web3ProviderUri": "https://rpc.gnosischain.com/",
+      "marketplaceUri": "https://marketplace-api.gnosis.nevermined.app",
+      "graphHttpUri": "https://api.thegraph.com/subgraphs/name/nevermined-io/public",
+      "neverminedNodeUri": "https://node.gnosis.nevermined.app",
+      "neverminedNodeAddress": "0x824dbcE5E9C96C5b8ce2A35a25a5ab87eD1D00b1",
+      "neverminedBackendUri": "https://one-backend.gnosis.nevermined.app",
+      "subscription_id": "79922471236808376650579296325311587488574799199590951702510416090224804407991",
+      "verbose": true
+    },
+    "nativeToken": "xDAI",
+    "networkName": "gnosis",
+    "contractsVersion": "3.5.7",
+    "tagName": "public",
+    "etherscanUrl": "https://gnosisscan.io",
+    "erc20TokenAddress": "0xDDAfbb505ad214D7b80b1f830fcCc89B60fb7A83",
+    "gasMultiplier": 1.1,
+    "gasPriceMultiplier": 0,
+    "externalNetwork": true
+  }
+}

scripts/utils.py

@@ -0,0 +1,127 @@
+import json
+from pathlib import Path
+from aea_ledger_ethereum import EthereumApi
+from web3.contract import Contract as Web3Contract
+from mech_client.marketplace_interact import get_contract, CHAIN_TO_PRICE_TOKEN
+
+
+# based on mech configs
+VALID_CHAINS = [
+    "gnosis",
+    "arbitrum",
+    "polygon",
+    "base",
+    "celo",
+    "optimism",
+]
+
+CHAIN_TO_NATIVE_BALANCE_TRACKER = {
+    100: "0x21cE6799A22A3Da84B7c44a814a9c79ab1d2A50D",
+    42161: "",
+    137: "",
+    8453: "0xB3921F8D8215603f0Bd521341Ac45eA8f2d274c1",
+    42220: "",
+    10: "",
+}
+
+CHAIN_TO_TOKEN_BALANCE_TRACKER = {
+    100: "0x53Bd432516707a5212A70216284a99A563aAC1D1",
+    42161: "",
+    137: "",
+    8453: "0x43fB32f25dce34EB76c78C7A42C8F40F84BCD237",
+    42220: "",
+    10: "",
+}
+
+
+def print_box(text: str, margin: int = 1, character: str = "=") -> None:
+    """Print text centered within a box."""
+
+    lines = text.split("\n")
+    text_length = max(len(line) for line in lines)
+    length = text_length + 2 * margin
+
+    border = character * length
+    margin_str = " " * margin
+
+    print(border)
+    print(f"{margin_str}{text}{margin_str}")
+    print(border)
+    print()
+
+
+def print_title(text: str) -> None:
+    """Print title."""
+    print()
+    print_box(text, 4, "=")
+
+
+def input_with_default_value(prompt: str, default_value: str) -> str:
+    user_input = input(f"{prompt} [{default_value}]: ")
+    return str(user_input) if user_input else default_value
+
+
+def input_select_chain() -> str:
+    """Chose a single option from the offered ones"""
+    user_input = input(f"Chose one of the following options {VALID_CHAINS}: ").lower()
+    if user_input in VALID_CHAINS:
+        return user_input
+    else:
+        print("Invalid option selected. Please try again.")
+        return input_select_chain()
+
+
+def get_native_balance_tracker_contract(
+    ledger_api: EthereumApi, chain_id: int
+) -> Web3Contract:
+    with open(
+        Path(__file__).parent.parent
+        / "mech_client"
+        / "abis"
+        / "BalanceTrackerFixedPriceNative.json",
+        encoding="utf-8",
+    ) as f:
+        abi = json.load(f)
+
+    native_balance_tracker_contract = get_contract(
+        contract_address=CHAIN_TO_NATIVE_BALANCE_TRACKER[chain_id],
+        abi=abi,
+        ledger_api=ledger_api,
+    )
+    return native_balance_tracker_contract
+
+
+def get_token_balance_tracker_contract(
+    ledger_api: EthereumApi, chain_id: int
+) -> Web3Contract:
+    with open(
+        Path(__file__).parent.parent
+        / "mech_client"
+        / "abis"
+        / "BalanceTrackerFixedPriceToken.json",
+        encoding="utf-8",
+    ) as f:
+        abi = json.load(f)
+
+    token_balance_tracker_contract = get_contract(
+        contract_address=CHAIN_TO_TOKEN_BALANCE_TRACKER[chain_id],
+        abi=abi,
+        ledger_api=ledger_api,
+    )
+    return token_balance_tracker_contract
+
+
+def get_token_contract(ledger_api: EthereumApi, chain_id: int) -> Web3Contract:
+    with open(
+        Path(__file__).parent.parent / "mech_client" / "abis" / "IToken.json",
+        encoding="utf-8",
+    ) as f:
+        abi = json.load(f)
+
+    token_contract = get_contract(
+        contract_address=CHAIN_TO_PRICE_TOKEN[chain_id],
+        abi=abi,
+        ledger_api=ledger_api,
+    )
+
+    return token_contract

scripts/whitelist.py

@@ -0,0 +1,5 @@
+directory # unused attribute (mech_client/acn.py:85)
+directory # unused attribute (mech_client/acn.py:100)
+directory # unused attribute (mech_client/acn.py:116)
+payment_data # unused variable (mech_client/interact.py:111)
+AGENT_QUERY_TEMPLATE # unused variable (mech_client/subgraph.py:30)