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

chia/_tests/cmds/wallet/test_vcs.py

@@ -9,13 +9,14 @@ from chia_rs.sized_ints import uint32, uint64
 from chia._tests.cmds.cmd_test_utils import TestRpcClients, TestWalletRpcClient, logType, run_cli_command_and_assert
 from chia._tests.cmds.wallet.test_consts import FINGERPRINT_ARG, STD_TX, STD_UTX, get_bytes32
 from chia.util.bech32m import encode_puzzle_hash
-from chia.wallet.conditions import ConditionValidTimes
+from chia.wallet.conditions import Condition, ConditionValidTimes
 from chia.wallet.lineage_proof import LineageProof
-from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.vc_wallet.vc_drivers import VCLineageProof, VerifiedCredential
 from chia.wallet.vc_wallet.vc_store import VCRecord
 from chia.wallet.wallet_request_types import (
+    CRCATApprovePending,
+    CRCATApprovePendingResponse,
     GetWallets,
     VCAddProofs,
     VCGet,
@@ -335,25 +336,23 @@ def test_vcs_approve_r_cats(capsys: object, get_test_cli_clients: tuple[TestRpcC
     class VcsApproveRCATSRpcClient(TestWalletRpcClient):
         async def crcat_approve_pending(
             self,
-            wallet_id: uint32,
-            min_amount_to_claim: uint64,
+            request: CRCATApprovePending,
             tx_config: TXConfig,
-            fee: uint64 = uint64(0),
-            push: bool = True,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
-        ) -> list[TransactionRecord]:
+        ) -> CRCATApprovePendingResponse:
             self.add_to_log(
                 "crcat_approve_pending",
                 (
-                    wallet_id,
-                    min_amount_to_claim,
+                    request.wallet_id,
+                    request.min_amount_to_claim,
                     tx_config,
-                    fee,
-                    push,
+                    request.fee,
+                    request.push,
                     timelock_info,
                 ),
             )
-            return [STD_TX]
+            return CRCATApprovePendingResponse([STD_UTX], [STD_TX])
 
     inst_rpc_client = VcsApproveRCATSRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client

chia/_tests/cmds/wallet/test_wallet.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import datetime
 import os
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 
 import importlib_resources
 import pytest
@@ -29,6 +29,7 @@ from chia.protocols.outbound_message import NodeType
 from chia.types.signing_mode import SigningMode
 from chia.util.bech32m import encode_puzzle_hash
 from chia.wallet.conditions import Condition, ConditionValidTimes
+from chia.wallet.puzzle_drivers import PuzzleInfo
 from chia.wallet.trade_record import TradeRecord
 from chia.wallet.trading.offer import Offer
 from chia.wallet.trading.trade_status import TradeStatus
@@ -41,6 +42,7 @@ from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet_coin_store import GetCoinRecords
 from chia.wallet.wallet_request_types import (
     BalanceResponse,
+    CancelOffer,
     CancelOfferResponse,
     CATAssetIDToName,
     CATAssetIDToNameResponse,
@@ -49,15 +51,22 @@ from chia.wallet.wallet_request_types import (
     CATSpend,
     CATSpendResponse,
     ClawbackPuzzleDecoratorOverride,
+    CreateNewWallet,
+    CreateNewWalletType,
+    CreateOfferForIDs,
     CreateOfferForIDsResponse,
     DeleteUnconfirmedTransactions,
     ExtendDerivationIndex,
     ExtendDerivationIndexResponse,
     FungibleAsset,
+    GetAllOffers,
+    GetAllOffersResponse,
     GetCurrentDerivationIndexResponse,
     GetHeightInfoResponse,
     GetNextAddress,
     GetNextAddressResponse,
+    GetOffer,
+    GetOfferResponse,
     GetTransaction,
     GetTransactions,
     GetTransactionsResponse,
@@ -73,12 +82,37 @@ from chia.wallet.wallet_request_types import (
     SendTransactionResponse,
     SpendClawbackCoins,
     SpendClawbackCoinsResponse,
+    TakeOffer,
     TakeOfferResponse,
     TransactionRecordWithMetadata,
+    WalletCreationMode,
     WalletInfoResponse,
 )
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
+TEMP = PuzzleInfo(
+    {
+        "type": "singleton",
+        "launcher_id": "0x0101010101010101010101010101010101010101010101010101010101010101",
+        "launcher_ph": "0xeff07522495060c066f66f32acc2a77e3a3e737aca8baea4d1a64ea4cdc13da9",
+        "also": {
+            "type": "metadata",
+            "metadata": "",
+            "updater_hash": "0x0707070707070707070707070707070707070707070707070707070707070707",
+            "also": {
+                "type": "ownership",
+                "owner": "()",
+                "transfer_program": {
+                    "type": "royalty transfer program",
+                    "launcher_id": "0x0101010101010101010101010101010101010101010101010101010101010101",
+                    "royalty_address": "0x0303030303030303030303030303030303030303030303030303030303030303",
+                    "royalty_percentage": "1000",
+                },
+            },
+        },
+    }
+)
+
 test_offer_file_path = importlib_resources.files(__name__.rpartition(".")[0]).joinpath("test_offer.toffer")
 test_offer_file_bech32 = test_offer_file_path.read_text(encoding="utf-8")
 test_offer_id: str = "0xdfb7e8643376820ec995b0bcdb3fc1f764c16b814df5e074631263fcf1e00839"
@@ -208,8 +242,8 @@ def test_get_transactions(capsys: object, get_test_cli_clients: tuple[TestRpcCli
     expected_calls: logType = {
         "get_wallets": [(GetWallets(type=None, include_data=True),)] * 2,
         "get_transactions": [
-            (GetTransactions(uint32(1), uint16(2), uint16(4), SortKey.RELEVANCE.name, True, None, None, None),),
-            (GetTransactions(uint32(1), uint16(2), uint16(4), SortKey.RELEVANCE.name, True, None, None, None),),
+            (GetTransactions(uint32(1), uint32(2), uint32(4), SortKey.RELEVANCE.name, True, None, None, None),),
+            (GetTransactions(uint32(1), uint32(2), uint32(4), SortKey.RELEVANCE.name, True, None, None, None),),
         ],
         "get_coin_records": [
             (GetCoinRecords(coin_id_filter=HashFilter.include([expected_coin_id])),),
@@ -276,8 +310,8 @@ def test_show(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path])
             return NFTGetWalletDIDResponse("did:chia:1qgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpq4msw0c")
 
         async def get_connections(
-            self, node_type: Optional[NodeType] = None
-        ) -> list[dict[str, Union[str, int, float, bytes32]]]:
+            self, node_type: NodeType | None = None
+        ) -> list[dict[str, str | int | float | bytes32]]:
             self.add_to_log("get_connections", (node_type,))
             return [
                 {
@@ -676,10 +710,6 @@ def test_add_token(capsys: object, get_test_cli_clients: tuple[TestRpcClients, P
 
     # set RPC Client
     class AddTokenRpcClient(TestWalletRpcClient):
-        async def create_wallet_for_existing_cat(self, asset_id: bytes) -> dict[str, int]:
-            self.add_to_log("create_wallet_for_existing_cat", (asset_id,))
-            return {"wallet_id": 3}
-
         async def set_cat_name(self, request: CATSetName) -> CATSetNameResponse:
             self.add_to_log("set_cat_name", (request.wallet_id, request.name))
             return CATSetNameResponse(wallet_id=request.wallet_id)
@@ -697,7 +727,19 @@ def test_add_token(capsys: object, get_test_cli_clients: tuple[TestRpcClients, P
 
     expected_calls: logType = {
         "cat_asset_id_to_name": [(get_bytes32(1),), (bytes32([1, 2] * 16),)],
-        "create_wallet_for_existing_cat": [(bytes32([1, 2] * 16),)],
+        "create_new_wallet": [
+            (
+                CreateNewWallet(
+                    wallet_type=CreateNewWalletType.CAT_WALLET,
+                    mode=WalletCreationMode.EXISTING,
+                    asset_id=bytes32([1, 2] * 16),
+                    push=True,
+                ),
+                DEFAULT_TX_CONFIG,
+                tuple(),
+                ConditionValidTimes(),
+            )
+        ],
         "set_cat_name": [(2, "examplecat"), (3, "examplecat")],
     }
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
@@ -763,17 +805,22 @@ def test_make_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
     class MakeOfferRpcClient(TestWalletRpcClient):
         async def create_offer_for_ids(
             self,
-            offer_dict: dict[uint32, int],
+            request: CreateOfferForIDs,
             tx_config: TXConfig,
-            driver_dict: Optional[dict[str, Any]] = None,
-            solver: Optional[dict[str, Any]] = None,
-            fee: uint64 = uint64(0),
-            validate_only: bool = False,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> CreateOfferForIDsResponse:
             self.add_to_log(
                 "create_offer_for_ids",
-                (offer_dict, tx_config, driver_dict, solver, fee, validate_only, timelock_info),
+                (
+                    request.offer,
+                    tx_config,
+                    request.driver_dict,
+                    request.solver,
+                    request.fee,
+                    request.validate_only,
+                    timelock_info,
+                ),
             )
 
             created_offer = Offer({}, WalletSpendBundle([], G2Element()), {})
@@ -866,35 +913,39 @@ def test_make_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
         "create_offer_for_ids": [
             (
                 {
-                    1: -10000000000000,
-                    3: -100000,
-                    "0404040404040404040404040404040404040404040404040404040404040404": -100000,
-                    "0202020202020202020202020202020202020202020202020202020202020202": 10000,
-                    "0101010101010101010101010101010101010101010101010101010101010101": 1,
+                    "1": "-10000000000000",
+                    "3": "-100000",
+                    "0404040404040404040404040404040404040404040404040404040404040404": "-100000",
+                    "0202020202020202020202020202020202020202020202020202020202020202": "10000",
+                    "0101010101010101010101010101010101010101010101010101010101010101": "1",
                 },
                 DEFAULT_TX_CONFIG.override(reuse_puzhash=True),
                 {
-                    "0101010101010101010101010101010101010101010101010101010101010101": {
-                        "type": "singleton",
-                        "launcher_id": "0x0101010101010101010101010101010101010101010101010101010101010101",
-                        "launcher_ph": "0xeff07522495060c066f66f32acc2a77e3a3e737aca8baea4d1a64ea4cdc13da9",
-                        "also": {
-                            "type": "metadata",
-                            "metadata": "",
-                            "updater_hash": "0x0707070707070707070707070707070707070707070707070707070707070707",
+                    bytes32([1] * 32): PuzzleInfo(
+                        {
+                            "type": "singleton",
+                            "launcher_id": "0x0101010101010101010101010101010101010101010101010101010101010101",
+                            "launcher_ph": "0xeff07522495060c066f66f32acc2a77e3a3e737aca8baea4d1a64ea4cdc13da9",
                             "also": {
-                                "type": "ownership",
-                                "owner": "()",
-                                "transfer_program": {
-                                    "type": "royalty transfer program",
-                                    "launcher_id": "0x0101010101010101010101010101010101010101010101010101010101010101",
-                                    "royalty_address": "0x0303030303030303030303030303030303030303030"
-                                    "303030303030303030303",
-                                    "royalty_percentage": "1000",
+                                "type": "metadata",
+                                "metadata": "",
+                                "updater_hash": "0x0707070707070707070707070707070707070707070707070707070707070707",
+                                "also": {
+                                    "type": "ownership",
+                                    "owner": "()",
+                                    "transfer_program": {
+                                        "type": "royalty transfer program",
+                                        "launcher_id": (
+                                            "0x0101010101010101010101010101010101010101010101010101010101010101"
+                                        ),
+                                        "royalty_address": "0x0303030303030303030303030303030303030303030"
+                                        "303030303030303030303",
+                                        "royalty_percentage": "1000",
+                                    },
                                 },
                             },
-                        },
-                    }
+                        }
+                    )
                 },
                 None,
                 500000000000,
@@ -911,32 +962,22 @@ def test_get_offers(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
 
     # set RPC Client
     class GetOffersRpcClient(TestWalletRpcClient):
-        async def get_all_offers(
-            self,
-            start: int = 0,
-            end: int = 50,
-            sort_key: Optional[str] = None,
-            reverse: bool = False,
-            file_contents: bool = False,
-            exclude_my_offers: bool = False,
-            exclude_taken_offers: bool = False,
-            include_completed: bool = False,
-        ) -> list[TradeRecord]:
+        async def get_all_offers(self, request: GetAllOffers) -> GetAllOffersResponse:
             self.add_to_log(
                 "get_all_offers",
                 (
-                    start,
-                    end,
-                    sort_key,
-                    reverse,
-                    file_contents,
-                    exclude_my_offers,
-                    exclude_taken_offers,
-                    include_completed,
+                    request.start,
+                    request.end,
+                    request.sort_key,
+                    request.reverse,
+                    request.file_contents,
+                    request.exclude_my_offers,
+                    request.exclude_taken_offers,
+                    request.include_completed,
                 ),
             )
             records: list[TradeRecord] = []
-            for i in reversed(range(start, end - 1)):  # reversed to match the sort order
+            for i in reversed(range(request.start, request.end - 1)):  # reversed to match the sort order
                 trade_offer = TradeRecord(
                     confirmed_at_index=uint32(0),
                     accepted_at_time=None,
@@ -960,7 +1001,7 @@ def test_get_offers(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
                     ),
                 )
                 records.append(trade_offer)
-            return records
+            return GetAllOffersResponse([], records)
 
     inst_rpc_client = GetOffersRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
@@ -1021,18 +1062,19 @@ def test_take_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
     class TakeOfferRpcClient(TestWalletRpcClient):
         async def take_offer(
             self,
-            offer: Offer,
+            request: TakeOffer,
             tx_config: TXConfig,
-            solver: Optional[dict[str, Any]] = None,
-            fee: uint64 = uint64(0),
-            push: bool = True,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> TakeOfferResponse:
-            self.add_to_log("take_offer", (offer, tx_config, solver, fee, push, timelock_info))
+            self.add_to_log(
+                "take_offer",
+                (request.parsed_offer, tx_config, request.solver, request.fee, request.push, timelock_info),
+            )
             return TakeOfferResponse(
                 [STD_UTX],
                 [STD_TX],
-                offer,
+                request.parsed_offer,
                 TradeRecord(
                     confirmed_at_index=uint32(0),
                     accepted_at_time=uint64(123456789),
@@ -1040,10 +1082,10 @@ def test_take_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
                     is_my_offer=False,
                     sent=uint32(1),
                     sent_to=[("aaaaa", uint8(1), None)],
-                    offer=bytes(offer),
+                    offer=bytes(request.parsed_offer),
                     taken_offer=None,
-                    coins_of_interest=offer.get_involved_coins(),
-                    trade_id=offer.name(),
+                    coins_of_interest=request.parsed_offer.get_involved_coins(),
+                    trade_id=request.parsed_offer.name(),
                     status=uint32(TradeStatus.PENDING_ACCEPT.value),
                     valid_times=ConditionValidTimes(),
                 ),
@@ -1127,34 +1169,37 @@ def test_cancel_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients
 
     # set RPC Client
     class CancelOfferRpcClient(TestWalletRpcClient):
-        async def get_offer(self, trade_id: bytes32, file_contents: bool = False) -> TradeRecord:
-            self.add_to_log("get_offer", (trade_id, file_contents))
+        async def get_offer(self, request: GetOffer) -> GetOfferResponse:
+            self.add_to_log("get_offer", (request.trade_id, request.file_contents))
             offer = Offer.from_bech32(test_offer_file_bech32)
-            return TradeRecord(
-                confirmed_at_index=uint32(0),
-                accepted_at_time=uint64(0),
-                created_at_time=uint64(12345678),
-                is_my_offer=True,
-                sent=uint32(0),
-                sent_to=[],
-                offer=bytes(offer),
-                taken_offer=None,
-                coins_of_interest=offer.get_involved_coins(),
-                trade_id=offer.name(),
-                status=uint32(TradeStatus.PENDING_ACCEPT.value),
-                valid_times=ConditionValidTimes(),
+            return GetOfferResponse(
+                test_offer_file_bech32,
+                TradeRecord(
+                    confirmed_at_index=uint32(0),
+                    accepted_at_time=uint64(0),
+                    created_at_time=uint64(12345678),
+                    is_my_offer=True,
+                    sent=uint32(0),
+                    sent_to=[],
+                    offer=bytes(offer),
+                    taken_offer=None,
+                    coins_of_interest=offer.get_involved_coins(),
+                    trade_id=offer.name(),
+                    status=uint32(TradeStatus.PENDING_ACCEPT.value),
+                    valid_times=ConditionValidTimes(),
+                ),
             )
 
         async def cancel_offer(
             self,
-            trade_id: bytes32,
+            request: CancelOffer,
             tx_config: TXConfig,
-            fee: uint64 = uint64(0),
-            secure: bool = True,
-            push: bool = True,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> CancelOfferResponse:
-            self.add_to_log("cancel_offer", (trade_id, tx_config, fee, secure, push, timelock_info))
+            self.add_to_log(
+                "cancel_offer", (request.trade_id, tx_config, request.fee, request.secure, request.push, timelock_info)
+            )
             return CancelOfferResponse([STD_UTX], [STD_TX])
 
     inst_rpc_client = CancelOfferRpcClient()

chia/_tests/conftest.py

@@ -12,9 +12,9 @@ import os
 import random
 import sysconfig
 import tempfile
-from collections.abc import AsyncIterator, Iterator
+from collections.abc import AsyncIterator, Callable, Iterator
 from contextlib import AsyncExitStack
-from typing import Any, Callable, Union
+from typing import Any
 
 import aiohttp
 import pytest
@@ -28,7 +28,6 @@ from pytest import MonkeyPatch
 from chia._tests import ether
 from chia._tests.core.data_layer.util import ChiaRoot
 from chia._tests.core.node_height import node_height_at_least
-from chia._tests.simulation.test_simulation import test_constants_modified
 from chia._tests.util.misc import (
     BenchmarkRunner,
     ComparableEnum,
@@ -100,6 +99,20 @@ from chia.util.keyring_wrapper import KeyringWrapper
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.wallet_node import Balance
 
+test_constants_modified = test_constants.replace(
+    DIFFICULTY_STARTING=uint64(2**8),
+    DISCRIMINANT_SIZE_BITS=uint16(1024),
+    SUB_EPOCH_BLOCKS=uint32(140),
+    WEIGHT_PROOF_THRESHOLD=uint8(2),
+    WEIGHT_PROOF_RECENT_BLOCKS=uint32(350),
+    MAX_SUB_SLOT_BLOCKS=uint32(50),
+    NUM_SPS_SUB_SLOT=uint8(32),  # Must be a power of 2
+    EPOCH_BLOCKS=uint32(280),
+    SUB_SLOT_ITERS_STARTING=uint64(2**20),
+    NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(5),
+    NUMBER_ZERO_BITS_PLOT_FILTER_V2=uint8(5),
+)
+
 
 @pytest.fixture(name="ether_setup", autouse=True)
 def ether_setup_fixture(request: SubRequest, record_property: Callable[[str, object], None]) -> Iterator[None]:
@@ -195,12 +208,14 @@ def get_keychain():
 class ConsensusMode(ComparableEnum):
     PLAIN = 0
     HARD_FORK_2_0 = 1
-    HARD_FORK_3_0 = 2
+    SOFT_FORK_2_6 = 2
+    HARD_FORK_3_0 = 3
 
 
 @pytest.fixture(
     scope="session",
-    params=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0, ConsensusMode.HARD_FORK_3_0],
+    # TODO: todo_v2_plots add HARD_FORK_3_0 mode as well as after phase-out
+    params=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0, ConsensusMode.SOFT_FORK_2_6],
 )
 def consensus_mode(request):
     return request.param
@@ -217,6 +232,11 @@ def blockchain_constants(consensus_mode: ConsensusMode) -> ConsensusConstants:
             PLOT_FILTER_32_HEIGHT=uint32(20),
         )
 
+    if consensus_mode >= ConsensusMode.SOFT_FORK_2_6:
+        ret = ret.replace(
+            SOFT_FORK8_HEIGHT=uint32(2),
+        )
+
     if consensus_mode >= ConsensusMode.HARD_FORK_3_0:
         ret = ret.replace(
             HARD_FORK_HEIGHT=uint32(2),
@@ -230,10 +250,14 @@ def blockchain_constants(consensus_mode: ConsensusMode) -> ConsensusConstants:
 
 
 @pytest.fixture(scope="session", name="bt")
-async def block_tools_fixture(get_keychain, blockchain_constants, anyio_backend) -> BlockTools:
+async def block_tools_fixture(
+    get_keychain, blockchain_constants, anyio_backend, testrun_uid: str
+) -> AsyncIterator[BlockTools]:
     # Note that this causes a lot of CPU and disk traffic - disk, DB, ports, process creation ...
-    shared_block_tools = await create_block_tools_async(constants=blockchain_constants, keychain=get_keychain)
-    return shared_block_tools
+    async with create_block_tools_async(
+        constants=blockchain_constants, keychain=get_keychain, testrun_uid=testrun_uid
+    ) as shared_block_tools:
+        yield shared_block_tools
 
 
 # if you have a system that has an unusual hostname for localhost and you want
@@ -797,7 +821,7 @@ async def one_node(
 @pytest.fixture(scope="function")
 async def one_node_one_block(
     blockchain_constants: ConsensusConstants,
-) -> AsyncIterator[tuple[Union[FullNodeAPI, FullNodeSimulator], ChiaServer, BlockTools]]:
+) -> AsyncIterator[tuple[FullNodeAPI | FullNodeSimulator, ChiaServer, BlockTools]]:
     async with setup_simulators_and_wallets(1, 0, blockchain_constants) as new:
         (nodes, _, bt) = make_old_setup_simulators_and_wallets(new=new)
         full_node_1 = nodes[0]
@@ -809,7 +833,6 @@ async def one_node_one_block(
             1,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
             genesis_timestamp=uint64(10000),
             time_per_block=10,
         )
@@ -838,7 +861,6 @@ async def two_nodes_one_block(blockchain_constants: ConsensusConstants):
             1,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
             genesis_timestamp=uint64(10000),
             time_per_block=10,
         )
@@ -950,16 +972,21 @@ def get_temp_keyring():
 
 
 @pytest.fixture(scope="function")
-async def get_b_tools_1(get_temp_keyring):
-    return await create_block_tools_async(constants=test_constants_modified, keychain=get_temp_keyring)
+async def get_b_tools_1(get_temp_keyring, testrun_uid: str):
+    async with create_block_tools_async(
+        constants=test_constants_modified, keychain=get_temp_keyring, testrun_uid=testrun_uid
+    ) as bt:
+        yield bt
 
 
 @pytest.fixture(scope="function")
-async def get_b_tools(get_temp_keyring):
-    local_b_tools = await create_block_tools_async(constants=test_constants_modified, keychain=get_temp_keyring)
-    new_config = local_b_tools._config
-    local_b_tools.change_config(new_config)
-    return local_b_tools
+async def get_b_tools(get_temp_keyring, testrun_uid):
+    async with create_block_tools_async(
+        constants=test_constants_modified, keychain=get_temp_keyring, testrun_uid=testrun_uid
+    ) as local_b_tools:
+        new_config = local_b_tools._config
+        local_b_tools.change_config(new_config)
+        yield local_b_tools
 
 
 @pytest.fixture(scope="function")
@@ -1258,13 +1285,15 @@ def populated_temp_file_keyring_fixture() -> Iterator[TempKeyring]:
 
 @pytest.fixture(scope="function")
 async def farmer_harvester_2_simulators_zero_bits_plot_filter(
-    tmp_path: Path, get_temp_keyring: Keychain
+    tmp_path: Path,
+    get_temp_keyring: Keychain,
+    testrun_uid,
 ) -> AsyncIterator[
     tuple[
         FarmerService,
         HarvesterService,
-        Union[FullNodeService, SimulatorFullNodeService],
-        Union[FullNodeService, SimulatorFullNodeService],
+        FullNodeService | SimulatorFullNodeService,
+        FullNodeService | SimulatorFullNodeService,
         BlockTools,
     ]
 ]:
@@ -1274,21 +1303,27 @@ async def farmer_harvester_2_simulators_zero_bits_plot_filter(
     )
 
     async with AsyncExitStack() as async_exit_stack:
-        bt = await create_block_tools_async(
-            zero_bit_plot_filter_consts,
-            keychain=get_temp_keyring,
+        bt = await async_exit_stack.enter_async_context(
+            create_block_tools_async(
+                zero_bit_plot_filter_consts,
+                keychain=get_temp_keyring,
+                testrun_uid=testrun_uid,
+            )
         )
 
         config_overrides: dict[str, int] = {"full_node.max_sync_wait": 0}
 
         bts = [
-            await create_block_tools_async(
-                zero_bit_plot_filter_consts,
-                keychain=get_temp_keyring,
-                num_og_plots=0,
-                num_pool_plots=0,
-                num_non_keychain_plots=0,
-                config_overrides=config_overrides,
+            await async_exit_stack.enter_async_context(
+                create_block_tools_async(
+                    zero_bit_plot_filter_consts,
+                    keychain=get_temp_keyring,
+                    num_og_plots=0,
+                    num_pool_plots=0,
+                    num_non_keychain_plots=0,
+                    config_overrides=config_overrides,
+                    testrun_uid=testrun_uid,
+                )
             )
             for _ in range(2)
         ]

chia/_tests/connection_utils.py

@@ -12,7 +12,7 @@ from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes, serialization
 
 from chia._tests.util.time_out_assert import time_out_assert
-from chia.apis import ApiProtocolRegistry
+from chia.apis import StubMetadataRegistry
 from chia.protocols.outbound_message import NodeType
 from chia.protocols.shared_protocol import default_capabilities
 from chia.server.server import ChiaServer, ssl_context_for_client
@@ -98,7 +98,7 @@ async def add_dummy_connection_wsc(
         100,
         30,
         local_capabilities_for_handshake=default_capabilities[type] + additional_capabilities,
-        class_for_type=ApiProtocolRegistry,
+        stub_metadata_for_type=StubMetadataRegistry,
     )
     await wsc.perform_handshake(server._network_id, dummy_port, type)
     if wsc.incoming_message_task is not None: