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

chia/_tests/core/mempool/test_mempool_manager.py

@@ -3,20 +3,23 @@ from __future__ import annotations
 import dataclasses
 import logging
 import random
-from collections.abc import Awaitable, Collection, Sequence
-from typing import Any, Callable, ClassVar, Optional, Union
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable, Collection, Sequence
+from contextlib import asynccontextmanager
+from typing import Any, ClassVar
 
 import pytest
 from chia_rs import (
     ELIGIBLE_FOR_DEDUP,
     ELIGIBLE_FOR_FF,
     AugSchemeMPL,
+    CoinRecord,
     CoinSpend,
     ConsensusConstants,
     G2Element,
     SpendBundle,
     SpendBundleConditions,
     SpendConditions,
+    check_time_locks,
     get_conditions_from_spendbundle,
     run_block_generator2,
 )
@@ -25,9 +28,9 @@ from chia_rs.sized_ints import uint8, uint32, uint64
 from chiabip158 import PyBIP158
 
 from chia._tests.conftest import ConsensusMode
+from chia._tests.connection_utils import add_dummy_connection, connect_and_get_peer
 from chia._tests.util.misc import Marks, datacases, invariant_check_mempool
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets, setup_simulators_and_wallets
-from chia.consensus.check_time_locks import check_time_locks
 from chia.consensus.condition_costs import ConditionCost
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.eligible_coin_spends import (
@@ -53,6 +56,7 @@ from chia.full_node.mempool_manager import (
 from chia.protocols import wallet_protocol
 from chia.protocols.full_node_protocol import RequestBlock, RespondBlock
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
 from chia.simulator.wallet_tools import WalletTool
@@ -60,13 +64,11 @@ from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import DEFAULT_FLAGS, INFINITE_COST, Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.clvm_cost import CLVMCost
-from chia.types.coin_record import CoinRecord
 from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.mempool_item import BundleCoinSpend, MempoolItem, UnspentLineageInfo
-from chia.types.peer_info import PeerInfo
 from chia.util.casts import int_to_bytes
 from chia.util.default_root import DEFAULT_ROOT_PATH
 from chia.util.errors import Err, ValidationError
@@ -205,9 +207,9 @@ class TestBlockRecord:
 
     header_hash: bytes32
     height: uint32
-    timestamp: Optional[uint64]
+    timestamp: uint64 | None
     prev_transaction_block_height: uint32
-    prev_transaction_block_hash: Optional[bytes32]
+    prev_transaction_block_hash: bytes32 | None
 
     @property
     def is_transaction_block(self) -> bool:
@@ -219,7 +221,7 @@ async def zero_calls_get_coin_records(coin_ids: Collection[bytes32]) -> list[Coi
     return []
 
 
-async def zero_calls_get_unspent_lineage_info_for_puzzle_hash(_puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
+async def zero_calls_get_unspent_lineage_info_for_puzzle_hash(_puzzle_hash: bytes32) -> UnspentLineageInfo | None:
     assert False  # pragma no cover
 
 
@@ -252,37 +254,53 @@ def create_test_block_record(*, height: uint32 = TEST_HEIGHT, timestamp: uint64
     )
 
 
+@asynccontextmanager
 async def instantiate_mempool_manager(
     get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
     *,
     block_height: uint32 = TEST_HEIGHT,
     block_timestamp: uint64 = TEST_TIMESTAMP,
     constants: ConsensusConstants = DEFAULT_CONSTANTS,
-    max_tx_clvm_cost: Optional[uint64] = None,
-) -> MempoolManager:
-    mempool_manager = MempoolManager(
+    max_tx_clvm_cost: uint64 | None = None,
+) -> AsyncGenerator[MempoolManager, None]:
+    async with MempoolManager.managed(
         get_coin_records,
         zero_calls_get_unspent_lineage_info_for_puzzle_hash,
         constants,
         max_tx_clvm_cost=max_tx_clvm_cost,
-    )
-    test_block_record = create_test_block_record(height=block_height, timestamp=block_timestamp)
-    await mempool_manager.new_peak(test_block_record, None)
-    invariant_check_mempool(mempool_manager.mempool)
-    return mempool_manager
+    ) as mempool_manager:
+        test_block_record = create_test_block_record(height=block_height, timestamp=block_timestamp)
+        await mempool_manager.new_peak(test_block_record, None)
+        invariant_check_mempool(mempool_manager.mempool)
+        yield mempool_manager
+
+
+@pytest.fixture(name="zero_mempool_manager", scope="function")
+async def zero_mempool_manager_fixture() -> AsyncIterator[MempoolManager]:
+    async with instantiate_mempool_manager(zero_calls_get_coin_records) as mempool_manager:
+        yield mempool_manager
 
 
+@pytest.fixture(name="test_coins_mempool_manager", scope="function")
+async def test_coins_mempool_manager_fixture() -> AsyncIterator[MempoolManager]:
+    async with instantiate_mempool_manager(get_coin_records_for_test_coins) as mempool_manager:
+        yield mempool_manager
+
+
+@asynccontextmanager
 async def setup_mempool_with_coins(
     *,
     coin_amounts: list[int],
-    max_block_clvm_cost: Optional[int] = None,
-    max_tx_clvm_cost: Optional[uint64] = None,
-    mempool_block_buffer: Optional[int] = None,
-) -> tuple[MempoolManager, list[Coin]]:
+    max_block_clvm_cost: int | None = None,
+    max_tx_clvm_cost: uint64 | None = None,
+    mempool_block_buffer: int | None = None,
+    puzzle_hash: bytes32 = IDENTITY_PUZZLE_HASH,
+    height: uint32 = TEST_HEIGHT,
+) -> AsyncGenerator[tuple[MempoolManager, list[Coin]], None]:
     coins = []
     test_coin_records = {}
     for amount in coin_amounts:
-        coin = Coin(IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, uint64(amount))
+        coin = Coin(bytes32.random(), puzzle_hash, uint64(amount))
         coins.append(coin)
         test_coin_records[coin.name()] = CoinRecord(coin, uint32(0), uint32(0), False, uint64(0))
 
@@ -299,30 +317,31 @@ async def setup_mempool_with_coins(
         constants = constants.replace(MAX_BLOCK_COST_CLVM=uint64(max_block_clvm_cost + TEST_BLOCK_OVERHEAD))
     if mempool_block_buffer is not None:
         constants = constants.replace(MEMPOOL_BLOCK_BUFFER=uint8(mempool_block_buffer))
-    mempool_manager = await instantiate_mempool_manager(
-        get_coin_records, constants=constants, max_tx_clvm_cost=max_tx_clvm_cost
-    )
-    return (mempool_manager, coins)
 
+    async with instantiate_mempool_manager(
+        get_coin_records, block_height=height, constants=constants, max_tx_clvm_cost=max_tx_clvm_cost
+    ) as mempool_manager:
+        yield (mempool_manager, coins)
 
-CreateCoin = tuple[bytes32, int, Optional[bytes]]
+
+CreateCoin = tuple[bytes32, int, bytes | None]
 
 
 def make_test_conds(
     *,
-    birth_height: Optional[int] = None,
-    birth_seconds: Optional[int] = None,
-    height_relative: Optional[int] = None,
+    birth_height: int | None = None,
+    birth_seconds: int | None = None,
+    height_relative: int | None = None,
     height_absolute: int = 0,
-    seconds_relative: Optional[int] = None,
+    seconds_relative: int | None = None,
     seconds_absolute: int = 0,
-    before_height_relative: Optional[int] = None,
-    before_height_absolute: Optional[int] = None,
-    before_seconds_relative: Optional[int] = None,
-    before_seconds_absolute: Optional[int] = None,
+    before_height_relative: int | None = None,
+    before_height_absolute: int | None = None,
+    before_seconds_relative: int | None = None,
+    before_seconds_absolute: int | None = None,
     cost: int = 0,
-    spend_ids: Sequence[tuple[Union[bytes32, Coin], int]] = [(TEST_COIN_ID, 0)],
-    created_coins: Optional[list[list[CreateCoin]]] = None,
+    spend_ids: Sequence[tuple[bytes32 | Coin, int]] = [(TEST_COIN_ID, 0)],
+    created_coins: list[list[CreateCoin]] | None = None,
 ) -> SpendBundleConditions:
     if created_coins is None:
         created_coins = []
@@ -432,21 +451,23 @@ class TestCheckTimeLocks:
     def test_conditions(
         self,
         conds: SpendBundleConditions,
-        expected: Optional[Err],
+        expected: Err | None,
     ) -> None:
-        assert (
-            check_time_locks(
-                dict(self.REMOVALS),
-                conds,
-                self.PREV_BLOCK_HEIGHT,
-                self.PREV_BLOCK_TIMESTAMP,
-            )
-            == expected
+        res: int | None = check_time_locks(
+            dict(self.REMOVALS),
+            conds,
+            self.PREV_BLOCK_HEIGHT,
+            self.PREV_BLOCK_TIMESTAMP,
         )
+        e: Err | None = None
+        if res is not None:
+            # TODO: remove when Rust errors and Python Errors are the same
+            e = Err(res)
+        assert e == expected
 
 
 def expect(
-    *, height: int = 0, seconds: int = 0, before_height: Optional[int] = None, before_seconds: Optional[int] = None
+    *, height: int = 0, seconds: int = 0, before_height: int | None = None, before_seconds: int | None = None
 ) -> TimelockConditions:
     ret = TimelockConditions(uint32(height), uint64(seconds))
     if before_height is not None:
@@ -538,7 +559,7 @@ def spend_bundle_from_conditions(
 
 async def add_spendbundle(
     mempool_manager: MempoolManager, sb: SpendBundle, sb_name: bytes32
-) -> tuple[Optional[uint64], MempoolInclusionStatus, Optional[Err]]:
+) -> tuple[uint64 | None, MempoolInclusionStatus, Err | None]:
     sbc = await mempool_manager.pre_validate_spendbundle(sb, sb_name)
     ret = await mempool_manager.add_spend_bundle(sb, sbc, sb_name, TEST_HEIGHT)
     invariant_check_mempool(mempool_manager.mempool)
@@ -550,7 +571,7 @@ async def generate_and_add_spendbundle(
     conditions: list[list[Any]],
     coin: Coin = TEST_COIN,
     aggsig: G2Element = G2Element(),
-) -> tuple[SpendBundle, bytes32, tuple[Optional[uint64], MempoolInclusionStatus, Optional[Err]]]:
+) -> tuple[SpendBundle, bytes32, tuple[uint64 | None, MempoolInclusionStatus, Err | None]]:
     sb = spend_bundle_from_conditions(conditions, coin, aggsig)
     sb_name = sb.name()
     result = await add_spendbundle(mempool_manager, sb, sb_name)
@@ -607,98 +628,89 @@ def mempool_item_from_spendbundle(spend_bundle: SpendBundle) -> MempoolItem:
 
 
 @pytest.mark.anyio
-async def test_empty_spend_bundle() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
+async def test_empty_spend_bundle(zero_mempool_manager: MempoolManager) -> None:
     sb = SpendBundle([], G2Element())
     with pytest.raises(ValidationError, match="INVALID_SPEND_BUNDLE"):
-        await mempool_manager.pre_validate_spendbundle(sb)
+        await zero_mempool_manager.pre_validate_spendbundle(sb)
 
 
 @pytest.mark.anyio
-async def test_negative_addition_amount() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
+async def test_negative_addition_amount(zero_mempool_manager: MempoolManager) -> None:
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, -1]]
     sb = spend_bundle_from_conditions(conditions)
     with pytest.raises(ValidationError, match="COIN_AMOUNT_NEGATIVE"):
-        await mempool_manager.pre_validate_spendbundle(sb)
+        await zero_mempool_manager.pre_validate_spendbundle(sb)
 
 
 @pytest.mark.anyio
-async def test_valid_addition_amount() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
-    max_amount = mempool_manager.constants.MAX_COIN_AMOUNT
+async def test_valid_addition_amount(zero_mempool_manager: MempoolManager) -> None:
+    max_amount = zero_mempool_manager.constants.MAX_COIN_AMOUNT
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, max_amount]]
     coin = Coin(IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, max_amount)
     sb = spend_bundle_from_conditions(conditions, coin)
     # ensure this does not throw
-    _ = await mempool_manager.pre_validate_spendbundle(sb)
+    _ = await zero_mempool_manager.pre_validate_spendbundle(sb)
 
 
 @pytest.mark.anyio
-async def test_too_big_addition_amount() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
-    max_amount = mempool_manager.constants.MAX_COIN_AMOUNT
+async def test_too_big_addition_amount(zero_mempool_manager: MempoolManager) -> None:
+    max_amount = zero_mempool_manager.constants.MAX_COIN_AMOUNT
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, max_amount + 1]]
     sb = spend_bundle_from_conditions(conditions)
     with pytest.raises(ValidationError, match="COIN_AMOUNT_EXCEEDS_MAXIMUM"):
-        await mempool_manager.pre_validate_spendbundle(sb)
+        await zero_mempool_manager.pre_validate_spendbundle(sb)
 
 
 @pytest.mark.anyio
-async def test_duplicate_output() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
+async def test_duplicate_output(zero_mempool_manager: MempoolManager) -> None:
     conditions = [
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1],
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1],
     ]
     sb = spend_bundle_from_conditions(conditions)
     with pytest.raises(ValidationError, match="DUPLICATE_OUTPUT"):
-        await mempool_manager.pre_validate_spendbundle(sb)
+        await zero_mempool_manager.pre_validate_spendbundle(sb)
 
 
 @pytest.mark.anyio
-async def test_block_cost_exceeds_max() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
+async def test_block_cost_exceeds_max(zero_mempool_manager: MempoolManager) -> None:
     conditions = []
     for i in range(2400):
         conditions.append([ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, i])
     sb = spend_bundle_from_conditions(conditions)
     with pytest.raises(ValidationError, match="BLOCK_COST_EXCEEDS_MAX"):
-        await mempool_manager.pre_validate_spendbundle(sb)
+        await zero_mempool_manager.pre_validate_spendbundle(sb)
 
 
 @pytest.mark.anyio
-async def test_double_spend_prevalidation() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
+async def test_double_spend_prevalidation(zero_mempool_manager: MempoolManager) -> None:
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
     sb = spend_bundle_from_conditions(conditions)
     sb_twice = SpendBundle.aggregate([sb, sb])
     with pytest.raises(ValidationError, match="DOUBLE_SPEND"):
-        await mempool_manager.pre_validate_spendbundle(sb_twice)
+        await zero_mempool_manager.pre_validate_spendbundle(sb_twice)
 
 
 @pytest.mark.anyio
-async def test_minting_coin() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
+async def test_minting_coin(zero_mempool_manager: MempoolManager) -> None:
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT]]
     sb = spend_bundle_from_conditions(conditions)
-    _ = await mempool_manager.pre_validate_spendbundle(sb)
+    _ = await zero_mempool_manager.pre_validate_spendbundle(sb)
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT + 1]]
     sb = spend_bundle_from_conditions(conditions)
     with pytest.raises(ValidationError, match="MINTING_COIN"):
-        await mempool_manager.pre_validate_spendbundle(sb)
+        await zero_mempool_manager.pre_validate_spendbundle(sb)
 
 
 @pytest.mark.anyio
-async def test_reserve_fee_condition() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
+async def test_reserve_fee_condition(zero_mempool_manager: MempoolManager) -> None:
     conditions = [[ConditionOpcode.RESERVE_FEE, TEST_COIN_AMOUNT]]
     sb = spend_bundle_from_conditions(conditions)
-    _ = await mempool_manager.pre_validate_spendbundle(sb)
+    _ = await zero_mempool_manager.pre_validate_spendbundle(sb)
     conditions = [[ConditionOpcode.RESERVE_FEE, TEST_COIN_AMOUNT + 1]]
     sb = spend_bundle_from_conditions(conditions)
     with pytest.raises(ValidationError, match="RESERVE_FEE_CONDITION_FAILED"):
-        await mempool_manager.pre_validate_spendbundle(sb)
+        await zero_mempool_manager.pre_validate_spendbundle(sb)
 
 
 @pytest.mark.anyio
