chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/full_node/full_node_store.py

@@ -4,7 +4,6 @@ import asyncio
 import dataclasses
 import logging
 import time
-from typing import Optional
 
 from chia_rs import BlockRecord, ConsensusConstants, EndOfSubSlotBundle, FullBlock, UnfinishedBlock
 from chia_rs.sized_bytes import bytes32
@@ -16,6 +15,7 @@ from chia.consensus.make_sub_epoch_summary import make_sub_epoch_summary
 from chia.consensus.multiprocess_validation import PreValidationResult
 from chia.consensus.pot_iterations import calculate_sp_interval_iters
 from chia.consensus.signage_point import SignagePoint
+from chia.full_node.tx_processing_queue import PeerWithTx
 from chia.protocols import timelord_protocol
 from chia.protocols.outbound_message import Message
 from chia.types.blockchain_format.classgroup import ClassgroupElement
@@ -29,7 +29,7 @@ log = logging.getLogger(__name__)
 @streamable
 @dataclasses.dataclass(frozen=True)
 class FullNodeStorePeakResult(Streamable):
-    added_eos: Optional[EndOfSubSlotBundle]
+    added_eos: EndOfSubSlotBundle | None
     new_signage_points: list[tuple[uint8, SignagePoint]]
     new_infusion_points: list[timelord_protocol.NewInfusionPointVDF]
 
@@ -38,16 +38,16 @@ class FullNodeStorePeakResult(Streamable):
 class UnfinishedBlockEntry:
     # if this is None, it means we've requested this block but not yet received
     # it
-    unfinished_block: Optional[UnfinishedBlock]
+    unfinished_block: UnfinishedBlock | None
     # If this is None, it means we've initiated validation of this block, but it
     # hasn't completed yet
-    result: Optional[PreValidationResult]
+    result: PreValidationResult | None
     height: uint32
 
 
 def find_best_block(
-    result: dict[Optional[bytes32], UnfinishedBlockEntry],
-) -> tuple[Optional[bytes32], Optional[UnfinishedBlock]]:
+    result: dict[bytes32 | None, UnfinishedBlockEntry],
+) -> tuple[bytes32 | None, UnfinishedBlock | None]:
     """
     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.
@@ -64,7 +64,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[bytes32 | None, UnfinishedBlockEntry]) -> bool:
         foliage_hash, entry = item
         return foliage_hash is not None and entry.unfinished_block is not None
 
@@ -104,13 +104,13 @@ 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[bytes32 | None, 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[EndOfSubSlotBundle | None, list[SignagePoint | None], 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.
@@ -132,10 +132,12 @@ class FullNodeStore:
     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}
+    # Map of transaction ID to the map of peer ID to its hostname, fee and cost
+    # it advertised for that transaction.
+    peers_with_tx: dict[bytes32, dict[bytes32, PeerWithTx]]
     tx_fetch_tasks: dict[bytes32, asyncio.Task[None]]  # Task id: task
-    serialized_wp_message: Optional[Message]
-    serialized_wp_message_tip: Optional[bytes32]
+    serialized_wp_message: Message | None
+    serialized_wp_message_tip: bytes32 | None
 
     max_seen_unfinished_blocks: int
 
@@ -162,7 +164,7 @@ class FullNodeStore:
         self.max_seen_unfinished_blocks = 1000
 
     def is_requesting_unfinished_block(
-        self, reward_block_hash: bytes32, foliage_hash: Optional[bytes32]
+        self, reward_block_hash: bytes32, foliage_hash: bytes32 | None
     ) -> tuple[bool, int]:
         """
         Asks if we are already requesting this specific unfinished block (given
@@ -180,11 +182,11 @@ class FullNodeStore:
         else:
             return (foliage_hash in ents, len(ents))
 
-    def mark_requesting_unfinished_block(self, reward_block_hash: bytes32, foliage_hash: Optional[bytes32]) -> None:
+    def mark_requesting_unfinished_block(self, reward_block_hash: bytes32, foliage_hash: bytes32 | None) -> None:
         ents = self._unfinished_blocks.setdefault(reward_block_hash, {})
         ents.setdefault(foliage_hash, UnfinishedBlockEntry(None, None, uint32(0)))
 
-    def remove_requesting_unfinished_block(self, reward_block_hash: bytes32, foliage_hash: Optional[bytes32]) -> None:
+    def remove_requesting_unfinished_block(self, reward_block_hash: bytes32, foliage_hash: bytes32 | None) -> None:
         reward_ents = self._unfinished_blocks.get(reward_block_hash)
         if reward_ents is None:
             return
@@ -209,7 +211,7 @@ class FullNodeStore:
 
     def get_candidate_block(
         self, quality_string: bytes32, backup: bool = False
-    ) -> Optional[tuple[uint32, UnfinishedBlock]]:
+    ) -> tuple[uint32, UnfinishedBlock] | None:
         if backup:
             return self.candidate_backup_blocks.get(quality_string, None)
         else:
@@ -254,7 +256,7 @@ class FullNodeStore:
             unfinished_block, result, height
         )
 
-    def get_unfinished_block(self, unfinished_reward_hash: bytes32) -> Optional[UnfinishedBlock]:
+    def get_unfinished_block(self, unfinished_reward_hash: bytes32) -> UnfinishedBlock | None:
         result = self._unfinished_blocks.get(unfinished_reward_hash, None)
         if result is None:
             return None
@@ -269,8 +271,8 @@ class FullNodeStore:
         return block
 
     def get_unfinished_block2(
-        self, unfinished_reward_hash: bytes32, unfinished_foliage_hash: Optional[bytes32]
-    ) -> tuple[Optional[UnfinishedBlock], int, bool]:
+        self, unfinished_reward_hash: bytes32, unfinished_foliage_hash: bytes32 | None
+    ) -> tuple[UnfinishedBlock | None, 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
@@ -304,7 +306,7 @@ class FullNodeStore:
     # have a foliage hash. That's why unfinished_foliage_hash is not Optional.
     def get_unfinished_block_result(
         self, unfinished_reward_hash: bytes32, unfinished_foliage_hash: bytes32
-    ) -> Optional[UnfinishedBlockEntry]:
+    ) -> UnfinishedBlockEntry | None:
         result = self._unfinished_blocks.get(unfinished_reward_hash, None)
         if result is None:
             return None
@@ -323,7 +325,7 @@ class FullNodeStore:
     def clear_unfinished_blocks_below(self, height: uint32) -> None:
         del_partial: list[bytes32] = []
         for partial_hash, entry in self._unfinished_blocks.items():
-            del_foliage: list[Optional[bytes32]] = []
+            del_foliage: list[bytes32 | None] = []
             for foliage_hash, ube in entry.items():
                 if ube.height < height:
                     del_foliage.append(foliage_hash)
@@ -392,7 +394,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) -> tuple[EndOfSubSlotBundle, int, uint128] | None:
         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:
@@ -407,11 +409,11 @@ class FullNodeStore:
         self,
         eos: EndOfSubSlotBundle,
         blocks: BlockRecordsProtocol,
-        peak: Optional[BlockRecord],
+        peak: BlockRecord | None,
         next_sub_slot_iters: uint64,
         next_difficulty: uint64,
