chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/_tests/pools/test_pool_config.py

@@ -1,8 +1,5 @@
-# flake8: noqa: E501
 from __future__ import annotations
 
-from chia_rs import AugSchemeMPL, PrivateKey
-
 from chia.pools.pool_config import PoolWalletConfig
 from chia.util.config import create_default_chia_config, load_config, lock_config, save_config
 
@@ -18,9 +15,10 @@ def test_pool_config(tmp_path):
     eg_config.rename(to_config)
     config = load_config(test_root, "test_pool_config.yaml")
 
-    auth_sk: PrivateKey = AugSchemeMPL.key_gen(b"1" * 32)
     d = {
-        "owner_public_key": "84c3fcf9d5581c1ddc702cb0f3b4a06043303b334dd993ab42b2c320ebfa98e5ce558448615b3f69638ba92cf7f43da5",
+        "owner_public_key": (
+            "84c3fcf9d5581c1ddc702cb0f3b4a06043303b334dd993ab42b2c320ebfa98e5ce558448615b3f69638ba92cf7f43da5"
+        ),
         "p2_singleton_puzzle_hash": "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824",
         "payout_instructions": "c2b08e41d766da4116e388357ed957d04ad754623a915f3fd65188a8746cf3e8",
         "pool_url": "localhost",

chia/_tests/pools/test_pool_puzzles_lifecycle.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import copy
-from typing import List
 from unittest import TestCase
 
 import pytest
@@ -205,7 +204,7 @@ class TestPoolPuzzles(TestCase):
         assert launcher_id_to_p2_puzzle_hash(launcher_id, DELAY_TIME, DELAY_PH) == p2_singleton_ph
         assert get_seconds_and_delayed_puzhash_from_p2_singleton_puzzle(p2_singleton_puz) == (DELAY_TIME, DELAY_PH)
         coin_db.farm_coin(p2_singleton_ph, time, 1750000000000)
-        coin_sols: List[CoinSpend] = create_absorb_spend(
+        coin_sols: list[CoinSpend] = create_absorb_spend(
             launcher_coinsol,
             pool_state,
             launcher_coin,
@@ -220,13 +219,13 @@ class TestPoolPuzzles(TestCase):
         )
 
         # ABSORB A NON EXISTENT REWARD (Negative test)
-        last_coinsol: CoinSpend = list(
+        last_coinsol: CoinSpend = next(
             filter(
                 lambda e: e.coin.amount == START_AMOUNT,
                 coin_sols,
             )
-        )[0]
-        coin_sols: List[CoinSpend] = create_absorb_spend(
+        )
+        coin_sols: list[CoinSpend] = create_absorb_spend(
             last_coinsol,
             pool_state,
             launcher_coin,
@@ -236,12 +235,12 @@ class TestPoolPuzzles(TestCase):
             DELAY_PH,  # height
         )
         # pick the larger coin, otherwise we'll fail with Err.MINTING_COIN
-        singleton_coinsol: CoinSpend = list(
+        singleton_coinsol: CoinSpend = next(
             filter(
                 lambda e: e.coin.amount != START_AMOUNT,
                 coin_sols,
             )
-        )[0]
+        )
         # Spend it and hope it fails!
         with pytest.raises(
             BadSpendBundleError, match="condition validation failure Err.ASSERT_ANNOUNCE_CONSUMED_FAILED"
@@ -332,7 +331,7 @@ class TestPoolPuzzles(TestCase):
         # create the farming reward
         coin_db.farm_coin(p2_singleton_ph, time, 1750000000000)
         # generate relevant coin solutions
-        coin_sols: List[CoinSpend] = create_absorb_spend(
+        coin_sols: list[CoinSpend] = create_absorb_spend(
             travel_coinsol,
             target_pool_state,
             launcher_coin,
@@ -349,12 +348,12 @@ class TestPoolPuzzles(TestCase):
         # LEAVE THE WAITING ROOM
         time = CoinTimestamp(20000000, 10000)
         # find the singleton
-        singleton_coinsol: CoinSpend = list(
+        singleton_coinsol: CoinSpend = next(
             filter(
                 lambda e: e.coin.amount == START_AMOUNT,
                 coin_sols,
             )
-        )[0]
+        )
         singleton: Coin = get_most_recent_singleton_coin_from_coin_spend(singleton_coinsol)
         # get the relevant coin solution
         return_coinsol, _ = create_travel_spend(
@@ -383,7 +382,7 @@ class TestPoolPuzzles(TestCase):
         time = CoinTimestamp(20000000, 10005)
         # create the farming  reward
         coin_db.farm_coin(p2_singleton_ph, time, 1750000000000)
-        coin_sols: List[CoinSpend] = create_absorb_spend(
+        coin_sols: list[CoinSpend] = create_absorb_spend(
             return_coinsol,
             pool_state,
             launcher_coin,

chia/_tests/pools/test_pool_rpc.py

@@ -4,10 +4,11 @@ import asyncio
 import contextlib
 import logging
 import tempfile
+from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from pathlib import Path
 from shutil import rmtree
-from typing import Any, AsyncIterator, Dict, List, Tuple
+from typing import Any, Union
 
 import pytest
 
@@ -15,12 +16,14 @@ import pytest
 from _pytest.fixtures import SubRequest
 from chia_rs import G1Element
 
+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.consensus.constants import ConsensusConstants
 from chia.pools.pool_puzzles import SINGLETON_LAUNCHER_HASH
 from chia.pools.pool_wallet_info import PoolSingletonState, PoolWalletInfo
 from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.simulator.block_tools import BlockTools, get_plot_dir
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import ReorgProtocol
@@ -34,15 +37,21 @@ from chia.util.config import load_config
 from chia.util.ints import uint32, uint64
 from chia.wallet.derive_keys import find_authentication_sk, find_owner_sk
 from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.util.transaction_type import TransactionType
 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_state_manager import WalletStateManager
 
 # TODO: Compare deducted fees in all tests against reported total_fee
 
+# limit to plain consensus mode for all tests
+pytestmark = [pytest.mark.limit_consensus_modes(reason="irrelevant")]
+
 log = logging.getLogger(__name__)
 FEE_AMOUNT = uint64(29_000)
 MAX_WAIT_SECS = 30  # A high value for WAIT_SECS is useful when paused in the debugger
+LOCK_HEIGHT = uint32(5)
 
 
 def get_pool_plot_dir() -> Path:
@@ -91,7 +100,7 @@ def fee(trusted: bool) -> uint64:
     return uint64(0)
 
 
-OneWalletNodeAndRpc = Tuple[WalletRpcClient, Any, FullNodeSimulator, int, BlockTools]
+OneWalletNodeAndRpc = tuple[WalletRpcClient, Any, FullNodeSimulator, int, BlockTools]
 
 
 @pytest.fixture(scope="function")
@@ -129,17 +138,17 @@ async def one_wallet_node_and_rpc(
         await client.await_closed()
 
 
-Setup = Tuple[FullNodeSimulator, WalletNode, bytes32, int, WalletRpcClient]
+Setup = tuple[FullNodeSimulator, WalletNode, bytes32, int, WalletRpcClient]
 
 
 @pytest.fixture(scope="function")
 async def setup(
-    one_wallet_and_one_simulator_services: Tuple[List[SimulatorFullNodeService], List[WalletService], BlockTools],
+    one_wallet_and_one_simulator_services: tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools],
     trusted: bool,
     self_hostname: str,
 ) -> AsyncIterator[Setup]:
     rmtree(get_pool_plot_dir(), ignore_errors=True)
-    [full_node_service], [wallet_service], bt = one_wallet_and_one_simulator_services
+    [full_node_service], [wallet_service], _bt = one_wallet_and_one_simulator_services
     full_node_api: FullNodeSimulator = full_node_service._api
     wallet_node = wallet_service._node
     our_ph_record = await wallet_node.wallet_state_manager.get_unused_derivation_record(uint32(1), hardened=True)
@@ -180,6 +189,90 @@ async def setup(
     await client.await_closed()
 
 
+async def verify_pool_state(wallet_rpc: WalletRpcClient, w_id: int, expected_state: PoolSingletonState) -> bool:
+    pw_status: PoolWalletInfo = (await wallet_rpc.pw_status(w_id))[0]
+    return pw_status.current.state == expected_state.value
+
+
+async def process_plotnft_create(
+    wallet_test_framework: WalletTestFramework, expected_state: PoolSingletonState, second_nft: bool = False
+) -> int:
+    wallet_rpc: WalletRpcClient = wallet_test_framework.environments[0].rpc_client
+
+    pre_block_balance_updates: dict[Union[int, str], dict[str, int]] = {
+        1: {
+            "confirmed_wallet_balance": 0,
+            "unconfirmed_wallet_balance": -1,
+            "<=#spendable_balance": 1,
+            "<=#max_send_amount": 1,
+            ">=#pending_change": 1,  # any amount increase
+            "pending_coin_removal_count": 1,
+        }
+    }
+
+    post_block_balance_updates: dict[Union[int, str], dict[str, int]] = {
+        1: {
+            "confirmed_wallet_balance": -1,
+            "unconfirmed_wallet_balance": 0,
+            ">=#spendable_balance": 1,
+            ">=#max_send_amount": 1,
+            "<=#pending_change": 1,  # any amount decrease
+            "<=#pending_coin_removal_count": 1,
+        },
+    }
+
+    if second_nft:
+        post_block = post_block_balance_updates | {
+            2: {
+                "set_remainder": True,  # TODO: sometimes this fails with pending_coin_removal_count
+            },
+            3: {"init": True, "unspent_coin_count": 1},
+        }
+    else:
+        post_block = post_block_balance_updates | {2: {"init": True, "unspent_coin_count": 1}}
+
+    await wallet_test_framework.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates=pre_block_balance_updates,
+                post_block_balance_updates=post_block,
+            )
+        ]
+    )
+
+    summaries_response = await wallet_rpc.get_wallets(WalletType.POOLING_WALLET)
+    assert len(summaries_response) == 2 if second_nft else 1
+    wallet_id: int = summaries_response[-1]["id"]
+
+    await verify_pool_state(wallet_rpc, wallet_id, expected_state=expected_state)
+    return wallet_id
+
+
+async def create_new_plotnft(
+    wallet_test_framework: WalletTestFramework, self_pool: bool = False, second_nft: bool = False
+) -> int:
+    wallet_state_manager: WalletStateManager = wallet_test_framework.environments[0].wallet_state_manager
+    wallet_rpc: WalletRpcClient = wallet_test_framework.environments[0].rpc_client
+
+    our_ph = await wallet_state_manager.main_wallet.get_new_puzzlehash()
+
+    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),
+    )
+
+    return await process_plotnft_create(
+        wallet_test_framework=wallet_test_framework,
+        expected_state=PoolSingletonState.SELF_POOLING if self_pool else PoolSingletonState.FARMING_TO_POOL,
+        second_nft=second_nft,
+    )
+
+
 class TestPoolWalletRpc:
     @pytest.mark.anyio
     async def test_create_new_pool_wallet_self_farm(
@@ -188,7 +281,7 @@ class TestPoolWalletRpc:
         fee: uint64,
         self_hostname: str,
     ) -> None:
-        client, wallet_node, full_node_api, total_block_rewards, _ = one_wallet_node_and_rpc
+        client, wallet_node, full_node_api, _total_block_rewards, _ = one_wallet_node_and_rpc
         wallet = wallet_node.wallet_state_manager.main_wallet
 
         our_ph = await wallet.get_new_puzzlehash()
@@ -216,8 +309,8 @@ class TestPoolWalletRpc:
         assert status.current.relative_lock_height == 0
         assert status.current.version == 1
         # Check that config has been written properly
-        full_config: Dict[str, Any] = load_config(wallet.wallet_state_manager.root_path, "config.yaml")
-        pool_list: List[Dict[str, Any]] = full_config["pool"]["pool_list"]
+        full_config: dict[str, Any] = load_config(wallet.wallet_state_manager.root_path, "config.yaml")
+        pool_list: list[dict[str, Any]] = full_config["pool"]["pool_list"]
         assert len(pool_list) == 1
         pool_config = pool_list[0]
         assert (
@@ -240,7 +333,7 @@ class TestPoolWalletRpc:
         fee: uint64,
         self_hostname: str,
     ) -> None:
-        client, wallet_node, full_node_api, total_block_rewards, _ = one_wallet_node_and_rpc
+        client, wallet_node, full_node_api, _total_block_rewards, _ = one_wallet_node_and_rpc
         wallet = wallet_node.wallet_state_manager.main_wallet
 
         our_ph = await wallet.get_new_puzzlehash()
@@ -269,8 +362,8 @@ class TestPoolWalletRpc:
         assert status.current.relative_lock_height == 10
         assert status.current.version == 1
         # Check that config has been written properly
-        full_config: Dict[str, Any] = load_config(wallet.wallet_state_manager.root_path, "config.yaml")
-        pool_list: List[Dict[str, Any]] = full_config["pool"]["pool_list"]
+        full_config: dict[str, Any] = load_config(wallet.wallet_state_manager.root_path, "config.yaml")
+        pool_list: list[dict[str, Any]] = full_config["pool"]["pool_list"]
         assert len(pool_list) == 1
         pool_config = pool_list[0]
         assert (
@@ -294,7 +387,7 @@ class TestPoolWalletRpc:
         fee: uint64,
         self_hostname: str,
     ) -> None:
-        client, wallet_node, full_node_api, total_block_rewards, _ = one_wallet_node_and_rpc
+        client, wallet_node, full_node_api, _total_block_rewards, _ = one_wallet_node_and_rpc
 
         wallet = wallet_node.wallet_state_manager.main_wallet
 
@@ -333,7 +426,7 @@ class TestPoolWalletRpc:
             assert status_3.current.state == PoolSingletonState.SELF_POOLING.value
 
         full_config = load_config(wallet.wallet_state_manager.root_path, "config.yaml")
-        pool_list: List[Dict[str, Any]] = full_config["pool"]["pool_list"]
+        pool_list: list[dict[str, Any]] = full_config["pool"]["pool_list"]
         assert len(pool_list) == 2
 
         assert len(await wallet_node.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0
@@ -403,7 +496,7 @@ class TestPoolWalletRpc:
     async def test_absorb_self(
         self, one_wallet_node_and_rpc: OneWalletNodeAndRpc, fee: uint64, self_hostname: str
     ) -> None:
-        client, wallet_node, full_node_api, total_block_rewards, _ = one_wallet_node_and_rpc
+        client, wallet_node, full_node_api, _total_block_rewards, _ = one_wallet_node_and_rpc
         bt = full_node_api.bt
 
         wallet = wallet_node.wallet_state_manager.main_wallet
@@ -430,19 +523,28 @@ class TestPoolWalletRpc:
                 guarantee_transaction_block=True,
             )
 
-            for block in blocks[-3:]:
-                await full_node_api.full_node.add_block(block)
+            await add_blocks_in_batches(blocks[-3:], full_node_api.full_node)
             await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
             bal = await client.get_wallet_balance(2)
             assert bal["confirmed_wallet_balance"] == 2 * 1_750_000_000_000
 
             # Claim 2 * 1.75, and farm a new 1.75
-            absorb_txs: List[TransactionRecord] = (await client.pw_absorb_rewards(2, uint64(fee)))["transactions"]
+            absorb_txs: list[TransactionRecord] = (await client.pw_absorb_rewards(2, uint64(fee)))["transactions"]
             await full_node_api.wait_transaction_records_entered_mempool(records=absorb_txs)
             await full_node_api.farm_blocks_to_puzzlehash(count=2, farm_to=our_ph, guarantee_transaction_blocks=True)
             await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
             await full_node_api.check_transactions_confirmed(wallet_node.wallet_state_manager, absorb_txs)
+            assert (
+                len(
+                    [
+                        tx
+                        for tx in await wallet_node.wallet_state_manager.tx_store.get_all_transactions()
+                        if TransactionType(tx.type) is TransactionType.INCOMING_TX and tx.amount == 1_750_000_000_000
+                    ]
+                )
+                == 2
+            )
             new_status: PoolWalletInfo = (await client.pw_status(2))[0]
             assert status.current == new_status.current
             assert status.tip_singleton_coin_id != new_status.tip_singleton_coin_id
@@ -450,7 +552,7 @@ class TestPoolWalletRpc:
             assert bal["confirmed_wallet_balance"] == 1 * 1_750_000_000_000
 
             # Claim another 1.75
-            absorb_txs1: List[TransactionRecord] = (await client.pw_absorb_rewards(2, uint64(fee)))["transactions"]
+            absorb_txs1: list[TransactionRecord] = (await client.pw_absorb_rewards(2, uint64(fee)))["transactions"]
 
             await full_node_api.wait_transaction_records_entered_mempool(records=absorb_txs1)
 
@@ -520,8 +622,7 @@ class TestPoolWalletRpc:
             )
 
             block_count = 3
-            for block in blocks[-block_count:]:
-                await full_node_api.full_node.add_block(block)
+            await add_blocks_in_batches(blocks[-block_count:], full_node_api.full_node)
             await full_node_api.farm_blocks_to_puzzlehash(count=1, guarantee_transaction_blocks=True)
             await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
@@ -534,7 +635,7 @@ class TestPoolWalletRpc:
             assert bal["confirmed_wallet_balance"] == pool_expected_confirmed_balance
 
             # Claim
-            absorb_txs: List[TransactionRecord] = (await client.pw_absorb_rewards(2, uint64(fee), 1))["transactions"]
+            absorb_txs: list[TransactionRecord] = (await client.pw_absorb_rewards(2, uint64(fee), 1))["transactions"]
             await full_node_api.process_transaction_records(records=absorb_txs)
             main_expected_confirmed_balance -= fee
             main_expected_confirmed_balance += 1_750_000_000_000
@@ -592,8 +693,7 @@ class TestPoolWalletRpc:
             )
 
             block_count = 3
-            for block in blocks[-block_count:]:
-                await full_node_api.full_node.add_block(block)
+            await add_blocks_in_batches(blocks[-block_count:], full_node_api.full_node)
             await full_node_api.farm_blocks_to_puzzlehash(count=1, guarantee_transaction_blocks=True)
             await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
             # Pooled plots don't have balance
@@ -603,7 +703,7 @@ class TestPoolWalletRpc:
 
             # Claim block_count * 1.75
             ret = await client.pw_absorb_rewards(2, uint64(fee))
-            absorb_txs: List[TransactionRecord] = ret["transactions"]
+            absorb_txs: list[TransactionRecord] = ret["transactions"]
             if fee == 0:
                 assert ret["fee_transaction"] is None
             else:
@@ -652,8 +752,7 @@ class TestPoolWalletRpc:
                         block_list_input=blocks,
                         guarantee_transaction_block=True,
                     )
-                    for block in blocks[-2:]:
-                        await full_node_api.full_node.add_block(block)
+                    await add_blocks_in_batches(blocks[-2:], full_node_api.full_node)
                     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
                     # Absorb the farmed reward
@@ -679,8 +778,8 @@ 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
-        pool_ph = bytes32([0] * 32)
+        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
 
@@ -715,7 +814,7 @@ class TestPoolWalletRpc:
         assert status_2.target is None
 
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-        join_pool: Dict[str, Any] = await client.pw_join_pool(
+        join_pool: dict[str, Any] = await client.pw_join_pool(
             wallet_id,
             pool_ph,
             "https://pool.example.com",
@@ -727,7 +826,7 @@ class TestPoolWalletRpc:
         assert join_pool_tx is not None
         await full_node_api.wait_transaction_records_entered_mempool(records=[join_pool_tx])
 
-        join_pool_2: Dict[str, Any] = await client.pw_join_pool(
+        join_pool_2: dict[str, Any] = await client.pw_join_pool(
             wallet_id_2, pool_ph, "https://pool.example.com", uint32(10), uint64(fee)
         )
         assert join_pool_2["success"]
@@ -760,8 +859,8 @@ class TestPoolWalletRpc:
     @pytest.mark.anyio
     async def test_leave_pool(self, setup: Setup, fee: uint64, self_hostname: str) -> None:
         """This tests self-pooling -> pooling -> escaping -> self pooling"""
-        full_node_api, wallet_node, our_ph, total_block_rewards, client = setup
-        pool_ph = bytes32([0] * 32)
+        full_node_api, wallet_node, our_ph, _total_block_rewards, client = setup
+        pool_ph = bytes32.zeros
 
         assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0
 
@@ -820,7 +919,7 @@ class TestPoolWalletRpc:
 
         await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
-        leave_pool_tx: Dict[str, Any] = await client.pw_self_pool(wallet_id, uint64(fee))
+        leave_pool_tx: dict[str, Any] = await client.pw_self_pool(wallet_id, uint64(fee))
         assert leave_pool_tx["transaction"].wallet_id == wallet_id
         assert leave_pool_tx["transaction"].amount == 1
         await full_node_api.wait_transaction_records_entered_mempool(records=leave_pool_tx["transactions"])
@@ -856,80 +955,95 @@ class TestPoolWalletRpc:
         await time_out_assert(timeout=MAX_WAIT_SECS, function=status_is_self_pooling)
         assert len(await wallet_node.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0
 
+    @pytest.mark.parametrize(
+        "wallet_environments",
+        [
+            {
+                "num_environments": 1,
+                "blocks_needed": [10],
+            }
+        ],
+        indirect=True,
+    )
     @pytest.mark.anyio
-    async def test_change_pools(self, setup: Setup, fee: uint64, self_hostname: str) -> None:
+    async def test_change_pools(
+        self,
+        fee: uint64,
+        wallet_environments: WalletTestFramework,
+    ) -> None:
         """This tests Pool A -> escaping -> Pool B"""
-        full_node_api, wallet_node, our_ph, total_block_rewards, client = setup
-        pool_a_ph = bytes32([0] * 32)
-        pool_b_ph = bytes32([0] * 32)
-
-        WAIT_SECS = 200
-        assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0
-
-        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", fee
-        )
-
-        await full_node_api.wait_transaction_records_entered_mempool(records=[creation_tx])
-
-        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])
-
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
-        summaries_response = await client.get_wallets(WalletType.POOLING_WALLET)
-        assert len(summaries_response) == 1
-        wallet_id: int = summaries_response[0]["id"]
-        status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]
-
-        assert status.current.state == PoolSingletonState.FARMING_TO_POOL.value
-        assert status.target is None
-
-        async def status_is_farming_to_pool() -> bool:
-            await full_node_api.farm_blocks_to_puzzlehash(count=1, farm_to=our_ph, guarantee_transaction_blocks=True)
-            pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]
-            return pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value
+        wallet_state_manager: WalletStateManager = wallet_environments.environments[0].wallet_state_manager
+        wallet_rpc: WalletRpcClient = wallet_environments.environments[0].rpc_client
 
-        await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)
+        wallet_state_manager.config["reuse_public_key_for_change"][
+            str(wallet_state_manager.root_pubkey.get_fingerprint())
+        ] = wallet_environments.tx_config.reuse_puzhash
 