@@ -706,15 +718,15 @@ async def test_unknown_unspent() -> None:
     async def get_coin_records(_: Collection[bytes32]) -> list[CoinRecord]:
         return []
 
-    mempool_manager = await instantiate_mempool_manager(get_coin_records)
-    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
-    _, _, result = await generate_and_add_spendbundle(mempool_manager, conditions)
-    assert result == (None, MempoolInclusionStatus.FAILED, Err.UNKNOWN_UNSPENT)
+    async with instantiate_mempool_manager(get_coin_records) as mempool_manager:
+        conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
+        _, _, result = await generate_and_add_spendbundle(mempool_manager, conditions)
+        assert result == (None, MempoolInclusionStatus.FAILED, Err.UNKNOWN_UNSPENT)
 
 
 @pytest.mark.anyio
-async def test_same_sb_twice_with_eligible_coin() -> None:
-    mempool_manager = await instantiate_mempool_manager(get_coin_records_for_test_coins)
+async def test_same_sb_twice_with_eligible_coin(test_coins_mempool_manager: MempoolManager) -> None:
+    mempool_manager = test_coins_mempool_manager
     sb1_conditions = [
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1],
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 2],
@@ -740,8 +752,10 @@ async def test_same_sb_twice_with_eligible_coin() -> None:
 
 
 @pytest.mark.anyio
-async def test_sb_twice_with_eligible_coin_and_different_spends_order() -> None:
-    mempool_manager = await instantiate_mempool_manager(get_coin_records_for_test_coins)
+async def test_sb_twice_with_eligible_coin_and_different_spends_order(
+    test_coins_mempool_manager: MempoolManager,
+) -> None:
+    mempool_manager = test_coins_mempool_manager
     sb1_conditions = [
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1],
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 2],
@@ -838,29 +852,28 @@ async def test_ephemeral_timelock(
     opcode: ConditionOpcode,
     lock_value: int,
     expected_status: MempoolInclusionStatus,
-    expected_error: Optional[Err],
+    expected_error: Err | None,
 ) -> None:
-    mempool_manager = await instantiate_mempool_manager(
+    async with instantiate_mempool_manager(
         get_coin_records=get_coin_records_for_test_coins,
         block_height=uint32(5),
         block_timestamp=uint64(10050),
         constants=DEFAULT_CONSTANTS,
-    )
-
-    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
-    created_coin = Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(1))
-    sb1 = spend_bundle_from_conditions(conditions)
-    sb2 = spend_bundle_from_conditions([[opcode, lock_value]], created_coin)
-    # sb spends TEST_COIN and creates created_coin which gets spent too
-    sb = SpendBundle.aggregate([sb1, sb2])
-    # We shouldn't have a record of this ephemeral coin
-    assert await get_coin_records_for_test_coins([created_coin.name()]) == []
-    try:
-        _, status, error = await add_spendbundle(mempool_manager, sb, sb.name())
-        assert (status, error) == (expected_status, expected_error)
-    except ValidationError as e:
-        assert expected_status == mis.FAILED
-        assert expected_error == e.code
+    ) as mempool_manager:
+        conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
+        created_coin = Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(1))
+        sb1 = spend_bundle_from_conditions(conditions)
+        sb2 = spend_bundle_from_conditions([[opcode, lock_value]], created_coin)
+        # sb spends TEST_COIN and creates created_coin which gets spent too
+        sb = SpendBundle.aggregate([sb1, sb2])
+        # We shouldn't have a record of this ephemeral coin
+        assert await get_coin_records_for_test_coins([created_coin.name()]) == []
+        try:
+            _, status, error = await add_spendbundle(mempool_manager, sb, sb.name())
+            assert (status, error) == (expected_status, expected_error)
+        except ValidationError as e:
+            assert expected_status == mis.FAILED
+            assert expected_error == e.code
 
 
 def test_optional_min() -> None:
@@ -877,7 +890,7 @@ def test_optional_max() -> None:
     assert optional_max(uint32(123), uint32(234)) == uint32(234)
 
 
-def mk_coin_spend(coin: Coin, solution: Optional[str] = None) -> CoinSpend:
+def mk_coin_spend(coin: Coin, solution: str | None = None) -> CoinSpend:
     return make_spend(
         coin,
         SerializedProgram.to(None),
@@ -904,10 +917,10 @@ def mk_item(
     *,
     cost: int = 1,
     fee: int = 0,
-    assert_height: Optional[int] = None,
-    assert_before_height: Optional[int] = None,
-    assert_before_seconds: Optional[int] = None,
-    solution: Optional[str] = None,
+    assert_height: int | None = None,
+    assert_before_height: int | None = None,
+    assert_before_seconds: int | None = None,
+    solution: str | None = None,
     flags: list[int] = [],
 ) -> MempoolItem:
     # we don't actually care about the puzzle and solutions for the purpose of
@@ -1126,8 +1139,8 @@ def test_can_replace(existing_items: list[MempoolItem], new_item: MempoolItem, e
 
 
 @pytest.mark.anyio
-async def test_get_items_not_in_filter() -> None:
-    mempool_manager = await instantiate_mempool_manager(get_coin_records_for_test_coins)
+async def test_get_items_not_in_filter(test_coins_mempool_manager: MempoolManager) -> None:
+    mempool_manager = test_coins_mempool_manager
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
     sb1, sb1_name, _ = await generate_and_add_spendbundle(mempool_manager, conditions)
     conditions2 = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 2]]
@@ -1138,7 +1151,7 @@ async def test_get_items_not_in_filter() -> None:
     # Don't filter anything
     empty_filter = PyBIP158([])
     result = mempool_manager.get_items_not_in_filter(empty_filter)
-    assert result == [sb3, sb2, sb1]
+    assert [item.to_spend_bundle() for item in result] == [sb3, sb2, sb1]
 
     # Filter everything
     full_filter = PyBIP158([bytearray(sb1_name), bytearray(sb2_name), bytearray(sb3_name)])
@@ -1158,16 +1171,16 @@ async def test_get_items_not_in_filter() -> None:
 
     # With a limit of one, sb2 has the highest FPC
     result = mempool_manager.get_items_not_in_filter(sb3_filter, limit=1)
-    assert result == [sb2]
+    assert [item.to_spend_bundle() for item in result] == [sb2]
 
     # With a higher limit, all bundles aside from sb3 get included
     result = mempool_manager.get_items_not_in_filter(sb3_filter, limit=5)
-    assert result == [sb2, sb1]
+    assert [item.to_spend_bundle() for item in result] == [sb2, sb1]
 
     # Filter two of the spend bundles
     sb2_and_3_filter = PyBIP158([bytearray(sb2_name), bytearray(sb3_name)])
     result = mempool_manager.get_items_not_in_filter(sb2_and_3_filter)
-    assert result == [sb1]
+    assert [item.to_spend_bundle() for item in result] == [sb1]
 
 
 @pytest.mark.anyio
@@ -1182,29 +1195,29 @@ async def test_total_mempool_fees() -> None:
                 ret.append(r)
         return ret
 
-    mempool_manager = await instantiate_mempool_manager(get_coin_records)
-    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
+    async with instantiate_mempool_manager(get_coin_records) as mempool_manager:
+        conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
+
+        # the limit of total fees in the mempool is 2^63
+        # the limit per mempool item is 2^50, that lets us add 8192 items with the
+        # maximum amount of fee before reaching the total mempool limit
+        amount = uint64(2**50)
+        total_fee = 0
+        for i in range(8192):
+            coin = Coin(IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, amount)
+            coin_records[coin.name()] = CoinRecord(coin, uint32(0), uint32(0), False, uint64(0))
+            amount = uint64(amount - 1)
+            # the fee is 1 less than the amount because we create a coin of 1 mojo
+            total_fee += amount
+            _, _, result = await generate_and_add_spendbundle(mempool_manager, conditions, coin)
+            assert result[1] == MempoolInclusionStatus.SUCCESS
+            assert mempool_manager.mempool.total_mempool_fees() == total_fee
 
-    # the limit of total fees in the mempool is 2^63
-    # the limit per mempool item is 2^50, that lets us add 8192 items with the
-    # maximum amount of fee before reaching the total mempool limit
-    amount = uint64(2**50)
-    total_fee = 0
-    for i in range(8192):
         coin = Coin(IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, amount)
         coin_records[coin.name()] = CoinRecord(coin, uint32(0), uint32(0), False, uint64(0))
-        amount = uint64(amount - 1)
-        # the fee is 1 less than the amount because we create a coin of 1 mojo
-        total_fee += amount
         _, _, result = await generate_and_add_spendbundle(mempool_manager, conditions, coin)
-        assert result[1] == MempoolInclusionStatus.SUCCESS
-        assert mempool_manager.mempool.total_mempool_fees() == total_fee
-
-    coin = Coin(IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, amount)
-    coin_records[coin.name()] = CoinRecord(coin, uint32(0), uint32(0), False, uint64(0))
-    _, _, result = await generate_and_add_spendbundle(mempool_manager, conditions, coin)
-    assert result[1] == MempoolInclusionStatus.FAILED
-    assert result[2] == Err.INVALID_BLOCK_FEE_AMOUNT
+        assert result[1] == MempoolInclusionStatus.FAILED
+        assert result[2] == Err.INVALID_BLOCK_FEE_AMOUNT
 
 
 @pytest.mark.parametrize("reverse_tx_order", [True, False])
@@ -1230,17 +1243,17 @@ async def test_create_bundle_from_mempool(reverse_tx_order: bool) -> None:
             result = await add_spendbundle(mempool_manager, sb, sb.name())
             assert result[1] == MempoolInclusionStatus.SUCCESS
 
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(2000000000, 2000002200)))
-    high_rate_spends = await make_coin_spends(coins[0:2200])
-    low_rate_spends = await make_coin_spends(coins[2200:2400], high_fees=False)
-    spends = low_rate_spends + high_rate_spends if reverse_tx_order else high_rate_spends + low_rate_spends
-    await send_spends_to_mempool(spends)
-    assert mempool_manager.peak is not None
-    result = mempool_manager.create_bundle_from_mempool(mempool_manager.peak.header_hash)
-    assert result is not None
-    # Make sure we filled the block with only high rate spends
-    assert len([s for s in high_rate_spends if s in result[0].coin_spends]) == len(result[0].coin_spends)
-    assert len([s for s in low_rate_spends if s in result[0].coin_spends]) == 0
+    async with setup_mempool_with_coins(coin_amounts=list(range(2000000000, 2000002200))) as (mempool_manager, coins):
+        high_rate_spends = await make_coin_spends(coins[0:2200])
+        low_rate_spends = await make_coin_spends(coins[2200:2400], high_fees=False)
+        spends = low_rate_spends + high_rate_spends if reverse_tx_order else high_rate_spends + low_rate_spends
+        await send_spends_to_mempool(spends)
+        assert mempool_manager.peak is not None
+        result = mempool_manager.create_bundle_from_mempool(mempool_manager.peak.header_hash)
+        assert result is not None
+        # Make sure we filled the block with only high rate spends
+        assert len([s for s in high_rate_spends if s in result[0].coin_spends]) == len(result[0].coin_spends)
+        assert len([s for s in low_rate_spends if s in result[0].coin_spends]) == 0
 
 
 @pytest.mark.parametrize("num_skipped_items", [PRIORITY_TX_THRESHOLD, MAX_SKIPPED_ITEMS])
@@ -1257,105 +1270,105 @@ async def test_create_bundle_from_mempool_on_max_cost(num_skipped_items: int, ca
 
     MAX_BLOCK_CLVM_COST = 550_000_000
 
-    mempool_manager, coins = await setup_mempool_with_coins(
+    async with setup_mempool_with_coins(
         coin_amounts=list(range(1_000_000_000, 1_000_000_030)),
         max_block_clvm_cost=MAX_BLOCK_CLVM_COST,
         max_tx_clvm_cost=uint64(MAX_BLOCK_CLVM_COST),
         mempool_block_buffer=20,
-    )
-
-    async def make_and_send_big_cost_sb(coin: Coin) -> None:
-        """
-        Creates a spend bundle with a big enough cost that gets it close to the
-        maximum block clvm cost limit.
-        """
-        conditions = []
-        sk = AugSchemeMPL.key_gen(b"7" * 32)
+    ) as (mempool_manager, coins):
+
+        async def make_and_send_big_cost_sb(coin: Coin) -> None:
+            """
+            Creates a spend bundle with a big enough cost that gets it close to the
+            maximum block clvm cost limit.
+            """
+            conditions = []
+            sk = AugSchemeMPL.key_gen(b"7" * 32)
+            g1 = sk.get_g1()
+            sig = AugSchemeMPL.sign(sk, IDENTITY_PUZZLE_HASH, g1)
+            aggsig = G2Element()
+            # Let's get as close to `MAX_BLOCK_CLVM_COST` (550_000_000) as possible.
+            # We start by accounting for execution cost
+            spend_bundle_cost = 44
+            # And then the created coin
+            conditions.append([ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount - 10_000_000])
+            TEST_CREATE_COIN_SPEND_BYTESIZE = 93
+            TEST_CREATE_COIN_CONDITION_COST = (
+                ConditionCost.CREATE_COIN.value + TEST_CREATE_COIN_SPEND_BYTESIZE * DEFAULT_CONSTANTS.COST_PER_BYTE
+            )
+            spend_bundle_cost += TEST_CREATE_COIN_CONDITION_COST
+            # We're using agg sig conditions to increase the spend bundle's cost
+            # and reach our target cost.
+            TEST_AGG_SIG_SPEND_BYTESIZE = 88
+            TEST_AGGSIG_CONDITION_COST = (
+                ConditionCost.AGG_SIG.value + TEST_AGG_SIG_SPEND_BYTESIZE * DEFAULT_CONSTANTS.COST_PER_BYTE
+            )
+            while spend_bundle_cost + TEST_AGGSIG_CONDITION_COST < MAX_BLOCK_CLVM_COST:
+                conditions.append([ConditionOpcode.AGG_SIG_UNSAFE, g1, IDENTITY_PUZZLE_HASH])
+                aggsig += sig
+                spend_bundle_cost += TEST_AGGSIG_CONDITION_COST
+            # We now have a spend bundle with a big enough cost that gets it close to the limit
+            _, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, coin, aggsig)
+            cost, status, _ = res
+            assert status == MempoolInclusionStatus.SUCCESS
+            assert cost == spend_bundle_cost
+
+        # Create the spend bundles with a big enough cost that they get close to the limit
+        for i in range(num_skipped_items):
+            await make_and_send_big_cost_sb(coins[i])
+
+        # Create a spend bundle with a relatively smaller cost.
+        # Combined with a big cost spend bundle, we'd exceed the maximum block clvm cost
+        sb2_coin = coins[num_skipped_items]
+        conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, sb2_coin.amount - 200_000]]
+        sb2, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, sb2_coin)
+        assert res[1] == MempoolInclusionStatus.SUCCESS
+        sb2_addition = Coin(sb2_coin.name(), IDENTITY_PUZZLE_HASH, uint64(sb2_coin.amount - 200_000))
+        # Create 4 extra spend bundles with smaller FPC and smaller costs
+        extra_sbs = []
+        extra_additions = []
+        sk = AugSchemeMPL.key_gen(b"8" * 32)
         g1 = sk.get_g1()
