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

chia/full_node/mempool_manager.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import asyncio
 import logging
 import time
+from collections.abc import Awaitable, Collection
 from concurrent.futures import Executor, ThreadPoolExecutor
 from dataclasses import dataclass
-from typing import Awaitable, Callable, Collection, Dict, List, Optional, Set, Tuple, TypeVar
+from typing import Callable, Optional, TypeVar
 
 from chia_rs import ELIGIBLE_FOR_DEDUP, ELIGIBLE_FOR_FF, BLSCache, supports_fast_forward, validate_clvm_and_signature
 from chiabip158 import PyBIP158
@@ -33,7 +34,6 @@ from chia.util.db_wrapper import SQLITE_INT_MAX
 from chia.util.errors import Err, ValidationError
 from chia.util.inline_executor import InlineExecutor
 from chia.util.ints import uint32, uint64
-from chia.util.setproctitle import getproctitle, setproctitle
 
 log = logging.getLogger(__name__)
 
@@ -51,7 +51,7 @@ class TimelockConditions:
 
 
 def compute_assert_height(
-    removal_coin_records: Dict[bytes32, CoinRecord],
+    removal_coin_records: dict[bytes32, CoinRecord],
     conds: SpendBundleConditions,
 ) -> TimelockConditions:
     """
@@ -102,14 +102,14 @@ def compute_assert_height(
 class SpendBundleAddInfo:
     cost: Optional[uint64]
     status: MempoolInclusionStatus
-    removals: List[MempoolRemoveInfo]
+    removals: list[MempoolRemoveInfo]
     error: Optional[Err]
 
 
 @dataclass
 class NewPeakInfo:
-    items: List[NewPeakItem]
-    removals: List[MempoolRemoveInfo]
+    items: list[NewPeakItem]
+    removals: list[MempoolRemoveInfo]
 
 
 @dataclass
@@ -127,8 +127,8 @@ QUOTE_EXECUTION_COST = 20
 class MempoolManager:
     pool: Executor
     constants: ConsensusConstants
-    seen_bundle_hashes: Dict[bytes32, bytes32]
-    get_coin_records: Callable[[Collection[bytes32]], Awaitable[List[CoinRecord]]]
+    seen_bundle_hashes: dict[bytes32, bytes32]
+    get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]]
     nonzero_fee_minimum_fpc: int
     mempool_max_total_cost: int
     # a cache of MempoolItems that conflict with existing items in the pool
@@ -144,7 +144,7 @@ class MempoolManager:
 
     def __init__(
         self,
-        get_coin_records: Callable[[Collection[bytes32]], Awaitable[List[CoinRecord]]],
+        get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
         consensus_constants: ConsensusConstants,
         *,
         single_threaded: bool = False,
@@ -153,7 +153,7 @@ class MempoolManager:
         self.constants: ConsensusConstants = consensus_constants
 
         # Keep track of seen spend_bundles
-        self.seen_bundle_hashes: Dict[bytes32, bytes32] = {}
+        self.seen_bundle_hashes: dict[bytes32, bytes32] = {}
 
         self.get_coin_records = get_coin_records
 
@@ -162,12 +162,11 @@ class MempoolManager:
         # spends.
         self.nonzero_fee_minimum_fpc = 5
 
-        BLOCK_SIZE_LIMIT_FACTOR = 0.7
         # We need to deduct the block overhead, which consists of the wrapping
         # quote opcode's bytes cost as well as its execution cost.
         BLOCK_OVERHEAD = QUOTE_BYTES * self.constants.COST_PER_BYTE + QUOTE_EXECUTION_COST
 
-        self.max_block_clvm_cost = uint64(self.constants.MAX_BLOCK_COST_CLVM * BLOCK_SIZE_LIMIT_FACTOR - BLOCK_OVERHEAD)
+        self.max_block_clvm_cost = uint64(self.constants.MAX_BLOCK_COST_CLVM - BLOCK_OVERHEAD)
         self.max_tx_clvm_cost = (
             max_tx_clvm_cost if max_tx_clvm_cost is not None else uint64(self.constants.MAX_BLOCK_COST_CLVM // 2)
         )
@@ -181,11 +180,7 @@ class MempoolManager:
         if single_threaded:
             self.pool = InlineExecutor()
         else:
-            self.pool = ThreadPoolExecutor(
-                max_workers=2,
-                initializer=setproctitle,
-                initargs=(f"{getproctitle()}_mempool_worker",),
-            )
+            self.pool = ThreadPoolExecutor(max_workers=2)
 
         # The mempool will correspond to a certain peak
         self.peak: Optional[BlockRecordProtocol] = None
@@ -205,7 +200,7 @@ class MempoolManager:
         last_tb_header_hash: bytes32,
         get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
         item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
-    ) -> Optional[Tuple[SpendBundle, List[Coin]]]:
+    ) -> Optional[tuple[SpendBundle, list[Coin]]]:
         """
         Returns aggregated spendbundle that can be used for creating new block,
         additions and removals in that spend_bundle
