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

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"

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)}