-        sig = AugSchemeMPL.sign(sk, IDENTITY_PUZZLE_HASH, g1)
-        aggsig = G2Element()
-        # Let's get as close to `MAX_BLOCK_CLVM_COST` (550_000_000) as possible.
-        # We start by accounting for execution cost
-        spend_bundle_cost = 44
-        # And then the created coin
-        conditions.append([ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount - 10_000_000])
-        TEST_CREATE_COIN_SPEND_BYTESIZE = 93
-        TEST_CREATE_COIN_CONDITION_COST = (
-            ConditionCost.CREATE_COIN.value + TEST_CREATE_COIN_SPEND_BYTESIZE * DEFAULT_CONSTANTS.COST_PER_BYTE
-        )
-        spend_bundle_cost += TEST_CREATE_COIN_CONDITION_COST
-        # We're using agg sig conditions to increase the spend bundle's cost
-        # and reach our target cost.
-        TEST_AGG_SIG_SPEND_BYTESIZE = 88
-        TEST_AGGSIG_CONDITION_COST = (
-            ConditionCost.AGG_SIG.value + TEST_AGG_SIG_SPEND_BYTESIZE * DEFAULT_CONSTANTS.COST_PER_BYTE
+        sig = AugSchemeMPL.sign(sk, b"foobar", g1)
+        for i in range(num_skipped_items + 1, num_skipped_items + 5):
+            conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coins[i].amount]]
+            # Make the first of these without eligible coins
+            if i == num_skipped_items + 1:
+                conditions.append([ConditionOpcode.AGG_SIG_UNSAFE, bytes(g1), b"foobar"])
+                aggsig = sig
+            else:
+                aggsig = G2Element()
+            sb, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, coins[i], aggsig)
+            extra_sbs.append(sb)
+            coin = Coin(coins[i].name(), IDENTITY_PUZZLE_HASH, uint64(coins[i].amount))
+            extra_additions.append(coin)
+            assert res[1] == MempoolInclusionStatus.SUCCESS
+
+        assert mempool_manager.peak is not None
+        caplog.set_level(logging.DEBUG)
+        result = mempool_manager.create_bundle_from_mempool(mempool_manager.peak.header_hash)
+        assert result is not None
+        agg, additions = result
+        skipped_due_to_eligible_coins = sum(
+            1 for line in caplog.text.split("\n") if "Skipping transaction with dedup or FF spends" in line
         )
-        while spend_bundle_cost + TEST_AGGSIG_CONDITION_COST < MAX_BLOCK_CLVM_COST:
-            conditions.append([ConditionOpcode.AGG_SIG_UNSAFE, g1, IDENTITY_PUZZLE_HASH])
-            aggsig += sig
-            spend_bundle_cost += TEST_AGGSIG_CONDITION_COST
-        # We now have a spend bundle with a big enough cost that gets it close to the limit
-        _, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, coin, aggsig)
-        cost, status, _ = res
-        assert status == MempoolInclusionStatus.SUCCESS
-        assert cost == spend_bundle_cost
-
-    # Create the spend bundles with a big enough cost that they get close to the limit
-    for i in range(num_skipped_items):
-        await make_and_send_big_cost_sb(coins[i])
-
-    # Create a spend bundle with a relatively smaller cost.
-    # Combined with a big cost spend bundle, we'd exceed the maximum block clvm cost
-    sb2_coin = coins[num_skipped_items]
-    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, sb2_coin.amount - 200_000]]
-    sb2, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, sb2_coin)
-    assert res[1] == MempoolInclusionStatus.SUCCESS
-    sb2_addition = Coin(sb2_coin.name(), IDENTITY_PUZZLE_HASH, uint64(sb2_coin.amount - 200_000))
-    # Create 4 extra spend bundles with smaller FPC and smaller costs
-    extra_sbs = []
-    extra_additions = []
-    sk = AugSchemeMPL.key_gen(b"8" * 32)
-    g1 = sk.get_g1()
-    sig = AugSchemeMPL.sign(sk, b"foobar", g1)
-    for i in range(num_skipped_items + 1, num_skipped_items + 5):
-        conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coins[i].amount]]
-        # Make the first of these without eligible coins
-        if i == num_skipped_items + 1:
-            conditions.append([ConditionOpcode.AGG_SIG_UNSAFE, bytes(g1), b"foobar"])
-            aggsig = sig
+        if num_skipped_items == PRIORITY_TX_THRESHOLD:
+            # We skipped enough big cost items to reach `PRIORITY_TX_THRESHOLD`,
+            # so the first from the extra 4 (the one without eligible coins) went in,
+            # and the other 3 were skipped (they have eligible coins)
+            assert skipped_due_to_eligible_coins == 3
+            assert agg == SpendBundle.aggregate([sb2, extra_sbs[0]])
+            assert additions == [sb2_addition, extra_additions[0]]
+            assert agg.removals() == [sb2_coin, coins[num_skipped_items + 1]]
+        elif num_skipped_items == MAX_SKIPPED_ITEMS:
+            # We skipped enough big cost items to trigger `MAX_SKIPPED_ITEMS` so
+            # we didn't process any of the extra items
+            assert skipped_due_to_eligible_coins == 0
+            assert agg == SpendBundle.aggregate([sb2])
+            assert additions == [sb2_addition]
+            assert agg.removals() == [sb2_coin]
         else:
-            aggsig = G2Element()
-        sb, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, coins[i], aggsig)
-        extra_sbs.append(sb)
-        coin = Coin(coins[i].name(), IDENTITY_PUZZLE_HASH, uint64(coins[i].amount))
-        extra_additions.append(coin)
-        assert res[1] == MempoolInclusionStatus.SUCCESS
-
-    assert mempool_manager.peak is not None
-    caplog.set_level(logging.DEBUG)
-    result = mempool_manager.create_bundle_from_mempool(mempool_manager.peak.header_hash)
-    assert result is not None
-    agg, additions = result
-    skipped_due_to_eligible_coins = sum(
-        1 for line in caplog.text.split("\n") if "Skipping transaction with dedup or FF spends" in line
-    )
-    if num_skipped_items == PRIORITY_TX_THRESHOLD:
-        # We skipped enough big cost items to reach `PRIORITY_TX_THRESHOLD`,
-        # so the first from the extra 4 (the one without eligible coins) went in,
-        # and the other 3 were skipped (they have eligible coins)
-        assert skipped_due_to_eligible_coins == 3
-        assert agg == SpendBundle.aggregate([sb2, extra_sbs[0]])
-        assert additions == [sb2_addition, extra_additions[0]]
-        assert agg.removals() == [sb2_coin, coins[num_skipped_items + 1]]
-    elif num_skipped_items == MAX_SKIPPED_ITEMS:
-        # We skipped enough big cost items to trigger `MAX_SKIPPED_ITEMS` so
-        # we didn't process any of the extra items
-        assert skipped_due_to_eligible_coins == 0
-        assert agg == SpendBundle.aggregate([sb2])
-        assert additions == [sb2_addition]
-        assert agg.removals() == [sb2_coin]
-    else:
-        raise ValueError("num_skipped_items must be PRIORITY_TX_THRESHOLD or MAX_SKIPPED_ITEMS")  # pragma: no cover
+            raise ValueError("num_skipped_items must be PRIORITY_TX_THRESHOLD or MAX_SKIPPED_ITEMS")  # pragma: no cover
 
 
 @pytest.mark.parametrize(
@@ -1377,7 +1390,7 @@ async def test_create_bundle_from_mempool_on_max_cost(num_skipped_items: int, ca
 )
 @pytest.mark.anyio
 async def test_assert_before_expiration(
-    opcode: ConditionOpcode, arg: int, expect_eviction: bool, expect_limit: Optional[int]
+    opcode: ConditionOpcode, arg: int, expect_eviction: bool, expect_limit: int | None
 ) -> None:
     async def get_coin_records(coin_ids: Collection[bytes32]) -> list[CoinRecord]:
         all_coins = {TEST_COIN.name(): CoinRecord(TEST_COIN, uint32(5), uint32(0), False, uint64(9900))}
@@ -1388,41 +1401,40 @@ async def test_assert_before_expiration(
                 ret.append(r)
         return ret
 
-    mempool_manager = await instantiate_mempool_manager(
+    async with instantiate_mempool_manager(
         get_coin_records,
         block_height=uint32(10),
         block_timestamp=uint64(10000),
         constants=DEFAULT_CONSTANTS,
-    )
-
-    bundle = spend_bundle_from_conditions(
-        [
-            [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1],
-            [opcode, arg],
-        ],
-        coin=TEST_COIN,
-    )
-    bundle_name = bundle.name()
-    assert (await add_spendbundle(mempool_manager, bundle, bundle_name))[1] == mis.SUCCESS
-    # make sure the spend was added correctly
-    assert mempool_manager.get_spendbundle(bundle_name) == bundle
-
-    block_record = create_test_block_record(height=uint32(11), timestamp=uint64(10019))
-    await mempool_manager.new_peak(block_record, None)
-    invariant_check_mempool(mempool_manager.mempool)
-
-    still_in_pool = mempool_manager.get_spendbundle(bundle_name) == bundle
-    assert still_in_pool != expect_eviction
-    if still_in_pool:
-        assert expect_limit is not None
-        item = mempool_manager.get_mempool_item(bundle_name)
-        assert item is not None
-        if opcode in {co.ASSERT_BEFORE_SECONDS_ABSOLUTE, co.ASSERT_BEFORE_SECONDS_RELATIVE}:
-            assert item.assert_before_seconds == expect_limit
-        elif opcode in {co.ASSERT_BEFORE_HEIGHT_ABSOLUTE, co.ASSERT_BEFORE_HEIGHT_RELATIVE}:
-            assert item.assert_before_height == expect_limit
-        else:
-            assert False
+    ) as mempool_manager:
+        bundle = spend_bundle_from_conditions(
+            [
+                [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1],
+                [opcode, arg],
+            ],
+            coin=TEST_COIN,
+        )
+        bundle_name = bundle.name()
+        assert (await add_spendbundle(mempool_manager, bundle, bundle_name))[1] == mis.SUCCESS
+        # make sure the spend was added correctly
+        assert mempool_manager.get_spendbundle(bundle_name) == bundle
+
+        block_record = create_test_block_record(height=uint32(11), timestamp=uint64(10019))
+        await mempool_manager.new_peak(block_record, None)
+        invariant_check_mempool(mempool_manager.mempool)
+
+        still_in_pool = mempool_manager.get_spendbundle(bundle_name) == bundle
+        assert still_in_pool != expect_eviction
+        if still_in_pool:
+            assert expect_limit is not None
+            item = mempool_manager.get_mempool_item(bundle_name)
+            assert item is not None
+            if opcode in {co.ASSERT_BEFORE_SECONDS_ABSOLUTE, co.ASSERT_BEFORE_SECONDS_RELATIVE}:
+                assert item.assert_before_seconds == expect_limit
+            elif opcode in {co.ASSERT_BEFORE_HEIGHT_ABSOLUTE, co.ASSERT_BEFORE_HEIGHT_RELATIVE}:
+                assert item.assert_before_height == expect_limit
+            else:
+                assert False
 
 
 def make_test_spendbundle(coin: Coin, *, fee: int = 0, eligible_spend: bool = False) -> SpendBundle:
@@ -1439,7 +1451,7 @@ def make_test_spendbundle(coin: Coin, *, fee: int = 0, eligible_spend: bool = Fa
 async def send_spendbundle(
     mempool_manager: MempoolManager,
     sb: SpendBundle,
-    expected_result: tuple[MempoolInclusionStatus, Optional[Err]] = (MempoolInclusionStatus.SUCCESS, None),
+    expected_result: tuple[MempoolInclusionStatus, Err | None] = (MempoolInclusionStatus.SUCCESS, None),
 ) -> None:
     result = await add_spendbundle(mempool_manager, sb, sb.name())
     assert (result[1], result[2]) == expected_result
@@ -1450,7 +1462,7 @@ async def make_and_send_spendbundle(
     coin: Coin,
     *,
     fee: int = 0,
-    expected_result: tuple[MempoolInclusionStatus, Optional[Err]] = (MempoolInclusionStatus.SUCCESS, None),
+    expected_result: tuple[MempoolInclusionStatus, Err | None] = (MempoolInclusionStatus.SUCCESS, None),
 ) -> SpendBundle:
     sb = make_test_spendbundle(coin, fee=fee)
     await send_spendbundle(mempool_manager, sb, expected_result)
@@ -1467,125 +1479,125 @@ def assert_sb_not_in_pool(mempool_manager: MempoolManager, sb: SpendBundle) -> N
 
 @pytest.mark.anyio
 async def test_insufficient_fee_increase() -> None:
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010)))
-    sb1_1 = await make_and_send_spendbundle(mempool_manager, coins[0])
-    sb1_2 = await make_and_send_spendbundle(
-        mempool_manager, coins[0], fee=1, expected_result=(MempoolInclusionStatus.PENDING, Err.MEMPOOL_CONFLICT)
-    )
-    # The old spendbundle must stay
-    assert_sb_in_pool(mempool_manager, sb1_1)
-    assert_sb_not_in_pool(mempool_manager, sb1_2)
+    async with setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010))) as (mempool_manager, coins):
+        sb1_1 = await make_and_send_spendbundle(mempool_manager, coins[0])
+        sb1_2 = await make_and_send_spendbundle(
+            mempool_manager, coins[0], fee=1, expected_result=(MempoolInclusionStatus.PENDING, Err.MEMPOOL_CONFLICT)
+        )
+        # The old spendbundle must stay
+        assert_sb_in_pool(mempool_manager, sb1_1)
+        assert_sb_not_in_pool(mempool_manager, sb1_2)
 
 
 @pytest.mark.anyio
 async def test_sufficient_fee_increase() -> None:
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010)))
-    sb1_1 = await make_and_send_spendbundle(mempool_manager, coins[0])
-    sb1_2 = await make_and_send_spendbundle(mempool_manager, coins[0], fee=MEMPOOL_MIN_FEE_INCREASE)
-    # sb1_1 gets replaced with sb1_2
-    assert_sb_not_in_pool(mempool_manager, sb1_1)
-    assert_sb_in_pool(mempool_manager, sb1_2)
+    async with setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010))) as (mempool_manager, coins):
+        sb1_1 = await make_and_send_spendbundle(mempool_manager, coins[0])
+        sb1_2 = await make_and_send_spendbundle(mempool_manager, coins[0], fee=MEMPOOL_MIN_FEE_INCREASE)
+        # sb1_1 gets replaced with sb1_2
+        assert_sb_not_in_pool(mempool_manager, sb1_1)
+        assert_sb_in_pool(mempool_manager, sb1_2)
 
 
 @pytest.mark.anyio
 async def test_superset() -> None:
     # Aggregated spendbundle sb12 replaces sb1 since it spends a superset
     # of coins spent in sb1
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010)))
-    sb1 = await make_and_send_spendbundle(mempool_manager, coins[0])
-    sb2 = make_test_spendbundle(coins[1], fee=MEMPOOL_MIN_FEE_INCREASE)
-    sb12 = SpendBundle.aggregate([sb2, sb1])
-    await send_spendbundle(mempool_manager, sb12)
-    assert_sb_in_pool(mempool_manager, sb12)
-    assert_sb_not_in_pool(mempool_manager, sb1)
+    async with setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010))) as (mempool_manager, coins):
+        sb1 = await make_and_send_spendbundle(mempool_manager, coins[0])
+        sb2 = make_test_spendbundle(coins[1], fee=MEMPOOL_MIN_FEE_INCREASE)
+        sb12 = SpendBundle.aggregate([sb2, sb1])
+        await send_spendbundle(mempool_manager, sb12)
+        assert_sb_in_pool(mempool_manager, sb12)
+        assert_sb_not_in_pool(mempool_manager, sb1)
 
 
 @pytest.mark.anyio
 async def test_superset_violation() -> None:
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010)))
-    sb1 = make_test_spendbundle(coins[0])
-    sb2 = make_test_spendbundle(coins[1])
-    sb12 = SpendBundle.aggregate([sb1, sb2])
-    await send_spendbundle(mempool_manager, sb12)
-    assert_sb_in_pool(mempool_manager, sb12)
-    # sb23 must not replace existing sb12 as the former does not spend all
-    # coins that are spent in the latter (specifically, the first coin)
-    sb3 = make_test_spendbundle(coins[2], fee=MEMPOOL_MIN_FEE_INCREASE)
-    sb23 = SpendBundle.aggregate([sb2, sb3])
-    await send_spendbundle(
-        mempool_manager, sb23, expected_result=(MempoolInclusionStatus.PENDING, Err.MEMPOOL_CONFLICT)
-    )
-    assert_sb_in_pool(mempool_manager, sb12)
-    assert_sb_not_in_pool(mempool_manager, sb23)
+    async with setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010))) as (mempool_manager, coins):
+        sb1 = make_test_spendbundle(coins[0])
+        sb2 = make_test_spendbundle(coins[1])
+        sb12 = SpendBundle.aggregate([sb1, sb2])
+        await send_spendbundle(mempool_manager, sb12)
+        assert_sb_in_pool(mempool_manager, sb12)
+        # sb23 must not replace existing sb12 as the former does not spend all
+        # coins that are spent in the latter (specifically, the first coin)
+        sb3 = make_test_spendbundle(coins[2], fee=MEMPOOL_MIN_FEE_INCREASE)
+        sb23 = SpendBundle.aggregate([sb2, sb3])
+        await send_spendbundle(
+            mempool_manager, sb23, expected_result=(MempoolInclusionStatus.PENDING, Err.MEMPOOL_CONFLICT)
+        )
+        assert_sb_in_pool(mempool_manager, sb12)
+        assert_sb_not_in_pool(mempool_manager, sb23)
 
 
 @pytest.mark.anyio
 async def test_total_fpc_decrease() -> None:
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010)))
-    sb1 = make_test_spendbundle(coins[0])
-    sb2 = make_test_spendbundle(coins[1], fee=MEMPOOL_MIN_FEE_INCREASE * 2)
-    sb12 = SpendBundle.aggregate([sb1, sb2])
-    await send_spendbundle(mempool_manager, sb12)
-    sb3 = await make_and_send_spendbundle(mempool_manager, coins[2], fee=MEMPOOL_MIN_FEE_INCREASE * 2)
-    assert_sb_in_pool(mempool_manager, sb12)
-    assert_sb_in_pool(mempool_manager, sb3)
-    # sb1234 should not be in pool as it decreases total fees per cost
-    sb4 = make_test_spendbundle(coins[3], fee=MEMPOOL_MIN_FEE_INCREASE)
-    sb1234 = SpendBundle.aggregate([sb12, sb3, sb4])
-    await send_spendbundle(
-        mempool_manager, sb1234, expected_result=(MempoolInclusionStatus.PENDING, Err.MEMPOOL_CONFLICT)
-    )
-    assert_sb_not_in_pool(mempool_manager, sb1234)
+    async with setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010))) as (mempool_manager, coins):
+        sb1 = make_test_spendbundle(coins[0])
+        sb2 = make_test_spendbundle(coins[1], fee=MEMPOOL_MIN_FEE_INCREASE * 2)
+        sb12 = SpendBundle.aggregate([sb1, sb2])
+        await send_spendbundle(mempool_manager, sb12)
+        sb3 = await make_and_send_spendbundle(mempool_manager, coins[2], fee=MEMPOOL_MIN_FEE_INCREASE * 2)
+        assert_sb_in_pool(mempool_manager, sb12)
+        assert_sb_in_pool(mempool_manager, sb3)
+        # sb1234 should not be in pool as it decreases total fees per cost
+        sb4 = make_test_spendbundle(coins[3], fee=MEMPOOL_MIN_FEE_INCREASE)
+        sb1234 = SpendBundle.aggregate([sb12, sb3, sb4])
+        await send_spendbundle(
+            mempool_manager, sb1234, expected_result=(MempoolInclusionStatus.PENDING, Err.MEMPOOL_CONFLICT)
+        )
+        assert_sb_not_in_pool(mempool_manager, sb1234)
 
 
 @pytest.mark.anyio
 async def test_sufficient_total_fpc_increase() -> None:
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010)))
-    sb1 = make_test_spendbundle(coins[0])
-    sb2 = make_test_spendbundle(coins[1], fee=MEMPOOL_MIN_FEE_INCREASE * 2)
-    sb12 = SpendBundle.aggregate([sb1, sb2])
-    await send_spendbundle(mempool_manager, sb12)
-    sb3 = await make_and_send_spendbundle(mempool_manager, coins[2], fee=MEMPOOL_MIN_FEE_INCREASE * 2)
-    assert_sb_in_pool(mempool_manager, sb12)
-    assert_sb_in_pool(mempool_manager, sb3)
-    # sb1234 has a higher fee per cost than its conflicts and should get
-    # into the mempool
-    sb4 = make_test_spendbundle(coins[3], fee=MEMPOOL_MIN_FEE_INCREASE * 3)
-    sb1234 = SpendBundle.aggregate([sb12, sb3, sb4])
-    await send_spendbundle(mempool_manager, sb1234)
-    assert_sb_in_pool(mempool_manager, sb1234)
-    assert_sb_not_in_pool(mempool_manager, sb12)
-    assert_sb_not_in_pool(mempool_manager, sb3)
+    async with setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010))) as (mempool_manager, coins):
+        sb1 = make_test_spendbundle(coins[0])
+        sb2 = make_test_spendbundle(coins[1], fee=MEMPOOL_MIN_FEE_INCREASE * 2)
+        sb12 = SpendBundle.aggregate([sb1, sb2])
+        await send_spendbundle(mempool_manager, sb12)
+        sb3 = await make_and_send_spendbundle(mempool_manager, coins[2], fee=MEMPOOL_MIN_FEE_INCREASE * 2)
+        assert_sb_in_pool(mempool_manager, sb12)
+        assert_sb_in_pool(mempool_manager, sb3)
+        # sb1234 has a higher fee per cost than its conflicts and should get
+        # into the mempool
+        sb4 = make_test_spendbundle(coins[3], fee=MEMPOOL_MIN_FEE_INCREASE * 3)
+        sb1234 = SpendBundle.aggregate([sb12, sb3, sb4])
+        await send_spendbundle(mempool_manager, sb1234)
+        assert_sb_in_pool(mempool_manager, sb1234)
+        assert_sb_not_in_pool(mempool_manager, sb12)
+        assert_sb_not_in_pool(mempool_manager, sb3)
 
 
 @pytest.mark.anyio
 async def test_replace_with_extra_eligible_coin() -> None:
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010)))
-    sb1234 = SpendBundle.aggregate([make_test_spendbundle(coins[i]) for i in range(4)])
-    await send_spendbundle(mempool_manager, sb1234)
-    assert_sb_in_pool(mempool_manager, sb1234)
-    # Replace sb1234 with sb1234_2 which spends an eligible coin additionally
-    eligible_sb = make_test_spendbundle(coins[4], fee=MEMPOOL_MIN_FEE_INCREASE, eligible_spend=True)
-    sb1234_2 = SpendBundle.aggregate([sb1234, eligible_sb])
-    await send_spendbundle(mempool_manager, sb1234_2)
-    assert_sb_not_in_pool(mempool_manager, sb1234)
-    assert_sb_in_pool(mempool_manager, sb1234_2)
+    async with setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010))) as (mempool_manager, coins):
+        sb1234 = SpendBundle.aggregate([make_test_spendbundle(coins[i]) for i in range(4)])
+        await send_spendbundle(mempool_manager, sb1234)
+        assert_sb_in_pool(mempool_manager, sb1234)
+        # Replace sb1234 with sb1234_2 which spends an eligible coin additionally
+        eligible_sb = make_test_spendbundle(coins[4], fee=MEMPOOL_MIN_FEE_INCREASE, eligible_spend=True)
+        sb1234_2 = SpendBundle.aggregate([sb1234, eligible_sb])
+        await send_spendbundle(mempool_manager, sb1234_2)
+        assert_sb_not_in_pool(mempool_manager, sb1234)
+        assert_sb_in_pool(mempool_manager, sb1234_2)
 
 
 @pytest.mark.anyio
 async def test_replacing_one_with_an_eligible_coin() -> None:
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010)))
-    sb123 = SpendBundle.aggregate([make_test_spendbundle(coins[i]) for i in range(3)])
-    eligible_sb = make_test_spendbundle(coins[3], eligible_spend=True)
-    sb123e = SpendBundle.aggregate([sb123, eligible_sb])
-    await send_spendbundle(mempool_manager, sb123e)
-    assert_sb_in_pool(mempool_manager, sb123e)
-    # Replace sb123e with sb123e4
-    sb4 = make_test_spendbundle(coins[4], fee=MEMPOOL_MIN_FEE_INCREASE)
-    sb123e4 = SpendBundle.aggregate([sb123e, sb4])
-    await send_spendbundle(mempool_manager, sb123e4)
-    assert_sb_not_in_pool(mempool_manager, sb123e)
-    assert_sb_in_pool(mempool_manager, sb123e4)
+    async with setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000010))) as (mempool_manager, coins):
+        sb123 = SpendBundle.aggregate([make_test_spendbundle(coins[i]) for i in range(3)])
+        eligible_sb = make_test_spendbundle(coins[3], eligible_spend=True)
+        sb123e = SpendBundle.aggregate([sb123, eligible_sb])
+        await send_spendbundle(mempool_manager, sb123e)
+        assert_sb_in_pool(mempool_manager, sb123e)
+        # Replace sb123e with sb123e4
+        sb4 = make_test_spendbundle(coins[4], fee=MEMPOOL_MIN_FEE_INCREASE)
+        sb123e4 = SpendBundle.aggregate([sb123e, sb4])
+        await send_spendbundle(mempool_manager, sb123e4)
+        assert_sb_not_in_pool(mempool_manager, sb123e)
+        assert_sb_in_pool(mempool_manager, sb123e4)
 
 
 def test_dedup_info_nothing_to_do() -> None:
@@ -1757,64 +1769,64 @@ async def test_coin_spending_different_ways_then_finding_it_spent_in_new_peak(ne
                 ret.append(r)
         return ret
 
-    mempool_manager = await instantiate_mempool_manager(get_coin_records)
-    # Create a bunch of mempool items that spend the coin in different ways
-    # only the first one will be accepted
-    for i in range(3):
-        _, _, result = await generate_and_add_spendbundle(
-            mempool_manager,
-            [
-                [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount],
-                [ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, uint64(i)],
-            ],
-            coin,
-        )
-        if i == 0:
-            assert result[1] == MempoolInclusionStatus.SUCCESS
-        else:
-            assert result[1] == MempoolInclusionStatus.PENDING
-    assert len(list(mempool_manager.mempool.get_items_by_coin_id(coin_id))) == 1
-    assert mempool_manager.mempool.size() == 1
-    assert len(list(mempool_manager.mempool.items_by_feerate())) == 1
-    # Setup a new peak where the incoming block has spent the coin
-    # Mark this coin as spent
-    test_coin_records = {coin_id: CoinRecord(coin, uint32(0), TEST_HEIGHT, False, uint64(0))}
-    block_record = create_test_block_record(height=new_height)
-    await mempool_manager.new_peak(block_record, [coin_id])
-    invariant_check_mempool(mempool_manager.mempool)
-    # As the coin was a spend in all the mempool items we had, nothing should be left now
-    assert len(list(mempool_manager.mempool.get_items_by_coin_id(coin_id))) == 0
-    assert mempool_manager.mempool.size() == 0
-    assert len(list(mempool_manager.mempool.items_by_feerate())) == 0
+    async with instantiate_mempool_manager(get_coin_records) as mempool_manager:
+        # Create a bunch of mempool items that spend the coin in different ways
+        # only the first one will be accepted
+        for i in range(3):
+            _, _, result = await generate_and_add_spendbundle(
+                mempool_manager,
+                [
+                    [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount],
+                    [ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, uint64(i)],
+                ],
+                coin,
+            )
+            if i == 0:
+                assert result[1] == MempoolInclusionStatus.SUCCESS
+            else:
+                assert result[1] == MempoolInclusionStatus.PENDING
+        assert len(list(mempool_manager.mempool.get_items_by_coin_id(coin_id))) == 1
+        assert mempool_manager.mempool.size() == 1
+        assert len(list(mempool_manager.mempool.items_by_feerate())) == 1
+        # Setup a new peak where the incoming block has spent the coin
+        # Mark this coin as spent
+        test_coin_records = {coin_id: CoinRecord(coin, uint32(0), TEST_HEIGHT, False, uint64(0))}
+        block_record = create_test_block_record(height=new_height)
+        await mempool_manager.new_peak(block_record, [coin_id])
+        invariant_check_mempool(mempool_manager.mempool)
+        # As the coin was a spend in all the mempool items we had, nothing should be left now
+        assert len(list(mempool_manager.mempool.get_items_by_coin_id(coin_id))) == 0
+        assert mempool_manager.mempool.size() == 0
+        assert len(list(mempool_manager.mempool.items_by_feerate())) == 0
 
 
 @pytest.mark.anyio
 async def test_bundle_coin_spends() -> None:
     # This tests the construction of bundle_coin_spends map for mempool items
     # We're creating sb123e with 4 coins, one of them being eligible
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000005)))
-    sb123 = SpendBundle.aggregate([make_test_spendbundle(coins[i]) for i in range(3)])
-    eligible_sb = make_test_spendbundle(coins[3], eligible_spend=True)
-    sb123e = SpendBundle.aggregate([sb123, eligible_sb])
-    await send_spendbundle(mempool_manager, sb123e)
-    mi123e = mempool_manager.get_mempool_item(sb123e.name())
-    assert mi123e is not None
-    execution_cost = 44
-    for i in range(3):
-        assert mi123e.bundle_coin_spends[coins[i].name()] == BundleCoinSpend(
-            coin_spend=sb123.coin_spends[i],
-            eligible_for_dedup=False,
-            additions=[Coin(coins[i].name(), IDENTITY_PUZZLE_HASH, coins[i].amount)],
-            cost=uint64(ConditionCost.CREATE_COIN.value + ConditionCost.AGG_SIG.value + execution_cost),
+    async with setup_mempool_with_coins(coin_amounts=list(range(1000000000, 1000000005))) as (mempool_manager, coins):
+        sb123 = SpendBundle.aggregate([make_test_spendbundle(coins[i]) for i in range(3)])
+        eligible_sb = make_test_spendbundle(coins[3], eligible_spend=True)
+        sb123e = SpendBundle.aggregate([sb123, eligible_sb])
+        await send_spendbundle(mempool_manager, sb123e)
+        mi123e = mempool_manager.get_mempool_item(sb123e.name())
+        assert mi123e is not None
+        execution_cost = 44
+        for i in range(3):
+            assert mi123e.bundle_coin_spends[coins[i].name()] == BundleCoinSpend(
+                coin_spend=sb123.coin_spends[i],
+                eligible_for_dedup=False,
+                additions=[Coin(coins[i].name(), IDENTITY_PUZZLE_HASH, coins[i].amount)],
+                cost=uint64(ConditionCost.CREATE_COIN.value + ConditionCost.AGG_SIG.value + execution_cost),
+                latest_singleton_lineage=None,
+            )
+        assert mi123e.bundle_coin_spends[coins[3].name()] == BundleCoinSpend(
+            coin_spend=eligible_sb.coin_spends[0],
+            eligible_for_dedup=True,
+            additions=[Coin(coins[3].name(), IDENTITY_PUZZLE_HASH, coins[3].amount)],
+            cost=uint64(ConditionCost.CREATE_COIN.value + execution_cost),
             latest_singleton_lineage=None,
         )
-    assert mi123e.bundle_coin_spends[coins[3].name()] == BundleCoinSpend(
-        coin_spend=eligible_sb.coin_spends[0],
-        eligible_for_dedup=True,
-        additions=[Coin(coins[3].name(), IDENTITY_PUZZLE_HASH, coins[3].amount)],
-        cost=uint64(ConditionCost.CREATE_COIN.value + execution_cost),
-        latest_singleton_lineage=None,
-    )
 
 
 @pytest.mark.anyio
@@ -1831,9 +1843,13 @@ async def test_identical_spend_aggregation_e2e(
         }
 
     async def send_to_mempool(
-        full_node: FullNodeSimulator, spend_bundle: SpendBundle, *, expecting_conflict: bool = False
+        full_node: FullNodeSimulator,
+        wallet_peer: WSChiaConnection,
+        spend_bundle: SpendBundle,
+        *,
+        expecting_conflict: bool = False,
     ) -> None:
-        res = await full_node.send_transaction(wallet_protocol.SendTransaction(spend_bundle))
+        res = await full_node.send_transaction(wallet_protocol.SendTransaction(spend_bundle), wallet_peer)
         assert res is not None and ProtocolMessageTypes(res.type) == ProtocolMessageTypes.transaction_ack
         res_parsed = wallet_protocol.TransactionAck.from_bytes(res.data)
         if expecting_conflict:
@@ -1861,7 +1877,7 @@ async def test_identical_spend_aggregation_e2e(
             await wallet.generate_signed_transaction([uint64(200)] * len(phs), phs, action_scope)
         [tx] = action_scope.side_effects.transactions
         assert tx.spend_bundle is not None
-        await send_to_mempool(full_node_api, tx.spend_bundle)
+        await send_to_mempool(full_node_api, wallet_peer, tx.spend_bundle)
         await farm_a_block(full_node_api, wallet_node, ph)
         coins = list(await wallet_node.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(1))
         # Two blocks farmed plus 3 transactions
@@ -1870,7 +1886,7 @@ async def test_identical_spend_aggregation_e2e(
 
     [[full_node_api], [[wallet_node, wallet_server]], _] = simulator_and_wallet
     server = full_node_api.full_node.server
-    await wallet_server.start_client(PeerInfo(self_hostname, server.get_port()), None)
+    wallet_peer = await connect_and_get_peer(server, wallet_server, self_hostname)
     wallet, coins, ph = await make_setup_and_coins(full_node_api, wallet_node)
 
     # Make sure spending AB then BC would generate a conflict for the latter
@@ -1885,10 +1901,10 @@ async def test_identical_spend_aggregation_e2e(
     assert tx_b.spend_bundle is not None
     assert tx_c.spend_bundle is not None
     ab_bundle = SpendBundle.aggregate([tx_a.spend_bundle, tx_b.spend_bundle])
-    await send_to_mempool(full_node_api, ab_bundle)
+    await send_to_mempool(full_node_api, wallet_peer, ab_bundle)
     # BC should conflict here (on B)
     bc_bundle = SpendBundle.aggregate([tx_b.spend_bundle, tx_c.spend_bundle])
-    await send_to_mempool(full_node_api, bc_bundle, expecting_conflict=True)
+    await send_to_mempool(full_node_api, wallet_peer, bc_bundle, expecting_conflict=True)
     await farm_a_block(full_node_api, wallet_node, ph)
 
     # Make sure DE and EF would aggregate on E when E is eligible for deduplication
@@ -1902,7 +1918,7 @@ async def test_identical_spend_aggregation_e2e(
         )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
-    await send_to_mempool(full_node_api, tx.spend_bundle)
+    await send_to_mempool(full_node_api, wallet_peer, tx.spend_bundle)
     await farm_a_block(full_node_api, wallet_node, ph)
     # Grab the coin we created and make an eligible coin out of it
     coins_with_identity_ph = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(
@@ -1910,7 +1926,7 @@ async def test_identical_spend_aggregation_e2e(
     )
     coin = coins_with_identity_ph[0].coin
     sb = spend_bundle_from_conditions([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount]], coin)
-    await send_to_mempool(full_node_api, sb)
+    await send_to_mempool(full_node_api, wallet_peer, sb)
     await farm_a_block(full_node_api, wallet_node, ph)
     # Grab the eligible coin to spend as E in DE and EF transactions
     e_coin = (await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(False, IDENTITY_PUZZLE_HASH))[
@@ -1953,10 +1969,10 @@ async def test_identical_spend_aggregation_e2e(
     # Send DE and EF combinations to the mempool
     sb_de = SpendBundle.aggregate([tx_d.spend_bundle, sb_e])
     sb_de_name = sb_de.name()
-    await send_to_mempool(full_node_api, sb_de)
+    await send_to_mempool(full_node_api, wallet_peer, sb_de)
     sb_ef = SpendBundle.aggregate([sb_e, tx_f.spend_bundle])
     sb_ef_name = sb_ef.name()
-    await send_to_mempool(full_node_api, sb_ef)
+    await send_to_mempool(full_node_api, wallet_peer, sb_ef)
     # Send also a transaction EG that spends E differently from DE and EF,
     # to ensure it's rejected by the mempool
     conditions = [
@@ -1976,7 +1992,7 @@ async def test_identical_spend_aggregation_e2e(
     [tx_g] = action_scope.side_effects.transactions
     assert tx_g.spend_bundle is not None
     sb_e2g = SpendBundle.aggregate([sb_e2, tx_g.spend_bundle])
-    await send_to_mempool(full_node_api, sb_e2g, expecting_conflict=True)
+    await send_to_mempool(full_node_api, wallet_peer, sb_e2g, expecting_conflict=True)
 
     # Make sure our coin IDs to spend bundles mappings are correct
     assert get_sb_names_by_coin_id(full_node_api, coins[4].coin.name()) == {sb_de_name}
@@ -2131,7 +2147,7 @@ async def test_identical_spend_aggregation_e2e(
         ),
     ],
 )
-async def test_mempool_timelocks(cond1: list[object], cond2: list[object], expected: Optional[Err]) -> None:
+async def test_mempool_timelocks(cond1: list[object], cond2: list[object], expected: Err | None) -> None:
     coins = []
     test_coin_records = {}
 
@@ -2150,27 +2166,26 @@ async def test_mempool_timelocks(cond1: list[object], cond2: list[object], expec
                 ret.append(r)
         return ret
 
-    mempool_manager = await instantiate_mempool_manager(
+    async with instantiate_mempool_manager(
         get_coin_records, block_height=uint32(21), block_timestamp=uint64(2010)
-    )
-
-    coin_spends = [
-        make_spend(coins[0], IDENTITY_PUZZLE, Program.to([cond1])),
-        make_spend(coins[1], IDENTITY_PUZZLE, Program.to([cond2])),
-    ]
-
-    bundle = SpendBundle(coin_spends, G2Element())
-    bundle_name = bundle.name()
-    try:
-        result = await add_spendbundle(mempool_manager, bundle, bundle_name)
-        print(result)
-        if expected is not None:
-            assert result == (None, MempoolInclusionStatus.FAILED, expected)
-        else:
-            assert result[0] is not None
-            assert result[1] != MempoolInclusionStatus.FAILED
-    except ValidationError as e:
-        assert e.code == expected
+    ) as mempool_manager:
+        coin_spends = [
+            make_spend(coins[0], IDENTITY_PUZZLE, Program.to([cond1])),
+            make_spend(coins[1], IDENTITY_PUZZLE, Program.to([cond2])),
+        ]
+
+        bundle = SpendBundle(coin_spends, G2Element())
+        bundle_name = bundle.name()
+        try:
+            result = await add_spendbundle(mempool_manager, bundle, bundle_name)
+            print(result)
+            if expected is not None:
+                assert result == (None, MempoolInclusionStatus.FAILED, expected)
+            else:
+                assert result[0] is not None
+                assert result[1] != MempoolInclusionStatus.FAILED
+        except ValidationError as e:
+            assert e.code == expected
 
 
 TEST_FILL_RATE_ITEM_COST = 144_720_020
@@ -2202,6 +2217,7 @@ async def test_fill_rate_block_validation(
     max_block_clvm_cost: uint64,
     expected_block_items: int,
     expected_block_cost: uint64,
+    self_hostname: str,
 ) -> None:
     """
     This test covers the case where we set the fill rate to 100% and ensure
@@ -2212,8 +2228,10 @@ async def test_fill_rate_block_validation(
         expecting only one of the two test items to get included in the block.
     """
 
-    async def send_to_mempool(full_node: FullNodeSimulator, spend_bundle: SpendBundle) -> None:
-        res = await full_node.send_transaction(wallet_protocol.SendTransaction(spend_bundle))
+    async def send_to_mempool(
+        full_node: FullNodeSimulator, dummy_peer: WSChiaConnection, spend_bundle: SpendBundle
+    ) -> None:
+        res = await full_node.send_transaction(wallet_protocol.SendTransaction(spend_bundle), dummy_peer)
         assert res is not None and ProtocolMessageTypes(res.type) == ProtocolMessageTypes.transaction_ack
         res_parsed = wallet_protocol.TransactionAck.from_bytes(res.data)
         assert res_parsed.status == MempoolInclusionStatus.SUCCESS.value
@@ -2232,11 +2250,13 @@ async def test_fill_rate_block_validation(
             coin_records = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(False, ph)
             coin = next(cr.coin for cr in coin_records if cr.coin.amount == 250_000_000_000)
             coins_and_puzzles.append((coin, puzzle))
+        _, dummy_node_id = await add_dummy_connection(full_node_api.server, self_hostname, 12312)
+        dummy_peer = full_node_api.server.all_connections[dummy_node_id]
         sbs_info = []
         for coin, puzzle in coins_and_puzzles:
             coin_spend = make_spend(coin, puzzle, SerializedProgram.to([]))
             sb = SpendBundle([coin_spend], G2Element())
-            await send_to_mempool(full_node_api, sb)
+            await send_to_mempool(full_node_api, dummy_peer, sb)
             sbs_info.append((coin.name(), puzzle, sb.name()))
         return sbs_info
 
@@ -2288,14 +2308,14 @@ async def test_fill_rate_block_validation(
 
 @pytest.mark.parametrize("optimized_path", [True, False])
 @pytest.mark.anyio
-async def test_height_added_to_mempool(optimized_path: bool) -> None:
+async def test_height_added_to_mempool(optimized_path: bool, test_coins_mempool_manager: MempoolManager) -> None:
     """
     This test covers scenarios when the mempool is updated or rebuilt, to make
     sure that mempool items maintain correct height added to mempool values.
     We control whether we're updating the mempool or rebuilding it, through the
     `optimized_path` param.
     """
-    mempool_manager = await instantiate_mempool_manager(get_coin_records_for_test_coins)
+    mempool_manager = test_coins_mempool_manager
     assert mempool_manager.peak is not None
     assert mempool_manager.peak.height == TEST_HEIGHT
     assert mempool_manager.peak.header_hash == height_hash(TEST_HEIGHT)
@@ -2346,9 +2366,9 @@ class TestCoins:
             self.lineage_info[ph] = UnspentLineageInfo(c.name(), c.parent_coin_info, bytes32([42] * 32))
 
     def spend_coin(self, coin_id: bytes32, height: uint32 = uint32(10)) -> None:
-        self.coin_records[coin_id] = dataclasses.replace(self.coin_records[coin_id], spent_block_index=height)
+        self.coin_records[coin_id] = self.coin_records[coin_id].replace(spent_block_index=height)
 
-    def update_lineage(self, puzzle_hash: bytes32, coin: Optional[Coin]) -> None:
+    def update_lineage(self, puzzle_hash: bytes32, coin: Coin | None) -> None:
         if coin is None:
             self.lineage_info.pop(puzzle_hash)
         else:
@@ -2365,7 +2385,7 @@ class TestCoins:
 
         return ret
 
-    async def get_unspent_lineage_info(self, ph: bytes32) -> Optional[UnspentLineageInfo]:
+    async def get_unspent_lineage_info(self, ph: bytes32) -> UnspentLineageInfo | None:
         return self.lineage_info.get(ph)
 
 
@@ -2396,15 +2416,16 @@ def make_singleton_spend(
     return ret
 
 
-async def setup_mempool(coins: TestCoins) -> MempoolManager:
-    mempool_manager = MempoolManager(
+@asynccontextmanager
+async def setup_mempool(coins: TestCoins) -> AsyncGenerator[MempoolManager, None]:
+    async with MempoolManager.managed(
         coins.get_coin_records,
         coins.get_unspent_lineage_info,
         DEFAULT_CONSTANTS,
-    )
-    test_block_record = create_test_block_record(height=uint32(5000000), timestamp=uint64(12345678))
-    await mempool_manager.new_peak(test_block_record, None)
-    return mempool_manager
+    ) as mempool_manager:
+        test_block_record = create_test_block_record(height=uint32(5000000), timestamp=uint64(12345678))
+        await mempool_manager.new_peak(test_block_record, None)
+        yield mempool_manager
 
 
 # adds a new peak to the memepool manager with the specified coin IDs spent
@@ -2452,55 +2473,54 @@ async def test_new_peak_ff_eviction(
 
     coins = TestCoins([singleton_spend.coin, TEST_COIN], {singleton_spend.coin.puzzle_hash: singleton_spend.coin})
 
-    mempool_manager = await setup_mempool(coins)
+    async with setup_mempool(coins) as mempool_manager:
+        bundle_add_info = await mempool_manager.add_spend_bundle(
+            bundle,
+            make_test_conds(spend_ids=[(singleton_spend.coin, ELIGIBLE_FOR_FF), (TEST_COIN, 0)], cost=1000000),
+            bundle.name(),
+            first_added_height=uint32(1),
+        )
 
-    bundle_add_info = await mempool_manager.add_spend_bundle(
-        bundle,
-        make_test_conds(spend_ids=[(singleton_spend.coin, ELIGIBLE_FOR_FF), (TEST_COIN, 0)], cost=1000000),
-        bundle.name(),
-        first_added_height=uint32(1),
-    )
+        assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
+        item = mempool_manager.get_mempool_item(bundle.name())
+        assert item is not None
+        singleton_name = singleton_spend.coin.name()
+        assert item.bundle_coin_spends[singleton_name].supports_fast_forward
+        latest_singleton_lineage = item.bundle_coin_spends[singleton_name].latest_singleton_lineage
+        assert latest_singleton_lineage is not None
+        assert latest_singleton_lineage.coin_id == singleton_name
 
-    assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
-    item = mempool_manager.get_mempool_item(bundle.name())
-    assert item is not None
-    singleton_name = singleton_spend.coin.name()
-    assert item.bundle_coin_spends[singleton_name].supports_fast_forward
-    latest_singleton_lineage = item.bundle_coin_spends[singleton_name].latest_singleton_lineage
-    assert latest_singleton_lineage is not None
-    assert latest_singleton_lineage.coin_id == singleton_name
-
-    spent_coins: list[bytes32] = []
-
-    if spend_singleton:
-        # pretend that we melted the singleton, the FF spend
-        coins.update_lineage(singleton_spend.coin.puzzle_hash, None)
-        coins.spend_coin(singleton_spend.coin.name(), uint32(11))
-        spent_coins.append(singleton_spend.coin.name())
-
-    if spend_plain:
-        # pretend that we spend singleton, the FF spend
-        coins.spend_coin(coin_spend.coin.name(), uint32(11))
-        spent_coins.append(coin_spend.coin.name())
-
-    assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
-    invariant_check_mempool(mempool_manager.mempool)
+        spent_coins: list[bytes32] = []
 
-    if reverse_spend_order:
-        spent_coins.reverse()
+        if spend_singleton:
+            # pretend that we melted the singleton, the FF spend
+            coins.update_lineage(singleton_spend.coin.puzzle_hash, None)
+            coins.spend_coin(singleton_spend.coin.name(), uint32(11))
+            spent_coins.append(singleton_spend.coin.name())
 
-    await advance_mempool(mempool_manager, spent_coins, use_optimization=use_optimization)
+        if spend_plain:
+            # pretend that we spend singleton, the FF spend
+            coins.spend_coin(coin_spend.coin.name(), uint32(11))
+            spent_coins.append(coin_spend.coin.name())
 
-    # make sure the mempool item is evicted
-    if spend_singleton or spend_plain:
-        assert mempool_manager.get_mempool_item(bundle.name()) is None
-    else:
-        item = mempool_manager.get_mempool_item(bundle.name())
-        assert item is not None
-        assert item.bundle_coin_spends[singleton_spend.coin.name()].supports_fast_forward
-        latest_singleton_lineage = item.bundle_coin_spends[singleton_spend.coin.name()].latest_singleton_lineage
-        assert latest_singleton_lineage is not None
-        assert latest_singleton_lineage.coin_id == singleton_spend.coin.name()
+        assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
+        invariant_check_mempool(mempool_manager.mempool)
+
+        if reverse_spend_order:
+            spent_coins.reverse()
+
+        await advance_mempool(mempool_manager, spent_coins, use_optimization=use_optimization)
+
+        # make sure the mempool item is evicted
+        if spend_singleton or spend_plain:
+            assert mempool_manager.get_mempool_item(bundle.name()) is None
+        else:
+            item = mempool_manager.get_mempool_item(bundle.name())
+            assert item is not None
+            assert item.bundle_coin_spends[singleton_spend.coin.name()].supports_fast_forward
+            latest_singleton_lineage = item.bundle_coin_spends[singleton_spend.coin.name()].latest_singleton_lineage
+            assert latest_singleton_lineage is not None
+            assert latest_singleton_lineage.coin_id == singleton_spend.coin.name()
 
 
 @pytest.mark.anyio
@@ -2534,45 +2554,44 @@ async def test_multiple_ff(use_optimization: bool) -> None:
     singleton_ph = singleton_spend2.coin.puzzle_hash
     coins = TestCoins([singleton_spend1.coin, singleton_spend2.coin, TEST_COIN], {singleton_ph: singleton_spend2.coin})
 
-    mempool_manager = await setup_mempool(coins)
-
-    bundle_add_info = await mempool_manager.add_spend_bundle(
-        bundle,
-        make_test_conds(
-            spend_ids=[
-                (singleton_spend1.coin, ELIGIBLE_FOR_FF),
-                (singleton_spend2.coin, ELIGIBLE_FOR_FF),
-                (TEST_COIN, 0),
-            ],
-            cost=1000000,
-        ),
-        bundle.name(),
-        first_added_height=uint32(1),
-    )
-    assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
-    invariant_check_mempool(mempool_manager.mempool)
+    async with setup_mempool(coins) as mempool_manager:
+        bundle_add_info = await mempool_manager.add_spend_bundle(
+            bundle,
+            make_test_conds(
+                spend_ids=[
+                    (singleton_spend1.coin, ELIGIBLE_FOR_FF),
+                    (singleton_spend2.coin, ELIGIBLE_FOR_FF),
+                    (TEST_COIN, 0),
+                ],
+                cost=1000000,
+            ),
+            bundle.name(),
+            first_added_height=uint32(1),
+        )
+        assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
+        invariant_check_mempool(mempool_manager.mempool)
 
-    item = mempool_manager.get_mempool_item(bundle.name())
-    assert item is not None
-    assert item.bundle_coin_spends[singleton_spend1.coin.name()].supports_fast_forward
-    assert item.bundle_coin_spends[singleton_spend2.coin.name()].supports_fast_forward
-    assert not item.bundle_coin_spends[coin_spend.coin.name()].supports_fast_forward
+        item = mempool_manager.get_mempool_item(bundle.name())
+        assert item is not None
+        assert item.bundle_coin_spends[singleton_spend1.coin.name()].supports_fast_forward
+        assert item.bundle_coin_spends[singleton_spend2.coin.name()].supports_fast_forward
+        assert not item.bundle_coin_spends[coin_spend.coin.name()].supports_fast_forward
 
-    # spend the singleton coin2 and make coin3 the latest version
-    coins.update_lineage(singleton_ph, singleton_spend3.coin)
-    coins.spend_coin(singleton_spend2.coin.name(), uint32(11))
+        # spend the singleton coin2 and make coin3 the latest version
+        coins.update_lineage(singleton_ph, singleton_spend3.coin)
+        coins.spend_coin(singleton_spend2.coin.name(), uint32(11))
 
-    await advance_mempool(mempool_manager, [singleton_spend2.coin.name()], use_optimization=use_optimization)
+        await advance_mempool(mempool_manager, [singleton_spend2.coin.name()], use_optimization=use_optimization)
 
-    # we can still fast-forward the singleton spends, the bundle should still be valid
-    item = mempool_manager.get_mempool_item(bundle.name())
-    assert item is not None
-    spend = item.bundle_coin_spends[singleton_spend1.coin.name()]
-    assert spend.latest_singleton_lineage is not None
-    assert spend.latest_singleton_lineage.coin_id == singleton_spend3.coin.name()
-    spend = item.bundle_coin_spends[singleton_spend2.coin.name()]
-    assert spend.latest_singleton_lineage is not None
-    assert spend.latest_singleton_lineage.coin_id == singleton_spend3.coin.name()
+        # we can still fast-forward the singleton spends, the bundle should still be valid
+        item = mempool_manager.get_mempool_item(bundle.name())
+        assert item is not None
+        spend = item.bundle_coin_spends[singleton_spend1.coin.name()]
+        assert spend.latest_singleton_lineage is not None
+        assert spend.latest_singleton_lineage.coin_id == singleton_spend3.coin.name()
+        spend = item.bundle_coin_spends[singleton_spend2.coin.name()]
+        assert spend.latest_singleton_lineage is not None
+        assert spend.latest_singleton_lineage.coin_id == singleton_spend3.coin.name()
 
 
 @pytest.mark.anyio
@@ -2604,47 +2623,46 @@ async def test_advancing_ff(use_optimization: bool) -> None:
     singleton_ph = spend_a.coin.puzzle_hash
     coins = TestCoins([spend_a.coin, spend_b.coin, spend_c.coin, TEST_COIN], {singleton_ph: spend_a.coin})
 
-    mempool_manager = await setup_mempool(coins)
-
-    bundle_add_info = await mempool_manager.add_spend_bundle(
-        bundle,
-        make_test_conds(spend_ids=[(spend_a.coin, ELIGIBLE_FOR_FF), (TEST_COIN, 0)], cost=1000000),
-        bundle.name(),
-        first_added_height=uint32(1),
-    )
-    assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
-    invariant_check_mempool(mempool_manager.mempool)
+    async with setup_mempool(coins) as mempool_manager:
+        bundle_add_info = await mempool_manager.add_spend_bundle(
+            bundle,
+            make_test_conds(spend_ids=[(spend_a.coin, ELIGIBLE_FOR_FF), (TEST_COIN, 0)], cost=1000000),
+            bundle.name(),
+            first_added_height=uint32(1),
+        )
+        assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
+        invariant_check_mempool(mempool_manager.mempool)
 
-    item = mempool_manager.get_mempool_item(bundle.name())
-    assert item is not None
-    spend = item.bundle_coin_spends[spend_a.coin.name()]
-    assert spend.supports_fast_forward
-    assert spend.latest_singleton_lineage is not None
-    assert spend.latest_singleton_lineage.coin_id == spend_a.coin.name()
+        item = mempool_manager.get_mempool_item(bundle.name())
+        assert item is not None
+        spend = item.bundle_coin_spends[spend_a.coin.name()]
+        assert spend.supports_fast_forward
+        assert spend.latest_singleton_lineage is not None
+        assert spend.latest_singleton_lineage.coin_id == spend_a.coin.name()
 
-    coins.update_lineage(singleton_ph, spend_b.coin)
-    coins.spend_coin(spend_a.coin.name(), uint32(11))
+        coins.update_lineage(singleton_ph, spend_b.coin)
+        coins.spend_coin(spend_a.coin.name(), uint32(11))
 
-    await advance_mempool(mempool_manager, [spend_a.coin.name()])
+        await advance_mempool(mempool_manager, [spend_a.coin.name()])
 
-    item = mempool_manager.get_mempool_item(bundle.name())
-    assert item is not None
-    spend = item.bundle_coin_spends[spend_a.coin.name()]
-    assert spend.supports_fast_forward
-    assert spend.latest_singleton_lineage is not None
-    assert spend.latest_singleton_lineage.coin_id == spend_b.coin.name()
+        item = mempool_manager.get_mempool_item(bundle.name())
+        assert item is not None
+        spend = item.bundle_coin_spends[spend_a.coin.name()]
+        assert spend.supports_fast_forward
+        assert spend.latest_singleton_lineage is not None
+        assert spend.latest_singleton_lineage.coin_id == spend_b.coin.name()
 
-    coins.update_lineage(singleton_ph, spend_c.coin)
-    coins.spend_coin(spend_b.coin.name(), uint32(12))
+        coins.update_lineage(singleton_ph, spend_c.coin)
+        coins.spend_coin(spend_b.coin.name(), uint32(12))
 
-    await advance_mempool(mempool_manager, [spend_b.coin.name()], use_optimization=use_optimization)
+        await advance_mempool(mempool_manager, [spend_b.coin.name()], use_optimization=use_optimization)
 
-    item = mempool_manager.get_mempool_item(bundle.name())
-    assert item is not None
-    spend = item.bundle_coin_spends[spend_a.coin.name()]
-    assert spend.supports_fast_forward
-    assert spend.latest_singleton_lineage is not None
-    assert spend.latest_singleton_lineage.coin_id == spend_c.coin.name()
+        item = mempool_manager.get_mempool_item(bundle.name())
+        assert item is not None
+        spend = item.bundle_coin_spends[spend_a.coin.name()]
+        assert spend.supports_fast_forward
+        assert spend.latest_singleton_lineage is not None
+        assert spend.latest_singleton_lineage.coin_id == spend_c.coin.name()
 
 
 @pytest.mark.parametrize("old", [True, False])
@@ -2653,15 +2671,14 @@ def test_no_peak(old: bool, transactions_1000: list[SpendBundle]) -> None:
     all_coins = [s.coin for b in bundles for s in b.coin_spends]
     coins = TestCoins(all_coins, {})
 
-    mempool_manager = MempoolManager(
+    with MempoolManager(
         coins.get_coin_records,
         coins.get_unspent_lineage_info,
         DEFAULT_CONSTANTS,
-    )
-
-    create_block = mempool_manager.create_block_generator if old else mempool_manager.create_block_generator2
+    ) as mempool_manager:
+        create_block = mempool_manager.create_block_generator if old else mempool_manager.create_block_generator2
 
-    assert create_block(bytes32([1] * 32), 10.0) is None
+        assert create_block(bytes32([1] * 32), 10.0) is None
 
 
 @pytest.fixture(name="test_wallet")
@@ -2766,77 +2783,76 @@ async def test_create_block_generator(
     rng = random.Random(seed)
 
     # run the test multiple times, generating different combinations of mempools
-    mempool_manager = await setup_mempool(coins)
-
-    included_bundles = rng.sample(bundles, mempool_size)
-    expected_additions: set[Coin] = set()
-    expected_removals: set[Coin] = set()
-    expected_signature = G2Element()
-    for sb in included_bundles:
-        pre_validation = await mempool_manager.pre_validate_spendbundle(sb)
-        bundle_add_info = await mempool_manager.add_spend_bundle(
-            sb, pre_validation, sb.name(), first_added_height=uint32(1)
+    async with setup_mempool(coins) as mempool_manager:
+        included_bundles = rng.sample(bundles, mempool_size)
+        expected_additions: set[Coin] = set()
+        expected_removals: set[Coin] = set()
+        expected_signature = G2Element()
+        for sb in included_bundles:
+            pre_validation = await mempool_manager.pre_validate_spendbundle(sb)
+            bundle_add_info = await mempool_manager.add_spend_bundle(
+                sb, pre_validation, sb.name(), first_added_height=uint32(1)
+            )
+            expected_additions.update(sb.additions())
+            expected_removals.update(sb.removals())
+
+            expected_signature += sb.aggregated_signature
+            assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
+            item = mempool_manager.get_mempool_item(sb.name())
+            assert item is not None
+        all_items = mempool_manager.mempool.all_items()
+        assert len(list(all_items)) == len(included_bundles)
+
+        invariant_check_mempool(mempool_manager.mempool)
+
+        assert mempool_manager.peak is not None
+        create_block = mempool_manager.create_block_generator if old else mempool_manager.create_block_generator2
+        new_block_gen = create_block(mempool_manager.peak.header_hash, 10.0)
+        assert new_block_gen is not None
+
+        # now, make sure the generator we got is valid
+
+        if expect_failure:
+            assert len(expected_additions) != len(new_block_gen.additions)
+            assert expected_additions != set(new_block_gen.additions)
+            assert len(expected_removals) != len(new_block_gen.removals)
+            assert expected_removals != set(new_block_gen.removals)
+            assert expected_signature != new_block_gen.signature
+        else:
+            assert len(expected_additions) == len(new_block_gen.additions)
+            assert expected_additions == set(new_block_gen.additions)
+            assert len(expected_removals) == len(new_block_gen.removals)
+            assert expected_removals == set(new_block_gen.removals)
+            assert expected_signature == new_block_gen.signature
+
+        err, conds = run_block_generator2(
+            bytes(new_block_gen.program),
+            new_block_gen.generator_refs,
+            DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
+            DEFAULT_FLAGS,
+            new_block_gen.signature,
+            None,
+            DEFAULT_CONSTANTS,
         )
-        expected_additions.update(sb.additions())
-        expected_removals.update(sb.removals())
 
-        expected_signature += sb.aggregated_signature
-        assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
-        item = mempool_manager.get_mempool_item(sb.name())
-        assert item is not None
-    all_items = mempool_manager.mempool.all_items()
-    assert len(list(all_items)) == len(included_bundles)
+        assert err is None
+        assert conds is not None
 
-    invariant_check_mempool(mempool_manager.mempool)
-
-    assert mempool_manager.peak is not None
-    create_block = mempool_manager.create_block_generator if old else mempool_manager.create_block_generator2
-    new_block_gen = create_block(mempool_manager.peak.header_hash, 10.0)
-    assert new_block_gen is not None
-
-    # now, make sure the generator we got is valid
-
-    if expect_failure:
-        assert len(expected_additions) != len(new_block_gen.additions)
-        assert expected_additions != set(new_block_gen.additions)
-        assert len(expected_removals) != len(new_block_gen.removals)
-        assert expected_removals != set(new_block_gen.removals)
-        assert expected_signature != new_block_gen.signature
-    else:
-        assert len(expected_additions) == len(new_block_gen.additions)
-        assert expected_additions == set(new_block_gen.additions)
-        assert len(expected_removals) == len(new_block_gen.removals)
-        assert expected_removals == set(new_block_gen.removals)
-        assert expected_signature == new_block_gen.signature
-
-    err, conds = run_block_generator2(
-        bytes(new_block_gen.program),
-        new_block_gen.generator_refs,
-        DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
-        DEFAULT_FLAGS,
-        new_block_gen.signature,
-        None,
-        DEFAULT_CONSTANTS,
-    )
-
-    assert err is None
-    assert conds is not None
-
-    if expect_failure:
-        assert len(conds.spends) != len(expected_removals)
-    else:
-        assert len(conds.spends) == len(expected_removals)
-    assert conds.cost < DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM
-    assert new_block_gen.cost == conds.cost
+        if expect_failure:
+            assert len(conds.spends) != len(expected_removals)
+        else:
+            assert len(conds.spends) == len(expected_removals)
+        assert conds.cost < DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM
+        assert new_block_gen.cost == conds.cost
 
-    num_additions = 0
-    for spend in conds.spends:
-        assert Coin(spend.parent_id, spend.puzzle_hash, uint64(spend.coin_amount)) in expected_removals
-        for add2 in spend.create_coin:
-            assert Coin(spend.coin_id, add2[0], uint64(add2[1])) in expected_additions
-            num_additions += 1
+        num_additions = 0
+        for spend in conds.spends:
+            assert Coin(spend.parent_id, spend.puzzle_hash, uint64(spend.coin_amount)) in expected_removals
+            for add2 in spend.create_coin:
+                assert Coin(spend.coin_id, add2[0], uint64(add2[1])) in expected_additions
+                num_additions += 1
 
-    assert num_additions == len(new_block_gen.additions)
+        assert num_additions == len(new_block_gen.additions)
 
 
 # if we try to fill the mempool with more than 550, all spends won't
@@ -2850,58 +2866,57 @@ async def test_create_block_generator_real_bundles(seed: int, old: bool, test_bu
 
     rng = random.Random(seed)
 
-    mempool_manager = await setup_mempool(coins)
+    async with setup_mempool(coins) as mempool_manager:
+        included_bundles = rng.sample(test_bundles, len(test_bundles) // 5)
+        for sb in included_bundles:
+            pre_validation = await mempool_manager.pre_validate_spendbundle(sb)
+            bundle_add_info = await mempool_manager.add_spend_bundle(
+                sb, pre_validation, sb.name(), first_added_height=uint32(1)
+            )
 
-    included_bundles = rng.sample(test_bundles, len(test_bundles) // 5)
-    for sb in included_bundles:
-        pre_validation = await mempool_manager.pre_validate_spendbundle(sb)
-        bundle_add_info = await mempool_manager.add_spend_bundle(
-            sb, pre_validation, sb.name(), first_added_height=uint32(1)
+            # in the test bundles, we have some duplicate spends
+            # just ignore them for now
+            if bundle_add_info.status == MempoolInclusionStatus.FAILED:
+                assert bundle_add_info.error == Err.DOUBLE_SPEND
+                continue
+            assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
+            item = mempool_manager.get_mempool_item(sb.name())
+            assert item is not None
+
+        invariant_check_mempool(mempool_manager.mempool)
+
+        assert mempool_manager.peak is not None
+        create_block = mempool_manager.create_block_generator if old else mempool_manager.create_block_generator2
+        new_block_gen = create_block(mempool_manager.peak.header_hash, 10.0)
+        assert new_block_gen is not None
+
+        # now, make sure the generator we got is valid
+
+        err, conds = run_block_generator2(
+            bytes(new_block_gen.program),
+            new_block_gen.generator_refs,
+            DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
+            DEFAULT_FLAGS,
+            new_block_gen.signature,
+            None,
+            DEFAULT_CONSTANTS,
         )
 
-        # in the test bundles, we have some duplicate spends
-        # just ignore them for now
-        if bundle_add_info.status == MempoolInclusionStatus.FAILED:
-            assert bundle_add_info.error == Err.DOUBLE_SPEND
-            continue
-        assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
-        item = mempool_manager.get_mempool_item(sb.name())
-        assert item is not None
-
-    invariant_check_mempool(mempool_manager.mempool)
-
-    assert mempool_manager.peak is not None
-    create_block = mempool_manager.create_block_generator if old else mempool_manager.create_block_generator2
-    new_block_gen = create_block(mempool_manager.peak.header_hash, 10.0)
-    assert new_block_gen is not None
-
-    # now, make sure the generator we got is valid
-
-    err, conds = run_block_generator2(
-        bytes(new_block_gen.program),
-        new_block_gen.generator_refs,
-        DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
-        DEFAULT_FLAGS,
-        new_block_gen.signature,
-        None,
-        DEFAULT_CONSTANTS,
-    )
-
-    assert err is None
-    assert conds is not None
+        assert err is None
+        assert conds is not None
 
-    assert conds.cost == new_block_gen.cost
+        assert conds.cost == new_block_gen.cost
 
-    removals: set[Coin] = set()
-    additions: set[Coin] = set()
+        removals: set[Coin] = set()
+        additions: set[Coin] = set()
 
-    for spend in conds.spends:
-        removals.add(Coin(spend.parent_id, spend.puzzle_hash, uint64(spend.coin_amount)))
-        for add in spend.create_coin:
-            additions.add(Coin(spend.coin_id, add[0], uint64(add[1])))
+        for spend in conds.spends:
+            removals.add(Coin(spend.parent_id, spend.puzzle_hash, uint64(spend.coin_amount)))
+            for add in spend.create_coin:
+                additions.add(Coin(spend.coin_id, add[0], uint64(add[1])))
 
-    assert removals == set(new_block_gen.removals)
-    assert additions == set(new_block_gen.additions)
+        assert removals == set(new_block_gen.removals)
+        assert additions == set(new_block_gen.additions)
 
 
 @pytest.mark.anyio
@@ -2920,30 +2935,33 @@ async def test_spending_singleton_to_invalidate_existing_ff_spends() -> None:
         coins=[singleton_spend1.coin, singleton_spend2.coin, TEST_COIN, TEST_COIN2],
         lineage={singleton_spend2.coin.puzzle_hash: singleton_spend2.coin},
     )
-    mempool_manager = await setup_mempool(coins)
-    coin_spend1 = make_spend(
-        TEST_COIN, IDENTITY_PUZZLE, Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 42]])
-    )
-    sb1 = SpendBundle([singleton_spend1, coin_spend1], G2Element())
-    sb1_conds = make_test_conds(spend_ids=[(singleton_spend1.coin, ELIGIBLE_FOR_FF), (TEST_COIN, 0)], cost=100_000_000)
-    bundle_add_info1 = await mempool_manager.add_spend_bundle(sb1, sb1_conds, sb1.name(), uint32(1))
-    assert bundle_add_info1.status == MempoolInclusionStatus.SUCCESS
-    invariant_check_mempool(mempool_manager.mempool)
-    # Trying to spend the same singleton with a different child amount should
-    # trigger a conflict on any replace by fee attempt.
-    coin_spend2 = make_spend(
-        TEST_COIN2, IDENTITY_PUZZLE, Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 42]])
-    )
-    sb2 = SpendBundle([singleton_spend2, coin_spend1, coin_spend2], G2Element())
-    # This singleton spend is not eligible for fast forward as its next
-    # iteration has a different amount.
-    sb2_conds = make_test_conds(spend_ids=[(singleton_spend2.coin, 0), (TEST_COIN, 0), (TEST_COIN2, 0)], cost=1337)
-    # This transaction conflicts with the previous one no matter what fee you
-    # pay, because we're changing the fast forward eligibility flag for the
-    # singleton spend.
-    bundle_add_info2 = await mempool_manager.add_spend_bundle(sb2, sb2_conds, sb2.name(), uint32(1))
-    assert bundle_add_info2.error == Err.MEMPOOL_CONFLICT
-    assert bundle_add_info2.status == MempoolInclusionStatus.PENDING
+
+    async with setup_mempool(coins) as mempool_manager:
+        coin_spend1 = make_spend(
+            TEST_COIN, IDENTITY_PUZZLE, Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 42]])
+        )
+        sb1 = SpendBundle([singleton_spend1, coin_spend1], G2Element())
+        sb1_conds = make_test_conds(
+            spend_ids=[(singleton_spend1.coin, ELIGIBLE_FOR_FF), (TEST_COIN, 0)], cost=100_000_000
+        )
+        bundle_add_info1 = await mempool_manager.add_spend_bundle(sb1, sb1_conds, sb1.name(), uint32(1))
+        assert bundle_add_info1.status == MempoolInclusionStatus.SUCCESS
+        invariant_check_mempool(mempool_manager.mempool)
+        # Trying to spend the same singleton with a different child amount should
+        # trigger a conflict on any replace by fee attempt.
+        coin_spend2 = make_spend(
+            TEST_COIN2, IDENTITY_PUZZLE, Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 42]])
+        )
+        sb2 = SpendBundle([singleton_spend2, coin_spend1, coin_spend2], G2Element())
+        # This singleton spend is not eligible for fast forward as its next
+        # iteration has a different amount.
+        sb2_conds = make_test_conds(spend_ids=[(singleton_spend2.coin, 0), (TEST_COIN, 0), (TEST_COIN2, 0)], cost=1337)
+        # This transaction conflicts with the previous one no matter what fee you
+        # pay, because we're changing the fast forward eligibility flag for the
+        # singleton spend.
+        bundle_add_info2 = await mempool_manager.add_spend_bundle(sb2, sb2_conds, sb2.name(), uint32(1))
+        assert bundle_add_info2.error == Err.MEMPOOL_CONFLICT
+        assert bundle_add_info2.status == MempoolInclusionStatus.PENDING
 
 
 @pytest.mark.parametrize("flags", [ELIGIBLE_FOR_DEDUP, ELIGIBLE_FOR_FF, ELIGIBLE_FOR_FF | ELIGIBLE_FOR_DEDUP])
@@ -2956,37 +2974,38 @@ async def test_check_removals_with_block_creation(flags: int, old: bool) -> None
     coins = TestCoins(
         coins=[singleton_spend.coin, TEST_COIN], lineage={singleton_spend.coin.puzzle_hash: singleton_spend.coin}
     )
-    mempool_manager = await setup_mempool(coins)
-    sb1 = SpendBundle([singleton_spend], G2Element())
-    sb1_conds = make_test_conds(
-        spend_ids=[(singleton_spend.coin, 0)],
-        created_coins=[[(singleton_spend.coin.puzzle_hash, 1, None)]],
-        cost=100_000_000,
-    )
-    bundle_add_info1 = await mempool_manager.add_spend_bundle(sb1, sb1_conds, sb1.name(), uint32(1))
-    assert bundle_add_info1.status == MempoolInclusionStatus.SUCCESS
-    invariant_check_mempool(mempool_manager.mempool)
-    extra_spend = make_spend(
-        TEST_COIN, IDENTITY_PUZZLE, Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 42]])
-    )
-    sb2 = SpendBundle([singleton_spend, extra_spend], G2Element())
-    sb2_conds = make_test_conds(
-        spend_ids=[(singleton_spend.coin, flags), (TEST_COIN, 0)],
-        created_coins=[[(singleton_spend.coin.puzzle_hash, 1, None)], []],
-        cost=1337,
-    )
-    bundle_add_info2 = await mempool_manager.add_spend_bundle(sb2, sb2_conds, sb2.name(), uint32(1))
-    assert bundle_add_info2.status == MempoolInclusionStatus.SUCCESS
-    assert mempool_manager.peak is not None
-    create_block = mempool_manager.create_block_generator if old else mempool_manager.create_block_generator2
-    new_block_gen = create_block(mempool_manager.peak.header_hash, 10.0)
-    assert new_block_gen is not None
-    assert len(new_block_gen.additions) == 1
-    assert set(new_block_gen.additions) == {
-        Coin(singleton_spend.coin.name(), singleton_spend.coin.puzzle_hash, uint64(1))
-    }
-    assert len(new_block_gen.removals) == 2
-    assert set(new_block_gen.removals) == {singleton_spend.coin, TEST_COIN}
+
+    async with setup_mempool(coins) as mempool_manager:
+        sb1 = SpendBundle([singleton_spend], G2Element())
+        sb1_conds = make_test_conds(
+            spend_ids=[(singleton_spend.coin, 0)],
+            created_coins=[[(singleton_spend.coin.puzzle_hash, 1, None)]],
+            cost=100_000_000,
+        )
+        bundle_add_info1 = await mempool_manager.add_spend_bundle(sb1, sb1_conds, sb1.name(), uint32(1))
+        assert bundle_add_info1.status == MempoolInclusionStatus.SUCCESS
+        invariant_check_mempool(mempool_manager.mempool)
+        extra_spend = make_spend(
+            TEST_COIN, IDENTITY_PUZZLE, Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 42]])
+        )
+        sb2 = SpendBundle([singleton_spend, extra_spend], G2Element())
+        sb2_conds = make_test_conds(
+            spend_ids=[(singleton_spend.coin, flags), (TEST_COIN, 0)],
+            created_coins=[[(singleton_spend.coin.puzzle_hash, 1, None)], []],
+            cost=1337,
+        )
+        bundle_add_info2 = await mempool_manager.add_spend_bundle(sb2, sb2_conds, sb2.name(), uint32(1))
+        assert bundle_add_info2.status == MempoolInclusionStatus.SUCCESS
+        assert mempool_manager.peak is not None
+        create_block = mempool_manager.create_block_generator if old else mempool_manager.create_block_generator2
+        new_block_gen = create_block(mempool_manager.peak.header_hash, 10.0)
+        assert new_block_gen is not None
+        assert len(new_block_gen.additions) == 1
+        assert set(new_block_gen.additions) == {
+            Coin(singleton_spend.coin.name(), singleton_spend.coin.puzzle_hash, uint64(1))
+        }
+        assert len(new_block_gen.removals) == 2
+        assert set(new_block_gen.removals) == {singleton_spend.coin, TEST_COIN}
 
 
 @pytest.mark.anyio
