chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__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, Dict, List, Optional, Tuple
+from typing import Callable, Optional
 
 import pytest
 from chia_rs import G1Element, G2Element, get_flags_for_height_and_constants
@@ -24,6 +24,7 @@ from chia._tests.core.mempool.test_mempool_manager import (
     spend_bundle_from_conditions,
 )
 from chia._tests.core.node_height import node_height_at_least
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia._tests.util.misc import BenchmarkRunner, invariant_check_mempool
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.consensus.condition_costs import ConditionCost
@@ -33,14 +34,16 @@ from chia.full_node.bitcoin_fee_estimator import create_bitcoin_fee_estimator
 from chia.full_node.fee_estimation import EmptyMempoolInfo, MempoolInfo
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.full_node.mempool import Mempool
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions, get_puzzle_and_solution_for_coin
+from chia.full_node.mempool_check_conditions import get_puzzle_and_solution_for_coin
 from chia.full_node.mempool_manager import MEMPOOL_MIN_FEE_INCREASE
 from chia.full_node.pending_tx_cache import ConflictTxCache, PendingTxCache
 from chia.protocols import full_node_protocol, wallet_protocol
 from chia.protocols.wallet_protocol import TransactionAck
+from chia.server.api_protocol import ApiMetadata
 from chia.server.outbound_message import Message
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
+from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.simulator.block_tools import BlockTools, test_constants
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
@@ -61,7 +64,6 @@ from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.mempool_item import MempoolItem
 from chia.types.spend_bundle import SpendBundle, estimate_fees
 from chia.types.spend_bundle_conditions import SpendBundleConditions
-from chia.util.api_decorators import api_request
 from chia.util.errors import Err
 from chia.util.hash import std_hash
 from chia.util.ints import uint32, uint64
@@ -90,7 +92,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: Optional[dict[ConditionOpcode, list[ConditionWithArgs]]] = None,
     fee: uint64 = uint64(0),
     amount: uint64 = uint64(1000),
     new_puzzle_hash: bytes32 = BURN_PUZZLE_HASH,
