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

chia/full_node/full_node_store.py

@@ -4,7 +4,7 @@ import asyncio
 import dataclasses
 import logging
 import time
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Optional
 
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
@@ -33,8 +33,8 @@ log = logging.getLogger(__name__)
 @dataclasses.dataclass(frozen=True)
 class FullNodeStorePeakResult(Streamable):
     added_eos: Optional[EndOfSubSlotBundle]
-    new_signage_points: List[Tuple[uint8, SignagePoint]]
-    new_infusion_points: List[timelord_protocol.NewInfusionPointVDF]
+    new_signage_points: list[tuple[uint8, SignagePoint]]
+    new_infusion_points: list[timelord_protocol.NewInfusionPointVDF]
 
 
 @dataclasses.dataclass
@@ -49,8 +49,8 @@ class UnfinishedBlockEntry:
 
 
 def find_best_block(
-    result: Dict[Optional[bytes32], UnfinishedBlockEntry]
-) -> Tuple[Optional[bytes32], Optional[UnfinishedBlock]]:
+    result: dict[Optional[bytes32], UnfinishedBlockEntry],
+) -> tuple[Optional[bytes32], Optional[UnfinishedBlock]]:
     """
     Given a collection of UnfinishedBlocks (all with the same reward block
     hash), return the "best" one. i.e. the one with the smallest foliage hash.
@@ -67,7 +67,7 @@ def find_best_block(
         else:
             return foliage_hash, entry.unfinished_block
 
-    def include_block(item: Tuple[Optional[bytes32], UnfinishedBlockEntry]) -> bool:
+    def include_block(item: tuple[Optional[bytes32], UnfinishedBlockEntry]) -> bool:
         foliage_hash, entry = item
         return foliage_hash is not None and entry.unfinished_block is not None
 
@@ -88,14 +88,14 @@ class FullNodeStore:
     constants: ConsensusConstants
 
     # Blocks which we have created, but don't have plot signatures yet, so not yet "unfinished blocks"
-    candidate_blocks: Dict[bytes32, Tuple[uint32, UnfinishedBlock]]
-    candidate_backup_blocks: Dict[bytes32, Tuple[uint32, UnfinishedBlock]]
+    candidate_blocks: dict[bytes32, tuple[uint32, UnfinishedBlock]]
+    candidate_backup_blocks: dict[bytes32, tuple[uint32, UnfinishedBlock]]
 
     # Block hashes of unfinished blocks that we have seen recently. This is
-    # effectively a Set[bytes32] but in order to evict the oldest items first,
+    # effectively a set[bytes32] but in order to evict the oldest items first,
     # we use a Dict that preserves insertion order, and remove from the
     # beginning
-    seen_unfinished_blocks: Dict[bytes32, None]
+    seen_unfinished_blocks: dict[bytes32, None]
 
     # Unfinished blocks, keyed from reward hash
     # There may be multiple different unfinished blocks with the same partial
@@ -107,36 +107,36 @@ class FullNodeStore:
     # The inner key (the foliage hash) is Optional, where None either means
     # it's not a transaction block, or it's a block we learned about via the old
     # protocol, where all we get is the reward block hash.
-    _unfinished_blocks: Dict[bytes32, Dict[Optional[bytes32], UnfinishedBlockEntry]]
+    _unfinished_blocks: dict[bytes32, dict[Optional[bytes32], UnfinishedBlockEntry]]
 
     # Finished slots and sps from the peak's slot onwards
     # We store all 32 SPs for each slot, starting as 32 Nones and filling them as we go
     # Also stores the total iters at the end of slot
     # For the first sub-slot, EndOfSlotBundle is None
-    finished_sub_slots: List[Tuple[Optional[EndOfSubSlotBundle], List[Optional[SignagePoint]], uint128]]
+    finished_sub_slots: list[tuple[Optional[EndOfSubSlotBundle], list[Optional[SignagePoint]], uint128]]
 
     # These caches maintain objects which depend on infused blocks in the reward chain, that we
     # might receive before the blocks themselves. The dict keys are the reward chain challenge hashes.
 
     # End of slots which depend on infusions that we don't have
-    future_eos_cache: Dict[bytes32, List[EndOfSubSlotBundle]]
+    future_eos_cache: dict[bytes32, list[EndOfSubSlotBundle]]
 
     # Signage points which depend on infusions that we don't have
-    future_sp_cache: Dict[bytes32, List[Tuple[uint8, SignagePoint]]]
+    future_sp_cache: dict[bytes32, list[tuple[uint8, SignagePoint]]]
 
     # Infusion point VDFs which depend on infusions that we don't have
-    future_ip_cache: Dict[bytes32, List[timelord_protocol.NewInfusionPointVDF]]
+    future_ip_cache: dict[bytes32, list[timelord_protocol.NewInfusionPointVDF]]
 
     # This stores the time that each key was added to the future cache, so we can clear old keys
-    future_cache_key_times: Dict[bytes32, int]
+    future_cache_key_times: dict[bytes32, int]
 
     # These recent caches are for pooling support
-    recent_signage_points: LRUCache[bytes32, Tuple[SignagePoint, float]]
-    recent_eos: LRUCache[bytes32, Tuple[EndOfSubSlotBundle, float]]
+    recent_signage_points: LRUCache[bytes32, tuple[SignagePoint, float]]
+    recent_eos: LRUCache[bytes32, tuple[EndOfSubSlotBundle, float]]
 
-    pending_tx_request: Dict[bytes32, bytes32]  # tx_id: peer_id
-    peers_with_tx: Dict[bytes32, Set[bytes32]]  # tx_id: Set[peer_ids}
-    tx_fetch_tasks: Dict[bytes32, asyncio.Task[None]]  # Task id: task
+    pending_tx_request: dict[bytes32, bytes32]  # tx_id: peer_id
+    peers_with_tx: dict[bytes32, set[bytes32]]  # tx_id: set[peer_ids}
+    tx_fetch_tasks: dict[bytes32, asyncio.Task[None]]  # Task id: task
     serialized_wp_message: Optional[Message]
     serialized_wp_message_tip: Optional[bytes32]
 
@@ -166,7 +166,7 @@ class FullNodeStore:
 
     def is_requesting_unfinished_block(
         self, reward_block_hash: bytes32, foliage_hash: Optional[bytes32]
-    ) -> Tuple[bool, int]:
+    ) -> tuple[bool, int]:
         """
         Asks if we are already requesting this specific unfinished block (given
         the reward block hash and foliage hash). The returned bool is true if we