@@ -2994,12 +3013,12 @@ async def test_dedup_not_canonical() -> None:
     # this is ((1)), but with a non-canonical encoding
     coin_spend = mk_coin_spend(TEST_COIN, solution="ffffc001018080")
     coins = TestCoins([TEST_COIN], lineage={})
-    mempool_manager = await setup_mempool(coins)
-    sb = SpendBundle([coin_spend], G2Element())
-    sb_conds = make_test_conds(spend_ids=[(TEST_COIN, ELIGIBLE_FOR_DEDUP)])
-    bundle_add_info = await mempool_manager.add_spend_bundle(sb, sb_conds, sb.name(), uint32(1))
-    assert bundle_add_info.status == MempoolInclusionStatus.FAILED
-    assert bundle_add_info.error == Err.INVALID_COIN_SOLUTION
+    async with setup_mempool(coins) as mempool_manager:
+        sb = SpendBundle([coin_spend], G2Element())
+        sb_conds = make_test_conds(spend_ids=[(TEST_COIN, ELIGIBLE_FOR_DEDUP)])
+        bundle_add_info = await mempool_manager.add_spend_bundle(sb, sb_conds, sb.name(), uint32(1))
+        assert bundle_add_info.status == MempoolInclusionStatus.FAILED
+        assert bundle_add_info.error == Err.INVALID_COIN_SOLUTION
 
 
 def make_coin_record(coin: Coin, spent_block_index: int = 0) -> CoinRecord:
@@ -3012,7 +3031,7 @@ class CheckRemovalsCase:
     removals: dict[bytes32, CoinRecord]
     bundle_coin_spends: dict[bytes32, BundleCoinSpend] = dataclasses.field(default_factory=dict)
     conflicting_mempool_items: dict[bytes32, list[MempoolItem]] = dataclasses.field(default_factory=dict)
-    expected_result: tuple[Optional[Err], list[MempoolItem]] = dataclasses.field(default_factory=lambda: (None, []))
+    expected_result: tuple[Err | None, list[MempoolItem]] = dataclasses.field(default_factory=lambda: (None, []))
     marks: Marks = ()
 
 
@@ -3161,6 +3180,119 @@ def test_check_removals(case: CheckRemovalsCase) -> None:
     assert set(conflicts) == set(expected_conflicts)
 
 
+# this puzzle just creates coins, however many are requested by the solution
+# (mod (A)
+#    (defun loop (n)
+#        (if (= n 1)
+#            (list)
+#            (c (list 51 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff n) (loop (- n 1))))
+#    )
+#    (loop A)
+# )
+create_coins_loop: str = (
+    "ff02ffff01ff02ff02ffff04ff02ffff04ff05ff80808080ffff04ffff01ff02"
+    "ffff03ffff09ff05ffff010180ff80ffff01ff04ffff04ffff0133ffff04ffff"
+    "01a0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+    "ffffffff04ff05ff80808080ffff02ff02ffff04ff02ffff04ffff11ff05ffff"
+    "010180ff808080808080ff0180ff018080"
+)
+
+# (mod (A)
+#   (defun loop (n)
+#     (if (= n 0) (list) (c n (loop (- n 1))))
+#   )
+#   (c (c 1 (loop A)) ())
+# )
+deep_recursion: str = (
+    "ff02ffff01ff04ffff04ffff0101ffff02ff02ffff04ff02ffff04ff05ff8080"
+    "808080ff8080ffff04ffff01ff02ffff03ffff09ff05ff8080ff80ffff01ff04"
+    "ff05ffff02ff02ffff04ff02ffff04ffff11ff05ffff010180ff808080808080"
+    "ff0180ff018080"
+)
+
+
+# this test uses artificial puzzles just to exercise the block creation. These
+# spends are expected not to verify any signatures
+# This is to keep the test simple.
+@pytest.mark.parametrize(
+    "puzzle, solution",
+    [
+        pytest.param(create_coins_loop, "ff8207d180", id="2000-coins"),
+        pytest.param(create_coins_loop, "ff8203e980", id="1000-coins"),
+        pytest.param(create_coins_loop, "ff8201f580", id="500 coins"),
+        pytest.param(deep_recursion, "ff830f424080", id="recurse-1000000"),
+        pytest.param(deep_recursion, "ff82271080", id="recurse-10000"),
+        pytest.param(deep_recursion, "ff6480", id="recurse-100"),
+    ],
+)
+@pytest.mark.parametrize("old", [True, False])
+@pytest.mark.anyio
+async def test_create_block_generator_custom_spend(
+    puzzle: str, solution: str, old: bool, softfork_height: uint32
+) -> None:
+    solution_str = SerializedProgram.fromhex(solution)
+    puzzle_reveal = SerializedProgram.fromhex(puzzle)
+    puzzle_hash = puzzle_reveal.get_tree_hash()
+
+    async with setup_mempool_with_coins(
+        coin_amounts=list(range(100000000, 100000022)), puzzle_hash=puzzle_hash, height=softfork_height
+    ) as (mempool_manager, coins):
+        spend_bundles = [
+            SpendBundle(
+                coin_spends=[CoinSpend(coin, puzzle_reveal=puzzle_reveal, solution=solution_str)],
+                aggregated_signature=G2Element(),
+            )
+            for coin in coins
+        ]
+
+        for sb in spend_bundles:
+            try:
+                conds2 = await mempool_manager.pre_validate_spendbundle(sb)
+                await mempool_manager.add_spend_bundle(sb, conds2, sb.name(), softfork_height)
+                invariant_check_mempool(mempool_manager.mempool)
+            except Exception as e:
+                print(f"not adding bundle: {e}")
+                # we don't expect this coin to be spent by the resulting generator
+                # so remove it from the list
+                for cs in sb.coin_spends:
+                    coins.remove(cs.coin)
+
+        create_block = mempool_manager.create_block_generator if old else mempool_manager.create_block_generator2
+        assert mempool_manager.peak is not None
+        generator = create_block(mempool_manager.peak.header_hash, 10.0)
+
+        if len(coins) == 0:
+            assert generator is None
+        else:
+            assert generator is not None
+
+            assert generator.signature == G2Element()
+
+            removals = set(generator.removals)
+
+            err, conds = run_block_generator2(
+                bytes(generator.program),
+                generator.generator_refs,
+                DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
+                0,
+                generator.signature,
+                None,
+                DEFAULT_CONSTANTS,
+            )
+
+            assert err is None
+            assert conds is not None
+
+            assert len(conds.spends) == len(removals)
+
+            for spend in conds.spends:
+                removal = Coin(spend.parent_id, spend.puzzle_hash, uint64(spend.coin_amount))
+                assert removal in coins
+                assert removal in removals
+
+        invariant_check_mempool(mempool_manager.mempool)
+
+
 @pytest.mark.anyio
 async def test_new_peak_deferred_ff_items() -> None:
     """
@@ -3178,37 +3310,37 @@ async def test_new_peak_deferred_ff_items() -> None:
             singleton_spend2.coin.puzzle_hash: singleton_spend2.coin,
         },
     )
-    mempool_manager = await setup_mempool(coins)
-    # Let's submit the two singletons transactions to the mempool
-    sb_names = []
-    for singleton_spend, regular_coin in [(singleton_spend1, TEST_COIN), (singleton_spend2, TEST_COIN2)]:
-        sb = SpendBundle([singleton_spend, mk_coin_spend(regular_coin)], G2Element())
-        sb_name = sb.name()
-        await mempool_manager.add_spend_bundle(
-            sb,
-            make_test_conds(spend_ids=[(singleton_spend.coin, ELIGIBLE_FOR_FF), (regular_coin, 0)], cost=1337),
-            sb_name,
-            uint32(1),
-        )
-        assert mempool_manager.get_mempool_item(sb_name) is not None
-        sb_names.append(sb_name)
-    # Let's advance the mempool by spending these singletons into new lineages
-    singleton1_new_latest = Coin(singleton1_id, singleton_spend1.coin.puzzle_hash, singleton_spend1.coin.amount)
-    coins.update_lineage(singleton_spend1.coin.puzzle_hash, singleton1_new_latest)
-    singleton2_new_latest = Coin(singleton2_id, singleton_spend2.coin.puzzle_hash, singleton_spend2.coin.amount)
-    coins.update_lineage(singleton_spend2.coin.puzzle_hash, singleton2_new_latest)
-    await advance_mempool(mempool_manager, [singleton1_id, singleton2_id], use_optimization=True)
-    # Both items should get updated with their related latest lineages
-    mi1 = mempool_manager.get_mempool_item(sb_names[0])
-    assert mi1 is not None
-    latest_singleton_lineage1 = mi1.bundle_coin_spends[singleton1_id].latest_singleton_lineage
-    assert latest_singleton_lineage1 is not None
-    assert latest_singleton_lineage1.coin_id == singleton1_new_latest.name()
-    mi2 = mempool_manager.get_mempool_item(sb_names[1])
-    assert mi2 is not None
-    latest_singleton_lineage2 = mi2.bundle_coin_spends[singleton2_id].latest_singleton_lineage
-    assert latest_singleton_lineage2 is not None
-    assert latest_singleton_lineage2.coin_id == singleton2_new_latest.name()
+    async with setup_mempool(coins) as mempool_manager:
+        # Let's submit the two singletons transactions to the mempool
+        sb_names = []
+        for singleton_spend, regular_coin in [(singleton_spend1, TEST_COIN), (singleton_spend2, TEST_COIN2)]:
+            sb = SpendBundle([singleton_spend, mk_coin_spend(regular_coin)], G2Element())
+            sb_name = sb.name()
+            await mempool_manager.add_spend_bundle(
+                sb,
+                make_test_conds(spend_ids=[(singleton_spend.coin, ELIGIBLE_FOR_FF), (regular_coin, 0)], cost=1337),
+                sb_name,
+                uint32(1),
+            )
+            assert mempool_manager.get_mempool_item(sb_name) is not None
+            sb_names.append(sb_name)
+        # Let's advance the mempool by spending these singletons into new lineages
+        singleton1_new_latest = Coin(singleton1_id, singleton_spend1.coin.puzzle_hash, singleton_spend1.coin.amount)
+        coins.update_lineage(singleton_spend1.coin.puzzle_hash, singleton1_new_latest)
+        singleton2_new_latest = Coin(singleton2_id, singleton_spend2.coin.puzzle_hash, singleton_spend2.coin.amount)
+        coins.update_lineage(singleton_spend2.coin.puzzle_hash, singleton2_new_latest)
+        await advance_mempool(mempool_manager, [singleton1_id, singleton2_id], use_optimization=True)
+        # Both items should get updated with their related latest lineages
+        mi1 = mempool_manager.get_mempool_item(sb_names[0])
+        assert mi1 is not None
+        latest_singleton_lineage1 = mi1.bundle_coin_spends[singleton1_id].latest_singleton_lineage
+        assert latest_singleton_lineage1 is not None
+        assert latest_singleton_lineage1.coin_id == singleton1_new_latest.name()
+        mi2 = mempool_manager.get_mempool_item(sb_names[1])
+        assert mi2 is not None
+        latest_singleton_lineage2 = mi2.bundle_coin_spends[singleton2_id].latest_singleton_lineage
+        assert latest_singleton_lineage2 is not None
+        assert latest_singleton_lineage2.coin_id == singleton2_new_latest.name()
 
 
 @pytest.mark.anyio
@@ -3226,47 +3358,47 @@ async def test_different_ff_versions() -> None:
     coins = TestCoins(
         [singleton_spend1.coin, singleton_spend2.coin, TEST_COIN, TEST_COIN2], {singleton_ph: singleton_spend2.coin}
     )
-    mempool_manager = await setup_mempool(coins)
-    mempool_items: list[MempoolItem] = []
-    for singleton_spend, regular_coin in [(singleton_spend1, TEST_COIN), (singleton_spend2, TEST_COIN2)]:
-        sb = SpendBundle([singleton_spend, mk_coin_spend(regular_coin)], G2Element())
-        sb_name = sb.name()
-        await mempool_manager.add_spend_bundle(
-            sb,
-            make_test_conds(spend_ids=[(singleton_spend.coin, ELIGIBLE_FOR_FF), (regular_coin, 0)], cost=1337),
-            sb_name,
-            uint32(1),
-        )
-        mi = mempool_manager.get_mempool_item(sb_name)
-        assert mi is not None
-        mempool_items.append(mi)
-    [mi1, mi2] = mempool_items
-    latest_lineage_id = version2_id
-    assert latest_lineage_id != version1_id
-    # Bundle coin spends key points to version 1 but the lineage is latest (v2)
-    latest_singleton_lineage1 = mi1.bundle_coin_spends[version1_id].latest_singleton_lineage
-    assert latest_singleton_lineage1 is not None
-    assert latest_singleton_lineage1.coin_id == latest_lineage_id
-    # Both the bundle coin spends key and the lineage point to latest (v2)
-    latest_singleton_lineage2 = mi2.bundle_coin_spends[version2_id].latest_singleton_lineage
-    assert latest_singleton_lineage2 is not None
-    assert latest_singleton_lineage2.coin_id == latest_lineage_id
-    # Let's update the lineage with a new version of the singleton
-    new_latest_lineage = Coin(version2_id, singleton_ph, singleton_spend2.coin.amount)
-    new_latest_lineage_id = new_latest_lineage.name()
-    coins.update_lineage(singleton_ph, new_latest_lineage)
-    await advance_mempool(mempool_manager, [version1_id, version2_id], use_optimization=True)
-    # Both items should get updated with the latest lineage
-    new_mi1 = mempool_manager.get_mempool_item(mi1.spend_bundle_name)
-    assert new_mi1 is not None
-    latest_singleton_lineage1 = new_mi1.bundle_coin_spends[version1_id].latest_singleton_lineage
-    assert latest_singleton_lineage1 is not None
-    assert latest_singleton_lineage1.coin_id == new_latest_lineage_id
-    new_mi2 = mempool_manager.get_mempool_item(mi2.spend_bundle_name)
-    assert new_mi2 is not None
-    latest_singleton_lineage2 = new_mi2.bundle_coin_spends[version2_id].latest_singleton_lineage
-    assert latest_singleton_lineage2 is not None
-    assert latest_singleton_lineage2.coin_id == new_latest_lineage_id
+    async with setup_mempool(coins) as mempool_manager:
+        mempool_items: list[MempoolItem] = []
+        for singleton_spend, regular_coin in [(singleton_spend1, TEST_COIN), (singleton_spend2, TEST_COIN2)]:
+            sb = SpendBundle([singleton_spend, mk_coin_spend(regular_coin)], G2Element())
+            sb_name = sb.name()
+            await mempool_manager.add_spend_bundle(
+                sb,
+                make_test_conds(spend_ids=[(singleton_spend.coin, ELIGIBLE_FOR_FF), (regular_coin, 0)], cost=1337),
+                sb_name,
+                uint32(1),
+            )
+            mi = mempool_manager.get_mempool_item(sb_name)
+            assert mi is not None
+            mempool_items.append(mi)
+        [mi1, mi2] = mempool_items
+        latest_lineage_id = version2_id
+        assert latest_lineage_id != version1_id
+        # Bundle coin spends key points to version 1 but the lineage is latest (v2)
+        latest_singleton_lineage1 = mi1.bundle_coin_spends[version1_id].latest_singleton_lineage
+        assert latest_singleton_lineage1 is not None
+        assert latest_singleton_lineage1.coin_id == latest_lineage_id
+        # Both the bundle coin spends key and the lineage point to latest (v2)
+        latest_singleton_lineage2 = mi2.bundle_coin_spends[version2_id].latest_singleton_lineage
+        assert latest_singleton_lineage2 is not None
+        assert latest_singleton_lineage2.coin_id == latest_lineage_id
+        # Let's update the lineage with a new version of the singleton
+        new_latest_lineage = Coin(version2_id, singleton_ph, singleton_spend2.coin.amount)
+        new_latest_lineage_id = new_latest_lineage.name()
+        coins.update_lineage(singleton_ph, new_latest_lineage)
+        await advance_mempool(mempool_manager, [version1_id, version2_id], use_optimization=True)
+        # Both items should get updated with the latest lineage
+        new_mi1 = mempool_manager.get_mempool_item(mi1.spend_bundle_name)
+        assert new_mi1 is not None
+        latest_singleton_lineage1 = new_mi1.bundle_coin_spends[version1_id].latest_singleton_lineage
+        assert latest_singleton_lineage1 is not None
+        assert latest_singleton_lineage1.coin_id == new_latest_lineage_id
+        new_mi2 = mempool_manager.get_mempool_item(mi2.spend_bundle_name)
+        assert new_mi2 is not None
+        latest_singleton_lineage2 = new_mi2.bundle_coin_spends[version2_id].latest_singleton_lineage
+        assert latest_singleton_lineage2 is not None
+        assert latest_singleton_lineage2.coin_id == new_latest_lineage_id
 
 
 @pytest.mark.anyio
@@ -3284,32 +3416,32 @@ async def test_new_peak_txs_added(condition_and_error: tuple[ConditionOpcode, Er
     time-lock allows them to be reconsidered.
     """
     coins = TestCoins([TEST_COIN], {})
