chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/daemon/windows_signal.py

@@ -21,8 +21,8 @@ else:
     import threading
 
     sigmap = {
-        signal.SIGINT: signal.CTRL_C_EVENT,  # pylint: disable=E1101
-        signal.SIGBREAK: signal.CTRL_BREAK_EVENT,  # pylint: disable=E1101
+        signal.SIGINT: signal.CTRL_C_EVENT,
+        signal.SIGBREAK: signal.CTRL_BREAK_EVENT,
     }
 
     def kill(pid: int, signum: signal.Signals) -> None:

chia/data_layer/data_layer.py

@@ -10,22 +10,9 @@ import os
 import random
 import time
 import traceback
+from collections.abc import AsyncIterator, Awaitable
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncIterator,
-    Awaitable,
-    ClassVar,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Union,
-    cast,
-    final,
-)
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast, final
 
 import aiohttp
 
@@ -76,13 +63,14 @@ from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.async_pool import Job, QueuedAsyncPool
 from chia.util.ints import uint32, uint64
 from chia.util.path import path_from_root
+from chia.util.task_referencer import create_referenced_task
 from chia.wallet.trade_record import TradeRecord
 from chia.wallet.trading.offer import Offer as TradingOffer
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 
 
-async def get_plugin_info(plugin_remote: PluginRemote) -> Tuple[PluginRemote, Dict[str, Any]]:
+async def get_plugin_info(plugin_remote: PluginRemote) -> tuple[PluginRemote, dict[str, Any]]:
     try:
         async with aiohttp.ClientSession() as session:
             async with session.post(
@@ -107,17 +95,17 @@ class DataLayer:
         _protocol_check: ClassVar[RpcServiceProtocol] = cast("DataLayer", None)
 
     db_path: Path
-    config: Dict[str, Any]
+    config: dict[str, Any]
     root_path: Path
     log: logging.Logger
     wallet_rpc_init: Awaitable[WalletRpcClient]
-    downloaders: List[PluginRemote]
-    uploaders: List[PluginRemote]
+    downloaders: list[PluginRemote]
+    uploaders: list[PluginRemote]
     maximum_full_file_count: int
     server_files_location: Path
-    unsubscribe_data_queue: List[UnsubscribeData]
+    unsubscribe_data_queue: list[UnsubscribeData]
     _server: Optional[ChiaServer] = None
-    none_bytes: bytes32 = bytes32([0] * 32)
+    none_bytes: bytes32 = bytes32.zeros
     initialized: bool = False
     _data_store: Optional[DataStore] = None
     state_changed_callback: Optional[StateChangedProtocol] = None
@@ -161,11 +149,11 @@ class DataLayer:
     @classmethod
     def create(
         cls,
-        config: Dict[str, Any],
+        config: dict[str, Any],
         root_path: Path,
         wallet_rpc_init: Awaitable[WalletRpcClient],
-        downloaders: List[PluginRemote],
-        uploaders: List[PluginRemote],  # dont add FilesystemUploader to this, it is the default uploader
+        downloaders: list[PluginRemote],
+        uploaders: list[PluginRemote],  # dont add FilesystemUploader to this, it is the default uploader
         name: Optional[str] = None,
     ) -> DataLayer:
         if name == "":
@@ -213,7 +201,7 @@ class DataLayer:
             self._wallet_rpc = await self.wallet_rpc_init
 
             await self._data_store.migrate_db()
-            self.periodically_manage_data_task = asyncio.create_task(self.periodically_manage_data())
+            self.periodically_manage_data_task = create_referenced_task(self.periodically_manage_data())
             try:
                 yield
             finally:
@@ -236,7 +224,7 @@ class DataLayer:
     async def on_connect(self, connection: WSChiaConnection) -> None:
         pass
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> List[Dict[str, Any]]:
+    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     def set_server(self, server: ChiaServer) -> None:
@@ -250,9 +238,7 @@ class DataLayer:
 
         return result.fingerprint
 
-    async def create_store(
-        self, fee: uint64, root: bytes32 = bytes32([0] * 32)
-    ) -> Tuple[List[TransactionRecord], bytes32]:
+    async def create_store(self, fee: uint64, root: bytes32 = bytes32.zeros) -> tuple[list[TransactionRecord], bytes32]:
         txs, store_id = await self.wallet_rpc.create_new_dl(root, fee)
         res = await self.data_store.create_tree(store_id=store_id)
         if res is None:
@@ -263,7 +249,7 @@ class DataLayer:
     async def batch_update(
         self,
         store_id: bytes32,
-        changelist: List[Dict[str, Any]],
+        changelist: list[dict[str, Any]],
         fee: uint64,
         submit_on_chain: bool = True,
     ) -> Optional[TransactionRecord]:
@@ -287,11 +273,11 @@ class DataLayer:
 
     async def multistore_batch_update(
         self,
-        store_updates: List[Dict[str, Any]],
+        store_updates: list[dict[str, Any]],
         fee: uint64,
         submit_on_chain: bool = True,
-    ) -> List[TransactionRecord]:
-        store_ids: Set[bytes32] = set()
+    ) -> list[TransactionRecord]:
+        store_ids: set[bytes32] = set()
         for update in store_updates:
             store_id = update["store_id"]
             changelist = update["changelist"]