@@ -212,7 +212,7 @@ class FullNodeStore:
 
     def get_candidate_block(
         self, quality_string: bytes32, backup: bool = False
-    ) -> Optional[Tuple[uint32, UnfinishedBlock]]:
+    ) -> Optional[tuple[uint32, UnfinishedBlock]]:
         if backup:
             return self.candidate_backup_blocks.get(quality_string, None)
         else:
@@ -268,12 +268,12 @@ class FullNodeStore:
         # deterministic property.
         # this sorts the UnfinishedBlocks by the foliage hash, and picks the
         # smallest hash
-        foliage_hash, block = find_best_block(result)
+        _foliage_hash, block = find_best_block(result)
         return block
 
     def get_unfinished_block2(
         self, unfinished_reward_hash: bytes32, unfinished_foliage_hash: Optional[bytes32]
-    ) -> Tuple[Optional[UnfinishedBlock], int, bool]:
+    ) -> tuple[Optional[UnfinishedBlock], int, bool]:
         """
         Looks up an UnfinishedBlock by its reward block hash and foliage hash.
         If the foliage hash is None (e.g. it's not a transaction block), we fall
@@ -315,8 +315,8 @@ class FullNodeStore:
             return result.get(unfinished_foliage_hash)
 
     # returns all unfinished blocks for the specified height
-    def get_unfinished_blocks(self, height: uint32) -> List[UnfinishedBlock]:
-        ret: List[UnfinishedBlock] = []
+    def get_unfinished_blocks(self, height: uint32) -> list[UnfinishedBlock]:
+        ret: list[UnfinishedBlock] = []
         for entry in self._unfinished_blocks.values():
             for ube in entry.values():
                 if ube.height == height and ube.unfinished_block is not None:
@@ -324,9 +324,9 @@ class FullNodeStore:
         return ret
 
     def clear_unfinished_blocks_below(self, height: uint32) -> None:
-        del_partial: List[bytes32] = []
+        del_partial: list[bytes32] = []
         for partial_hash, entry in self._unfinished_blocks.items():
-            del_foliage: List[Optional[bytes32]] = []
+            del_foliage: list[Optional[bytes32]] = []
             for foliage_hash, ube in entry.items():
                 if ube.height < height:
                     del_foliage.append(foliage_hash)
@@ -377,12 +377,12 @@ class FullNodeStore:
         self.future_sp_cache[signage_point.rc_vdf.challenge].append((index, signage_point))
         log.info(f"Don't have rc hash {signage_point.rc_vdf.challenge.hex()}. caching signage point {index}.")
 
-    def get_future_ip(self, rc_challenge_hash: bytes32) -> List[timelord_protocol.NewInfusionPointVDF]:
+    def get_future_ip(self, rc_challenge_hash: bytes32) -> list[timelord_protocol.NewInfusionPointVDF]:
         return self.future_ip_cache.get(rc_challenge_hash, [])
 
     def clear_old_cache_entries(self) -> None:
         current_time: int = int(time.time())
-        remove_keys: List[bytes32] = []
+        remove_keys: list[bytes32] = []
         for rc_hash, time_added in self.future_cache_key_times.items():
             if current_time - time_added > 3600:
                 remove_keys.append(rc_hash)
@@ -395,7 +395,7 @@ class FullNodeStore:
     def clear_slots(self) -> None:
         self.finished_sub_slots.clear()
 
-    def get_sub_slot(self, challenge_hash: bytes32) -> Optional[Tuple[EndOfSubSlotBundle, int, uint128]]:
+    def get_sub_slot(self, challenge_hash: bytes32) -> Optional[tuple[EndOfSubSlotBundle, int, uint128]]:
         assert len(self.finished_sub_slots) >= 1
         for index, (sub_slot, _, total_iters) in enumerate(self.finished_sub_slots):
             if sub_slot is not None and sub_slot.challenge_chain.get_hash() == challenge_hash:
@@ -414,7 +414,7 @@ class FullNodeStore:
         next_sub_slot_iters: uint64,
         next_difficulty: uint64,
         peak_full_block: Optional[FullBlock],
-    ) -> Optional[List[timelord_protocol.NewInfusionPointVDF]]:
+    ) -> Optional[list[timelord_protocol.NewInfusionPointVDF]]:
         """
         Returns false if not added. Returns a list if added. The list contains all infusion points that depended
         on this sub slot
