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

chia/full_node/mempool_manager.py

@@ -1,21 +1,25 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
 import time
-from collections.abc import Awaitable, Collection
+from collections.abc import AsyncIterator, Awaitable, Callable, Collection
 from concurrent.futures import Executor, ThreadPoolExecutor
 from dataclasses import dataclass, field
-from typing import Callable, Optional, TypeVar
+from types import TracebackType
+from typing import TypeVar
 
 from chia_rs import (
     ELIGIBLE_FOR_DEDUP,
     ELIGIBLE_FOR_FF,
     MEMPOOL_MODE,
     BLSCache,
+    CoinRecord,
     ConsensusConstants,
     SpendBundle,
     SpendBundleConditions,
+    check_time_locks,
     get_flags_for_height_and_constants,
     supports_fast_forward,
     validate_clvm_and_signature,
@@ -23,9 +27,9 @@ from chia_rs import (
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 from chiabip158 import PyBIP158
+from typing_extensions import Self
 
 from chia.consensus.block_record import BlockRecordProtocol
-from chia.consensus.check_time_locks import check_time_locks
 from chia.full_node.bitcoin_fee_estimator import create_bitcoin_fee_estimator
 from chia.full_node.fee_estimation import FeeBlockInfo, MempoolInfo, MempoolItemInfo
 from chia.full_node.fee_estimator_interface import FeeEstimatorInterface
@@ -33,7 +37,6 @@ from chia.full_node.mempool import MEMPOOL_ITEM_FEE_LIMIT, Mempool, MempoolRemov
 from chia.full_node.pending_tx_cache import ConflictTxCache, PendingTxCache
 from chia.types.blockchain_format.coin import Coin
 from chia.types.clvm_cost import CLVMCost
-from chia.types.coin_record import CoinRecord
 from chia.types.fee_rate import FeeRate
 from chia.types.generator_types import NewBlockGenerator
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
@@ -53,16 +56,16 @@ MEMPOOL_MIN_FEE_INCREASE = uint64(10000000)
 class TimelockConditions:
     assert_height: uint32 = uint32(0)
     assert_seconds: uint64 = uint64(0)
-    assert_before_height: Optional[uint32] = None
-    assert_before_seconds: Optional[uint64] = None
+    assert_before_height: uint32 | None = None
+    assert_before_seconds: uint64 | None = None
 
 
 @dataclass
 class LineageInfoCache:
-    _fun: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]]
-    _cache: dict[bytes32, Optional[UnspentLineageInfo]] = field(default_factory=dict)
+    _fun: Callable[[bytes32], Awaitable[UnspentLineageInfo | None]]
+    _cache: dict[bytes32, UnspentLineageInfo | None] = field(default_factory=dict)
 
-    async def get_unspent_lineage_info(self, puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
+    async def get_unspent_lineage_info(self, puzzle_hash: bytes32) -> UnspentLineageInfo | None:
         # we rely on KeyError to distinguish between a stored
         # None value and a missing entry
         try:
@@ -125,10 +128,10 @@ def compute_assert_height(
 
 @dataclass
 class SpendBundleAddInfo:
-    cost: Optional[uint64]
+    cost: uint64 | None
     status: MempoolInclusionStatus
     removals: list[MempoolRemoveInfo]
-    error: Optional[Err]
+    error: Err | None
 
 
 @dataclass
@@ -233,7 +236,7 @@ def check_removals(
     bundle_coin_spends: dict[bytes32, BundleCoinSpend],
     *,
     get_items_by_coin_ids: Callable[[list[bytes32]], list[MempoolItem]],
-) -> tuple[Optional[Err], list[MempoolItem]]:
+) -> tuple[Err | None, 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).
@@ -299,7 +302,7 @@ class MempoolManager:
     constants: ConsensusConstants
     seen_bundle_hashes: dict[bytes32, bytes32]
     get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]]
-    get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]]
+    get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[UnspentLineageInfo | None]]
     nonzero_fee_minimum_fpc: int
     mempool_max_total_cost: int
     # a cache of MempoolItems that conflict with existing items in the pool
@@ -307,7 +310,9 @@ class MempoolManager:
     # cache of MempoolItems with height conditions making them not valid yet
     _pending_cache: PendingTxCache
     seen_cache_size: int
-    peak: Optional[BlockRecordProtocol]
+    # the peak is only ever set to a transaction block. We use it to validate
+    # timelocks against, so it must have a timestamp.
+    peak: BlockRecordProtocol | None
     mempool: Mempool
     _worker_queue_size: int
     max_block_clvm_cost: uint64
