dkg 8.0.0a3__py3-none-any.whl → 8.0.2__py3-none-any.whl

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,23 +303,14 @@ class BlockchainRequest:
             "paranetServiceAddresses": list[Address],
         },
     )
-    mint_knowledge_asset = ContractTransaction(
+    submit_knowledge_collection = ContractTransaction(
         contract="Paranet",
-        function="mintKnowledgeAsset",
+        function="submitKnowledgeCollection",
         args={
-            "paranetKAStorageContract": Address,
-            "paranetKATokenId": int,
-            "knowledgeAssetArgs": dict[str, bytes | int | Wei | bool],
-        },
-    )
-    submit_knowledge_asset = ContractTransaction(
-        contract="Paranet",
-        function="submitKnowledgeAsset",
-        args={
-            "paranetKAStorageContract": Address,
-            "paranetKATokenId": int,
-            "knowledgeAssetStorageContract": Address,
-            "knowledgeAssetTokenId": int,
+            "paranetKCStorageContract": Address,
+            "paranetKnowledgeCollectionId": int,
+            "knowledgeCollectionStorageContract": Address,
+            "knowledgeCollectionTokenId": int,
         },
     )
 
@@ -339,9 +334,9 @@ class BlockchainRequest:
         },
     )
 
-    get_updating_knowledge_asset_states = ContractCall(
+    get_updating_knowledge_collection_states = ContractCall(
         contract="ParanetKnowledgeMinersRegistry",
-        function="getUpdatingKnowledgeAssetStates",
+        function="getUpdatingKnowledgeCollectionStates",
         args={
             "miner": Address,
             "paranetId": HexStr,
@@ -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_collection = ContractTransaction(
+        contract="Paranet",
+        function="mintKnowledgeCollection",
+        args={
+            "paranetKCStorageContract": Address,
+            "paranetKCTokenId": 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}"

dkg/utils/node_request.py

@@ -17,11 +17,11 @@
 
 from dataclasses import dataclass, field
 from enum import auto, Enum
-from typing import Any, Type
+from typing import Any, Type, Dict
 
 from dkg.dataclasses import BidSuggestionRange, HTTPRequestMethod
 from dkg.exceptions import OperationFailed, OperationNotFinished
-from dkg.types import AutoStrEnumUpperCase, UAL, Address, DataHexStr, NQuads
+from dkg.types import AutoStrEnumUpperCase, UAL, Address, DataHexStr
 
 
 @dataclass
@@ -52,32 +52,55 @@ class NodeRequest:
         path="{operation}/{operation_id}",
     )
 
-    local_store = NodeCall(
-        method=HTTPRequestMethod.POST,
-        path="local-store",
-        data=list[dict[str, str | Address | NQuads]],
-    )
     publish = NodeCall(
         method=HTTPRequestMethod.POST,
         path="publish",
         data={
-            "assertionId": str,
-            "assertion": NQuads,
+            "datasetRoot": str,
+            "dataset": dict[str, list[str]],
             "blockchain": str,
-            "contract": Address,
-            "tokenId": int,
             "hashFunctionId": int,
+            "minimumNumberOfNodeReplications": int,
         },
     )
+
+    ask = NodeCall(
+        method=HTTPRequestMethod.POST,
+        path="ask",
+        params={
+            "ual": UAL,
+            "minimumNumberOfNodeReplications": int,
+        },
+    )
+
+    finality_status = NodeCall(
+        method=HTTPRequestMethod.GET,
+        path="finality",
+        params={"ual": UAL},
+    )
+
     get = NodeCall(
         method=HTTPRequestMethod.POST,
         path="get",
-        data={"id": UAL, "state": str, "hashFunctionId": int},
+        data={
+            "id": UAL,
+            "contentType": str,
+            "includeMetadata": bool,
+            "hashFunctionId": int,
+            "paranetUAL": UAL,
+            "subjectUAL": UAL,
+        },
     )
+
     query = NodeCall(
         method=HTTPRequestMethod.POST,
-        path="query",
-        data={"query": str, "type": str, "repository": str},
+        path="direct-query",
+        data={
+            "query": str,
+            "type": str,
+            "repository": str | None,
+            "paranetUAL": str | None,
+        },
     )
 
 
@@ -169,3 +192,26 @@ def validate_operation_status(operation_result: dict[str, Any]) -> None:
             )
         case _:
             raise OperationNotFinished("Operation isn't finished")
+
+
+def get_operation_status_object(
+    operation_result: Dict[str, Any], operation_id: str
+) -> Dict[str, Any]:
+    """
+    Creates an operation status object from operation result and ID.
+
+    Args:
+        operation_result: Dictionary containing operation result data
+        operation_id: The ID of the operation
+
+    Returns:
+        Dictionary containing operation status information
+    """
+    # Check if error_type exists in operation_result.data
+    operation_data = (
+        {"status": operation_result.get("status"), **operation_result.get("data")}
+        if operation_result.get("data", {}).get("errorType")
+        else {"status": operation_result.get("status")}
+    )
+
+    return {"operationId": operation_id, **operation_data}

dkg/utils/rdf.py

@@ -17,7 +17,11 @@
 
 from typing import Literal
 
-from dkg.constants import PRIVATE_ASSERTION_PREDICATE
+from dkg.constants import (
+    PRIVATE_ASSERTION_PREDICATE,
+    DEFAULT_RDF_FORMAT,
+    DEFAULT_CANON_ALGORITHM,
+)
 from dkg.exceptions import DatasetInputFormatNotSupported, InvalidDataset
 from dkg.types import JSONLD, HexStr, NQuads
 from dkg.utils.merkle import MerkleTree, hash_assertion_with_indexes
@@ -27,10 +31,12 @@ from pyld import jsonld
 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": "URDNA2015",
-        "format": "application/n-quads",
+        "algorithm": algorithm,
+        "format": output_format,
     }
 
     match input_format.lower():