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

dkg/paranet.py

@@ -0,0 +1,477 @@
+# 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 json
+
+from dataclasses import dataclass
+from web3 import Web3
+from web3.contract import Contract
+from web3.types import TxReceipt
+
+from dkg.dataclasses import BaseIncentivesPoolParams, ParanetIncentivizationType
+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
+
+
+class Paranet(Module):
+    @dataclass
+    class NeuroWebIncentivesPoolParams(BaseIncentivesPoolParams):
+        neuro_emission_multiplier: float
+        operator_percentage: float
+        voters_percentage: float
+
+        def to_contract_args(self) -> dict:
+            return {
+                "tracToNeuroEmissionMultiplier": int(
+                    self.neuro_emission_multiplier * (10**12)
+                ),
+                "paranetOperatorRewardPercentage": int(self.operator_percentage * 100),
+                "paranetIncentivizationProposalVotersRewardPercentage": int(
+                    self.voters_percentage * 100
+                ),
+            }
+
+    def __init__(self, manager: DefaultRequestManager):
+        self.manager = manager
+        self.incentives_pools_deployment_functions = {
+            ParanetIncentivizationType.NEUROWEB: self._deploy_neuro_incentives_pool,
+        }
+
+    _register_paranet = Method(BlockchainRequest.register_paranet)
+
+    def create(
+        self, ual: UAL, name: str, description: str
+    ) -> 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"],
+        )
+
+        receipt: TxReceipt = self._register_paranet(
+            knowledge_asset_storage,
+            knowledge_asset_token_id,
+            name,
+            description,
+        )
+
+        return {
+            "paranetUAL": ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [knowledge_asset_storage, knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _deploy_neuro_incentives_pool = Method(
+        BlockchainRequest.deploy_neuro_incentives_pool
+    )
+
+    def deploy_incentives_contract(
+        self,
+        ual: UAL,
+        incentives_pool_parameters: NeuroWebIncentivesPoolParams,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        deploy_incentives_pool_fn = self.incentives_pools_deployment_functions.get(
+            incentives_type,
+            None,
+        )
+
+        if deploy_incentives_pool_fn is None:
+            raise ValueError(
+                f"{incentives_type} Incentive Type isn't supported. Supported "
+                f"Incentive Types: {self.incentives_pools_deployment_functions.keys()}"
+            )
+
+        parsed_ual = parse_ual(ual)
+        knowledge_asset_storage, knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        receipt: TxReceipt = deploy_incentives_pool_fn(
+            knowledge_asset_storage,
+            knowledge_asset_token_id,
+            **incentives_pool_parameters.to_contract_args(),
+        )
+
+        events = self.manager.blockchain_provider.decode_logs_event(
+            receipt,
+            "ParanetIncentivesPoolFactory",
+            "ParanetIncetivesPoolDeployed",
+        )
+
+        return {
+            "paranetUAL": ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [knowledge_asset_storage, knowledge_asset_token_id],
+                )
+            ),
+            "incentivesPoolAddress": events[0].args["incentivesPool"]["addr"],
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _get_incentives_pool_address = Method(BlockchainRequest.get_incentives_pool_address)
+
+    def get_incentives_pool_address(
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> Address:
+        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]
+        )
+
+        return self._get_incentives_pool_address(paranet_id, incentives_type)
+
+    _register_paranet_service = Method(BlockchainRequest.register_paranet_service)
+
+    def create_service(
+        self, ual: UAL, name: str, description: str, addresses: list[Address]
+    ) -> 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"],
+        )
+
+        receipt: TxReceipt = self._register_paranet_service(
+            knowledge_asset_storage,
+            knowledge_asset_token_id,
+            name,
+            description,
+            addresses,
+        )
+
+        return {
+            "paranetServiceUAL": ual,
+            "paranetServiceId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [knowledge_asset_storage, knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _add_paranet_services = Method(BlockchainRequest.add_paranet_services)
+
+    def add_services(
+        self, ual: UAL, services_uals: list[UAL]
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        parsed_paranet_ual = parse_ual(ual)
+        paranet_knowledge_asset_storage, paranet_knowledge_asset_token_id = (
+            parsed_paranet_ual["contract_address"],
+            parsed_paranet_ual["token_id"],
+        )
+
+        parsed_service_uals = []
+        for service_ual in services_uals:
+            parsed_service_ual = parse_ual(service_ual)
+            (service_knowledge_asset_storage, service_knowledge_asset_token_id) = (
+                parsed_service_ual["contract_address"],
+                parsed_service_ual["token_id"],
+            )
+
+            parsed_service_uals.append(
+                {
+                    "knowledgeAssetStorageContract": service_knowledge_asset_storage,
+                    "tokenId": service_knowledge_asset_token_id,
+                }
+            )
+
+        receipt: TxReceipt = self._add_paranet_services(
+            paranet_knowledge_asset_storage,
+            paranet_knowledge_asset_token_id,
+            parsed_service_uals,
+        )
+
+        return {
+            "paranetUAL": 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)),
+        }
+
+    _is_knowledge_miner_registered = Method(
+        BlockchainRequest.is_knowledge_miner_registered
+    )
+
+    def is_knowledge_miner(self, ual: UAL, address: Address | None = None) -> bool:
+        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]
+        )
+
+        return self._is_knowledge_miner_registered(
+            paranet_id, address or self.manager.blockchain_provider.account.address
+        )
+
+    _owner_of = Method(BlockchainRequest.owner_of)
+
+    def is_operator(self, ual: UAL, address: Address | None = None) -> bool:
+        knowledge_asset_token_id = parse_ual(ual)["token_id"]
+
+        return self._owner_of(knowledge_asset_token_id) == (
+            address or self.manager.blockchain_provider.account.address
+        )
+
+    _is_proposal_voter = Method(BlockchainRequest.is_proposal_voter)
+
+    def is_voter(
+        self,
+        ual: UAL,
+        address: Address | None = None,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> bool:
+        return self._is_proposal_voter(
+            contract=self._get_incentives_pool_contract(ual, incentives_type),
+            addr=address or self.manager.blockchain_provider.account.address,
+        )
+
+    _get_claimable_knowledge_miner_reward_amount = Method(
+        BlockchainRequest.get_claimable_knowledge_miner_reward_amount
+    )
+
+    def calculate_claimable_miner_reward_amount(
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> int:
+        return self._get_claimable_knowledge_miner_reward_amount(
+            contract=self._get_incentives_pool_contract(ual, incentives_type)
+        )
+
+    _get_claimable_all_knowledge_miners_reward_amount = Method(
+        BlockchainRequest.get_claimable_all_knowledge_miners_reward_amount
+    )
+
+    def calculate_all_claimable_miner_rewards_amount(
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> int:
+        return self._get_claimable_all_knowledge_miners_reward_amount(
+            contract=self._get_incentives_pool_contract(ual, incentives_type)
+        )
+
+    _claim_knowledge_miner_reward = Method(
+        BlockchainRequest.claim_knowledge_miner_reward
+    )
+
+    def claim_miner_reward(
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        receipt: TxReceipt = self._claim_knowledge_miner_reward(
+            contract=self._get_incentives_pool_contract(ual, incentives_type)
+        )
+
+        parsed_ual = parse_ual(ual)
+        knowledge_asset_storage, knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        return {
+            "paranetUAL": ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [knowledge_asset_storage, knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _get_claimable_paranet_operator_reward_amount = Method(
+        BlockchainRequest.get_claimable_paranet_operator_reward_amount
+    )
+
+    def calculate_claimable_operator_reward_amount(
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> int:
+        return self._get_claimable_paranet_operator_reward_amount(
+            contract=self._get_incentives_pool_contract(ual, incentives_type)
+        )
+
+    _claim_paranet_operator_reward = Method(
+        BlockchainRequest.claim_paranet_operator_reward
+    )
+
+    def claim_operator_reward(
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        receipt: TxReceipt = self._claim_paranet_operator_reward(
+            contract=self._get_incentives_pool_contract(ual, incentives_type)
+        )
+
+        parsed_ual = parse_ual(ual)
+        knowledge_asset_storage, knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        return {
+            "paranetUAL": ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [knowledge_asset_storage, knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _get_claimable_proposal_voter_reward_amount = Method(
+        BlockchainRequest.get_claimable_proposal_voter_reward_amount
+    )
+
+    def calculate_claimable_voter_reward_amount(
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> int:
+        return self._get_claimable_proposal_voter_reward_amount(
+            contract=self._get_incentives_pool_contract(ual, incentives_type)
+        )
+
+    _get_claimable_all_proposal_voters_reward_amount = Method(
+        BlockchainRequest.get_claimable_all_proposal_voters_reward_amount
+    )
+
+    def calculate_all_claimable_voters_reward_amount(
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> int:
+        return self._get_claimable_all_proposal_voters_reward_amount(
+            contract=self._get_incentives_pool_contract(ual, incentives_type)
+        )
+
+    _claim_incentivization_proposal_voter_reward = Method(
+        BlockchainRequest.claim_incentivization_proposal_voter_reward
+    )
+
+    def claim_voter_reward(
+        self,
+        ual: UAL,
+        incentives_type: ParanetIncentivizationType = ParanetIncentivizationType.NEUROWEB,
+    ) -> dict[str, str | HexStr | TxReceipt]:
+        receipt: TxReceipt = self._claim_incentivization_proposal_voter_reward(
+            contract=self._get_incentives_pool_contract(ual, incentives_type)
+        )
+
+        parsed_ual = parse_ual(ual)
+        knowledge_asset_storage, knowledge_asset_token_id = (
+            parsed_ual["contract_address"],
+            parsed_ual["token_id"],
+        )
+
+        return {
+            "paranetUAL": ual,
+            "paranetId": Web3.to_hex(
+                Web3.solidity_keccak(
+                    ["address", "uint256"],
+                    [knowledge_asset_storage, knowledge_asset_token_id],
+                )
+            ),
+            "operation": json.loads(Web3.to_json(receipt)),
+        }
+
+    _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 = ParanetIncentivizationType.NEUROWEB,
+    ) -> str | dict[str, str]:
+        incentives_pool_name = f"Paranet{str(incentives_type)}IncentivesPool"
+        is_incentives_pool_cached = (
+            incentives_pool_name in self.manager.blockchain_provider.contracts.keys()
+        )
+
+        return (
+            incentives_pool_name
+            if is_incentives_pool_cached
+            else {
+                "name": incentives_pool_name,
+                "address": self.get_incentives_pool_address(ual, incentives_type),
+            }
+        )

dkg/providers/blockchain.py

@@ -24,8 +24,12 @@ from typing import Any, Type
 
 import requests
 from dkg.constants import BLOCKCHAINS, DEFAULT_GAS_PRICE_GWEI
-from dkg.exceptions import (AccountMissing, EnvironmentNotSupported,
-                            NetworkNotSupported, RPCURINotDefined)
+from dkg.exceptions import (
+    AccountMissing,
+    EnvironmentNotSupported,
+    NetworkNotSupported,
+    RPCURINotDefined,
+)
 from dkg.types import URI, Address, DataHexStr, Environment, Wei
 from eth_account.signers.local import LocalAccount
 from web3 import Web3
@@ -96,13 +100,14 @@ class BlockchainProvider:
             "Hub": self.w3.eth.contract(
                 address=hub_address,
                 abi=self.abi["Hub"],
+                decode_tuples=True,
             )
         }
         self._init_contracts()
 
         if (
-            private_key is not None or
-            (private_key_env := os.environ.get("PRIVATE_KEY", None)) is not None
+            private_key is not None
+            or (private_key_env := os.environ.get("PRIVATE_KEY", None)) is not None
         ):
             self.set_account(private_key or private_key_env)
 
@@ -125,33 +130,48 @@ class BlockchainProvider:
             except Exception as err:
                 if (
                     contract_name
+                    and isinstance(contract_name, str)
                     and any(msg in str(err) for msg in ["revert", "VM Exception"])
                     and not self._check_contract_status(contract_name)
                 ):
-                    self._update_contract_instance(contract_name)
-                    return func(self, *args, **kwargs)
-                raise
+                    is_updated = self._update_contract_instance(contract_name)
+                    if is_updated:
+                        return func(self, *args, **kwargs)
+                raise err
 
         return wrapper
 
     @handle_updated_contract
     def call_function(
         self,
-        contract: str,
+        contract: str | dict[str, str],
         function: str,
         args: dict[str, Any] = {},
         state_changing: bool = False,
         gas_price: Wei | None = None,
         gas_limit: Wei | None = None,
     ) -> TxReceipt | Any:
-        contract_instance = self.contracts[contract]
+        if isinstance(contract, str):
+            contract_name = contract
+            contract_instance = self.contracts[contract_name]
+        else:
+            contract_name = contract["name"]
+            contract_instance = self.w3.eth.contract(
+                address=contract["address"],
+                abi=self.abi[contract_name],
+                decode_tuples=True,
+            )
+            self.contracts[contract_name] = contract_instance
+
         contract_function: ContractFunction = getattr(
             contract_instance.functions, function
         )
 
         if not state_changing:
             result = contract_function(**args).call()
-            if function in (output_named_tuples := self.output_named_tuples[contract]):
+            if function in (
+                output_named_tuples := self.output_named_tuples[contract_name]
+            ):
                 result = output_named_tuples[function](*result)
             return result
         else:
@@ -190,11 +210,13 @@ class BlockchainProvider:
         self.w3.eth.default_account = self.account.address
 
     def _get_network_gas_price(self) -> Wei | None:
+        if self.environment == "development":
+            return None
+
         blockchain_name, _ = self.blockchain_id.split(":")
 
         default_gas_price = self.w3.to_wei(
-            DEFAULT_GAS_PRICE_GWEI[blockchain_name],
-            "gwei"
+            DEFAULT_GAS_PRICE_GWEI[blockchain_name], "gwei"
         )
 
         def fetch_gas_price(oracle_url: str) -> Wei | None:
@@ -204,9 +226,9 @@ class BlockchainProvider:
                 data: dict = response.json()
 
                 if "result" in data:
-                    return int(data['result'], 16)
+                    return int(data["result"], 16)
                 elif "average" in data:
-                    return self.w3.to_wei(data['average'], 'gwei')
+                    return self.w3.to_wei(data["average"], "gwei")
                 else:
                     return None
             except Exception:
@@ -221,7 +243,7 @@ class BlockchainProvider:
                 gas_price = fetch_gas_price(oracle_url)
                 if gas_price is not None:
                     return gas_price
-                
+
         return default_gas_price
 
     def _init_contracts(self):
@@ -231,17 +253,26 @@ class BlockchainProvider:
 
             self._update_contract_instance(contract)
 
-    def _update_contract_instance(self, contract: str):
-        self.contracts[contract] = self.w3.eth.contract(
-            address=(
-                self.contracts["Hub"]
-                .functions.getContractAddress(contract).call()
-                if not contract.endswith("AssetStorage")
-                else self.contracts["Hub"]
-                .functions.getAssetStorageAddress(contract).call()
-            ),
-            abi=self.abi[contract],
-        )
+    def _update_contract_instance(self, contract: str) -> bool:
+        if (
+            self.contracts["Hub"].functions.isContract(contractName=contract).call()
+            or self.contracts["Hub"]
+            .functions.isAssetStorage(assetStorageName=contract)
+            .call()
+        ):
+            self.contracts[contract] = self.w3.eth.contract(
+                address=(
+                    self.contracts["Hub"].functions.getContractAddress(contract).call()
+                    if not contract.endswith("AssetStorage")
+                    else self.contracts["Hub"]
+                    .functions.getAssetStorageAddress(contract)
+                    .call()
+                ),
+                abi=self.abi[contract],
+                decode_tuples=True,
+            )
+            return True
+        return False
 
     def _check_contract_status(self, contract: str) -> bool:
         try:

dkg/types/__init__.py

@@ -1,3 +1,4 @@
+from .general import AutoStrEnum, AutoStrEnumCapitalize, AutoStrEnumUpperCase # NOQA: F401
 from .blockchain import (ABI, ABIElement, ABIError, ABIEvent,  # NOQA: F401
                          ABIFunction, ABIParameter, AgreementData, Environment)
 from .dkg_node import UAL  # NOQA: F401

dkg/types/general.py

@@ -0,0 +1,44 @@
+# 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 enum import Enum
+
+class AutoStrEnum(str, Enum):
+    @staticmethod
+    def _generate_next_value_(name: str, start: int, count: int, last_values: list) -> str:
+        return name.lower()
+    
+    def __str__(self):
+        return str(self.value)
+    
+
+class AutoStrEnumCapitalize(str, Enum):
+    @staticmethod
+    def _generate_next_value_(name: str, start: int, count: int, last_values: list) -> str:
+        return name.capitalize()
+    
+    def __str__(self):
+        return str(self.value)
+
+
+class AutoStrEnumUpperCase(str, Enum):
+    @staticmethod
+    def _generate_next_value_(name: str, start: int, count: int, last_values: list) -> str:
+        return name
+    
+    def __str__(self):
+        return str(self.value)