@@ -316,11 +321,11 @@ class MempoolManager:
     def __init__(
         self,
         get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
-        get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
+        get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[UnspentLineageInfo | None]],
         consensus_constants: ConsensusConstants,
         *,
         single_threaded: bool = False,
-        max_tx_clvm_cost: Optional[uint64] = None,
+        max_tx_clvm_cost: uint64 | None = None,
     ):
         self.constants: ConsensusConstants = consensus_constants
 
@@ -356,7 +361,7 @@ class MempoolManager:
             self.pool = ThreadPoolExecutor(max_workers=2, thread_name_prefix="mempool-")
 
         # The mempool will correspond to a certain peak
-        self.peak: Optional[BlockRecordProtocol] = None
+        self.peak: BlockRecordProtocol | None = None
         self.fee_estimator: FeeEstimatorInterface = create_bitcoin_fee_estimator(self.max_block_clvm_cost)
         mempool_info = MempoolInfo(
             CLVMCost(uint64(self.mempool_max_total_cost)),
@@ -365,11 +370,45 @@ class MempoolManager:
         )
         self.mempool: Mempool = Mempool(mempool_info, self.fee_estimator)
 
+    @classmethod
+    @contextlib.asynccontextmanager
+    async def managed(
+        cls,
+        get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
+        get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[UnspentLineageInfo | None]],
+        consensus_constants: ConsensusConstants,
+        single_threaded: bool = False,
+        max_tx_clvm_cost: uint64 | None = None,
+    ) -> AsyncIterator[Self]:
+        self = cls(
+            get_coin_records,
+            get_unspent_lineage_info_for_puzzle_hash,
+            consensus_constants,
+            single_threaded=single_threaded,
+            max_tx_clvm_cost=max_tx_clvm_cost,
+        )
+        try:
+            yield self
+        finally:
+            self.shut_down()
+
     def shut_down(self) -> None:
         self.pool.shutdown(wait=True)
+        self.mempool.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.shut_down()
 
     # TODO: remove this, use create_generator() instead
-    def create_bundle_from_mempool(self, last_tb_header_hash: bytes32) -> Optional[tuple[SpendBundle, list[Coin]]]:
+    def create_bundle_from_mempool(self, last_tb_header_hash: bytes32) -> tuple[SpendBundle, list[Coin]] | None:
         """
         Returns aggregated spendbundle that can be used for creating new block,
         additions and removals in that spend_bundle
@@ -378,7 +417,7 @@ class MempoolManager:
             return None
         return self.mempool.create_bundle_from_mempool_items(self.constants, self.peak.height)
 
-    def create_block_generator(self, last_tb_header_hash: bytes32, timeout: float) -> Optional[NewBlockGenerator]:
+    def create_block_generator(self, last_tb_header_hash: bytes32, timeout: float) -> NewBlockGenerator | None:
         """
         Returns a block generator program, the aggregate signature and all additions and removals, for a new block
         """
@@ -386,7 +425,7 @@ class MempoolManager:
             return None
         return self.mempool.create_block_generator(self.constants, self.peak.height, timeout)
 
-    def create_block_generator2(self, last_tb_header_hash: bytes32, timeout: float) -> Optional[NewBlockGenerator]:
+    def create_block_generator2(self, last_tb_header_hash: bytes32, timeout: float) -> NewBlockGenerator | None:
         """
         Returns a block generator program, the aggregate signature and all additions, for a new block
         """
@@ -435,7 +474,7 @@ class MempoolManager:
             self.seen_bundle_hashes.pop(bundle_hash)
 
     async def pre_validate_spendbundle(
-        self, spend_bundle: SpendBundle, spend_bundle_id: Optional[bytes32] = None, bls_cache: Optional[BLSCache] = None
+        self, spend_bundle: SpendBundle, spend_bundle_id: bytes32 | None = None, bls_cache: BLSCache | None = None
     ) -> SpendBundleConditions:
         """
         Errors are included within the cached_result.
@@ -469,6 +508,12 @@ class MempoolManager:
         finally:
             self._worker_queue_size -= 1
 
+        if sbc.num_atoms > sbc.cost * 60_000_000 / self.constants.MAX_BLOCK_COST_CLVM:
+            raise ValidationError(Err.INVALID_SPEND_BUNDLE, "too many atoms")
+
+        if sbc.num_pairs > sbc.cost * 60_000_000 / self.constants.MAX_BLOCK_COST_CLVM:
+            raise ValidationError(Err.INVALID_SPEND_BUNDLE, "too many pairs")
+
         if bls_cache is not None:
             bls_cache.update(new_cache_entries)
 
