dkg 0.1.0b5__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,11 +24,14 @@ 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 requests.exceptions import ConnectionError, HTTPError, RequestException, Timeout
 from web3 import Web3
 from web3.contract import Contract
 from web3.contract.contract import ContractFunction
@@ -97,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)
 
@@ -126,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:
@@ -162,11 +181,9 @@ class BlockchainProvider:
                     "account."
                 )
 
-            nonce = self.w3.eth.get_transaction_count(self.w3.eth.default_account)
             gas_price = self.gas_price or gas_price or self._get_network_gas_price()
 
             options = {
-                "nonce": nonce,
                 "gasPrice": gas_price,
                 "gas": gas_limit or contract_function(**args).estimate_gas(),
             }
@@ -192,45 +209,42 @@ class BlockchainProvider:
         )
         self.w3.eth.default_account = self.account.address
 
-    def _get_network_gas_price(self) -> int | None:
-        blockchain_name, chain_id = self.blockchain_id.split(":")
-
-        default_gas_price = self.w3.to_wei(DEFAULT_GAS_PRICE_GWEI, "gwei")
-
-        match blockchain_name:
-            case "otp":
-                return self.w3.eth.gas_price
-            case "gnosis":
-                if self.gas_price_oracle is None:
-                    return default_gas_price
-
-                try:
-                    response = requests.get(self.gas_price_oracle)
-
-                    response.raise_for_status()
-
-                    try:
-                        response_json: dict = response.json()
-                    except ValueError:
-                        return default_gas_price
+    def _get_network_gas_price(self) -> Wei | None:
+        if self.environment == "development":
+            return None
 
-                except (HTTPError, ConnectionError, Timeout, RequestException):
-                    return default_gas_price
+        blockchain_name, _ = self.blockchain_id.split(":")
 
-                gas_price = None
-                match chain_id:
-                    case "100":
-                        gas_price_hex = response_json.get("result")
-                        if gas_price_hex:
-                            gas_price = int(gas_price_hex, 16)
-                    case "10200":
-                        gas_price_avg = response_json.get("average")
-                        if gas_price_avg:
-                            gas_price = self.w3.to_wei(gas_price_avg, "gwei")
+        default_gas_price = self.w3.to_wei(
+            DEFAULT_GAS_PRICE_GWEI[blockchain_name], "gwei"
+        )
 
-                return gas_price if gas_price is not None else default_gas_price
-            case _:
-                return default_gas_price
+        def fetch_gas_price(oracle_url: str) -> Wei | None:
+            try:
+                response = requests.get(oracle_url)
+                response.raise_for_status()
+                data: dict = response.json()
+
+                if "result" in data:
+                    return int(data["result"], 16)
+                elif "average" in data:
+                    return self.w3.to_wei(data["average"], "gwei")
+                else:
+                    return None
+            except Exception:
+                return None
+
+        oracles = self.gas_price_oracle
+        if oracles is not None:
+            if isinstance(oracles, str):
+                oracles = [oracles]
+
+            for oracle_url in oracles:
+                gas_price = fetch_gas_price(oracle_url)
+                if gas_price is not None:
+                    return gas_price
+
+        return default_gas_price
 
     def _init_contracts(self):
         for contract in self.abi.keys():
@@ -239,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