dkg 0.1.0b5__py3-none-any.whl → 1.0.0__py3-none-any.whl

dkg/asset.py

@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import json
 import math
 import re
 from typing import Literal, Type
@@ -23,17 +24,29 @@ from pyld import jsonld
 from web3 import Web3
 from web3.constants import ADDRESS_ZERO, HASH_ZERO
 from web3.exceptions import ContractLogicError
-
-from dkg.constants import (DEFAULT_HASH_FUNCTION_ID, DEFAULT_SCORE_FUNCTION_ID,
-                           PRIVATE_ASSERTION_PREDICATE,
-                           PRIVATE_CURRENT_REPOSITORY,
-                           PRIVATE_HISTORICAL_REPOSITORY)
-from dkg.dataclasses import (KnowledgeAssetContentVisibility,
-                             KnowledgeAssetEnumStates, NodeResponseDict)
-from dkg.exceptions import (DatasetOutputFormatNotSupported,
-                            InvalidKnowledgeAsset, InvalidStateOption,
-                            InvalidTokenAmount, MissingKnowledgeAssetState,
-                            OperationNotFinished)
+from web3.types import TxReceipt
+
+from dkg.constants import (
+    DEFAULT_HASH_FUNCTION_ID,
+    DEFAULT_PROXIMITY_SCORE_FUNCTIONS_PAIR_IDS,
+    PRIVATE_ASSERTION_PREDICATE,
+    PRIVATE_CURRENT_REPOSITORY,
+    PRIVATE_HISTORICAL_REPOSITORY,
+)
+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
@@ -41,15 +54,22 @@ 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.utils.node_request import (NodeRequest, StoreTypes,
-                                    validate_operation_status)
+from dkg.utils.metadata import (
+    generate_agreement_id,
+    generate_assertion_metadata,
+    generate_keyword,
+)
+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
 
 
-class ContentAsset(Module):
+class KnowledgeAsset(Module):
     def __init__(self, manager: DefaultRequestManager):
         self.manager = manager
 
@@ -176,6 +196,7 @@ class ContentAsset(Module):
 
     _get_asset_storage_address = Method(BlockchainRequest.get_asset_storage_address)
     _create = Method(BlockchainRequest.create_asset)
+    _mint_paranet_knowledge_asset = Method(BlockchainRequest.mint_knowledge_asset)
 
     _get_bid_suggestion = Method(NodeRequest.bid_suggestion)
     _local_store = Method(NodeRequest.local_store)
@@ -188,7 +209,8 @@ class ContentAsset(Module):
         token_amount: Wei | None = None,
         immutable: bool = False,
         content_type: Literal["JSON-LD", "N-Quads"] = "JSON-LD",
-    ) -> dict[str, HexStr | dict[str, str]]:
+        paranet_ual: UAL | None = None,
+    ) -> dict[str, UAL | HexStr | dict[str, dict[str, str] | TxReceipt]]:
         blockchain_id = self.manager.blockchain_provider.blockchain_id
         assertions = format_content(content, content_type)
 
@@ -211,6 +233,7 @@ class ContentAsset(Module):
                     content_asset_storage_address,
                     public_assertion_id,
                     DEFAULT_HASH_FUNCTION_ID,
+                    token_amount or BidSuggestionRange.LOW,
                 )["bidSuggestion"]
             )
 
@@ -218,19 +241,57 @@ class ContentAsset(Module):
         if is_allowance_increased := current_allowance < token_amount:
             self.increase_allowance(token_amount)
 
+        result = {"publicAssertionId": public_assertion_id, "operation": {}}
+
         try:
-            receipt = 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_SCORE_FUNCTION_ID,
-                    "immutable_": immutable,
-                }
-            )
+            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"],
+                )
+
+                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,
+                    },
+                )
+
+                result["paranetId"] = Web3.to_hex(
+                    Web3.solidity_keccak(
+                        ["address", "uint256"],
+                        [
+                            paranet_knowledge_asset_storage,
+                            paranet_knowledge_asset_token_id,
+                        ],
+                    )
+                )
         except ContractLogicError as err:
             if is_allowance_increased:
                 self.decrease_allowance(token_amount)
