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

dkg/services/blockchain_services/blockchain_service.py

@@ -0,0 +1,174 @@
+from dkg.modules.module import Module
+from dkg.managers.manager import DefaultRequestManager
+from dkg.utils.blockchain_request import BlockchainRequest
+from dkg.method import Method
+from dkg.constants import ZERO_ADDRESS
+from web3 import Web3
+from typing import Optional
+from dkg.types import Address, UAL
+from dkg.utils.blockchain_request import KnowledgeCollectionResult, AllowanceResult
+from dkg.utils.ual import parse_ual
+
+
+class BlockchainService(Module):
+    def __init__(self, manager: DefaultRequestManager):
+        self.manager = manager
+
+    _owner = Method(BlockchainRequest.owner_of)
+    _get_contract_address = Method(BlockchainRequest.get_contract_address)
+    _get_current_allowance = Method(BlockchainRequest.allowance)
+    _increase_allowance = Method(BlockchainRequest.increase_allowance)
+    _decrease_allowance = Method(BlockchainRequest.decrease_allowance)
+    _create_knowledge_collection = Method(BlockchainRequest.create_knowledge_collection)
+    _mint_knowledge_asset = Method(BlockchainRequest.mint_knowledge_asset)
+    _get_asset_storage_address = Method(BlockchainRequest.get_asset_storage_address)
+    _key_is_operational_wallet = Method(BlockchainRequest.key_is_operational_wallet)
+    _time_until_next_epoch = Method(BlockchainRequest.time_until_next_epoch)
+    _epoch_length = Method(BlockchainRequest.epoch_length)
+    _get_stake_weighted_average_ask = Method(
+        BlockchainRequest.get_stake_weighted_average_ask
+    )
+    _get_block = Method(BlockchainRequest.get_block)
+
+    def decrease_knowledge_collection_allowance(
+        self,
+        allowance_gap: int,
+    ):
+        knowledge_collection_address = self._get_contract_address("KnowledgeCollection")
+        self._decrease_allowance(knowledge_collection_address, allowance_gap)
+
+    def increase_knowledge_collection_allowance(
+        self,
+        sender: str,
+        token_amount: str,
+    ) -> AllowanceResult:
+        """
+        Increases the allowance for knowledge collection if necessary.
+
+        Args:
+            sender: The address of the sender
+            token_amount: The amount of tokens to check/increase allowance for
+
+        Returns:
+            AllowanceResult containing whether allowance was increased and the gap
+        """
+        knowledge_collection_address = self._get_contract_address("KnowledgeCollection")
+
+        allowance = self._get_current_allowance(sender, knowledge_collection_address)
+        allowance_gap = int(token_amount) - int(allowance)
+
+        if allowance_gap > 0:
+            self._increase_allowance(knowledge_collection_address, allowance_gap)
+
+            return AllowanceResult(
+                allowance_increased=True, allowance_gap=allowance_gap
+            )
+
+        return AllowanceResult(allowance_increased=False, allowance_gap=allowance_gap)
+
+    def create_knowledge_collection(
+        self,
+        request: dict,
+        paranet_ka_contract: Optional[Address] = None,
+        paranet_token_id: Optional[int] = None,
+    ) -> KnowledgeCollectionResult:
+        """
+        Creates a knowledge collection on the blockchain.
+
+        Args:
+            request: dict containing all collection parameters
+            paranet_ka_contract: Optional paranet contract address
+            paranet_token_id: Optional paranet token ID
+            blockchain: Blockchain configuration
+
+        Returns:
+            KnowledgeCollectionResult containing collection ID and transaction receipt
+
+        Raises:
+            BlockchainError: If the collection creation fails
+        """
+        sender = self.manager.blockchain_provider.account.address
+        allowance_increased = False
+        allowance_gap = 0
+
+        try:
+            # Handle allowance
+            if request.get("paymaster") and request.get("paymaster") != ZERO_ADDRESS:
+                pass
+            else:
+                allowance_result = self.increase_knowledge_collection_allowance(
+                    sender=sender,
+                    token_amount=request.get("tokenAmount"),
+                )
+                allowance_increased = allowance_result.allowance_increased
+                allowance_gap = allowance_result.allowance_gap
+
+            if not paranet_ka_contract and not paranet_token_id:
+                receipt = self._create_knowledge_collection(
+                    request.get("publishOperationId"),
+                    Web3.to_bytes(hexstr=request.get("merkleRoot")),
+                    request.get("knowledgeAssetsAmount"),
+                    request.get("byteSize"),
+                    request.get("epochs"),
+                    request.get("tokenAmount"),
+                    request.get("isImmutable"),
+                    request.get("paymaster"),
+                    request.get("publisherNodeIdentityId"),
+                    Web3.to_bytes(hexstr=request.get("publisherNodeR")),
+                    Web3.to_bytes(hexstr=request.get("publisherNodeVS")),
+                    request.get("identityIds"),
+                    [Web3.to_bytes(hexstr=x) for x in request.get("r")],
+                    [Web3.to_bytes(hexstr=x) for x in request.get("vs")],
+                )
+            else:
+                receipt = self._mint_knowledge_asset(
+                    paranet_ka_contract,
+                    paranet_token_id,
+                    list(request.values()),
+                )
+
+            event_data = self.manager.blockchain_provider.decode_logs_event(
+                receipt=receipt,
+                contract_name="KnowledgeCollectionStorage",
+                event_name="KnowledgeCollectionCreated",
+            )
+            collection_id = (
+                int(getattr(event_data[0].get("args", {}), "id", None))
+                if event_data
+                else None
+            )
+
+            return KnowledgeCollectionResult(
+                knowledge_collection_id=collection_id, receipt=receipt
+            )
+
+        except Exception as e:
+            if allowance_increased:
+                self.decrease_knowledge_collection_allowance(allowance_gap)
+            raise e
+
+    # TODO: change self._owner to v8 compatible function
+    def get_owner(self, ual: UAL) -> Address:
+        token_id = parse_ual(ual)["token_id"]
+
+        return self._owner(token_id)
+
+    def get_asset_storage_address(self, asset_storage_name: str) -> Address:
+        return self._get_asset_storage_address(asset_storage_name)
+
+    def key_is_operational_wallet(
+        self, identity_id: int, key: Address, purpose: int
+    ) -> bool:
+        return self._key_is_operational_wallet(identity_id, key, purpose)
+
+    def time_until_next_epoch(self) -> int:
+        return self._time_until_next_epoch()
+
+    def epoch_length(self) -> int:
+        return self._epoch_length()
+
+    def get_stake_weighted_average_ask(self) -> int:
+        return self._get_stake_weighted_average_ask()
+
+    def get_block(self, block_identifier: str | int):
+        return self._get_block(block_identifier)

