dkg 8.0.0a2__py3-none-any.whl → 8.0.1__py3-none-any.whl

dkg/modules/async_module.py

@@ -0,0 +1,66 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from dataclasses import asdict
+from typing import Any, Callable, Sequence
+
+from dkg.exceptions import ValidationError
+from dkg.managers.async_manager import AsyncRequestManager
+from dkg.method import Method
+from dkg.types import TReturn
+
+
+class AsyncModule:
+    manager: AsyncRequestManager
+
+    def retrieve_caller_fn(
+        self, method: Method[Callable[..., TReturn]]
+    ) -> Callable[..., TReturn]:
+        async def caller(*args: Any, **kwargs: Any) -> TReturn:
+            processed_args = method.process_args(*args, **kwargs)
+            request_params = asdict(method.action)
+            request_params.update(processed_args)
+
+            return await self.manager.blocking_request(
+                type(method.action), request_params
+            )
+
+        return caller
+
+    def _attach_modules(self, module_definitions: dict[str, Any]) -> None:
+        for module_name, module_info in module_definitions.items():
+            module_info_is_list_like = isinstance(module_info, Sequence)
+
+            module = module_info[0] if module_info_is_list_like else module_info
+
+            if hasattr(self, module_name):
+                raise AttributeError(
+                    f"Cannot set {self} module named '{module_name}'. "
+                    " The dkg object already has an attribute with that name"
+                )
+
+            setattr(self, module_name, module)
+
+            if module_info_is_list_like:
+                if len(module_info) == 2:
+                    submodule_definitions = module_info[1]
+                    module: "AsyncModule" = getattr(self, module_name)
+                    module._attach_modules(submodule_definitions)
+                elif len(module_info) != 1:
+                    raise ValidationError(
+                        "Module definitions can only have 1 or 2 elements."
+                    )

dkg/modules/graph/async_graph.py

@@ -0,0 +1,118 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+from rdflib.plugins.sparql.parser import parseQuery
+
+from dkg.managers.async_manager import AsyncRequestManager
+from dkg.modules.async_module import AsyncModule
+from dkg.types import NQuads
+from dkg.constants import Operations, Status
+from dkg.services.input_service import InputService
+from dkg.services.node_services.async_node_service import AsyncNodeService
+from dkg.types import UAL
+
+
+class AsyncGraph(AsyncModule):
+    def __init__(
+        self,
+        manager: AsyncRequestManager,
+        input_service: InputService,
+        node_service: AsyncNodeService,
+    ):
+        self.manager = manager
+        self.input_service = input_service
+        self.node_service = node_service
+
+    async def query(
+        self,
+        query: str,
+        options: dict = None,
+    ) -> NQuads:
+        if options is None:
+            options = {}
+
+        arguments = self.input_service.get_query_arguments(options)
+
+        max_number_of_retries = arguments.get("max_number_of_retries")
+        frequency = arguments.get("frequency")
+        paranet_ual = arguments.get("paranet_ual")
+        repository = arguments.get("repository")
+
+        parsed_query = parseQuery(query)
+        query_type = parsed_query[1].name.replace("Query", "").upper()
+
+        result = await self.node_service.query(
+            query, query_type, repository, paranet_ual
+        )
+        operation_id = result.get("operationId")
+        operation_result = await self.node_service.get_operation_result(
+            operation_id, Operations.QUERY.value, max_number_of_retries, frequency
+        )
+
+        return operation_result["data"]
+
+    async def publish_finality(self, UAL: UAL, options=None):
+        if options is None:
+            options = {}
+
+        arguments = self.input_service.get_publish_finality_arguments(options)
+        max_number_of_retries = arguments.get("max_number_of_retries")
+        minimum_number_of_finalization_confirmations = arguments.get(
+            "minimum_number_of_finalization_confirmations"
+        )
+        frequency = arguments.get("frequency")
+        try:
+            finality_status_result = await self.node_service.finality_status(
+                UAL,
+                minimum_number_of_finalization_confirmations,
+                max_number_of_retries,
+                frequency,
+            )
+        except Exception as e:
+            return {"status": Status.ERROR.value, "error": str(e)}
+
+        if finality_status_result == 0:
+            try:
+                finality_operation_id = await self.node_service.finality(
+                    UAL,
+                    minimum_number_of_finalization_confirmations,
+                    max_number_of_retries,
+                    frequency,
+                )
+            except Exception as e:
+                return {"status": Status.ERROR.value, "error": str(e)}
+
+            try:
+                return await self.node_service.get_operation_result(
+                    finality_operation_id, "finality", max_number_of_retries, frequency
+                )
+            except Exception as e:
+                return {"status": Status.NOT_FINALIZED.value, "error": str(e)}
+
+        elif finality_status_result >= minimum_number_of_finalization_confirmations:
+            return {
+                "status": Status.FINALIZED.value,
+                "numberOfConfirmations": finality_status_result,
+                "requiredConfirmations": minimum_number_of_finalization_confirmations,
+            }
+        else:
+            return {
+                "status": Status.NOT_FINALIZED.value,
+                "numberOfConfirmations": finality_status_result,
+                "requiredConfirmations": minimum_number_of_finalization_confirmations,
+            }

