chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/data_layer/data_layer_util.py

@@ -4,7 +4,7 @@ import dataclasses
 from dataclasses import dataclass, field
 from enum import Enum, IntEnum
 from hashlib import sha256
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import aiosqlite
 from typing_extensions import final
@@ -52,14 +52,14 @@ def key_hash(key: bytes) -> bytes32:
 class PaginationData:
     total_pages: int
     total_bytes: int
-    hashes: List[bytes32]
+    hashes: list[bytes32]
 
 
-def get_hashes_for_page(page: int, lengths: Dict[bytes32, int], max_page_size: int) -> PaginationData:
+def get_hashes_for_page(page: int, lengths: dict[bytes32, int], max_page_size: int) -> PaginationData:
     current_page = 0
     current_page_size = 0
     total_bytes = 0
-    hashes: List[bytes32] = []
+    hashes: list[bytes32] = []
     for hash, length in sorted(lengths.items(), key=lambda x: (-x[1], x[0])):
         if length > max_page_size:
             raise RuntimeError(
@@ -98,9 +98,9 @@ async def _dot_dump(
 
     n = 8
 
-    dot_nodes: List[str] = []
-    dot_connections: List[str] = []
-    dot_pair_boxes: List[str] = []
+    dot_nodes: list[str] = []
+    dot_connections: list[str] = []
+    dot_pair_boxes: list[str] = []
 
     for terminal_node in terminal_nodes:
         hash = terminal_node.hash.hex()
@@ -245,7 +245,7 @@ other_side_to_bit = {Side.LEFT: 1, Side.RIGHT: 0}
 class ProofOfInclusion:
     node_hash: bytes32
     # children before parents
-    layers: List[ProofOfInclusionLayer]
+    layers: list[ProofOfInclusionLayer]
 
     @property
     def root_hash(self) -> bytes32:
@@ -257,7 +257,7 @@ class ProofOfInclusion:
     def sibling_sides_integer(self) -> int:
         return sum(other_side_to_bit[layer.other_hash_side] << index for index, layer in enumerate(self.layers))
 
-    def sibling_hashes(self) -> List[bytes32]:
+    def sibling_hashes(self) -> list[bytes32]:
         return [layer.other_hash for layer in self.layers]
 
     def as_program(self) -> Program:
@@ -366,7 +366,7 @@ class Root:
             status=Status(row["status"]),
         )
 
-    def to_row(self) -> Dict[str, Any]:
+    def to_row(self) -> dict[str, Any]:
         return {
             "tree_id": self.store_id,
             "node_hash": self.node_hash,
@@ -375,7 +375,7 @@ class Root:
         }
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> Root:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> Root:
         return cls(
             store_id=bytes32.from_hexstr(marshalled["tree_id"]),
             node_hash=None if marshalled["node_hash"] is None else bytes32.from_hexstr(marshalled["node_hash"]),
@@ -383,7 +383,7 @@ class Root:
             status=Status(marshalled["status"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "tree_id": self.store_id.hex(),
             "node_hash": None if self.node_hash is None else self.node_hash.hex(),
@@ -392,7 +392,7 @@ class Root:
         }
 
 
-node_type_to_class: Dict[NodeType, Union[Type[InternalNode], Type[TerminalNode]]] = {
+node_type_to_class: dict[NodeType, Union[type[InternalNode], type[TerminalNode]]] = {
     NodeType.INTERNAL: InternalNode,
     NodeType.TERMINAL: TerminalNode,
 }
@@ -408,7 +408,7 @@ class ServerInfo:
 @dataclass(frozen=True)
 class Subscription:
     store_id: bytes32
-    servers_info: List[ServerInfo]
+    servers_info: list[ServerInfo]
 
 
 @dataclass(frozen=True)
@@ -433,13 +433,13 @@ class KeyValue:
     value: bytes
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> KeyValue:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> KeyValue:
         return cls(
             key=hexstr_to_bytes(marshalled["key"]),
             value=hexstr_to_bytes(marshalled["value"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "key": self.key.hex(),
             "value": self.value.hex(),
@@ -449,16 +449,16 @@ class KeyValue:
 @dataclasses.dataclass(frozen=True)
 class OfferStore:
     store_id: bytes32
-    inclusions: Tuple[KeyValue, ...]
+    inclusions: tuple[KeyValue, ...]
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> OfferStore:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> OfferStore:
         return cls(
             store_id=bytes32.from_hexstr(marshalled["store_id"]),
             inclusions=tuple(KeyValue.unmarshal(key_value) for key_value in marshalled["inclusions"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "store_id": self.store_id.hex(),
             "inclusions": [key_value.marshal() for key_value in self.inclusions],
@@ -475,14 +475,14 @@ class Layer:
     combined_hash: bytes32
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> Layer:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> Layer:
         return cls(
             other_hash_side=Side.unmarshal(marshalled["other_hash_side"]),
             other_hash=bytes32.from_hexstr(marshalled["other_hash"]),
             combined_hash=bytes32.from_hexstr(marshalled["combined_hash"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "other_hash_side": self.other_hash_side.marshal(),
             "other_hash": self.other_hash.hex(),
@@ -492,19 +492,19 @@ class Layer:
 
 @dataclasses.dataclass(frozen=True)
 class MakeOfferRequest:
-    maker: Tuple[OfferStore, ...]
-    taker: Tuple[OfferStore, ...]
+    maker: tuple[OfferStore, ...]
+    taker: tuple[OfferStore, ...]
     fee: Optional[uint64]
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> MakeOfferRequest:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> MakeOfferRequest:
         return cls(
             maker=tuple(OfferStore.unmarshal(offer_store) for offer_store in marshalled["maker"]),
             taker=tuple(OfferStore.unmarshal(offer_store) for offer_store in marshalled["taker"]),
             fee=None if marshalled["fee"] is None else uint64(marshalled["fee"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "maker": [offer_store.marshal() for offer_store in self.maker],
             "taker": [offer_store.marshal() for offer_store in self.taker],
@@ -517,10 +517,10 @@ class Proof:
     key: bytes
     value: bytes
     node_hash: bytes32
-    layers: Tuple[Layer, ...]
+    layers: tuple[Layer, ...]
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> Proof:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> Proof:
         return cls(
             key=hexstr_to_bytes(marshalled["key"]),
             value=hexstr_to_bytes(marshalled["value"]),
@@ -534,7 +534,7 @@ class Proof:
 
         return self.layers[-1].combined_hash
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "key": self.key.hex(),
             "value": self.value.hex(),
@@ -546,16 +546,16 @@ class Proof:
 @dataclasses.dataclass(frozen=True)
 class StoreProofs:
     store_id: bytes32
-    proofs: Tuple[Proof, ...]
+    proofs: tuple[Proof, ...]
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> StoreProofs:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> StoreProofs:
         return cls(
             store_id=bytes32.from_hexstr(marshalled["store_id"]),
             proofs=tuple(Proof.unmarshal(proof) for proof in marshalled["proofs"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "store_id": self.store_id.hex(),
             "proofs": [proof.marshal() for proof in self.proofs],
@@ -566,11 +566,11 @@ class StoreProofs:
 class Offer:
     trade_id: bytes
     offer: bytes
-    taker: Tuple[OfferStore, ...]
-    maker: Tuple[StoreProofs, ...]
+    taker: tuple[OfferStore, ...]
+    maker: tuple[StoreProofs, ...]
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> Offer:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> Offer:
         return cls(
             trade_id=bytes32.from_hexstr(marshalled["trade_id"]),
             offer=hexstr_to_bytes(marshalled["offer"]),
@@ -578,7 +578,7 @@ class Offer:
             maker=tuple(StoreProofs.unmarshal(store_proof) for store_proof in marshalled["maker"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "trade_id": self.trade_id.hex(),
             "offer": self.offer.hex(),
@@ -593,13 +593,13 @@ class MakeOfferResponse:
     offer: Offer
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> MakeOfferResponse:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> MakeOfferResponse:
         return cls(
             success=marshalled["success"],
             offer=Offer.unmarshal(marshalled["offer"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "success": self.success,
             "offer": self.offer.marshal(),
@@ -612,13 +612,13 @@ class TakeOfferRequest:
     fee: Optional[uint64]
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> TakeOfferRequest:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> TakeOfferRequest:
         return cls(
             offer=Offer.unmarshal(marshalled["offer"]),
             fee=None if marshalled["fee"] is None else uint64(marshalled["fee"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "offer": self.offer.marshal(),
             "fee": None if self.fee is None else int(self.fee),
@@ -631,13 +631,13 @@ class TakeOfferResponse:
     trade_id: bytes32
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> TakeOfferResponse:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> TakeOfferResponse:
         return cls(
             success=marshalled["success"],
             trade_id=bytes32.from_hexstr(marshalled["trade_id"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "success": self.success,
             "trade_id": self.trade_id.hex(),
@@ -653,7 +653,7 @@ class VerifyOfferResponse:
     fee: Optional[uint64] = None
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> VerifyOfferResponse:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> VerifyOfferResponse:
         return cls(
             success=marshalled["success"],
             valid=marshalled["valid"],
@@ -661,7 +661,7 @@ class VerifyOfferResponse:
             fee=None if marshalled["fee"] is None else uint64(marshalled["fee"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "success": self.success,
             "valid": self.valid,
@@ -678,14 +678,14 @@ class CancelOfferRequest:
     fee: Optional[uint64]
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> CancelOfferRequest:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> CancelOfferRequest:
         return cls(
             trade_id=bytes32.from_hexstr(marshalled["trade_id"]),
             secure=marshalled["secure"],
             fee=None if marshalled["fee"] is None else uint64(marshalled["fee"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "trade_id": self.trade_id.hex(),
             "secure": self.secure,
@@ -698,12 +698,12 @@ class CancelOfferResponse:
     success: bool
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> CancelOfferResponse:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> CancelOfferResponse:
         return cls(
             success=marshalled["success"],
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "success": self.success,
         }
@@ -715,12 +715,12 @@ class ClearPendingRootsRequest:
     store_id: bytes32
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> ClearPendingRootsRequest:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> ClearPendingRootsRequest:
         return cls(
             store_id=bytes32.from_hexstr(marshalled["store_id"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "store_id": self.store_id.hex(),
         }
@@ -738,13 +738,13 @@ class ClearPendingRootsResponse:
     # status: Status
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> ClearPendingRootsResponse:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> ClearPendingRootsResponse:
         return cls(
             success=marshalled["success"],
             root=None if marshalled["root"] is None else Root.unmarshal(marshalled["root"]),
         )
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "success": self.success,
             "root": None if self.root is None else self.root.marshal(),
@@ -764,10 +764,10 @@ class SyncStatus:
 class PluginRemote:
     url: str
     # repr=False to avoid leaking secrets
-    headers: Dict[str, str] = dataclasses.field(default_factory=dict, hash=False, repr=False)
+    headers: dict[str, str] = dataclasses.field(default_factory=dict, hash=False, repr=False)
 
     @classmethod
-    def unmarshal(cls, marshalled: Dict[str, Any]) -> PluginRemote:
+    def unmarshal(cls, marshalled: dict[str, Any]) -> PluginRemote:
         return cls(
             url=marshalled["url"],
             headers=marshalled.get("headers", {}),
@@ -776,10 +776,10 @@ class PluginRemote:
 
 @dataclasses.dataclass(frozen=True)
 class PluginStatus:
-    uploaders: Dict[str, Dict[str, Any]]
-    downloaders: Dict[str, Dict[str, Any]]
+    uploaders: dict[str, dict[str, Any]]
+    downloaders: dict[str, dict[str, Any]]
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "plugin_status": {
                 "uploaders": self.uploaders,
@@ -802,9 +802,9 @@ class UnsubscribeData:
 
 @dataclasses.dataclass(frozen=True)
 class KeysValuesCompressed:
-    keys_values_hashed: Dict[bytes32, bytes32]
-    key_hash_to_length: Dict[bytes32, int]
-    leaf_hash_to_length: Dict[bytes32, int]
+    keys_values_hashed: dict[bytes32, bytes32]
+    key_hash_to_length: dict[bytes32, int]
+    leaf_hash_to_length: dict[bytes32, int]
     root_hash: Optional[bytes32]
 
 
@@ -812,7 +812,7 @@ class KeysValuesCompressed:
 class KeysPaginationData:
     total_pages: int
     total_bytes: int
-    keys: List[bytes]
+    keys: list[bytes]
     root_hash: Optional[bytes32]
 
 
@@ -820,7 +820,7 @@ class KeysPaginationData:
 class KeysValuesPaginationData:
     total_pages: int
     total_bytes: int
-    keys_values: List[TerminalNode]
+    keys_values: list[TerminalNode]
     root_hash: Optional[bytes32]
 
 
@@ -828,7 +828,7 @@ class KeysValuesPaginationData:
 class KVDiffPaginationData:
     total_pages: int
     total_bytes: int
-    kv_diff: List[DiffData]
+    kv_diff: list[DiffData]
 
 
 #
@@ -849,7 +849,7 @@ class HashOnlyProof(Streamable):
     key_clvm_hash: bytes32
     value_clvm_hash: bytes32
     node_hash: bytes32
-    layers: List[ProofLayer]
+    layers: list[ProofLayer]
 
     def root(self) -> bytes32:
         if len(self.layers) == 0:
@@ -857,7 +857,7 @@ class HashOnlyProof(Streamable):
         return self.layers[-1].combined_hash
 
     @classmethod
-    def from_key_value(cls, key: bytes, value: bytes, node_hash: bytes32, layers: List[ProofLayer]) -> HashOnlyProof:
+    def from_key_value(cls, key: bytes, value: bytes, node_hash: bytes32, layers: list[ProofLayer]) -> HashOnlyProof:
         return cls(
             key_clvm_hash=Program.to(key).get_tree_hash(),
             value_clvm_hash=Program.to(value).get_tree_hash(),
@@ -877,21 +877,21 @@ class KeyValueHashes(Streamable):
 @dataclasses.dataclass(frozen=True)
 class ProofResultInclusions(Streamable):
     store_id: bytes32
-    inclusions: List[KeyValueHashes]
+    inclusions: list[KeyValueHashes]
 
 
 @streamable
 @dataclasses.dataclass(frozen=True)
 class GetProofRequest(Streamable):
     store_id: bytes32
-    keys: List[bytes]
+    keys: list[bytes]
 
 
 @streamable
 @dataclasses.dataclass(frozen=True)
 class StoreProofsHashes(Streamable):
     store_id: bytes32
-    proofs: List[HashOnlyProof]
+    proofs: list[HashOnlyProof]
 
 
 @streamable
@@ -917,10 +917,10 @@ class VerifyProofResponse(Streamable):
     success: bool
 
 
-def dl_verify_proof_internal(dl_proof: DLProof, puzzle_hash: bytes32) -> List[KeyValueHashes]:
+def dl_verify_proof_internal(dl_proof: DLProof, puzzle_hash: bytes32) -> list[KeyValueHashes]:
     """Verify a proof of inclusion for a DL singleton"""
 
-    verified_keys: List[KeyValueHashes] = []
+    verified_keys: list[KeyValueHashes] = []
 
     for reference_proof in dl_proof.store_proofs.proofs:
         inner_puz_hash = dl_proof.inner_puzzle_hash
@@ -962,10 +962,10 @@ def dl_verify_proof_internal(dl_proof: DLProof, puzzle_hash: bytes32) -> List[Ke
 
 
 async def dl_verify_proof(
-    request: Dict[str, Any],
+    request: dict[str, Any],
     wallet_node: WalletNode,
     peer: WSChiaConnection,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Verify a proof of inclusion for a DL singleton"""
 
     dlproof = DLProof.from_json_dict(request)