@@ -224,7 +219,7 @@ class MempoolManager:
         )
 
     def get_filter(self) -> bytes:
-        all_transactions: Set[bytes32] = set()
+        all_transactions: set[bytes32] = set()
         byte_array_list = []
         for key in self.mempool.all_item_ids():
             if key not in all_transactions:
@@ -252,7 +247,7 @@ class MempoolManager:
     def add_and_maybe_pop_seen(self, spend_name: bytes32) -> None:
         self.seen_bundle_hashes[spend_name] = spend_name
         while len(self.seen_bundle_hashes) > self.seen_cache_size:
-            first_in = list(self.seen_bundle_hashes.keys())[0]
+            first_in = next(iter(self.seen_bundle_hashes.keys()))
             self.seen_bundle_hashes.pop(first_in)
 
     def seen(self, bundle_hash: bytes32) -> bool:
@@ -321,7 +316,7 @@ class MempoolManager:
         conds: SpendBundleConditions,
         spend_name: bytes32,
         first_added_height: uint32,
-        get_coin_records: Optional[Callable[[Collection[bytes32]], Awaitable[List[CoinRecord]]]] = None,
+        get_coin_records: Optional[Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]]] = None,
     ) -> SpendBundleAddInfo:
         """
         Validates and adds to mempool a new_spend with the given NPCResult, and spend_name, and the current mempool.
@@ -337,7 +332,7 @@ class MempoolManager:
         Returns:
             Optional[uint64]: cost of the entire transaction, None iff status is FAILED
             MempoolInclusionStatus:  SUCCESS (should add to pool), FAILED (cannot add), and PENDING (can add later)
-            List[MempoolRemoveInfo]: conflicting mempool items which were removed, if no Err
+            list[MempoolRemoveInfo]: conflicting mempool items which were removed, if no Err
             Optional[Err]: Err is set iff status is FAILED
         """
 
@@ -362,7 +357,7 @@ class MempoolManager:
             info = self.mempool.add_to_pool(item)
             if info.error is not None:
                 return SpendBundleAddInfo(item.cost, MempoolInclusionStatus.FAILED, [], info.error)
-            return SpendBundleAddInfo(item.cost, MempoolInclusionStatus.SUCCESS, info.removals + [conflict], None)
+            return SpendBundleAddInfo(item.cost, MempoolInclusionStatus.SUCCESS, [*info.removals, conflict], None)
         elif err is Err.MEMPOOL_CONFLICT and item is not None:
             # The transaction has a conflict with another item in the
             # mempool, put it aside and re-try it later
@@ -383,8 +378,8 @@ class MempoolManager:
         conds: SpendBundleConditions,
         spend_name: bytes32,
         first_added_height: uint32,
-        get_coin_records: Callable[[Collection[bytes32]], Awaitable[List[CoinRecord]]],
-    ) -> Tuple[Optional[Err], Optional[MempoolItem], List[bytes32]]:
+        get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
+    ) -> tuple[Optional[Err], Optional[MempoolItem], list[bytes32]]:
         """
         Validates new_spend with the given NPCResult, and spend_name, and the current mempool. The mempool should
         be locked during this call (blockchain lock).
@@ -400,7 +395,7 @@ class MempoolManager:
         Returns:
             Optional[Err]: Err is set if we cannot add to the mempool, None if we will immediately add to mempool
             Optional[MempoolItem]: the item to add (to mempool or pending pool)
-            List[bytes32]: conflicting mempool items to remove, if no Err
+            list[bytes32]: conflicting mempool items to remove, if no Err
         """
         start_time = time.time()
         if self.peak is None:
@@ -408,12 +403,12 @@ class MempoolManager:
 
         cost = conds.cost
 
-        removal_names: Set[bytes32] = set()
-        additions_dict: Dict[bytes32, Coin] = {}
+        removal_names: set[bytes32] = set()
+        additions_dict: dict[bytes32, Coin] = {}
         addition_amount: int = 0
         # Map of coin ID to eligibility information
-        eligibility_and_additions: Dict[bytes32, EligibilityAndAdditions] = {}
-        non_eligible_coin_ids: List[bytes32] = []
+        eligibility_and_additions: dict[bytes32, EligibilityAndAdditions] = {}
+        non_eligible_coin_ids: list[bytes32] = []
         for spend in conds.spends:
             coin_id = bytes32(spend.coin_id)
             removal_names.add(coin_id)
@@ -422,7 +417,7 @@ class MempoolManager:
                 child_coin = Coin(coin_id, puzzle_hash, uint64(amount))
                 spend_additions.append(child_coin)
                 additions_dict[child_coin.name()] = child_coin
-                addition_amount = addition_amount + child_coin.amount
+                addition_amount += child_coin.amount
             is_eligible_for_dedup = bool(spend.flags & ELIGIBLE_FOR_DEDUP)
             is_eligible_for_ff = bool(spend.flags & ELIGIBLE_FOR_FF)
             eligibility_and_additions[coin_id] = EligibilityAndAdditions(
@@ -430,9 +425,9 @@ class MempoolManager:
                 spend_additions=spend_additions,
                 is_eligible_for_ff=is_eligible_for_ff,
             )
-        removal_names_from_coin_spends: Set[bytes32] = set()
-        fast_forward_coin_ids: Set[bytes32] = set()
-        bundle_coin_spends: Dict[bytes32, BundleCoinSpend] = {}
+        removal_names_from_coin_spends: set[bytes32] = set()
+        fast_forward_coin_ids: set[bytes32] = set()
+        bundle_coin_spends: dict[bytes32, BundleCoinSpend] = {}
         for coin_spend in new_spend.coin_spends:
             coin_id = coin_spend.coin.name()
             removal_names_from_coin_spends.add(coin_id)
@@ -457,7 +452,7 @@ class MempoolManager:
             # If you reach here it's probably because your program reveal doesn't match the coin's puzzle hash
             return Err.INVALID_SPEND_BUNDLE, None, []
 
-        removal_record_dict: Dict[bytes32, CoinRecord] = {}
+        removal_record_dict: dict[bytes32, CoinRecord] = {}
         removal_amount: int = 0
         removal_records = await get_coin_records(removal_names)
         for record in removal_records:
@@ -485,7 +480,7 @@ class MempoolManager:
                 removal_record_dict[name] = removal_record
             else:
                 removal_record = removal_record_dict[name]
-            removal_amount = removal_amount + removal_record.coin.amount
+            removal_amount += removal_record.coin.amount
 
         fees = uint64(removal_amount - addition_amount)
 
@@ -580,17 +575,17 @@ class MempoolManager:
         log.log(
             logging.DEBUG if duration < 2 else logging.WARNING,
             f"add_spendbundle {spend_name} took {duration:0.2f} seconds. "
-            f"Cost: {cost} ({round(100.0 * cost/self.constants.MAX_BLOCK_COST_CLVM, 3)}% of max block cost)",
+            f"Cost: {cost} ({round(100.0 * cost / self.constants.MAX_BLOCK_COST_CLVM, 3)}% of max block cost)",
         )
 
         return None, potential, [item.name for item in conflicts]
 
     def check_removals(
         self,
-        non_eligible_coin_ids: List[bytes32],
-        removals: Dict[bytes32, CoinRecord],
-        fast_forward_coin_ids: Set[bytes32],
-    ) -> Tuple[Optional[Err], List[MempoolItem]]:
+        non_eligible_coin_ids: list[bytes32],
+        removals: dict[bytes32, CoinRecord],
+        fast_forward_coin_ids: set[bytes32],
+    ) -> tuple[Optional[Err], list[MempoolItem]]:
         """
         This function checks for double spends, unknown spends and conflicting transactions in mempool.
         Returns Error (if any), the set of existing MempoolItems with conflicting spends (if any).
@@ -636,7 +631,7 @@ class MempoolManager:
         return item
 
     async def new_peak(
-        self, new_peak: Optional[BlockRecordProtocol], spent_coins: Optional[List[bytes32]]
+        self, new_peak: Optional[BlockRecordProtocol], spent_coins: Optional[list[bytes32]]
     ) -> NewPeakInfo:
         """
         Called when a new peak is available, we try to recreate a mempool for the new tip.
