dkg 0.1.0b1__py3-none-any.whl

dkg/utils/blockchain_request.py

@@ -0,0 +1,159 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from dataclasses import dataclass, field
+from typing import Type
+
+from dkg.types import Address, HexStr, Wei
+
+
+@dataclass
+class JSONRPCRequest:
+    endpoint: str
+    args: dict[str, Type] = field(default_factory=dict)
+
+
+@dataclass
+class ContractInteraction:
+    contract: str
+    function: str
+    args: dict[str, Type] = field(default_factory=dict)
+
+
+@dataclass
+class ContractTransaction(ContractInteraction):
+    gas_price: Wei | None = None
+    gas_limit: Wei | None = None
+
+
+@dataclass
+class ContractCall(ContractInteraction):
+    pass
+
+
+class BlockchainRequest:
+    chain_id = JSONRPCRequest("chain_id")
+    get_block = JSONRPCRequest("get_block", args={"block_identifier": str | int})
+
+    get_contract_address = ContractCall(
+        contract="Hub",
+        function="getContractAddress",
+        args={"contractName": str},
+    )
+    get_asset_storage_address = ContractCall(
+        contract="Hub",
+        function="getAssetStorageAddress",
+        args={"assetStorageName": str},
+    )
+
+    increase_allowance = ContractTransaction(
+        contract="Token",
+        function="increaseAllowance",
+        args={"spender": Address, "addedValue": Wei},
+    )
+    decrease_allowance = ContractTransaction(
+        contract="Token",
+        function="decreaseAllowance",
+        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",
+        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",
+        args={"tokenId": int},
+    )
+    owner_of = ContractCall(
+        contract="ContentAssetStorage",
+        function="ownerOf",
+        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": HexStr},
+    )
+
+    get_assertion_size = ContractCall(
+        contract="AssertionStorage",
+        function="getAssertionSize",
+        args={"assertionId": HexStr},
+    )

dkg/utils/decorators.py

@@ -0,0 +1,46 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import time
+from functools import wraps
+from typing import Any, Callable
+
+from dkg.exceptions import NodeRequestError
+
+
+def retry(
+    catch: Exception, max_retries: int, base_delay: int, backoff: float
+) -> Callable[[Callable], Callable]:
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            _delay = base_delay
+
+            for _ in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except catch:
+                    time.sleep(_delay)
+                    _delay *= backoff
+
+            raise NodeRequestError(
+                f"Failed executing {func.__name__} after {max_retries} retries."
+            )
+
+        return wrapper
+
+    return decorator

dkg/utils/merkle.py