@@ -243,6 +304,11 @@ class ContentAsset(Module):
         )
         token_id = events[0].args["tokenId"]
 
+        result["UAL"] = format_ual(
+            blockchain_id, content_asset_storage_address, token_id
+        )
+        result["operation"]["mintKnowledgeAsset"] = json.loads(Web3.to_json(receipt))
+
         assertions_list = [
             {
                 "blockchain": blockchain_id,
@@ -250,7 +316,7 @@ class ContentAsset(Module):
                 "tokenId": token_id,
                 "assertionId": public_assertion_id,
                 "assertion": assertions["public"],
-                "storeType": StoreTypes.TRIPLE.value,
+                "storeType": StoreTypes.TRIPLE,
             }
         ]
 
@@ -265,13 +331,10 @@ class ContentAsset(Module):
                         sort_pairs=True,
                     ).root,
                     "assertion": assertions["private"],
-                    "storeType": StoreTypes.TRIPLE.value,
+                    "storeType": StoreTypes.TRIPLE,
                 }
             )
 
-        operation_id = self._local_store(assertions_list)["operationId"]
-        self.get_operation_result(operation_id, "local-store")
-
         operation_id = self._publish(
             public_assertion_id,
             assertions["public"],
@@ -282,13 +345,56 @@ class ContentAsset(Module):
         )["operationId"]
         operation_result = self.get_operation_result(operation_id, "publish")
 
-        return {
-            "UAL": format_ual(blockchain_id, content_asset_storage_address, token_id),
-            "publicAssertionId": public_assertion_id,
-            "operation": {
+        result["operation"]["publish"] = {
+            "operationId": operation_id,
+            "status": operation_result["status"],
+        }
+
+        if operation_result["status"] == OperationStatus.COMPLETED:
+            operation_id = self._local_store(assertions_list)["operationId"]
+            operation_result = self.get_operation_result(operation_id, "local-store")
+
+            result["operation"]["localStore"] = {
                 "operationId": operation_id,
                 "status": operation_result["status"],
-            },
+            }
+
+        return result
+
+    _submit_knowledge_asset = Method(BlockchainRequest.submit_knowledge_asset)
+
+    def submit_to_paranet(
+        self, ual: UAL, paranet_ual: UAL
+    ) -> dict[str, UAL | Address | TxReceipt]:
+        parsed_ual = parse_ual(ual)
+        knowledge_asset_storage, knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        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"],
+        )
+
+        receipt: TxReceipt = self._submit_knowledge_asset(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+            knowledge_asset_storage,
+            knowledge_asset_token_id,
+        )
+
+        return {
+            "UAL": ual,
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [knowledge_asset_storage, knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
         }
 
     _transfer = Method(BlockchainRequest.transfer_asset)
@@ -297,10 +403,10 @@ class ContentAsset(Module):
         self,
         ual: UAL,
         new_owner: Address,
-    ) -> dict[str, UAL | Address | dict[str, str]]:
+    ) -> dict[str, UAL | Address | TxReceipt]:
         token_id = parse_ual(ual)["token_id"]
 
-        self._transfer(
+        receipt: TxReceipt = self._transfer(
             self.manager.blockchain_provider.account,
             new_owner,
             token_id,
@@ -309,7 +415,7 @@ class ContentAsset(Module):
         return {
             "UAL": ual,
             "owner": new_owner,
-            "operation": {"status": "COMPLETED"},
+            "operation": json.loads(Web3.to_json(receipt)),
         }
 
     _update = Method(NodeRequest.update)
@@ -325,7 +431,7 @@ class ContentAsset(Module):
         content: dict[Literal["public", "private"], JSONLD],
         token_amount: Wei | None = None,
         content_type: Literal["JSON-LD", "N-Quads"] = "JSON-LD",
-    ) -> dict[str, HexStr | dict[str, str]]:
+    ) -> dict[str, UAL | HexStr | dict[str, str]]:
         parsed_ual = parse_ual(ual)
         blockchain_id, content_asset_storage_address, token_id = (
             parsed_ual["blockchain"],
@@ -364,6 +470,7 @@ class ContentAsset(Module):
                     content_asset_storage_address,
                     public_assertion_id,
                     DEFAULT_HASH_FUNCTION_ID,
+                    token_amount or BidSuggestionRange.LOW,
                 )["bidSuggestion"]
             )
 
