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

chia/_tests/core/full_node/test_tx_processing_queue.py

@@ -2,14 +2,17 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import math
 import random
-from dataclasses import dataclass
-from typing import Optional, cast
+from dataclasses import dataclass, field
+from typing import cast
 
 import pytest
+from chia_rs import G2Element, SpendBundle
 from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
 
-from chia.full_node.tx_processing_queue import TransactionQueue, TransactionQueueEntry, TransactionQueueFull
+from chia.full_node.tx_processing_queue import PeerWithTx, TransactionQueue, TransactionQueueEntry, TransactionQueueFull
 from chia.util.task_referencer import create_referenced_task
 
 log = logging.getLogger(__name__)
@@ -17,12 +20,17 @@ log = logging.getLogger(__name__)
 
 @dataclass(frozen=True)
 class FakeTransactionQueueEntry:
-    index: int
-    peer_id: Optional[bytes32]
+    index: int = field(compare=False)
+    peer_id: bytes32 | None = field(compare=False)
+    peers_with_tx: dict[bytes32, PeerWithTx] | None = field(compare=False)
 
 
-def get_transaction_queue_entry(peer_id: Optional[bytes32], tx_index: int) -> TransactionQueueEntry:  # easy shortcut
-    return cast(TransactionQueueEntry, FakeTransactionQueueEntry(index=tx_index, peer_id=peer_id))
+def get_transaction_queue_entry(
+    peer_id: bytes32 | None, tx_index: int, peers_with_tx: dict[bytes32, PeerWithTx] | None = None
+) -> TransactionQueueEntry:  # easy shortcut
+    if peers_with_tx is None:
+        peers_with_tx = {}
+    return cast(TransactionQueueEntry, FakeTransactionQueueEntry(tx_index, peer_id, peers_with_tx))
 
 
 @pytest.mark.anyio
@@ -30,7 +38,7 @@ async def test_local_txs(seeded_random: random.Random) -> None:
     transaction_queue = TransactionQueue(1000, log)
     # test 1 tx
     first_tx = get_transaction_queue_entry(None, 0)
-    await transaction_queue.put(first_tx, None)
+    transaction_queue.put(first_tx, None)
 
     result1 = await transaction_queue.pop()
 
@@ -40,7 +48,7 @@ async def test_local_txs(seeded_random: random.Random) -> None:
     num_txs = 2000
     list_txs = [get_transaction_queue_entry(bytes32.random(seeded_random), i) for i in range(num_txs)]
     for tx in list_txs:
-        await transaction_queue.put(tx, None)
+        transaction_queue.put(tx, None)
 
     resulting_txs = []
     for _ in range(num_txs):
@@ -58,12 +66,12 @@ async def test_one_peer_and_await(seeded_random: random.Random) -> None:
 
     list_txs = [get_transaction_queue_entry(peer_id, i) for i in range(num_txs)]
     for tx in list_txs:
-        await transaction_queue.put(tx, peer_id)
+        transaction_queue.put(tx, peer_id)
 
     # test transaction priority
     local_txs = [get_transaction_queue_entry(None, i) for i in range(int(num_txs / 5))]  # 20 txs
     for tx in local_txs:
-        await transaction_queue.put(tx, None)
+        transaction_queue.put(tx, None)
 
     resulting_txs = []
     for _ in range(num_txs + len(local_txs)):
@@ -80,7 +88,7 @@ async def test_one_peer_and_await(seeded_random: random.Random) -> None:
     with pytest.raises(asyncio.InvalidStateError):  # task is not done, so we expect an error when getting result
         task.result()
     # add a tx to test task completion
-    await transaction_queue.put(get_transaction_queue_entry(None, 0), None)
+    transaction_queue.put(get_transaction_queue_entry(None, 0), None)
     await asyncio.wait_for(task, 1)  # we should never time out here
 
 
@@ -95,7 +103,7 @@ async def test_lots_of_peers(seeded_random: random.Random) -> None:
     # 100 txs per peer
     list_txs = [get_transaction_queue_entry(peer_id, i) for peer_id in peer_ids for i in range(num_txs)]
     for tx in list_txs:
-        await transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
+        transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
 
     resulting_txs = []
     for _ in range(total_txs):
@@ -117,11 +125,11 @@ async def test_full_queue(seeded_random: random.Random) -> None:
     # 999 txs per peer then 1 to fail later
     list_txs = [get_transaction_queue_entry(peer_id, i) for peer_id in peer_ids for i in range(num_txs)]
     for tx in list_txs:
-        await transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
+        transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
 
     # test failure case.
     with pytest.raises(TransactionQueueFull):
-        await transaction_queue.put(get_transaction_queue_entry(peer_ids[0], 1001), peer_ids[0])
+        transaction_queue.put(get_transaction_queue_entry(peer_ids[0], 1001), peer_ids[0])
 
     resulting_txs = []
     for _ in range(total_txs):
@@ -135,20 +143,96 @@ async def test_queue_cleanup_and_fairness(seeded_random: random.Random) -> None:
     peer_b = bytes32.random(seeded_random)
     peer_c = bytes32.random(seeded_random)
 
+    higher_tx_cost = uint64(20)
+    lower_tx_cost = uint64(10)
+    higher_tx_fee = uint64(5)
+    lower_tx_fee = uint64(1)
     # 2 for a, 1 for b, 2 for c
-    peer_tx_a = [get_transaction_queue_entry(peer_a, i) for i in range(2)]
-    peer_tx_b = [get_transaction_queue_entry(peer_b, 0)]
-    peer_tx_c = [get_transaction_queue_entry(peer_c, i) for i in range(2)]
+    peer_tx_a = [
+        get_transaction_queue_entry(peer_a, 0, {peer_a: PeerWithTx(str(peer_a), lower_tx_fee, higher_tx_cost)}),
+        get_transaction_queue_entry(peer_a, 1, {peer_a: PeerWithTx(str(peer_a), higher_tx_fee, lower_tx_cost)}),
+    ]
+    peer_tx_b = [
+        get_transaction_queue_entry(peer_b, 0, {peer_b: PeerWithTx(str(peer_b), higher_tx_fee, lower_tx_cost)})
+    ]
+    peer_tx_c = [
+        get_transaction_queue_entry(peer_c, 0, {peer_c: PeerWithTx(str(peer_c), higher_tx_fee, lower_tx_cost)}),
+        get_transaction_queue_entry(peer_c, 1, {peer_c: PeerWithTx(str(peer_c), lower_tx_fee, higher_tx_cost)}),
+    ]
 
     list_txs = peer_tx_a + peer_tx_b + peer_tx_c
     for tx in list_txs:
-        await transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
+        transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
 
-    resulting_ids = []
+    entries = []
     for _ in range(3):  # we validate we get one transaction per peer
-        resulting_ids.append((await transaction_queue.pop()).peer_id)  # type: ignore[attr-defined]
-    assert [peer_a, peer_b, peer_c] == resulting_ids  # all peers have been properly included in the queue.
-    second_resulting_ids = []
+        entry = await transaction_queue.pop()
+        entries.append((entry.peer_id, entry.index))  # type: ignore[attr-defined]
+    assert [(peer_a, 1), (peer_b, 0), (peer_c, 0)] == entries  # all peers have been properly included in the queue.
+    second_entries = []
     for _ in range(2):  # we validate that we properly queue the last 2 transactions