@@ -0,0 +1,173 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import copy
+import hashlib
+from typing import Callable
+
+from dkg.exceptions import LeafNotInTree
+from dkg.types import HexStr
+from eth_abi.packed import encode_packed
+from hexbytes import HexBytes
+from web3 import Web3
+
+
+def solidity_keccak256(data: HexStr) -> HexStr:
+    bytes_hash: HexBytes = Web3.solidity_keccak(
+        ["bytes"],
+        [data],
+    )
+
+    return bytes_hash.hex()
+
+
+def hash_assertion_with_indexes(
+    leaves: list[str],
+    hash_function: str | Callable[[str], HexStr] = solidity_keccak256,
+    sort: bool = True,
+) -> list[HexStr]:
+    if sort:
+        leaves.sort()
+
+    return list(
+        map(
+            hash_function,
+            [
+                encode_packed(
+                    ["bytes32", "uint256"],
+                    [Web3.solidity_keccak(["string"], [leaf]), i],
+                )
+                for i, leaf in enumerate(leaves)
+            ],
+        )
+    )
+
+
+class MerkleTree:
+    def __init__(
+        self,
+        leaves: list[str],
+        hash_function: str | Callable[[str], HexStr] = solidity_keccak256,
+        sort_leaves: bool = False,
+        sort_pairs: bool = False,
+    ):
+        self.hash_function = self._set_hash_function(hash_function)
+        self.sort_leaves = sort_leaves
+        self.sort_pairs = sort_pairs
+        self.leaves = self._process_leaves(leaves)
+        self.tree = self.build_tree()
+
+    @property
+    def root(self) -> HexStr:
+        return self.tree[0][0]
+
+    def build_tree(self) -> list[list[HexStr]]:
+        tree = [self.leaves]
+
+        while len(level := tree[-1]) > 1:
+            next_level = []
+            for h1, h2 in zip(level[::2], level[1::2] + [None]):
+                if h2:
+                    next_level.append(
+                        self.hash_function(
+                            h1 + h2[2:]
+                            if not self.sort_pairs
+                            else "0x" + "".join(sorted([h1[2:], h2[2:]]))
+                        )
+                    )
+                else:
+                    next_level.append(h1)
+
+            tree.append(next_level)
+
+        tree.reverse()
+        return tree
+
+    def proof(self, leaf: HexStr, index: int | None = None) -> list[HexStr]:
+        if index is None:
+            for i, t_leaf in enumerate(self.leaves):
+                if leaf == t_leaf:
+                    index = i
+                    break
+
+        if index is None:
+            raise LeafNotInTree(f"{leaf} is not a part of the Merkle Tree.")
+
+        proof = []
+        levels = copy.deepcopy(self.tree[:0:-1])
+        for level in levels:
+            if (len(level) % 2) == 1:
+                level.append(level[-1])
+
+            if (index % 2) == 1:
+                proof.append(level[index - 1])
+            else:
+                proof.append(level[index + 1])
+
+            index //= 2
+
+        return proof
+
+    def verify(self, proof: list[HexStr], leaf: HexStr) -> bool:
+        if self.sort_pairs:
+            hash = leaf
+            for p in proof:
+                if hash == p:
+                    continue
+
+                hash = self.hash_function("".join(sorted([hash, p])))
+
+        else:
+            for i, t_leaf in enumerate(self.leaves):
+                if leaf == t_leaf:
+                    index = i
+                    break
+
+            if index is None:
+                raise LeafNotInTree(f"{leaf} is not a part of the Merkle Tree.")
+
+            hash = leaf
+            for p in proof:
+                if hash == p:
+                    continue
+
+                is_left = (index % 2) == 0
+                hash = self.hash_function("".join([hash, p] if is_left else [p, hash]))
+                index //= 2
+
+        return hash == self.root
+
+    def _process_leaves(self, leaves: list[str | HexStr]) -> list[HexStr]:
+        if self.sort_leaves:
+            leaves.sort()
+
+        return leaves
+
+    def _set_hash_function(
+        self, hash_function: str | Callable[[str], HexStr]
+    ) -> Callable[[str], HexStr]:
+        if (
+            isinstance(hash_function, str)
+            and hash_function in hashlib.algorithms_available
+        ):
+            return lambda data: getattr(hashlib, hash_function)(
+                data.encode()
+            ).hexdigest()
+        elif isinstance(hash_function, Callable):
+            return hash_function
+        else:
+            raise ValueError()

dkg/utils/metadata.py

@@ -0,0 +1,50 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import hashlib
+import json
+
+from dkg.types import Address, NQuads
+from eth_abi.packed import encode_packed
+
+
+def generate_assertion_metadata(assertion: NQuads) -> dict[str, int]:
+    return {
+        "size": len(json.dumps(assertion, separators=(",", ":")).encode("utf-8")),
+        "triples_number": len(assertion),
+        "chunks_number": len(assertion),  # TODO: Change when chunking introduced
+    }
+
+
+def generate_keyword(contract_address: Address, assertion_id: bytes) -> bytes:
+    return encode_packed(
+        ["address", "bytes32"],
+        [contract_address, assertion_id],
+    )
+
+
+def generate_agreement_id(
+    contract_address: Address,
+    token_id: int,
+    keyword: bytes,
+) -> bytes:
+    return hashlib.sha256(
+        encode_packed(
+            ["address", "uint256", "bytes"],
+            [contract_address, token_id, keyword],
+        )
+    ).digest()

dkg/utils/node_request.py

