dkg 8.0.0a0__py3-none-any.whl → 8.0.0a2__py3-none-any.whl

dkg/dataclasses.py

@@ -16,7 +16,7 @@
 # under the License.
 
 from dataclasses import dataclass
-from enum import auto, Enum
+from enum import auto, Enum, IntEnum
 
 import pandas as pd
 
@@ -59,6 +59,16 @@ class ParanetIncentivizationType(AutoStrEnumCapitalize):
     NEUROWEB = auto()
 
 
+class ParanetNodesAccessPolicy(IntEnum):
+    OPEN = 0
+    CURATED = 1
+
+
+class ParanetMinersAccessPolicy(IntEnum):
+    OPEN = 0
+    CURATED = 1
+
+
 @dataclass
 class BaseIncentivesPoolParams:
     def to_contract_args(self) -> dict:

dkg/exceptions.py

@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
+
 class DKGException(Exception):
     """
     Exception mixin inherited by all exceptions of dkg.py

dkg/node.py

@@ -20,6 +20,8 @@ from dkg.manager import DefaultRequestManager
 from dkg.method import Method
 from dkg.module import Module
 from dkg.utils.node_request import NodeRequest
+from dkg.utils.blockchain_request import BlockchainRequest
+from dkg.types import Address
 
 
 class Node(Module):
@@ -31,3 +33,8 @@ class Node(Module):
     @property
     def info(self) -> NodeResponseDict:
         return self._info()
+
+    _get_identity_id = Method(BlockchainRequest.get_identity_id)
+
+    def get_identity_id(self, operational: Address) -> int:
+        return self._get_identity_id(operational)

dkg/paranet.py

@@ -21,7 +21,12 @@ 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
@@ -57,7 +62,12 @@ class Paranet(Module):
     _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 = (
@@ -70,6 +80,8 @@ class Paranet(Module):
             knowledge_asset_token_id,
             name,
             description,
+            paranet_nodes_access_policy,
+            paranet_miners_access_policy,
         )
 
         return {
@@ -83,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
     )

dkg/providers/blockchain.py

@@ -23,7 +23,7 @@ from pathlib import Path
 from typing import Any, Type
 
 import requests
-from dkg.constants import BLOCKCHAINS, DEFAULT_GAS_PRICE_GWEI
+from dkg.constants import BLOCKCHAINS
 from dkg.exceptions import (
     AccountMissing,
     EnvironmentNotSupported,
@@ -32,12 +32,13 @@ from dkg.exceptions import (
 )
 from dkg.types import URI, Address, DataHexStr, Environment, Wei
 from eth_account.signers.local import LocalAccount
+from eth_typing import ABI, ABIFunction
 from web3 import Web3
 from web3.contract import Contract
 from web3.contract.contract import ContractFunction
 from web3.logs import DISCARD
-from web3.middleware import construct_sign_and_send_raw_middleware
-from web3.types import ABI, ABIFunction, TxReceipt
+from web3.middleware import SignAndSendRawMiddlewareBuilder
+from web3.types import TxReceipt
 
 
 class BlockchainProvider:
@@ -181,13 +182,15 @@ class BlockchainProvider:
                     "account."
                 )
 
-            gas_price = self.gas_price or gas_price or self._get_network_gas_price()
-
             options = {
-                "gasPrice": gas_price,
                 "gas": gas_limit or contract_function(**args).estimate_gas(),
             }
 
+            gas_price = self.gas_price or gas_price or self._get_network_gas_price()
+
+            if gas_price is not None:
+                options["gasPrice"] = gas_price
+
             tx_hash = contract_function(**args).transact(options)
             tx_receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
 
@@ -204,8 +207,9 @@ class BlockchainProvider:
 
     def set_account(self, private_key: DataHexStr):
         self.account: LocalAccount = self.w3.eth.account.from_key(private_key)
-        self.w3.middleware_onion.add(
-            construct_sign_and_send_raw_middleware(self.account)
+        self.w3.middleware_onion.inject(
+            SignAndSendRawMiddlewareBuilder.build(private_key),
+            layer=0,
         )
         self.w3.eth.default_account = self.account.address
 
@@ -213,12 +217,6 @@ class BlockchainProvider:
         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"
-        )
-
         def fetch_gas_price(oracle_url: str) -> Wei | None:
             try:
                 response = requests.get(oracle_url)
@@ -244,7 +242,7 @@ class BlockchainProvider:
                 if gas_price is not None:
                     return gas_price
 
-        return default_gas_price
+        return None
 
     def _init_contracts(self):
         for contract in self.abi.keys():

dkg/types/__init__.py

@@ -1,6 +1,18 @@
-from .general import AutoStrEnum, AutoStrEnumCapitalize, AutoStrEnumUpperCase # NOQA: F401
-from .blockchain import (ABI, ABIElement, ABIError, ABIEvent,  # NOQA: F401
-                         ABIFunction, ABIParameter, AgreementData, Environment)
+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
 from .encoding import BytesLike, DataHexStr, HexStr  # NOQA: F401
 from .evm import Address, ChecksumAddress, Wei  # NOQA: F401

dkg/types/general.py

@@ -17,28 +17,35 @@
 
 from enum import Enum
 
+
 class AutoStrEnum(str, Enum):
     @staticmethod
-    def _generate_next_value_(name: str, start: int, count: int, last_values: list) -> str:
+    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:
+    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:
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list
+    ) -> str:
         return name
-    
+
     def __str__(self):
-        return str(self.value)
+        return str(self.value)

dkg/utils/blockchain_request.py

@@ -70,7 +70,7 @@ class BlockchainRequest:
     allowance = ContractCall(
         contract="Token",
         function="allowance",
-        args={"owner": Address, "spender": Address}
+        args={"owner": Address, "spender": Address},
     )
     increase_allowance = ContractTransaction(
         contract="Token",
@@ -148,6 +148,13 @@ class BlockchainRequest:
         args={"assertionId": bytes | HexStr},
     )
 
+    # Identity
+    get_identity_id = ContractCall(
+        contract="IdentityStorage",
+        function="getIdentityId",
+        args={"operational": Address},
+    )
+
     # Paranets
     register_paranet = ContractTransaction(
         contract="Paranet",
@@ -157,8 +164,121 @@ class BlockchainRequest:
             "paranetKATokenId": int,
             "paranetName": str,
             "paranetDescription": str,
+            "nodesAccessPolicy": int,
+            "minersAccessPolicy": int,
+        },
+    )
+
+    add_paranet_curated_nodes = ContractTransaction(
+        contract="Paranet",
+        function="addParanetCuratedNodes",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "identityIds": list[int],
+        },
+    )
+
+    remove_paranet_curated_nodes = ContractTransaction(
+        contract="Paranet",
+        function="removeParanetCuratedNodes",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "identityIds": list[int],
+        },
+    )
+
+    request_paranet_curated_node_access = ContractTransaction(
+        contract="Paranet",
+        function="requestParanetCuratedNodeAccess",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+        },
+    )
+
+    approve_curated_node = ContractTransaction(
+        contract="Paranet",
+        function="approveCuratedNode",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "identityId": int,
         },
     )
+
+    reject_curated_node = ContractTransaction(
+        contract="Paranet",
+        function="rejectCuratedNode",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "identityId": int,
+        },
+    )
+
+    get_curated_nodes = ContractCall(
+        contract="ParanetsRegistry",
+        function="getCuratedNodes",
+        args={"paranetId": HexStr},
+    )
+
+    add_paranet_curated_miners = ContractTransaction(
+        contract="Paranet",
+        function="addParanetCuratedMiners",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "minerAddresses": list[Address],
+        },
+    )
+
+    remove_paranet_curated_miners = ContractTransaction(
+        contract="Paranet",
+        function="removeParanetCuratedMiners",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "minerAddresses": list[Address],
+        },
+    )
+
+    request_paranet_curated_miner_access = ContractTransaction(
+        contract="Paranet",
+        function="requestParanetCuratedMinerAccess",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+        },
+    )
+
+    approve_curated_miner = ContractTransaction(
+        contract="Paranet",
+        function="approveCuratedMiner",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "minerAddress": Address,
+        },
+    )
+
+    reject_curated_miner = ContractTransaction(
+        contract="Paranet",
+        function="rejectCuratedMiner",
+        args={
+            "paranetKAStorageContract": Address,
+            "paranetKATokenId": int,
+            "minerAddress": Address,
+        },
+    )
+
+    get_knowledge_miners = ContractCall(
+        contract="ParanetsRegistry",
+        function="getKnowledgeMiners",
+        args={"paranetId": HexStr},
+    )
+
     add_paranet_services = ContractTransaction(
         contract="Paranet",
         function="addParanetServices",