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

dkg/services/node_services/node_service.py

@@ -0,0 +1,167 @@
+from dkg.managers.manager import DefaultRequestManager
+from dkg.method import Method
+from dkg.modules.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):
+        confirmations_count = 0
+        retries = 0
+
+        while (
+            confirmations_count < 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:
+                        confirmations_count = number_of_confirmations
+
+            except Exception as e:
+                confirmations_count = 0
+                print(f"Retry {retries + 1}/{max_number_of_retries} failed: {e}")
+
+            return confirmations_count
+
+    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,17 +1,17 @@
 from .general import (
-    AutoStrEnum,
-    AutoStrEnumCapitalize,
-    AutoStrEnumUpperCase,
-)  # NOQA: F401
+    AutoStrEnum,  # NOQA: F401
+    AutoStrEnumCapitalize,  # NOQA: F401
+    AutoStrEnumUpperCase,  # NOQA: F401
+)
 from .blockchain import (
-    ABI,
-    ABIElement,
-    ABIError,
+    ABI,  # NOQA: F401
+    ABIElement,  # NOQA: F401
+    ABIError,  # NOQA: F401
     ABIEvent,  # NOQA: F401
-    ABIFunction,
-    ABIParameter,
-    AgreementData,
-    Environment,
+    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

dkg/utils/blockchain_request.py

@@ -16,7 +16,7 @@
 # under the License.
 
 from dataclasses import dataclass, field
-from typing import Type
+from typing import Type, Dict, Any
 
 from dkg.dataclasses import ParanetIncentivizationType
 from dkg.types import Address, HexStr, Wei
@@ -52,6 +52,18 @@ class ContractCall(ContractInteraction):
     pass
 
 
+@dataclass
+class KnowledgeCollectionResult:
+    knowledge_collection_id: int
+    receipt: Dict[str, Any]
+
+
+@dataclass
+class AllowanceResult:
+    allowance_increased: bool
+    allowance_gap: int
+
+
 class BlockchainRequest:
     chain_id = JSONRPCRequest("chain_id")
     get_block = JSONRPCRequest("get_block", args={"block_identifier": str | int})
@@ -67,6 +79,30 @@ class BlockchainRequest:
         args={"assetStorageName": str},
     )
 
+    key_is_operational_wallet = ContractCall(
+        contract="IdentityStorage",
+        function="keyHasPurpose",
+        args={"identityId": int, "_key": Address, "_purpose": int},
+    )
+
+    time_until_next_epoch = ContractCall(
+        contract="Chronos",
+        function="timeUntilNextEpoch",
+        args={},
+    )
+
+    epoch_length = ContractCall(
+        contract="Chronos",
+        function="epochLength",
+        args={},
+    )
+
+    get_stake_weighted_average_ask = ContractCall(
+        contract="AskStorage",
+        function="getStakeWeightedAverageAsk",
+        args={},
+    )
+
     allowance = ContractCall(
         contract="Token",
         function="allowance",
@@ -83,11 +119,6 @@ class BlockchainRequest:
         args={"spender": Address, "subtractedValue": Wei},
     )
 
-    create_asset = ContractTransaction(
-        contract="ContentAsset",
-        function="createAsset",
-        args={"args": dict[str, bytes | int | Wei | bool]},
-    )
     burn_asset = ContractTransaction(
         contract="ContentAsset",
         function="burnAsset",
@@ -98,27 +129,12 @@ class BlockchainRequest:
         function="extendAssetStoringPeriod",
         args={"tokenId": int, "epochsNumber": int, "tokenAmount": int},
     )
-    increase_asset_token_amount = ContractTransaction(
-        contract="ContentAsset",
-        function="increaseAssetTokenAmount",
-        args={"tokenId": int, "tokenAmount": int},
-    )
 
     transfer_asset = ContractTransaction(
         contract="ContentAssetStorage",
         function="transferFrom",
         args={"from": Address, "to": Address, "tokenId": int},
     )
-    get_assertion_ids = ContractCall(
-        contract="ContentAssetStorage",
-        function="getAssertionIds",
-        args={"tokenId": int},
-    )
-    get_assertion_id_by_index = ContractCall(
-        contract="ContentAssetStorage",
-        function="getAssertionIdByIndex",
-        args={"tokenId": int, "index": int},
-    )
     get_latest_assertion_id = ContractCall(
         contract="ContentAssetStorage",
         function="getLatestAssertionId",
@@ -130,18 +146,6 @@ class BlockchainRequest:
         args={"tokenId": int},
     )
 
-    get_unfinalized_state = ContractCall(
-        contract="UnfinalizedStateStorage",
-        function="getUnfinalizedState",
-        args={"tokenId": int},
-    )
-
-    get_service_agreement_data = ContractCall(
-        contract="ServiceAgreementStorageProxy",
-        function="getAgreementData",
-        args={"agreementId": bytes | HexStr},
-    )
-
     get_assertion_size = ContractCall(
         contract="AssertionStorage",
         function="getAssertionSize",
@@ -299,15 +303,6 @@ class BlockchainRequest:
             "paranetServiceAddresses": list[Address],
         },
     )