@@ -306,7 +292,7 @@ class DataLayer:
         await self.data_store.clean_node_table()
 
         if submit_on_chain:
-            update_dictionary: Dict[bytes32, bytes32] = {}
+            update_dictionary: dict[bytes32, bytes32] = {}
             for store_id in store_ids:
                 await self._update_confirmation_status(store_id=store_id)
                 root_hash = await self._get_publishable_root_hash(store_id=store_id)
@@ -332,9 +318,9 @@ class DataLayer:
         await self.data_store.change_root_status(pending_root, Status.PENDING)
         return await self.publish_update(store_id, fee)
 
-    async def submit_all_pending_roots(self, fee: uint64) -> List[TransactionRecord]:
+    async def submit_all_pending_roots(self, fee: uint64) -> list[TransactionRecord]:
         pending_roots = await self.data_store.get_all_pending_batches_roots()
-        update_dictionary: Dict[bytes32, bytes32] = {}
+        update_dictionary: dict[bytes32, bytes32] = {}
         if len(pending_roots) == 0:
             raise Exception("No pending roots found to submit")
         for pending_root in pending_roots:
@@ -347,7 +333,7 @@ class DataLayer:
     async def batch_insert(
         self,
         store_id: bytes32,
-        changelist: List[Dict[str, Any]],
+        changelist: list[dict[str, Any]],
         status: Status = Status.PENDING,
         enable_batch_autoinsert: Optional[bool] = None,
     ) -> bytes32:
@@ -359,7 +345,7 @@ class DataLayer:
                 raise Exception("Already have a pending root waiting for confirmation.")
 
             # check before any DL changes that this singleton is currently owned by this wallet
-            singleton_records: List[SingletonRecord] = await self.get_owned_stores()
+            singleton_records: list[SingletonRecord] = await self.get_owned_stores()
             if not any(store_id == singleton.launcher_id for singleton in singleton_records):
                 raise ValueError(f"Singleton with launcher ID {store_id} is not owned by DL Wallet")
 
@@ -417,7 +403,7 @@ class DataLayer:
         self,
         store_id: bytes32,
         root_hash: Union[bytes32, Unspecified],
-    ) -> List[TerminalNode]:
+    ) -> list[TerminalNode]:
         await self._update_confirmation_status(store_id=store_id)
 
         res = await self.data_store.get_keys_values(store_id, root_hash)
@@ -439,7 +425,7 @@ class DataLayer:
         res = await self.data_store.get_keys_values_paginated(store_id, page, max_page_size, root_hash)
         return res
 
-    async def get_keys(self, store_id: bytes32, root_hash: Union[bytes32, Unspecified]) -> List[bytes]:
+    async def get_keys(self, store_id: bytes32, root_hash: Union[bytes32, Unspecified]) -> list[bytes]:
         await self._update_confirmation_status(store_id=store_id)
 
         res = await self.data_store.get_keys(store_id, root_hash)
@@ -459,7 +445,7 @@ class DataLayer:
         res = await self.data_store.get_keys_paginated(store_id, page, max_page_size, root_hash)
         return res
 
-    async def get_ancestors(self, node_hash: bytes32, store_id: bytes32) -> List[InternalNode]:
+    async def get_ancestors(self, node_hash: bytes32, store_id: bytes32) -> list[InternalNode]:
         await self._update_confirmation_status(store_id=store_id)
 
         res = await self.data_store.get_ancestors(node_hash=node_hash, store_id=store_id)