dkg/services/input_service.py

@@ -0,0 +1,183 @@
+from dkg.constants import (
+    DefaultParameters,
+    ZERO_ADDRESS,
+    DEFAULT_PROXIMITY_SCORE_FUNCTIONS_PAIR_IDS,
+)
+
+
+class InputService:
+    def __init__(self, manager, config):
+        self.manager = manager
+        self.config = config
+
+    def get_asset_get_arguments(self, options):
+        return {
+            "max_number_of_retries": self.get_max_number_of_retries(options),
+            "frequency": self.get_frequency(options),
+            "state": self.get_state(options),
+            "include_metadata": self.get_include_metadata(options),
+            "content_type": self.get_content_type(options),
+            "validate": self.get_validate(options),
+            "output_format": self.get_output_format(options),
+            "hash_function_id": self.get_hash_function_id(options),
+            "paranet_ual": self.get_paranet_ual(options),
+            "subject_ual": self.get_subject_ual(options),
+        }
+
+    def get_asset_create_arguments(self, options):
+        return {
+            "max_number_of_retries": self.get_max_number_of_retries(options),
+            "frequency": self.get_frequency(options),
+            "epochs_num": self.get_epochs_num(options),
+            "hash_function_id": self.get_hash_function_id(options),
+            "score_function_id": self.get_score_function_id(options),
+            "immutable": self.get_immutable(options),
+            "token_amount": self.get_token_amount(options),
+            "payer": self.get_payer(options),
+            "minimum_number_of_finalization_confirmations": self.get_minimum_number_of_finalization_confirmations(
+                options
+            ),
+            "minimum_number_of_node_replications": self.get_minimum_number_of_node_replications(
+                options
+            ),
+        }
+
+    def get_query_arguments(self, options):
+        return {
+            "max_number_of_retries": self.get_max_number_of_retries(options),
+            "frequency": self.get_frequency(options),
+            "paranet_ual": self.get_paranet_ual(options),
+            "repository": self.get_repository(options),
+        }
+
+    def get_publish_finality_arguments(self, options):
+        return {
+            "max_number_of_retries": self.get_max_number_of_retries(options),
+            "frequency": self.get_frequency(options),
+            "minimum_number_of_finalization_confirmations": self.get_minimum_number_of_finalization_confirmations(
+                options
+            ),
+        }
+
+    def get_max_number_of_retries(self, options):
+        return (
+            options.get("max_number_of_retries")
+            or self.config.get("max_number_of_retries")
+            or DefaultParameters.MAX_NUMBER_OF_RETRIES.value
+        )
+
+    def get_frequency(self, options):
+        return (
+            options.get("frequency")
+            or self.config.get("frequency")
+            or DefaultParameters.FREQUENCY.value
+        )
+
+    def get_state(self, options):
+        return (
+            options.get("state")
+            or self.config.get("state")
+            or DefaultParameters.STATE.value
+        )
+
+    def get_include_metadata(self, options):
+        return (
+            options.get("include_metadata")
+            or self.config.get("include_metadata")
+            or DefaultParameters.INCLUDE_METADATA.value
+        )
+
+    def get_content_type(self, options):
+        return (
+            options.get("content_type")
+            or self.config.get("content_type")
+            or DefaultParameters.CONTENT_TYPE.value
+        )
+
+    def get_validate(self, options):
+        return (
+            options.get("validate")
+            or self.config.get("validate")
+            or DefaultParameters.VALIDATE.value
+        )
+
+    def get_output_format(self, options):
+        return (
+            options.get("output_format")
+            or self.config.get("output_format")
+            or DefaultParameters.OUTPUT_FORMAT.value
+        )
+
+    def get_hash_function_id(self, options):
+        return (
+            options.get("hash_function_id")
+            or self.config.get("hash_function_id")
+            or DefaultParameters.HASH_FUNCTION_ID.value
+        )
+
+    def get_paranet_ual(self, options):
+        return (
+            options.get("paranet_ual")
+            or self.config.get("paranet_ual")
+            or DefaultParameters.PARANET_UAL.value
+        )
+
+    def get_subject_ual(self, options):
+        return (
+            options.get("subject_ual")
+            or self.config.get("subject_ual")
+            or DefaultParameters.GET_SUBJECT_UAL.value
+        )
+
+    def get_epochs_num(self, options):
+        return options.get("epochs_num") or self.config.get("epochs_num") or None
+
+    def get_immutable(self, options):
+        return (
+            options.get("immutable")
+            or self.config.get("immutable")
+            or DefaultParameters.IMMUTABLE.value
+        )
+
+    def get_token_amount(self, options):
+        return options.get("token_amount") or self.config.get("token_amount") or None
+
+    def get_payer(self, options):
+        return options.get("payer") or self.config.get("payer") or ZERO_ADDRESS
+
+    def get_minimum_number_of_finalization_confirmations(self, options):
+        return (
+            options.get("minimum_number_of_finalization_confirmations")
+            or self.config.get("minimum_number_of_finalization_confirmations")
+            or DefaultParameters.MIN_NUMBER_OF_FINALIZATION_CONFIRMATION.value
+            or None
+        )
+
+    def get_minimum_number_of_node_replications(self, options):
+        return (
+            options.get("minimum_number_of_node_replications")
+            or self.config.get("minimum_number_of_node_replications")
+            or None
+        )
+
+    def get_score_function_id(self, options):
+        environment = (
+            options.get("environment")
+            or self.config.get("environment")
+            or self.manager.blockchain_provider.environment
+            or DefaultParameters.ENVIRONMENT.value
+        )
+        blockchain_name = (
+            options.get("blockchain")
+            or self.config.get("blockchain")
+            or self.manager.blockchain_provider.blockchain_id
+        )
+
+        return DEFAULT_PROXIMITY_SCORE_FUNCTIONS_PAIR_IDS[environment][blockchain_name]
+
+    def get_repository(self, options):
+        return (
+            options.get("repository")
+            or self.config.get("repository")
+            or DefaultParameters.REPOSITORY.value
+        )

