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

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,10 +79,34 @@ 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",
-        args={"owner": Address, "spender": Address}
+        args={"owner": Address, "spender": Address},
     )
     increase_allowance = ContractTransaction(
         contract="Token",
@@ -83,48 +119,16 @@ 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",
         args={"tokenId": int},
     )
-    update_asset_state = ContractTransaction(
-        contract="ContentAsset",
-        function="updateAssetState",
-        args={
-            "tokenId": int,
-            "assertionId": bytes | HexStr,
-            "size": int,
-            "triplesNumber": int,
-            "chunksNumber": int,
-            "updateTokenAmount": int,
-        },
-    )
-    cancel_asset_state_update = ContractTransaction(
-        contract="ContentAsset",
-        function="cancelAssetStateUpdate",
-        args={"tokenId": int},
-    )
     extend_asset_storing_period = ContractTransaction(
         contract="ContentAsset",
         function="extendAssetStoringPeriod",
         args={"tokenId": int, "epochsNumber": int, "tokenAmount": int},
     )
-    increase_asset_token_amount = ContractTransaction(
-        contract="ContentAsset",
-        function="increaseAssetTokenAmount",
-        args={"tokenId": int, "tokenAmount": int},
-    )
-    increase_asset_update_token_amount = ContractTransaction(
-        contract="ContentAsset",
-        function="increaseAssetUpdateTokenAmount",
-        args={"tokenId": int, "tokenAmount": int},
-    )
 
     transfer_asset = ContractTransaction(
         contract="ContentAssetStorage",
@@ -136,11 +140,6 @@ class BlockchainRequest:
         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",
@@ -158,18 +157,19 @@ class BlockchainRequest:
         args={"tokenId": int},
     )
 
-    get_service_agreement_data = ContractCall(
-        contract="ServiceAgreementStorageProxy",
-        function="getAgreementData",
-        args={"agreementId": bytes | HexStr},
-    )
-
     get_assertion_size = ContractCall(
         contract="AssertionStorage",
         function="getAssertionSize",
         args={"assertionId": bytes | HexStr},
     )
 
+    # Identity
+    get_identity_id = ContractCall(
+        contract="IdentityStorage",
+        function="getIdentityId",
+        args={"operational": Address},
+    )
+
     # Paranets
     register_paranet = ContractTransaction(
         contract="Paranet",
@@ -179,8 +179,121 @@ class BlockchainRequest:
             "paranetKATokenId": int,
             "paranetName": str,
             "paranetDescription": str,
+            "nodesAccessPolicy": int,
+            "minersAccessPolicy": int,
+        },
+    )
+
+    add_paranet_curated_nodes = ContractTransaction(
+        contract="Paranet",
+        function="addParanetCuratedNodes",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "identityIds": list[int],
+        },
+    )
+
+    remove_paranet_curated_nodes = ContractTransaction(
+        contract="Paranet",
+        function="removeParanetCuratedNodes",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "identityIds": list[int],
+        },
+    )
+
+    request_paranet_curated_node_access = ContractTransaction(
+        contract="Paranet",
+        function="requestParanetCuratedNodeAccess",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+        },
+    )
+
+    approve_curated_node = ContractTransaction(
+        contract="Paranet",
+        function="approveCuratedNode",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "identityId": int,
+        },
+    )
+
+    reject_curated_node = ContractTransaction(
+        contract="Paranet",
+        function="rejectCuratedNode",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "identityId": int,
+        },
+    )
+
+    get_curated_nodes = ContractCall(
+        contract="ParanetsRegistry",
+        function="getCuratedNodes",
+        args={"paranetId": HexStr},
+    )
+
+    add_paranet_curated_miners = ContractTransaction(
+        contract="Paranet",
+        function="addParanetCuratedMiners",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "minerAddresses": list[Address],
+        },
+    )
+
+    remove_paranet_curated_miners = ContractTransaction(
+        contract="Paranet",
+        function="removeParanetCuratedMiners",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "minerAddresses": list[Address],
+        },
+    )
+
+    request_paranet_curated_miner_access = ContractTransaction(
+        contract="Paranet",
+        function="requestParanetCuratedMinerAccess",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+        },
+    )
+
+    approve_curated_miner = ContractTransaction(
+        contract="Paranet",
+        function="approveCuratedMiner",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "minerAddress": Address,
+        },
+    )
+
+    reject_curated_miner = ContractTransaction(
+        contract="Paranet",
+        function="rejectCuratedMiner",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "minerAddress": Address,
         },
     )
+
+    get_knowledge_miners = ContractCall(
+        contract="ParanetsRegistry",
+        function="getKnowledgeMiners",
+        args={"paranetId": HexStr},
+    )
+
     add_paranet_services = ContractTransaction(
         contract="Paranet",
         function="addParanetServices",
@@ -201,15 +314,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",
@@ -249,16 +353,6 @@ class BlockchainRequest:
             "paranetId": HexStr,
         },
     )
-    process_updated_knowledge_asset_states_metadata = ContractTransaction(
-        contract="Paranet",
-        function="processUpdatedKnowledgeAssetStatesMetadata",
-        args={
-            "paranetKAStorageContract": Address,
-            "paranetKATokenId": int,
-            "start": int,
-            "end": int,
-        },
-    )
 
     is_knowledge_miner_registered = ContractCall(
         contract="ParanetsRegistry",
@@ -307,3 +401,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,236 @@
+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
+
+
+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)

dkg/utils/merkle.py

@@ -32,7 +32,7 @@ def solidity_keccak256(data: HexStr) -> HexStr:
         [data],
     )
 
-    return bytes_hash.hex()
+    return bytes_hash.to_0x_hex()
 
 
 def hash_assertion_with_indexes(

dkg/utils/node_request.py

@@ -21,7 +21,7 @@ from typing import Any, Type
 
 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,44 +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,
         },
     )
-    update = NodeCall(
+
+    ask = NodeCall(
         method=HTTPRequestMethod.POST,
-        path="update",
-        data={
-            "assertionId": str,
-            "assertion": NQuads,
-            "blockchain": str,
-            "contract": Address,
-            "tokenId": int,
-            "hashFunctionId": int,
+        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},
+        data={
+            "query": str,
+            "type": str,
+            "repository": str | None,
+            "paranet_ual": str | None,
+        },
     )
 
 
@@ -115,19 +126,9 @@ class PublishOperationStatus(Enum):
     PUBLISH_END = auto()
 
 
-class UpdateOperationStatus(AutoStrEnumUpperCase):
-    UPDATE_START = auto()
-    UPDATE_INIT_START = auto()
-    UPDATE_INIT_END = auto()
-    UPDATE_REPLICATE_START = auto()
-    UPDATE_REPLICATE_END = auto()
-    VALIDATING_UPDATE_ASSERTION_REMOTE_START = auto()
-    VALIDATING_UPDATE_ASSERTION_REMOTE_END = auto()
-    UPDATE_END = auto()
-
-
 class StoreTypes(AutoStrEnumUpperCase):
     TRIPLE = auto()
+    TRIPLE_PARANET = auto()
     PENDING = auto()
 
 
@@ -171,7 +172,6 @@ class OperationStatus(AutoStrEnumUpperCase):
     DIAL_PROTOCOL_END = auto()
     LOCAL_STORE = LocalStoreOperationStatus
     PUBLISH = PublishOperationStatus
-    UPDATE = UpdateOperationStatus
     GET = GetOperationStatus
     QUERY = QueryOperationStatus