@@ -0,0 +1,197 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Type
+
+from dkg.dataclasses import HTTPRequestMethod
+from dkg.exceptions import OperationFailed, OperationNotFinished
+from dkg.types import UAL, Address, DataHexStr, NQuads
+
+
+@dataclass
+class NodeCall:
+    method: HTTPRequestMethod
+    path: str
+    params: dict[str, Type] = field(default_factory=dict)
+    data: dict[str, Type] | Type = field(default_factory=dict)
+
+
+class NodeRequest:
+    info = NodeCall(method=HTTPRequestMethod.GET, path="info")
+    bid_suggestion = NodeCall(
+        method=HTTPRequestMethod.GET,
+        path="bid-suggestion",
+        params={
+            "blockchain": str,
+            "epochsNumber": int,
+            "assertionSize": int,
+            "contentAssetStorageAddress": Address,
+            "firstAssertionId": DataHexStr,
+            "hashFunctionId": int,
+        },
+    )
+    get_operation_result = NodeCall(
+        method=HTTPRequestMethod.GET,
+        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,
+            "blockchain": str,
+            "contract": Address,
+            "tokenId": int,
+            "hashFunctionId": int,
+        },
+    )
+    update = NodeCall(
+        method=HTTPRequestMethod.POST,
+        path="update",
+        data={
+            "assertionId": str,
+            "assertion": NQuads,
+            "blockchain": str,
+            "contract": Address,
+            "tokenId": int,
+            "hashFunctionId": int,
+        },
+    )
+    get = NodeCall(
+        method=HTTPRequestMethod.POST,
+        path="get",
+        data={"id": UAL, "state": str, "hashFunctionId": int},
+    )
+    query = NodeCall(
+        method=HTTPRequestMethod.POST,
+        path="query",
+        data={"query": str, "type": str, "repository": str},
+    )
+
+
+class LocalStoreOperationStatus(Enum):
+    LOCAL_STORE_INIT_START = "LOCAL_STORE_INIT_START"
+    LOCAL_STORE_INIT_END = "LOCAL_STORE_INIT_END"
+    LOCAL_STORE_START = "LOCAL_STORE_START"
+    LOCAL_STORE_END = "LOCAL_STORE_END"
+
+
+class PublishOperationStatus(Enum):
+    VALIDATING_PUBLISH_ASSERTION_REMOTE_START = (
+        "VALIDATING_PUBLISH_ASSERTION_REMOTE_START"
+    )
+    VALIDATING_PUBLISH_ASSERTION_REMOTE_END = "VALIDATING_PUBLISH_ASSERTION_REMOTE_END"
+    INSERTING_ASSERTION = "INSERTING_ASSERTION"
+    PUBLISHING_ASSERTION = "PUBLISHING_ASSERTION"
+    PUBLISH_START = "PUBLISH_START"
+    PUBLISH_INIT_START = "PUBLISH_INIT_START"
+    PUBLISH_INIT_END = "PUBLISH_INIT_END"
+    PUBLISH_LOCAL_STORE_START = "PUBLISH_LOCAL_STORE_START"
+    PUBLISH_LOCAL_STORE_END = "PUBLISH_LOCAL_STORE_END"
+    PUBLISH_REPLICATE_START = "PUBLISH_REPLICATE_START"
+    PUBLISH_REPLICATE_END = "PUBLISH_REPLICATE_END"
+    PUBLISH_END = "PUBLISH_END"
+
+
+class UpdateOperationStatus(Enum):
+    UPDATE_START = "UPDATE_START"
+    UPDATE_INIT_START = "UPDATE_INIT_START"
+    UPDATE_INIT_END = "UPDATE_INIT_END"
+    UPDATE_REPLICATE_START = "UPDATE_REPLICATE_START"
+    UPDATE_REPLICATE_END = "UPDATE_REPLICATE_END"
+    VALIDATING_UPDATE_ASSERTION_REMOTE_START = (
+        "VALIDATING_UPDATE_ASSERTION_REMOTE_START"
+    )
+    VALIDATING_UPDATE_ASSERTION_REMOTE_END = "VALIDATING_UPDATE_ASSERTION_REMOTE_END"
+    UPDATE_END = "UPDATE_END"
+
+
+class StoreTypes(Enum):
+    TRIPLE = "TRIPLE"
+    PENDING = "PENDING"
+
+
+class GetOperationStatus(Enum):
+    ASSERTION_EXISTS_LOCAL_START = "ASSERTION_EXISTS_LOCAL_START"
+    ASSERTION_EXISTS_LOCAL_END = "ASSERTION_EXISTS_LOCAL_END"
+    GET_START = "GET_START"
+    GET_INIT_START = "GET_INIT_START"
+    GET_INIT_END = "GET_INIT_END"
+    GET_LOCAL_START = "GET_LOCAL_START"
+    GET_LOCAL_END = "GET_LOCAL_END"
+    GET_REMOTE_START = "GET_REMOTE_START"
+    GET_REMOTE_END = "GET_REMOTE_END"
+    GET_FETCH_FROM_NODES_START = "GET_FETCH_FROM_NODES_START"
+    GET_FETCH_FROM_NODES_END = "GET_FETCH_FROM_NODES_END"
+    GET_END = "GET_END"
+
+
+class QueryOperationStatus(Enum):
+    QUERY_INIT_START = "QUERY_INIT_START"
+    QUERY_INIT_END = "QUERY_INIT_END"
+    QUERY_START = "QUERY_START"
+    QUERY_END = "QUERY_END"
+
+
+class OperationStatus(Enum):
+    PENDING = "PENDING"
+    FAILED = "FAILED"
+    COMPLETED = "COMPLETED"
+    FIND_NODES_START = "FIND_NODES_START"
+    FIND_NODES_END = "FIND_NODES_END"
+    FIND_NODES_LOCAL_START = "FIND_NODES_LOCAL_START"
+    FIND_NODES_LOCAL_END = "FIND_NODES_LOCAL_END"
+    FIND_NODES_OPEN_CONNECTION_START = "FIND_NODES_OPEN_CONNECTION_START"
+    FIND_NODES_OPEN_CONNECTION_END = "FIND_NODES_OPEN_CONNECTION_END"
+    FIND_NODES_CREATE_STREAM_START = "FIND_NODES_CREATE_STREAM_START"
+    FIND_NODES_CREATE_STREAM_END = "FIND_NODES_CREATE_STREAM_END"
+    FIND_NODES_SEND_MESSAGE_START = "FIND_NODES_SEND_MESSAGE_START"
+    FIND_NODES_SEND_MESSAGE_END = "FIND_NODES_SEND_MESSAGE_END"
+    DIAL_PROTOCOL_START = "DIAL_PROTOCOL_START"
+    DIAL_PROTOCOL_END = "DIAL_PROTOCOL_END"
+    LOCAL_STORE = LocalStoreOperationStatus
+    PUBLISH = PublishOperationStatus
+    UPDATE = UpdateOperationStatus
+    GET = GetOperationStatus
+    QUERY = QueryOperationStatus
+
+
+def validate_operation_status(operation_result: dict[str, Any]) -> None:
+    try:
+        status = OperationStatus(operation_result["status"])
+    except ValueError:
+        raise OperationNotFinished("Operation isn't finished")
+
+    match status:
+        case OperationStatus.COMPLETED:
+            return
+        case OperationStatus.FAILED:
+            raise OperationFailed(
+                f"Operation failed! {operation_result['data']['errorType']}: "
+                f"{operation_result['data']['errorMessage']}."
+            )
+        case _:
+            raise OperationNotFinished("Operation isn't finished")

dkg/utils/rdf.py

@@ -0,0 +1,51 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from typing import Literal
+
+from dkg.exceptions import DatasetInputFormatNotSupported, InvalidDataset
+from dkg.types import JSONLD, NQuads
+from pyld import jsonld
+
+
+def normalize_dataset(
+    dataset: JSONLD | NQuads,
+    input_format: Literal["JSON-LD", "N-Quads"] = "JSON-LD",
+) -> NQuads:
+    normalization_options = {
+        "algorithm": "URDNA2015",
+        "format": "application/n-quads",
+    }
+
+    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

dkg/utils/string_transformations.py

@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+
+#   http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+def snake_to_camel(string: str) -> str:
+    splitted_string = string.split("_")
+    return splitted_string[0] + "".join(
+        token.capitalize() for token in splitted_string[1:]
+    )