dkg 1.1.2__py3-none-any.whl → 8.0.0__py3-none-any.whl

dkg/providers/blockchain.py

@@ -17,13 +17,14 @@
 
 import json
 import os
+from dotenv import load_dotenv
 from collections import namedtuple
 from functools import wraps
 from pathlib import Path
 from typing import Any, Type
 
 import requests
-from dkg.constants import BLOCKCHAINS, DEFAULT_GAS_PRICE_GWEI
+from dkg.constants import BLOCKCHAINS
 from dkg.exceptions import (
     AccountMissing,
     EnvironmentNotSupported,
@@ -32,12 +33,13 @@ from dkg.exceptions import (
 )
 from dkg.types import URI, Address, DataHexStr, Environment, Wei
 from eth_account.signers.local import LocalAccount
+from eth_typing import ABI, ABIFunction
 from web3 import Web3
 from web3.contract import Contract
 from web3.contract.contract import ContractFunction
 from web3.logs import DISCARD
-from web3.middleware import construct_sign_and_send_raw_middleware
-from web3.types import ABI, ABIFunction, TxReceipt
+from web3.middleware import SignAndSendRawMiddlewareBuilder
+from web3.types import TxReceipt
 
 
 class BlockchainProvider:
@@ -48,7 +50,6 @@ class BlockchainProvider:
         environment: Environment,
         blockchain_id: str,
         rpc_uri: URI | None = None,
-        private_key: DataHexStr | None = None,
         gas_price: Wei | None = None,
         verify: bool = True,
     ):
@@ -105,11 +106,9 @@ class BlockchainProvider:
         }
         self._init_contracts()
 
-        if (
-            private_key is not None
-            or (private_key_env := os.environ.get("PRIVATE_KEY", None)) is not None
-        ):
-            self.set_account(private_key or private_key_env)
+        load_dotenv()
+        if private_key := os.environ.get("PRIVATE_KEY"):
+            self.set_account(private_key)
 
     def make_json_rpc_request(self, endpoint: str, args: dict[str, Any] = {}) -> Any:
         web3_method = getattr(self.w3.eth, endpoint)
@@ -181,13 +180,15 @@ class BlockchainProvider:
                     "account."
                 )
 
-            gas_price = self.gas_price or gas_price or self._get_network_gas_price()
-
             options = {
-                "gasPrice": gas_price,
                 "gas": gas_limit or contract_function(**args).estimate_gas(),
             }
 
+            gas_price = self.gas_price or gas_price or self._get_network_gas_price()
+
+            if gas_price is not None:
+                options["gasPrice"] = gas_price
+
             tx_hash = contract_function(**args).transact(options)
             tx_receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
 
@@ -204,8 +205,9 @@ class BlockchainProvider:
 
     def set_account(self, private_key: DataHexStr):
         self.account: LocalAccount = self.w3.eth.account.from_key(private_key)