@@ -655,10 +650,10 @@ class MempoolManager:
             return NewPeakInfo([], [])
         assert new_peak.timestamp is not None
         self.fee_estimator.new_block_height(new_peak.height)
-        included_items: List[MempoolItemInfo] = []
+        included_items: list[MempoolItemInfo] = []
 
         expired = self.mempool.new_tx_block(new_peak.height, new_peak.timestamp)
-        mempool_item_removals: List[MempoolRemoveInfo] = [expired]
+        mempool_item_removals: list[MempoolRemoveInfo] = [expired]
 
         use_optimization: bool = self.peak is not None and new_peak.prev_transaction_block_hash == self.peak.header_hash
         self.peak = new_peak
@@ -669,7 +664,7 @@ class MempoolManager:
             # when looking up transactions by all coin IDs, we're likely to
             # find the same transaction multiple times. We put them in a set
             # to deduplicate
-            spendbundle_ids_to_remove: Set[bytes32] = set()
+            spendbundle_ids_to_remove: set[bytes32] = set()
             for spend in spent_coins:
                 items = self.mempool.get_items_by_coin_id(spend)
                 for item in items:
@@ -692,9 +687,9 @@ class MempoolManager:
 
             # in order to make this a bit quicker, we look-up all the spends in
             # a single query, rather than one at a time.
-            coin_records: Dict[bytes32, CoinRecord] = {}
+            coin_records: dict[bytes32, CoinRecord] = {}
 
-            removals: Set[bytes32] = set()
+            removals: set[bytes32] = set()
             for item in old_pool.all_items():
                 for s in item.spend_bundle.coin_spends:
                     removals.add(s.coin.name())
@@ -703,8 +698,8 @@ class MempoolManager:
                 name = record.coin.name()
                 coin_records[name] = record
 
-            async def local_get_coin_records(names: Collection[bytes32]) -> List[CoinRecord]:
-                ret: List[CoinRecord] = []
+            async def local_get_coin_records(names: Collection[bytes32]) -> list[CoinRecord]:
+                ret: list[CoinRecord] = []
                 for name in names:
                     r = coin_records.get(name)
                     if r is not None:
@@ -751,8 +746,8 @@ class MempoolManager:
         self.mempool.fee_estimator.new_block(FeeBlockInfo(new_peak.height, included_items))
         return NewPeakInfo(txs_added, mempool_item_removals)
 
-    def get_items_not_in_filter(self, mempool_filter: PyBIP158, limit: int = 100) -> List[SpendBundle]:
-        items: List[SpendBundle] = []
+    def get_items_not_in_filter(self, mempool_filter: PyBIP158, limit: int = 100) -> list[SpendBundle]:
+        items: list[SpendBundle] = []
 
         assert limit > 0
 