@@ -671,7 +671,7 @@ class FullNodeStore:
         new_cc_hash = eos.challenge_chain.get_hash()
         self.recent_eos.put(new_cc_hash, (eos, time.time()))
 
-        new_ips: List[timelord_protocol.NewInfusionPointVDF] = []
+        new_ips: list[timelord_protocol.NewInfusionPointVDF] = []
         for ip in self.future_ip_cache.get(eos.reward_chain.get_hash(), []):
             new_ips.append(ip)
 
@@ -904,8 +904,8 @@ class FullNodeStore:
             self.initialize_genesis_sub_slot()
         else:
             # This is not the first sub-slot in the chain
-            sp_sub_slot_sps: List[Optional[SignagePoint]] = [None] * self.constants.NUM_SPS_SUB_SLOT
-            ip_sub_slot_sps: List[Optional[SignagePoint]] = [None] * self.constants.NUM_SPS_SUB_SLOT
+            sp_sub_slot_sps: list[Optional[SignagePoint]] = [None] * self.constants.NUM_SPS_SUB_SLOT
+            ip_sub_slot_sps: list[Optional[SignagePoint]] = [None] * self.constants.NUM_SPS_SUB_SLOT
 
             if fork_block is not None and fork_block.sub_slot_iters != peak.sub_slot_iters:
                 # If there was a reorg and a difficulty adjustment, just clear all the slots