-        self.w3.middleware_onion.add(
-            construct_sign_and_send_raw_middleware(self.account)
+        self.w3.middleware_onion.inject(
+            SignAndSendRawMiddlewareBuilder.build(private_key),
+            layer=0,
         )
         self.w3.eth.default_account = self.account.address
 
@@ -213,12 +215,6 @@ class BlockchainProvider:
         if self.environment == "development":
             return None
 
-        blockchain_name, _ = self.blockchain_id.split(":")
-
-        default_gas_price = self.w3.to_wei(
-            DEFAULT_GAS_PRICE_GWEI[blockchain_name], "gwei"
-        )
-
         def fetch_gas_price(oracle_url: str) -> Wei | None:
             try:
                 response = requests.get(oracle_url)
@@ -244,7 +240,7 @@ class BlockchainProvider:
                 if gas_price is not None:
                     return gas_price
 
-        return default_gas_price
+        return None
 
     def _init_contracts(self):
         for contract in self.abi.keys():
@@ -262,11 +258,14 @@ class BlockchainProvider:
         ):
             self.contracts[contract] = self.w3.eth.contract(
                 address=(
-                    self.contracts["Hub"].functions.getContractAddress(contract).call()
-                    if not contract.endswith("AssetStorage")
-                    else self.contracts["Hub"]
+                    self.contracts["Hub"]
                     .functions.getAssetStorageAddress(contract)
                     .call()
+                    if contract.endswith("AssetStorage")
+                    or contract.endswith("CollectionStorage")
+                    else self.contracts["Hub"]
+                    .functions.getContractAddress(contract)
+                    .call()
                 ),
                 abi=self.abi[contract],
                 decode_tuples=True,

dkg/providers/node_http.py

@@ -28,15 +28,11 @@ class NodeHTTPProvider:
     def __init__(
         self,
         endpoint_uri: URI | str,
+        api_version: str = "v1",
         auth_token: str | None = None,
-        api_version: str = "v0",
     ):
-        self.endpoint_uri = URI(endpoint_uri)
-        self.auth_token = auth_token
-        self.api_version = api_version
-
-    def get_full_url(self, path: str) -> str:
-        return f"{self.endpoint_uri}/{self.api_version}/{path}"
+        self.url = f"{URI(endpoint_uri)}/{api_version}"
+        self.headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else {}
 
     def make_request(
         self,
@@ -45,16 +41,13 @@ class NodeHTTPProvider:
         params: dict[str, Any] = {},
         data: dict[str, Any] = {},
     ) -> NodeResponseDict:
-        url = self.get_full_url(path)
-        headers = (
-            {"Authorization": f"Bearer {self.auth_token}"} if self.auth_token else {}
-        )
+        url = f"{self.url}/{path}"
 
         try:
             if method == HTTPRequestMethod.GET:
-                response = requests.get(url, params=params, headers=headers)
+                response = requests.get(url, params=params, headers=self.headers)
             elif method == HTTPRequestMethod.POST:
-                response = requests.post(url, json=data, headers=headers)
+                response = requests.post(url, json=data, headers=self.headers)
             else:
                 raise HTTPRequestMethodNotSupported(
                     f"{method.name} method isn't supported"

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_service.py

@@ -0,0 +1,164 @@
+from dkg.manager import DefaultRequestManager
+from dkg.method import Method
+from dkg.module import Module
+import time
+from dkg.utils.decorators import retry
+from dkg.exceptions import (
+    OperationNotFinished,
+)
+from dkg.utils.node_request import (
+    NodeRequest,
+    validate_operation_status,
+)
+
+
+class NodeService(Module):
+    def __init__(self, manager: DefaultRequestManager):
+        self.manager = manager
+
+    _get_operation_result = Method(NodeRequest.get_operation_result)
+    _finality_status = Method(NodeRequest.finality_status)
+    _ask = Method(NodeRequest.ask)
+    _publish = Method(NodeRequest.publish)
+    _get = Method(NodeRequest.get)
+    _query = Method(NodeRequest.query)
+
+    def get_operation_result(
+        self, operation_id: str, operation: str, max_retries: int, frequency: int
+    ):
+        @retry(
+            catch=OperationNotFinished,
+            max_retries=max_retries,
+            base_delay=frequency,
+            backoff=1,
+        )
+        def retry_get_operation_result():
+            operation_result = self._get_operation_result(
+                operation_id=operation_id,
+                operation=operation,
+            )
+            validate_operation_status(operation_result)
+
+            return operation_result
+
+        return retry_get_operation_result()
+
+    def finality_status(
+        self,
+        ual: str,
+        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."
+                )
+
+            if retries > 0:
+                time.sleep(frequency)
+
+            retries += 1
+
+            try:
+                try:
+                    response = self._finality_status(ual=ual)
+                except Exception as e:
+                    response = None
+                    print(f"failed: {e}")
+
+                if response is not None:
+                    finality = response.get("finality", 0)
+                    if finality >= required_confirmations:
+                        break
+
+            except Exception:
+                finality = 0
+
+        return finality
+
+    def ask(self, ual, required_confirmations, max_number_of_retries, frequency):
+        ask = 0
+        retries = 0
+
+        while ask < 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:
+                time.sleep(frequency)
+
+            retries += 1
+
+            try:
+                try:
+                    response = self._ask(
+                        ual=ual, minimumNumberOfNodeReplications=required_confirmations
+                    )
+                except Exception as e:
+                    response = None
+                    print(f"failed: {e}")
+
+                if response is not None:
+                    number_of_confirmations = response.json().get(
+                        "numberOfConfirmations", 0
+                    )
+                    if number_of_confirmations >= required_confirmations:
+                        ask = number_of_confirmations
+
+            except Exception as e:
+                ask = 0
+                print(f"Retry {retries + 1}/{max_number_of_retries} failed: {e}")
+
+            return ask
+
+    def publish(
+        self,
+        dataset_root,
+        dataset,
+        blockchain_id,
+        hash_function_id,
+        minimum_number_of_node_replications,
+    ):
+        return self._publish(
+            dataset_root,
+            dataset,
+            blockchain_id,
+            hash_function_id,
+            minimum_number_of_node_replications,
+        )
+
+    def get(
+        self,
+        ual_with_state,
+        content_type,
+        include_metadata,
+        hash_function_id,
+        paranet_ual,
+        subject_ual,
+    ):
+        return self._get(
+            ual_with_state,
+            content_type,
+            include_metadata,
+            hash_function_id,
+            paranet_ual,
+            subject_ual,
+        )
+
+    def query(
+        self,
+        query,
+        query_type,
+        repository,
+        paranet_ual,
+    ):
+        return self._query(query, query_type, repository, paranet_ual)

dkg/types/__init__.py

@@ -1,6 +1,18 @@
-from .general import AutoStrEnum, AutoStrEnumCapitalize, AutoStrEnumUpperCase # NOQA: F401
-from .blockchain import (ABI, ABIElement, ABIError, ABIEvent,  # NOQA: F401
-                         ABIFunction, ABIParameter, AgreementData, Environment)
+from .general import (
+    AutoStrEnum,  # NOQA: F401
+    AutoStrEnumCapitalize,  # NOQA: F401
+    AutoStrEnumUpperCase,  # NOQA: F401
+)
+from .blockchain import (
+    ABI,  # NOQA: F401
+    ABIElement,  # NOQA: F401
+    ABIError,  # NOQA: F401
+    ABIEvent,  # NOQA: F401
+    ABIFunction,  # NOQA: F401
+    ABIParameter,  # NOQA: F401
+    AgreementData,  # NOQA: F401
+    Environment,  # NOQA: F401
+)
 from .dkg_node import UAL  # NOQA: F401
 from .encoding import BytesLike, DataHexStr, HexStr  # NOQA: F401
 from .evm import Address, ChecksumAddress, Wei  # NOQA: F401

dkg/types/general.py

@@ -17,28 +17,35 @@
 
 from enum import Enum
 
+
 class AutoStrEnum(str, Enum):
     @staticmethod
-    def _generate_next_value_(name: str, start: int, count: int, last_values: list) -> str:
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list
+    ) -> str:
         return name.lower()
-    
+
     def __str__(self):
         return str(self.value)
-    
+
 
 class AutoStrEnumCapitalize(str, Enum):
     @staticmethod
-    def _generate_next_value_(name: str, start: int, count: int, last_values: list) -> str:
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list
+    ) -> str:
         return name.capitalize()
-    
+
     def __str__(self):
         return str(self.value)
 
 
 class AutoStrEnumUpperCase(str, Enum):
     @staticmethod
-    def _generate_next_value_(name: str, start: int, count: int, last_values: list) -> str:
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list
+    ) -> str:
         return name
-    
+
     def __str__(self):
-        return str(self.value)
+        return str(self.value)