-        peak_full_block: Optional[FullBlock],
-    ) -> Optional[list[timelord_protocol.NewInfusionPointVDF]]:
+        peak_full_block: FullBlock | None,
+    ) -> list[timelord_protocol.NewInfusionPointVDF] | None:
         """
         Returns false if not added. Returns a list if added. The list contains all infusion points that depended
         on this sub slot
@@ -427,8 +429,8 @@ class FullNodeStore:
         rc_challenge: bytes32 = (
             last_slot.reward_chain.get_hash() if last_slot is not None else self.constants.GENESIS_CHALLENGE
         )
-        icc_challenge: Optional[bytes32] = None
-        icc_iters: Optional[uint64] = None
+        icc_challenge: bytes32 | None = None
+        icc_iters: uint64 | None = None
 
         # Skip if already present
         for slot, _, _ in self.finished_sub_slots:
@@ -678,7 +680,7 @@ class FullNodeStore:
         self,
         index: uint8,
         blocks: BlockRecordsProtocol,
-        peak: Optional[BlockRecord],
+        peak: BlockRecord | None,
         next_sub_slot_iters: uint64,
         signage_point: SignagePoint,
         skip_vdf_validation: bool = False,
@@ -814,7 +816,7 @@ class FullNodeStore:
         self.add_to_future_sp(signage_point, index)
         return False
 
-    def get_signage_point(self, cc_signage_point: bytes32) -> Optional[SignagePoint]:
+    def get_signage_point(self, cc_signage_point: bytes32) -> SignagePoint | None:
         assert len(self.finished_sub_slots) >= 1
         if cc_signage_point == self.constants.GENESIS_CHALLENGE:
             return SignagePoint(None, None, None, None)
@@ -831,7 +833,7 @@ class FullNodeStore:
 
     def get_signage_point_by_index_and_cc_output(
         self, cc_signage_point: bytes32, challenge: bytes32, index: uint8
-    ) -> Optional[SignagePoint]:
+    ) -> SignagePoint | None:
         assert len(self.finished_sub_slots) >= 1
         for sub_slot, sps, _ in self.finished_sub_slots:
             if sub_slot is not None:
@@ -842,7 +844,7 @@ class FullNodeStore:
                 if index == 0:
                     # first SP in the sub slot
                     return SignagePoint(None, None, None, None)
-                sp: Optional[SignagePoint] = sps[index]
+                sp: SignagePoint | None = sps[index]
                 if sp is None:
                     return None
                 assert sp.cc_vdf is not None
@@ -852,7 +854,7 @@ class FullNodeStore:
 
     def get_signage_point_by_index(
         self, challenge_hash: bytes32, index: uint8, last_rc_infusion: bytes32
-    ) -> Optional[SignagePoint]:
+    ) -> SignagePoint | None:
         assert len(self.finished_sub_slots) >= 1
         for sub_slot, sps, _ in self.finished_sub_slots:
             if sub_slot is not None:
@@ -863,7 +865,7 @@ class FullNodeStore:
             if cc_hash == challenge_hash:
                 if index == 0:
                     return SignagePoint(None, None, None, None)
-                sp: Optional[SignagePoint] = sps[index]
+                sp: SignagePoint | None = sps[index]
                 if sp is not None:
                     assert sp.rc_vdf is not None
                     if sp.rc_vdf.challenge == last_rc_infusion:
@@ -885,7 +887,7 @@ class FullNodeStore:
             if cc_hash == challenge_hash:
                 found_rc_hash = False
                 for i in range(index):
-                    sp: Optional[SignagePoint] = sps[i]
+                    sp: SignagePoint | None = sps[i]
                     if sp is not None and sp.rc_vdf is not None and sp.rc_vdf.challenge == last_rc_infusion:
                         found_rc_hash = True
                 sp = sps[index]
@@ -902,9 +904,9 @@ class FullNodeStore:
         self,
         peak: BlockRecord,
         peak_full_block: FullBlock,
-        sp_sub_slot: Optional[EndOfSubSlotBundle],  # None if not overflow, or in first/second slot
-        ip_sub_slot: Optional[EndOfSubSlotBundle],  # None if in first slot
-        fork_block: Optional[BlockRecord],
+        sp_sub_slot: EndOfSubSlotBundle | None,  # None if not overflow, or in first/second slot
+        ip_sub_slot: EndOfSubSlotBundle | None,  # None if in first slot
+        fork_block: BlockRecord | None,
         blocks: BlockRecordsProtocol,
         next_sub_slot_iters: uint64,
         next_difficulty: uint64,
@@ -922,8 +924,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[SignagePoint | None] = [None] * self.constants.NUM_SPS_SUB_SLOT
+            ip_sub_slot_sps: list[SignagePoint | None] = [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
@@ -939,7 +941,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[SignagePoint | None] = []  # 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
@@ -968,7 +970,7 @@ class FullNodeStore:
             ip_sub_slot_total_iters = peak.ip_sub_slot_total_iters(self.constants)
             self.finished_sub_slots.append((ip_sub_slot, ip_sub_slot_sps, ip_sub_slot_total_iters))
 
-        new_eos: Optional[EndOfSubSlotBundle] = None
+        new_eos: EndOfSubSlotBundle | None = None
         new_sps: list[tuple[uint8, SignagePoint]] = []
         new_ips: list[timelord_protocol.NewInfusionPointVDF] = []
 
@@ -1006,9 +1008,9 @@ class FullNodeStore:
     def get_finished_sub_slots(
         self,
         block_records: BlockRecordsProtocol,
-        prev_b: Optional[BlockRecord],
+        prev_b: BlockRecord | None,
         last_challenge_to_add: bytes32,
-    ) -> Optional[list[EndOfSubSlotBundle]]:
+    ) -> list[EndOfSubSlotBundle] | None:
         """
         Retrieves the EndOfSubSlotBundles that are in the store either:
         1. From the starting challenge if prev_b is None

chia/full_node/hint_management.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Callable, Optional
+from collections.abc import Callable
 
 from chia_rs.sized_bytes import bytes32
 