@@ -921,7 +921,7 @@ class FullNodeStore:
                     if fork_block is None:
                         # If this is not a reorg, we still want to remove signage points after the new peak
                         fork_block = peak
-                    replaced_sps: List[Optional[SignagePoint]] = []  # index 0 is the end of sub slot
+                    replaced_sps: list[Optional[SignagePoint]] = []  # index 0 is the end of sub slot
                     for i, sp in enumerate(sps):
                         if (total_iters + i * interval_iters) < fork_block.total_iters:
                             # Sps before the fork point as still valid
@@ -951,10 +951,10 @@ class FullNodeStore:
             self.finished_sub_slots.append((ip_sub_slot, ip_sub_slot_sps, ip_sub_slot_total_iters))
 
         new_eos: Optional[EndOfSubSlotBundle] = None
-        new_sps: List[Tuple[uint8, SignagePoint]] = []
-        new_ips: List[timelord_protocol.NewInfusionPointVDF] = []
+        new_sps: list[tuple[uint8, SignagePoint]] = []
+        new_ips: list[timelord_protocol.NewInfusionPointVDF] = []
 
-        future_eos: List[EndOfSubSlotBundle] = self.future_eos_cache.get(peak.reward_infusion_new_challenge, []).copy()
+        future_eos: list[EndOfSubSlotBundle] = self.future_eos_cache.get(peak.reward_infusion_new_challenge, []).copy()
         for eos in future_eos:
             if (
                 self.new_finished_sub_slot(eos, blocks, peak, next_sub_slot_iters, next_difficulty, peak_full_block)
@@ -963,7 +963,7 @@ class FullNodeStore:
                 new_eos = eos
                 break
 
-        future_sps: List[Tuple[uint8, SignagePoint]] = self.future_sp_cache.get(
+        future_sps: list[tuple[uint8, SignagePoint]] = self.future_sp_cache.get(
             peak.reward_infusion_new_challenge, []
         ).copy()
         for index, sp in future_sps:
@@ -990,7 +990,7 @@ class FullNodeStore:
         block_records: BlockRecordsProtocol,
         prev_b: Optional[BlockRecord],
         last_challenge_to_add: bytes32,
-    ) -> Optional[List[EndOfSubSlotBundle]]:
+    ) -> Optional[list[EndOfSubSlotBundle]]:
         """
         Retrieves the EndOfSubSlotBundles that are in the store either:
         1. From the starting challenge if prev_b is None
@@ -1015,7 +1015,7 @@ class FullNodeStore:
             # No additional slots to add
             return []
 
-        collected_sub_slots: List[EndOfSubSlotBundle] = []
+        collected_sub_slots: list[EndOfSubSlotBundle] = []
         found_last_challenge = False
         found_connecting_challenge = False
         for sub_slot, sps, total_iters in self.finished_sub_slots[1:]:

chia/full_node/hint_management.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Callable, List, Optional, Set, Tuple
+from typing import Callable, Optional
 
 from chia.consensus.blockchain import StateChangeSummary
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -10,16 +10,16 @@ def get_hints_and_subscription_coin_ids(
     state_change_summary: StateChangeSummary,
     has_coin_subscription: Callable[[bytes32], bool],
     has_puzzle_subscription: Callable[[bytes32], bool],
-) -> Tuple[List[Tuple[bytes32, bytes]], List[bytes32]]:
+) -> tuple[list[tuple[bytes32, bytes]], list[bytes32]]:
     # Precondition: all hints passed in are max 32 bytes long
     # Returns the hints that we need to add to the DB, and the coin ids that need to be looked up
 
     # Finds the coin IDs that we need to lookup in order to notify wallets of hinted transactions
     hint: Optional[bytes]
-    hints_to_add: List[Tuple[bytes32, bytes]] = []
+    hints_to_add: list[tuple[bytes32, bytes]] = []
 
     # Goes through additions and removals for each block and flattens to a map and a set
-    lookup_coin_ids: Set[bytes32] = set()
+    lookup_coin_ids: set[bytes32] = set()
 
     def add_if_coin_subscription(coin_id: bytes32) -> None:
         if has_coin_subscription(coin_id):

chia/full_node/hint_store.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import dataclasses
 import logging
-from typing import List, Set, Tuple
 
 import typing_extensions
 
@@ -32,23 +31,23 @@ class HintStore:
             await conn.execute("CREATE INDEX IF NOT EXISTS hint_index on hints(hint)")
         return self
 
-    async def get_coin_ids(self, hint: bytes, *, max_items: int = 50000) -> List[bytes32]:
+    async def get_coin_ids(self, hint: bytes, *, max_items: int = 50000) -> list[bytes32]:
         async with self.db_wrapper.reader_no_transaction() as conn:
             cursor = await conn.execute("SELECT coin_id from hints WHERE hint=? LIMIT ?", (hint, max_items))
             rows = await cursor.fetchall()
             await cursor.close()
         return [bytes32(row[0]) for row in rows]
 
-    async def get_coin_ids_multi(self, hints: Set[bytes], *, max_items: int = 50000) -> List[bytes32]:
-        coin_ids: List[bytes32] = []
+    async def get_coin_ids_multi(self, hints: set[bytes], *, max_items: int = 50000) -> list[bytes32]:
+        coin_ids: list[bytes32] = []
 
         async with self.db_wrapper.reader_no_transaction() as conn:
             for batch in to_batches(hints, SQLITE_MAX_VARIABLE_NUMBER):
-                hints_db: Tuple[bytes, ...] = tuple(batch.entries)
+                hints_db: tuple[bytes, ...] = tuple(batch.entries)
                 cursor = await conn.execute(
                     f"SELECT coin_id from hints INDEXED BY hint_index "
                     f'WHERE hint IN ({"?," * (len(batch.entries) - 1)}?) LIMIT ?',
-                    hints_db + (max_items,),
+                    (*hints_db, max_items),
                 )
                 rows = await cursor.fetchall()
                 coin_ids.extend([bytes32(row[0]) for row in rows])
@@ -56,12 +55,12 @@ class HintStore:
 
         return coin_ids
 
-    async def get_hints(self, coin_ids: List[bytes32]) -> List[bytes32]:
-        hints: List[bytes32] = []
+    async def get_hints(self, coin_ids: list[bytes32]) -> list[bytes32]:
+        hints: list[bytes32] = []
 
         async with self.db_wrapper.reader_no_transaction() as conn:
             for batch in to_batches(coin_ids, SQLITE_MAX_VARIABLE_NUMBER):
-                coin_ids_db: Tuple[bytes32, ...] = tuple(batch.entries)
+                coin_ids_db: tuple[bytes32, ...] = tuple(batch.entries)
                 cursor = await conn.execute(
                     f'SELECT hint from hints WHERE coin_id IN ({"?," * (len(batch.entries) - 1)}?)',
                     coin_ids_db,
@@ -72,7 +71,7 @@ class HintStore:
 
         return hints
 
-    async def add_hints(self, coin_hint_list: List[Tuple[bytes32, bytes]]) -> None:
+    async def add_hints(self, coin_hint_list: list[tuple[bytes32, bytes]]) -> None:
         if len(coin_hint_list) == 0:
             return None
 

chia/full_node/mempool.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import logging
 import sqlite3
+from collections.abc import Awaitable, Iterator
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
 from time import monotonic
-from typing import Awaitable, Callable, Dict, Iterator, List, Optional, Set, Tuple
+from typing import Callable, Optional
 
 from chia_rs import AugSchemeMPL, Coin, G2Element
 
@@ -50,13 +51,13 @@ MEMPOOL_ITEM_FEE_LIMIT = 2**50
 
 @dataclass
 class MempoolRemoveInfo:
-    items: List[InternalMempoolItem]
+    items: list[InternalMempoolItem]
     reason: MempoolRemoveReason
 
 
 @dataclass
 class MempoolAddInfo:
-    removals: List[MempoolRemoveInfo]
+    removals: list[MempoolRemoveInfo]
     error: Optional[Err]
 
 
@@ -71,7 +72,7 @@ class Mempool:
     _db_conn: sqlite3.Connection
     # it's expensive to serialize and deserialize G2Element, so we keep those in
     # this separate dictionary
-    _items: Dict[bytes32, InternalMempoolItem]
+    _items: dict[bytes32, InternalMempoolItem]
 
     # the most recent block height and timestamp that we know of
     _block_height: uint32
@@ -164,18 +165,18 @@ class Mempool:
             for row in cursor:
                 yield self._row_to_item(row)
 
-    def all_item_ids(self) -> List[bytes32]:
+    def all_item_ids(self) -> list[bytes32]:
         with self._db_conn:
             cursor = self._db_conn.execute("SELECT name FROM tx")
             return [bytes32(row[0]) for row in cursor]
 
-    def items_with_coin_ids(self, coin_ids: Set[bytes32]) -> List[bytes32]:
+    def items_with_coin_ids(self, coin_ids: set[bytes32]) -> list[bytes32]:
         """
         Returns a list of transaction ids that spend or create any coins with the provided coin ids.
         This iterates over the internal items instead of using a query.
         """
 
-        transaction_ids: List[bytes32] = []
+        transaction_ids: list[bytes32] = []
 
         for transaction_id, item in self._items.items():
             conds = item.conds
@@ -197,14 +198,14 @@ class Mempool:
 
         return transaction_ids
 
-    def items_with_puzzle_hashes(self, puzzle_hashes: Set[bytes32], include_hints: bool) -> List[bytes32]:
+    def items_with_puzzle_hashes(self, puzzle_hashes: set[bytes32], include_hints: bool) -> list[bytes32]:
         """
         Returns a list of transaction ids that spend or create any coins
         with the provided puzzle hashes (or hints, if enabled).
         This iterates over the internal items instead of using a query.
         """
 
-        transaction_ids: List[bytes32] = []
+        transaction_ids: list[bytes32] = []
 
         for transaction_id, item in self._items.items():
             conds = item.conds
@@ -261,8 +262,8 @@ class Mempool:
         for row in cursor:
             yield self._row_to_item(row)
 
-    def get_items_by_coin_ids(self, spent_coin_ids: List[bytes32]) -> List[MempoolItem]:
-        items: List[MempoolItem] = []
+    def get_items_by_coin_ids(self, spent_coin_ids: list[bytes32]) -> list[MempoolItem]:
+        items: list[MempoolItem] = []
         for batch in to_batches(spent_coin_ids, SQLITE_MAX_VARIABLE_NUMBER):
             args = ",".join(["?"] * len(batch.entries))
             cursor = self._db_conn.execute(
@@ -318,14 +319,14 @@ class Mempool:
 
         return self.remove_from_pool(to_remove, MempoolRemoveReason.EXPIRED)
 
-    def remove_from_pool(self, items: List[bytes32], reason: MempoolRemoveReason) -> MempoolRemoveInfo:
+    def remove_from_pool(self, items: list[bytes32], reason: MempoolRemoveReason) -> MempoolRemoveInfo:
         """
         Removes an item from the mempool.
         """
         if items == []:
             return MempoolRemoveInfo([], reason)
 
-        removed_items: List[MempoolItemInfo] = []
+        removed_items: list[MempoolItemInfo] = []
         if reason != MempoolRemoveReason.BLOCK_INCLUSION:
             for batch in to_batches(items, SQLITE_MAX_VARIABLE_NUMBER):
                 args = ",".join(["?"] * len(batch.entries))
@@ -375,7 +376,7 @@ class Mempool:
         assert item.conds is not None
         assert item.cost <= self.mempool_info.max_block_clvm_cost
 
-        removals: List[MempoolRemoveInfo] = []
+        removals: list[MempoolRemoveInfo] = []
 
         # we have certain limits on transactions that will expire soon
         # (in the next 15 minutes)
@@ -399,7 +400,7 @@ class Mempool:
                 """,
                 (time_cutoff, block_cutoff),
             )