@@ -482,7 +468,7 @@ class DataLayer:
             return None
         return res.node_hash
 
-    async def get_root_history(self, store_id: bytes32) -> List[SingletonRecord]:
+    async def get_root_history(self, store_id: bytes32) -> list[SingletonRecord]:
         records = await self.wallet_rpc.dl_history(store_id)
         if records is None:
             self.log.error(f"Failed to get root history for {store_id.hex()}")
@@ -793,7 +779,7 @@ class DataLayer:
                         else:
                             self.log.debug(f"uploaded to uploader {uploader}")
 
-    async def subscribe(self, store_id: bytes32, urls: List[str]) -> Subscription:
+    async def subscribe(self, store_id: bytes32, urls: list[str]) -> Subscription:
         parsed_urls = [url.rstrip("/") for url in urls]
         subscription = Subscription(store_id, [ServerInfo(url, 0, 0) for url in parsed_urls])
         await self.wallet_rpc.dl_track_new(subscription.store_id)
@@ -802,7 +788,7 @@ class DataLayer:
         self.log.info(f"Done adding subscription: {subscription.store_id}")
         return subscription
 
-    async def remove_subscriptions(self, store_id: bytes32, urls: List[str]) -> None:
+    async def remove_subscriptions(self, store_id: bytes32, urls: list[str]) -> None:
         parsed_urls = [url.rstrip("/") for url in urls]
         async with self.subscription_lock:
             await self.data_store.remove_subscriptions(store_id, parsed_urls)
@@ -821,7 +807,7 @@ class DataLayer:
         subscriptions = await self.data_store.get_subscriptions()
         if store_id not in (subscription.store_id for subscription in subscriptions):
             raise RuntimeError("No subscription found for the given store_id.")
-        paths: List[Path] = []
+        paths: list[Path] = []
         if await self.data_store.store_id_exists(store_id) and not retain_data:
             generation = await self.data_store.get_tree_generation(store_id)
             all_roots = await self.data_store.get_roots_between(store_id, 1, generation + 1)
@@ -860,11 +846,11 @@ class DataLayer:
             except FileNotFoundError:
                 pass
 
-    async def get_subscriptions(self) -> List[Subscription]:
+    async def get_subscriptions(self) -> list[Subscription]:
         async with self.subscription_lock:
             return await self.data_store.get_subscriptions()
 
-    async def add_mirror(self, store_id: bytes32, urls: List[str], amount: uint64, fee: uint64) -> None:
+    async def add_mirror(self, store_id: bytes32, urls: list[str], amount: uint64, fee: uint64) -> None:
         if not urls:
             raise RuntimeError("URL list can't be empty")
         bytes_urls = [bytes(url, "utf8") for url in urls]
@@ -873,22 +859,22 @@ class DataLayer:
     async def delete_mirror(self, coin_id: bytes32, fee: uint64) -> None:
         await self.wallet_rpc.dl_delete_mirror(coin_id, fee)
 
-    async def get_mirrors(self, store_id: bytes32) -> List[Mirror]:
-        mirrors: List[Mirror] = await self.wallet_rpc.dl_get_mirrors(store_id)
+    async def get_mirrors(self, store_id: bytes32) -> list[Mirror]:
+        mirrors: list[Mirror] = await self.wallet_rpc.dl_get_mirrors(store_id)
         return [mirror for mirror in mirrors if mirror.urls]
 
     async def update_subscriptions_from_wallet(self, store_id: bytes32) -> None:
-        mirrors: List[Mirror] = await self.wallet_rpc.dl_get_mirrors(store_id)
-        urls: List[str] = []
+        mirrors: list[Mirror] = await self.wallet_rpc.dl_get_mirrors(store_id)
+        urls: list[str] = []
         for mirror in mirrors:
-            urls = urls + [url.decode("utf8") for url in mirror.urls]
+            urls += [url.decode("utf8") for url in mirror.urls]
         urls = [url.rstrip("/") for url in urls]
         await self.data_store.update_subscriptions_from_wallet(store_id, urls)
 
-    async def get_owned_stores(self) -> List[SingletonRecord]:
+    async def get_owned_stores(self) -> list[SingletonRecord]:
         return await self.wallet_rpc.dl_owned_singletons()
 