-        pw_info: PoolWalletInfo = (await client.pw_status(wallet_id))[0]
-        assert pw_info.current.pool_url == "https://pool-a.org"
-        assert pw_info.current.relative_lock_height == 5
+        # Create a farming plotnft to url http://pool.example.com
+        wallet_id = await create_new_plotnft(wallet_environments)
 
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+        # Join a different pool
         join_pool_tx: TransactionRecord = (
-            await client.pw_join_pool(
+            await wallet_rpc.pw_join_pool(
                 wallet_id,
-                pool_b_ph,
+                bytes32.zeros,
                 "https://pool-b.org",
-                uint32(10),
+                LOCK_HEIGHT,
                 uint64(fee),
             )
         )["transaction"]
         assert join_pool_tx is not None
 
-        async def status_is_leaving() -> bool:
-            await full_node_api.farm_blocks_to_puzzlehash(count=1, farm_to=our_ph, guarantee_transaction_blocks=True)
-            pw_status: PoolWalletInfo = (await client.pw_status(wallet_id))[0]
-            return pw_status.current.state == PoolSingletonState.LEAVING_POOL.value
+        await wallet_environments.full_node.farm_blocks_to_puzzlehash(count=1, guarantee_transaction_blocks=True)
+        await verify_pool_state(wallet_rpc, wallet_id, PoolSingletonState.LEAVING_POOL)
+        await wallet_environments.full_node.farm_blocks_to_puzzlehash(
+            count=LOCK_HEIGHT + 2, guarantee_transaction_blocks=True
+        )
+        await wallet_environments.full_node.wait_for_wallet_synced(
+            wallet_node=wallet_environments.environments[0].node, timeout=20
+        )
 
-        await time_out_assert(timeout=WAIT_SECS, function=status_is_leaving)
-        pw_info = (await client.pw_status(wallet_id))[0]
+        async def farm_blocks_until_state(
+            state: PoolSingletonState,
+            wallet_rpc: WalletRpcClient,
+            wallet_id: int,
+            full_node: FullNodeSimulator,
+            wallet_node: WalletNode,
+            max_blocks: int = 10 * (LOCK_HEIGHT + 2),
+        ) -> bool:
+            block_chunk = LOCK_HEIGHT + 2
+            total_blocks_farmed = 0
+            while total_blocks_farmed < max_blocks:
+                await full_node.farm_blocks_to_puzzlehash(count=block_chunk, guarantee_transaction_blocks=True)
+                total_blocks_farmed += block_chunk
+                print(f"Checking state after {total_blocks_farmed} blocks")
+
+                await full_node.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+                pw_status: PoolWalletInfo = (await wallet_rpc.pw_status(wallet_id))[0]
+                if pw_status.current.state == state.value:
+                    return True
+            return False
+
+        assert await farm_blocks_until_state(
+            PoolSingletonState.FARMING_TO_POOL,
+            wallet_rpc,
+            wallet_id,
+            wallet_environments.full_node,
+            wallet_environments.environments[0].node,
+        )
 
-        await time_out_assert(timeout=WAIT_SECS, function=status_is_farming_to_pool)
-        pw_info = (await client.pw_status(wallet_id))[0]
-        assert pw_info.current.pool_url == "https://pool-b.org"
-        assert pw_info.current.relative_lock_height == 10
-        assert len(await wallet_node.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(2)) == 0
+        pw_status: PoolWalletInfo = (await wallet_rpc.pw_status(wallet_id))[0]
+        assert pw_status.current.state == PoolSingletonState.FARMING_TO_POOL.value
+        assert pw_status.current.pool_url == "https://pool-b.org"
+        assert pw_status.current.relative_lock_height == LOCK_HEIGHT
 
     @pytest.mark.anyio
     async def test_change_pools_reorg(self, setup: Setup, fee: uint64, self_hostname: str) -> None:
         """This tests Pool A -> escaping -> reorg -> escaping -> Pool B"""
-        full_node_api, wallet_node, our_ph, total_block_rewards, client = setup
-        pool_a_ph = bytes32([0] * 32)
-        pool_b_ph = bytes32([0] * 32)
+        full_node_api, wallet_node, our_ph, _total_block_rewards, client = setup
+        pool_a_ph = bytes32.zeros
+        pool_b_ph = bytes32.zeros
         WAIT_SECS = 30
 
         assert len(await client.get_wallets(WalletType.POOLING_WALLET)) == 0
@@ -965,7 +1079,7 @@ class TestPoolWalletRpc:
         assert pw_info.current.pool_url == "https://pool-a.org"
         assert pw_info.current.relative_lock_height == 5
 
-        join_pool_txs: List[TransactionRecord] = (
+        join_pool_txs: list[TransactionRecord] = (
             await client.pw_join_pool(
                 wallet_id,
                 pool_b_ph,
@@ -995,8 +1109,7 @@ class TestPoolWalletRpc:
             transaction_data=next(tx.spend_bundle for tx in join_pool_txs if tx.spend_bundle is not None),
         )
 
-        for block in more_blocks[-3:]:
-            await full_node_api.full_node.add_block(block)
+        await add_blocks_in_batches(more_blocks[-3:], full_node_api.full_node)
 
         await time_out_assert(timeout=WAIT_SECS, function=status_is_leaving_no_blocks)