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

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

scripts/nvm_subscription/contracts/nft_sales.py

@@ -0,0 +1,119 @@
+# subscription/contracts/nft_sales.py
+import logging
+from typing import List, Any, Dict, 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 NFTSalesTemplateContract(BaseContract):
+    """
+    Wrapper class for the NFTSalesTemplate smart contract. Provides a method
+    to build a transaction for creating an agreement and paying escrow.
+    """
+
+    def __init__(self, w3: Web3):
+        """
+        Initialize the NFTSalesTemplateContract.
+
+        Args:
+            w3 (Web3): An instance of Web3 connected to an Ethereum network.
+        """
+        logger.debug("Initializing NFTSalesTemplateContract")
+        super().__init__(w3, name="NFTSalesTemplate")
+        logger.info("NFTSalesTemplateContract initialized")
+
+    def build_create_agreement_tx(
+        self,
+        agreement_id_seed: str,
+        did: str,
+        condition_seeds: List[bytes],
+        timelocks: List[int],
+        timeouts: List[int],
+        publisher: str,
+        service_index: int,
+        reward_address: str,
+        token_address: str,
+        amounts: List[int],
+        receivers: List[str],
+        sender: str,
+        value_eth: float,
+        gas: int = 600_000,
+        chain_id: int = 100
+    ) -> Dict[str, Any]:
+        """
+        Build a transaction dictionary to create an agreement and pay escrow.
+
+        Args:
+            agreement_id_seed (str): Unique identifier seed for the agreement.
+            did (str): Decentralized identifier.
+            condition_seeds (List[bytes]): List of hashed condition values.
+            timelocks (List[int]): Time locks for each condition.
+            timeouts (List[int]): Timeouts for each condition.
+            publisher (str): Ethereum address of the publisher.
+            service_index (int): Index of the service in the agreement.
+            reward_address (str): Address to receive the reward.
+            token_address (str): ERC20 token address.
+            amounts (List[int]): Payment amounts.
+            receivers (List[str]): List of payment receiver addresses.
+            sender (str): Ethereum address initiating the transaction.
+            value_eth (float): ETH value to include in the transaction.
+            gas (int, optional): Gas limit. Defaults to 600,000.
+            chain_id (int, optional): Ethereum network chain ID. Defaults to 100.
+
+        Returns:
+            Dict[str, Any]: Unsigned transaction dictionary.
+        """
+        logger.debug("Building transaction for createAgreementAndPayEscrow")
+        logger.debug(f"agreement_id_seed: {agreement_id_seed}")
+        logger.debug(f"did: {did}")
+        logger.debug(f"condition_seeds: {condition_seeds}")
+        logger.debug(f"timelocks: {timelocks}, timeouts: {timeouts}")
+        logger.debug(f"publisher: {publisher}, service_index: {service_index}")
+        logger.debug(f"reward_address: {reward_address}, token_address: {token_address}")
+        logger.debug(f"amounts: {amounts}, receivers: {receivers}")
+        logger.debug(f"sender: {sender}, value_eth: {value_eth}")
+
+        # Convert sender to a checksum address to ensure type safety
+        sender_address: ChecksumAddress = self.w3.to_checksum_address(sender)
+        nonce = self.w3.eth.get_transaction_count(sender_address)
+        logger.debug(f"Nonce for sender {sender_address}: {nonce}")
+
+        latest_block = self.w3.eth.get_block("latest")
+        base_fee = latest_block["baseFeePerGas"]
+        max_priority_fee = self.w3.eth.max_priority_fee
+
+        # Build the transaction using the contract method
+        tx = self.functions().createAgreementAndPayEscrow(
+            agreement_id_seed,
+            did,
+            condition_seeds,
+            timelocks,
+            timeouts,
+            self.w3.to_checksum_address(publisher),
+            service_index,
+            self.w3.to_checksum_address(reward_address),
+            self.w3.to_checksum_address(token_address),
+            amounts,
+            [self.w3.to_checksum_address(r) for r in receivers]
+        ).build_transaction({
+            "from": sender_address,
+            "value": self.w3.to_wei(value_eth, "ether"),
+            "chainId": chain_id,
+            "gas": gas,
+            "nonce": nonce,
+        })
+        gas = self.w3.eth.estimate_gas(tx)
+        tx.update({
+            "gas": gas,
+            "maxFeePerGas": base_fee + max_priority_fee,
+            "maxPriorityFeePerGas": max_priority_fee,
+        })
+
+        logger.info(f"Transaction built successfully for agreement ID: {agreement_id_seed}")
+        logger.debug(f"Transaction details: {tx}")
+        return tx

scripts/nvm_subscription/contracts/subscription_provider.py

@@ -0,0 +1,107 @@
+# subscription/contracts/subscription_provider.py
+import logging
+from typing import Union, List, Dict, Any
+from web3 import Web3
+from eth_typing import ChecksumAddress
+from web3.types import ENS
+
+from .base_contract import BaseContract
+
+logger = logging.getLogger(__name__)
+
+
+class SubscriptionProvider(BaseContract):
+    """
+    Wrapper for the Token smart contract. Supports token balance
+    """
+
+    def __init__(self, w3: Web3):
+        """
+        Initialize the Subscription provider instance.
+
+        Args:
+            w3 (Web3): A connected Web3 instance.
+        """
+        logger.debug("Initializing Subscription provider")
+        super().__init__(w3, name="SubscriptionProvider")
+        logger.info("Subscription provider initialized")
+
+    def build_create_fulfill_tx(
+        self,
+        agreement_id_seed: str,
+        did: str,
+        fulfill_for_delegate_params: tuple,
+        fulfill_params: tuple,
+        sender: str,
+        value_eth: float,
+        gas: int = 450_000,
+        chain_id: int = 100,
+    ) -> Dict[str, Any]:
+        """
+        Build a transaction dictionary to create a fulfill tx.
+
+        Args:
+            agreement_id_seed (str): Unique identifier seed for the agreement.
+            did (str): Decentralized identifier.
+            condition_seeds (List[bytes]): List of hashed condition values.
+            timelocks (List[int]): Time locks for each condition.
+            timeouts (List[int]): Timeouts for each condition.
+            publisher (str): Ethereum address of the publisher.
+            service_index (int): Index of the service in the agreement.
+            reward_address (str): Address to receive the reward.
+            token_address (str): ERC20 token address.
+            amounts (List[int]): Payment amounts.
+            receivers (List[str]): List of payment receiver addresses.
+            sender (str): Ethereum address initiating the transaction.
+            value_eth (float): ETH value to include in the transaction.
+            gas (int, optional): Gas limit. Defaults to 450,000.
+            chain_id (int, optional): Ethereum network chain ID. Defaults to 100.
+
+        Returns:
+            Dict[str, Any]: Unsigned transaction dictionary.
+        """
+        logger.debug("Building transaction for fulfill")
+        logger.debug(f"agreement_id_seed: {agreement_id_seed}")
+        logger.debug(f"did: {did}")
+        logger.debug(f"sender: {sender}, value_eth: {value_eth}")
+
+        # Convert sender to a checksum address to ensure type safety
+        sender_address: ChecksumAddress = self.w3.to_checksum_address(sender)
+        nonce = self.w3.eth.get_transaction_count(sender_address)
+        logger.debug(f"Nonce for sender {sender_address}: {nonce}")
+
+        latest_block = self.w3.eth.get_block("latest")
+        base_fee = latest_block["baseFeePerGas"]
+        max_priority_fee = self.w3.eth.max_priority_fee
+
+        logger.debug(f"fulfill_for_delegate_params: {fulfill_for_delegate_params}")
+        logger.debug(f"fulfill_params: {fulfill_params}")
+
+        # Build the transaction using the contract method
+        tx = (
+            self.functions()
+            .fulfill(
+                agreement_id_seed, did, fulfill_for_delegate_params, fulfill_params
+            )
+            .build_transaction(
+                {
+                    "from": sender_address,
+                    "value": self.w3.to_wei(value_eth, "ether"),
+                    "chainId": chain_id,
+                    "gas": gas,
+                    "nonce": nonce,
+                }
+            )
+        )
+        gas = self.w3.eth.estimate_gas(tx)
+        tx.update(
+            {
+                "gas": gas,
+                "maxFeePerGas": base_fee + max_priority_fee,
+                "maxPriorityFeePerGas": max_priority_fee,
+            }
+        )
+
+        logger.info(f"Transaction built successfully for fulfill: {agreement_id_seed}")
+        logger.debug(f"Transaction details: {tx}")
+        return tx