-    mint_knowledge_asset = ContractTransaction(
-        contract="Paranet",
-        function="mintKnowledgeAsset",
-        args={
-            "paranetKAStorageContract": Address,
-            "paranetKATokenId": int,
-            "knowledgeAssetArgs": dict[str, bytes | int | Wei | bool],
-        },
-    )
     submit_knowledge_asset = ContractTransaction(
         contract="Paranet",
         function="submitKnowledgeAsset",
@@ -395,3 +390,34 @@ class BlockchainRequest:
         function="claimIncentivizationProposalVoterReward",
         args={},
     )
+
+    create_knowledge_collection = ContractTransaction(
+        contract="KnowledgeCollection",
+        function="createKnowledgeCollection",
+        args={
+            "publishOperationId": str,
+            "merkleRoot": bytes,
+            "knowledgeAssetsAmount": int,
+            "byteSize": int,
+            "epochs": int,
+            "tokenAmount": int,
+            "isImmutable": bool,
+            "paymaster": Address,
+            "publisherNodeIdentityId": int,
+            "publisherNodeR": bytes,
+            "publisherNodeVS": bytes,
+            "identityIds": list[int],
+            "r": list[bytes],
+            "vs": list[bytes],
+        },
+    )
+
+    mint_knowledge_asset = ContractTransaction(
+        contract="Paranet",
+        function="mintKnowledgeAsset",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "knowledgeAssetArgs": dict,
+        },
+    )

dkg/utils/knowledge_asset_tools.py

@@ -0,0 +1,5 @@
+from uuid import uuid4
+
+
+def generate_named_node():
+    return f"uuid:{uuid4()}"

dkg/utils/knowledge_collection_tools.py

