ethernity-cloud-runner-py 0.2.2__tar.gz → 0.2.4__tar.gz

{ethernity_cloud_runner_py-0.2.2 → ethernity_cloud_runner_py-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ethernity-cloud-runner-py
-Version: 0.2.2
+Version: 0.2.4
 Summary: Ethernity Cloud Runner Python
 Home-page: https://github.com/ethernity-cloud/ethernity-cloud-runner-py
 Author: Ethernity Cloud Team

ethernity_cloud_runner_py-0.2.4/ethernity_cloud_runner_py/contract/abi/ECLDAbi.py

@@ -0,0 +1,8 @@
+import os
+
+contract = {
+    "address": os.getenv(
+        "ECLD_CONTRACT_ADDRESS", "0xc6920888988cAcEeA7ACCA0c96f2D65b05eE22Ba"
+    ),
+    "abi": [{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":False,"inputs":[{"indexed":True,"internalType":"address","name":"owner","type":"address"},{"indexed":True,"internalType":"address","name":"spender","type":"address"},{"indexed":False,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":False,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":False,"inputs":[{"indexed":False,"internalType":"address","name":"receiver","type":"address"},{"indexed":False,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":False,"internalType":"string","name":"mintId","type":"string"}],"name":"Mint","type":"event"},{"anonymous":False,"inputs":[{"indexed":True,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":True,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":False,"inputs":[{"indexed":True,"internalType":"address","name":"from","type":"address"},{"indexed":True,"internalType":"address","name":"to","type":"address"},{"indexed":False,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"flashFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC3156FlashBorrower","name":"receiver","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"flashLoan","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"maxFlashLoan","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"string","name":"mintId","type":"string"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}],
+}

ethernity_cloud_runner_py-0.2.2/ethernity_cloud_runner_py/contract/abi/polygonAbi.py → ethernity_cloud_runner_py-0.2.4/ethernity_cloud_runner_py/contract/abi/polygonProtocolAbi.py

@@ -2,7 +2,7 @@ import os
 
 contract = {
     "address": os.getenv(
-        "ECLD_CONTRACT_ADDRESS", "0x439945BE73fD86fcC172179021991E96Beff3Cc4"
+        "PROTOCOL_ADDRESS", "0x439945BE73fD86fcC172179021991E96Beff3Cc4"
     ),
     "abi": [
         {

{ethernity_cloud_runner_py-0.2.2 → ethernity_cloud_runner_py-0.2.4}/ethernity_cloud_runner_py/contract/operation/bloxbergProtocolContract.py

@@ -73,7 +73,7 @@ class BloxbergProtocolContract:
         ).call()
         if allowance < task_price_amount:
             tx = self.ethernity_contract.functions.approve(
-                protocol_address, allowance_amount
+                protocol_address, int(task_price)
             ).build_transaction(self.__transaction_object)
             signed_tx = self.provider.eth.account.sign_transaction(
                 tx, private_key=self.signer._private_key

{ethernity_cloud_runner_py-0.2.2 → ethernity_cloud_runner_py-0.2.4}/ethernity_cloud_runner_py/contract/operation/imageRegistryContract.py

@@ -15,7 +15,7 @@ class ImageRegistryContract:
     def __init__(
         self,
         network_address: Address = ECAddress.BLOXBERG.TESTNET_ADDRESS,  # type: ignore
-        runner_type: str = ECRunner.BLOXBERG["PYNITHY_RUNNER"],
+        runner_type: str = ECRunner.BLOXBERG["PYNITHY_RUNNER_TESTNET"],
         signer: Any = None,
     ):
         self.signer = signer
@@ -37,14 +37,14 @@ class ImageRegistryContract:
                     abi=contract["abi"],
                 )
         elif network_address == ECAddress.BLOXBERG.MAINNET_ADDRESS:
-            if runner_type == ECRunner.BLOXBERG["NODENITHY_RUNNER"]:
+            if runner_type == ECRunner.BLOXBERG["NODENITHY_RUNNER_MAINNET"]:
                 self.contract = self.provider.eth.contract(
                     address=to_checksum_address(
                         ECAddress.BLOXBERG.IMAGE_REGISTRY.NODENITHY.MAINNET_ADDRESS
                     ),
                     abi=contract["abi"],
                 )
-            elif runner_type == ECRunner.BLOXBERG["PYNITHY_RUNNER"]:
+            elif runner_type == ECRunner.BLOXBERG["PYNITHY_RUNNER_MAINNET"]:
                 self.contract = self.provider.eth.contract(
                     address=to_checksum_address(
                         ECAddress.BLOXBERG.IMAGE_REGISTRY.PYNITHY.MAINNET_ADDRESS
@@ -52,14 +52,14 @@ class ImageRegistryContract:
                     abi=contract["abi"],
                 )
         elif network_address == ECAddress.POLYGON.MAINNET_ADDRESS:
-            if runner_type == ECRunner.POLYGON["NODENITHY_RUNNER"]:
+            if runner_type == ECRunner.POLYGON["NODENITHY_RUNNER_MAINNET"]:
                 self.contract = self.provider.eth.contract(
                     address=to_checksum_address(
                         ECAddress.POLYGON.IMAGE_REGISTRY.NODENITHY.MAINNET_ADDRESS
                     ),
                     abi=contract["abi"],
                 )
-            elif runner_type == ECRunner.POLYGON["PYNITHY_RUNNER"]:
+            elif runner_type == ECRunner.POLYGON["PYNITHY_RUNNER_MAINNET"]:
                 self.contract = self.provider.eth.contract(
                     address=to_checksum_address(
                         ECAddress.POLYGON.IMAGE_REGISTRY.PYNITHY.MAINNET_ADDRESS

{ethernity_cloud_runner_py-0.2.2 → ethernity_cloud_runner_py-0.2.4}/ethernity_cloud_runner_py/contract/operation/polygonProtocolContract.py

@@ -9,44 +9,58 @@ from web3.contract.contract import Contract
 from web3.middleware import ExtraDataToPOAMiddleware
 from web3.types import TxParams
 
-from ..abi.polygonAbi import contract as polygonAbi
+from ..abi.polygonProtocolAbi import contract as polygonAbi
+from ..abi.ECLDAbi import contract as ECLDAbi
 from ...enums import ECNetworkByChainIdDictionary, ECNetworkRPCDictionary
 
 
 class PolygonProtocolContract:
     def __init__(
-        self, network_address: Address, signer: Any, is_main_net: bool = False
+        self, token_address: Address, protocol_address: Address, signer: Any, chain_id: int = 8559
     ) -> None:
-        self.is_main_net = is_main_net
-        self.network_address = network_address
-        _rpc_url = ECNetworkRPCDictionary[network_address]
+        self.chain_id = chain_id
+        self.token_address = token_address
+        self.protocol_address = protocol_address
+        self.max_fee_per_gas = 1000
+        self.max_priority_fee_per_gas = 35
+        _rpc_url = ECNetworkRPCDictionary[token_address]
         self.provider = Web3(Web3.HTTPProvider(_rpc_url))
-        #self.provider.enable_unstable_package_management_api()
+
         self.provider.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
 
         self.signer = signer
-        self.ethernity_contract = self.provider.eth.contract(
-            address=network_address, abi=polygonAbi["abi"]
+        self.protocol_contract = self.provider.eth.contract(
+            address=protocol_address, abi=polygonAbi["abi"]
+        )
+        self.token_contract = self.provider.eth.contract(
+            address=token_address, abi=ECLDAbi["abi"]
         )
 
-    def contract_address(self) -> Address:
-        return self.network_address
+    def get_token_address(self) -> Address:
+        return self.token_address
 
-    @property
-    def __transaction_object(self) -> TxParams:
+    def get_protocol_address(self) -> Address:
+        return self.protocol_address
+    
+    def __transaction_object(self, gas) -> TxParams:
         nonce = self.provider.eth.get_transaction_count(self.signer.address)
+        max_fee_per_gas = self.provider.to_wei(self.max_fee_per_gas, 'gwei')
+        max_priority_fee_per_gas = self.provider.to_wei(self.max_priority_fee_per_gas, 'gwei')
+
         return {
-            "gas": 40500500010 if self.is_main_net else 1300000010,  # type: ignore
-            "chainId": 137 if self.is_main_net else 80002,
+            "from": self.signer.address,
+            "chainId": self.chain_id,
             "nonce": nonce,
-            "gasPrice": self.provider.to_wei("1", "mwei"),  # type: ignore
+            "gas": gas,
+            "maxFeePerGas" : max_fee_per_gas,
+            "maxPriorityFeePerGas": max_priority_fee_per_gas,
         }
 
     def get_signer(self) -> Any:
         return self.signer
 
     def get_contract(self) -> Contract:
-        return self.ethernity_contract
+        return self.protocol_contract
 
     def get_provider(self) -> Web3:
         return self.provider
@@ -57,39 +71,42 @@ class PolygonProtocolContract:
     def get_balance(self) -> int:
         try:
             address = self.signer.address
-            balance = self.ethernity_contract.functions.balanceOf(address).call()
+            balance = self.token_contract.functions.balanceOf(address).call()
             return Web3.from_wei(balance, "ether")
         except Exception as e:
             print(e)
             return 0
 
     def check_and_set_allowance(
-        self, protocol_address: Address, amount: str, task_price: str
+        self, task_price: str
     ) -> bool:
-        allowance_amount = Web3.to_wei(amount, "ether")
         task_price_amount = Web3.to_wei(task_price, "ether")
         current_wallet_address = self.signer.address
-        allowance = self.ethernity_contract.functions.allowance(
-            current_wallet_address, protocol_address
+        allowance = self.token_contract.functions.allowance(
+            current_wallet_address, self.protocol_address
         ).call()
         if allowance < task_price_amount:
-            tx = self.ethernity_contract.functions.approve(
-                protocol_address, allowance_amount
-            ).build_transaction(self.__transaction_object)
-            signed_tx = self.provider.eth.account.sign_transaction(
-                tx, private_key=self.signer._private_key
-            )
-            self.provider.eth.send_raw_transaction(signed_tx.raw_transaction)
-            recept = self.provider.to_hex(
-                self.provider.keccak(signed_tx.raw_transaction)
-            )
             try:
-                self.provider.eth.wait_for_transaction_receipt(recept)
-                allowance = self.ethernity_contract.functions.allowance(
-                    current_wallet_address, protocol_address
+                tx = self.token_contract.functions.approve(
+                    self.protocol_address, int(task_price_amount * 10)
+                ).build_transaction(self.__transaction_object(100000))
+
+                signed_tx = self.provider.eth.account.sign_transaction(
+                    tx, private_key=self.signer._private_key
+                )
+                
+                self.provider.eth.send_raw_transaction(signed_tx.raw_transaction)
+
+                receipt = self.provider.to_hex(
+                    self.provider.keccak(signed_tx.raw_transaction)
+                )
+
+                self.provider.eth.wait_for_transaction_receipt(receipt)
+
+                allowance = self.protocol_contract.functions.allowance(
+                    current_wallet_address, self.protocol_address
                 ).call()
             except Exception as e:
-                print(e)
                 return False
         return True
 
@@ -112,14 +129,16 @@ class PolygonProtocolContract:
         resources: dict,
         gas_limit: None = None,
     ) -> HexStr:
+        
         cpu = resources.get("cpu", 1)
         memory = resources.get("memory", 1)
         storage = resources.get("storage", 40)
         bandwidth = resources.get("bandwidth", 1)
         duration = resources.get("duration", 1)
         validators = resources.get("validators", 1)
-        task_price = resources.get("task_price", 10)
-        tx = self.ethernity_contract.functions._addDORequest(
+        task_price = resources.get("taskPrice", 10)
+
+        tx = self.protocol_contract.functions._addDORequest(
             cpu,
             memory,
             storage,
@@ -131,22 +150,23 @@ class PolygonProtocolContract:
             payload_metadata,
             input_metadata,
             node_address,
-        ).build_transaction(self.__transaction_object)
+        ).build_transaction(self.__transaction_object(1000000))
 
         signed_tx = self.provider.eth.account.sign_transaction(
             tx, private_key=self.signer._private_key
         )
+
         self.provider.eth.send_raw_transaction(signed_tx.raw_transaction)
         return self.provider.to_hex(self.provider.keccak(signed_tx.raw_transaction))
 
     def get_order(self, order_id: int) -> int:
-        return self.ethernity_contract.functions._getOrder(order_id).call()
+        return self.protocol_contract.functions._getOrder(order_id).call()
 
     def approve_order(self, order_id: int) -> HexStr:
-        # return self.ethernity_contract.functions._approveOrder(order_id).transact()
-        unicorn_txn = self.ethernity_contract.functions._approveOrder(
+        # return self.protocol_contract.functions._approveOrder(order_id).transact()
+        unicorn_txn = self.protocol_contract.functions._approveOrder(
             order_id
-        ).build_transaction(self.__transaction_object)
+        ).build_transaction(self.__transaction_object(100000))
 
         signed_txn = self.provider.eth.account.sign_transaction(
             unicorn_txn, private_key=self.signer._private_key
@@ -155,12 +175,15 @@ class PolygonProtocolContract:
         return self.provider.to_hex(self.provider.keccak(signed_txn.raw_transaction))
 
     def get_result_from_order(self, order_id: int) -> Any:
-        self.ethernity_contract.caller()._getOrder(order_id)
-        return self.ethernity_contract.caller()._getResultFromOrder(order_id)
+        self.protocol_contract.caller()._getOrder(order_id)
+        return self.protocol_contract.caller()._getResultFromOrder(order_id)
 
+    def get_status_from_order(self, order_id: int) -> Any:
+        return self.protocol_contract.caller()._getOrder(order_id)[4]
+    
     def is_node_operator(self, account: str) -> bool:
         try:
-            requests = self.ethernity_contract.functions._getMyDPRequests().call(
+            requests = self.protocol_contract.functions._getMyDPRequests().call(
                 {"from": account}
             )
             return len(requests) > 0

{ethernity_cloud_runner_py-0.2.2 → ethernity_cloud_runner_py-0.2.4}/ethernity_cloud_runner_py/enums.py

@@ -60,14 +60,14 @@ class ECRunner:
     BLOXBERG = {
         "PYNITHY_RUNNER_TESTNET": "etny-pynithy-testnet",
         "NODENITHY_RUNNER_TESTNET": "etny-nodenithy-testnet",
-        "PYNITHY_RUNNER": "etny-pynithy",
-        "NODENITHY_RUNNER": "etny-nodenithy"
+        "PYNITHY_RUNNER_MAINNET": "etny-pynithy",
+        "NODENITHY_RUNNER_MAINNET": "etny-nodenithy"
     }
     POLYGON = {
         "PYNITHY_RUNNER_TESTNET": "ecld-pynithy-mumbai",
         "NODENITHY_RUNNER_TESTNET": "ecld-nodenithy",
-        "PYNITHY_RUNNER": "ecld-pynithy",
-        "NODENITHY_RUNNER": "ecld-nodenithy"
+        "PYNITHY_RUNNER_MAINNET": "ecld-pynithy",
+        "NODENITHY_RUNNER_MAINNET": "ecld-nodenithy"
     }
     
     def __getitem__(self, key):
@@ -126,10 +126,10 @@ ECNetworkName1Dictionary = {
 }
 
 ECNetworkRPCDictionary = {
-    ECAddress.BLOXBERG.MAINNET_ADDRESS: "https://core.bloxberg.org",
-    ECAddress.BLOXBERG.TESTNET_ADDRESS: "https://core.bloxberg.org",
+    ECAddress.BLOXBERG.MAINNET_ADDRESS: "https://bloxberg.ethernity.cloud",
+    ECAddress.BLOXBERG.TESTNET_ADDRESS: "https://bloxberg.ethernity.cloud",
     ECAddress.POLYGON.TESTNET_ADDRESS: "https://rpc-mumbai.matic.today",
-    ECAddress.POLYGON.MAINNET_ADDRESS: "https://rpc-mainnet.maticvigil.com",
+    ECAddress.POLYGON.MAINNET_ADDRESS: "https://polygon-rpc.com",
 }
 
 ECNetworkEnvToEnum = {
@@ -143,8 +143,8 @@ ZERO_CHECKSUM = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b85
 
 
 class ECError(Enum):
-    PARSE_ERROR = "EtnyParseError"
-    IPFS_DOWNLOAD_ERROR = "ECIPFSDownloadError"
+    PARSE_ERROR = "The result is not a valid v3 result"
+    IPFS_DOWNLOAD_ERROR = "Unable to download results, will keep trying until the download is complete."
 
 class ECLog(IntEnum):
     ERROR = 1

{ethernity_cloud_runner_py-0.2.2 → ethernity_cloud_runner_py-0.2.4}/ethernity_cloud_runner_py/ipfs.py

@@ -45,7 +45,6 @@ class IPFSClient:
                 return None
         else:
             print(f"Failed to upload to IPFS. Status code: {response.status_code}")
-            print(response.text)
             return None
 
     def download_file(
@@ -74,9 +73,6 @@ class IPFSClient:
             # TODO: use a get encoding function to determine the encoding
             return response.content.decode("utf-8")
         else:
-            print(
-                f"Failed to get content from IPFS. Attempt {attempt}. Status code: {response.status_code}. Response text: {response.text}.\n{'Trying again...' if attempt < 6 else ''}"
-            )
             if attempt < 6:
                 self.get_file_content(ipfs_hash, attempt + 1)
 

{ethernity_cloud_runner_py-0.2.2 → ethernity_cloud_runner_py-0.2.4}/ethernity_cloud_runner_py/runner.py

@@ -13,10 +13,12 @@ from web3.contract.contract import Contract
 from web3.exceptions import TimeExhausted, TransactionNotFound
 
 from .contract.abi.bloxbergAbi import contract as bloxbergAbi
-from .contract.abi.polygonAbi import contract as polygonAbi
+from .contract.abi.polygonProtocolAbi import contract as polygonAbi
+from .contract.abi.ECLDAbi import contract as ECLDAbi
 from .contract.operation.bloxbergProtocolContract import BloxbergProtocolContract
 from .contract.operation.imageRegistryContract import ImageRegistryContract
 from .contract.operation.polygonProtocolContract import PolygonProtocolContract
+from .enums import ECNetworkByChainId
 from binascii import hexlify
 from nacl.public import Box, PrivateKey, PublicKey
 
@@ -71,6 +73,7 @@ class EthernityCloudRunner:
         self.event_queue = Queue()  # Queue to store events
         self.processed_events: List[str] = []  # List to store processed events
         self.task_thread = None
+        self.current_order_index = 0
         self.status = ECStatus.RUNNING
         self.progress = ECEvent.INIT
         self.last_error = None
@@ -83,6 +86,8 @@ class EthernityCloudRunner:
     def set_network(self, network, type) -> None:
         self.network = network.lower()+ "_" + type.lower()
         self.trustedZoneImage = ECRunner()[network.upper()]["PYNITHY_RUNNER_"+type.upper()]
+        self.network_address = getattr(getattr(ECAddress, network.upper(), None), f"{type.upper()}_ADDRESS", None)
+        self.chain_id = ECNetworkByChainId[network.upper()][type.upper()]
         
     def set_private_key(self, private_key) -> None:
         self.private_key = private_key
@@ -98,22 +103,28 @@ class EthernityCloudRunner:
             ECAddress.BLOXBERG.TESTNET_ADDRESS,
             ECAddress.BLOXBERG.MAINNET_ADDRESS,
         ]:
-            self.protocol_contract = BloxbergProtocolContract(
+            self.protocol = BloxbergProtocolContract(
                 network_address, self.signer
             )
             self.protocol_abi = bloxbergAbi.get("abi")
+            self.token_contract = self.contract.token_contract
+            self.protocol_contract = self.contract.protocol_contract
+
         elif network_address == ECAddress.POLYGON.MAINNET_ADDRESS:
-            self.protocol_contract = PolygonProtocolContract(
-                ECAddress.POLYGON.MAINNET_PROTOCOL_ADDRESS, self.signer, True  # type: ignore
+            self.contract = PolygonProtocolContract(
+                ECAddress.POLYGON.MAINNET_ADDRESS, ECAddress.POLYGON.MAINNET_PROTOCOL_ADDRESS, self.signer, self.chain_id  # type: ignore
             )
             self.protocol_abi = polygonAbi.get("abi")
+            self.token_contract = self.contract.token_contract
+            self.protocol_contract = self.contract.protocol_contract
+
         elif network_address == ECAddress.POLYGON.TESTNET_ADDRESS:
-            self.protocol_contract = PolygonProtocolContract(
-                ECAddress.POLYGON.TESTNET_PROTOCOL_ADDRESS, self.signer, False  # type: ignore
+            self.contract = PolygonProtocolContract(
+                ECAddress.POLYGON.TESTNET_ADDRESS, ECAddress.POLYGON.TESTNET_PROTOCOL_ADDRESS, self.signer, self.chain_id  # type: ignore
             )
             self.protocol_abi = polygonAbi.get("abi")
-
-        self.token_contract = self.protocol_contract.ethernity_contract
+            self.token_contract = self.contract.token_contract     
+            self.protocol_contract = self.contract.protocol_contract
 
     def set_log_level(self, level):
         self.log_level = ECLog[level.upper()]
@@ -136,7 +147,7 @@ class EthernityCloudRunner:
             debug_details = ""
             if (self.log_level == ECLog.DEBUG):
                 debug_details = "Event:",{event_type},"Status:",{status}
-            self.log.append(f"[{self.log_level.name}] {datetime.now()} {message} {debug_details}")
+            self.log.append(f"[{log_level.name}] {datetime.now()} {message} {debug_details}")
                   
 
     def get_enclave_details(self) -> bool:
@@ -149,6 +160,8 @@ class EthernityCloudRunner:
                 self.enclave_public_key,
                 self.enclave_docker_compose_ipfs_hash,
             ) = details
+
+            print(self.enclave_public_key)
             self.log_append(
                 f"ENCLAVE_IMAGE_IPFS_HASH: {self.enclave_image_ipfs_hash}"
             )
@@ -192,8 +205,8 @@ class EthernityCloudRunner:
     def check_web3_connection(self) -> Literal[False]:
         try:
             # self.token_contract.get_provider().send("eth_requestAccounts", [])
-            self.protocol_contract.get_provider()
-            wallet_address = self.protocol_contract.get_current_wallet()
+            self.contract.get_provider()
+            wallet_address = self.contract.get_current_wallet()
             return wallet_address is not None and wallet_address != ""
         except Exception as e:
             self.log_append(
@@ -232,11 +245,11 @@ class EthernityCloudRunner:
             self.log_append(
                 f"Uploaded encrypted code to IPFS: {self.script_hash}"
             )
-        script_checksum = self.protocol_contract.sign_message(script_checksum)
+        script_checksum = self.contract.sign_message(script_checksum)
         return f"{TRUSTEDZONE_VERSION}:{self.script_hash}:{script_checksum.signature.hex()}"
 
     def get_v3_input_metadata(self) -> str:
-        file_set_checksum = self.protocol_contract.sign_message(ZERO_CHECKSUM)
+        file_set_checksum = self.contract.sign_message(ZERO_CHECKSUM)
         return f"{TRUSTEDZONE_VERSION}::{file_set_checksum.signature.hex()}"
 
     def create_do_request(
@@ -248,17 +261,26 @@ class EthernityCloudRunner:
         gas_limit: None = None,
     ) -> bool:
         try:
-            __provider = self.protocol_contract.get_provider()
+            __provider = self.contract.get_provider()
             self.log_append(
                 f"Submitting transaction for DO request",
             )
-            transaction_hash = self.protocol_contract.add_do_request(
-                image_metadata,
-                code_metadata,
-                input_metadata,
-                node_address,
-                self.resources,
-            )
+            while True:
+                try:
+                    transaction_hash = self.contract.add_do_request(
+                        image_metadata,
+                        code_metadata,
+                        input_metadata,
+                        node_address,
+                        self.resources,
+                    )
+                    break
+                except Exception as e: 
+                    self.log_append(
+                        f"Unable to build transaction: {e}", ECLog.WARNING
+                    )
+                    time.sleep(1)
+
 
             self.do_hash = transaction_hash
             receipt = None
@@ -269,13 +291,13 @@ class EthernityCloudRunner:
                     )
 
                     is_processed = self.wait_for_transaction_to_be_processed(
-                        self.protocol_contract, transaction_hash
+                        self.contract, transaction_hash
                     )
                     receipt = __provider.eth.wait_for_transaction_receipt(
                         transaction_hash
                     )
                     processed_logs = (
-                        self.token_contract.events._addDORequestEV().process_receipt(
+                        self.protocol_contract.events._addDORequestEV().process_receipt(
                             receipt
                         )
                     )
@@ -352,58 +374,81 @@ class EthernityCloudRunner:
 
         try:
             self.log_append(f"Operator {self.order[1]} is processing task {order_id}")
-            while self.protocol_contract.get_status_from_order(order_id) == 1:
-                time.sleep(1)
-            
-            order_result = self.protocol_contract.get_result_from_order(order_id)
 
-            self.log_append(
-                f"Task {order_id} was successfully processed."
-            )
-            parsed_order_result = self.parse_order_result(order_result)
+            while True:
+                try:
+                    while self.contract.get_status_from_order(order_id) == 1:
+                        time.sleep(1)
+                
+                    order_result = self.contract.get_result_from_order(order_id)
 
-            self.log_append(
-                f"Result IPFS hash: {parsed_order_result['result_ipfs_hash']}"
-            )
+                    self.log_append(
+                        f"Task {order_id} was successfully processed."
+                    )
+                    break
+                except Exception as e:
+                    self.log_append(f"Checking order details: {e}", ECLog.WARNING)
 
-            transaction_result = self.parse_transaction_bytes(
-                parsed_order_result["transaction_bytes"]
-            )
+            try:
+
+                parsed_order_result = self.parse_order_result(order_result)
+
+                self.log_append(
+                        f"Checking result hash: {parsed_order_result['result_ipfs_hash']}"
+                )
+
+                transaction_result = self.parse_transaction_bytes(
+                    parsed_order_result["transaction_bytes"]
+                )
+            except Exception as e:
+                self.log_append(f"Error parsing transaction bytes: {e}", ECLog.ERROR)
+                self.log_append(f"Could not parse transaction bytes. The operator result is invalid, indicating a failure", ECLog.ERROR)
+                self.log_append(f"The tokens associated with the task will be refunded after automatic result validation", ECLog.ERROR)
+                self.log_append(f"Please try again.", ECLog.ERROR)
+                return False
+            
+
+            self.log_append(f"Verifying ZK proof")
 
             wallet = generate_wallet(
                 self.challenge_hash.decode("utf-8"),  # type: ignore
                 transaction_result["enclave_challenge"],
             )
             if not wallet or wallet != transaction_result["from"]:
-                return {
-                    "success": False,
-                    "message": "Integrity check failed, signer wallet address is wrong.",
-                }
-            self.log_append(
-                f"Downloading {parsed_order_result['result_ipfs_hash']} ..."
-            )
-            ipfs_result = ipfsClient.get_file_content(
-                parsed_order_result["result_ipfs_hash"]
-            )
-            self.log_append(
-                f"Validating proof..."
-            )
-            current_wallet_address = self.protocol_contract.get_current_wallet()
+                self.log_append(f"Integrity check failed, signer wallet address is wrong", ECLog.ERROR)
+                self.log_append(f"The tokens associated with the task will be refunded after automatic result validation.",  ECLog.ERROR)
+                self.log_append(f"Please try running the task again", ECLog.ERROR)
+                return False
+            
+            self.log_append(f"Verification succesful!")
+            self.log_append(f"The result is signed by: {wallet}")
+            
+            while True:
+                try:
+                    time.sleep(1)
+                    self.log_append(f"Downloading {parsed_order_result['result_ipfs_hash']}")
+
+                    ipfs_result = ipfsClient.get_file_content(
+                        parsed_order_result["result_ipfs_hash"]
+                    )
+                    break
+                except Exception as e:
+                    self.log_append(f"Error downloading IPFS result: {e}", ECLog.WARNING)
+                    self.log_append(f"Retrying")
+            
+
+            self.log_append(f"Decrypting result")
 
             decrypted_data = decrypt_nacl(self.private_key, ipfs_result)
             if not decrypted_data["success"]:
-                return {
-                    "success": False,
-                    "message": "Could not decrypt the order result.",
-                }
+                self.log_append(f"Could not decrypt the order result.", ECLog.ERROR)
+
 
             self.log_append(f"Result value: {decrypted_data['data']}",ECLog.DEBUG)
             ipfs_result_checksum = sha256(decrypted_data["data"],True)
             if ipfs_result_checksum != transaction_result["checksum"]:
-                return {
-                    "success": False,
-                    "message": "Integrity check failed, checksum of the order result is wrong. {ipfs_result_checksum} != {transaction_result['checksum']}",
-                }
+                self.log_append(f"Integrity check failed, checksum of the order result is wrong. {ipfs_result_checksum} != {transaction_result['checksum']}", ECLog.ERROR)
+                return False
             
             result_transaction_hash = ""
             block_timestamp = 0
@@ -441,7 +486,7 @@ class EthernityCloudRunner:
 
             return {
                 "success": True,
-                "contract_address": self.protocol_contract.contract_address(),
+                "contract_address": self.contract.get_protocol_address(),
                 "input_transaction_hash": self.do_hash,
                 "output_transaction_hash": result_transaction_hash,
                 "order_id": order_id,
@@ -461,16 +506,22 @@ class EthernityCloudRunner:
             )
 
             if str(e) == ECError.PARSE_ERROR:
-                return {
-                    "success": False,
-                    "message": "Ethernity parsing transaction error.",
-                }
+                error_message = ECError.PARSE_ERROR
+                self.log_append(error_message)
+                self.progress = ECEvent.FINISHED
+                self.status = ECStatus.ERROR
+                return False
             if str(e) == ECError.IPFS_DOWNLOAD_ERROR:
-                return {
-                    "success": False,
-                    "message": "Ethernity IPFS download result error.",
-                }
-            time.sleep(5)
+                self.log_append("Unable to download result from ipfs, trying again",ECLog.WARNING)
+                time.sleep(5)
+
+
+            if (self.get_result_from_order_repeats > 10):
+                self.log_append("After multiple tries, the result cannot be downloaded", ECLog.ERROR)
+                self.progress = ECEvent.FINISHED
+                self.status = ECStatus.ERROR
+                return False
+            
             self.get_result_from_order_repeats += 1
             return self.get_result_from_order(order_id)
 
@@ -481,6 +532,7 @@ class EthernityCloudRunner:
         image_metadata = self.get_v3_image_metadata(self.challenge_hash)
         code_metadata = self.get_v3_code_metadata(code)
         input_metadata = self.get_v3_input_metadata()
+        self.current_order_index = self.protocol_contract.functions._getOrdersCount().call()
         do_sent_successfully = self.create_do_request(
             image_metadata, code_metadata, input_metadata, self.node_address, None
         )
@@ -493,7 +545,7 @@ class EthernityCloudRunner:
         self.log_append(
             f"Waiting for Ethernity CLOUD network..."
         )
-
+        
         while True:
             try:
                 if self.find_order(self.do_request):
@@ -534,9 +586,10 @@ class EthernityCloudRunner:
 
 
     def find_order(self, doreq: int) -> bool:
-        count = self.token_contract.functions._getOrdersCount().call()
-        for i in range(count - 1, count - 5, -1):
-            order = self.token_contract.caller()._getOrder(i)
+        time.sleep(1)
+        count = self.protocol_contract.functions._getOrdersCount().call()
+        for i in range(count - 1, self.current_order_index - 1, -1):
+            order = self.protocol_contract.caller()._getOrder(i)
             # if order[2] == doreq and order[4] == 0:
             if order[2] == doreq:
                 self.order = order
@@ -545,7 +598,11 @@ class EthernityCloudRunner:
         return False
 
     def approve_order(self) -> bool:
-        transaction_hash = self.protocol_contract.approve_order(self.order_id)
+        transaction_hash = self.contract.approve_order(self.order_id)
+
+        if self.node_address != "":
+            self.log_append(f"Transaction is delegated to {self.node_address}, skipping approval")
+            return True
 
         receipt = None
         for i in range(100):
@@ -553,11 +610,11 @@ class EthernityCloudRunner:
                 self.log_append(
                         f"{transaction_hash} is pending..."
                 )
-                receipt = self.protocol_contract.get_provider().eth.wait_for_transaction_receipt(
+                receipt = self.contract.get_provider().eth.wait_for_transaction_receipt(
                     transaction_hash
                 )
                 if receipt is not None:
-                    self.node_address = self.protocol_contract.get_order(self.order_id)[1]
+                    self.node_address = self.contract.get_order(self.order_id)[1]
                     break
             except KeyError:
                 time.sleep(1)
@@ -600,7 +657,7 @@ class EthernityCloudRunner:
             return True
         
         if is_address(node_address):
-            is_node = self.protocol_contract.is_node_operator(node_address)
+            is_node = self.contract.is_node_operator(node_address)
             if not is_node:
                 self.log_append(
                     "The target address is not a valid node operator address",
@@ -636,7 +693,8 @@ class EthernityCloudRunner:
                 "validators": 1,
             }
         
-        self.resources = resources;
+        self.resources = resources
+        self.price = resources['taskPrice']
 
         if self.running:
             raise RuntimeError("A task is already running.")
@@ -680,14 +738,14 @@ class EthernityCloudRunner:
                 if event == ECEvent.INIT:
                     self.progress = ECEvent.INIT
                     self.log_append("Checking wallet balance...")
-                    balance = self.protocol_contract.get_balance()
+                    balance = self.contract.get_balance()
                     balance = int(balance)
 
-                    if balance < resources["taskPrice"]:
+                    if balance < self.price:
                         self.progress = ECEvent.FINISHED
                         self.status = ECStatus.ERROR
                         error_message = (
-                            f"Insufficient wallet balance. Required: {resources['taskPrice']}, "
+                            f"Insufficient wallet balance. Required: {self.price}, "
                             f"Available: {balance}"
                         )
                         self.last_error = error_message
@@ -740,21 +798,19 @@ class EthernityCloudRunner:
                             ECAddress.POLYGON.TESTNET_ADDRESS,
                         ]:
                             self.log_append(
-                                "Checking for the allowance on the current wallet..."
+                                "Checking allowance on the current wallet..."
                             )
-                            passed_allowance = self.token_contract.check_and_set_allowance(
-                                self.protocol_contract.contract_address(),
-                                "100",
-                                str(resources["taskPrice"]),
-                            )
-                            if not passed_allowance:
-                                self.progress = ECEvent.FINISHED
-                                self.status = ECStatus.ERROR
-                                error_message = "Unable to set allowance on the current wallet"
-                                self.last_error = error_message
-                                self.log_append(error_message, ECLog.ERROR)
-                                self.processed_events.append(event)
-                                return
+                            while True:
+                                try:
+                                    passed_allowance = self.contract.check_and_set_allowance(
+                                        str(self.price),
+                                    )
+                                    if passed_allowance == True:
+                                        break
+                                except Exception as e:
+                                    self.log_append(f"Unable to set allowance on current wallet: {e}", ECLog.WARNING)
+                                    self.log_append(f"Retrying...", ECLog.WARNING)
+
                             self.log_append("Allowance checking completed.")
                         if not self.create_task(code):
                             self.progress = ECEvent.FINISHED

{ethernity_cloud_runner_py-0.2.2 → ethernity_cloud_runner_py-0.2.4}/ethernity_cloud_runner_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ethernity-cloud-runner-py
-Version: 0.2.2
+Version: 0.2.4
 Summary: Ethernity Cloud Runner Python
 Home-page: https://github.com/ethernity-cloud/ethernity-cloud-runner-py
 Author: Ethernity Cloud Team

{ethernity_cloud_runner_py-0.2.2 → ethernity_cloud_runner_py-0.2.4}/ethernity_cloud_runner_py.egg-info/SOURCES.txt

@@ -13,10 +13,11 @@ ethernity_cloud_runner_py.egg-info/dependency_links.txt
 ethernity_cloud_runner_py.egg-info/requires.txt
 ethernity_cloud_runner_py.egg-info/top_level.txt
 ethernity_cloud_runner_py/contract/__init__.py
+ethernity_cloud_runner_py/contract/abi/ECLDAbi.py
 ethernity_cloud_runner_py/contract/abi/__init__.py
 ethernity_cloud_runner_py/contract/abi/bloxbergAbi.py
 ethernity_cloud_runner_py/contract/abi/imageRegistryAbi.py
-ethernity_cloud_runner_py/contract/abi/polygonAbi.py
+ethernity_cloud_runner_py/contract/abi/polygonProtocolAbi.py
 ethernity_cloud_runner_py/contract/operation/__init__.py
 ethernity_cloud_runner_py/contract/operation/bloxbergProtocolContract.py
 ethernity_cloud_runner_py/contract/operation/imageRegistryContract.py

{ethernity_cloud_runner_py-0.2.2 → ethernity_cloud_runner_py-0.2.4}/setup.py

@@ -13,7 +13,7 @@ print(this_directory);
 
 setup(
     name="ethernity-cloud-runner-py",
-    version="0.2.2",
+    version="0.2.4",
     url="https://github.com/ethernity-cloud/ethernity-cloud-runner-py",
     author="Ethernity Cloud Team",
     author_email="contact@ethernity.cloud",