dkg/services/node_services/async_node_service.py

@@ -0,0 +1,184 @@
+from dkg.managers.async_manager import AsyncRequestManager
+from dkg.method import Method
+from dkg.constants import OperationStatuses, ErrorType, Status
+from dkg.utils.node_request import NodeRequest
+from dkg.modules.async_module import AsyncModule
+from typing import Dict, Any
+from dkg.types import UAL
+from dkg.dataclasses import NodeResponseDict
+import asyncio
+
+
+class AsyncNodeService(AsyncModule):
+    def __init__(self, manager: AsyncRequestManager):
+        self.manager = manager
+
+    _info = Method(NodeRequest.info)
+    _get_operation_result = Method(NodeRequest.get_operation_result)
+    _finality_status = Method(NodeRequest.finality_status)
+    _ask = Method(NodeRequest.ask)
+    _get_bid_suggestion = Method(NodeRequest.bid_suggestion)
+    _publish = Method(NodeRequest.publish)
+    _get = Method(NodeRequest.get)
+    _query = Method(NodeRequest.query)
+
+    async def info(self) -> NodeResponseDict:
+        return await self._info()
+
+    async def get_operation_result(
+        self,
+        operation_id: str,
+        operation: str,
+        max_retries: int,
+        frequency: int,
+    ) -> Dict[str, Any]:
+        response = {"status": OperationStatuses.PENDING.value}
+
+        retries = 0
+
+        while True:
+            if retries > max_retries:
+                response["data"] = {
+                    "errorType": ErrorType.DKG_CLIENT_ERROR.value,
+                    "errorMessage": "Unable to get results. Max number of retries reached.",
+                }
+                break
+
+            if retries > 0:
+                await asyncio.sleep(frequency)
+
+            retries += 1
+
+            try:
+                result = await self._get_operation_result(
+                    operation=operation,
+                    operation_id=operation_id,
+                )
+                response = {"data": result}
+            except Exception:
+                response = {"data": {"status": Status.NETWORK_ERROR.value}}
+
+            # Check completion conditions
+            if (
+                response["data"].get("status") == OperationStatuses.COMPLETED.value
+                or response["data"].get("status") == OperationStatuses.FAILED.value
+            ):
+                break
+
+        return response["data"]
+
+    async def finality_status(
+        self,
+        ual: UAL,
+        required_confirmations: int,
+        max_number_of_retries: int,
+        frequency: int,
+    ):
+        retries = 0
+        finality = 0
+
+        while finality < required_confirmations and retries <= max_number_of_retries:
+            if retries > max_number_of_retries:
+                raise Exception(
+                    f"Unable to achieve required confirmations. "
+                    f"Max number of retries ({max_number_of_retries}) reached."
+                )
+
+            # Sleep between attempts (except for first try)
+            if retries > 0:
+                await asyncio.sleep(frequency)
+
+            retries += 1
+
+            try:
+                response = await self._finality_status(ual)
+                finality = response.get("finality", 0)
+            except Exception:
+                finality = 0
+
+        return finality
+
+    async def ask(
+        self,
+        ual: UAL,
+        required_confirmations: int,
+        max_number_of_retries: int,
+        frequency: int,
+    ):
+        finality_id = 0
+        retries = 0
+
+        while finality_id < required_confirmations and retries < max_number_of_retries:
+            if retries > max_number_of_retries:
+                raise Exception(
+                    f"Unable to achieve required confirmations. "
+                    f"Max number of retries ({max_number_of_retries}) reached."
+                )
+
+            if retries > 0:
+                await asyncio.sleep(frequency)
+
+            retries += 1
+
+            try:
+                try:
+                    response = await self._ask(
+                        ual=ual, minimumNumberOfNodeReplications=required_confirmations
+                    )
+                except Exception as e:
+                    response = None
+                    print(f"failed: {e}")
+
+                if response is not None:
+                    operation_id = response.json().get("operationId", 0)
+                    if operation_id >= required_confirmations:
+                        finality_id = operation_id
+
+            except Exception as e:
+                finality_id = 0
+                print(f"Retry {retries + 1}/{max_number_of_retries} failed: {e}")
+
+            return finality_id
+
+    async def publish(
+        self,
+        dataset_root,
+        dataset,
+        blockchain_id,
+        hash_function_id,
+        minimum_number_of_node_replications,
+    ):
+        return await self._publish(
+            dataset_root,
+            dataset,
+            blockchain_id,
+            hash_function_id,
+            minimum_number_of_node_replications,
+        )
+
+    async def get(
+        self,
+        ual_with_state,
+        content_type,
+        include_metadata,
+        hash_function_id,
+        paranet_ual,
+        subject_ual,
+    ):
+        return await self._get(
+            ual_with_state,
+            content_type,
+            include_metadata,
+            hash_function_id,
+            paranet_ual,
+            subject_ual,
+        )
+
+    async def query(
+        self,
+        query,
+        query_type,
+        repository,
+        paranet_ual,
+    ):
+        return await self._query(query, query_type, repository, paranet_ual)