@@ -779,8 +774,8 @@ def optional_max(a: Optional[T], b: Optional[T]) -> Optional[T]:
 
 
 def can_replace(
-    conflicting_items: List[MempoolItem],
-    removal_names: Set[bytes32],
+    conflicting_items: list[MempoolItem],
+    removal_names: set[bytes32],
     new_item: MempoolItem,
 ) -> bool:
     """

chia/full_node/pending_tx_cache.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Dict, Optional
+from typing import Optional
 
 from sortedcontainers import SortedDict
 
@@ -15,7 +15,7 @@ class ConflictTxCache:
     _cache_max_total_cost: int
     _cache_max_size: int = 1000
     _cache_cost: int = field(default=0, init=False)
-    _txs: Dict[bytes32, MempoolItem] = field(default_factory=dict, init=False)
+    _txs: dict[bytes32, MempoolItem] = field(default_factory=dict, init=False)
 
     def get(self, bundle_name: bytes32) -> Optional[MempoolItem]:
         return self._txs.get(bundle_name, None)
@@ -34,11 +34,11 @@ class ConflictTxCache:
         self._cache_cost += item.cost
 
         while self._cache_cost > self._cache_max_total_cost or len(self._txs) > self._cache_max_size:
-            first_in = list(self._txs.keys())[0]
+            first_in = next(iter(self._txs.keys()))
             self._cache_cost -= self._txs[first_in].cost
             self._txs.pop(first_in)
 
-    def drain(self) -> Dict[bytes32, MempoolItem]:
+    def drain(self) -> dict[bytes32, MempoolItem]:
         ret = self._txs
         self._txs = {}
         self._cache_cost = 0
@@ -53,8 +53,8 @@ class PendingTxCache:
     _cache_max_total_cost: int
     _cache_max_size: int = 3000
     _cache_cost: int = field(default=0, init=False)
-    _txs: Dict[bytes32, MempoolItem] = field(default_factory=dict, init=False)
-    _by_height: SortedDict[uint32, Dict[bytes32, MempoolItem]] = field(default_factory=SortedDict, init=False)
+    _txs: dict[bytes32, MempoolItem] = field(default_factory=dict, init=False)
+    _by_height: SortedDict[uint32, dict[bytes32, MempoolItem]] = field(default_factory=SortedDict, init=False)
 
     def get(self, bundle_name: bytes32) -> Optional[MempoolItem]:
         return self._txs.get(bundle_name, None)
@@ -82,15 +82,15 @@ class PendingTxCache:
                 self._txs.pop(to_evict[0])
                 continue
 
-            first_in = list(to_evict[1].keys())[0]
+            first_in = next(iter(to_evict[1].keys()))
             removed_item = self._txs.pop(first_in)
             self._cache_cost -= removed_item.cost
             to_evict[1].pop(first_in)
             if to_evict[1] == {}:
                 self._by_height.popitem()
 
-    def drain(self, up_to_height: uint32) -> Dict[bytes32, MempoolItem]:
-        ret: Dict[bytes32, MempoolItem] = {}
+    def drain(self, up_to_height: uint32) -> dict[bytes32, MempoolItem]:
+        ret: dict[bytes32, MempoolItem] = {}
 
         if self._txs == {}:
             return ret

chia/full_node/subscriptions.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass, field
-from typing import Dict, List, Set
 
 from chia_rs import Coin
 
@@ -15,8 +14,8 @@ log = logging.getLogger(__name__)
 
 @dataclass(frozen=True)
 class SubscriptionSet:
-    _subscriptions_for_peer: Dict[bytes32, Set[bytes32]] = field(default_factory=dict, init=False)
-    _peers_for_subscription: Dict[bytes32, Set[bytes32]] = field(default_factory=dict, init=False)
+    _subscriptions_for_peer: dict[bytes32, set[bytes32]] = field(default_factory=dict, init=False)
+    _peers_for_subscription: dict[bytes32, set[bytes32]] = field(default_factory=dict, init=False)
 
     def add_subscription(self, peer_id: bytes32, item: bytes32) -> bool:
         peers = self._peers_for_subscription.setdefault(item, set())
@@ -61,10 +60,10 @@ class SubscriptionSet:
             if len(self._peers_for_subscription[item]) == 0:
                 self._peers_for_subscription.pop(item)
 
-    def subscriptions(self, peer_id: bytes32) -> Set[bytes32]:
+    def subscriptions(self, peer_id: bytes32) -> set[bytes32]:
         return self._subscriptions_for_peer.get(peer_id, set())
 
-    def peers(self, item: bytes32) -> Set[bytes32]:
+    def peers(self, item: bytes32) -> set[bytes32]:
         return self._peers_for_subscription.get(item, set())
 
     def total_count(self) -> int:
@@ -87,15 +86,15 @@ class PeerSubscriptions:
         coin_subscriptions = self._coin_subscriptions.count_subscriptions(peer_id)
         return puzzle_subscriptions + coin_subscriptions
 
-    def add_puzzle_subscriptions(self, peer_id: bytes32, puzzle_hashes: List[bytes32], max_items: int) -> Set[bytes32]:
+    def add_puzzle_subscriptions(self, peer_id: bytes32, puzzle_hashes: list[bytes32], max_items: int) -> set[bytes32]:
         """
         Adds subscriptions until max_items is reached. Filters out duplicates and returns all additions.
         """
 
         subscription_count = self.peer_subscription_count(peer_id)
-        added: Set[bytes32] = set()
+        added: set[bytes32] = set()
 
-        def limit_reached() -> Set[bytes32]:
+        def limit_reached() -> set[bytes32]:
             log.info(
                 "Peer %s attempted to exceed the subscription limit while adding puzzle subscriptions.",
                 peer_id,
@@ -121,15 +120,15 @@ class PeerSubscriptions:
 
         return added
 
-    def add_coin_subscriptions(self, peer_id: bytes32, coin_ids: List[bytes32], max_items: int) -> Set[bytes32]:
+    def add_coin_subscriptions(self, peer_id: bytes32, coin_ids: list[bytes32], max_items: int) -> set[bytes32]:
         """
         Adds subscriptions until max_items is reached. Filters out duplicates and returns all additions.
         """
 
         subscription_count = self.peer_subscription_count(peer_id)
-        added: Set[bytes32] = set()
+        added: set[bytes32] = set()
 
-        def limit_reached() -> Set[bytes32]:
+        def limit_reached() -> set[bytes32]:
             log.info(
                 "Peer %s attempted to exceed the subscription limit while adding coin subscriptions.",
                 peer_id,
@@ -155,12 +154,12 @@ class PeerSubscriptions:
 
         return added
 
-    def remove_puzzle_subscriptions(self, peer_id: bytes32, puzzle_hashes: List[bytes32]) -> Set[bytes32]:
+    def remove_puzzle_subscriptions(self, peer_id: bytes32, puzzle_hashes: list[bytes32]) -> set[bytes32]:
         """
         Removes subscriptions. Filters out duplicates and returns all removals.
         """
 
-        removed: Set[bytes32] = set()
+        removed: set[bytes32] = set()
 
         for puzzle_hash in puzzle_hashes:
             if not self._puzzle_subscriptions.remove_subscription(peer_id, puzzle_hash):
@@ -170,12 +169,12 @@ class PeerSubscriptions:
 
         return removed
 
-    def remove_coin_subscriptions(self, peer_id: bytes32, coin_ids: List[bytes32]) -> Set[bytes32]:
+    def remove_coin_subscriptions(self, peer_id: bytes32, coin_ids: list[bytes32]) -> set[bytes32]:
         """
         Removes subscriptions. Filters out duplicates and returns all removals.
         """
 
-        removed: Set[bytes32] = set()
+        removed: set[bytes32] = set()
 
         for coin_id in coin_ids:
             if not self._coin_subscriptions.remove_subscription(peer_id, coin_id):
@@ -195,16 +194,16 @@ class PeerSubscriptions:
         self._puzzle_subscriptions.remove_peer(peer_id)
         self._coin_subscriptions.remove_peer(peer_id)
 
-    def coin_subscriptions(self, peer_id: bytes32) -> Set[bytes32]:
+    def coin_subscriptions(self, peer_id: bytes32) -> set[bytes32]:
         return self._coin_subscriptions.subscriptions(peer_id)
 
-    def puzzle_subscriptions(self, peer_id: bytes32) -> Set[bytes32]:
+    def puzzle_subscriptions(self, peer_id: bytes32) -> set[bytes32]:
         return self._puzzle_subscriptions.subscriptions(peer_id)
 
-    def peers_for_coin_id(self, coin_id: bytes32) -> Set[bytes32]:
+    def peers_for_coin_id(self, coin_id: bytes32) -> set[bytes32]:
         return self._coin_subscriptions.peers(coin_id)
 
-    def peers_for_puzzle_hash(self, puzzle_hash: bytes32) -> Set[bytes32]:
+    def peers_for_puzzle_hash(self, puzzle_hash: bytes32) -> set[bytes32]:
         return self._puzzle_subscriptions.peers(puzzle_hash)
 
     def coin_subscription_count(self) -> int:
@@ -215,16 +214,16 @@ class PeerSubscriptions:
 
 
 def peers_for_spend_bundle(
-    peer_subscriptions: PeerSubscriptions, conds: SpendBundleConditions, hints_for_removals: Set[bytes32]
-) -> Set[bytes32]:
+    peer_subscriptions: PeerSubscriptions, conds: SpendBundleConditions, hints_for_removals: set[bytes32]
+) -> set[bytes32]:
     """
     Returns a list of peer ids that are subscribed to any of the created or
     spent coins, puzzle hashes, or hints in the spend bundle. To avoid repeated
     lookups, `hints_for_removals` should be a set of all puzzle hashes that are being removed.
     """
 
-    coin_ids: Set[bytes32] = set()
-    puzzle_hashes: Set[bytes32] = hints_for_removals.copy()
+    coin_ids: set[bytes32] = set()
+    puzzle_hashes: set[bytes32] = hints_for_removals.copy()
 
     for spend in conds.spends:
         coin_ids.add(bytes32(spend.coin_id))
@@ -237,7 +236,7 @@ def peers_for_spend_bundle(
             if memo is not None and len(memo) == 32:
                 puzzle_hashes.add(bytes32(memo))
 
-    peers: Set[bytes32] = set()
+    peers: set[bytes32] = set()
 
     for coin_id in coin_ids:
         peers |= peer_subscriptions.peers_for_coin_id(coin_id)

chia/full_node/sync_store.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import asyncio
 import collections
 import logging
+from collections import OrderedDict
 from collections import OrderedDict as orderedDict
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional, OrderedDict, Set
+from typing import Optional
 
 import typing_extensions
 
@@ -29,14 +30,14 @@ class SyncStore:
     sync_mode: bool = False
     long_sync: bool = False
     # Header hash : peer node id
-    peak_to_peer: OrderedDict[bytes32, Set[bytes32]] = field(default_factory=orderedDict)
+    peak_to_peer: OrderedDict[bytes32, set[bytes32]] = field(default_factory=orderedDict)
     # peer node id : Peak
-    peer_to_peak: Dict[bytes32, Peak] = field(default_factory=dict)
+    peer_to_peak: dict[bytes32, Peak] = field(default_factory=dict)
     # Peak we are syncing towards
     target_peak: Optional[Peak] = None
     peers_changed: asyncio.Event = field(default_factory=asyncio.Event)
     # Set of nodes which we are batch syncing from
-    batch_syncing: Set[bytes32] = field(default_factory=set)
+    batch_syncing: set[bytes32] = field(default_factory=set)
     # Set of nodes which we are backtrack syncing from, and how many threads
     _backtrack_syncing: collections.defaultdict[bytes32, int] = field(
         default_factory=lambda: collections.defaultdict(int),
@@ -79,19 +80,19 @@ class SyncStore:
         if new_peak:
             self.peer_to_peak[peer_id] = Peak(header_hash, height, weight)
 
-    def get_peers_that_have_peak(self, header_hashes: List[bytes32]) -> Set[bytes32]:
+    def get_peers_that_have_peak(self, header_hashes: list[bytes32]) -> set[bytes32]:
         """
         Returns: peer ids of peers that have at least one of the header hashes.
         """
 
-        node_ids: Set[bytes32] = set()
+        node_ids: set[bytes32] = set()
         for header_hash in header_hashes:
             if header_hash in self.peak_to_peer:
                 for node_id in self.peak_to_peer[header_hash]:
                     node_ids.add(node_id)
         return node_ids
 
-    def get_peak_of_each_peer(self) -> Dict[bytes32, Peak]:
+    def get_peak_of_each_peer(self) -> dict[bytes32, Peak]:
         """
         Returns: dictionary of peer id to peak information.
         """

chia/full_node/tx_processing_queue.py

@@ -4,7 +4,7 @@ import asyncio
 import logging
 from dataclasses import dataclass
 from queue import SimpleQueue
-from typing import Dict, List, Optional
+from typing import Optional
 
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.transaction_queue_entry import TransactionQueueEntry
@@ -25,8 +25,8 @@ class TransactionQueue:
 
     _list_cursor: int  # this is which index
     _queue_length: asyncio.Semaphore
-    _index_to_peer_map: List[bytes32]
-    _queue_dict: Dict[bytes32, SimpleQueue[TransactionQueueEntry]]
+    _index_to_peer_map: list[bytes32]
+    _queue_dict: dict[bytes32, SimpleQueue[TransactionQueueEntry]]
     _high_priority_queue: SimpleQueue[TransactionQueueEntry]
     peer_size_limit: int
     log: logging.Logger