scripts/nvm_subscription/contracts/token.py

@@ -0,0 +1,87 @@
+# 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 SubscriptionToken(BaseContract):
+    """
+    Wrapper for the Token smart contract. Supports approve token
+    """
+
+    def __init__(self, w3: Web3):
+        """
+        Initialize the Token instance.
+
+        Args:
+            w3 (Web3): A connected Web3 instance.
+        """
+        logger.debug("Initializing Subscription Token")
+        super().__init__(w3, name="SubscriptionToken")
+        logger.info("Token initialized")
+
+    def build_approve_token_tx(
+        self,
+        sender: Union[ChecksumAddress, ENS],
+        to: Union[ChecksumAddress, ENS],
+        amount: int,
+        gas: int = 60_000,
+        chain_id: int = 100,
+    ) -> bytes:
+        """
+        Compute the hash of parameters for the transfer condition.
+
+        Args:
+            sender (ChecksumAddress | ENS): Address sending the approve tx.
+            to_address (ChecksumAddress | ENS): Address getting the approval.
+            amount (int): Number of tokens to approve.
+            gas (int, optional): Gas limit. Defaults to 60,000.
+            chain_id (int, optional): Ethereum network chain ID. Defaults to 100.
+
+        Returns:
+            Dict[str, Any]: Unsigned transaction dictionary.
+        """
+        logger.debug("Approving token...")
+        sender_address: ChecksumAddress = self.w3.to_checksum_address(sender)
+        to_address: ChecksumAddress = self.w3.to_checksum_address(to)
+        nonce = self.w3.eth.get_transaction_count(sender_address)
+        logger.debug(f"Nonce for sender {sender_address}: {nonce}")
+
+        latest_block = self.w3.eth.get_block("latest")
+        base_fee = latest_block["baseFeePerGas"]
+        max_priority_fee = self.w3.eth.max_priority_fee
+
+        tx = (
+            self.functions()
+            .approve(
+                to_address,
+                amount,
+            )
+            .build_transaction(
+                {
+                    "from": sender,
+                    "value": 0,
+                    "chainId": chain_id,
+                    "gas": gas,
+                    "nonce": nonce,
+                }
+            )
+        )
+        gas = self.w3.eth.estimate_gas(tx)
+        tx.update(
+            {
+                "gas": gas,
+                "maxFeePerGas": base_fee + max_priority_fee,
+                "maxPriorityFeePerGas": max_priority_fee,
+            }
+        )
+
+        logger.info("Transaction built successfully for token approve")
+        logger.debug(f"Transaction details: {tx}")
+        return tx

scripts/nvm_subscription/contracts/transfer_nft.py