-    async def get_kv_diff(self, store_id: bytes32, hash_1: bytes32, hash_2: bytes32) -> Set[DiffData]:
+    async def get_kv_diff(self, store_id: bytes32, hash_1: bytes32, hash_2: bytes32) -> set[DiffData]:
         return await self.data_store.get_kv_diff(store_id, hash_1, hash_2)
 
     async def get_kv_diff_paginated(
@@ -935,10 +921,14 @@ class DataLayer:
             # Need this to make sure we process updates and generate DAT files
             try:
                 owned_stores = await self.get_owned_stores()
-            except ValueError:
+            except (ValueError, aiohttp.client_exceptions.ClientConnectorError):
                 # Sometimes the DL wallet isn't available, so we can't get the owned stores.
                 # We'll try again next time.
                 owned_stores = []
+            except Exception as e:
+                self.log.error(f"Exception while fetching owned stores: {type(e)} {e} {traceback.format_exc()}")
+                owned_stores = []
+
             subscription_store_ids = {subscription.store_id for subscription in subscriptions}
             for record in owned_stores:
                 store_id = record.launcher_id
@@ -1006,10 +996,10 @@ class DataLayer:
     async def build_offer_changelist(
         self,
         store_id: bytes32,
-        inclusions: Tuple[KeyValue, ...],
-    ) -> List[Dict[str, Any]]:
+        inclusions: tuple[KeyValue, ...],
+    ) -> list[dict[str, Any]]:
         async with self.data_store.transaction():
-            changelist: List[Dict[str, Any]] = []
+            changelist: list[dict[str, Any]] = []
             for entry in inclusions:
                 try:
                     existing_value = await self.get_value(store_id=store_id, key=entry.key)
@@ -1039,12 +1029,12 @@ class DataLayer:
 
             return changelist
 
-    async def process_offered_stores(self, offer_stores: Tuple[OfferStore, ...]) -> Dict[bytes32, StoreProofs]:
+    async def process_offered_stores(self, offer_stores: tuple[OfferStore, ...]) -> dict[bytes32, StoreProofs]:
         for offer_store in offer_stores:
             await self._update_confirmation_status(store_id=offer_store.store_id)
 
         async with self.data_store.transaction():