@@ -395,7 +502,7 @@ class ContentAsset(Module):
                 "tokenId": token_id,
                 "assertionId": public_assertion_id,
                 "assertion": assertions["public"],
-                "storeType": StoreTypes.PENDING.value,
+                "storeType": StoreTypes.PENDING,
             }
         ]
 
@@ -410,7 +517,7 @@ class ContentAsset(Module):
                         sort_pairs=True,
                     ).root,
                     "assertion": assertions["private"],
-                    "storeType": StoreTypes.PENDING.value,
+                    "storeType": StoreTypes.PENDING,
                 }
             )
 
@@ -428,7 +535,7 @@ class ContentAsset(Module):
         operation_result = self.get_operation_result(operation_id, "update")
 
         return {
-            "UAL": format_ual(blockchain_id, content_asset_storage_address, token_id),
+            "UAL": ual,
             "publicAssertionId": public_assertion_id,
             "operation": {
                 "operationId": operation_id,
@@ -438,24 +545,24 @@ class ContentAsset(Module):
 
     _cancel_update = Method(BlockchainRequest.cancel_asset_state_update)
 
-    def cancel_update(self, ual: UAL) -> dict[str, UAL | dict[str, str]]:
+    def cancel_update(self, ual: UAL) -> dict[str, UAL | TxReceipt]:
         token_id = parse_ual(ual)["token_id"]
 
-        self._cancel_update(token_id)
+        receipt: TxReceipt = self._cancel_update(token_id)
 
         return {
             "UAL": ual,
-            "operation": {"status": "COMPLETED"},
+            "operation": json.loads(Web3.to_json(receipt)),
         }
 
     _burn_asset = Method(BlockchainRequest.burn_asset)
 
-    def burn(self, ual: UAL) -> dict[str, UAL | dict[str, str]]:
+    def burn(self, ual: UAL) -> dict[str, UAL | TxReceipt]:
         token_id = parse_ual(ual)["token_id"]
 
-        self._burn_asset(token_id)
+        receipt: TxReceipt = self._burn_asset(token_id)
 
-        return {"UAL": ual, "operation": {"status": "COMPLETED"}}
+        return {"UAL": ual, "operation": json.loads(Web3.to_json(receipt))}
 
     _get_assertion_ids = Method(BlockchainRequest.get_assertion_ids)
     _get_latest_assertion_id = Method(BlockchainRequest.get_latest_assertion_id)
@@ -467,11 +574,11 @@ class ContentAsset(Module):
     def get(
         self,
         ual: UAL,
-        state: str | HexStr | int = KnowledgeAssetEnumStates.LATEST.value,
-        content_visibility: str = KnowledgeAssetContentVisibility.ALL.value,
+        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, HexStr | list[JSONLD] | dict[str, str]]:
+    ) -> 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))
@@ -496,10 +603,10 @@ class ContentAsset(Module):
         is_state_finalized = False
 
         match state:
-            case KnowledgeAssetEnumStates.LATEST.value:
+            case KnowledgeAssetEnumStates.LATEST:
                 public_assertion_id, is_state_finalized = handle_latest_state(token_id)
 
-            case KnowledgeAssetEnumStates.LATEST_FINALIZED.value:
+            case KnowledgeAssetEnumStates.LATEST_FINALIZED:
                 public_assertion_id, is_state_finalized = handle_latest_finalized_state(
                     token_id
                 )
@@ -560,7 +667,7 @@ class ContentAsset(Module):
                 )
 
         result = {"operation": {}}