-    mempool_manager = await setup_mempool(coins)
-    # Add an item that should go to the pending cache
-    assert mempool_manager.peak is not None
-    condition_height = mempool_manager.peak.height + 1
-    condition, expected_error = condition_and_error
-    _, sb_name, result = await generate_and_add_spendbundle(mempool_manager, [[condition, condition_height]])
-    _, status, error = result
-    assert status == MempoolInclusionStatus.PENDING
-    assert error == expected_error
-    # Advance the mempool beyond the asserted height to retry the test item
-    if optimized_path:
-        spent_coins: Optional[list[bytes32]] = []
+    async with setup_mempool(coins) as mempool_manager:
+        # Add an item that should go to the pending cache
+        assert mempool_manager.peak is not None
+        condition_height = mempool_manager.peak.height + 1
+        condition, expected_error = condition_and_error
+        _, sb_name, result = await generate_and_add_spendbundle(mempool_manager, [[condition, condition_height]])
+        _, status, error = result
+        assert status == MempoolInclusionStatus.PENDING
+        assert error == expected_error
+        # Advance the mempool beyond the asserted height to retry the test item
+        if optimized_path:
+            spent_coins: list[bytes32] | None = []
+            new_peak_info = await mempool_manager.new_peak(
+                create_test_block_record(height=uint32(condition_height)), spent_coins
+            )
+            # We're not there yet (needs to be higher, not equal)
+            assert new_peak_info.spend_bundle_ids == []
+            assert mempool_manager.get_mempool_item(sb_name, include_pending=False) is None
+        else:
+            spent_coins = None
         new_peak_info = await mempool_manager.new_peak(
-            create_test_block_record(height=uint32(condition_height)), spent_coins
+            create_test_block_record(height=uint32(condition_height + 1)), spent_coins
         )
