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

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
     )
@@ -424,37 +758,6 @@ 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,

dkg/providers/blockchain.py

@@ -17,13 +17,14 @@
 
 import json
 import os
+from dotenv import load_dotenv
 from collections import namedtuple
 from functools import wraps
 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 +33,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:
@@ -48,7 +50,6 @@ class BlockchainProvider:
         environment: Environment,
         blockchain_id: str,
         rpc_uri: URI | None = None,
-        private_key: DataHexStr | None = None,
         gas_price: Wei | None = None,
         verify: bool = True,
     ):
@@ -105,11 +106,9 @@ class BlockchainProvider:
         }
         self._init_contracts()
 
-        if (
-            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)
+        load_dotenv()
+        if private_key := os.environ.get("PRIVATE_KEY"):
+            self.set_account(private_key)
 
     def make_json_rpc_request(self, endpoint: str, args: dict[str, Any] = {}) -> Any:
         web3_method = getattr(self.w3.eth, endpoint)
@@ -181,13 +180,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 +205,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 +215,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 +240,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():
@@ -262,11 +258,14 @@ class BlockchainProvider:
         ):
             self.contracts[contract] = self.w3.eth.contract(
                 address=(
-                    self.contracts["Hub"].functions.getContractAddress(contract).call()
-                    if not contract.endswith("AssetStorage")
-                    else self.contracts["Hub"]
+                    self.contracts["Hub"]
                     .functions.getAssetStorageAddress(contract)
                     .call()
+                    if contract.endswith("AssetStorage")
+                    or contract.endswith("CollectionStorage")
+                    else self.contracts["Hub"]
+                    .functions.getContractAddress(contract)
+                    .call()
                 ),
                 abi=self.abi[contract],
                 decode_tuples=True,

dkg/providers/node_http.py

@@ -25,9 +25,14 @@ from requests.exceptions import HTTPError, ConnectionError, Timeout, RequestExce
 
 
 class NodeHTTPProvider:
-    def __init__(self, endpoint_uri: URI | str, auth_token: str | None = None):
-        self.endpoint_uri = URI(endpoint_uri)
-        self.auth_token = auth_token
+    def __init__(
+        self,
+        endpoint_uri: URI | str,
+        api_version: str = "v1",
+        auth_token: str | None = None,
+    ):
+        self.url = f"{URI(endpoint_uri)}/{api_version}"
+        self.headers = {"Authorization": f"Bearer {auth_token}"} if auth_token else {}
 
     def make_request(
         self,
@@ -36,16 +41,13 @@ class NodeHTTPProvider:
         params: dict[str, Any] = {},
         data: dict[str, Any] = {},
     ) -> NodeResponseDict:
-        url = f"{self.endpoint_uri}/{path}"
-        headers = (
-            {"Authorization": f"Bearer {self.auth_token}"} if self.auth_token else {}
-        )
+        url = f"{self.url}/{path}"
 
         try:
             if method == HTTPRequestMethod.GET:
-                response = requests.get(url, params=params, headers=headers)
+                response = requests.get(url, params=params, headers=self.headers)
             elif method == HTTPRequestMethod.POST:
-                response = requests.post(url, json=data, headers=headers)
+                response = requests.post(url, json=data, headers=self.headers)
             else:
                 raise HTTPRequestMethodNotSupported(
                     f"{method.name} method isn't supported"