-            to_remove: List[bytes32] = []
+            to_remove: list[bytes32] = []
             for row in cursor:
                 name, fee_per_cost, cumulative_cost = row
 
@@ -476,11 +477,11 @@ class Mempool:
         get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
         constants: ConsensusConstants,
         height: uint32,
-    ) -> Optional[Tuple[SpendBundle, List[Coin]]]:
+    ) -> Optional[tuple[SpendBundle, list[Coin]]]:
         cost_sum = 0  # Checks that total cost does not exceed block maximum
         fee_sum = 0  # Checks that total fees don't exceed 64 bits
         processed_spend_bundles = 0
-        additions: List[Coin] = []
+        additions: list[Coin] = []
         # This contains:
         # 1. A map of coin ID to a coin spend solution and its isolated cost
         #   We reconstruct it for every bundle we create from mempool items because we
@@ -490,8 +491,8 @@ class Mempool:
         #   recent unspent singleton data, to allow chaining fast forward
         #   singleton spends
         eligible_coin_spends = EligibleCoinSpends()
-        coin_spends: List[CoinSpend] = []
-        sigs: List[G2Element] = []
+        coin_spends: list[CoinSpend] = []
+        sigs: list[G2Element] = []
         log.info(f"Starting to make block, max cost: {self.mempool_info.max_block_clvm_cost}")
         bundle_creation_start = monotonic()
         cursor = self._db_conn.execute("SELECT name, fee FROM tx ORDER BY fee_per_cost DESC, seq ASC")