@@ -488,10 +533,9 @@ class MempoolManager:
         conds: SpendBundleConditions,
         spend_name: bytes32,
         first_added_height: uint32,
-        get_coin_records: Optional[Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]]] = None,
-        get_unspent_lineage_info_for_puzzle_hash: Optional[
-            Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]]
-        ] = None,
+        get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]] | None = None,
+        get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[UnspentLineageInfo | None]]
+        | None = None,
     ) -> SpendBundleAddInfo:
         """
         Validates and adds to mempool a new_spend with the given
@@ -561,8 +605,8 @@ class MempoolManager:
         spend_name: bytes32,
         first_added_height: uint32,
         get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
-        get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
-    ) -> tuple[Optional[Err], Optional[MempoolItem], list[bytes32]]:
+        get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[UnspentLineageInfo | None]],
+    ) -> tuple[Err | None, MempoolItem | None, list[bytes32]]:
         """
         Validates new_spend with the given SpendBundleConditions, and
         spend_name, and the current mempool. The mempool should
@@ -724,12 +768,15 @@ class MempoolManager:
         # point-of-view of the next block to be farmed. Therefore we pass in the
         # current peak's height and timestamp
         assert self.peak.timestamp is not None
-        tl_error: Optional[Err] = check_time_locks(
+        tl_error_rust: int | None = check_time_locks(
             removal_record_dict,
             conds,
             self.peak.height,
             self.peak.timestamp,
         )
+        tl_error: Err | None = None
+        if tl_error_rust is not None:
+            tl_error = Err(tl_error_rust)
 
         timelocks: TimelockConditions = compute_assert_height(removal_record_dict, conds)
 
@@ -777,14 +824,14 @@ class MempoolManager:
 
         return None, potential, [item.name for item in conflicts]
 
-    def get_spendbundle(self, bundle_hash: bytes32) -> Optional[SpendBundle]:
+    def get_spendbundle(self, bundle_hash: bytes32) -> SpendBundle | None:
         """Returns a full SpendBundle if it's inside one the mempools"""
-        item: Optional[MempoolItem] = self.mempool.get_item_by_id(bundle_hash)
+        item: MempoolItem | None = self.mempool.get_item_by_id(bundle_hash)
         if item is not None:
             return item.to_spend_bundle()
         return None
 
-    def get_mempool_item(self, bundle_hash: bytes32, include_pending: bool = False) -> Optional[MempoolItem]:
+    def get_mempool_item(self, bundle_hash: bytes32, include_pending: bool = False) -> MempoolItem | None:
         """
         Returns the MempoolItem in the mempool that matches the provided spend bundle hash (id)
         or None if not found.
@@ -800,9 +847,7 @@ class MempoolManager:
 
         return item
 
-    async def new_peak(
-        self, new_peak: Optional[BlockRecordProtocol], spent_coins: Optional[list[bytes32]]
-    ) -> NewPeakInfo:
+    async def new_peak(self, new_peak: BlockRecordProtocol | None, spent_coins: list[bytes32] | None) -> NewPeakInfo:
         """
         Called when a new peak is available, we try to recreate a mempool for the new tip.
         new_peak should always be the most recent *transaction* block of the chain. Since
@@ -967,6 +1012,8 @@ class MempoolManager:
                     # Item is most likely included in the block.
                     included_items.append(MempoolItemInfo(item.cost, item.fee, item.height_added_to_mempool))
 
+            old_pool.close()
+
         potential_txs = self._pending_cache.drain(new_peak.height)
         potential_txs.update(self._conflict_cache.drain())
         txs_added = []
@@ -992,8 +1039,8 @@ class MempoolManager:
         log.log(logging.WARNING if duration > 1 else logging.INFO, f"new_peak() took {duration:0.2f} seconds")
         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[MempoolItem]:
+        items: list[MempoolItem] = []
 
         assert limit > 0
 
@@ -1003,7 +1050,7 @@ class MempoolManager:
                 return items
             if mempool_filter.Match(bytearray(item.spend_bundle_name)):
                 continue
-            items.append(item.to_spend_bundle())
+            items.append(item)
 
         return items
 
@@ -1011,11 +1058,11 @@ class MempoolManager:
 T = TypeVar("T", uint32, uint64)
 
 
-def optional_min(a: Optional[T], b: Optional[T]) -> Optional[T]:
+def optional_min(a: T | None, b: T | None) -> T | None:
     return min((v for v in [a, b] if v is not None), default=None)
 
 
-def optional_max(a: Optional[T], b: Optional[T]) -> Optional[T]:
+def optional_max(a: T | None, b: T | None) -> T | None:
     return max((v for v in [a, b] if v is not None), default=None)
 
 
@@ -1029,9 +1076,9 @@ def can_replace(conflicting_items: list[MempoolItem], new_item: MempoolItem) ->
 
     conflicting_fees = 0
     conflicting_cost = 0
-    assert_height: Optional[uint32] = None
-    assert_before_height: Optional[uint32] = None
-    assert_before_seconds: Optional[uint64] = None
+    assert_height: uint32 | None = None
+    assert_before_height: uint32 | None = None
+    assert_before_seconds: uint64 | None = None
     # we don't allow replacing mempool items with new ones that remove
     # eligibility for dedup and fast-forward. Doing so could be abused by
     # denying such spends from operating as intended

chia/full_node/pending_tx_cache.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
@@ -17,7 +16,7 @@ class ConflictTxCache:
     _cache_cost: int = field(default=0, init=False)
     _txs: dict[bytes32, MempoolItem] = field(default_factory=dict, init=False)
 
-    def get(self, bundle_name: bytes32) -> Optional[MempoolItem]:
+    def get(self, bundle_name: bytes32) -> MempoolItem | None:
         return self._txs.get(bundle_name, None)
 
     def add(self, item: MempoolItem) -> None:
@@ -56,7 +55,7 @@ class PendingTxCache:
     _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]:
+    def get(self, bundle_name: bytes32) -> MempoolItem | None:
         return self._txs.get(bundle_name, None)
 
     def add(self, item: MempoolItem) -> None:

chia/full_node/start_full_node.py

@@ -4,12 +4,12 @@ import os
 import pathlib
 import sys
 from multiprocessing import freeze_support
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import ConsensusConstants
 from chia_rs.sized_ints import uint16
 
-from chia.apis import ApiProtocolRegistry
+from chia.apis import StubMetadataRegistry
 from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.full_node.full_node import FullNode
@@ -36,7 +36,7 @@ async def create_full_node_service(
     config: dict[str, Any],
     consensus_constants: ConsensusConstants,
     connect_to_daemon: bool = True,
-    override_capabilities: Optional[list[tuple[uint16, str]]] = None,
+    override_capabilities: list[tuple[uint16, str]] | None = None,
 ) -> FullNodeService:
     service_config = config[SERVICE_NAME]
 
@@ -52,7 +52,7 @@ async def create_full_node_service(
     )
     peer_api = FullNodeAPI(node)
 
-    rpc_info: Optional[RpcInfo[FullNodeRpcApi]] = None
+    rpc_info: RpcInfo[FullNodeRpcApi] | None = None
     if service_config.get("start_rpc_server", True):
         rpc_info = (FullNodeRpcApi, service_config["rpc_port"])
 
@@ -71,7 +71,7 @@ async def create_full_node_service(
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
         override_capabilities=override_capabilities,
-        class_for_type=ApiProtocolRegistry,
+        stub_metadata_for_type=StubMetadataRegistry,
     )
 
 

chia/full_node/sync_store.py

@@ -6,7 +6,6 @@ import logging
 from collections import OrderedDict
 from collections import OrderedDict as orderedDict
 from dataclasses import dataclass, field
-from typing import Optional
 
 import typing_extensions
 from chia_rs.sized_bytes import bytes32
@@ -33,7 +32,7 @@ class SyncStore:
     # peer node id : Peak
     peer_to_peak: dict[bytes32, Peak] = field(default_factory=dict)
     # Peak we are syncing towards
-    target_peak: Optional[Peak] = None
+    target_peak: Peak | None = 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)
@@ -103,7 +102,7 @@ class SyncStore:
             ret[peer_id] = peak
         return ret
 