-            our_store_proofs: Dict[bytes32, StoreProofs] = {}
+            our_store_proofs: dict[bytes32, StoreProofs] = {}
             for offer_store in offer_stores:
                 changelist = await self.build_offer_changelist(
                     store_id=offer_store.store_id,
@@ -1066,7 +1056,7 @@ class DataLayer:
                 if new_root_hash is None:
                     raise Exception("only inserts are supported so a None root hash should not be possible")
 
-                proofs: List[Proof] = []
+                proofs: list[Proof] = []
                 for entry in offer_store.inclusions:
                     node_hash = await self.get_key_value_hash(
                         store_id=offer_store.store_id,
@@ -1098,21 +1088,20 @@ class DataLayer:
 
     async def make_offer(
         self,
-        maker: Tuple[OfferStore, ...],
-        taker: Tuple[OfferStore, ...],
+        maker: tuple[OfferStore, ...],
+        taker: tuple[OfferStore, ...],
         fee: uint64,
     ) -> Offer:
         async with self.data_store.transaction():
             our_store_proofs = await self.process_offered_stores(offer_stores=maker)
 
-            offer_dict: Dict[Union[uint32, str], int] = {
+            offer_dict: dict[Union[uint32, str], int] = {
                 **{offer_store.store_id.hex(): -1 for offer_store in maker},
                 **{offer_store.store_id.hex(): 1 for offer_store in taker},
             }
 
-            solver: Dict[str, Any] = {
-                "0x"
-                + our_offer_store.store_id.hex(): {
+            solver: dict[str, Any] = {
+                "0x" + our_offer_store.store_id.hex(): {
                     "new_root": "0x" + our_store_proofs[our_offer_store.store_id].proofs[0].root().hex(),
                     "dependencies": [
                         {
@@ -1158,8 +1147,8 @@ class DataLayer:
     async def take_offer(
         self,
         offer_bytes: bytes,
-        taker: Tuple[OfferStore, ...],
-        maker: Tuple[StoreProofs, ...],
+        taker: tuple[OfferStore, ...],
+        maker: tuple[StoreProofs, ...],
         fee: uint64,
     ) -> TradeRecord:
         async with self.data_store.transaction():
@@ -1170,10 +1159,10 @@ class DataLayer:
 
             verify_offer(maker=maker, taker=taker, summary=summary)
 
-            all_store_proofs: Dict[bytes32, StoreProofs] = {
+            all_store_proofs: dict[bytes32, StoreProofs] = {
                 store_proofs.proofs[0].root(): store_proofs for store_proofs in [*maker, *our_store_proofs.values()]
             }
-            proofs_of_inclusion: List[Tuple[str, str, List[str]]] = []
+            proofs_of_inclusion: list[tuple[str, str, list[str]]] = []
             for root, store_proofs in all_store_proofs.items():
                 for proof in store_proofs.proofs:
                     layers = [
@@ -1194,11 +1183,10 @@ class DataLayer:
                         )
                     )
 
-            solver: Dict[str, Any] = {
+            solver: dict[str, Any] = {
                 "proofs_of_inclusion": proofs_of_inclusion,
                 **{
-                    "0x"
-                    + our_offer_store.store_id.hex(): {
+                    "0x" + our_offer_store.store_id.hex(): {
                         "new_root": "0x" + root.hex(),
                         "dependencies": [
                             {
@@ -1232,7 +1220,7 @@ class DataLayer:
         return trade_record
 
     async def cancel_offer(self, trade_id: bytes32, secure: bool, fee: uint64) -> None:
-        store_ids: List[bytes32] = []
+        store_ids: list[bytes32] = []
 
         if not secure:
             trade_record = await self.wallet_rpc.get_offer(trade_id=trade_id, file_contents=True)
@@ -1270,7 +1258,7 @@ class DataLayer:
             target_generation=singleton_record.generation,
         )
 
-    async def get_uploaders(self, store_id: bytes32) -> List[PluginRemote]:
+    async def get_uploaders(self, store_id: bytes32) -> list[PluginRemote]:
         uploaders = []
         for uploader in self.uploaders:
             async with aiohttp.ClientSession() as session:

chia/data_layer/data_layer_api.py

@@ -1,14 +1,22 @@
 from __future__ import annotations
 
 import logging
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from chia.data_layer.data_layer import DataLayer
+from chia.server.api_protocol import ApiMetadata
 from chia.server.server import ChiaServer
 
 
 class DataLayerAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+
+        _protocol_check: ClassVar[ApiProtocol] = cast("DataLayerAPI", None)
+
     log: logging.Logger
     data_layer: DataLayer
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
 
     def __init__(self, data_layer: DataLayer) -> None:
         self.log = logging.getLogger(__name__)

chia/data_layer/data_layer_errors.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Iterable, List
+from collections.abc import Iterable
 
 from chia.types.blockchain_format.sized_bytes import bytes32
 
@@ -14,7 +14,7 @@ def build_message_with_hashes(message: str, bytes_objects: Iterable[bytes]) -> s
 
 
 class TreeGenerationIncrementingError(IntegrityError):
-    def __init__(self, store_ids: List[bytes32]) -> None:
+    def __init__(self, store_ids: list[bytes32]) -> None:
         super().__init__(
             build_message_with_hashes(
                 message="Found trees with generations not properly incrementing:",
@@ -24,7 +24,7 @@ class TreeGenerationIncrementingError(IntegrityError):
 
 
 class NodeHashError(IntegrityError):
-    def __init__(self, node_hashes: List[bytes32]) -> None:
+    def __init__(self, node_hashes: list[bytes32]) -> None:
         super().__init__(
             build_message_with_hashes(
                 message="Found nodes with incorrect hashes:",

chia/data_layer/data_layer_server.py

@@ -7,7 +7,7 @@ import sys
 from dataclasses import dataclass, field
 from pathlib import Path
 from types import FrameType
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 import click
 from aiohttp import web
@@ -35,7 +35,7 @@ log = logging.getLogger(__name__)
 @dataclass
 class DataLayerServer:
     root_path: Path
-    config: Dict[str, Any]
+    config: dict[str, Any]
     log: logging.Logger
     shutdown_event: asyncio.Event
     webserver: Optional[WebServer] = None