dkg/modules/graph/graph.py

@@ -0,0 +1,94 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from rdflib.plugins.sparql.parser import parseQuery
+
+
+from dkg.managers.manager import DefaultRequestManager
+from dkg.modules.module import Module
+from dkg.types import NQuads
+from dkg.services.node_services.node_service import NodeService
+from dkg.services.input_service import InputService
+from dkg.constants import Operations, Status
+
+
+class Graph(Module):
+    def __init__(
+        self,
+        manager: DefaultRequestManager,
+        input_service: InputService,
+        node_service: NodeService,
+    ):
+        self.manager = manager
+        self.input_service = input_service
+        self.node_service = node_service
+
+    def query(
+        self,
+        query: str,
+        options: dict = {},
+    ) -> NQuads:
+        arguments = self.input_service.get_query_arguments(options)
+
+        max_number_of_retries = arguments.get("max_number_of_retries")
+        frequency = arguments.get("frequency")
+        paranet_ual = arguments.get("paranet_ual")
+        repository = arguments.get("repository")
+
+        parsed_query = parseQuery(query)
+        query_type = parsed_query[1].name.replace("Query", "").upper()
+
+        result = self.node_service.query(query, query_type, repository, paranet_ual)
+        operation_id = result.get("operationId")
+        operation_result = self.node_service.get_operation_result(
+            operation_id, Operations.QUERY.value, max_number_of_retries, frequency
+        )
+
+        return operation_result["data"]
+
+    def publish_finality(self, UAL, options=None):
+        if options is None:
+            options = {}
+
+        arguments = self.input_service.get_publish_finality_arguments(options)
+        max_number_of_retries = arguments.get("max_number_of_retries")
+        minimum_number_of_finalization_confirmations = arguments.get(
+            "minimum_number_of_finalization_confirmations"
+        )
+        frequency = arguments.get("frequency")
+        try:
+            finality_status_result = self.node_service.finality_status(
+                UAL,
+                minimum_number_of_finalization_confirmations,
+                max_number_of_retries,
+                frequency,
+            )
+        except Exception as e:
+            return {"status": Status.ERROR.value, "error": str(e)}
+
+        if finality_status_result >= minimum_number_of_finalization_confirmations:
+            return {
+                "status": Status.FINALIZED.value,
+                "numberOfConfirmations": finality_status_result,
+                "requiredConfirmations": minimum_number_of_finalization_confirmations,
+            }
+        else:
+            return {
+                "status": Status.NOT_FINALIZED.value,
+                "numberOfConfirmations": finality_status_result,
+                "requiredConfirmations": minimum_number_of_finalization_confirmations,
+            }

dkg/{module.py → modules/module.py}

@@ -19,7 +19,7 @@ from dataclasses import asdict
 from typing import Any, Callable, Sequence
 
 from dkg.exceptions import ValidationError
-from dkg.manager import DefaultRequestManager
+from dkg.managers.manager import DefaultRequestManager
 from dkg.method import Method
 from dkg.types import TReturn
 

dkg/{network.py → modules/network/network.py}

@@ -15,11 +15,11 @@
 # specific language governing permissions and limitations
 # under the License.
 
-from dkg.constants import DEFAULT_HASH_FUNCTION_ID
+from dkg.constants import DefaultParameters
 from dkg.dataclasses import BidSuggestionRange
-from dkg.manager import DefaultRequestManager
+from dkg.managers.manager import DefaultRequestManager
 from dkg.method import Method
-from dkg.module import Module
+from dkg.modules.module import Module
 from dkg.types import DataHexStr
 from dkg.utils.blockchain_request import BlockchainRequest
 from dkg.utils.node_request import NodeRequest
@@ -50,7 +50,7 @@ class Network(Module):
             size_in_bytes,
             content_asset_storage_address,
             public_assertion_id,
-            DEFAULT_HASH_FUNCTION_ID,
+            DefaultParameters.HASH_FUNCTION_ID.value,
             range,
         )
 

dkg/modules/node/async_node.py