-        # We're not there yet (needs to be higher, not equal)
-        assert new_peak_info.spend_bundle_ids == []
-        assert mempool_manager.get_mempool_item(sb_name, include_pending=False) is None
-    else:
-        spent_coins = None
-    new_peak_info = await mempool_manager.new_peak(
-        create_test_block_record(height=uint32(condition_height + 1)), spent_coins
-    )
-    # The item gets retried successfully now
-    assert new_peak_info.spend_bundle_ids == [sb_name]
-    assert mempool_manager.get_mempool_item(sb_name, include_pending=False) is not None
+        # The item gets retried successfully now
+        assert new_peak_info.spend_bundle_ids == [sb_name]
+        assert mempool_manager.get_mempool_item(sb_name, include_pending=False) is not None
 
 
 @pytest.mark.anyio
@@ -3318,13 +3450,15 @@ async def test_mempool_item_to_spend_bundle() -> None:
     Tests that we can properly go back to a `SpendBundle` from a `MempoolItem`.
     """
     coins = [Coin(bytes32.random(), IDENTITY_PUZZLE_HASH, uint64(i + 1)) for i in range(random.randint(42, 1337))]
-    mempool_manager = await setup_mempool(TestCoins(coins, {}))
-    random_sample = random.sample(coins, 42)
-    sb = SpendBundle([CoinSpend(c, IDENTITY_PUZZLE, SerializedProgram.to(None)) for c in random_sample], G2Element())
-    sb_name = sb.name()
-    await add_spendbundle(mempool_manager, sb, sb_name)
-    mi = mempool_manager.get_mempool_item(sb_name)
-    assert mi is not None
-    result = mi.to_spend_bundle()
-    assert result == sb
-    assert result.name() == sb_name
+    async with setup_mempool(TestCoins(coins, {})) as mempool_manager:
+        random_sample = random.sample(coins, 42)
+        sb = SpendBundle(
+            [CoinSpend(c, IDENTITY_PUZZLE, SerializedProgram.to(None)) for c in random_sample], G2Element()
+        )
+        sb_name = sb.name()
+        await add_spendbundle(mempool_manager, sb, sb_name)
+        mi = mempool_manager.get_mempool_item(sb_name)
+        assert mi is not None
+        result = mi.to_spend_bundle()
+        assert result == sb
+        assert result.name() == sb_name