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

dkg/asset.py

@@ -16,62 +16,57 @@
 # under the License.
 
 import json
-import math
-import re
-from typing import Literal, Type
-
+import hashlib
+from typing import Literal, Dict, Optional, Any
 from pyld import jsonld
 from web3 import Web3
-from web3.constants import ADDRESS_ZERO, HASH_ZERO
-from web3.exceptions import ContractLogicError
+from web3.constants import ADDRESS_ZERO
 from web3.types import TxReceipt
+from itertools import chain
+from eth_abi.packed import encode_packed
+from eth_account.messages import encode_defunct
+from eth_account import Account
+from hexbytes import HexBytes
 
 from dkg.constants import (
-    DEFAULT_HASH_FUNCTION_ID,
-    DEFAULT_PROXIMITY_SCORE_FUNCTIONS_PAIR_IDS,
     PRIVATE_ASSERTION_PREDICATE,
-    PRIVATE_CURRENT_REPOSITORY,
-    PRIVATE_HISTORICAL_REPOSITORY,
+    PRIVATE_RESOURCE_PREDICATE,
+    PRIVATE_HASH_SUBJECT_PREFIX,
+    CHUNK_BYTE_SIZE,
+    MAX_FILE_SIZE,
+    DEFAULT_RDF_FORMAT,
+    Operations,
+    OutputTypes,
+    DefaultParameters,
+    ZERO_ADDRESS,
 )
 from dkg.dataclasses import (
     BidSuggestionRange,
-    KnowledgeAssetContentVisibility,
-    KnowledgeAssetEnumStates,
     NodeResponseDict,
 )
-from dkg.exceptions import (
-    DatasetOutputFormatNotSupported,
-    InvalidKnowledgeAsset,
-    InvalidStateOption,
-    InvalidTokenAmount,
-    MissingKnowledgeAssetState,
-    OperationNotFinished,
-)
 from dkg.manager import DefaultRequestManager
 from dkg.method import Method
 from dkg.module import Module
-from dkg.types import JSONLD, UAL, Address, AgreementData, HexStr, Wei
-from dkg.utils.blockchain_request import BlockchainRequest
-from dkg.utils.decorators import retry
-from dkg.utils.merkle import MerkleTree, hash_assertion_with_indexes
-from dkg.utils.metadata import (
-    generate_agreement_id,
-    generate_assertion_metadata,
-    generate_keyword,
+from dkg.types import JSONLD, UAL, Address, HexStr, Wei
+from dkg.utils.blockchain_request import (
+    BlockchainRequest,
+    KnowledgeCollectionResult,
+    AllowanceResult,
 )
 from dkg.utils.node_request import (
     NodeRequest,
     OperationStatus,
-    StoreTypes,
-    validate_operation_status,
 )
-from dkg.utils.rdf import format_content, normalize_dataset
 from dkg.utils.ual import format_ual, parse_ual
+import dkg.utils.knowledge_collection_tools as kc_tools
+import dkg.utils.knowledge_asset_tools as ka_tools
 
 
 class KnowledgeAsset(Module):
-    def __init__(self, manager: DefaultRequestManager):
+    def __init__(self, manager: DefaultRequestManager, input_service, node_service):
         self.manager = manager
+        self.input_service = input_service
+        self.node_service = node_service
 
     _owner = Method(BlockchainRequest.owner_of)
 
@@ -140,226 +135,490 @@ class KnowledgeAsset(Module):
 
     _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)
+    _chain_id = Method(BlockchainRequest.chain_id)
+    _get_asset_storage_address = Method(BlockchainRequest.get_asset_storage_address)
+    _mint_paranet_knowledge_asset = Method(BlockchainRequest.mint_knowledge_asset)
+    _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_bid_suggestion = Method(NodeRequest.bid_suggestion)
+    _create_knowledge_collection = Method(BlockchainRequest.create_knowledge_collection)
+    _mint_knowledge_asset = Method(BlockchainRequest.mint_knowledge_asset)
+
+    def get_operation_status_object(
+        self, 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}
 
-    def get_current_allowance(self, spender: Address | None = None) -> Wei:
-        if spender is None:
-            spender = self._get_contract_address("ServiceAgreementV1")
+    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")
 
-        return int(
-            self._get_current_allowance(
-                self.manager.blockchain_provider.account.address, spender
+        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
             )
-        )
 
-    _increase_allowance = Method(BlockchainRequest.increase_allowance)
-    _decrease_allowance = Method(BlockchainRequest.decrease_allowance)
+        return AllowanceResult(allowance_increased=False, allowance_gap=allowance_gap)
 
-    def set_allowance(self, token_amount: Wei, spender: Address | None = None) -> Wei:
-        if spender is None:
-            spender = self._get_contract_address("ServiceAgreementV1")
+    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
 
-        current_allowance = self.get_current_allowance(spender)
+        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()),
+                )
 
-        allowance_difference = token_amount - current_allowance
+            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
+            )
 
-        if allowance_difference > 0:
-            self._increase_allowance(spender, allowance_difference)
-        elif allowance_difference < 0:
-            self._decrease_allowance(spender, -allowance_difference)
+            return KnowledgeCollectionResult(
+                knowledge_collection_id=collection_id, receipt=receipt
+            )
 
-        return allowance_difference
+        except Exception as e:
+            if allowance_increased:
+                self.decrease_knowledge_collection_allowance(allowance_gap)
+            raise e
 
-    def increase_allowance(
-        self, token_amount: Wei, spender: Address | None = None
-    ) -> Wei:
-        if spender is None:
-            spender = self._get_contract_address("ServiceAgreementV1")
+    def process_content(self, content: str) -> list:
+        return [line.strip() for line in content.split("\n") if line.strip() != ""]
 
-        self._increase_allowance(spender, token_amount)
+    def solidity_packed_sha256(self, types: list[str], values: list) -> str:
+        # Encode the values using eth_abi's encode_packed
+        packed_data = encode_packed(types, values)
 