-        if content_visibility != KnowledgeAssetContentVisibility.PRIVATE.value:
+        if content_visibility != KnowledgeAssetContentVisibility.PRIVATE:
             formatted_public_assertion = public_assertion
 
             match output_format:
@@ -577,7 +684,7 @@ class ContentAsset(Module):
                         f"{output_format} isn't supported!"
                     )
 
-            if content_visibility == KnowledgeAssetContentVisibility.PUBLIC.value:
+            if content_visibility == KnowledgeAssetContentVisibility.PUBLIC:
                 result = {
                     **result,
                     "asertion": formatted_public_assertion,
@@ -594,7 +701,7 @@ class ContentAsset(Module):
                 "status": get_public_operation_result["status"],
             }
 
-        if content_visibility != KnowledgeAssetContentVisibility.PUBLIC.value:
+        if content_visibility != KnowledgeAssetContentVisibility.PUBLIC:
             private_assertion_link_triples = list(
                 filter(
                     lambda element: PRIVATE_ASSERTION_PREDICATE in element,
@@ -670,7 +777,7 @@ class ContentAsset(Module):
                                 f"{output_format} isn't supported!"
                             )
 
-                    if content_visibility == KnowledgeAssetContentVisibility.PRIVATE:
+                    if content_visibility == KnowledgeAssetContentVisibility:
                         result = {
                             **result,
                             "assertion": formatted_private_assertion,
@@ -697,7 +804,7 @@ class ContentAsset(Module):
         ual: UAL,
         additional_epochs: int,
         token_amount: Wei | None = None,
-    ) -> dict[str, UAL | dict[str, str]]:
+    ) -> dict[str, UAL | TxReceipt]:
         parsed_ual = parse_ual(ual)
         blockchain_id, content_asset_storage_address, token_id = (
             parsed_ual["blockchain"],
@@ -719,14 +826,17 @@ class ContentAsset(Module):
                     content_asset_storage_address,
                     latest_finalized_state,
                     DEFAULT_HASH_FUNCTION_ID,
+                    token_amount or BidSuggestionRange.LOW,
                 )["bidSuggestion"]
             )
 
-        self._extend_storing_period(token_id, additional_epochs, token_amount)
+        receipt: TxReceipt = self._extend_storing_period(
+            token_id, additional_epochs, token_amount
+        )
 
         return {
             "UAL": ual,
-            "operation": {"status": "COMPLETED"},
+            "operation": json.loads(Web3.to_json(receipt)),
         }
 
     _get_assertion_size = Method(BlockchainRequest.get_assertion_size)
@@ -736,7 +846,7 @@ class ContentAsset(Module):
         self,
         ual: UAL,
         token_amount: Wei | None = None,
-    ) -> dict[str, UAL | dict[str, str]]:
+    ) -> dict[str, UAL | TxReceipt]:
         parsed_ual = parse_ual(ual)
         blockchain_id, content_asset_storage_address, token_id = (
             parsed_ual["blockchain"],
@@ -772,6 +882,7 @@ class ContentAsset(Module):
                     content_asset_storage_address,
                     latest_finalized_state,
                     DEFAULT_HASH_FUNCTION_ID,
+                    token_amount or BidSuggestionRange.LOW,
                 )["bidSuggestion"]
             ) - sum(agreement_data.tokensInfo)
 
@@ -782,11 +893,11 @@ class ContentAsset(Module):
                     "more tokens!"
                 )
 
-        self._add_tokens(token_id, token_amount)
+        receipt: TxReceipt = self._add_tokens(token_id, token_amount)
 
         return {
             "UAL": ual,
-            "operation": {"status": "COMPLETED"},
+            "operation": json.loads(Web3.to_json(receipt)),
         }
 
     _add_update_tokens = Method(BlockchainRequest.increase_asset_update_token_amount)
@@ -795,7 +906,7 @@ class ContentAsset(Module):
         self,
         ual: UAL,
         token_amount: Wei | None = None,