@@ -0,0 +1,81 @@
+# 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 TransferNFTConditionContract(BaseContract):
+    """
+    Wrapper for the TransferNFTCondition smart contract. Supports hash and ID generation.
+    """
+
+    def __init__(self, w3: Web3):
+        """
+        Initialize the TransferNFTConditionContract instance.
+
+        Args:
+            w3 (Web3): A connected Web3 instance.
+        """
+        logger.debug("Initializing TransferNFTConditionContract")
+        super().__init__(w3, name="TransferNFTCondition")
+        logger.info("TransferNFTConditionContract initialized")
+
+    def hash_values(
+        self,
+        did: str,
+        from_address: Union[ChecksumAddress, ENS],
+        to_address: Union[ChecksumAddress, ENS],
+        amount: int,
+        lock_condition_id: bytes,
+        nft_contract_address: Union[ChecksumAddress, ENS],
+        _is_transfer: bool,
+    ) -> bytes:
+        """
+        Compute the hash of parameters for the transfer condition.
+
+        Args:
+            did (str): Decentralized identifier.
+            from_address (ChecksumAddress | ENS): Address sending the NFT.
+            to_address (ChecksumAddress | ENS): Address receiving the NFT.
+            amount (int): Number of tokens to transfer.
+            lock_condition_id (bytes): Lock payment condition ID.
+            nft_contract_address (ChecksumAddress | ENS): NFT contract address.
+            is_escrow (bool): Indicates if escrow is involved.
+
+        Returns:
+            bytes: Hashed value.
+        """
+        logger.debug("Computing transfer NFT hash value")
+        hash_ = self.functions().hashValues(
+            did,
+            from_address,
+            to_address,
+            amount,
+            lock_condition_id,
+            nft_contract_address,
+            _is_transfer
+        ).call()
+        logger.debug(f"Transfer NFT hash: {hash_.hex()}")
+        return hash_
+
+    def generate_id(self, agreement_id: bytes, hash_value: bytes) -> bytes:
+        """
+        Generate the condition ID for the transfer NFT condition.
+
+        Args:
+            agreement_id (str): ID of the agreement.
+            hash_value (bytes): Hashed condition parameters.
+
+        Returns:
+            bytes: Condition ID.
+        """
+        logger.debug("Generating transfer NFT condition ID")
+        condition_id = self.functions().generateId(agreement_id, hash_value).call()
+        logger.info(f"Transfer NFT condition ID: {condition_id.hex()}")
+        return condition_id

scripts/nvm_subscription/envs/base.env

@@ -0,0 +1,10 @@
+export NETWORK_NAME="BASE"
+export CHAIN_ID=8453
+export SUBSCRIPTION_NFT_ADDRESS="0xd5318d1a17819f65771b6c9277534c08dd765498"
+export OLAS_MARKETPLACE_ADDRESS="0xaaFBeef195BDAb1Bb6f3Dc9cEbA875Cd72499230"
+export RECEIVER_PLAN="0xaaFBeef195BDAb1Bb6f3Dc9cEbA875Cd72499230"
+export TOKEN_ADDRESS="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" #USDC
+export PLAN_DID="did:nv:6f74c18fae7e5c3589b99d7cd0ba317593f00dee53c81a2ba4ac2244232f99da"
+export SUBSCRIPTION_CREDITS="1000000"
+export PLAN_FEE_NVM="10000"
+export PLAN_PRICE_MECHS="990000"

scripts/nvm_subscription/envs/gnosis.env

@@ -0,0 +1,10 @@
+export NETWORK_NAME="GNOSIS"
+export CHAIN_ID=100
+export SUBSCRIPTION_NFT_ADDRESS="0x1b5DeaD7309b56ca7663b3301A503e077Be18cba"
+export OLAS_MARKETPLACE_ADDRESS="0x7D686bD1fD3CFF6E45a40165154D61043af7D67c"
+export RECEIVER_PLAN="0x7D686bD1fD3CFF6E45a40165154D61043af7D67c"
+export TOKEN_ADDRESS="0x0000000000000000000000000000000000000000" # xDAI
+export PLAN_DID="did:nv:b0b28402e5a7229804579d4ac55b98a1dd94660d7a7eb4add78e5ca856f2aab7"
+export SUBSCRIPTION_CREDITS="1000000"
+export PLAN_FEE_NVM="10000000000000000"
+export PLAN_PRICE_MECHS="990000000000000000"