-        return token_amount
+        # Calculate SHA256
+        sha256_hash = hashlib.sha256(packed_data).hexdigest()
 
-    def decrease_allowance(
-        self, token_amount: Wei, spender: Address | None = None
-    ) -> Wei:
-        if spender is None:
-            spender = self._get_contract_address("ServiceAgreementV1")
+        return f"0x{sha256_hash}"
 
-        current_allowance = self.get_current_allowance(spender)
-        subtracted_value = min(token_amount, current_allowance)
+    def insert_triple_sorted(self, triples_list: list, new_triple: str) -> int:
+        # Assuming triples_list is already sorted
+        left = 0
+        right = len(triples_list)
 
-        self._decrease_allowance(spender, subtracted_value)
+        while left < right:
+            mid = (left + right) // 2
+            if triples_list[mid] < new_triple:
+                left = mid + 1
+            else:
+                right = mid
+
+        # Insert the new triple at the correct position
+        triples_list.insert(left, new_triple)
+        return left
+
+    def get_operation_status_dict(self, operation_result, operation_id):
+        # Check if data exists and has errorType
+        operation_data = (
+            {"status": operation_result.get("status"), **operation_result.get("data")}
+            if operation_result.get("data")
+            and operation_result.get("data", {}).get("errorType")
+            else {"status": operation_result.get("status")}
+        )
 
-        return subtracted_value
+        return {"operationId": operation_id, **operation_data}
 
-    _chain_id = Method(BlockchainRequest.chain_id)
+    def get_message_signer_address(self, dataset_root: str, signature: dict):
+        message = encode_defunct(HexBytes(dataset_root))
+        r, s, v = signature.get("r"), signature.get("s"), signature.get("v")
+        r = r[2:] if r.startswith("0x") else r
+        s = s[2:] if s.startswith("0x") else s
 
-    _get_asset_storage_address = Method(BlockchainRequest.get_asset_storage_address)
-    _create = Method(BlockchainRequest.create_asset)
-    _mint_paranet_knowledge_asset = Method(BlockchainRequest.mint_knowledge_asset)
+        sig = "0x" + r + s + hex(v)[2:].zfill(2)
 
-    _get_bid_suggestion = Method(NodeRequest.bid_suggestion)
-    _local_store = Method(NodeRequest.local_store)
-    _publish = Method(NodeRequest.publish)
+        return Account.recover_message(message, signature=sig)
 
     def create(
         self,
         content: dict[Literal["public", "private"], JSONLD],
-        epochs_number: int,
-        token_amount: Wei | None = None,
-        immutable: bool = False,
-        content_type: Literal["JSON-LD", "N-Quads"] = "JSON-LD",
-        paranet_ual: UAL | None = None,
+        options: dict = {},
     ) -> dict[str, UAL | HexStr | dict[str, dict[str, str] | TxReceipt]]:
+        arguments = self.input_service.get_asset_create_arguments(options)
+
+        max_number_of_retries = arguments.get("max_number_of_retries")
+        frequency = arguments.get("frequency")
+        epochs_num = arguments.get("epochs_num")
+        hash_function_id = arguments.get("hash_function_id")
+        immutable = arguments.get("immutable")
+        token_amount = arguments.get("token_amount")
+        payer = arguments.get("payer")
+        minimum_number_of_finalization_confirmations = arguments.get(
+            "minimum_number_of_finalization_confirmations"
+        )
+        minimum_number_of_node_replications = arguments.get(
+            "minimum_number_of_node_replications"
+        )
         blockchain_id = self.manager.blockchain_provider.blockchain_id
-        assertions = format_content(content, content_type)
 
-        public_assertion_id = MerkleTree(
-            hash_assertion_with_indexes(assertions["public"]),
-            sort_pairs=True,
-        ).root
-        public_assertion_metadata = generate_assertion_metadata(assertions["public"])
+        dataset = {}
+        public_content = dataset.get("public")
+        private_content = dataset.get("private")
+        if isinstance(content, str):
+            dataset["public"] = self.process_content(content)
+        elif isinstance(public_content, str) or (
+            not public_content and private_content and isinstance(private_content, str)
+        ):
+            if public_content:
+                dataset["public"] = self.process_content(public_content)
+            else:
+                dataset["public"] = []
 