@@ -0,0 +1,248 @@
+from typing import Literal
+from dkg.constants import CHUNK_BYTE_SIZE
+from dkg.exceptions import DatasetInputFormatNotSupported, InvalidDataset
+from dkg.types import JSONLD, NQuads
+from pyld import jsonld
+from dkg.constants import DEFAULT_RDF_FORMAT, DEFAULT_CANON_ALGORITHM
+from rdflib import Graph, BNode, URIRef, Literal as RDFLiteral
+from uuid import uuid4
+from web3 import Web3
+import math
+import hashlib
+from eth_abi.packed import encode_packed
+
+
+def normalize_dataset(
+    dataset: JSONLD | NQuads,
+    input_format: Literal["JSON-LD", "N-Quads"] = "JSON-LD",
+    output_format=DEFAULT_RDF_FORMAT,
+    algorithm=DEFAULT_CANON_ALGORITHM,
+) -> NQuads:
+    normalization_options = {
+        "algorithm": algorithm,
+        "format": output_format,
+    }
+
+    match input_format.lower():
+        case "json-ld" | "jsonld":
+            pass
+        case "n-quads" | "nquads":
+            normalization_options["inputFormat"] = "application/n-quads"
+        case _:
+            raise DatasetInputFormatNotSupported(
+                f"Dataset input format isn't supported: {input_format}. "
+                "Supported formats: JSON-LD / N-Quads."
+            )
+
+    n_quads = jsonld.normalize(dataset, normalization_options)
+    assertion = [quad for quad in n_quads.split("\n") if quad]
+
+    if not assertion:
+        raise InvalidDataset("Invalid dataset, no quads were extracted.")
+
+    return assertion
+
+
+def is_empty_dict(dictionary: dict):
+    return len(dictionary.keys()) == 0 and isinstance(dictionary, dict)
+
+
+def format_dataset(
+    content: dict,
+    input_format: Literal["JSON-LD", "N-Quads"] = "JSON-LD",
+    output_format=DEFAULT_RDF_FORMAT,
+    algorithm=DEFAULT_CANON_ALGORITHM,
+):
+    private_assertion = None
+    if content.get("private") and not is_empty_dict(content.get("private")):
+        private_assertion = normalize_dataset(
+            content.get("private"), input_format, output_format, algorithm
+        )
+    elif not content.get("public"):
+        content = {"public": content}
+
+    public_assertion = []
+    if content.get("public"):
+        public_assertion = normalize_dataset(
+            content.get("public"), input_format, output_format, algorithm
+        )
+
+    if (
+        public_assertion
+        and len(public_assertion) == 0
+        and private_assertion
+        and len(private_assertion) == 0
+    ):
+        raise ValueError("File format is corrupted, no n-quads are extracted.")
+
+    dataset = {"public": public_assertion}
+    if private_assertion:
+        dataset["private"] = private_assertion
+
+    return dataset
+
+
+def split_into_chunks(quads, chunk_size_bytes=32):
+    # Concatenate the quads with newline characters
+    concatenated_quads = "\n".join(quads)
+
+    # Encode the concatenated string to bytes
+    encoded_bytes = concatenated_quads.encode("utf-8")
+
+    # Split the encoded bytes into chunks
+    chunks = []
+    start = 0
+
+    while start < len(encoded_bytes):
+        end = min(start + chunk_size_bytes, len(encoded_bytes))
+        chunk = encoded_bytes[start:end]
+        chunks.append(chunk.decode("utf-8"))  # Decode bytes back to string
+        start = end
+
+    return chunks
+
+
+def calculate_merkle_root(quads: list[str], chunk_size_bytes: int = CHUNK_BYTE_SIZE):
+    chunks = split_into_chunks(quads, chunk_size_bytes)
+
+    # Create leaves using solidityKeccak256 equivalent
+    leaves = [
+        bytes.fromhex(Web3.solidity_keccak(["string", "uint256"], [chunk, index]).hex())
+        for index, chunk in enumerate(chunks)
+    ]
+
+    while len(leaves) > 1:
+        next_level = []
+
+        for i in range(0, len(leaves), 2):
+            left = leaves[i]
+
+            if i + 1 >= len(leaves):
+                next_level.append(left)
+                break
+
+            right = leaves[i + 1]
+
+            # Combine and sort the leaves
+            combined = [left, right]
+            combined.sort()
+
+            # Calculate the hash of the combined leaves
+            hash_value = Web3.keccak(b"".join(combined))
+            next_level.append(hash_value)
+
+        leaves = next_level
+
+    return f"0x{leaves[0].hex()}"
+
+
+def generate_missing_ids_for_blank_nodes(nquads_list: list[str] | None) -> list[str]:
+    if not nquads_list:
+        return [""]
+
+    generated_ids = {}
+
+    def replace_blank_node(term):
+        # Handle blank nodes
+        if isinstance(term, BNode):
+            if str(term) not in generated_ids:
+                generated_ids[str(term)] = URIRef(f"uuid:{str(uuid4())}")
+            return generated_ids[str(term)]
+
+        return term  # Return IRIs or Literals unchanged
+
+    # Create a temporary graph for parsing individual quads
+    result = []
+
+    # Process each N-Quad string individually to maintain order
+    for nquad in nquads_list:
+        if not nquad.strip():
+            continue
+
+        # Parse single N-Quad
+        g = Graph()
+        g.parse(data=nquad, format="nquads")
+
+        # Get the triple and replace blank nodes
+        for s, p, o in g:
+            updated_quad = (
+                replace_blank_node(s),
+                replace_blank_node(p),
+                replace_blank_node(o),
+            )
+            # Format as N-Quad string
+            result.append(
+                f"{updated_quad[0].n3()} {updated_quad[1].n3()} {updated_quad[2].n3()} ."
+            )
+
+    return result
+
+
+def group_nquads_by_subject(nquads_list: list[str], sort: bool = False):
+    grouped = {}
+
+    # Process each quad in original order
+    for nquad in nquads_list:
+        if not nquad.strip():  # Skip empty lines
+            continue
+
+        # Parse single quad
+        g = Graph()
+        g.parse(data=nquad, format="nquads")
+        quad = next(iter(g))
+        subject, predicate, obj = quad
+
+        # Get subject key
+        subject_key = (
+            f"<<<{subject.subject}> <{subject.predicate}> <{subject.object}>>"
+            if hasattr(subject, "subject")
+            else f"<{subject}>"
+        )
+
+        # Initialize group if needed
+        if subject_key not in grouped:
+            grouped[subject_key] = []
+
+        # Format object
+        object_value = f'"{obj}"' if isinstance(obj, RDFLiteral) else f"<{obj}>"
+
+        # Add quad to group
+        quad_string = f"{subject_key} <{predicate}> {object_value} ."
+        grouped[subject_key].append(quad_string)
+
+    # Return grouped quads (sorted if requested)
+    grouped_items = sorted(grouped.items()) if sort else grouped.items()
+    return [quads for _, quads in grouped_items]
+
+
+def calculate_number_of_chunks(quads, chunk_size_bytes=CHUNK_BYTE_SIZE):
+    # Concatenate the quads with newline characters
+    concatenated_quads = "\n".join(quads)
+
+    total_size_bytes = len(concatenated_quads.encode("utf-8"))
+
+    # Calculate and return the number of chunks
+    return math.ceil(total_size_bytes / chunk_size_bytes)
+
+
+def count_distinct_subjects(nquads_list: list[str]) -> int:
+    # Create a new RDF graph
+    graph = Graph()
+
+    # Parse the joined N-Quads
+    graph.parse(data="\n".join(nquads_list), format="nquads")
+
+    # Extract unique subjects using set comprehension
+    subjects = {str(quad[0]) for quad in graph}
+
+    return len(subjects)
+
+
+def solidity_packed_sha256(types: list[str], values: list) -> str:
+    # Encode the values using eth_abi's encode_packed
+    packed_data = encode_packed(types, values)
+
+    # Calculate SHA256
+    sha256_hash = hashlib.sha256(packed_data).hexdigest()
+
+    return f"0x{sha256_hash}"