dkg 8.0.0a3__py3-none-any.whl → 8.0.1__py3-none-any.whl

dkg/providers/blockchain/base_blockchain.py

@@ -0,0 +1,102 @@
+import json
+from collections import namedtuple
+from pathlib import Path
+from typing import Any, Type
+
+from dkg.constants import BLOCKCHAINS
+from dkg.exceptions import (
+    EnvironmentNotSupported,
+    RPCURINotDefined,
+)
+from dkg.types import URI, DataHexStr, Environment, Wei
+from eth_account.signers.local import LocalAccount
+from eth_typing import ABI, ABIFunction
+from web3.logs import DISCARD
+from web3.middleware import SignAndSendRawMiddlewareBuilder
+from web3.types import TxReceipt
+
+
+class BaseBlockchainProvider:
+    CONTRACTS_METADATA_DIR = Path(__file__).parents[2] / "data/interfaces"
+
+    def __init__(
+        self,
+        environment: Environment,
+        blockchain_id: str,
+        rpc_uri: URI | None = None,
+        gas_price: Wei | None = None,
+    ):
+        if environment not in BLOCKCHAINS.keys():
+            raise EnvironmentNotSupported(f"Environment {environment} isn't supported!")
+
+        self.environment = environment
+        self.rpc_uri = rpc_uri
+        self.blockchain_id = (
+            blockchain_id
+            if blockchain_id in BLOCKCHAINS[self.environment].keys()
+            else None
+        )
+
+        if self.rpc_uri is None and self.blockchain_id is not None:
+            self.blockchain_id = blockchain_id
+            self.rpc_uri = self.rpc_uri or BLOCKCHAINS[self.environment][
+                self.blockchain_id
+            ].get("rpc", None)
+
+        if self.rpc_uri is None:
+            raise RPCURINotDefined(
+                "No RPC URI provided for unrecognized "
+                f"blockchain ID {self.blockchain_id}"
+            )
+
+        self.gas_price = gas_price
+
+        self.abi = self._load_abi()
+        self.output_named_tuples = self._generate_output_named_tuples()
+
+    def _generate_output_named_tuples(self) -> dict[str, dict[str, Type[tuple]]]:
+        def generate_output_namedtuple(function_abi: ABIFunction) -> Type[tuple] | None:
+            output_names = [output["name"] for output in function_abi["outputs"]]
+            if all(name != "" for name in output_names):
+                return namedtuple(f"{function_abi['name']}Result", output_names)
+            return None
+
+        output_named_tuples = {}
+        for contract_name, contract_abi in self.abi.items():
+            output_named_tuples[contract_name] = {}
+            for item in contract_abi:
+                if (item["type"] != "function") or not item["outputs"]:
+                    continue
+                elif item["name"] in output_named_tuples[contract_name]:
+                    continue
+                named_tuple = generate_output_namedtuple(item)
+                if named_tuple is not None:
+                    output_named_tuples[contract_name][item["name"]] = named_tuple
+
+        return output_named_tuples
+
+    def _load_abi(self) -> ABI:
+        abi = {}
+
+        for contract_metadata in self.CONTRACTS_METADATA_DIR.glob("*.json"):
+            with open(contract_metadata, "r") as metadata_json:
+                abi[contract_metadata.stem] = json.load(metadata_json)
+
+        return abi
+
+    def decode_logs_event(
+        self, receipt: TxReceipt, contract_name: str, event_name: str
+    ) -> Any:
+        return (
+            self.contracts[contract_name]
+            .events[event_name]()
+            .process_receipt(receipt, errors=DISCARD)
+        )
+
+    def set_account(self, private_key: DataHexStr):
+        self.account: LocalAccount = self.w3.eth.account.from_key(private_key)
+        self.w3.middleware_onion.inject(
+            SignAndSendRawMiddlewareBuilder.build(private_key),
+            layer=0,
+        )
+        self.w3.eth.default_account = self.account.address