@@ -16,7 +16,7 @@ def get_hints_and_subscription_coin_ids(
     # 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]
+    hint: bytes | None
     hints_to_add: list[tuple[bytes32, bytes]] = []
 
     # Goes through additions and removals for each block and flattens to a map and a set

chia/full_node/mempool.py

@@ -7,11 +7,9 @@ from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
 from time import monotonic
-from typing import Optional
 
 from chia_rs import (
     DONT_VALIDATE_SIGNATURE,
-    MEMPOOL_MODE,
     AugSchemeMPL,
     BlockBuilder,
     Coin,
@@ -74,7 +72,7 @@ class MempoolRemoveInfo:
 @dataclass
 class MempoolAddInfo:
     removals: list[MempoolRemoveInfo]
-    error: Optional[Err]
+    error: Err | None
 
 
 class MempoolRemoveReason(Enum):
@@ -146,7 +144,7 @@ class Mempool:
         self.mempool_info: MempoolInfo = mempool_info
         self.fee_estimator: FeeEstimatorInterface = fee_estimator
 
-    def __del__(self) -> None:
+    def close(self) -> None:
         self._db_conn.close()
 
     def _row_to_item(self, row: sqlite3.Row) -> MempoolItem:
@@ -255,7 +253,7 @@ class Mempool:
         row = cursor.fetchone()
         return int(row[0])
 
-    def get_item_by_id(self, item_id: bytes32) -> Optional[MempoolItem]:
+    def get_item_by_id(self, item_id: bytes32) -> MempoolItem | None:
         with self._db_conn:
             cursor = self._db_conn.execute("SELECT * FROM tx WHERE name=?", (item_id,))
             row = cursor.fetchone()
@@ -289,7 +287,7 @@ class Mempool:
             items.extend(self._row_to_item(row) for row in cursor)
         return items
 
-    def get_min_fee_rate(self, cost: int) -> Optional[float]:
+    def get_min_fee_rate(self, cost: int) -> float | None:
         """
         Gets the minimum fpc rate that a transaction with specified cost will need in order to get included.
         """
@@ -505,15 +503,15 @@ class Mempool:
     def create_block_generator(
         self,
         constants: ConsensusConstants,
-        height: uint32,
+        prev_tx_height: uint32,
         timeout: float,
-    ) -> Optional[NewBlockGenerator]:
+    ) -> NewBlockGenerator | None:
         """
-        height is needed in case we fast-forward a transaction and we need to
-        re-run its puzzle.
+        prev_tx_height is needed in case we fast-forward a transaction and we
+        need to re-run its puzzle.
         """
 
-        mempool_bundle = self.create_bundle_from_mempool_items(constants, height, timeout)
+        mempool_bundle = self.create_bundle_from_mempool_items(constants, prev_tx_height, timeout)
         if mempool_bundle is None:
             return None
 
@@ -535,7 +533,7 @@ class Mempool:
             f"spends: {len(removals)} additions: {len(additions)}",
         )
 
-        flags = get_flags_for_height_and_constants(height, constants) | MEMPOOL_MODE | DONT_VALIDATE_SIGNATURE
+        flags = get_flags_for_height_and_constants(prev_tx_height, constants) | DONT_VALIDATE_SIGNATURE
 
         err, conds = run_block_generator2(
             block_program,
@@ -551,7 +549,7 @@ class Mempool:
         if err is not None:  # pragma: no cover
             log.error(
                 f"Failed to compute block cost during farming: {err} "
-                f"height: {height} "
+                f"prev-tx-height: {prev_tx_height} "
                 f"generator: {bytes(block_program).hex()}"
             )
             return None
@@ -570,8 +568,8 @@ class Mempool:
         )
 
     def create_bundle_from_mempool_items(
-        self, constants: ConsensusConstants, height: uint32, timeout: float = 1.0
-    ) -> Optional[tuple[SpendBundle, list[Coin]]]:
+        self, constants: ConsensusConstants, prev_tx_height: uint32, timeout: float = 1.0
+    ) -> tuple[SpendBundle, list[Coin]] | None:
         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
@@ -624,7 +622,7 @@ class Mempool:
                     cost_saving = 0
                 else:
                     bundle_coin_spends = singleton_ff.process_fast_forward_spends(
-                        mempool_item=item, height=height, constants=constants
+                        mempool_item=item, prev_tx_height=prev_tx_height, constants=constants
                     )
                     unique_coin_spends, cost_saving, unique_additions = dedup_coin_spends.get_deduplication_info(
                         bundle_coin_spends=bundle_coin_spends
@@ -687,8 +685,8 @@ class Mempool:
         return agg, additions
 
     def create_block_generator2(
-        self, constants: ConsensusConstants, height: uint32, timeout: float
-    ) -> Optional[NewBlockGenerator]:
+        self, constants: ConsensusConstants, prev_tx_height: uint32, timeout: float
+    ) -> NewBlockGenerator | None:
         fee_sum = 0  # Checks that total fees don't exceed 64 bits
         additions: list[Coin] = []
         removals: list[Coin] = []
@@ -723,7 +721,7 @@ class Mempool:
                 assert item.conds is not None
                 cost = item.conds.condition_cost + item.conds.execution_cost
                 bundle_coin_spends = singleton_ff.process_fast_forward_spends(
-                    mempool_item=item, height=height, constants=constants
+                    mempool_item=item, prev_tx_height=prev_tx_height, constants=constants
                 )
                 unique_coin_spends, cost_saving, unique_additions = dedup_coin_spends.get_deduplication_info(
                     bundle_coin_spends=bundle_coin_spends