-        content_asset_storage_address = self._get_asset_storage_address(
-            "ContentAssetStorage"
+            if private_content and isinstance(private_content, str):
+                dataset["private"] = self.process_content(private_content)
+        else:
+            dataset = kc_tools.format_dataset(content)
+
+        public_triples_grouped = []
+
+        dataset["public"] = kc_tools.generate_missing_ids_for_blank_nodes(
+            dataset.get("public")
         )
 
-        if token_amount is None:
-            token_amount = int(
-                self._get_bid_suggestion(
-                    blockchain_id,
-                    epochs_number,
-                    public_assertion_metadata["size"],
-                    content_asset_storage_address,
-                    public_assertion_id,
-                    DEFAULT_HASH_FUNCTION_ID,
-                    token_amount or BidSuggestionRange.LOW,
-                )["bidSuggestion"]
+        if dataset.get("private") and len(dataset.get("private")):
+            dataset["private"] = kc_tools.generate_missing_ids_for_blank_nodes(
+                dataset.get("private")
             )
 
-        current_allowance = self.get_current_allowance()
-        if is_allowance_increased := current_allowance < token_amount:
-            self.increase_allowance(token_amount)
+            # Group private triples by subject and flatten
+            private_triples_grouped = kc_tools.group_nquads_by_subject(
+                dataset.get("private"), True
+            )
 
-        result = {"publicAssertionId": public_assertion_id, "operation": {}}
+            dataset["private"] = list(chain.from_iterable(private_triples_grouped))
 
-        try:
-            if paranet_ual is None:
-                receipt: TxReceipt = self._create(
-                    {
-                        "assertionId": Web3.to_bytes(hexstr=public_assertion_id),
-                        "size": public_assertion_metadata["size"],
-                        "triplesNumber": public_assertion_metadata["triples_number"],
-                        "chunksNumber": public_assertion_metadata["chunks_number"],
-                        "tokenAmount": token_amount,
-                        "epochsNumber": epochs_number,
-                        "scoreFunctionId": DEFAULT_PROXIMITY_SCORE_FUNCTIONS_PAIR_IDS[
-                            self.manager.blockchain_provider.environment
-                        ][blockchain_id],
-                        "immutable_": immutable,
-                    }
-                )
-            else:
-                parsed_paranet_ual = parse_ual(paranet_ual)
-                paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
-                    parsed_paranet_ual["contract_address"],
-                    parsed_paranet_ual["token_id"],
-                )
+            # Compute private root and add to public
+            private_root = kc_tools.calculate_merkle_root(dataset.get("private"))
+            dataset["public"].append(
+                f'<{ka_tools.generate_named_node()}> <{PRIVATE_ASSERTION_PREDICATE}> "{private_root}" .'
+            )
 
-                receipt: TxReceipt = self._mint_paranet_knowledge_asset(
-                    paranet_knowledge_asset_storage,
-                    paranet_knowledge_asset_token_id,
-                    {
-                        "assertionId": Web3.to_bytes(hexstr=public_assertion_id),
-                        "size": public_assertion_metadata["size"],
-                        "triplesNumber": public_assertion_metadata["triples_number"],
-                        "chunksNumber": public_assertion_metadata["chunks_number"],
-                        "tokenAmount": token_amount,
-                        "epochsNumber": epochs_number,
-                        "scoreFunctionId": DEFAULT_PROXIMITY_SCORE_FUNCTIONS_PAIR_IDS[
-                            self.manager.blockchain_provider.environment
-                        ][blockchain_id],
-                        "immutable_": immutable,
-                    },
+            # Compute private root and add to public
+            public_triples_grouped = kc_tools.group_nquads_by_subject(
+                dataset.get("public"), True
+            )
+
+            # Create a dictionary for public subject -> index for quick lookup
+            public_subject_dict = {}
+            for i in range(len(public_triples_grouped)):
+                public_subject = public_triples_grouped[i][0].split(" ")[0]
+                public_subject_dict[public_subject] = i
+
+            private_triple_subject_hashes_grouped_without_public_pair = []
+
+            # Integrate private subjects into public or store separately if no match to be appended later
+            for private_triples in private_triples_grouped:
+                private_subject = private_triples[0].split(" ")[
+                    0
+                ]  # Extract the private subject
+
+                private_subject_hash = self.solidity_packed_sha256(
+                    types=["string"],
+                    values=[private_subject[1:-1]],
                 )
 
-                result["paranetId"] = Web3.to_hex(
-                    Web3.solidity_keccak(
-                        ["address", "uint256"],
-                        [
-                            paranet_knowledge_asset_storage,
-                            paranet_knowledge_asset_token_id,
-                        ],
+                if (
+                    private_subject in public_subject_dict
+                ):  # Check if there's a public pair
+                    # If there's a public pair, insert a representation in that group
+                    public_index = public_subject_dict.get(private_subject)
+                    self.insert_triple_sorted(
+                        public_triples_grouped[public_index],
+                        f"{private_subject} <{PRIVATE_RESOURCE_PREDICATE}> <{ka_tools.generate_named_node()}> .",
                     )
-                )
-        except ContractLogicError as err:
-            if is_allowance_increased:
-                self.decrease_allowance(token_amount)
-            raise err
-
-        events = self.manager.blockchain_provider.decode_logs_event(
-            receipt,
-            "ContentAsset",
-            "AssetMinted",
+                else:
+                    # If no public pair, maintain separate list, inserting sorted by hash
+                    self.insert_triple_sorted(
+                        private_triple_subject_hashes_grouped_without_public_pair,
+                        f"<{PRIVATE_HASH_SUBJECT_PREFIX}{private_subject_hash}> <{PRIVATE_RESOURCE_PREDICATE}> <{ka_tools.generate_named_node()}> .",
+                    )
+
+            for triple in private_triple_subject_hashes_grouped_without_public_pair:
+                public_triples_grouped.append([triple])
+
+            dataset["public"] = list(chain.from_iterable(public_triples_grouped))
+        else:
+            # No private triples, just group and flatten public
+            public_triples_grouped = kc_tools.group_nquads_by_subject(
+                dataset.get("public"), True
+            )
+            dataset["public"] = list(chain.from_iterable(public_triples_grouped))
+
+        # Calculate the number of chunks
+        number_of_chunks = kc_tools.calculate_number_of_chunks(
+            dataset.get("public"), CHUNK_BYTE_SIZE
         )
-        token_id = events[0].args["tokenId"]
+        dataset_size = number_of_chunks * CHUNK_BYTE_SIZE
+
+        # Validate the assertion size in bytes
+        if dataset_size > MAX_FILE_SIZE:
+            raise ValueError(f"File size limit is {MAX_FILE_SIZE / (1024 * 1024)}MB.")
+
+        # Calculate the Merkle root
+        dataset_root = kc_tools.calculate_merkle_root(dataset.get("public"))
 
-        result["UAL"] = format_ual(
-            blockchain_id, content_asset_storage_address, token_id
+        # Get the contract address for KnowledgeCollectionStorage
+        content_asset_storage_address = self._get_asset_storage_address(
+            "KnowledgeCollectionStorage"
         )
-        result["operation"]["mintKnowledgeAsset"] = json.loads(Web3.to_json(receipt))
 
-        assertions_list = [
-            {
-                "blockchain": blockchain_id,
-                "contract": content_asset_storage_address,
-                "tokenId": token_id,
-                "assertionId": public_assertion_id,
-                "assertion": assertions["public"],
-                "storeType": StoreTypes.TRIPLE,
+        publish_operation_id = self.node_service.publish(
+            dataset_root,
+            dataset,
+            blockchain_id,
+            hash_function_id,
+            minimum_number_of_node_replications,
+        )["operationId"]
+        publish_operation_result = self.node_service.get_operation_result(
+            publish_operation_id,
+            Operations.PUBLISH.value,
+            max_number_of_retries,
+            frequency,
+        )
+
+        if publish_operation_result.get(
+            "status"
+        ) != OperationStatus.COMPLETED and not publish_operation_result.get(
+            "data", {}
+        ).get("minAcksReached"):
+            return {
+                "datasetRoot": dataset_root,
+                "operation": {
+                    "publish": self.get_operation_status_dict(
+                        publish_operation_result, publish_operation_id
+                    )
+                },
             }
-        ]
 
-        if content.get("private", None):
-            assertions_list.append(
-                {
-                    "blockchain": blockchain_id,
-                    "contract": content_asset_storage_address,
-                    "tokenId": token_id,
-                    "assertionId": MerkleTree(
-                        hash_assertion_with_indexes(assertions["private"]),
-                        sort_pairs=True,
-                    ).root,
-                    "assertion": assertions["private"],
-                    "storeType": StoreTypes.TRIPLE,
-                }
+        data = publish_operation_result.get("data", {})
+        signatures = data.get("signatures")
+
+        publisher_node_signature = data.get("publisherNodeSignature", {})
+        publisher_node_identity_id = publisher_node_signature.get("identityId")
+        publisher_node_r = publisher_node_signature.get("r")
+        publisher_node_vs = publisher_node_signature.get("vs")
+
+        identity_ids, r, vs = [], [], []
+
+        for signature in signatures:
+            try:
+                signer_address = self.get_message_signer_address(
+                    dataset_root, signature
+                )
+
+                key_is_operational_wallet = self._key_is_operational_wallet(
+                    signature.get("identityId"),
+                    Web3.solidity_keccak(["address"], [signer_address]),
+                    2,  # IdentityLib.OPERATIONAL_KEY
+                )
+
+                # If valid, append the signature components
+                if key_is_operational_wallet:
+                    identity_ids.append(signature.get("identityId"))
+                    r.append(signature.get("r"))
+                    vs.append(signature.get("vs"))
+
+            except Exception:
+                continue
+
+        if token_amount:
+            estimated_publishing_cost = token_amount
+        else:
+            time_until_next_epoch = self._time_until_next_epoch()
+            epoch_length = self._epoch_length()
+            stake_weighted_average_ask = self._get_stake_weighted_average_ask()
+
+            # Convert to integers and perform calculation
+            estimated_publishing_cost = (
+                (
+                    int(stake_weighted_average_ask)
+                    * (
+                        int(epochs_num) * int(1e18)
+                        + (int(time_until_next_epoch) * int(1e18)) // int(epoch_length)
+                    )
+                    * int(dataset_size)
+                )
+                // 1024
+                // int(1e18)
             )
 
-        operation_id = self._publish(
-            public_assertion_id,
-            assertions["public"],
-            blockchain_id,
-            content_asset_storage_address,
-            token_id,
-            DEFAULT_HASH_FUNCTION_ID,
-        )["operationId"]
-        operation_result = self.get_operation_result(operation_id, "publish")
+        knowledge_collection_id = None
+        mint_knowledge_asset_receipt = None
 
-        result["operation"]["publish"] = {
-            "operationId": operation_id,
-            "status": operation_result["status"],
-        }
+        knowledge_collection_result = self.create_knowledge_collection(
+            {
+                "publishOperationId": publish_operation_id,
+                "merkleRoot": dataset_root,
+                "knowledgeAssetsAmount": kc_tools.count_distinct_subjects(
+                    dataset.get("public")
+                ),
+                "byteSize": dataset_size,
+                "epochs": epochs_num,
+                "tokenAmount": estimated_publishing_cost,
+                "isImmutable": immutable,
+                "paymaster": payer,
+                "publisherNodeIdentityId": publisher_node_identity_id,
+                "publisherNodeR": publisher_node_r,
+                "publisherNodeVS": publisher_node_vs,
+                "identityIds": identity_ids,
+                "r": r,
+                "vs": vs,
+            },
+            None,
+            None,
+        )
+        knowledge_collection_id = knowledge_collection_result.knowledge_collection_id
+        mint_knowledge_asset_receipt = knowledge_collection_result.receipt
 
-        if operation_result["status"] == OperationStatus.COMPLETED:
-            operation_id = self._local_store(assertions_list)["operationId"]
-            operation_result = self.get_operation_result(operation_id, "local-store")
+        ual = format_ual(
+            blockchain_id, content_asset_storage_address, knowledge_collection_id
+        )
 
-            result["operation"]["localStore"] = {
-                "operationId": operation_id,
-                "status": operation_result["status"],
-            }
+        finality_status_result = 0
+        if minimum_number_of_finalization_confirmations > 0:
+            finality_status_result = self.node_service.finality_status(
+                ual,
+                minimum_number_of_finalization_confirmations,
+                max_number_of_retries,
+                frequency,
+            )
 
-        return result
+        return json.loads(
+            Web3.to_json(
+                {
+                    "UAL": ual,
+                    "datasetRoot": dataset_root,
+                    "signatures": publish_operation_result.get("data", {}).get(
+                        "signatures"
+                    ),
+                    "operation": {
+                        "mintKnowledgeAsset": mint_knowledge_asset_receipt,
+                        "publish": self.get_operation_status_object(
+                            publish_operation_result, publish_operation_id
+                        ),
+                        "finality": {
+                            "status": (
+                                "FINALIZED"
+                                if finality_status_result
+                                >= minimum_number_of_finalization_confirmations
+                                else "NOT FINALIZED"
+                            )
+                        },
+                        "numberOfConfirmations": finality_status_result,
+                        "requiredConfirmations": minimum_number_of_finalization_confirmations,
+                    },
+                }
+            )
+        )
 
     _submit_knowledge_asset = Method(BlockchainRequest.submit_knowledge_asset)
 
@@ -418,143 +677,6 @@ class KnowledgeAsset(Module):
             "operation": json.loads(Web3.to_json(receipt)),
         }
 
-    _update = Method(NodeRequest.update)
-
-    _get_block = Method(BlockchainRequest.get_block)
-
-    _get_service_agreement_data = Method(BlockchainRequest.get_service_agreement_data)
-    _update_asset_state = Method(BlockchainRequest.update_asset_state)
-
-    def update(
-        self,
-        ual: UAL,
-        content: dict[Literal["public", "private"], JSONLD],
-        token_amount: Wei | None = None,
-        content_type: Literal["JSON-LD", "N-Quads"] = "JSON-LD",
-    ) -> dict[str, UAL | HexStr | dict[str, str]]:
-        parsed_ual = parse_ual(ual)
-        blockchain_id, content_asset_storage_address, token_id = (
-            parsed_ual["blockchain"],
-            parsed_ual["contract_address"],
-            parsed_ual["token_id"],
-        )
-
-        assertions = format_content(content, content_type)
-
-        public_assertion_id = MerkleTree(
-            hash_assertion_with_indexes(assertions["public"]),
-            sort_pairs=True,
-        ).root
-        public_assertion_metadata = generate_assertion_metadata(assertions["public"])
-
-        if token_amount is None:
-            agreement_id = self.get_agreement_id(
-                content_asset_storage_address, token_id
-            )
-            # TODO: Dynamic types for namedtuples?
-            agreement_data: Type[AgreementData] = self._get_service_agreement_data(
-                agreement_id
-            )
-
-            timestamp_now = self._get_block("latest")["timestamp"]
-            current_epoch = math.floor(
-                (timestamp_now - agreement_data.startTime) / agreement_data.epochLength
-            )
-            epochs_left = agreement_data.epochsNumber - current_epoch
-
-            token_amount = int(
-                self._get_bid_suggestion(
-                    blockchain_id,
-                    epochs_left,
-                    public_assertion_metadata["size"],
-                    content_asset_storage_address,
-                    public_assertion_id,
-                    DEFAULT_HASH_FUNCTION_ID,
-                    token_amount or BidSuggestionRange.LOW,
-                )["bidSuggestion"]
-            )
-
-            token_amount -= agreement_data.tokens[0]
-            token_amount = token_amount if token_amount > 0 else 0
-
-        current_allowance = self.get_current_allowance()
-        if is_allowance_increased := current_allowance < token_amount:
-            self.increase_allowance(token_amount)
-
-        try:
-            self._update_asset_state(
-                token_id=token_id,
-                assertion_id=public_assertion_id,
-                size=public_assertion_metadata["size"],
-                triples_number=public_assertion_metadata["triples_number"],
-                chunks_number=public_assertion_metadata["chunks_number"],
-                update_token_amount=token_amount,
-            )
-        except ContractLogicError as err:
-            if is_allowance_increased:
-                self.decrease_allowance(token_amount)
-            raise err
-
-        assertions_list = [
-            {
-                "blockchain": blockchain_id,
-                "contract": content_asset_storage_address,
-                "tokenId": token_id,
-                "assertionId": public_assertion_id,
-                "assertion": assertions["public"],
-                "storeType": StoreTypes.PENDING,
-            }
-        ]
-
-        if content.get("private", None):
-            assertions_list.append(
-                {
-                    "blockchain": blockchain_id,
-                    "contract": content_asset_storage_address,
-                    "tokenId": token_id,
-                    "assertionId": MerkleTree(
-                        hash_assertion_with_indexes(assertions["private"]),
-                        sort_pairs=True,
-                    ).root,
-                    "assertion": assertions["private"],
-                    "storeType": StoreTypes.PENDING,
-                }
-            )
-
-        operation_id = self._local_store(assertions_list)["operationId"]
-        self.get_operation_result(operation_id, "local-store")
-
-        operation_id = self._update(
-            public_assertion_id,
-            assertions["public"],
-            blockchain_id,
-            content_asset_storage_address,
-            token_id,
-            DEFAULT_HASH_FUNCTION_ID,
-        )["operationId"]
-        operation_result = self.get_operation_result(operation_id, "update")
-
-        return {
-            "UAL": ual,
-            "publicAssertionId": public_assertion_id,
-            "operation": {
-                "operationId": operation_id,
-                "status": operation_result["status"],
-            },
-        }
-
-    _cancel_update = Method(BlockchainRequest.cancel_asset_state_update)
-
-    def cancel_update(self, ual: UAL) -> dict[str, UAL | TxReceipt]:
-        token_id = parse_ual(ual)["token_id"]
-
-        receipt: TxReceipt = self._cancel_update(token_id)
-
-        return {
-            "UAL": ual,
-            "operation": json.loads(Web3.to_json(receipt)),
-        }
-
     _burn_asset = Method(BlockchainRequest.burn_asset)
 
     def burn(self, ual: UAL) -> dict[str, UAL | TxReceipt]:
@@ -571,229 +693,124 @@ class KnowledgeAsset(Module):
     _get = Method(NodeRequest.get)
     _query = Method(NodeRequest.query)
 
-    def get(
-        self,
-        ual: UAL,
-        state: str | HexStr | int = KnowledgeAssetEnumStates.LATEST,
-        content_visibility: str = KnowledgeAssetContentVisibility.ALL,
-        output_format: Literal["JSON-LD", "N-Quads"] = "JSON-LD",
-        validate: bool = True,
-    ) -> dict[str, UAL | HexStr | list[JSONLD] | dict[str, str]]:
-        state = (
-            state.upper()
-            if (isinstance(state, str) and not re.match(r"^0x[a-fA-F0-9]{64}$", state))
-            else state
-        )
-        content_visibility = content_visibility.upper()
-        output_format = output_format.upper()
-
-        token_id = parse_ual(ual)["token_id"]
-
-        def handle_latest_state(token_id: int) -> tuple[HexStr, bool]:
-            unfinalized_state = Web3.to_hex(self._get_unfinalized_state(token_id))
-
-            if unfinalized_state and unfinalized_state != HASH_ZERO:
-                return unfinalized_state, False
-            else:
-                return handle_latest_finalized_state(token_id)
-
-        def handle_latest_finalized_state(token_id: int) -> tuple[HexStr, bool]:
-            return Web3.to_hex(self._get_latest_assertion_id(token_id)), True
-
-        is_state_finalized = False
-
-        match state:
-            case KnowledgeAssetEnumStates.LATEST:
-                public_assertion_id, is_state_finalized = handle_latest_state(token_id)
-
-            case KnowledgeAssetEnumStates.LATEST_FINALIZED:
-                public_assertion_id, is_state_finalized = handle_latest_finalized_state(
-                    token_id
-                )
-
-            case _ if isinstance(state, int):
-                assertion_ids = [
-                    Web3.to_hex(assertion_id)
-                    for assertion_id in self._get_assertion_ids(token_id)
-                ]
-                if 0 <= state < (states_number := len(assertion_ids)):
-                    public_assertion_id = assertion_ids[state]
-
-                    if state == states_number - 1:
-                        is_state_finalized = True
-                else:
-                    raise InvalidStateOption(f"State index {state} is out of range.")
-
-            case _ if isinstance(state, str) and re.match(
-                r"^0x[a-fA-F0-9]{64}$", state
-            ):
-                assertion_ids = [
-                    Web3.to_hex(assertion_id)
-                    for assertion_id in self._get_assertion_ids(token_id)
-                ]
-
-                if state in assertion_ids:
-                    public_assertion_id = state
-
-                    if state == assertion_ids[-1]:
-                        is_state_finalized = True
-                else:
-                    raise InvalidStateOption(
-                        f"Given state hash: {state} is not a part of the KA."
-                    )
-
-            case _:
-                raise InvalidStateOption(f"Invalid state option: {state}.")
-
-        get_public_operation_id: NodeResponseDict = self._get(
-            ual, public_assertion_id, hashFunctionId=1
+    def get(self, ual: UAL, options: dict = {}) -> dict:
+        arguments = self.input_service.get_asset_get_arguments(options)
+
+        max_number_of_retries = arguments.get("max_number_of_retries")
+        frequency = arguments.get("frequency")
+        state = arguments.get("state")
+        include_metadata = arguments.get("include_metadata")
+        content_type = arguments.get("content_type")
+        validate = arguments.get("validate")
+        output_format = arguments.get("output_format")
+        hash_function_id = arguments.get("hash_function_id")
+        paranet_ual = arguments.get("paranet_ual")
+        subject_ual = arguments.get("subject_ual")
+
+        ual_with_state = f"{ual}:{state}" if state else ual
+        get_public_operation_id: NodeResponseDict = self.node_service.get(
+            ual_with_state,
+            content_type,
+            include_metadata,
+            hash_function_id,
+            paranet_ual,
+            subject_ual,
         )["operationId"]
 
-        get_public_operation_result = self.get_operation_result(
-            get_public_operation_id, "get"
+        get_public_operation_result = self.node_service.get_operation_result(
+            get_public_operation_id,
+            Operations.GET.value,
+            max_number_of_retries,
+            frequency,
         )
-        public_assertion = get_public_operation_result["data"].get("assertion", None)
-
-        if public_assertion is None:
-            raise MissingKnowledgeAssetState("Unable to find state on the network!")
-
-        if validate:
-            root = MerkleTree(
-                hash_assertion_with_indexes(public_assertion), sort_pairs=True
-            ).root
-            if root != public_assertion_id:
-                raise InvalidKnowledgeAsset(
-                    f"State: {public_assertion_id}. " f"Merkle Tree Root: {root}"
-                )
-
-        result = {"operation": {}}
-        if content_visibility != KnowledgeAssetContentVisibility.PRIVATE:
-            formatted_public_assertion = public_assertion
 
-            match output_format:
-                case "NQUADS" | "N-QUADS":
-                    formatted_public_assertion: list[JSONLD] = jsonld.from_rdf(
-                        "\n".join(public_assertion),
-                        {"algorithm": "URDNA2015", "format": "application/n-quads"},
-                    )
-                case "JSONLD" | "JSON-LD":
-                    formatted_public_assertion = "\n".join(public_assertion)
-
-                case _:
-                    raise DatasetOutputFormatNotSupported(
-                        f"{output_format} isn't supported!"
-                    )
-
-            if content_visibility == KnowledgeAssetContentVisibility.PUBLIC:
-                result = {
-                    **result,
-                    "asertion": formatted_public_assertion,
-                    "assertionId": public_assertion_id,
+        if subject_ual:
+            if get_public_operation_result.get("data"):
+                return {
+                    "operation": {
+                        "get": self.get_operation_status_object(
+                            get_public_operation_result, get_public_operation_id
+                        ),
+                    },
+                    "subject_ual_pairs": get_public_operation_result.get("data"),
                 }
-            else:
-                result["public"] = {
-                    "assertion": formatted_public_assertion,
-                    "assertionId": public_assertion_id,
+            if get_public_operation_result.get("status") != "FAILED":
+                get_public_operation_result["data"] = {
+                    "errorType": "DKG_CLIENT_ERROR",
+                    "errorMessage": "Unable to find assertion on the network!",
                 }
-
-            result["operation"]["publicGet"] = {
-                "operationId": get_public_operation_id,
-                "status": get_public_operation_result["status"],
+                get_public_operation_result["status"] = "FAILED"
+
+            return {
+                "operation": {
+                    "get": self.get_operation_status_object(
+                        get_public_operation_result, get_public_operation_id
+                    ),
+                },
+            }
+        metadata = get_public_operation_result.get("data")
+        assertion = get_public_operation_result.get("data", {}).get("assertion", None)
+
+        if not assertion:
+            if get_public_operation_result.get("status") != "FAILED":
+                get_public_operation_result["data"] = {
+                    "errorType": "DKG_CLIENT_ERROR",
+                    "errorMessage": "Unable to find assertion on the network!",
+                }
+                get_public_operation_result["status"] = "FAILED"
+
+            return {
+                "operation": {
+                    "get": self.get_operation_status_object(
+                        get_public_operation_result, get_public_operation_id
+                    ),
+                },
             }
 
-        if content_visibility != KnowledgeAssetContentVisibility.PUBLIC:
-            private_assertion_link_triples = list(
-                filter(
-                    lambda element: PRIVATE_ASSERTION_PREDICATE in element,
-                    public_assertion,
-                )
-            )
-
-            if private_assertion_link_triples:
-                private_assertion_id = re.search(
-                    r'"(.*?)"', private_assertion_link_triples[0]
-                ).group(1)
-
-                private_assertion = get_public_operation_result["data"].get(
-                    "privateAssertion", None
-                )
+        if validate:
+            is_valid = True  # #TODO: Implement assertion validation logic
+            if not is_valid:
+                get_public_operation_result["data"] = {
+                    "error_type": "DKG_CLIENT_ERROR",
+                    "error_message": "Calculated root hashes don't match!",
+                }
 
-                query_private_operation_id: NodeResponseDict | None = None
-                if private_assertion is None:
-                    query = f"""
-                    CONSTRUCT {{ ?s ?p ?o }}
-                    WHERE {{
-                        {{
-                            GRAPH <assertion:{private_assertion_id}>
-                            {{
-                                ?s ?p ?o .
-                            }}
-                        }}
-                    }}
-                    """
-
-                    query_private_operation_id = self._query(
-                        query,
-                        "CONSTRUCT",
-                        PRIVATE_CURRENT_REPOSITORY
-                        if is_state_finalized
-                        else PRIVATE_HISTORICAL_REPOSITORY,
-                    )["operationId"]
-
-                    query_private_operation_result = self.get_operation_result(
-                        query_private_operation_id, "query"
-                    )
+        formatted_assertion = "\n".join(
+            assertion.get("public", [])
+            + (
+                assertion.get("private")
+                if isinstance(assertion.get("private"), list)
+                else []
+            )
+        )
 
-                    private_assertion = normalize_dataset(
-                        query_private_operation_result["data"],
-                        "N-Quads",
-                    )
+        formatted_metadata = None
+        if output_format == OutputTypes.JSONLD.value:
+            formatted_assertion = self.to_jsonld(formatted_assertion)
 
-                    if validate:
-                        root = MerkleTree(
-                            hash_assertion_with_indexes(private_assertion),
-                            sort_pairs=True,
-                        ).root
-                        if root != private_assertion_id:
-                            raise InvalidKnowledgeAsset(
-                                f"State: {private_assertion_id}. "
-                                f"Merkle Tree Root: {root}"
-                            )
+            if include_metadata:
+                formatted_metadata = self.to_jsonld("\n".join(metadata))
 
-                    match output_format:
-                        case "NQUADS" | "N-QUADS":
-                            formatted_private_assertion: list[JSONLD] = jsonld.from_rdf(
-                                "\n".join(private_assertion),
-                                {
-                                    "algorithm": "URDNA2015",
-                                    "format": "application/n-quads",
-                                },
-                            )
-                        case "JSONLD" | "JSON-LD":
-                            formatted_private_assertion = "\n".join(private_assertion)
+        if output_format == OutputTypes.NQUADS.value:
+            formatted_assertion = self.to_nquads(
+                formatted_assertion, DEFAULT_RDF_FORMAT
+            )
+            if include_metadata:
+                formatted_metadata = self.to_nquads(
+                    "\n".join(metadata), DEFAULT_RDF_FORMAT
+                )
 
-                        case _:
-                            raise DatasetOutputFormatNotSupported(
-                                f"{output_format} isn't supported!"
-                            )
+        result = {
+            "assertion": formatted_assertion,
+            "operation": {
+                "get": self.get_operation_status_object(
+                    get_public_operation_result, get_public_operation_id
+                ),
+            },
+        }
 
-                    if content_visibility == KnowledgeAssetContentVisibility:
-                        result = {
-                            **result,
-                            "assertion": formatted_private_assertion,
-                            "assertionId": private_assertion_id,
-                        }
-                    else:
-                        result["private"] = {
-                            "assertion": formatted_private_assertion,
-                            "assertionId": private_assertion_id,
-                        }
-
-                    if query_private_operation_id is not None:
-                        result["operation"]["queryPrivate"] = {
-                            "operationId": query_private_operation_id,
-                            "status": query_private_operation_result["status"],
-                        }
+        if include_metadata and metadata:
+            result["metadata"] = formatted_metadata
 
         return result
 
@@ -825,7 +842,7 @@ class KnowledgeAsset(Module):
                     latest_finalized_state_size,
                     content_asset_storage_address,
                     latest_finalized_state,
-                    DEFAULT_HASH_FUNCTION_ID,
+                    DefaultParameters.HASH_FUNCTION_ID.value,
                     token_amount or BidSuggestionRange.LOW,
                 )["bidSuggestion"]
             )
@@ -839,148 +856,37 @@ class KnowledgeAsset(Module):
             "operation": json.loads(Web3.to_json(receipt)),
         }
 
-    _get_assertion_size = Method(BlockchainRequest.get_assertion_size)
-    _add_tokens = Method(BlockchainRequest.increase_asset_token_amount)
-
-    def add_tokens(
-        self,
-        ual: UAL,
-        token_amount: Wei | None = None,
-    ) -> dict[str, UAL | TxReceipt]:
-        parsed_ual = parse_ual(ual)
-        blockchain_id, content_asset_storage_address, token_id = (
-            parsed_ual["blockchain"],
-            parsed_ual["contract_address"],
-            parsed_ual["token_id"],
-        )
-
-        if token_amount is None:
-            agreement_id = self.get_agreement_id(
-                content_asset_storage_address, token_id
-            )
-            # TODO: Dynamic types for namedtuples?
-            agreement_data: Type[AgreementData] = self._get_service_agreement_data(
-                agreement_id
-            )
-
-            timestamp_now = self._get_block("latest")["timestamp"]
-            current_epoch = math.floor(
-                (timestamp_now - agreement_data.startTime) / agreement_data.epochLength
-            )
-            epochs_left = agreement_data.epochsNumber - current_epoch
-
-            latest_finalized_state = self._get_latest_assertion_id(token_id)
-            latest_finalized_state_size = self._get_assertion_size(
-                latest_finalized_state
-            )
-
-            token_amount = int(
-                self._get_bid_suggestion(
-                    blockchain_id,
-                    epochs_left,
-                    latest_finalized_state_size,
-                    content_asset_storage_address,
-                    latest_finalized_state,
-                    DEFAULT_HASH_FUNCTION_ID,
-                    token_amount or BidSuggestionRange.LOW,
-                )["bidSuggestion"]
-            ) - sum(agreement_data.tokensInfo)
-
-            if token_amount <= 0:
-                raise InvalidTokenAmount(
-                    "Token amount is bigger than default suggested amount, "
-                    "please specify exact token_amount if you still want to add "
-                    "more tokens!"
-                )
-
-        receipt: TxReceipt = self._add_tokens(token_id, token_amount)
-
-        return {
-            "UAL": ual,
-            "operation": json.loads(Web3.to_json(receipt)),
-        }
-
-    _add_update_tokens = Method(BlockchainRequest.increase_asset_update_token_amount)
-
-    def add_update_tokens(
-        self,
-        ual: UAL,
-        token_amount: Wei | None = None,
-    ) -> dict[str, UAL | TxReceipt]:
-        parsed_ual = parse_ual(ual)
-        blockchain_id, content_asset_storage_address, token_id = (
-            parsed_ual["blockchain"],
-            parsed_ual["contract_address"],
-            parsed_ual["token_id"],
-        )
-
-        if token_amount is None:
-            agreement_id = self.get_agreement_id(
-                content_asset_storage_address, token_id
-            )
-            # TODO: Dynamic types for namedtuples?
-            agreement_data: Type[AgreementData] = self._get_service_agreement_data(
-                agreement_id
-            )
-
-            timestamp_now = self._get_block("latest")["timestamp"]
-            current_epoch = math.floor(
-                (timestamp_now - agreement_data.startTime) / agreement_data.epochLength
-            )
-            epochs_left = agreement_data.epochsNumber - current_epoch
-
-            unfinalized_state = self._get_latest_assertion_id(token_id)
-            unfinalized_state_size = self._get_assertion_size(unfinalized_state)
-
-            token_amount = int(
-                self._get_bid_suggestion(
-                    blockchain_id,
-                    epochs_left,
-                    unfinalized_state_size,
-                    content_asset_storage_address,
-                    unfinalized_state,
-                    DEFAULT_HASH_FUNCTION_ID,
-                    token_amount or BidSuggestionRange.LOW,
-                )["bidSuggestion"]
-            ) - sum(agreement_data.tokensInfo)
-
-            if token_amount <= 0:
-                raise InvalidTokenAmount(
-                    "Token amount is bigger than default suggested amount, "
-                    "please specify exact token_amount if you still want to add "
-                    "more update tokens!"
-                )
-
-        receipt: TxReceipt = self._add_update_tokens(token_id, token_amount)
+    _get_block = Method(BlockchainRequest.get_block)
 
-        return {
-            "UAL": ual,
-            "operation": json.loads(Web3.to_json(receipt)),
-        }
+    _get_assertion_size = Method(BlockchainRequest.get_assertion_size)
 
     def get_owner(self, ual: UAL) -> Address:
         token_id = parse_ual(ual)["token_id"]
 
         return self._owner(token_id)
 
-    _get_assertion_id_by_index = Method(BlockchainRequest.get_assertion_id_by_index)
+    def to_jsonld(self, nquads: str):
+        options = {
+            "algorithm": "URDNA2015",
+            "format": "application/n-quads",
+        }
 
-    def get_agreement_id(self, contract_address: Address, token_id: int) -> HexStr:
-        first_assertion_id = self._get_assertion_id_by_index(token_id, 0)
-        keyword = generate_keyword(contract_address, first_assertion_id)
-        return generate_agreement_id(contract_address, token_id, keyword)
+        return jsonld.from_rdf(nquads, options)
 
-    _get_operation_result = Method(NodeRequest.get_operation_result)
+    def to_nquads(self, content, input_format):
+        options = {
+            "algorithm": "URDNA2015",
+            "format": "application/n-quads",
+        }
 
-    @retry(catch=OperationNotFinished, max_retries=5, base_delay=1, backoff=2)
-    def get_operation_result(
-        self, operation_id: str, operation: str
-    ) -> NodeResponseDict:
-        operation_result = self._get_operation_result(
-            operation_id=operation_id,
-            operation=operation,
-        )
+        if input_format:
+            options["inputFormat"] = input_format
+        try:
+            jsonld_data = jsonld.from_rdf(content, options)
+            canonized = jsonld.to_rdf(jsonld_data, options)
 
-        validate_operation_status(operation_result)
+            if isinstance(canonized, str):
+                return [line for line in canonized.split("\n") if line.strip()]
 
-        return operation_result
+        except Exception as e:
+            raise ValueError(f"Error processing content: {e}")