dkg/providers/{blockchain.py → blockchain/blockchain.py}

@@ -15,66 +15,35 @@
 # specific language governing permissions and limitations
 # under the License.
 
-import json
 import os
-from collections import namedtuple
+from dotenv import load_dotenv
 from functools import wraps
-from pathlib import Path
-from typing import Any, Type
+from typing import Any
 
 import requests
 from dkg.constants import BLOCKCHAINS
 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 eth_typing import ABI, ABIFunction
+from dkg.types import URI, Address, Environment, Wei
 from web3 import Web3
 from web3.contract import Contract
 from web3.contract.contract import ContractFunction
-from web3.logs import DISCARD
-from web3.middleware import SignAndSendRawMiddlewareBuilder
 from web3.types import TxReceipt
+from dkg.providers.blockchain.base_blockchain import BaseBlockchainProvider
 
 
-class BlockchainProvider:
-    CONTRACTS_METADATA_DIR = Path(__file__).parents[1] / "data/interfaces"
-
+class BlockchainProvider(BaseBlockchainProvider):
     def __init__(
         self,
         environment: Environment,
         blockchain_id: str,
         rpc_uri: URI | None = None,
-        private_key: DataHexStr | None = None,
         gas_price: Wei | None = None,
         verify: bool = True,
     ):
-        if environment not in BLOCKCHAINS.keys():
-            raise EnvironmentNotSupported(f"Environment {environment} isn't supported!")
-
-        self.environment = environment
-        self.rpc_uri = rpc_uri
-        self.blockchain_id = (
-            blockchain_id
-            if blockchain_id in BLOCKCHAINS[self.environment].keys()
-            else None
-        )
-
-        if self.rpc_uri is None and self.blockchain_id is not None:
-            self.blockchain_id = blockchain_id
-            self.rpc_uri = self.rpc_uri or BLOCKCHAINS[self.environment][
-                self.blockchain_id
-            ].get("rpc", None)
-
-        if self.rpc_uri is None:
-            raise RPCURINotDefined(
-                "No RPC URI provided for unrecognized "
-                f"blockchain ID {self.blockchain_id}"
-            )
+        super().__init__(environment, blockchain_id, rpc_uri, gas_price)
 
         self.w3 = Web3(
             Web3.HTTPProvider(self.rpc_uri, request_kwargs={"verify": verify})
@@ -87,15 +56,11 @@ class BlockchainProvider:
                     f"Network with blockchain ID {self.blockchain_id} isn't supported!"
                 )
 
-        self.gas_price = gas_price
         self.gas_price_oracle = BLOCKCHAINS[self.environment][self.blockchain_id].get(
             "gas_price_oracle",
             None,
         )
 