@@ -500,6 +501,11 @@ class Mempool:
             name = bytes32(row[0])
             fee = int(row[1])
             item = self._items[name]
+
+            current_time = monotonic()
+            if current_time - bundle_creation_start > 1:
+                log.info(f"exiting early, already spent {current_time - bundle_creation_start:0.2f} s")
+                break
             if not item_inclusion_filter(name):
                 continue
             try:

chia/full_node/mempool_check_conditions.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
 import logging
-from typing import Dict, List, Optional
+from typing import Optional
 
-from chia_rs import DONT_VALIDATE_SIGNATURE, MEMPOOL_MODE, G2Element, get_flags_for_height_and_constants
+from chia_rs import (
+    get_flags_for_height_and_constants,
+    run_chia_program,
+)
 from chia_rs import get_puzzle_and_solution_for_coin2 as get_puzzle_and_solution_for_coin_rust
-from chia_rs import run_block_generator, run_block_generator2, run_chia_program
 
 from chia.consensus.constants import ConsensusConstants
-from chia.consensus.cost_calculator import NPCResult
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -18,7 +19,7 @@ from chia.types.generator_types import BlockGenerator
 from chia.types.spend_bundle_conditions import SpendBundleConditions
 from chia.util.condition_tools import conditions_for_solution
 from chia.util.errors import Err
