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

chia/types/coin_spend.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any, Union
 
 import chia_rs
 
@@ -46,7 +46,7 @@ def compute_additions_with_cost(
     cs: CoinSpend,
     *,
     max_cost: int = DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
-) -> Tuple[List[Coin], int]:
+) -> tuple[list[Coin], int]:
     """
     Run the puzzle in the specified CoinSpend and return the cost and list of
     coins created by the puzzle, i.e. additions. If the cost (CLVM- and
@@ -56,14 +56,14 @@ def compute_additions_with_cost(
     measured at the block generator level.
     """
     parent_id = cs.coin.name()
-    ret: List[Coin] = []
+    ret: list[Coin] = []
     cost, r = cs.puzzle_reveal.run_with_cost(max_cost, cs.solution)
     for cond in Program.to(r).as_iter():
         if cost > max_cost:
             raise ValidationError(Err.BLOCK_COST_EXCEEDS_MAX, "compute_additions() for CoinSpend")
         atoms = cond.as_iter()
         op = next(atoms).atom
-        if op in [
+        if op in {
             ConditionOpcode.AGG_SIG_PARENT,
             ConditionOpcode.AGG_SIG_PUZZLE,
             ConditionOpcode.AGG_SIG_AMOUNT,
@@ -72,7 +72,7 @@ def compute_additions_with_cost(
             ConditionOpcode.AGG_SIG_PARENT_PUZZLE,
             ConditionOpcode.AGG_SIG_UNSAFE,
             ConditionOpcode.AGG_SIG_ME,
-        ]:
+        }:
             cost += ConditionCost.AGG_SIG.value
             continue
         if op != ConditionOpcode.CREATE_COIN.value:
@@ -85,7 +85,7 @@ def compute_additions_with_cost(
     return ret, cost
 
 
-def compute_additions(cs: CoinSpend, *, max_cost: int = DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM) -> List[Coin]:
+def compute_additions(cs: CoinSpend, *, max_cost: int = DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM) -> list[Coin]:
     return compute_additions_with_cost(cs, max_cost=max_cost)[0]
 
 
@@ -99,10 +99,10 @@ class SpendInfo(Streamable):
 @dataclass(frozen=True)
 class CoinSpendWithConditions:
     coin_spend: CoinSpend
-    conditions: List[ConditionWithArgs]
+    conditions: list[ConditionWithArgs]
 
     @staticmethod
-    def from_json_dict(dict: Dict[str, Any]) -> CoinSpendWithConditions:
+    def from_json_dict(dict: dict[str, Any]) -> CoinSpendWithConditions:
         return CoinSpendWithConditions(
             CoinSpend.from_json_dict(dict["coin_spend"]),
             [

chia/types/condition_with_args.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List
 
 from chia.types.condition_opcodes import ConditionOpcode
 
@@ -14,4 +13,4 @@ class ConditionWithArgs:
     """
 
     opcode: ConditionOpcode
-    vars: List[bytes]
+    vars: list[bytes]

chia/types/eligible_coin_spends.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Awaitable, Callable, Dict, List, Optional, Tuple
+from collections.abc import Awaitable
+from typing import Callable, Optional
 
 from chia_rs import fast_forward_singleton, get_conditions_from_spendbundle
 
@@ -21,7 +22,7 @@ from chia.util.ints import uint32, uint64
 @dataclasses.dataclass(frozen=True)
 class EligibilityAndAdditions:
     is_eligible_for_dedup: bool
-    spend_additions: List[Coin]
+    spend_additions: list[Coin]
     is_eligible_for_ff: bool
 
 
@@ -50,7 +51,7 @@ class UnspentLineageInfo:
 
 
 def set_next_singleton_version(
-    current_singleton: Coin, singleton_additions: List[Coin], fast_forward_spends: Dict[bytes32, UnspentLineageInfo]
+    current_singleton: Coin, singleton_additions: list[Coin], fast_forward_spends: dict[bytes32, UnspentLineageInfo]
 ) -> None:
     """
     Finds the next version of the singleton among its additions and updates the
@@ -83,8 +84,8 @@ def set_next_singleton_version(
 def perform_the_fast_forward(
     unspent_lineage_info: UnspentLineageInfo,
     spend_data: BundleCoinSpend,
-    fast_forward_spends: Dict[bytes32, UnspentLineageInfo],
-) -> Tuple[CoinSpend, List[Coin]]:
+    fast_forward_spends: dict[bytes32, UnspentLineageInfo],
+) -> tuple[CoinSpend, list[Coin]]:
     """
     Performs a singleton fast forward, including the updating of all previous
     additions to point to the most recent version, and updates the fast forward
@@ -97,7 +98,7 @@ def perform_the_fast_forward(
 
     Returns:
         CoinSpend: the new coin spend after performing the fast forward
-        List[Coin]: the updated additions that point to the new coin to spend
+        list[Coin]: the updated additions that point to the new coin to spend
 
     Raises:
         ValueError if none of the additions are considered to be the singleton's
@@ -141,12 +142,12 @@ def perform_the_fast_forward(
 
 @dataclasses.dataclass(frozen=True)
 class EligibleCoinSpends:
-    deduplication_spends: Dict[bytes32, DedupCoinSpend] = dataclasses.field(default_factory=dict)
-    fast_forward_spends: Dict[bytes32, UnspentLineageInfo] = dataclasses.field(default_factory=dict)
+    deduplication_spends: dict[bytes32, DedupCoinSpend] = dataclasses.field(default_factory=dict)
+    fast_forward_spends: dict[bytes32, UnspentLineageInfo] = dataclasses.field(default_factory=dict)
 
     def get_deduplication_info(
-        self, *, bundle_coin_spends: Dict[bytes32, BundleCoinSpend], max_cost: int
-    ) -> Tuple[List[CoinSpend], uint64, List[Coin]]:
+        self, *, bundle_coin_spends: dict[bytes32, BundleCoinSpend], max_cost: int
+    ) -> tuple[list[CoinSpend], uint64, list[Coin]]:
         """
         Checks all coin spends of a mempool item for deduplication eligibility and
         provides the caller with the necessary information that allows it to perform
@@ -157,9 +158,9 @@ class EligibleCoinSpends:
             max_cost: the maximum limit when running for cost
 
         Returns:
-            List[CoinSpend]: list of unique coin spends in this mempool item
+            list[CoinSpend]: list of unique coin spends in this mempool item
             uint64: the cost we're saving by deduplicating eligible coins
-            List[Coin]: list of unique additions in this mempool item
+            list[Coin]: list of unique additions in this mempool item
 
         Raises:
             ValueError to skip the mempool item we're currently in, if it's
@@ -167,10 +168,10 @@ class EligibleCoinSpends:
             one we're already deduplicating on.
         """
         cost_saving = 0
-        unique_coin_spends: List[CoinSpend] = []
-        unique_additions: List[Coin] = []
+        unique_coin_spends: list[CoinSpend] = []
+        unique_additions: list[Coin] = []
         # Map of coin ID to deduplication information
-        new_dedup_spends: Dict[bytes32, DedupCoinSpend] = {}
+        new_dedup_spends: dict[bytes32, DedupCoinSpend] = {}
         # See if this item has coin spends that are eligible for deduplication
         for coin_id, spend_data in bundle_coin_spends.items():
             if not spend_data.eligible_for_dedup:

chia/types/generator_types.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List
 
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.util.streamable import Streamable, streamable
@@ -11,4 +10,4 @@ from chia.util.streamable import Streamable, streamable
 @dataclass(frozen=True)
 class BlockGenerator(Streamable):
     program: SerializedProgram
-    generator_refs: List[bytes]
+    generator_refs: list[bytes]

chia/types/internal_mempool_item.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict
 
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.mempool_item import BundleCoinSpend
@@ -16,4 +15,4 @@ class InternalMempoolItem:
     conds: SpendBundleConditions
     height_added_to_mempool: uint32
     # Map of coin ID to coin spend data between the bundle and its NPCResult
-    bundle_coin_spends: Dict[bytes32, BundleCoinSpend]
+    bundle_coin_spends: dict[bytes32, BundleCoinSpend]

chia/types/mempool_item.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -17,7 +17,7 @@ class BundleCoinSpend:
     coin_spend: CoinSpend
     eligible_for_dedup: bool
     eligible_for_fast_forward: bool
-    additions: List[Coin]
+    additions: list[Coin]
     # cost on the specific solution in this item
     cost: Optional[uint64] = None
 
@@ -40,7 +40,7 @@ class MempoolItem:
 
     # Map of coin ID to coin spend data between the bundle and its
     # SpendBundleConditions
-    bundle_coin_spends: Dict[bytes32, BundleCoinSpend] = field(default_factory=dict)
+    bundle_coin_spends: dict[bytes32, BundleCoinSpend] = field(default_factory=dict)
 
     def __lt__(self, other: MempoolItem) -> bool:
         return self.fee_per_cost < other.fee_per_cost
@@ -61,8 +61,8 @@ class MempoolItem:
         return uint64(0 if self.conds is None else self.conds.cost)
 
     @property
-    def additions(self) -> List[Coin]:
-        additions: List[Coin] = []
+    def additions(self) -> list[Coin]:
+        additions: list[Coin] = []
         for spend in self.conds.spends:
             for puzzle_hash, amount, _ in spend.create_coin:
                 coin = Coin(spend.coin_id, puzzle_hash, uint64(amount))
@@ -70,10 +70,10 @@ class MempoolItem:
         return additions
 
     @property
-    def removals(self) -> List[Coin]:
+    def removals(self) -> list[Coin]:
         return self.spend_bundle.removals()
 
-    def to_json_dict(self) -> Dict[str, Any]:
+    def to_json_dict(self) -> dict[str, Any]:
         return {
             "spend_bundle": recurse_jsonify(self.spend_bundle),
             "fee": recurse_jsonify(self.fee),

chia/types/mempool_submission_status.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, Optional, Union
+from typing import Optional, Union
 
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.util.ints import uint8
@@ -21,7 +21,7 @@ class MempoolSubmissionStatus(Streamable):
     inclusion_status: uint8  # MempoolInclusionStatus
     error_msg: Optional[str]
 
-    def to_json_dict_convenience(self) -> Dict[str, Union[str, MempoolInclusionStatus, Optional[str]]]:
+    def to_json_dict_convenience(self) -> dict[str, Union[str, MempoolInclusionStatus, Optional[str]]]:
         formatted = self.to_json_dict()
         formatted["inclusion_status"] = MempoolInclusionStatus(self.inclusion_status).name
         return formatted

chia/types/peer_info.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from typing import Union
 
 from chia.util.ints import uint16, uint64
-from chia.util.network import IPAddress
+from chia.util.ip_address import IPAddress
 from chia.util.streamable import Streamable, streamable
 
 

chia/types/spend_bundle.py

@@ -5,10 +5,9 @@ from typing import TypeVar
 import chia_rs
 
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.coin_spend import compute_additions_with_cost
 from chia.util.errors import Err, ValidationError
 
-from .coin_spend import compute_additions_with_cost
-
 SpendBundle = chia_rs.SpendBundle
 T_SpendBundle = TypeVar("T_SpendBundle", bound="SpendBundle")
 

chia/types/transaction_queue_entry.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import dataclasses
 from dataclasses import dataclass, field
-from typing import ClassVar, Generic, Optional, Tuple, TypeVar, Union
+from typing import ClassVar, Generic, Optional, TypeVar, Union
 
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -49,7 +49,7 @@ class TransactionQueueEntry:
     spend_name: bytes32
     peer: Optional[WSChiaConnection] = field(compare=False)
     test: bool = field(compare=False)
-    done: ValuedEvent[Tuple[MempoolInclusionStatus, Optional[Err]]] = field(
+    done: ValuedEvent[tuple[MempoolInclusionStatus, Optional[Err]]] = field(
         default_factory=ValuedEvent,
         compare=False,
     )

chia/types/unfinished_header_block.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 
 from chia.types.blockchain_format.foliage import Foliage, FoliageTransactionBlock
 from chia.types.blockchain_format.reward_chain_block import RewardChainBlockUnfinished
@@ -16,7 +16,7 @@ from chia.util.streamable import Streamable, streamable
 @dataclass(frozen=True)
 class UnfinishedHeaderBlock(Streamable):
     # Same as a FullBlock but without TransactionInfo and Generator, used by light clients
-    finished_sub_slots: List[EndOfSubSlotBundle]  # If first sb
+    finished_sub_slots: list[EndOfSubSlotBundle]  # If first sb
     reward_chain_block: RewardChainBlockUnfinished  # Reward chain trunk data
     challenge_chain_sp_proof: Optional[VDFProof]  # If not first sp in sub-slot
     reward_chain_sp_proof: Optional[VDFProof]  # If not first sp in sub-slot

chia/types/validation_state.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+from chia.consensus.block_record import BlockRecord
+from chia.util.ints import uint64
+
+
+@dataclasses.dataclass
+class ValidationState:
+    ssi: uint64
+    difficulty: uint64
+    prev_ses_block: Optional[BlockRecord] = None

chia/types/weight_proof.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List
 
 import chia_rs
 
@@ -32,19 +31,19 @@ SubSlotData = chia_rs.SubSlotData
 @dataclass(frozen=True)
 # this is used only for serialization to database
 class RecentChainData(Streamable):
-    recent_chain_data: List[HeaderBlock]
+    recent_chain_data: list[HeaderBlock]
 
 
 @streamable
 @dataclass(frozen=True)
 class ProofBlockHeader(Streamable):
-    finished_sub_slots: List[EndOfSubSlotBundle]
+    finished_sub_slots: list[EndOfSubSlotBundle]
     reward_chain_block: RewardChainBlock
 
 
 @streamable
 @dataclass(frozen=True)
 class WeightProof(Streamable):
-    sub_epochs: List[SubEpochData]
-    sub_epoch_segments: List[SubEpochChallengeSegment]  # sampled sub epoch
-    recent_chain_data: List[HeaderBlock]
+    sub_epochs: list[SubEpochData]
+    sub_epoch_segments: list[SubEpochChallengeSegment]  # sampled sub epoch
+    recent_chain_data: list[HeaderBlock]

chia/util/action_scope.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import contextlib
+from collections.abc import AsyncIterator, Awaitable
 from dataclasses import dataclass, field
-from typing import AsyncIterator, Awaitable, Callable, Generic, Optional, Protocol, Type, TypeVar, final
+from typing import Callable, Generic, Optional, Protocol, TypeVar, final
 
 import aiosqlite
 
@@ -21,14 +22,13 @@ class ResourceManager(Protocol):
         # yield included to make this a generator as expected by @contextlib.asynccontextmanager
         yield
 
-    async def get_resource(self, resource_type: Type[_T_SideEffects]) -> _T_SideEffects: ...
+    async def get_resource(self, resource_type: type[_T_SideEffects]) -> _T_SideEffects: ...
 
     async def save_resource(self, resource: SideEffects) -> None: ...
 
 
 @dataclass
 class SQLiteResourceManager:
-
     _db: DBWrapper2
     _active_writer: Optional[aiosqlite.Connection] = field(init=False, default=None)
 
@@ -62,7 +62,7 @@ class SQLiteResourceManager:
             finally:
                 self._active_writer = None
 
-    async def get_resource(self, resource_type: Type[_T_SideEffects]) -> _T_SideEffects:
+    async def get_resource(self, resource_type: type[_T_SideEffects]) -> _T_SideEffects:
         row = await execute_fetchone(self.get_active_writer(), "SELECT total FROM side_effects")
         assert row is not None
         side_effects = resource_type.from_bytes(row[0])
@@ -80,7 +80,7 @@ class SideEffects(Protocol):
     def __bytes__(self) -> bytes: ...
 
     @classmethod
-    def from_bytes(cls: Type[_T_SideEffects], blob: bytes) -> _T_SideEffects: ...
+    def from_bytes(cls: type[_T_SideEffects], blob: bytes) -> _T_SideEffects: ...
 
 
 _T_SideEffects = TypeVar("_T_SideEffects", bound=SideEffects)
@@ -100,7 +100,7 @@ class ActionScope(Generic[_T_SideEffects, _T_Config]):
     """
 
     _resource_manager: ResourceManager
-    _side_effects_format: Type[_T_SideEffects]
+    _side_effects_format: type[_T_SideEffects]
     _config: _T_Config  # An object not intended to be mutated during the lifetime of the scope
     _callback: Optional[Callable[[StateInterface[_T_SideEffects]], Awaitable[None]]] = None
     _final_side_effects: Optional[_T_SideEffects] = field(init=False, default=None)
@@ -123,11 +123,11 @@ class ActionScope(Generic[_T_SideEffects, _T_Config]):
     @contextlib.asynccontextmanager
     async def new_scope(
         cls,
-        side_effects_format: Type[_T_SideEffects],
+        side_effects_format: type[_T_SideEffects],
         # I want a default here in case a use case doesn't want to take advantage of the config but no default seems to
         # satisfy the type hint _T_Config so we'll just ignore this.
         config: _T_Config = object(),  # type: ignore[assignment]
-        resource_manager_backend: Type[ResourceManager] = SQLiteResourceManager,
+        resource_manager_backend: type[ResourceManager] = SQLiteResourceManager,
     ) -> AsyncIterator[ActionScope[_T_SideEffects, _T_Config]]:
         async with resource_manager_backend.managed(side_effects_format()) as resource_manager:
             self = cls(_resource_manager=resource_manager, _side_effects_format=side_effects_format, _config=config)

chia/util/async_pool.py

@@ -6,11 +6,13 @@ import dataclasses
 import itertools
 import logging
 import traceback
-from typing import AsyncIterator, Dict, Generic, Iterator, Optional, Protocol, TypeVar, final
+from collections.abc import AsyncIterator, Iterator
+from typing import Generic, Optional, Protocol, TypeVar, final
 
 import anyio
 
 from chia.util.log_exceptions import log_exceptions
+from chia.util.task_referencer import create_referenced_task
 
 
 class InvalidTargetWorkerCountError(Exception):
@@ -128,7 +130,7 @@ class AsyncPool:
     log: logging.Logger
     worker_async_callable: WorkerCallable
     _target_worker_count: int
-    _workers: Dict[asyncio.Task[object], int] = dataclasses.field(init=False, default_factory=dict)
+    _workers: dict[asyncio.Task[object], int] = dataclasses.field(init=False, default_factory=dict)
     _worker_id_counter: Iterator[int] = dataclasses.field(init=False, default_factory=itertools.count)
     _started: asyncio.Event = dataclasses.field(default_factory=asyncio.Event)
     _single_use_used: bool = False
@@ -152,7 +154,7 @@ class AsyncPool:
         if self._target_worker_count < 1:
             raise InvalidTargetWorkerCountError(self._target_worker_count)
 
-        task = asyncio.create_task(self._run(_check_single_use=False))
+        task = create_referenced_task(self._run(_check_single_use=False))
         try:
             # TODO: should this terminate if the run task ends?
             await self._started.wait()
@@ -186,7 +188,7 @@ class AsyncPool:
     async def _run_single(self) -> None:
         while len(self._workers) < self._target_worker_count:
             new_worker_id = next(self._worker_id_counter)
-            new_worker = asyncio.create_task(self.worker_async_callable(new_worker_id))
+            new_worker = create_referenced_task(self.worker_async_callable(new_worker_id))
             self.log.debug(f"{self.name}: adding worker {new_worker_id}")
             self._workers[new_worker] = new_worker_id
 

chia/util/augmented_chain.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, ClassVar, Dict, List, Optional, Set, Tuple, cast
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlocksProtocol
@@ -26,8 +26,8 @@ class AugmentedBlockchain:
         _protocol_check: ClassVar[BlocksProtocol] = cast("AugmentedBlockchain", None)
 
     _underlying: BlocksProtocol
-    _extra_blocks: Dict[bytes32, Tuple[FullBlock, BlockRecord]]
-    _height_to_hash: Dict[uint32, bytes32]
+    _extra_blocks: dict[bytes32, tuple[FullBlock, BlockRecord]]
+    _height_to_hash: dict[uint32, bytes32]
 
     def __init__(self, underlying: BlocksProtocol) -> None:
         self._underlying = underlying
@@ -45,15 +45,19 @@ class AugmentedBlockchain:
         self._extra_blocks[block_record.header_hash] = (block, block_record)
         self._height_to_hash[block_record.height] = block_record.header_hash
 
-    # BlocksProtocol
-    async def lookup_block_generators(self, header_hash: bytes32, generator_refs: Set[uint32]) -> Dict[uint32, bytes]:
+    def remove_extra_block(self, hh: bytes32) -> None:
+        if hh in self._extra_blocks:
+            block_record = self._extra_blocks.pop(hh)[1]
+            del self._height_to_hash[block_record.height]
 
-        generators: Dict[uint32, bytes] = {}
+    # BlocksProtocol
+    async def lookup_block_generators(self, header_hash: bytes32, generator_refs: set[uint32]) -> dict[uint32, bytes]:
+        generators: dict[uint32, bytes] = {}
 
         # traverse the additional blocks (if any) and resolve heights into
         # generators
         to_remove = []
-        curr: Optional[Tuple[FullBlock, BlockRecord]] = self._extra_blocks.get(header_hash)
+        curr: Optional[tuple[FullBlock, BlockRecord]] = self._extra_blocks.get(header_hash)
         while curr is not None:
             b = curr[0]
             if b.height in generator_refs:
@@ -119,8 +123,8 @@ class AugmentedBlockchain:
     def contains_height(self, height: uint32) -> bool:
         return (height in self._height_to_hash) or self._underlying.contains_height(height)
 
-    async def prev_block_hash(self, header_hashes: List[bytes32]) -> List[bytes32]:
-        ret: List[bytes32] = []
+    async def prev_block_hash(self, header_hashes: list[bytes32]) -> list[bytes32]:
+        ret: list[bytes32] = []
         for hh in header_hashes:
             b = self._extra_blocks.get(hh)
             if b is not None:

chia/util/batches.py

@@ -1,7 +1,10 @@
+# Package: utils
+
 from __future__ import annotations
 
+from collections.abc import Collection, Iterator
 from dataclasses import dataclass
-from typing import Collection, Generic, Iterator, List, TypeVar
+from typing import Generic, TypeVar
 
 T = TypeVar("T")
 
@@ -9,7 +12,7 @@ T = TypeVar("T")
 @dataclass(frozen=True)
 class Batch(Generic[T]):
     remaining: int
-    entries: List[T]
+    entries: list[T]
 
 
 def to_batches(to_split: Collection[T], batch_size: int) -> Iterator[Batch[T]]:

chia/util/bech32m.py

@@ -1,3 +1,5 @@
+# Package: utils
+
 # Copyright (c) 2017 Pieter Wuille
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -20,9 +22,10 @@
 
 from __future__ import annotations
 
-from typing import Iterable, List, Optional, Tuple
+from collections.abc import Iterable
+from typing import Optional
 
-from chia.types.blockchain_format.sized_bytes import bytes32
+from chia_rs.sized_bytes import bytes32
 
 # Based on this specification from Pieter Wuille:
 # https://github.com/sipa/bips/blob/bip-bech32m/bip-bech32m.mediawiki
@@ -32,7 +35,7 @@ from chia.types.blockchain_format.sized_bytes import bytes32
 CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
 
 
-def bech32_polymod(values: List[int]) -> int:
+def bech32_polymod(values: list[int]) -> int:
     """Internal function that computes the Bech32 checksum."""
     generator = [0x3B6A57B2, 0x26508E6D, 0x1EA119FA, 0x3D4233DD, 0x2A1462B3]
     chk = 1
@@ -44,7 +47,7 @@ def bech32_polymod(values: List[int]) -> int:
     return chk
 
 
-def bech32_hrp_expand(hrp: str) -> List[int]:
+def bech32_hrp_expand(hrp: str) -> list[int]:
     """Expand the HRP into values for checksum computation."""
     return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp]
 
@@ -52,23 +55,23 @@ def bech32_hrp_expand(hrp: str) -> List[int]:
 M = 0x2BC830A3
 
 
-def bech32_verify_checksum(hrp: str, data: List[int]) -> bool:
+def bech32_verify_checksum(hrp: str, data: list[int]) -> bool:
     return bech32_polymod(bech32_hrp_expand(hrp) + data) == M
 
 
-def bech32_create_checksum(hrp: str, data: List[int]) -> List[int]:
+def bech32_create_checksum(hrp: str, data: list[int]) -> list[int]:
     values = bech32_hrp_expand(hrp) + data
-    polymod = bech32_polymod(values + [0, 0, 0, 0, 0, 0]) ^ M
+    polymod = bech32_polymod([*values, 0, 0, 0, 0, 0, 0]) ^ M
     return [(polymod >> 5 * (5 - i)) & 31 for i in range(6)]
 
 
-def bech32_encode(hrp: str, data: List[int]) -> str:
+def bech32_encode(hrp: str, data: list[int]) -> str:
     """Compute a Bech32 string given HRP and data values."""
     combined = data + bech32_create_checksum(hrp, data)
     return hrp + "1" + "".join([CHARSET[d] for d in combined])
 
 
-def bech32_decode(bech: str, max_length: int = 90) -> Tuple[Optional[str], Optional[List[int]]]:
+def bech32_decode(bech: str, max_length: int = 90) -> tuple[Optional[str], Optional[list[int]]]:
     """Validate a Bech32 string, and determine HRP and data."""
     bech = bech.strip()
     if (any(ord(x) < 33 or ord(x) > 126 for x in bech)) or (bech.lower() != bech and bech.upper() != bech):
@@ -86,7 +89,7 @@ def bech32_decode(bech: str, max_length: int = 90) -> Tuple[Optional[str], Optio
     return hrp, data[:-6]
 
 
-def convertbits(data: Iterable[int], frombits: int, tobits: int, pad: bool = True) -> List[int]:
+def convertbits(data: Iterable[int], frombits: int, tobits: int, pad: bool = True) -> list[int]:
     """General power-of-2 base conversion."""
     acc = 0
     bits = 0
@@ -115,7 +118,7 @@ def encode_puzzle_hash(puzzle_hash: bytes32, prefix: str) -> str:
 
 
 def decode_puzzle_hash(address: str) -> bytes32:
-    hrpgot, data = bech32_decode(address)
+    _hrpgot, data = bech32_decode(address)
     if data is None:
         raise ValueError("Invalid Address")
     decoded = convertbits(data, 5, 8, False)