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

chia/_tests/pools/test_pool_rpc.py

@@ -8,7 +8,7 @@ from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from pathlib import Path
 from shutil import rmtree
-from typing import Any, Union
+from typing import Any
 
 import pytest
 
@@ -22,7 +22,7 @@ from pytest_mock import MockerFixture
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
 from chia._tests.util.setup_nodes import setup_simulators_and_wallets_service
 from chia._tests.util.time_out_assert import time_out_assert
-from chia.pools.pool_wallet_info import PoolSingletonState, PoolWalletInfo
+from chia.pools.pool_wallet_info import NewPoolWalletInitialTargetState, PoolSingletonState, PoolWalletInfo
 from chia.rpc.rpc_client import ResponseFailureError
 from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.simulator.block_tools import BlockTools, get_plot_dir
@@ -41,6 +41,8 @@ from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_request_types import (
+    CreateNewWallet,
+    CreateNewWalletType,
     DeleteUnconfirmedTransactions,
     GetTransactions,
     GetWalletBalance,
@@ -50,6 +52,7 @@ from chia.wallet.wallet_request_types import (
     PWSelfPool,
     PWStatus,
     SendTransaction,
+    WalletCreationMode,
 )
 from chia.wallet.wallet_rpc_client import WalletRpcClient
 from chia.wallet.wallet_service import WalletService
@@ -211,7 +214,7 @@ async def process_plotnft_create(
 ) -> int:
     wallet_rpc: WalletRpcClient = wallet_test_framework.environments[0].rpc_client
 
-    pre_block_balance_updates: dict[Union[int, str], dict[str, int]] = {
+    pre_block_balance_updates: dict[int | str, dict[str, int]] = {
         1: {
             "confirmed_wallet_balance": 0,
             "unconfirmed_wallet_balance": -1,
@@ -222,7 +225,7 @@ async def process_plotnft_create(
         }
     }
 
-    post_block_balance_updates: dict[Union[int, str], dict[str, int]] = {
+    post_block_balance_updates: dict[int | str, dict[str, int]] = {
         1: {
             "confirmed_wallet_balance": -1,
             "unconfirmed_wallet_balance": 0,
@@ -269,14 +272,20 @@ async def create_new_plotnft(
     async with wallet_state_manager.new_action_scope(wallet_test_framework.tx_config, push=True) as action_scope:
         our_ph = await action_scope.get_puzzle_hash(wallet_state_manager)
 
-    await wallet_rpc.create_new_pool_wallet(
-        target_puzzlehash=our_ph,
-        backup_host="",
-        mode="new",
-        relative_lock_height=uint32(0) if self_pool else LOCK_HEIGHT,
-        state="SELF_POOLING" if self_pool else "FARMING_TO_POOL",
-        pool_url="" if self_pool else "http://pool.example.com",
-        fee=uint64(0),
+    await wallet_rpc.create_new_wallet(
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.POOL_WALLET,
+            initial_target_state=NewPoolWalletInitialTargetState(
+                target_puzzle_hash=None if self_pool else our_ph,
+                state="SELF_POOLING" if self_pool else "FARMING_TO_POOL",
+                pool_url=None if self_pool else "http://pool.example.com",
+                relative_lock_height=None if self_pool else LOCK_HEIGHT,
+            ),
+            mode=WalletCreationMode.NEW,
+            fee=uint64(0),
+            push=True,
+        ),
+        wallet_test_framework.tx_config,
     )
 
     return await process_plotnft_create(
@@ -297,15 +306,22 @@ class TestPoolWalletRpc:
         client, wallet_node, full_node_api, _total_block_rewards, _ = one_wallet_node_and_rpc
         wallet = wallet_node.wallet_state_manager.main_wallet
 
-        async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-            our_ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
         summaries_response = await client.get_wallets(GetWallets(uint16(WalletType.POOLING_WALLET.value)))
         assert len(summaries_response.wallets) == 0
-        creation_tx: TransactionRecord = await client.create_new_pool_wallet(
-            our_ph, "", uint32(0), f"{self_hostname}:5000", "new", "SELF_POOLING", fee
+        create_response = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    state="SELF_POOLING",
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=fee,
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
-        await full_node_api.process_transaction_records(records=[creation_tx])
+        await full_node_api.process_transaction_records(records=create_response.transactions)
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=30)
 
         summaries_response = await client.get_wallets(GetWallets(uint16(WalletType.POOLING_WALLET.value)))
@@ -334,7 +350,7 @@ class TestPoolWalletRpc:
         )
         # It can be one of multiple launcher IDs, due to selecting a different coin
         launcher_id = None
-        for addition in creation_tx.additions:
+        for addition in create_response.transactions[0].additions:
             if addition.puzzle_hash == SINGLETON_LAUNCHER_HASH:
                 launcher_id = addition.name()
                 break
@@ -357,10 +373,22 @@ class TestPoolWalletRpc:
         summaries_response = await client.get_wallets(GetWallets(uint16(WalletType.POOLING_WALLET)))
         assert len(summaries_response.wallets) == 0
 
-        creation_tx: TransactionRecord = await client.create_new_pool_wallet(
-            our_ph, "http://pool.example.com", uint32(10), f"{self_hostname}:5000", "new", "FARMING_TO_POOL", fee
+        create_response = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    target_puzzle_hash=our_ph,
+                    state="FARMING_TO_POOL",
+                    pool_url="http://pool.example.com",
+                    relative_lock_height=uint32(10),
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=fee,
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
-        await full_node_api.process_transaction_records(records=[creation_tx])
+        await full_node_api.process_transaction_records(records=create_response.transactions)
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
         summaries_response = await client.get_wallets(GetWallets(uint16(WalletType.POOLING_WALLET)))
@@ -389,7 +417,7 @@ class TestPoolWalletRpc:
         )
         # It can be one of multiple launcher IDs, due to selecting a different coin
         launcher_id = None
-        for addition in creation_tx.additions:
+        for addition in create_response.transactions[0].additions:
             if addition.puzzle_hash == SINGLETON_LAUNCHER_HASH:
                 launcher_id = addition.name()
                 break
@@ -415,15 +443,38 @@ class TestPoolWalletRpc:
         summaries_response = await client.get_wallets(GetWallets(uint16(WalletType.POOLING_WALLET)))
         assert len(summaries_response.wallets) == 0
 
-        creation_tx: TransactionRecord = await client.create_new_pool_wallet(
-            our_ph_1, "", uint32(0), f"{self_hostname}:5000", "new", "SELF_POOLING", fee
+        create_response_1 = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    state="SELF_POOLING",
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=fee,
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-        creation_tx_2: TransactionRecord = await client.create_new_pool_wallet(
-            our_ph_1, self_hostname, uint32(12), f"{self_hostname}:5000", "new", "FARMING_TO_POOL", fee
+        create_response_2 = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    target_puzzle_hash=our_ph_1,
+                    state="FARMING_TO_POOL",
+                    pool_url=self_hostname,
+                    relative_lock_height=uint32(12),
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=fee,
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
 
-        await full_node_api.process_transaction_records(records=[creation_tx, creation_tx_2])
+        await full_node_api.process_transaction_records(
+            records=[*create_response_1.transactions, *create_response_2.transactions]
+        )
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
         async def pw_created(check_wallet_id: int) -> bool:
@@ -471,10 +522,19 @@ class TestPoolWalletRpc:
 
         for i in range(5):
             await time_out_assert(10, mempool_empty)
-            res = await client.create_new_cat_and_wallet(uint64(20), test=True)
-            assert res["success"]
-            cat_0_id = res["wallet_id"]
-            asset_id = bytes.fromhex(res["asset_id"])
+            create_cat_res = await client.create_new_wallet(
+                CreateNewWallet(
+                    wallet_type=CreateNewWalletType.CAT_WALLET,
+                    mode=WalletCreationMode.NEW,
+                    amount=uint64(20),
+                    test=True,
+                    push=True,
+                ),
+                tx_config=DEFAULT_TX_CONFIG,
+            )
+            cat_0_id = create_cat_res.wallet_id
+            asset_id = create_cat_res.asset_id
+            assert asset_id is not None  # mypy doesn't know about __post_init__
             assert len(asset_id) > 0
             await full_node_api.process_all_wallet_transactions(wallet=wallet)
             await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
@@ -486,10 +546,22 @@ class TestPoolWalletRpc:
         if not trusted:
             for i in range(22):
                 await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-                creation_tx_3: TransactionRecord = await client.create_new_pool_wallet(
-                    our_ph_1, self_hostname, uint32(5), f"{self_hostname}:5000", "new", "FARMING_TO_POOL", fee
+                create_response = await client.create_new_wallet(
+                    CreateNewWallet(
+                        wallet_type=CreateNewWalletType.POOL_WALLET,
+                        initial_target_state=NewPoolWalletInitialTargetState(
+                            target_puzzle_hash=our_ph_1,
+                            state="FARMING_TO_POOL",
+                            pool_url=self_hostname,
+                            relative_lock_height=uint32(5),
+                        ),
+                        mode=WalletCreationMode.NEW,
+                        fee=fee,
+                        push=True,
+                    ),
+                    DEFAULT_TX_CONFIG,
                 )
-                await full_node_api.process_transaction_records(records=[creation_tx_3])
+                await full_node_api.process_transaction_records(records=create_response.transactions)
                 await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
                 full_config = load_config(wallet.wallet_state_manager.root_path, "config.yaml")
@@ -524,10 +596,19 @@ class TestPoolWalletRpc:
         summaries_response = await client.get_wallets(GetWallets(uint16(WalletType.POOLING_WALLET)))
         assert len(summaries_response.wallets) == 0
 
-        creation_tx: TransactionRecord = await client.create_new_pool_wallet(
-            our_ph, "", uint32(0), f"{self_hostname}:5000", "new", "SELF_POOLING", fee
+        create_response = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    state="SELF_POOLING",
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=fee,
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
-        await full_node_api.process_transaction_records(records=[creation_tx])
+        await full_node_api.process_transaction_records(records=create_response.transactions)
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
         status: PoolWalletInfo = (await client.pw_status(PWStatus(uint32(2)))).state
 
@@ -633,10 +714,19 @@ class TestPoolWalletRpc:
         assert len(summaries_response.wallets) == 0
 
         main_expected_confirmed_balance = total_block_rewards
-        creation_tx: TransactionRecord = await client.create_new_pool_wallet(
-            our_ph, "", uint32(0), f"{self_hostname}:5000", "new", "SELF_POOLING", fee
+        create_response = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    state="SELF_POOLING",
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=fee,
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
-        await full_node_api.process_transaction_records(records=[creation_tx])
+        await full_node_api.process_transaction_records(records=create_response.transactions)
         main_expected_confirmed_balance -= fee
         main_expected_confirmed_balance -= 1
         pool_expected_confirmed_balance = 0
@@ -708,10 +798,22 @@ class TestPoolWalletRpc:
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
         summaries_response = await client.get_wallets(GetWallets(uint16(WalletType.POOLING_WALLET)))
         assert len(summaries_response.wallets) == 0
-        creation_tx: TransactionRecord = await client.create_new_pool_wallet(
-            our_ph, "http://123.45.67.89", uint32(10), f"{self_hostname}:5000", "new", "FARMING_TO_POOL", fee
+        create_response = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    target_puzzle_hash=our_ph,
+                    state="FARMING_TO_POOL",
+                    pool_url="http://123.45.67.89",
+                    relative_lock_height=uint32(10),
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=fee,
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
-        await full_node_api.process_transaction_records(records=[creation_tx])
+        await full_node_api.process_transaction_records(records=create_response.transactions)
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
         main_expected_confirmed_balance -= 1
         main_expected_confirmed_balance -= fee
@@ -827,7 +929,7 @@ class TestPoolWalletRpc:
         if fee != 0:
             pytest.skip("need to fix this test for non-zero fees")
 
-        full_node_api, wallet_node, our_ph, _total_block_rewards, client = setup
+        full_node_api, wallet_node, _our_ph, _total_block_rewards, client = setup
         pool_ph = bytes32.zeros
 
         assert wallet_node._wallet_state_manager is not None
@@ -835,20 +937,39 @@ class TestPoolWalletRpc:
         summaries_response = await client.get_wallets(GetWallets(uint16(WalletType.POOLING_WALLET)))
         assert len(summaries_response.wallets) == 0
 
-        creation_tx: TransactionRecord = await client.create_new_pool_wallet(
-            our_ph, "", uint32(0), f"{self_hostname}:5000", "new", "SELF_POOLING", fee
+        create_response_1 = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    state="SELF_POOLING",
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=fee,
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
-        await full_node_api.wait_transaction_records_entered_mempool(records=[creation_tx])
-        creation_tx_2: TransactionRecord = await client.create_new_pool_wallet(
-            our_ph, "", uint32(0), f"{self_hostname}:5001", "new", "SELF_POOLING", fee
+        await full_node_api.wait_transaction_records_entered_mempool(records=create_response_1.transactions)
+        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+        create_response_2 = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    state="SELF_POOLING",
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=fee,
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
 
-        for r in creation_tx.removals:
-            assert r not in creation_tx_2.removals
+        for r in create_response_1.transactions[0].removals:
+            assert r not in create_response_2.transactions[0].removals
 
-        await full_node_api.process_transaction_records(records=[creation_tx_2])
+        await full_node_api.process_transaction_records(records=create_response_2.transactions)
 
-        assert not full_node_api.txs_in_mempool(txs=[creation_tx])
+        assert not full_node_api.txs_in_mempool(txs=create_response_1.transactions)
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
         summaries_response = await client.get_wallets(GetWallets(uint16(WalletType.POOLING_WALLET)))
@@ -927,14 +1048,23 @@ class TestPoolWalletRpc:
 
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
-        creation_tx: TransactionRecord = await client.create_new_pool_wallet(
-            our_ph, "", uint32(0), f"{self_hostname}:5000", "new", "SELF_POOLING", fee
+        create_response = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    state="SELF_POOLING",
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=fee,
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
 
-        await full_node_api.wait_transaction_records_entered_mempool(records=[creation_tx])
+        await full_node_api.wait_transaction_records_entered_mempool(records=create_response.transactions)
 
         await full_node_api.farm_blocks_to_puzzlehash(count=6, farm_to=our_ph, guarantee_transaction_blocks=True)
-        assert not full_node_api.txs_in_mempool(txs=[creation_tx])
+        assert not full_node_api.txs_in_mempool(txs=create_response.transactions)
 
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
@@ -1119,14 +1249,26 @@ class TestPoolWalletRpc:
 
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
-        creation_tx: TransactionRecord = await client.create_new_pool_wallet(
-            pool_a_ph, "https://pool-a.org", uint32(5), f"{self_hostname}:5000", "new", "FARMING_TO_POOL", uint64(fee)
+        create_response = await client.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.POOL_WALLET,
+                initial_target_state=NewPoolWalletInitialTargetState(
+                    target_puzzle_hash=pool_a_ph,
+                    state="FARMING_TO_POOL",
+                    pool_url="https://pool-a.org",
+                    relative_lock_height=uint32(5),
+                ),
+                mode=WalletCreationMode.NEW,
+                fee=uint64(0),
+                push=True,
+            ),
+            DEFAULT_TX_CONFIG,
         )
 
-        await full_node_api.wait_transaction_records_entered_mempool(records=[creation_tx])
+        await full_node_api.wait_transaction_records_entered_mempool(records=create_response.transactions)
 
         await full_node_api.farm_blocks_to_puzzlehash(count=6, farm_to=our_ph, guarantee_transaction_blocks=True)
-        assert not full_node_api.txs_in_mempool(txs=[creation_tx])
+        assert not full_node_api.txs_in_mempool(txs=create_response.transactions)
 
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 

chia/_tests/pools/test_pool_wallet.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Optional, cast
+from typing import Any, cast
 from unittest.mock import MagicMock
 
 import pytest
@@ -27,7 +27,7 @@ class MockStandardWallet:
 
 @dataclass
 class MockWalletStateManager:
-    root_path: Optional[Path] = None
+    root_path: Path | None = None
     config: dict[str, Any] = field(default_factory=dict)
 
 
@@ -43,7 +43,7 @@ class MockPoolWalletConfig:
 
 @dataclass
 class MockPoolState:
-    pool_url: Optional[str]
+    pool_url: str | None
     target_puzzle_hash: bytes32
     owner_pubkey: G1Element
 

chia/_tests/pools/test_wallet_pool_store.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import random
 from dataclasses import dataclass, field
-from typing import Optional
 
 import pytest
 from chia_rs import CoinSpend
@@ -18,9 +17,7 @@ from chia.wallet.util.compute_additions import compute_additions
 from chia.wallet.wallet_pool_store import WalletPoolStore
 
 
-def make_child_solution(
-    coin_spend: Optional[CoinSpend], new_coin: Optional[Coin], seeded_random: random.Random
-) -> CoinSpend:
+def make_child_solution(coin_spend: CoinSpend | None, new_coin: Coin | None, seeded_random: random.Random) -> CoinSpend:
     new_puzzle_hash: bytes32 = bytes32.random(seeded_random)
     solution = "()"
     puzzle = f"(q . ((51 0x{new_puzzle_hash.hex()} 1)))"

chia/_tests/process_junit.py

@@ -7,7 +7,7 @@ from collections import defaultdict
 from dataclasses import dataclass, field
 from pathlib import Path
 from statistics import StatisticsError, mean, stdev
-from typing import Any, Optional, TextIO, final
+from typing import Any, TextIO, final
 
 import click
 import lxml.etree
@@ -126,7 +126,7 @@ def main(
     percent_margin: int,
     randomoji: bool,
     tag: str,
-    result_count_limit: Optional[int],
+    result_count_limit: int | None,
 ) -> None:
     data_type = supported_data_types_by_tag[tag]
 

chia/_tests/rpc/test_rpc_client.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from collections.abc import AsyncIterator, Awaitable
+from collections.abc import AsyncIterator, Awaitable, Callable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Callable, Optional
+from typing import Any
 
 import pytest
 from chia_rs.sized_ints import uint16
@@ -31,8 +31,8 @@ client_fetch_methods = [
 @dataclass
 class InvalidCreateCase:
     id: str
-    root_path: Optional[Path] = None
-    net_config: Optional[dict[str, Any]] = None
+    root_path: Path | None = None
+    net_config: dict[str, Any] | None = None
     marks: Marks = ()
 
 

chia/_tests/rpc/test_rpc_server.py

@@ -7,7 +7,7 @@ import ssl
 import sys
 from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 import aiohttp
 import pytest
@@ -42,7 +42,7 @@ class TestRpcApi:
     service: RpcServiceProtocol
     service_name: str = service_name
 
-    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: dict[str, Any] | None = None) -> list[WsRpcMessage]:
         # just here to satisfy the complete protocol
         return []  # pragma: no cover
 
@@ -73,7 +73,7 @@ class Client:
         async with aiohttp.ClientSession() as session:
             yield cls(session=session, ssl_context=ssl_context, url=url)
 
-    async def request(self, endpoint: str, json: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+    async def request(self, endpoint: str, json: dict[str, Any] | None = None) -> dict[str, Any]:
         if json is None:
             json = {}
 

chia/_tests/simulation/test_simulation.py

@@ -12,8 +12,9 @@ import dns.rdtypes.IN.AAAA
 import pytest
 from chia_rs import BlockRecord
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint8, uint16, uint32, uint64
+from chia_rs.sized_ints import uint16, uint32, uint64
 
+from chia._tests.conftest import test_constants_modified
 from chia._tests.core.node_height import node_height_at_least
 from chia._tests.util.setup_nodes import FullSystem, OldSimulatorsAndWallets
 from chia._tests.util.time_out_assert import time_out_assert
@@ -24,7 +25,7 @@ from chia.full_node.full_node import FullNode
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.protocols.outbound_message import NodeType
 from chia.server.server import ChiaServer
-from chia.simulator.block_tools import BlockTools, create_block_tools_async, test_constants
+from chia.simulator.block_tools import BlockTools, create_block_tools_async
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.keyring import TempKeyring
 from chia.simulator.setup_services import setup_full_node
@@ -36,20 +37,6 @@ from chia.wallet.wallet_node import WalletNode
 
 chiapos_version = importlib.metadata.version("chiapos")
 
-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),
-)
-
 
 # TODO: Ideally, the db_version should be the (parameterized) db_version
 # fixture, to test all versions of the database schema. This doesn't work
@@ -58,15 +45,15 @@ test_constants_modified = test_constants.replace(
 @pytest.fixture(scope="function")
 async def extra_node(self_hostname) -> AsyncIterator[FullNodeAPI | FullNodeSimulator]:
     with TempKeyring() as keychain:
-        b_tools = await create_block_tools_async(constants=test_constants_modified, keychain=keychain)
-        async with setup_full_node(
-            test_constants_modified,
-            "blockchain_test_3.db",
-            self_hostname,
-            b_tools,
-            db_version=2,
-        ) as service:
-            yield service._api
+        async with create_block_tools_async(constants=test_constants_modified, keychain=keychain) as b_tools:
+            async with setup_full_node(
+                test_constants_modified,
+                "blockchain_test_3.db",
+                self_hostname,
+                b_tools,
+                db_version=2,
+            ) as service:
+                yield service._api
 
 
 class FakeDNSResolver:

chia/_tests/solver/test_solver_service.py

@@ -4,7 +4,9 @@ from pathlib import Path
 from unittest.mock import patch
 
 import pytest
-from chia_rs import ConsensusConstants
+from chia_rs import ConsensusConstants, PartialProof
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint64
 
 from chia.protocols.outbound_message import Message
 from chia.protocols.solver_protocol import SolverInfo
@@ -16,12 +18,19 @@ from chia.simulator.setup_services import setup_solver
 @pytest.mark.anyio
 async def test_solver_api_methods(blockchain_constants: ConsensusConstants, tmp_path: Path) -> None:
     with TempKeyring(populate=True) as keychain:
-        bt = await create_block_tools_async(constants=blockchain_constants, keychain=keychain)
-        async with setup_solver(tmp_path, bt, blockchain_constants) as solver_service:
+        async with (
+            create_block_tools_async(constants=blockchain_constants, keychain=keychain) as bt,
+            setup_solver(tmp_path, bt, blockchain_constants) as solver_service,
+        ):
             solver = solver_service._node
             solver_api = solver_service._api
             assert solver_api.ready() is True
-            test_info = SolverInfo(partial_proof=b"test_partial_proof_42")
+            test_info = SolverInfo(
+                PartialProof([uint64(256)] * 64),
+                plot_id=bytes32.fromhex("abababababababababababababababababababababababababababababababab"),
+                strength=uint8(5),
+                size=uint8(28),
+            )
             expected_proof = b"test_proof_data_12345"
             with patch.object(solver, "solve", return_value=expected_proof):
                 api_result = await solver_api.solve(test_info)

chia/_tests/testconfig.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from typing import Literal, Union
+from typing import Literal
 
 # Defaults are conservative.
-parallel: Union[bool, int, Literal["auto"]] = True
+parallel: bool | int | Literal["auto"] = True
 checkout_blocks_and_plots = False
 install_timelord = False
 # NOTE: do not use until the hangs are fixed