@@ -0,0 +1,39 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from dkg.dataclasses import NodeResponseDict
+from dkg.managers.async_manager import AsyncRequestManager
+from dkg.method import Method
+from dkg.modules.async_module import AsyncModule
+from dkg.utils.blockchain_request import BlockchainRequest
+from dkg.types import Address
+from dkg.services.node_services.async_node_service import AsyncNodeService
+
+
+class AsyncNode(AsyncModule):
+    def __init__(self, manager: AsyncRequestManager, node_service: AsyncNodeService):
+        self.manager = manager
+        self.node_service = node_service
+
+    @property
+    async def info(self) -> NodeResponseDict:
+        return await self.node_service.info()
+
+    _get_identity_id = Method(BlockchainRequest.get_identity_id)
+
+    async def get_identity_id(self, operational: Address) -> int:
+        return await self._get_identity_id(operational)

dkg/{node.py → modules/node/node.py}

@@ -16,9 +16,9 @@
 # under the License.
 
 from dkg.dataclasses import NodeResponseDict
-from dkg.manager import DefaultRequestManager
+from dkg.managers.manager import DefaultRequestManager
 from dkg.method import Method
-from dkg.module import Module
+from dkg.modules.module import Module
 from dkg.utils.node_request import NodeRequest
 from dkg.utils.blockchain_request import BlockchainRequest
 from dkg.types import Address

dkg/{paranet.py → modules/paranet/paranet.py}

@@ -27,9 +27,9 @@ from dkg.dataclasses import (
     ParanetNodesAccessPolicy,
     ParanetMinersAccessPolicy,
 )
-from dkg.manager import DefaultRequestManager
+from dkg.managers.manager import DefaultRequestManager
 from dkg.method import Method
-from dkg.module import Module
+from dkg.modules.module import Module
 from dkg.types import Address, UAL, HexStr
 from dkg.utils.blockchain_request import BlockchainRequest
 from dkg.utils.ual import parse_ual

dkg/providers/__init__.py

@@ -1,2 +1,9 @@
-from .blockchain import BlockchainProvider  # NOQA
-from .node_http import NodeHTTPProvider  # NOQA
+from .blockchain import BlockchainProvider, AsyncBlockchainProvider
+from .node import NodeHTTPProvider, AsyncNodeHTTPProvider
+
+__all__ = [
+    "BlockchainProvider",
+    "AsyncBlockchainProvider",
+    "NodeHTTPProvider",
+    "AsyncNodeHTTPProvider",
+]

dkg/providers/blockchain/__init__.py

@@ -0,0 +1,4 @@
+from .blockchain import BlockchainProvider
+from .async_blockchain import AsyncBlockchainProvider
+
+__all__ = ["BlockchainProvider", "AsyncBlockchainProvider"]

dkg/providers/blockchain/async_blockchain.py