-        self.abi = self._load_abi()
-        self.output_named_tuples = self._generate_output_named_tuples()
-
         hub_address: Address = BLOCKCHAINS[self.environment][self.blockchain_id]["hub"]
         self.contracts: dict[str, Contract] = {
             "Hub": self.w3.eth.contract(
@@ -106,11 +71,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)
@@ -196,23 +159,6 @@ class BlockchainProvider:
 
             return tx_receipt
 
-    def decode_logs_event(
-        self, receipt: TxReceipt, contract_name: str, event_name: str
-    ) -> Any:
-        return (
-            self.contracts[contract_name]
-            .events[event_name]()
-            .process_receipt(receipt, errors=DISCARD)
-        )
-
-    def set_account(self, private_key: DataHexStr):
-        self.account: LocalAccount = self.w3.eth.account.from_key(private_key)
-        self.w3.middleware_onion.inject(
-            SignAndSendRawMiddlewareBuilder.build(private_key),
-            layer=0,
-        )
-        self.w3.eth.default_account = self.account.address
-
     def _get_network_gas_price(self) -> Wei | None:
         if self.environment == "development":
             return None
@@ -260,11 +206,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,
@@ -277,33 +226,3 @@ class BlockchainProvider:
             return self.call_function(contract, "status")
         except Exception:
             return False
-
-    def _generate_output_named_tuples(self) -> dict[str, dict[str, Type[tuple]]]:
-        def generate_output_namedtuple(function_abi: ABIFunction) -> Type[tuple] | None:
-            output_names = [output["name"] for output in function_abi["outputs"]]
-            if all(name != "" for name in output_names):
-                return namedtuple(f"{function_abi['name']}Result", output_names)
-            return None
-
-        output_named_tuples = {}
-        for contract_name, contract_abi in self.abi.items():
-            output_named_tuples[contract_name] = {}
-            for item in contract_abi:
-                if (item["type"] != "function") or not item["outputs"]:
-                    continue
-                elif item["name"] in output_named_tuples[contract_name]:
-                    continue
-                named_tuple = generate_output_namedtuple(item)
-                if named_tuple is not None:
-                    output_named_tuples[contract_name][item["name"]] = named_tuple
-
-        return output_named_tuples
-
-    def _load_abi(self) -> ABI:
-        abi = {}
-
-        for contract_metadata in self.CONTRACTS_METADATA_DIR.glob("*.json"):
-            with open(contract_metadata, "r") as metadata_json:
-                abi[contract_metadata.stem] = json.load(metadata_json)
-
-        return abi

dkg/providers/node/__init__.py

@@ -0,0 +1,4 @@
+from .node_http import NodeHTTPProvider
+from .async_node_http import AsyncNodeHTTPProvider
+
+__all__ = ["NodeHTTPProvider", "AsyncNodeHTTPProvider"]

dkg/providers/node/async_node_http.py

@@ -0,0 +1,72 @@
+# 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 typing import Any
+
+import aiohttp
+from dkg.dataclasses import HTTPRequestMethod, NodeResponseDict
+from dkg.exceptions import HTTPRequestMethodNotSupported, NodeRequestError
+from dkg.types import URI
+from dkg.providers.node.base_node_http import BaseNodeHTTPProvider
+
+
+class AsyncNodeHTTPProvider(BaseNodeHTTPProvider):
+    def __init__(
+        self,
+        endpoint_uri: URI | str,
+        api_version: str = "v1",
+        auth_token: str | None = None,
+    ):
+        super().__init__(endpoint_uri, api_version, auth_token)
+
+    async def make_request(
+        self,
+        method: HTTPRequestMethod,
+        path: str,
+        params: dict[str, Any] = {},
+        data: dict[str, Any] = {},
+    ) -> NodeResponseDict:
+        url = f"{self.url}/{path}"
+
+        async with aiohttp.ClientSession() as session:
+            try:
+                if method == HTTPRequestMethod.GET:
+                    async with session.get(
+                        url, params=params, headers=self.headers
+                    ) as response:
+                        response.raise_for_status()
+                        response = await response.json()
+                elif method == HTTPRequestMethod.POST:
+                    async with session.post(
+                        url, json=data, headers=self.headers
+                    ) as response:
+                        response.raise_for_status()
+                        response = await response.json()
+                else:
+                    raise HTTPRequestMethodNotSupported(
+                        f"{method.name} method isn't supported"
+                    )
+
+                try:
+                    return NodeResponseDict(response)
+                except ValueError as err:
+                    raise NodeRequestError(f"JSON decoding failed: {err}")
+
+            except aiohttp.ClientError as err:
+                raise NodeRequestError(f"Network error: {err}")
+            except Exception as err:
+                raise NodeRequestError(f"Unexpected error: {err}")

dkg/providers/node/base_node_http.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from dkg.dataclasses import HTTPRequestMethod, NodeResponseDict
+from typing import Any
+from dkg.types import URI
+
+
+class BaseNodeHTTPProvider(ABC):
+    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 {}
+
+    @abstractmethod
+    async def make_request(
+        self,
+        method: HTTPRequestMethod,
+        path: str,
+        params: dict[str, Any] = {},
+        data: dict[str, Any] = {},
+    ) -> NodeResponseDict:
+        raise NotImplementedError("Subclasses must implement make_request")

dkg/providers/{node_http.py → node/node_http.py}

@@ -22,12 +22,17 @@ from dkg.dataclasses import HTTPRequestMethod, NodeResponseDict
 from dkg.exceptions import HTTPRequestMethodNotSupported, NodeRequestError
 from dkg.types import URI
 from requests.exceptions import HTTPError, ConnectionError, Timeout, RequestException
+from dkg.providers.node.base_node_http import BaseNodeHTTPProvider
 
 
-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
+class NodeHTTPProvider(BaseNodeHTTPProvider):
+    def __init__(
+        self,
+        endpoint_uri: URI | str,
+        api_version: str = "v1",
+        auth_token: str | None = None,
+    ):
+        super().__init__(endpoint_uri, api_version, auth_token)
 
     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"

dkg/services/blockchain_services/async_blockchain_service.py

@@ -0,0 +1,180 @@
+from dkg.modules.async_module import AsyncModule
+from dkg.managers.async_manager import AsyncRequestManager
+from dkg.utils.blockchain_request import BlockchainRequest
+from dkg.method import Method
+from dkg.constants import ZERO_ADDRESS
+from web3 import Web3
+from typing import Optional
+from dkg.types import Address, UAL
+from dkg.utils.blockchain_request import KnowledgeCollectionResult, AllowanceResult
+from dkg.utils.ual import parse_ual
+
+
+class AsyncBlockchainService(AsyncModule):
+    def __init__(self, manager: AsyncRequestManager):
+        self.manager = manager
+
+    _owner = Method(BlockchainRequest.owner_of)
+    _get_contract_address = Method(BlockchainRequest.get_contract_address)
+    _get_current_allowance = Method(BlockchainRequest.allowance)
+    _increase_allowance = Method(BlockchainRequest.increase_allowance)
+    _decrease_allowance = Method(BlockchainRequest.decrease_allowance)
+    _create_knowledge_collection = Method(BlockchainRequest.create_knowledge_collection)
+    _mint_knowledge_asset = Method(BlockchainRequest.mint_knowledge_asset)
+    _get_asset_storage_address = Method(BlockchainRequest.get_asset_storage_address)
+    _key_is_operational_wallet = Method(BlockchainRequest.key_is_operational_wallet)
+    _time_until_next_epoch = Method(BlockchainRequest.time_until_next_epoch)
+    _epoch_length = Method(BlockchainRequest.epoch_length)
+    _get_stake_weighted_average_ask = Method(
+        BlockchainRequest.get_stake_weighted_average_ask
+    )
+    _get_block = Method(BlockchainRequest.get_block)
+
+    async def decrease_knowledge_collection_allowance(
+        self,
+        allowance_gap: int,
+    ):
+        knowledge_collection_address = await self._get_contract_address(
+            "KnowledgeCollection"
+        )
+        await self._decrease_allowance(knowledge_collection_address, allowance_gap)
+
+    async def increase_knowledge_collection_allowance(
+        self,
+        sender: str,
+        token_amount: str,
+    ) -> AllowanceResult:
+        """
+        Increases the allowance for knowledge collection if necessary.
+
+        Args:
+            sender: The address of the sender
+            token_amount: The amount of tokens to check/increase allowance for
+
+        Returns:
+            AllowanceResult containing whether allowance was increased and the gap
+        """
+        knowledge_collection_address = await self._get_contract_address(
+            "KnowledgeCollection"
+        )
+
+        allowance = await self._get_current_allowance(
+            sender, knowledge_collection_address
+        )
+        allowance_gap = int(token_amount) - int(allowance)
+
+        if allowance_gap > 0:
+            await self._increase_allowance(knowledge_collection_address, allowance_gap)
+
+            return AllowanceResult(
+                allowance_increased=True, allowance_gap=allowance_gap
+            )
+
+        return AllowanceResult(allowance_increased=False, allowance_gap=allowance_gap)
+
+    async def create_knowledge_collection(
+        self,
+        request: dict,
+        paranet_ka_contract: Optional[Address] = None,
+        paranet_token_id: Optional[int] = None,
+    ) -> KnowledgeCollectionResult:
+        """
+        Creates a knowledge collection on the blockchain.
+
+        Args:
+            request: dict containing all collection parameters
+            paranet_ka_contract: Optional paranet contract address
+            paranet_token_id: Optional paranet token ID
+            blockchain: Blockchain configuration
+
+        Returns:
+            KnowledgeCollectionResult containing collection ID and transaction receipt
+
+        Raises:
+            BlockchainError: If the collection creation fails
+        """
+        sender = self.manager.blockchain_provider.account.address
+        allowance_increased = False
+        allowance_gap = 0
+
+        try:
+            # Handle allowance
+            if request.get("paymaster") and request.get("paymaster") != ZERO_ADDRESS:
+                pass
+            else:
+                allowance_result = await self.increase_knowledge_collection_allowance(
+                    sender=sender,
+                    token_amount=request.get("tokenAmount"),
+                )
+                allowance_increased = allowance_result.allowance_increased
+                allowance_gap = allowance_result.allowance_gap
+
+            if not paranet_ka_contract and not paranet_token_id:
+                receipt = await self._create_knowledge_collection(
+                    request.get("publishOperationId"),
+                    Web3.to_bytes(hexstr=request.get("merkleRoot")),
+                    request.get("knowledgeAssetsAmount"),
+                    request.get("byteSize"),
+                    request.get("epochs"),
+                    request.get("tokenAmount"),
+                    request.get("isImmutable"),
+                    request.get("paymaster"),
+                    request.get("publisherNodeIdentityId"),
+                    Web3.to_bytes(hexstr=request.get("publisherNodeR")),
+                    Web3.to_bytes(hexstr=request.get("publisherNodeVS")),
+                    request.get("identityIds"),
+                    [Web3.to_bytes(hexstr=x) for x in request.get("r")],
+                    [Web3.to_bytes(hexstr=x) for x in request.get("vs")],
+                )
+            else:
+                receipt = await self._mint_knowledge_asset(
+                    paranet_ka_contract,
+                    paranet_token_id,
+                    list(request.values()),
+                )
+
+            event_data = self.manager.blockchain_provider.decode_logs_event(
+                receipt=receipt,
+                contract_name="KnowledgeCollectionStorage",
+                event_name="KnowledgeCollectionCreated",
+            )
+            collection_id = (
+                int(getattr(event_data[0].get("args", {}), "id", None))
+                if event_data
+                else None
+            )
+
+            return KnowledgeCollectionResult(
+                knowledge_collection_id=collection_id, receipt=receipt
+            )
+
+        except Exception as e:
+            if allowance_increased:
+                await self.decrease_knowledge_collection_allowance(allowance_gap)
+            raise e
+
+    # TODO: change self._owner to v8 compatible function
+    async def get_owner(self, ual: UAL) -> Address:
+        token_id = parse_ual(ual)["token_id"]
+
+        return await self._owner(token_id)
+
+    async def get_asset_storage_address(self, asset_storage_name: str) -> Address:
+        return await self._get_asset_storage_address(asset_storage_name)
+
+    async def key_is_operational_wallet(
+        self, identity_id: int, key: Address, purpose: int
+    ) -> bool:
+        return await self._key_is_operational_wallet(identity_id, key, purpose)
+
+    async def time_until_next_epoch(self) -> int:
+        return await self._time_until_next_epoch()
+
+    async def epoch_length(self) -> int:
+        return await self._epoch_length()
+
+    async def get_stake_weighted_average_ask(self) -> int:
+        return await self._get_stake_weighted_average_ask()
+
+    async def get_block(self, block_identifier: str | int):
+        return await self._get_block(block_identifier)