@@ -109,7 +111,7 @@ def make_item(
     return MempoolItem(
         SpendBundle([], G2Element()),
         fee,
-        SpendBundleConditions([], 0, 0, 0, None, None, [], cost, 0, 0, False),
+        SpendBundleConditions([], 0, 0, 0, None, None, [], cost, 0, 0, False, 0, 0),
         spend_bundle_name,
         uint32(0),
         assert_height,
@@ -307,9 +309,9 @@ class TestPendingTxCache:
 class TestMempool:
     @pytest.mark.anyio
     async def test_basic_mempool(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
@@ -328,14 +330,19 @@ class TestMempool:
         assert spend_bundle is not None
 
 
-@api_request(peer_required=True, bytes_required=True)
+metadata = ApiMetadata()
+
+
+# this (method'ish) function is not designed per normal uses so allowing the ignore
+# for the different return type.  normal is Optional[Message]
+@metadata.request(peer_required=True, bytes_required=True)  # type: ignore[type-var]
 async def respond_transaction(
     self: FullNodeAPI,
     tx: full_node_protocol.RespondTransaction,
     peer: WSChiaConnection,
     tx_bytes: bytes = b"",
     test: bool = False,
-) -> Tuple[MempoolInclusionStatus, Optional[Err]]:
+) -> tuple[MempoolInclusionStatus, Optional[Err]]:
     """
     Receives a full transaction from peer.
     If tx is added to mempool, send tx_id to others. (new_transaction)
@@ -367,8 +374,7 @@ async def next_block(full_node_1: FullNodeSimulator, wallet_a: WalletTool, bt: B
         time_per_block=10,
     )
 
-    for block in blocks:
-        await full_node_1.full_node.add_block(block)
+    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 + 1)
     return blocks[-1].get_included_reward_coins()[0]
@@ -394,11 +400,11 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_basic_mempool_manager(
         self,
-        two_nodes_one_block: Tuple[FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, BlockTools],
+        two_nodes_one_block: tuple[FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, BlockTools],
         wallet_a: WalletTool,
         self_hostname: str,
     ) -> None:
-        full_node_1, full_node_2, server_1, server_2, bt = two_nodes_one_block
+        full_node_1, _full_node_2, server_1, server_2, bt = two_nodes_one_block
 
         peer = await connect_and_get_peer(server_1, server_2, self_hostname)
 
@@ -455,7 +461,7 @@ class TestMempoolManager:
     )
     async def test_ephemeral_timelock(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
         opcode: ConditionOpcode,
         lock_value: int,
@@ -473,10 +479,10 @@ class TestMempoolManager:
             bundle = SpendBundle.aggregate([tx1, tx2])
             return bundle
 
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
-        blocks, bundle, status, err = await self.condition_tester2(one_node_one_block, wallet_a, test_fun)
+        _blocks, bundle, status, err = await self.condition_tester2(one_node_one_block, wallet_a, test_fun)
         mempool_bundle = full_node_1.full_node.mempool_manager.get_spendbundle(bundle.name())
 
         print(f"opcode={opcode} timelock_value={lock_value} expected={expected} status={status}")
@@ -495,7 +501,7 @@ class TestMempoolManager:
     # another spend, even though the assert condition is duplicated 100 times
     @pytest.mark.anyio
     async def test_coin_announcement_duplicate_consumed(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertCoinAnnouncement(asserted_id=coin_2.name(), asserted_msg=b"test")
@@ -509,8 +515,8 @@ class TestMempoolManager:
             bundle = SpendBundle.aggregate([spend_bundle1, spend_bundle2])
             return bundle
 
-        full_node_1, server_1, bt = one_node_one_block
-        blocks, bundle, status, err = await self.condition_tester2(one_node_one_block, wallet_a, test_fun)
+        full_node_1, _server_1, _bt = one_node_one_block
+        _blocks, bundle, status, err = await self.condition_tester2(one_node_one_block, wallet_a, test_fun)
         mempool_bundle = full_node_1.full_node.mempool_manager.get_spendbundle(bundle.name())
 
         assert err is None
@@ -521,7 +527,7 @@ class TestMempoolManager:
     # another spend, even though the create announcement is duplicated 100 times
     @pytest.mark.anyio
     async def test_coin_duplicate_announcement_consumed(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertCoinAnnouncement(asserted_id=coin_2.name(), asserted_msg=b"test")
@@ -535,8 +541,8 @@ class TestMempoolManager:
             bundle = SpendBundle.aggregate([spend_bundle1, spend_bundle2])
             return bundle
 
-        full_node_1, server_1, bt = one_node_one_block
-        blocks, bundle, status, err = await self.condition_tester2(one_node_one_block, wallet_a, test_fun)
+        full_node_1, _server_1, _bt = one_node_one_block
+        _blocks, bundle, status, err = await self.condition_tester2(one_node_one_block, wallet_a, test_fun)
         mempool_bundle = full_node_1.full_node.mempool_manager.get_spendbundle(bundle.name())
 
         assert err is None
@@ -546,12 +552,12 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_double_spend(
         self,
-        two_nodes_one_block: Tuple[FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, BlockTools],
+        two_nodes_one_block: tuple[FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, BlockTools],
         wallet_a: WalletTool,
         self_hostname: str,
     ) -> None:
         reward_ph = wallet_a.get_new_puzzlehash()
-        full_node_1, full_node_2, server_1, server_2, bt = two_nodes_one_block
+        full_node_1, _full_node_2, server_1, server_2, bt = two_nodes_one_block
         blocks = await full_node_1.get_all_full_blocks()
         start_height = blocks[-1].height
         blocks = bt.get_consecutive_blocks(
@@ -563,8 +569,7 @@ class TestMempoolManager:
         )
         peer = await connect_and_get_peer(server_1, server_2, self_hostname)
 
-        for block in blocks:
-            await full_node_1.full_node.add_block(block)
+        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])
@@ -594,7 +599,7 @@ 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
     ) -> None:
         full_node_1, _, bt = one_node_one_block
         blocks = await full_node_1.get_all_full_blocks()
@@ -609,8 +614,7 @@ class TestMempoolManager:
         )
 
         invariant_check_mempool(full_node_1.full_node.mempool_manager.mempool)
-        for block in blocks:
-            await full_node_1.full_node.add_block(block)
+        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())
@@ -677,11 +681,11 @@ 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
     ) -> None:
         reward_ph = wallet_a.get_new_puzzlehash()
 
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
         blocks = await full_node_1.get_all_full_blocks()
         start_height = blocks[-1].height if len(blocks) > 0 else -1
         blocks = bt.get_consecutive_blocks(
@@ -692,8 +696,7 @@ class TestMempoolManager:
             pool_reward_puzzle_hash=reward_ph,
         )
 
-        for block in blocks:
-            await full_node_1.full_node.add_block(block)
+        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())
@@ -711,13 +714,13 @@ class TestMempoolManager:
 
     async def condition_tester(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
-        dic: Dict[ConditionOpcode, List[ConditionWithArgs]],
+        dic: dict[ConditionOpcode, list[ConditionWithArgs]],
         fee: int = 0,
         num_blocks: int = 3,
         coin: Optional[Coin] = None,
-    ) -> Tuple[List[FullBlock], SpendBundle, WSChiaConnection, MempoolInclusionStatus, Optional[Err]]:
+    ) -> tuple[list[FullBlock], SpendBundle, WSChiaConnection, MempoolInclusionStatus, Optional[Err]]:
         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()
@@ -737,13 +740,12 @@ class TestMempoolManager:
         else:
             raise Exception("dummy peer not found")
 
-        for block in blocks:
-            await full_node_1.full_node.add_block(block)
+        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 + num_blocks)
 
         spend_bundle1 = generate_test_spend_bundle(
-            wallet_a, coin or list(blocks[-num_blocks + 2].get_included_reward_coins())[0], dic, uint64(fee)
+            wallet_a, coin or blocks[-num_blocks + 2].get_included_reward_coins()[0], dic, uint64(fee)
         )
 
         assert spend_bundle1 is not None
@@ -756,10 +758,10 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def condition_tester2(
         self,
-        node_server_bt: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        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, Optional[Err]]:
         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()
@@ -780,8 +782,7 @@ class TestMempoolManager:
         else:
             raise Exception("dummy peer not found")
 
-        for block in blocks:
-            await full_node_1.full_node.add_block(block)
+        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)
 
@@ -797,9 +798,9 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_invalid_block_index(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         blocks = await full_node_1.get_all_full_blocks()
         start_height = blocks[-1].height
         cvp = ConditionWithArgs(
@@ -807,7 +808,7 @@ class TestMempoolManager:
             [int_to_bytes(start_height + 5)],
         )
         dic = {ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert sb1 is None
         # the transaction may become valid later
@@ -816,12 +817,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_block_index_missing_arg(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, [])
         dic = {ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert sb1 is None
         # the transaction may become valid later
@@ -830,12 +831,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_correct_block_index(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, [int_to_bytes(1)])
         dic = {ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err is None
         assert sb1 == spend_bundle1
@@ -843,14 +844,14 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_block_index_garbage(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         # garbage at the end of the argument list is ignored in consensus mode,
         # but not in mempool-mode
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, [int_to_bytes(1), b"garbage"])
         dic = {ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err is Err.INVALID_CONDITION
         assert sb1 is None
@@ -858,12 +859,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_negative_block_index(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, [int_to_bytes(-1)])
         dic = {ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err is None
         assert sb1 == spend_bundle1
@@ -871,12 +872,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_invalid_block_age(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_RELATIVE, [int_to_bytes(5)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err == Err.ASSERT_HEIGHT_RELATIVE_FAILED
         assert sb1 is None
@@ -885,12 +886,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_block_age_missing_arg(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_RELATIVE, [])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err == Err.INVALID_CONDITION
         assert sb1 is None
@@ -899,12 +900,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_correct_block_age(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_RELATIVE, [int_to_bytes(1)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, num_blocks=4
         )
 
@@ -915,14 +916,14 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_block_age_garbage(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         # garbage at the end of the argument list is ignored in consensus mode,
         # but not in mempool mode
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_RELATIVE, [int_to_bytes(1), b"garbage"])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, num_blocks=4
         )
 
@@ -933,12 +934,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_negative_block_age(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_HEIGHT_RELATIVE, [int_to_bytes(-1)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, num_blocks=4
         )
 
@@ -949,16 +950,16 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_correct_my_id(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
         coin = await next_block(full_node_1, wallet_a, bt)
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_COIN_ID, [coin.name()])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -969,9 +970,9 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_my_id_garbage(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
@@ -980,7 +981,7 @@ class TestMempoolManager:
         # but not in mempool mode
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_COIN_ID, [coin.name(), b"garbage"])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -991,9 +992,9 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_invalid_my_id(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
@@ -1001,7 +1002,7 @@ class TestMempoolManager:
         coin_2 = await next_block(full_node_1, wallet_a, bt)
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_COIN_ID, [coin_2.name()])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -1012,12 +1013,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_my_id_missing_arg(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_COIN_ID, [])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
 
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err == Err.INVALID_CONDITION
@@ -1026,7 +1027,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_time_exceeds(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         full_node_1, _, _ = one_node_one_block
         blockchain_peak = full_node_1.full_node.blockchain.get_peak()
@@ -1045,7 +1046,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_time_fail(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         full_node_1, _, _ = one_node_one_block
         blockchain_peak = full_node_1.full_node.blockchain.get_peak()
@@ -1055,7 +1056,7 @@ class TestMempoolManager:
 
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_SECONDS_ABSOLUTE, [int_to_bytes(time_now)])
         dic = {cvp.opcode: [cvp]}
-        _, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err == Err.ASSERT_SECONDS_ABSOLUTE_FAILED
         assert sb1 is None
@@ -1063,7 +1064,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_height_pending(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         full_node_1, _, _ = one_node_one_block
         blockchain_peak = full_node_1.full_node.blockchain.get_peak()
@@ -1080,14 +1081,14 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_time_negative(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         time_now = -1
 
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_SECONDS_ABSOLUTE, [int_to_bytes(time_now)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err is None
         assert sb1 == spend_bundle1
@@ -1095,13 +1096,13 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_time_missing_arg(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
 
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_SECONDS_ABSOLUTE, [])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err == Err.INVALID_CONDITION
         assert sb1 is None
@@ -1109,7 +1110,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_time_garbage(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         full_node_1, _, _ = one_node_one_block
         blockchain_peak = full_node_1.full_node.blockchain.get_peak()
@@ -1129,14 +1130,14 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_time_relative_exceeds(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         time_relative = 3
 
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_SECONDS_RELATIVE, [int_to_bytes(time_relative)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
 
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err == Err.ASSERT_SECONDS_RELATIVE_FAILED
@@ -1157,16 +1158,16 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_time_relative_garbage(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         time_relative = 0
 
         # garbage at the end of the arguments is ignored in consensus mode, but
         # not in mempool mode
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_SECONDS_RELATIVE, [int_to_bytes(time_relative), b"garbage"])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
 
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err is Err.INVALID_CONDITION
@@ -1175,13 +1176,13 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_time_relative_missing_arg(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
 
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_SECONDS_RELATIVE, [])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
 
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err == Err.INVALID_CONDITION
@@ -1190,14 +1191,14 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_time_relative_negative(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         time_relative = -3
 
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_SECONDS_RELATIVE, [int_to_bytes(time_relative)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
 
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
         assert err is None
@@ -1207,7 +1208,7 @@ class TestMempoolManager:
     # ensure one spend can assert a coin announcement from another spend
     @pytest.mark.anyio
     async def test_correct_coin_announcement_consumed(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertCoinAnnouncement(asserted_id=coin_2.name(), asserted_msg=b"test")
@@ -1221,8 +1222,8 @@ class TestMempoolManager:
             bundle = SpendBundle.aggregate([spend_bundle1, spend_bundle2])
             return bundle
 
-        full_node_1, server_1, bt = one_node_one_block
-        blocks, bundle, status, err = await self.condition_tester2(one_node_one_block, wallet_a, test_fun)
+        full_node_1, _server_1, _bt = one_node_one_block
+        _blocks, bundle, status, err = await self.condition_tester2(one_node_one_block, wallet_a, test_fun)
         mempool_bundle = full_node_1.full_node.mempool_manager.get_spendbundle(bundle.name())
 
         assert err is None
@@ -1246,7 +1247,7 @@ class TestMempoolManager:
         announce_garbage: bool,
         expected: Optional[Err],
         expected_included: MempoolInclusionStatus,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
@@ -1270,8 +1271,8 @@ class TestMempoolManager:
             bundle = SpendBundle.aggregate([spend_bundle1, spend_bundle2])
             return bundle
 
-        full_node_1, server_1, bt = one_node_one_block
-        blocks, bundle, status, err = await self.condition_tester2(one_node_one_block, wallet_a, test_fun)
+        full_node_1, _server_1, _bt = one_node_one_block
+        _blocks, bundle, status, err = await self.condition_tester2(one_node_one_block, wallet_a, test_fun)
 
         assert err is expected
         assert status == expected_included
@@ -1281,7 +1282,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_coin_announcement_missing_arg(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             # missing arg here
@@ -1303,7 +1304,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_coin_announcement_missing_arg2(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertCoinAnnouncement(asserted_id=coin_2.name(), asserted_msg=b"test")
@@ -1326,7 +1327,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_coin_announcement_too_big(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertCoinAnnouncement(asserted_id=coin_2.name(), asserted_msg=bytes([1] * 10000))
@@ -1362,7 +1363,7 @@ class TestMempoolManager:
     # create announcement
     @pytest.mark.anyio
     async def test_invalid_coin_announcement_rejected(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertCoinAnnouncement(asserted_id=coin_2.name(), asserted_msg=b"test")
@@ -1392,7 +1393,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_invalid_coin_announcement_rejected_two(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertCoinAnnouncement(asserted_id=coin_1.name(), asserted_msg=b"test")
@@ -1419,7 +1420,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_correct_puzzle_announcement(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertPuzzleAnnouncement(asserted_ph=coin_2.puzzle_hash, asserted_msg=bytes(0x80))
@@ -1459,7 +1460,7 @@ class TestMempoolManager:
         announce_garbage: bool,
         expected: Optional[Err],
         expected_included: MempoolInclusionStatus,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
@@ -1494,7 +1495,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_puzzle_announcement_missing_arg(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             # missing arg here
@@ -1521,7 +1522,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_puzzle_announcement_missing_arg2(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertPuzzleAnnouncement(asserted_ph=coin_2.puzzle_hash, asserted_msg=b"test")
@@ -1549,7 +1550,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_invalid_puzzle_announcement_rejected(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertPuzzleAnnouncement(asserted_ph=coin_2.puzzle_hash, asserted_msg=bytes("test", "utf-8"))
@@ -1579,7 +1580,7 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_invalid_puzzle_announcement_rejected_two(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
         def test_fun(coin_1: Coin, coin_2: Coin) -> SpendBundle:
             announce = AssertPuzzleAnnouncement(asserted_ph=coin_2.puzzle_hash, asserted_msg=bytes(0x80))
@@ -1609,12 +1610,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_fee_condition(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.RESERVE_FEE, [int_to_bytes(10)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, fee=10
         )
         mempool_bundle = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
@@ -1625,14 +1626,14 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_fee_condition_garbage(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         # garbage at the end of the arguments is ignored in consensus mode, but
         # not in mempool mode
         cvp = ConditionWithArgs(ConditionOpcode.RESERVE_FEE, [int_to_bytes(10), b"garbage"])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, fee=10
         )
         mempool_bundle = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
@@ -1643,12 +1644,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_fee_condition_missing_arg(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.RESERVE_FEE, [])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, fee=10
         )
         mempool_bundle = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
@@ -1659,12 +1660,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_fee_condition_negative_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
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.RESERVE_FEE, [int_to_bytes(-1)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, fee=10
         )
         assert err == Err.RESERVE_FEE_CONDITION_FAILED
@@ -1679,12 +1680,12 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_fee_condition_fee_too_large(
-        self, one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.RESERVE_FEE, [int_to_bytes(2**64)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, fee=10
         )
         assert err == Err.RESERVE_FEE_CONDITION_FAILED
@@ -1699,13 +1700,15 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_assert_fee_condition_wrong_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
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
 
         cvp = ConditionWithArgs(ConditionOpcode.RESERVE_FEE, [int_to_bytes(10)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic, fee=9)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
+            one_node_one_block, wallet_a, dic, fee=9
+        )
         mempool_bundle = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
 
         assert err == Err.RESERVE_FEE_CONDITION_FAILED
@@ -1715,7 +1718,7 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_stealing_fee(
         self,
-        two_nodes_one_block: Tuple[FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, BlockTools],
+        two_nodes_one_block: tuple[FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
         reward_ph = wallet_a.get_new_puzzlehash()
@@ -1732,8 +1735,7 @@ class TestMempoolManager:
 
         peer = await connect_and_get_peer(server_1, server_2, bt.config["self_hostname"])
 
-        for block in blocks:
-            await full_node_1.full_node.add_block(block)
+        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 + 5)
 
@@ -1776,7 +1778,7 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_double_spend_same_bundle(
         self,
-        two_nodes_one_block: Tuple[FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, BlockTools],
+        two_nodes_one_block: tuple[FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
         reward_ph = wallet_a.get_new_puzzlehash()
@@ -1791,8 +1793,7 @@ class TestMempoolManager:
             pool_reward_puzzle_hash=reward_ph,
         )
 
-        for block in blocks:
-            await full_node_1.full_node.add_block(block)
+        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]
@@ -1825,11 +1826,11 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_agg_sig_condition(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
         reward_ph = wallet_a.get_new_puzzlehash()
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
         blocks = await full_node_1.get_all_full_blocks()
         start_height = blocks[-1].height
         blocks = bt.get_consecutive_blocks(
@@ -1840,15 +1841,14 @@ class TestMempoolManager:
             pool_reward_puzzle_hash=reward_ph,
         )
 
-        for block in blocks:
-            await full_node_1.full_node.add_block(block)
+        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 = await next_block(full_node_1, wallet_a, bt)
         # coin = blocks[-1].get_included_reward_coins()[0]
         spend_bundle_0 = generate_test_spend_bundle(wallet_a, coin)
-        unsigned: List[CoinSpend] = spend_bundle_0.coin_spends
+        unsigned: list[CoinSpend] = spend_bundle_0.coin_spends
 
         assert len(unsigned) == 1
         # coin_spend: CoinSpend = unsigned[0]
@@ -1874,17 +1874,17 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_correct_my_parent(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
         coin = await next_block(full_node_1, wallet_a, bt)
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_PARENT_ID, [coin.parent_coin_info])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -1897,10 +1897,10 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_my_parent_garbage(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
@@ -1909,7 +1909,7 @@ class TestMempoolManager:
         # but not in mempool mode
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_PARENT_ID, [coin.parent_coin_info, b"garbage"])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -1922,13 +1922,13 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_my_parent_missing_arg(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_PARENT_ID, [])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
 
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
 
@@ -1939,10 +1939,10 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_invalid_my_parent(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
@@ -1950,7 +1950,7 @@ class TestMempoolManager:
         coin_2 = await next_block(full_node_1, wallet_a, bt)
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_PARENT_ID, [coin_2.parent_coin_info])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -1963,17 +1963,17 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_correct_my_puzhash(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
         coin = await next_block(full_node_1, wallet_a, bt)
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_PUZZLEHASH, [coin.puzzle_hash])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -1986,10 +1986,10 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_my_puzhash_garbage(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
@@ -1997,7 +1997,7 @@ class TestMempoolManager:
         # garbage at the end of the arguments list is allowed but stripped
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_PUZZLEHASH, [coin.puzzle_hash, b"garbage"])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -2010,13 +2010,13 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_my_puzhash_missing_arg(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_PUZZLEHASH, [])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
 
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
 
@@ -2027,17 +2027,17 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_invalid_my_puzhash(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
         coin = await next_block(full_node_1, wallet_a, bt)
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_PUZZLEHASH, [Program.to([]).get_tree_hash()])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -2050,17 +2050,17 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_correct_my_amount(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
         coin = await next_block(full_node_1, wallet_a, bt)
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_AMOUNT, [int_to_bytes(coin.amount)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -2073,10 +2073,10 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_my_amount_garbage(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, bt = one_node_one_block
 
         _ = await next_block(full_node_1, wallet_a, bt)
         _ = await next_block(full_node_1, wallet_a, bt)
@@ -2085,7 +2085,7 @@ class TestMempoolManager:
         # but not in mempool mode
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_AMOUNT, [int_to_bytes(coin.amount), b"garbage"])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(
             one_node_one_block, wallet_a, dic, coin=coin
         )
 
@@ -2098,13 +2098,13 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_my_amount_missing_arg(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_AMOUNT, [])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
 
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
 
@@ -2115,13 +2115,13 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_invalid_my_amount(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_AMOUNT, [int_to_bytes(1000)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
 
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
 
@@ -2132,13 +2132,13 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_negative_my_amount(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
-        full_node_1, server_1, bt = one_node_one_block
+        full_node_1, _server_1, _bt = one_node_one_block
         cvp = ConditionWithArgs(ConditionOpcode.ASSERT_MY_AMOUNT, [int_to_bytes(-1)])
         dic = {cvp.opcode: [cvp]}
-        blocks, spend_bundle1, peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
+        _blocks, spend_bundle1, _peer, status, err = await self.condition_tester(one_node_one_block, wallet_a, dic)
 
         sb1 = full_node_1.full_node.mempool_manager.get_spendbundle(spend_bundle1.name())
 
@@ -2149,7 +2149,7 @@ class TestMempoolManager:
     @pytest.mark.anyio
     async def test_my_amount_too_large(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
         full_node_1, _, _ = one_node_one_block
@@ -2227,7 +2227,7 @@ class TestGeneratorConditions:
         # note how the list of conditions isn't correctly terminated with a
         # NIL atom. This is a failure
         npc_result = generator_condition_tester("(80 50) . 3", height=softfork_height)
-        assert npc_result.error in [Err.INVALID_CONDITION.value, Err.GENERATOR_RUNTIME_ERROR.value]
+        assert npc_result.error in {Err.INVALID_CONDITION.value, Err.GENERATOR_RUNTIME_ERROR.value}
 
     @pytest.mark.parametrize(
         "opcode",
@@ -2341,7 +2341,7 @@ class TestGeneratorConditions:
             max_cost=generator_base_cost + 95 * COST_PER_BYTE + ConditionCost.CREATE_COIN.value - 1,
             height=softfork_height,
         )
-        assert npc_result.error in [Err.BLOCK_COST_EXCEEDS_MAX.value, Err.INVALID_BLOCK_COST.value]
+        assert npc_result.error in {Err.BLOCK_COST_EXCEEDS_MAX.value, Err.INVALID_BLOCK_COST.value}
 
     @pytest.mark.parametrize(
         "condition",
@@ -2383,11 +2383,11 @@ class TestGeneratorConditions:
             max_cost=generator_base_cost + 117 * COST_PER_BYTE + expected_cost - 1,
             height=softfork_height,
         )
-        assert npc_result.error in [
+        assert npc_result.error in {
             Err.GENERATOR_RUNTIME_ERROR.value,
             Err.BLOCK_COST_EXCEEDS_MAX.value,
             Err.INVALID_BLOCK_COST.value,
-        ]
+        }
 
     @pytest.mark.parametrize(
         "condition",
@@ -2834,7 +2834,7 @@ class TestMaliciousGenerators:
     @pytest.mark.anyio
     async def test_invalid_coin_spend_coin(
         self,
-        one_node_one_block: Tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
         wallet_a: WalletTool,
     ) -> None:
         full_node_1, _, bt = one_node_one_block
@@ -2846,8 +2846,7 @@ class TestMaliciousGenerators:
             pool_reward_puzzle_hash=reward_ph,
         )
 
-        for block in blocks:
-            await full_node_1.full_node.add_block(block)
+        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)
 
@@ -2900,7 +2899,7 @@ coins = make_test_coins()
         ),
     ],
 )
-def test_items_by_feerate(items: List[MempoolItem], expected: List[Coin]) -> None:
+def test_items_by_feerate(items: list[MempoolItem], expected: list[Coin]) -> None:
     fee_estimator = create_bitcoin_fee_estimator(uint64(11000000000))
 
     mempool_info = MempoolInfo(
@@ -2953,7 +2952,7 @@ def item_cost(cost: int, fee_rate: float) -> MempoolItem:
         ([75, 15, 9], 10, [10, 75, 15]),
     ],
 )
-def test_full_mempool(items: List[int], add: int, expected: List[int]) -> None:
+def test_full_mempool(items: list[int], add: int, expected: list[int]) -> None:
     fee_estimator = create_bitcoin_fee_estimator(uint64(11000000000))
 
     mempool_info = MempoolInfo(
@@ -3000,7 +2999,7 @@ def test_full_mempool(items: List[int], add: int, expected: List[int]) -> None:
         ([10, 11, 12, 13, 50], [10, 11, 12, 13], False),
     ],
 )
-def test_limit_expiring_transactions(height: bool, items: List[int], expected: List[int], increase_fee: bool) -> None:
+def test_limit_expiring_transactions(height: bool, items: list[int], expected: list[int], increase_fee: bool) -> None:
     fee_estimator = create_bitcoin_fee_estimator(uint64(11000000000))
 
     mempool_info = MempoolInfo(
@@ -3079,7 +3078,7 @@ def test_limit_expiring_transactions(height: bool, items: List[int], expected: L
         ),
     ],
 )
-def test_get_items_by_coin_ids(items: List[MempoolItem], coin_ids: List[bytes32], expected: List[MempoolItem]) -> None:
+def test_get_items_by_coin_ids(items: list[MempoolItem], coin_ids: list[bytes32], expected: list[MempoolItem]) -> None:
     fee_estimator = create_bitcoin_fee_estimator(uint64(11000000000))
     mempool_info = MempoolInfo(
         CLVMCost(uint64(11000000000 * 3)),
@@ -3112,7 +3111,7 @@ async def test_aggregating_on_a_solution_then_a_more_cost_saving_one_appears() -
         sb = spend_bundle_from_conditions(conditions, coin)
         return sb
 
-    def agg_and_add_sb_returning_cost_info(mempool: Mempool, spend_bundles: List[SpendBundle]) -> uint64:
+    def agg_and_add_sb_returning_cost_info(mempool: Mempool, spend_bundles: list[SpendBundle]) -> uint64:
         sb = SpendBundle.aggregate(spend_bundles)
         mi = mempool_item_from_spendbundle(sb)
         mempool.add_to_pool(mi)
@@ -3188,7 +3187,6 @@ ENABLE_KECCAK_OPS_OUTSIDE_GUARD = 0x100
 
 
 def test_flags_for_height() -> None:
-
     # the keccak operator is supposed to be enabled at soft-fork 6 height
     flags = get_flags_for_height_and_constants(DEFAULT_CONSTANTS.SOFT_FORK6_HEIGHT, DEFAULT_CONSTANTS)
     print(f"{flags:x}")
@@ -3200,7 +3198,6 @@ def test_flags_for_height() -> None:
 
 
 def test_keccak() -> None:
-
     # the keccak operator is 62. The assemble() function doesn't support it
     # (yet)