-        second_resulting_ids.append((await transaction_queue.pop()).peer_id)  # type: ignore[attr-defined]
-    assert [peer_a, peer_c] == second_resulting_ids
+        entry = await transaction_queue.pop()
+        second_entries.append((entry.peer_id, entry.index))  # type: ignore[attr-defined]
+    assert [(peer_a, 0), (peer_c, 1)] == second_entries
+
+
+def test_tx_queue_entry_order_compare() -> None:
+    """
+    Tests that `TransactionQueueEntry` orders and compares using transaction
+    IDs regardless of other fields.
+    """
+    # Let's create two items with the same transaction ID but different data
+    sb = SpendBundle([], G2Element())
+    sb_name = sb.name()
+    item1 = TransactionQueueEntry(
+        transaction=sb, transaction_bytes=bytes(sb), spend_name=sb_name, peer=None, test=False, peers_with_tx={}
+    )
+    item2 = TransactionQueueEntry(
+        transaction=sb, transaction_bytes=None, spend_name=sb_name, peer=None, test=True, peers_with_tx={}
+    )
+    # They should be ordered and compared (considered equal) by `spend_name`
+    # regardless of other fields.
+    assert (item1 < item2) is False
+    assert item1 == item2
+
+
+@pytest.mark.anyio
+async def test_peer_queue_prioritization_fallback() -> None:
+    """
+    Tests prioritization fallback, when `peer_id` is not in `peers_with_tx`.
+    """
+    queue = TransactionQueue(42, log)
+    peer1 = bytes32.random()
+    peer2 = bytes32.random()
+    # We'll be using this peer to test the fallback, so we don't include it in
+    # peers with transactions maps.
+    peer3 = bytes32.random()
+    peers_with_tx1 = {
+        # This has FPC of 5.0
+        peer1: PeerWithTx(str(peer1), uint64(10), uint64(2)),
+        # This has FPC of 2.0 but higher advertised cost
+        peer2: PeerWithTx(str(peer2), uint64(20), uint64(10)),
+    }
+    tx1 = get_transaction_queue_entry(peer3, 0, peers_with_tx1)
+    queue.put(tx1, peer3)
+    peers_with_tx2 = {
+        # This has FPC of 3.0
+        peer1: PeerWithTx(str(peer1), uint64(30), uint64(10)),
+        # This has FPC of 4.0 but lower advertised cost
+        peer2: PeerWithTx(str(peer2), uint64(20), uint64(5)),
+        # This has FPC of 1.0 but lower advertised cost
+        peer3: PeerWithTx(str(peer3), uint64(4), uint64(4)),
+    }
+    tx2 = get_transaction_queue_entry(peer3, 1, peers_with_tx2)
+    queue.put(tx2, peer3)
+    # tx2 gets top priority with FPC 1.0
+    assert math.isclose(queue._queue_dict[peer3].queue[0][0], -1.0)
+    entry = await queue.pop()
+    # NOTE: This whole test file uses `index` as an addition to
+    # `TransactionQueueEntry` for easier testing, hence this type ignore here
+    # and everywhere else.
+    assert entry.index == 1  # type: ignore[attr-defined]
+    # tx1 comes next due to lowest priority fallback
+    assert math.isinf(queue._queue_dict[peer3].queue[0][0])
+    entry = await queue.pop()
+    assert entry.index == 0  # type: ignore[attr-defined]

chia/_tests/core/mempool/test_mempool.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import dataclasses
 import logging
 import random
-from typing import Callable, Optional
+from collections.abc import Callable
 
 import pytest
 from chia_rs import (
@@ -26,6 +26,7 @@ from clvm_tools.binutils import assemble
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
 from chia._tests.connection_utils import add_dummy_connection, connect_and_get_peer
+from chia._tests.core.full_node.test_full_node import find_reward_coin
 from chia._tests.core.mempool.test_mempool_manager import (
     IDENTITY_PUZZLE_HASH,
     TEST_COIN,
@@ -100,7 +101,7 @@ def wallet_a(bt: BlockTools) -> WalletTool:
 def generate_test_spend_bundle(
     wallet: WalletTool,
     coin: Coin,
-    condition_dic: Optional[dict[ConditionOpcode, list[ConditionWithArgs]]] = None,
+    condition_dic: dict[ConditionOpcode, list[ConditionWithArgs]] | None = None,
     fee: uint64 = uint64(0),
     amount: uint64 = uint64(1000),
     new_puzzle_hash: bytes32 = BURN_PUZZLE_HASH,
@@ -350,7 +351,7 @@ async def respond_transaction(
     peer: WSChiaConnection,
     tx_bytes: bytes = b"",
     test: bool = False,
-) -> tuple[MempoolInclusionStatus, Optional[Err]]:
+) -> tuple[MempoolInclusionStatus, Err | None]:
     """
     Receives a full transaction from peer.
     If tx is added to mempool, send tx_id to others. (new_transaction)
@@ -380,7 +381,6 @@ async def next_block(full_node_1: FullNodeSimulator, wallet_a: WalletTool, bt: B
         block_list_input=blocks,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=reward_ph,
-        pool_reward_puzzle_hash=reward_ph,
         genesis_timestamp=uint64(10_000),
         time_per_block=10,
     )
@@ -395,7 +395,7 @@ co = ConditionOpcode
 mis = MempoolInclusionStatus
 
 
-async def send_sb(node: FullNodeAPI, sb: SpendBundle) -> Optional[Message]:
+async def send_sb(node: FullNodeAPI, sb: SpendBundle) -> Message | None:
     tx = wallet_protocol.SendTransaction(sb)
     return await node.send_transaction(tx, test=True)
 
@@ -576,14 +576,14 @@ class TestMempoolManager:
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
         )
         peer = await connect_and_get_peer(server_1, server_2, self_hostname)
 
         await add_blocks_in_batches(blocks, full_node_1.full_node)
         await time_out_assert(60, node_height_at_least, True, full_node_1, start_height + 3)
 
-        spend_bundle1 = generate_test_spend_bundle(wallet_a, blocks[-1].get_included_reward_coins()[0])
+        coin_1 = find_reward_coin(blocks[-1], reward_ph)
+        spend_bundle1 = generate_test_spend_bundle(wallet_a, coin_1)
 
         assert spend_bundle1 is not None
         tx1: full_node_protocol.RespondTransaction = full_node_protocol.RespondTransaction(spend_bundle1)
@@ -591,9 +591,10 @@ class TestMempoolManager:
         assert err is None
         assert status == MempoolInclusionStatus.SUCCESS
 
+        coin_1 = find_reward_coin(blocks[-1], reward_ph)
         spend_bundle2 = generate_test_spend_bundle(
             wallet_a,
-            blocks[-1].get_included_reward_coins()[0],
+            coin_1,
             new_puzzle_hash=BURN_PUZZLE_HASH_2,
         )
         assert spend_bundle2 is not None
@@ -621,7 +622,6 @@ class TestMempoolManager:
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
         )
 
         invariant_check_mempool(full_node_1.full_node.mempool_manager.mempool)
@@ -704,19 +704,17 @@ class TestMempoolManager:
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
         )
 
         await add_blocks_in_batches(blocks, full_node_1.full_node)
         await time_out_assert(60, node_height_at_least, True, full_node_1, start_height + 3)
 
-        coins = iter(blocks[-1].get_included_reward_coins())
-        coin1 = next(coins)
+        coin1 = find_reward_coin(blocks[-1], reward_ph)
 
         sb: SpendBundle = generate_test_spend_bundle(wallet_a, coin1)
         assert sb.aggregated_signature != G2Element.generator()
         sb = sb.replace(aggregated_signature=G2Element.generator())
-        res: Optional[Message] = await send_sb(full_node_1, sb)
+        res: Message | None = await send_sb(full_node_1, sb)
         assert res is not None
         ack: TransactionAck = TransactionAck.from_bytes(res.data)
         assert ack.status == MempoolInclusionStatus.FAILED.value
@@ -730,8 +728,8 @@ class TestMempoolManager:
         dic: dict[ConditionOpcode, list[ConditionWithArgs]],
         fee: int = 0,
         num_blocks: int = 3,
-        coin: Optional[Coin] = None,
-    ) -> tuple[list[FullBlock], SpendBundle, WSChiaConnection, MempoolInclusionStatus, Optional[Err]]:
+        coin: Coin | None = None,
+    ) -> tuple[list[FullBlock], SpendBundle, WSChiaConnection, MempoolInclusionStatus, Err | None]:
         reward_ph = wallet_a.get_new_puzzlehash()
         full_node_1, server_1, bt = one_node_one_block
         blocks = await full_node_1.get_all_full_blocks()
@@ -741,7 +739,6 @@ class TestMempoolManager:
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
         )
         _, dummy_node_id = await add_dummy_connection(server_1, bt.config["self_hostname"], 100)
         for node_id, wsc in server_1.all_connections.items():
@@ -755,9 +752,8 @@ class TestMempoolManager:
 
         await time_out_assert(60, node_height_at_least, True, full_node_1, start_height + num_blocks)
 
-        spend_bundle1 = generate_test_spend_bundle(
-            wallet_a, coin or blocks[-num_blocks + 2].get_included_reward_coins()[0], dic, uint64(fee)
-        )
+        coin1 = find_reward_coin(blocks[2 - num_blocks], reward_ph)
+        spend_bundle1 = generate_test_spend_bundle(wallet_a, coin or coin1, dic, uint64(fee))
 
         assert spend_bundle1 is not None
 
@@ -772,7 +768,7 @@ class TestMempoolManager:
         node_server_bt: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
         test_fun: Callable[[Coin, Coin], SpendBundle],
-    ) -> tuple[list[FullBlock], SpendBundle, MempoolInclusionStatus, Optional[Err]]:
+    ) -> tuple[list[FullBlock], SpendBundle, MempoolInclusionStatus, Err | None]:
         reward_ph = wallet_a.get_new_puzzlehash()
         full_node_1, server_1, bt = node_server_bt
         blocks = await full_node_1.get_all_full_blocks()
@@ -782,7 +778,6 @@ class TestMempoolManager:
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
             time_per_block=10,
         )
         _, dummy_node_id = await add_dummy_connection(server_1, bt.config["self_hostname"], 100)
@@ -797,8 +792,8 @@ class TestMempoolManager:
 
         await time_out_assert(60, node_height_at_least, True, full_node_1, start_height + 3)
 
-        coin_1 = blocks[-2].get_included_reward_coins()[0]
-        coin_2 = blocks[-1].get_included_reward_coins()[0]
+        coin_1 = find_reward_coin(blocks[-2], reward_ph)
+        coin_2 = find_reward_coin(blocks[-1], reward_ph)
 
         bundle = test_fun(coin_1, coin_2)
 
@@ -1256,7 +1251,7 @@ class TestMempoolManager:
         self,
         assert_garbage: bool,
         announce_garbage: bool,
-        expected: Optional[Err],
+        expected: Err | None,
         expected_included: MempoolInclusionStatus,
         one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
@@ -1469,7 +1464,7 @@ class TestMempoolManager:
         self,
         assert_garbage: bool,
         announce_garbage: bool,
-        expected: Optional[Err],
+        expected: Err | None,
         expected_included: MempoolInclusionStatus,
         one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
@@ -1741,7 +1736,6 @@ class TestMempoolManager:
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
         )
 
         peer = await connect_and_get_peer(server_1, server_2, bt.config["self_hostname"])
@@ -1757,7 +1751,7 @@ class TestMempoolManager:
 
         fee = 9
 
-        coin_1 = blocks[-2].get_included_reward_coins()[0]
+        coin_1 = find_reward_coin(blocks[-2], reward_ph)
         coin_2 = None
         for coin in blocks[-1].get_included_reward_coins():
             if coin.amount == coin_1.amount:
@@ -1801,13 +1795,12 @@ class TestMempoolManager:
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
         )
 
         await add_blocks_in_batches(blocks, full_node_1.full_node)
 
         await time_out_assert(60, node_height_at_least, True, full_node_1, start_height + 3)
-        # coin = blocks[-1].get_included_reward_coins()[0]
+        # coin = find_reward_coin(blocks[-1], reward_ph)
         # spend_bundle1 = generate_test_spend_bundle(wallet_a, coin)
         coin = await next_block(full_node_1, wallet_a, bt)
         spend_bundle1 = generate_test_spend_bundle(wallet_a, coin)
@@ -1849,7 +1842,6 @@ class TestMempoolManager:
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
         )
 
         await add_blocks_in_batches(blocks, full_node_1.full_node)
@@ -2530,7 +2522,7 @@ class TestGeneratorConditions:
         ],
     )
     def test_softfork_condition(
-        self, mempool: bool, condition: str, expect_error: Optional[int], softfork_height: uint32
+        self, mempool: bool, condition: str, expect_error: int | None, softfork_height: uint32
     ) -> None:
         npc_result = generator_condition_tester(condition, mempool_mode=mempool, height=softfork_height)
         print(npc_result)
@@ -2550,7 +2542,7 @@ class TestGeneratorConditions:
         ],
     )
     def test_message_condition(
-        self, mempool: bool, condition: str, expect_error: Optional[int], softfork_height: uint32
+        self, mempool: bool, condition: str, expect_error: int | None, softfork_height: uint32
     ) -> None:
         npc_result = generator_condition_tester(condition, mempool_mode=mempool, height=softfork_height)
         print(npc_result)
@@ -2854,14 +2846,14 @@ class TestMaliciousGenerators:
             5,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
         )
 
         await add_blocks_in_batches(blocks, full_node_1.full_node)
 
         await time_out_assert(60, node_height_at_least, True, full_node_1, blocks[-1].height)
 
-        spend_bundle = generate_test_spend_bundle(wallet_a, blocks[-1].get_included_reward_coins()[0])
+        coin_1 = find_reward_coin(blocks[-1], reward_ph)
+        spend_bundle = generate_test_spend_bundle(wallet_a, coin_1)
         cs = spend_bundle.coin_spends[0]
         c = cs.coin
         coin_0 = Coin(c.parent_coin_info, bytes32([1] * 32), c.amount)
@@ -2920,7 +2912,7 @@ def test_items_by_feerate(items: list[MempoolItem], expected: list[Coin]) -> Non
 
     assert len(ordered_items) == len(expected)
 
-    last_fpc: Optional[float] = None
+    last_fpc: float | None = None
     for mi, expected_coin in zip(ordered_items, expected):
         assert len(mi.bundle_coin_spends) == 1
         assert next(iter(mi.bundle_coin_spends.values())).coin_spend.coin == expected_coin
@@ -3413,7 +3405,7 @@ async def test_lineage_cache(seeded_random: random.Random) -> None:
         bytes32.random(seeded_random), bytes32.random(seeded_random), bytes32.random(seeded_random)
     )
 
-    async def callback1(ph: bytes32) -> Optional[UnspentLineageInfo]:
+    async def callback1(ph: bytes32) -> UnspentLineageInfo | None:
         nonlocal called
         called += 1
         return info1
@@ -3432,7 +3424,7 @@ async def test_lineage_cache(seeded_random: random.Random) -> None:
 
     called = 0
 
-    async def callback_none(ph: bytes32) -> Optional[UnspentLineageInfo]:
+    async def callback_none(ph: bytes32) -> UnspentLineageInfo | None:
         nonlocal called
         called += 1
         return None

chia/_tests/core/mempool/test_mempool_fee_estimator.py

@@ -62,43 +62,43 @@ async def test_basics() -> None:
 async def test_fee_increase() -> None:
     async with DBConnection(db_version=2) as db_wrapper:
         coin_store = await CoinStore.create(db_wrapper)
-        mempool_manager = MempoolManager(
+        async with MempoolManager.managed(
             coin_store.get_coin_records, coin_store.get_unspent_lineage_info_for_puzzle_hash, test_constants
-        )
-        assert test_constants.MAX_BLOCK_COST_CLVM == mempool_manager.constants.MAX_BLOCK_COST_CLVM
-        btc_fee_estimator: BitcoinFeeEstimator = mempool_manager.mempool.fee_estimator  # type: ignore
-        fee_tracker = btc_fee_estimator.get_tracker()
-        estimator = SmartFeeEstimator(fee_tracker, uint64(test_constants.MAX_BLOCK_COST_CLVM))
-        random = Random(x=1)
-        for i in range(300, 700):
-            items = []
-            for _ in range(20):
-                fee = uint64(0)
-                included_height = uint32(random.randint(i - 60, i - 1))
-                cost = uint64(5000000)
-                mempool_item = MempoolItemInfo(
-                    cost,
-                    fee,
-                    included_height,
-                )
-                items.append(mempool_item)
-
-            fee_tracker.process_block(uint32(i), items)
-
-        short, med, long = fee_tracker.estimate_fees()
-        mempool_info = mempool_manager.mempool.fee_estimator.get_mempool_info()
-
-        result = estimator.get_estimates(mempool_info, ignore_mempool=True)
-
-        assert short.median == -1
-        assert med.median == -1
-        assert long.median == 0.0
-
-        assert result.error is None
-        short_estimate = result.estimates[0].estimated_fee_rate
-        med_estimate = result.estimates[1].estimated_fee_rate
-        long_estimate = result.estimates[2].estimated_fee_rate
-
-        assert short_estimate.mojos_per_clvm_cost == uint64(fee_tracker.buckets[3] / 1000)
-        assert med_estimate.mojos_per_clvm_cost == uint64(fee_tracker.buckets[3] / 1000)
-        assert long_estimate.mojos_per_clvm_cost == uint64(0)
+        ) as mempool_manager:
+            assert test_constants.MAX_BLOCK_COST_CLVM == mempool_manager.constants.MAX_BLOCK_COST_CLVM
+            btc_fee_estimator: BitcoinFeeEstimator = mempool_manager.mempool.fee_estimator  # type: ignore
+            fee_tracker = btc_fee_estimator.get_tracker()
+            estimator = SmartFeeEstimator(fee_tracker, uint64(test_constants.MAX_BLOCK_COST_CLVM))
+            random = Random(x=1)
+            for i in range(300, 700):
+                items = []
+                for _ in range(20):
+                    fee = uint64(0)
+                    included_height = uint32(random.randint(i - 60, i - 1))
+                    cost = uint64(5000000)
+                    mempool_item = MempoolItemInfo(
+                        cost,
+                        fee,
+                        included_height,
+                    )
+                    items.append(mempool_item)
+
+                fee_tracker.process_block(uint32(i), items)
+
+            short, med, long = fee_tracker.estimate_fees()
+            mempool_info = mempool_manager.mempool.fee_estimator.get_mempool_info()
+
+            result = estimator.get_estimates(mempool_info, ignore_mempool=True)
+
+            assert short.median == -1
+            assert med.median == -1
+            assert long.median == 0.0
+
+            assert result.error is None
+            short_estimate = result.estimates[0].estimated_fee_rate
+            med_estimate = result.estimates[1].estimated_fee_rate
+            long_estimate = result.estimates[2].estimated_fee_rate
+
+            assert short_estimate.mojos_per_clvm_cost == uint64(fee_tracker.buckets[3] / 1000)
+            assert med_estimate.mojos_per_clvm_cost == uint64(fee_tracker.buckets[3] / 1000)
+            assert long_estimate.mojos_per_clvm_cost == uint64(0)

chia/_tests/core/mempool/test_mempool_fee_protocol.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import datetime
-from typing import Union
 
 import pytest
 from chia_rs.sized_ints import uint64
@@ -20,9 +19,7 @@ from chia.wallet.wallet import Wallet
 
 @pytest.mark.anyio
 async def test_protocol_messages(
-    simulator_and_wallet: tuple[
-        list[Union[FullNodeAPI, FullNodeSimulator]], list[tuple[Wallet, ChiaServer]], BlockTools
-    ],
+    simulator_and_wallet: tuple[list[FullNodeAPI | FullNodeSimulator], list[tuple[Wallet, ChiaServer]], BlockTools],
 ) -> None:
     full_nodes, _wallets, bt = simulator_and_wallet
     a_wallet = bt.get_pool_wallet_tool()
@@ -31,10 +28,9 @@ async def test_protocol_messages(
         35,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=reward_ph,
-        pool_reward_puzzle_hash=reward_ph,
     )
 
-    full_node_sim: Union[FullNodeAPI, FullNodeSimulator] = full_nodes[0]
+    full_node_sim: FullNodeAPI | FullNodeSimulator = full_nodes[0]
 
     for block in blocks:
         await full_node_sim.full_node.add_block(block)