-    def get_heaviest_peak(self) -> Optional[Peak]:
+    def get_heaviest_peak(self) -> Peak | None:
         """
         Returns: the header_hash, height, and weight of the heaviest block that one of our peers has notified
         us of.
@@ -111,7 +110,7 @@ class SyncStore:
 
         if len(self.peer_to_peak) == 0:
             return None
-        heaviest_peak: Optional[Peak] = None
+        heaviest_peak: Peak | None = None
         for peak in self.peer_to_peak.values():
             if peak.header_hash not in self.peak_to_peer:
                 continue

chia/full_node/tx_processing_queue.py

@@ -4,11 +4,12 @@ import asyncio
 import dataclasses
 import logging
 from dataclasses import dataclass, field
-from queue import SimpleQueue
-from typing import ClassVar, Generic, Optional, TypeVar, Union
+from queue import PriorityQueue, SimpleQueue
+from typing import ClassVar, Generic, TypeVar
 
 from chia_rs import SpendBundle
 from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
 
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
@@ -30,7 +31,7 @@ class ValuedEvent(Generic[T]):
     _value_sentinel: ClassVar[ValuedEventSentinel] = ValuedEventSentinel()
 
     _event: asyncio.Event = dataclasses.field(default_factory=asyncio.Event)
-    _value: Union[ValuedEventSentinel, T] = _value_sentinel
+    _value: ValuedEventSentinel | T = _value_sentinel
 
     def set(self, value: T) -> None:
         if not isinstance(self._value, ValuedEventSentinel):
@@ -45,18 +46,28 @@ class ValuedEvent(Generic[T]):
         return self._value
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
+class PeerWithTx:
+    peer_host: str
+    advertised_fee: uint64
+    advertised_cost: uint64
+
+
+@dataclass(frozen=True, order=True)
 class TransactionQueueEntry:
     """
     A transaction received from peer. This is put into a queue, and not yet in the mempool.
     """
 
     transaction: SpendBundle = field(compare=False)
-    transaction_bytes: Optional[bytes] = field(compare=False)
+    transaction_bytes: bytes | None = field(compare=False)
     spend_name: bytes32
-    peer: Optional[WSChiaConnection] = field(compare=False)
+    peer: WSChiaConnection | None = field(compare=False)
     test: bool = field(compare=False)
-    done: ValuedEvent[tuple[MempoolInclusionStatus, Optional[Err]]] = field(
+    # IDs of peers that advertised this transaction via new_transaction, along
+    # with their hostname, fee and cost.
+    peers_with_tx: dict[bytes32, PeerWithTx] = field(default_factory=dict, compare=False)
+    done: ValuedEvent[tuple[MempoolInclusionStatus, Err | None]] = field(
         default_factory=ValuedEvent,
         compare=False,
     )
@@ -74,7 +85,7 @@ 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]]
+    _queue_dict: dict[bytes32, PriorityQueue[tuple[float, TransactionQueueEntry]]]
     _high_priority_queue: SimpleQueue[TransactionQueueEntry]
     peer_size_limit: int
     log: logging.Logger
@@ -88,15 +99,25 @@ class TransactionQueue:
         self.peer_size_limit = peer_size_limit
         self.log = log
 
-    async def put(self, tx: TransactionQueueEntry, peer_id: Optional[bytes32], high_priority: bool = False) -> None:
+    def put(self, tx: TransactionQueueEntry, peer_id: bytes32 | None, high_priority: bool = False) -> None:
         if peer_id is None or high_priority:  # when it's local there is no peer_id.
             self._high_priority_queue.put(tx)
         else:
             if peer_id not in self._queue_dict:
-                self._queue_dict[peer_id] = SimpleQueue()
+                self._queue_dict[peer_id] = PriorityQueue()
                 self._index_to_peer_map.append(peer_id)
             if self._queue_dict[peer_id].qsize() < self.peer_size_limit:
-                self._queue_dict[peer_id].put(tx)
+                tx_info = tx.peers_with_tx.get(peer_id)
+                if tx_info is not None and tx_info.advertised_cost > 0:
+                    fpc = tx_info.advertised_fee / tx_info.advertised_cost
+                    # PriorityQueue returns lowest first so we invert
+                    priority = -fpc
+                else:
+                    # This peer didn't advertise cost and fee information for
+                    # this transaction (it sent a `RespondTransaction` message
+                    # instead of a `NewTransaction` one).
+                    priority = float("inf")
+                self._queue_dict[peer_id].put((priority, tx))
             else:
                 self.log.warning(f"Transaction queue full for peer {peer_id}")
                 raise TransactionQueueFull(f"Transaction queue full for peer {peer_id}")
@@ -106,11 +127,11 @@ class TransactionQueue:
         await self._queue_length.acquire()
         if not self._high_priority_queue.empty():
             return self._high_priority_queue.get()
-        result: Optional[TransactionQueueEntry] = None
+        result: TransactionQueueEntry | None = None
         while True:
             peer_queue = self._queue_dict[self._index_to_peer_map[self._list_cursor]]
             if not peer_queue.empty():
-                result = peer_queue.get()
+                _, result = peer_queue.get()
             self._list_cursor += 1
             if self._list_cursor > len(self._index_to_peer_map) - 1:
                 # reset iterator