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

dkg/paranet.py

@@ -21,14 +21,18 @@ from dataclasses import dataclass
 from web3 import Web3
 from web3.types import TxReceipt
 
-from dkg.dataclasses import BaseIncentivesPoolParams, ParanetIncentivizationType
+from dkg.dataclasses import (
+    BaseIncentivesPoolParams,
+    ParanetIncentivizationType,
+    ParanetNodesAccessPolicy,
+    ParanetMinersAccessPolicy,
+)
 from dkg.manager import DefaultRequestManager
 from dkg.method import Method
 from dkg.module import Module
 from dkg.types import Address, UAL, HexStr
 from dkg.utils.blockchain_request import BlockchainRequest
 from dkg.utils.ual import parse_ual
-from dkg.constants import NEUROWEB_BLOCKCHAIN_PREFIX, INCENTIVE_POOL_NAME
 
 
 class Paranet(Module):
@@ -38,15 +42,10 @@ class Paranet(Module):
         operator_percentage: float
         voters_percentage: float
 
-        def to_contract_args(self, incentive_type: ParanetIncentivizationType | None) -> dict:
+        def to_contract_args(self) -> dict:
             return {
                 "tracToNeuroEmissionMultiplier": int(
-                    self.neuro_emission_multiplier
-                    * (
-                        10**12
-                        if incentive_type == ParanetIncentivizationType.NEUROWEB
-                        else 10**18
-                    )
+                    self.neuro_emission_multiplier * (10**12)
                 ),
                 "paranetOperatorRewardPercentage": int(self.operator_percentage * 100),
                 "paranetIncentivizationProposalVotersRewardPercentage": int(
@@ -58,13 +57,17 @@ class Paranet(Module):
         self.manager = manager
         self.incentives_pools_deployment_functions = {
             ParanetIncentivizationType.NEUROWEB: self._deploy_neuro_incentives_pool,
-            ParanetIncentivizationType.NEUROWEB_ERC20: self._deploy_neuro_incentives_pool,
         }
 
     _register_paranet = Method(BlockchainRequest.register_paranet)
 
     def create(
-        self, ual: UAL, name: str, description: str
+        self,
+        ual: UAL,
+        name: str,
+        description: str,
+        paranet_nodes_access_policy: ParanetNodesAccessPolicy,
+        paranet_miners_access_policy: ParanetMinersAccessPolicy,
     ) -> dict[str, str | HexStr | TxReceipt]:
         parsed_ual = parse_ual(ual)
         knowledge_asset_storage, knowledge_asset_token_id = (
@@ -77,6 +80,8 @@ class Paranet(Module):
             knowledge_asset_token_id,
             name,
             description,
+            paranet_nodes_access_policy,
+            paranet_miners_access_policy,
         )
 
         return {
@@ -90,6 +95,328 @@ class Paranet(Module):
             "operation": json.loads(Web3.to_json(receipt)),
         }
 
+    _add_paranet_curated_nodes = Method(BlockchainRequest.add_paranet_curated_nodes)
+
+    def add_curated_nodes(
+        self, paranet_ual: UAL, identity_ids: list[int]
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt = self._add_paranet_curated_nodes(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+            identity_ids,
+        )
+
+        return {
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _remove_paranet_curated_nodes = Method(
+        BlockchainRequest.remove_paranet_curated_nodes
+    )
+
+    def remove_curated_nodes(
+        self, paranet_ual: UAL, identity_ids: list[int]
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt = self._remove_paranet_curated_nodes(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+            identity_ids,
+        )
+
+        return {
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _request_paranet_curated_node_access = Method(
+        BlockchainRequest.request_paranet_curated_node_access
+    )
+
+    def request_curated_node_access(
+        self, paranet_ual: UAL
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt = self._request_paranet_curated_node_access(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+        )
+
+        return {
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _approve_curated_node = Method(BlockchainRequest.approve_curated_node)
+
+    def approve_curated_node(
+        self, paranet_ual: UAL, identity_id: int
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt = self._approve_curated_node(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+            identity_id,
+        )
+
+        return {
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _reject_curated_node = Method(BlockchainRequest.reject_curated_node)
+
+    def reject_curated_node(
+        self, paranet_ual: UAL, identity_id: int
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt = self._reject_curated_node(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+            identity_id,
+        )
+
+        return {
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _get_curated_nodes = Method(BlockchainRequest.get_curated_nodes)
+
+    def get_curated_nodes(
+        self, paranet_ual: UAL
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        paranet_id = Web3.solidity_keccak(
+            ["address", "uint256"],
+            [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+        )
+
+        return self._get_curated_nodes(paranet_id)
+
+    _add_paranet_curated_miners = Method(BlockchainRequest.add_paranet_curated_miners)
+
+    def add_curated_miners(
+        self, paranet_ual: UAL, miner_addresses: list[Address]
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt = self._add_paranet_curated_miners(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+            miner_addresses,
+        )
+
+        return {
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _remove_paranet_curated_miners = Method(
+        BlockchainRequest.remove_paranet_curated_miners
+    )
+
+    def remove_curated_miners(
+        self, paranet_ual: UAL, miner_addresses: list[Address]
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt = self._remove_paranet_curated_miners(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+            miner_addresses,
+        )
+
+        return {
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _request_paranet_curated_miner_access = Method(
+        BlockchainRequest.request_paranet_curated_miner_access
+    )
+
+    def request_curated_miner_access(
+        self, paranet_ual: UAL
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt = self._request_paranet_curated_miner_access(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+        )
+
+        return {
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _approve_curated_miner = Method(BlockchainRequest.approve_curated_miner)
+
+    def approve_curated_miner(
+        self, paranet_ual: UAL, miner_address: Address
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt = self._approve_curated_miner(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+            miner_address,
+        )
+
+        return {
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _reject_curated_miner = Method(BlockchainRequest.reject_curated_miner)
+
+    def reject_curated_miner(
+        self, paranet_ual: UAL, miner_address: Address
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt = self._reject_curated_miner(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+            miner_address,
+        )
+
+        return {
+            "paranetUAL": paranet_ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _get_knowledge_miners = Method(BlockchainRequest.get_knowledge_miners)
+
+    def get_knowledge_miners(
+        self, paranet_ual: UAL
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_ual = parse_ual(paranet_ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        paranet_id = Web3.solidity_keccak(
+            ["address", "uint256"],
+            [paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id],
+        )
+
+        return self._get_knowledge_miners(paranet_id)
+
     _deploy_neuro_incentives_pool = Method(
         BlockchainRequest.deploy_neuro_incentives_pool
     )
@@ -98,7 +425,7 @@ class Paranet(Module):
         self,
         ual: UAL,
         incentives_pool_parameters: NeuroWebIncentivesPoolParams,
-        incentives_type: ParanetIncentivizationType | None = None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> dict[str, str | HexStr | TxReceipt]:
         deploy_incentives_pool_fn = self.incentives_pools_deployment_functions.get(
             incentives_type,
@@ -118,10 +445,9 @@ class Paranet(Module):
         )
 
         receipt: TxReceipt = deploy_incentives_pool_fn(
-            incentives_type == ParanetIncentivizationType.NEUROWEB,
             knowledge_asset_storage,
             knowledge_asset_token_id,
-            **incentives_pool_parameters.to_contract_args(incentives_type),
+            **incentives_pool_parameters.to_contract_args(),
         )
 
         events = self.manager.blockchain_provider.decode_logs_event(
@@ -145,7 +471,9 @@ class Paranet(Module):
     _get_incentives_pool_address = Method(BlockchainRequest.get_incentives_pool_address)
 
     def get_incentives_pool_address(
-        self, ual: UAL, incentives_type: ParanetIncentivizationType | None = None
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> Address:
         parsed_ual = parse_ual(ual)
         knowledge_asset_storage, knowledge_asset_token_id = (
@@ -265,14 +593,8 @@ class Paranet(Module):
         self,
         ual: UAL,
         address: Address | None = None,
-        incentives_type: ParanetIncentivizationType | None = None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> bool:
-        incentives_type = incentives_type or (
-            ParanetIncentivizationType.NEUROWEB.value
-            if NEUROWEB_BLOCKCHAIN_PREFIX in ual
-            else ParanetIncentivizationType.NEUROWEB_ERC20.value
-        )
-
         return self._is_proposal_voter(
             contract=self._get_incentives_pool_contract(ual, incentives_type),
             addr=address or self.manager.blockchain_provider.account.address,
@@ -285,14 +607,8 @@ class Paranet(Module):
     def calculate_claimable_miner_reward_amount(
         self,
         ual: UAL,
-        incentives_type: ParanetIncentivizationType | None = None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> int:
-        incentives_type = incentives_type or (
-            ParanetIncentivizationType.NEUROWEB.value
-            if NEUROWEB_BLOCKCHAIN_PREFIX in ual
-            else ParanetIncentivizationType.NEUROWEB_ERC20.value
-        )
-
         return self._get_claimable_knowledge_miner_reward_amount(
             contract=self._get_incentives_pool_contract(ual, incentives_type)
         )
@@ -304,14 +620,8 @@ class Paranet(Module):
     def calculate_all_claimable_miner_rewards_amount(
         self,
         ual: UAL,
-        incentives_type: ParanetIncentivizationType | None = None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> int:
-        incentives_type = incentives_type or (
-            ParanetIncentivizationType.NEUROWEB.value
-            if NEUROWEB_BLOCKCHAIN_PREFIX in ual
-            else ParanetIncentivizationType.NEUROWEB_ERC20.value
-        )
-
         return self._get_claimable_all_knowledge_miners_reward_amount(
             contract=self._get_incentives_pool_contract(ual, incentives_type)
         )
@@ -323,14 +633,8 @@ class Paranet(Module):
     def claim_miner_reward(
         self,
         ual: UAL,
-        incentives_type: None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> dict[str, str | HexStr | TxReceipt]:
-        incentives_type = incentives_type or (
-            ParanetIncentivizationType.NEUROWEB.value
-            if NEUROWEB_BLOCKCHAIN_PREFIX in ual
-            else ParanetIncentivizationType.NEUROWEB_ERC20.value
-        )
-
         receipt: TxReceipt = self._claim_knowledge_miner_reward(
             contract=self._get_incentives_pool_contract(ual, incentives_type)
         )
@@ -359,14 +663,8 @@ class Paranet(Module):
     def calculate_claimable_operator_reward_amount(
         self,
         ual: UAL,
-        incentives_type: ParanetIncentivizationType | None = None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> int:
-        incentives_type = incentives_type or (
-            ParanetIncentivizationType.NEUROWEB.value
-            if NEUROWEB_BLOCKCHAIN_PREFIX in ual
-            else ParanetIncentivizationType.NEUROWEB_ERC20.value
-        )
-
         return self._get_claimable_paranet_operator_reward_amount(
             contract=self._get_incentives_pool_contract(ual, incentives_type)
         )
@@ -378,14 +676,8 @@ class Paranet(Module):
     def claim_operator_reward(
         self,
         ual: UAL,
-        incentives_type: ParanetIncentivizationType | None = None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> dict[str, str | HexStr | TxReceipt]:
-        incentives_type = incentives_type or (
-            ParanetIncentivizationType.NEUROWEB.value
-            if NEUROWEB_BLOCKCHAIN_PREFIX in ual
-            else ParanetIncentivizationType.NEUROWEB_ERC20.value
-        )
-
         receipt: TxReceipt = self._claim_paranet_operator_reward(
             contract=self._get_incentives_pool_contract(ual, incentives_type)
         )
@@ -414,14 +706,8 @@ class Paranet(Module):
     def calculate_claimable_voter_reward_amount(
         self,
         ual: UAL,
-        incentives_type: ParanetIncentivizationType | None = None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> int:
-        incentives_type = incentives_type or (
-            ParanetIncentivizationType.NEUROWEB.value
-            if NEUROWEB_BLOCKCHAIN_PREFIX in ual
-            else ParanetIncentivizationType.NEUROWEB_ERC20.value
-        )
-
         return self._get_claimable_proposal_voter_reward_amount(
             contract=self._get_incentives_pool_contract(ual, incentives_type)
         )
@@ -433,14 +719,8 @@ class Paranet(Module):
     def calculate_all_claimable_voters_reward_amount(
         self,
         ual: UAL,
-        incentives_type: ParanetIncentivizationType | None = None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> int:
-        incentives_type = incentives_type or (
-            ParanetIncentivizationType.NEUROWEB.value
-            if NEUROWEB_BLOCKCHAIN_PREFIX in ual
-            else ParanetIncentivizationType.NEUROWEB_ERC20.value
-        )
-
         return self._get_claimable_all_proposal_voters_reward_amount(
             contract=self._get_incentives_pool_contract(ual, incentives_type)
         )
@@ -452,14 +732,8 @@ class Paranet(Module):
     def claim_voter_reward(
         self,
         ual: UAL,
-        incentives_type: ParanetIncentivizationType | None = None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> dict[str, str | HexStr | TxReceipt]:
-        incentives_type = incentives_type or (
-            ParanetIncentivizationType.NEUROWEB.value
-            if NEUROWEB_BLOCKCHAIN_PREFIX in ual
-            else ParanetIncentivizationType.NEUROWEB_ERC20.value
-        )
-
         receipt: TxReceipt = self._claim_incentivization_proposal_voter_reward(
             contract=self._get_incentives_pool_contract(ual, incentives_type)
         )
@@ -484,42 +758,13 @@ class Paranet(Module):
     _get_updating_knowledge_asset_states = Method(
         BlockchainRequest.get_updating_knowledge_asset_states
     )
-    _process_updated_knowledge_asset_states_metadata = Method(
-        BlockchainRequest.process_updated_knowledge_asset_states_metadata
-    )
-
-    def update_claimable_rewards(self, ual: UAL) -> dict[str, str | HexStr | TxReceipt]:
-        parsed_ual = parse_ual(ual)
-        knowledge_asset_storage, knowledge_asset_token_id = (
-            parsed_ual["contract_address"],
-            parsed_ual["token_id"],
-        )
-
-        paranet_id = Web3.solidity_keccak(
-            ["address", "uint256"], [knowledge_asset_storage, knowledge_asset_token_id]
-        )
-
-        updating_states = self._get_updating_knowledge_asset_states(
-            self.manager.blockchain_provider.account.address,
-            paranet_id,
-        )
-        receipt: TxReceipt = self._process_updated_knowledge_asset_states_metadata(
-            knowledge_asset_storage,
-            knowledge_asset_token_id,
-            0,
-            len(updating_states),
-        )
-
-        return {
-            "paranetUAL": ual,
-            "paranetId": paranet_id,
-            "operation": json.loads(Web3.to_json(receipt)),
-        }
 
     def _get_incentives_pool_contract(
-        self, ual: UAL, incentives_type: ParanetIncentivizationType
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
     ) -> str | dict[str, str]:
-        incentives_pool_name = INCENTIVE_POOL_NAME
+        incentives_pool_name = f"Paranet{str(incentives_type)}IncentivesPool"
         is_incentives_pool_cached = (
             incentives_pool_name in self.manager.blockchain_provider.contracts.keys()
         )