@@ -0,0 +1,245 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import os
+import asyncio
+from dotenv import load_dotenv
+from functools import wraps
+from typing import Any
+
+import aiohttp
+from dkg.constants import BLOCKCHAINS
+from dkg.exceptions import (
+    AccountMissing,
+    NetworkNotSupported,
+)
+from dkg.types import URI, Address, Environment, Wei
+from web3.contract import Contract
+from web3.contract.contract import ContractFunction
+from web3.types import TxReceipt
+from web3.providers import AsyncHTTPProvider
+from web3 import AsyncWeb3
+from dkg.providers.blockchain.base_blockchain import BaseBlockchainProvider
+
+
+class AsyncBlockchainProvider(BaseBlockchainProvider):
+    def __init__(
+        self,
+        environment: Environment,
+        blockchain_id: str,
+        rpc_uri: URI | None = None,
+        gas_price: Wei | None = None,
+        verify: bool = True,
+    ):
+        super().__init__(environment, blockchain_id, rpc_uri, gas_price)
+
+        ssl_context = None if verify else False
+        self.w3 = AsyncWeb3(
+            AsyncHTTPProvider(self.rpc_uri, request_kwargs={"ssl": ssl_context})
+        )
+
+        if self.blockchain_id is None:
+            self.blockchain_id = f"{blockchain_id}:{self.w3.eth.chain_id}"
+            if self.blockchain_id not in BLOCKCHAINS[self.environment]:
+                raise NetworkNotSupported(
+                    f"Network with blockchain ID {self.blockchain_id} isn't supported!"
+                )
+
+        self.gas_price_oracle = BLOCKCHAINS[self.environment][self.blockchain_id].get(
+            "gas_price_oracle",
+            None,
+        )
+
+        hub_address: Address = BLOCKCHAINS[self.environment][self.blockchain_id]["hub"]
+        self.contracts: dict[str, Contract] = {
+            "Hub": self.w3.eth.contract(
+                address=hub_address,
+                abi=self.abi["Hub"],
+                decode_tuples=True,
+            )
+        }
+
+        self.contracts_initialized = False
+
+        load_dotenv()
+        if private_key := os.environ.get("PRIVATE_KEY"):
+            self.set_account(private_key)
+
+    async def ensure_contracts_initialized(self):
+        if not self.contracts_initialized:
+            await self._init_contracts()
+            self.contracts_initialized = True
+
+    async def make_json_rpc_request(
+        self, endpoint: str, args: dict[str, Any] = {}
+    ) -> Any:
+        web3_method = getattr(self.w3.eth, endpoint)
+
+        if callable(web3_method):
+            return await web3_method(**args)
+        else:
+            return web3_method
+
+    @staticmethod
+    def handle_updated_contract(func):
+        @wraps(func)
+        async def wrapper(self, *args, **kwargs):
+            contract_name = kwargs.get("contract") or (args[0] if args else None)
+
+            try:
+                return await func(self, *args, **kwargs)
+            except Exception as err:
+                if (
+                    contract_name
+                    and isinstance(contract_name, str)
+                    and any(msg in str(err) for msg in ["revert", "VM Exception"])
+                    and not await self._check_contract_status(contract_name)
+                ):
+                    is_updated = await self._update_contract_instance(contract_name)
+                    if is_updated:
+                        return await func(self, *args, **kwargs)
+                raise err
+
+        return wrapper
+
+    @handle_updated_contract
+    async def call_function(
+        self,
+        contract: str | dict[str, str],
+        function: str,
+        args: dict[str, Any] = {},
+        state_changing: bool = False,
+        gas_price: Wei | None = None,
+        gas_limit: Wei | None = None,
+    ) -> TxReceipt | Any:
+        await self.ensure_contracts_initialized()
+        if isinstance(contract, str):
+            contract_name = contract
+            contract_instance = self.contracts[contract_name]
+        else:
+            contract_name = contract["name"]
+            contract_instance = self.w3.eth.contract(
+                address=contract["address"],
+                abi=self.abi[contract_name],
+                decode_tuples=True,
+            )
+            self.contracts[contract_name] = contract_instance
+
+        contract_function: ContractFunction = getattr(
+            contract_instance.functions, function
+        )
+
+        if not state_changing:
+            result = await contract_function(**args).call()
+            if function in (
+                output_named_tuples := self.output_named_tuples[contract_name]
+            ):
+                result = output_named_tuples[function](*result)
+            return result
+        else:
+            if not hasattr(self, "account"):
+                raise AccountMissing(
+                    "State-changing transactions can be performed only with specified "
+                    "account."
+                )
+
+            options = {
+                "gas": gas_limit or await contract_function(**args).estimate_gas(),
+            }
+
+            gas_price = (
+                self.gas_price or gas_price or await self._get_network_gas_price()
+            )
+
+            if gas_price is not None:
+                options["gasPrice"] = gas_price
+
+            tx_hash = await contract_function(**args).transact(options)
+            tx_receipt = await self.w3.eth.wait_for_transaction_receipt(tx_hash)
+
+            return tx_receipt
+
+    async def _get_network_gas_price(self) -> Wei | None:
+        if self.environment == "development":
+            return None
+
+        async def fetch_gas_price(oracle_url: str) -> Wei | None:
+            try:
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(oracle_url) as response:
+                        response.raise_for_status()
+                        data: dict = await response.json()
+
+                        if "result" in data:
+                            return int(data["result"], 16)
+                        elif "average" in data:
+                            return self.w3.to_wei(data["average"], "gwei")
+                        else:
+                            return None
+            except Exception:
+                return None
+
+        oracles = self.gas_price_oracle
+        if oracles is not None:
+            if isinstance(oracles, str):
+                oracles = [oracles]
+
+            for oracle_url in oracles:
+                gas_price = await fetch_gas_price(oracle_url)
+                if gas_price is not None:
+                    return gas_price
+
+        return None
+
+    async def _init_contracts(self):
+        init_tasks = []
+        for contract in self.abi.keys():
+            if contract == "Hub":
+                continue
+            init_tasks.append(self._update_contract_instance(contract))
+        await asyncio.gather(*init_tasks)
+
+    async def _update_contract_instance(self, contract: str) -> bool:
+        [is_contract, is_storage] = await asyncio.gather(
+            self.contracts["Hub"].functions.isContract(contractName=contract).call(),
+            self.contracts["Hub"]
+            .functions.isAssetStorage(assetStorageName=contract)
+            .call(),
+        )
+        if is_contract or is_storage:
+            self.contracts[contract] = self.w3.eth.contract(
+                address=(
+                    await self.contracts["Hub"]
+                    .functions.getAssetStorageAddress(contract)
+                    .call()
+                    if contract.endswith("AssetStorage")
+                    or contract.endswith("CollectionStorage")
+                    else await self.contracts["Hub"]
+                    .functions.getContractAddress(contract)
+                    .call()
+                ),
+                abi=self.abi[contract],
+                decode_tuples=True,
+            )
+            return True
+        return False
+
+    async def _check_contract_status(self, contract: str) -> bool:
+        try:
+            return await self.call_function(contract, "status")
+        except Exception:
+            return False