chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

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,15 +395,17 @@ co = ConditionOpcode
 mis = MempoolInclusionStatus
 
 
-async def send_sb(node: FullNodeAPI, sb: SpendBundle) -> Optional[Message]:
+async def send_sb(node: FullNodeAPI, dummy_peer: WSChiaConnection, sb: SpendBundle) -> Message | None:
     tx = wallet_protocol.SendTransaction(sb)
-    return await node.send_transaction(tx, test=True)
+    return await node.send_transaction(tx, dummy_peer, test=True)
 
 
-async def gen_and_send_sb(node: FullNodeAPI, wallet: WalletTool, coin: Coin, fee: uint64 = uint64(0)) -> SpendBundle:
+async def gen_and_send_sb(
+    node: FullNodeAPI, dummy_peer: WSChiaConnection, wallet: WalletTool, coin: Coin, fee: uint64 = uint64(0)
+) -> SpendBundle:
     sb = generate_test_spend_bundle(wallet=wallet, coin=coin, fee=fee)
     assert sb is not None
-    await send_sb(node, sb)
+    await send_sb(node, dummy_peer, sb)
     return sb
 
 
@@ -576,14 +578,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 +593,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
@@ -610,7 +613,10 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_double_spend_with_higher_fee(
-        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self,
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        wallet_a: WalletTool,
+        self_hostname: str,
     ) -> None:
         full_node_1, _, bt = one_node_one_block
         blocks = await full_node_1.get_all_full_blocks()
@@ -621,7 +627,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)
@@ -633,15 +638,17 @@ class TestMempoolManager:
         coins = iter(blocks[-2].get_included_reward_coins())
         coin3, coin4 = next(coins), next(coins)
 
-        sb1_1 = await gen_and_send_sb(full_node_1, wallet_a, coin1)
-        sb1_2 = await gen_and_send_sb(full_node_1, wallet_a, coin1, fee=uint64(1))
+        _, dummy_node_id = await add_dummy_connection(full_node_1.server, self_hostname, 12312)
+        dummy_peer = full_node_1.server.all_connections[dummy_node_id]
+        sb1_1 = await gen_and_send_sb(full_node_1, dummy_peer, wallet_a, coin1)
+        sb1_2 = await gen_and_send_sb(full_node_1, dummy_peer, wallet_a, coin1, fee=uint64(1))
 
         # Fee increase is insufficient, the old spendbundle must stay
         assert_sb_in_pool(full_node_1.full_node.mempool_manager, sb1_1)
         assert_sb_not_in_pool(full_node_1.full_node.mempool_manager, sb1_2)
         invariant_check_mempool(full_node_1.full_node.mempool_manager.mempool)
 
-        sb1_3 = await gen_and_send_sb(full_node_1, wallet_a, coin1, fee=MEMPOOL_MIN_FEE_INCREASE)
+        sb1_3 = await gen_and_send_sb(full_node_1, dummy_peer, wallet_a, coin1, fee=MEMPOOL_MIN_FEE_INCREASE)
 
         # Fee increase is sufficiently high, sb1_1 gets replaced with sb1_3
         assert_sb_not_in_pool(full_node_1.full_node.mempool_manager, sb1_1)
@@ -650,7 +657,7 @@ class TestMempoolManager:
 
         sb2 = generate_test_spend_bundle(wallet_a, coin2, fee=MEMPOOL_MIN_FEE_INCREASE)
         sb12 = SpendBundle.aggregate([sb2, sb1_3])
-        await send_sb(full_node_1, sb12)
+        await send_sb(full_node_1, dummy_peer, sb12)
 
         # Aggregated spendbundle sb12 replaces sb1_3 since it spends a superset
         # of coins spent in sb1_3
@@ -660,7 +667,7 @@ class TestMempoolManager:
 
         sb3 = generate_test_spend_bundle(wallet_a, coin3, fee=uint64(MEMPOOL_MIN_FEE_INCREASE * 2))
         sb23 = SpendBundle.aggregate([sb2, sb3])
-        await send_sb(full_node_1, sb23)
+        await send_sb(full_node_1, dummy_peer, sb23)
 
         # sb23 must not replace existing sb12 as the former does not spend all
         # coins that are spent in the latter (specifically, coin1)
@@ -668,21 +675,21 @@ class TestMempoolManager:
         assert_sb_not_in_pool(full_node_1.full_node.mempool_manager, sb23)
         invariant_check_mempool(full_node_1.full_node.mempool_manager.mempool)
 
-        await send_sb(full_node_1, sb3)
+        await send_sb(full_node_1, dummy_peer, sb3)
         # Adding non-conflicting sb3 should succeed
         assert_sb_in_pool(full_node_1.full_node.mempool_manager, sb3)
         invariant_check_mempool(full_node_1.full_node.mempool_manager.mempool)
 
         sb4_1 = generate_test_spend_bundle(wallet_a, coin4, fee=MEMPOOL_MIN_FEE_INCREASE)
         sb1234_1 = SpendBundle.aggregate([sb12, sb3, sb4_1])
-        await send_sb(full_node_1, sb1234_1)
+        await send_sb(full_node_1, dummy_peer, sb1234_1)
         # sb1234_1 should not be in pool as it decreases total fees per cost
         assert_sb_not_in_pool(full_node_1.full_node.mempool_manager, sb1234_1)
         invariant_check_mempool(full_node_1.full_node.mempool_manager.mempool)
 
         sb4_2 = generate_test_spend_bundle(wallet_a, coin4, fee=uint64(MEMPOOL_MIN_FEE_INCREASE * 2))
         sb1234_2 = SpendBundle.aggregate([sb12, sb3, sb4_2])
-        await send_sb(full_node_1, sb1234_2)
+        await send_sb(full_node_1, dummy_peer, sb1234_2)
         # sb1234_2 has a higher fee per cost than its conflicts and should get
         # into mempool
         assert_sb_in_pool(full_node_1.full_node.mempool_manager, sb1234_2)
@@ -692,7 +699,10 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_invalid_signature(
-        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self,
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        wallet_a: WalletTool,
+        self_hostname: str,
     ) -> None:
         reward_ph = wallet_a.get_new_puzzlehash()
 
@@ -704,19 +714,19 @@ 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)
+        _, dummy_node_id = await add_dummy_connection(full_node_1.server, self_hostname, 12312)
+        dummy_peer = full_node_1.server.all_connections[dummy_node_id]
+        res: Message | None = await send_sb(full_node_1, dummy_peer, sb)
         assert res is not None
         ack: TransactionAck = TransactionAck.from_bytes(res.data)
         assert ack.status == MempoolInclusionStatus.FAILED.value
@@ -730,8 +740,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 +751,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 +764,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 +780,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 +790,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 +804,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 +1263,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 +1476,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 +1748,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 +1763,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 +1807,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 +1854,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 +2534,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 +2554,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 +2858,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 +2924,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 +3417,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 +3436,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)