-from chia.util.ints import uint16, uint32, uint64
+from chia.util.ints import uint32, uint64
 from chia.wallet.puzzles.load_clvm import load_serialized_clvm_maybe_recompile
 
 DESERIALIZE_MOD = load_serialized_clvm_maybe_recompile(
@@ -28,38 +29,6 @@ DESERIALIZE_MOD = load_serialized_clvm_maybe_recompile(
 log = logging.getLogger(__name__)
 
 
-def get_name_puzzle_conditions(
-    generator: BlockGenerator,
-    max_cost: int,
-    *,
-    mempool_mode: bool,
-    height: uint32,
-    constants: ConsensusConstants,
-) -> NPCResult:
-    flags = get_flags_for_height_and_constants(height, constants) | DONT_VALIDATE_SIGNATURE
-
-    if mempool_mode:
-        flags = flags | MEMPOOL_MODE
-
-    if height >= constants.HARD_FORK_HEIGHT:
-        run_block = run_block_generator2
-    else:
-        run_block = run_block_generator
-
-    try:
-        block_args = generator.generator_refs
-        err, result = run_block(bytes(generator.program), block_args, max_cost, flags, G2Element(), None, constants)
-        assert (err is None) != (result is None)
-        if err is not None:
-            return NPCResult(uint16(err), None)
-        else:
-            assert result is not None
-            return NPCResult(None, result)
-    except BaseException:
-        log.exception("get_name_puzzle_condition failed")
-        return NPCResult(uint16(Err.GENERATOR_RUNTIME_ERROR.value), None)
-
-
 def get_puzzle_and_solution_for_coin(
     generator: BlockGenerator, coin: Coin, height: int, constants: ConsensusConstants
 ) -> SpendInfo:
@@ -76,7 +45,7 @@ def get_puzzle_and_solution_for_coin(
         raise ValueError(f"Failed to get puzzle and solution for coin {coin}, error: {e}") from e
 
 
-def get_spends_for_block(generator: BlockGenerator, height: int, constants: ConsensusConstants) -> List[CoinSpend]:
+def get_spends_for_block(generator: BlockGenerator, height: int, constants: ConsensusConstants) -> list[CoinSpend]:
     args = bytearray(b"\xff")
     args += bytes(DESERIALIZE_MOD)
     args += b"\xff"
@@ -90,7 +59,7 @@ def get_spends_for_block(generator: BlockGenerator, height: int, constants: Cons
         get_flags_for_height_and_constants(height, constants),
     )
 
-    spends: List[CoinSpend] = []
+    spends: list[CoinSpend] = []
 
     for spend in Program.to(ret).first().as_iter():
         parent, puzzle, amount, solution = spend.as_iter()
@@ -103,7 +72,7 @@ def get_spends_for_block(generator: BlockGenerator, height: int, constants: Cons
 
 def get_spends_for_block_with_conditions(
     generator: BlockGenerator, height: int, constants: ConsensusConstants
-) -> List[CoinSpendWithConditions]:
+) -> list[CoinSpendWithConditions]:
     args = bytearray(b"\xff")
     args += bytes(DESERIALIZE_MOD)
     args += b"\xff"
@@ -119,7 +88,7 @@ def get_spends_for_block_with_conditions(
         flags,
     )
 
-    spends: List[CoinSpendWithConditions] = []
+    spends: list[CoinSpendWithConditions] = []
 
     for spend in Program.to(ret).first().as_iter():
         parent, puzzle, amount, solution = spend.as_iter()
@@ -133,7 +102,7 @@ def get_spends_for_block_with_conditions(
 
 
 def mempool_check_time_locks(
-    removal_coin_records: Dict[bytes32, CoinRecord],
+    removal_coin_records: dict[bytes32, CoinRecord],
     bundle_conds: SpendBundleConditions,
     prev_transaction_block_height: uint32,
     timestamp: uint64,