-    ) -> dict[str, UAL | dict[str, str]]:
+    ) -> dict[str, UAL | TxReceipt]:
         parsed_ual = parse_ual(ual)
         blockchain_id, content_asset_storage_address, token_id = (
             parsed_ual["blockchain"],
@@ -829,6 +940,7 @@ class ContentAsset(Module):
                     content_asset_storage_address,
                     unfinalized_state,
                     DEFAULT_HASH_FUNCTION_ID,
+                    token_amount or BidSuggestionRange.LOW,
                 )["bidSuggestion"]
             ) - sum(agreement_data.tokensInfo)
 
@@ -839,11 +951,11 @@ class ContentAsset(Module):
                     "more update tokens!"
                 )
 
-        self._add_update_tokens(token_id, token_amount)
+        receipt: TxReceipt = self._add_update_tokens(token_id, token_amount)
 
         return {
             "UAL": ual,
-            "operation": {"status": "COMPLETED"},
+            "operation": json.loads(Web3.to_json(receipt)),
         }
 
     def get_owner(self, ual: UAL) -> Address:

dkg/constants.py

@@ -29,10 +29,6 @@ BLOCKCHAINS = {
             "hub": "0x5FbDB2315678afecb367f032d93F642f64180aa3",
             "rpc": "http://localhost:9545",
         },
-        "otp:2043": {
-            "hub": "0x7585a99C5C150a08f5CDeFD16465C6De8D41EbbD",
-            "rpc": "http://parachain-alphanet-02.origin-trail.network:9933",
-        },
     },
     "devnet": {
         "otp:2160": {
@@ -44,6 +40,10 @@ BLOCKCHAINS = {
             "rpc": "https://rpc.chiadochain.net",
             "gas_price_oracle": "https://blockscout.chiadochain.net/api/v1/gas-price-oracle",
         },
+        "base:84532": {
+            "hub": "0x6C861Cb69300C34DfeF674F7C00E734e840C29C0",
+            "rpc": "https://sepolia.base.org",
+        }
     },
     "testnet": {
         "otp:20430": {
@@ -55,19 +55,52 @@ BLOCKCHAINS = {
             "rpc": "https://rpc.chiadochain.net",
             "gas_price_oracle": "https://blockscout.chiadochain.net/api/v1/gas-price-oracle",
         },
+        "base:84532": {
+            "hub": "0x144eDa5cbf8926327cb2cceef168A121F0E4A299",
+            "rpc": "https://sepolia.base.org",
+        }
     },
     "mainnet": {
         "otp:2043": {
             "hub": "0x5fA7916c48Fe6D5F1738d12Ad234b78c90B4cAdA",
             "rpc": "https://astrosat-parachain-rpc.origin-trail.network",
         },
+        "gnosis:100": {
+            "hub": "0xbEF14fc04F870c2dD65c13Df4faB6ba01A9c746b",
+            "rpc": "https://rpc.gnosischain.com/",
+            "gas_price_oracle": [
+                "https://api.gnosisscan.io/api?module=proxy&action=eth_gasPrice",
+                "https://blockscout.com/xdai/mainnet/api/v1/gas-price-oracle",
+            ],
+        }
     },
 }
 
-DEFAULT_GAS_PRICE_GWEI = 100
+DEFAULT_GAS_PRICE_GWEI = {
+    "gnosis": 20,
+    "otp": 1,
+}
 
 DEFAULT_HASH_FUNCTION_ID = 1
-DEFAULT_SCORE_FUNCTION_ID = 1
+DEFAULT_PROXIMITY_SCORE_FUNCTIONS_PAIR_IDS = {
+    "development": {
+        "hardhat1:31337": 2,
+        "hardhat2:31337": 2,
+        "otp:2043": 2
+    },
+    "devnet": {
+        "otp:2160": 2,
+        "gnosis:10200": 2,
+    },
+    "testnet": {
+        "otp:20430": 2,
+        "gnosis:10200": 2,
+    },
+    "mainnet": {
+        "otp:2043": 2,
+        "gnosis:100": 2,
+    },
+}
 
 PRIVATE_HISTORICAL_REPOSITORY = "privateHistory"
 PRIVATE_CURRENT_REPOSITORY = "privateCurrent"