chia-blockchain 2.4.4__py3-none-any.whl

chia/_tests/wallet/clawback/config.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+checkout_blocks_and_plots = True

chia/_tests/wallet/clawback/test_clawback_decorator.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import List, Tuple
+
+import pytest
+
+from chia.server.server import ChiaServer
+from chia.simulator.block_tools import BlockTools
+from chia.simulator.full_node_simulator import FullNodeSimulator
+from chia.types.peer_info import PeerInfo
+from chia.wallet.puzzles.clawback.puzzle_decorator import ClawbackPuzzleDecorator
+from chia.wallet.util.puzzle_decorator import PuzzleDecoratorManager
+from chia.wallet.wallet_node import WalletNode
+
+
+@pytest.mark.parametrize(
+    "trusted",
+    [True, False],
+)
+@pytest.mark.anyio
+async def test_missing_decorator(
+    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    trusted: bool,
+    self_hostname: str,
+) -> None:
+    full_nodes, wallets, _ = simulator_and_wallet
+    full_node_api = full_nodes[0]
+    server_1: ChiaServer = full_node_api.full_node.server
+    wallet_node, server_2 = wallets[0]
+    decorator_config = {"clawback_timelock": 3600}
+    wallet_node.wallet_state_manager.decorator_manager = PuzzleDecoratorManager.create([decorator_config])
+    await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+    assert len(wallet_node.wallet_state_manager.decorator_manager.decorator_list) == 0
+
+
+@pytest.mark.parametrize(
+    "trusted",
+    [True, False],
+)
+@pytest.mark.anyio
+async def test_unknown_decorator(
+    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    trusted: bool,
+    self_hostname: str,
+) -> None:
+    full_nodes, wallets, _ = simulator_and_wallet
+    full_node_api = full_nodes[0]
+    server_1: ChiaServer = full_node_api.full_node.server
+    wallet_node, server_2 = wallets[0]
+    decorator_config = {"decorator": "UNKNOWN", "clawback_timelock": 3600}
+    wallet_node.wallet_state_manager.decorator_manager = PuzzleDecoratorManager.create([decorator_config])
+    await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+    assert len(wallet_node.wallet_state_manager.decorator_manager.decorator_list) == 0
+
+
+@pytest.mark.parametrize(
+    "trusted",
+    [True, False],
+)
+@pytest.mark.anyio
+async def test_decorator(
+    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    trusted: bool,
+    self_hostname: str,
+) -> None:
+    full_nodes, wallets, _ = simulator_and_wallet
+    full_node_api = full_nodes[0]
+    server_1: ChiaServer = full_node_api.full_node.server
+    wallet_node, server_2 = wallets[0]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    print(wallet_node.logged_in_fingerprint)
+    decorator_config = {"decorator": "CLAWBACK", "clawback_timelock": 3600}
+    wallet_node.wallet_state_manager.decorator_manager = PuzzleDecoratorManager.create([decorator_config])
+    await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+    assert len(wallet_node.wallet_state_manager.decorator_manager.decorator_list) == 1
+    assert isinstance(wallet_node.wallet_state_manager.decorator_manager.decorator_list[0], ClawbackPuzzleDecorator)
+    clawback_decorator: ClawbackPuzzleDecorator = wallet_node.wallet_state_manager.decorator_manager.decorator_list[0]
+    assert clawback_decorator.time_lock == 3600
+    puzzle = await wallet.get_new_puzzle()
+    assert puzzle == wallet_node.wallet_state_manager.decorator_manager.decorate(puzzle)

chia/_tests/wallet/clawback/test_clawback_lifecycle.py

@@ -0,0 +1,292 @@
+from __future__ import annotations
+
+from typing import Dict, Optional, Tuple
+
+import pytest
+from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+
+from chia._tests.clvm.benchmark_costs import cost_of_spend_bundle
+from chia._tests.clvm.test_puzzles import public_key_for_index, secret_exponent_for_index
+from chia._tests.util.key_tool import KeyTool
+from chia._tests.util.time_out_assert import time_out_assert
+from chia.clvm.spend_sim import CostLogger, SimClient, SpendSim, sim_and_client
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.blockchain_format.program import INFINITE_COST, Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.util.condition_tools import conditions_dict_for_solution, pkm_pairs_for_conditions_dict
+from chia.util.errors import Err
+from chia.util.ints import uint64
+from chia.util.streamable import VersionedBlob
+from chia.wallet.puzzles.clawback.drivers import (
+    create_augmented_cond_puzzle_hash,
+    create_clawback_merkle_tree,
+    create_merkle_puzzle,
+    create_merkle_solution,
+    create_p2_puzzle_hash_puzzle,
+    match_clawback_puzzle,
+)
+from chia.wallet.puzzles.clawback.metadata import ClawbackMetadata, ClawbackVersion
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
+    DEFAULT_HIDDEN_PUZZLE_HASH,
+    calculate_synthetic_secret_key,
+    puzzle_for_pk,
+    solution_for_conditions,
+)
+from chia.wallet.uncurried_puzzle import uncurry_puzzle
+from chia.wallet.util.merkle_utils import check_merkle_proof
+from chia.wallet.util.wallet_types import RemarkDataType
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+ACS = Program.to(1)
+ACS_PH = ACS.get_tree_hash()
+
+
+async def do_spend(
+    sim: SpendSim,
+    sim_client: SimClient,
+    spend_bundle: WalletSpendBundle,
+    expected_result: Tuple[MempoolInclusionStatus, Optional[Err]],
+    cost_logger: Optional[CostLogger] = None,
+    cost_log_msg: str = "",
+) -> int:
+    if cost_logger is not None:
+        spend_bundle = cost_logger.add_cost(cost_log_msg, spend_bundle)
+    result = await sim_client.push_tx(spend_bundle)
+    assert result == expected_result
+    cost = cost_of_spend_bundle(spend_bundle)
+    height = sim.get_height()
+    await sim.farm_block()
+    await time_out_assert(10, sim.get_height, height + 1)
+    return cost
+
+
+class TestClawbackLifecycle:
+    # Helper function
+    def sign_coin_spend(self, coin_spend: CoinSpend, index: int) -> G2Element:
+        synthetic_secret_key: PrivateKey = calculate_synthetic_secret_key(  # noqa
+            PrivateKey.from_bytes(
+                secret_exponent_for_index(index).to_bytes(32, "big"),
+            ),
+            DEFAULT_HIDDEN_PUZZLE_HASH,
+        )
+
+        conditions_dict = conditions_dict_for_solution(coin_spend.puzzle_reveal, coin_spend.solution, INFINITE_COST)
+        signatures = []
+        for pk, msg in pkm_pairs_for_conditions_dict(
+            conditions_dict, coin_spend.coin, DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA
+        ):
+            signature = AugSchemeMPL.sign(synthetic_secret_key, msg)
+            assert AugSchemeMPL.verify(pk, msg, signature)
+            signatures.append(signature)
+        return AugSchemeMPL.aggregate(signatures)
+
+    @pytest.mark.anyio
+    async def test_clawback_spends(self, cost_logger: CostLogger) -> None:
+        async with sim_and_client() as (sim, sim_client):
+            key_lookup = KeyTool()
+            sender_index = 1
+            sender_pk = G1Element.from_bytes(public_key_for_index(sender_index, key_lookup))
+            sender_puz = puzzle_for_pk(sender_pk)
+            sender_ph = sender_puz.get_tree_hash()
+            recipient_index = 2
+            recipient_pk = G1Element.from_bytes(public_key_for_index(recipient_index, key_lookup))
+            recipient_puz = puzzle_for_pk(recipient_pk)
+            recipient_ph = recipient_puz.get_tree_hash()
+
+            await sim.farm_block(sender_ph)
+            starting_coin = (await sim_client.get_coin_records_by_puzzle_hash(sender_ph))[0].coin
+
+            timelock = uint64(100)
+            amount = uint64(10000000)
+            cb_puzzle = create_merkle_puzzle(timelock, sender_ph, recipient_ph)
+            cb_puz_hash = cb_puzzle.get_tree_hash()
+
+            sender_invalid_sol = solution_for_conditions(
+                [
+                    [ConditionOpcode.CREATE_COIN, cb_puz_hash, amount],
+                    [ConditionOpcode.REMARK.value, RemarkDataType.CLAWBACK, b"Test"],
+                ]
+            )
+            sender_sol = solution_for_conditions(
+                [
+                    [ConditionOpcode.CREATE_COIN, cb_puz_hash, amount],
+                    [
+                        ConditionOpcode.REMARK.value,
+                        RemarkDataType.CLAWBACK,
+                        bytes(
+                            VersionedBlob(
+                                ClawbackVersion.V1.value, bytes(ClawbackMetadata(timelock, sender_ph, recipient_ph))
+                            )
+                        ),
+                    ],
+                ]
+            )
+            coin_spend = make_spend(starting_coin, sender_puz, sender_sol)
+            sig = self.sign_coin_spend(coin_spend, sender_index)
+            spend_bundle = WalletSpendBundle([coin_spend], sig)
+
+            await do_spend(
+                sim,
+                sim_client,
+                spend_bundle,
+                (MempoolInclusionStatus.SUCCESS, None),
+                cost_logger=cost_logger,
+                cost_log_msg="Create First Clawback",
+            )
+
+            # Fetch the clawback coin
+            clawback_coin = (await sim_client.get_coin_records_by_puzzle_hash(cb_puz_hash))[0].coin
+            assert clawback_coin.amount == amount
+            # Test match_clawback_puzzle
+            clawback_metadata = match_clawback_puzzle(uncurry_puzzle(sender_puz), sender_puz, sender_sol)
+            assert clawback_metadata is not None
+            assert clawback_metadata.time_lock == timelock
+            assert clawback_metadata.sender_puzzle_hash == sender_ph
+            assert clawback_metadata.recipient_puzzle_hash == recipient_ph
+            clawback_metadata = match_clawback_puzzle(uncurry_puzzle(sender_puz), sender_puz, sender_invalid_sol)
+            assert clawback_metadata is None
+            # Fail an early claim spend
+            recipient_sol = solution_for_conditions([[ConditionOpcode.CREATE_COIN, recipient_ph, amount]])
+            claim_sol = create_merkle_solution(timelock, sender_ph, recipient_ph, recipient_puz, recipient_sol)
+            coin_spend = make_spend(clawback_coin, cb_puzzle, claim_sol)
+            sig = self.sign_coin_spend(coin_spend, recipient_index)
+            spend_bundle = WalletSpendBundle([coin_spend], sig)
+
+            await do_spend(
+                sim,
+                sim_client,
+                spend_bundle,
+                (MempoolInclusionStatus.FAILED, Err.ASSERT_SECONDS_RELATIVE_FAILED),
+                cost_logger=cost_logger,
+                cost_log_msg="Early Claim",
+            )
+
+            # Pass time and submit successful claim spend
+            sim.pass_time(uint64(110))
+            await sim.farm_block()
+            await do_spend(
+                sim,
+                sim_client,
+                spend_bundle,
+                (MempoolInclusionStatus.SUCCESS, None),
+                cost_logger=cost_logger,
+                cost_log_msg="Successful Claim",
+            )
+
+            # check the claimed coin is found
+            claimed_coin = (await sim_client.get_coin_records_by_puzzle_hash(recipient_ph))[0].coin
+            assert claimed_coin.amount == amount
+
+            # create another clawback coin and claw it back to a "cold wallet"
+            cold_ph = bytes32([1] * 32)
+            new_coin = (await sim_client.get_coin_records_by_puzzle_hash(sender_ph, include_spent_coins=False))[0].coin
+            coin_spend = make_spend(new_coin, sender_puz, sender_sol)
+            sig = self.sign_coin_spend(coin_spend, sender_index)
+            spend_bundle = WalletSpendBundle([coin_spend], sig)
+
+            await do_spend(
+                sim,
+                sim_client,
+                spend_bundle,
+                (MempoolInclusionStatus.SUCCESS, None),
+                cost_logger=cost_logger,
+                cost_log_msg="Create Second Clawback",
+            )
+
+            new_cb_coin = (await sim_client.get_coin_records_by_puzzle_hash(cb_puz_hash, include_spent_coins=False))[
+                0
+            ].coin
+
+            sender_claw_sol = solution_for_conditions([[ConditionOpcode.CREATE_COIN, cold_ph, amount]])
+            claw_sol = create_merkle_solution(timelock, sender_ph, recipient_ph, sender_puz, sender_claw_sol)
+            coin_spend = make_spend(new_cb_coin, cb_puzzle, claw_sol)
+            sig = self.sign_coin_spend(coin_spend, sender_index)
+            spend_bundle = WalletSpendBundle([coin_spend], sig)
+
+            await do_spend(
+                sim,
+                sim_client,
+                spend_bundle,
+                (MempoolInclusionStatus.SUCCESS, None),
+                cost_logger=cost_logger,
+                cost_log_msg="Clawback Second Coin to cold ph",
+            )
+
+            clawed_coin = (await sim_client.get_coin_records_by_puzzle_hash(cold_ph))[0].coin
+            assert clawed_coin.amount == amount
+
+    def test_merkle_puzzles(self) -> None:
+        # set up test info
+        timelock = uint64(100)
+        sender_ph = bytes32([1] * 32)
+        recipient_ph = bytes32([2] * 32)
+        # create the puzzles which go into the merkle tree
+        claw_puz_hash = create_p2_puzzle_hash_puzzle(sender_ph).get_tree_hash()
+        claim_puz_hash = create_augmented_cond_puzzle_hash([80, timelock], recipient_ph)
+        # create and check the merkle root and proofs
+        merkle_tree = create_clawback_merkle_tree(timelock, sender_ph, recipient_ph)
+        bad_proof = (1, [claim_puz_hash])
+        clawback_proof = merkle_tree.generate_proof(claw_puz_hash)
+        assert clawback_proof[0] is not None
+        assert len(clawback_proof[1]) == 1
+        assert clawback_proof[1][0] is not None
+
+        claim_proof = merkle_tree.generate_proof(claim_puz_hash)
+        assert claim_proof[0] is not None
+        assert len(claim_proof[1]) == 1
+        assert claim_proof[1][0] is not None
+
+        assert check_merkle_proof(
+            merkle_tree.calculate_root(), claw_puz_hash, (clawback_proof[0], clawback_proof[1][0])
+        )
+        assert check_merkle_proof(merkle_tree.calculate_root(), claim_puz_hash, (claim_proof[0], claim_proof[1][0]))
+        assert not check_merkle_proof(merkle_tree.calculate_root(), claim_puz_hash, bad_proof)
+
+        # check we can't use a timelock less than 1
+        bad_timelock = uint64(0)
+        with pytest.raises(ValueError) as exc_info:
+            create_clawback_merkle_tree(bad_timelock, sender_ph, recipient_ph)
+        assert exc_info.value.args[0] == "Timelock must be at least 1 second"
+
+    def test_clawback_puzzles(self) -> None:
+        timelock = uint64(100)
+        amount = uint64(1000)
+        pk = G1Element()
+        sender_puz = puzzle_for_pk(pk)
+        sender_ph = sender_puz.get_tree_hash()
+        recipient_puz = ACS
+        recipient_ph = ACS_PH
+
+        clawback_puz = create_merkle_puzzle(timelock, sender_ph, recipient_ph)
+
+        sender_sol = solution_for_conditions(
+            [
+                [51, sender_ph, amount],
+            ]
+        )
+        # Test invalid puzzle
+        has_exception = False
+        try:
+            create_merkle_solution(timelock, sender_ph, recipient_ph, Program.to([]), sender_sol)
+        except ValueError:
+            has_exception = True
+        assert has_exception
+        cb_sender_sol = create_merkle_solution(timelock, sender_ph, recipient_ph, sender_puz, sender_sol)
+
+        conds = conditions_dict_for_solution(clawback_puz, cb_sender_sol, INFINITE_COST)
+        assert isinstance(conds, Dict)
+        create_coins = conds[ConditionOpcode.CREATE_COIN]
+        assert len(create_coins) == 1
+        assert create_coins[0].vars[0] == sender_ph
+
+        recipient_sol = Program.to([[51, recipient_ph, amount]])
+        cb_recipient_sol = create_merkle_solution(timelock, sender_ph, recipient_ph, recipient_puz, recipient_sol)
+        clawback_puz.run(cb_recipient_sol)
+        conds = conditions_dict_for_solution(clawback_puz, cb_recipient_sol, INFINITE_COST)
+        assert isinstance(conds, Dict)
+        create_coins = conds[ConditionOpcode.CREATE_COIN]
+        assert len(create_coins) == 1
+        assert create_coins[0].vars[0] == recipient_ph

chia/_tests/wallet/clawback/test_clawback_metadata.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import random
+from typing import List, Tuple
+
+import pytest
+
+from chia.server.server import ChiaServer
+from chia.simulator.block_tools import BlockTools
+from chia.simulator.full_node_simulator import FullNodeSimulator
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.peer_info import PeerInfo
+from chia.util.ints import uint64
+from chia.wallet.puzzles.clawback.metadata import ClawbackMetadata
+from chia.wallet.wallet_node import WalletNode
+
+
+@pytest.mark.parametrize(
+    "trusted",
+    [True, False],
+)
+@pytest.mark.anyio
+async def test_is_recipient(
+    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    trusted: bool,
+    self_hostname: str,
+    seeded_random: random.Random,
+) -> None:
+    full_nodes, wallets, _ = simulator_and_wallet
+    full_node_api = full_nodes[0]
+    server_1: ChiaServer = full_node_api.full_node.server
+    wallet_node, server_2 = wallets[0]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    puzhash_1 = await wallet.get_new_puzzlehash()
+    puzhash_2 = await wallet.get_new_puzzlehash()
+    await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+    invalid_data = ClawbackMetadata(uint64(500), bytes32.random(seeded_random), bytes32.random(seeded_random))
+    both_data = ClawbackMetadata(uint64(500), puzhash_1, puzhash_2)
+    sender_data = ClawbackMetadata(uint64(500), puzhash_1, bytes32.random(seeded_random))
+    recipient_data = ClawbackMetadata(uint64(500), bytes32.random(seeded_random), puzhash_2)
+    # Test invalid metadata
+    has_exception = False
+    try:
+        await invalid_data.is_recipient(wallet_node.wallet_state_manager.puzzle_store)
+    except ValueError:
+        has_exception = True
+    assert has_exception
+    # Test valid metadata
+    assert not (await both_data.is_recipient(wallet_node.wallet_state_manager.puzzle_store))
+    assert await recipient_data.is_recipient(wallet_node.wallet_state_manager.puzzle_store)
+    assert not (await sender_data.is_recipient(wallet_node.wallet_state_manager.puzzle_store))

chia/_tests/wallet/config.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+job_timeout = 40
+checkout_blocks_and_plots = True

chia/_tests/wallet/conftest.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+from contextlib import AsyncExitStack
+from dataclasses import replace
+from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Literal, Optional, Tuple
+
+import pytest
+
+from chia._tests.environments.wallet import WalletEnvironment, WalletState, WalletTestFramework
+from chia._tests.util.setup_nodes import setup_simulators_and_wallets_service
+from chia._tests.wallet.wallet_block_tools import WalletBlockTools
+from chia.consensus.constants import ConsensusConstants
+from chia.consensus.cost_calculator import NPCResult
+from chia.full_node.full_node import FullNode
+from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.peer_info import PeerInfo
+from chia.util.ints import uint32, uint64, uint128
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
+from chia.wallet.wallet_node import Balance
+from chia.wallet.wallet_state_manager import WalletStateManager
+
+
+@pytest.fixture(scope="function", autouse=True)
+def block_is_current_at(monkeypatch: pytest.MonkeyPatch) -> None:
+    def make_new_synced(func: Callable[..., Awaitable[bool]]) -> Any:
+        async def mocked_synced(self: Any, block_is_current_at: Optional[uint64] = uint64(0)) -> bool:
+            return await func(self, block_is_current_at)
+
+        return mocked_synced
+
+    monkeypatch.setattr(WalletStateManager, "synced", make_new_synced(WalletStateManager.synced))
+    monkeypatch.setattr(FullNode, "synced", make_new_synced(FullNode.synced))
+
+
+@pytest.fixture(scope="function", autouse=True)
+async def ignore_block_validation(
+    request: pytest.FixtureRequest,
+    monkeypatch: pytest.MonkeyPatch,
+    # https://anyio.readthedocs.io/en/stable/testing.html#asynchronous-fixtures
+    anyio_backend: str,
+) -> None:
+    """
+    This fixture exists to patch the existing BlockTools with WalletBlockTools and to patch existing code to work with
+    simplified blocks. This is done as a step towards the separation of the wallet into its own self contained project.
+
+    Many consensus concepts are irrelevant when testing wallet code which generally only cares about the mempool's
+    acceptance of its spends and notifications of new representations of the coin set.  One day, it would be good to
+    patch away the full node entirely in favor of the bare minimum logic to emulate the two features above.
+
+    In addition, making truly consensus valid blocks is often slow so shortcutting the logic makes wallet tests as of
+    today (3/4/24) about ~30% faster.
+    """
+    if "standard_block_tools" in request.keywords:
+        return None
+
+    async def validate_block_body(*args: Any, **kwargs: Any) -> Tuple[Literal[None], NPCResult]:
+        return None, args[7]
+
+    def create_wrapper(original_create: Any) -> Any:
+        async def new_create(*args: Any, **kwargs: Any) -> Any:
+            # Modify the config argument directly since it's a mutable dictionary
+            if "config" in kwargs:
+                kwargs["config"]["single_threaded"] = True
+            else:  # pragma: no cover
+                # Nowhere covers this line right now but its entirely possible
+                args[0]["single_threaded"] = True
+
+            # Call the original function with modified arguments
+            full_node = await original_create(*args, **kwargs)
+            return full_node
+
+        return new_create
+
+    monkeypatch.setattr("chia.simulator.block_tools.BlockTools", WalletBlockTools)
+    monkeypatch.setattr(FullNode, "create", create_wrapper(FullNode.create))
+    monkeypatch.setattr("chia.consensus.blockchain.validate_block_body", validate_block_body)
+    monkeypatch.setattr(
+        "chia.consensus.block_header_validation.validate_unfinished_header_block", lambda *_, **__: (uint64(1), None)
+    )
+    monkeypatch.setattr(
+        "chia.wallet.wallet_blockchain.validate_finished_header_block", lambda *_, **__: (uint64(1), None)
+    )
+    monkeypatch.setattr(
+        "chia.consensus.multiprocess_validation.validate_finished_header_block", lambda *_, **__: (uint64(1), None)
+    )
+    monkeypatch.setattr(
+        "chia.consensus.multiprocess_validation.verify_and_get_quality_string", lambda *_, **__: bytes32([0] * 32)
+    )
+    monkeypatch.setattr("chia.consensus.block_record.BlockRecord.sp_total_iters", lambda *_: uint128(0))
+    monkeypatch.setattr("chia.consensus.block_record.BlockRecord.ip_sub_slot_total_iters", lambda *_: uint128(0))
+    monkeypatch.setattr("chia.consensus.make_sub_epoch_summary.calculate_sp_iters", lambda *_: uint64(0))
+    monkeypatch.setattr("chia.consensus.make_sub_epoch_summary.calculate_ip_iters", lambda *_: uint64(0))
+    monkeypatch.setattr("chia.consensus.difficulty_adjustment._get_next_sub_slot_iters", lambda *_: uint64(1))
+    monkeypatch.setattr("chia.consensus.difficulty_adjustment._get_next_difficulty", lambda *_: uint64(1))
+    monkeypatch.setattr("chia.full_node.full_node_store.calculate_sp_interval_iters", lambda *_: uint64(1))
+    monkeypatch.setattr("chia.consensus.pot_iterations.calculate_sp_interval_iters", lambda *_: uint64(1))
+    monkeypatch.setattr("chia.consensus.pot_iterations.calculate_ip_iters", lambda *_: uint64(1))
+    monkeypatch.setattr("chia.consensus.block_record.BlockRecord.sp_sub_slot_total_iters", lambda *_: uint64(1))
+
+
+@pytest.fixture(scope="function", params=[True, False])
+def trusted_full_node(request: Any) -> bool:
+    trusted: bool = request.param
+    return trusted
+
+
+@pytest.fixture(scope="function", params=[True, False])
+def tx_config(request: Any) -> TXConfig:
+    return replace(DEFAULT_TX_CONFIG, reuse_puzhash=request.param)
+
+
+# This fixture automatically creates 4 parametrized tests trusted/untrusted x reuse/new derivations
+# These parameterizations can be skipped by manually specifying "trusted" or "reuse puzhash" to the fixture
+@pytest.fixture(scope="function")
+async def wallet_environments(
+    trusted_full_node: bool,
+    tx_config: TXConfig,
+    blockchain_constants: ConsensusConstants,
+    request: pytest.FixtureRequest,
+) -> AsyncIterator[WalletTestFramework]:
+    if "trusted" in request.param:
+        if request.param["trusted"] != trusted_full_node:
+            pytest.skip("Skipping not specified trusted mode")
+    if "reuse_puzhash" in request.param:
+        if request.param["reuse_puzhash"] != tx_config.reuse_puzhash:
+            pytest.skip("Skipping not specified reuse_puzhash mode")
+    assert len(request.param["blocks_needed"]) == request.param["num_environments"]
+    if "config_overrides" in request.param:
+        config_overrides: Dict[str, Any] = request.param["config_overrides"]
+    else:  # pragma: no cover
+        config_overrides = {}
+    async with setup_simulators_and_wallets_service(
+        1,
+        request.param["num_environments"],
+        blockchain_constants,
+        initial_num_public_keys=config_overrides.get("initial_num_public_keys", 5),
+    ) as wallet_nodes_services:
+        full_node, wallet_services, bt = wallet_nodes_services
+
+        full_node[0]._api.full_node.config = {**full_node[0]._api.full_node.config, **config_overrides}
+
+        wallet_rpc_clients: List[WalletRpcClient] = []
+        async with AsyncExitStack() as astack:
+            for service in wallet_services:
+                service._node.config = {
+                    **service._node.config,
+                    "trusted_peers": (
+                        {full_node[0]._api.server.node_id.hex(): full_node[0]._api.server.node_id.hex()}
+                        if trusted_full_node
+                        else {}
+                    ),
+                    **config_overrides,
+                }
+                service._node.wallet_state_manager.config = service._node.config
+                # Shorten the 10 seconds default value
+                service._node.coin_state_retry_seconds = 2
+                await service._node.server.start_client(
+                    PeerInfo(bt.config["self_hostname"], full_node[0]._api.full_node.server.get_port()), None
+                )
+                wallet_rpc_clients.append(
+                    await astack.enter_async_context(
+                        WalletRpcClient.create_as_context(
+                            bt.config["self_hostname"],
+                            # Semantics guarantee us a non-None value here
+                            service.rpc_server.listen_port,  # type: ignore[union-attr]
+                            service.root_path,
+                            service.config,
+                        )
+                    )
+                )
+
+            wallet_states: List[WalletState] = []
+            for service, blocks_needed in zip(wallet_services, request.param["blocks_needed"]):
+                if blocks_needed > 0:
+                    await full_node[0]._api.farm_blocks_to_wallet(
+                        count=blocks_needed, wallet=service._node.wallet_state_manager.main_wallet
+                    )
+                    await full_node[0]._api.wait_for_wallet_synced(wallet_node=service._node, timeout=20)
+                wallet_states.append(
+                    WalletState(
+                        Balance(
+                            confirmed_wallet_balance=uint128(2_000_000_000_000 * blocks_needed),
+                            unconfirmed_wallet_balance=uint128(2_000_000_000_000 * blocks_needed),
+                            spendable_balance=uint128(2_000_000_000_000 * blocks_needed),
+                            pending_change=uint64(0),
+                            max_send_amount=uint128(2_000_000_000_000 * blocks_needed),
+                            unspent_coin_count=uint32(2 * blocks_needed),
+                            pending_coin_removal_count=uint32(0),
+                        ),
+                    )
+                )
+
+            assert full_node[0].rpc_server is not None
+            client_node = await astack.enter_async_context(
+                FullNodeRpcClient.create_as_context(
+                    bt.config["self_hostname"],
+                    full_node[0].rpc_server.listen_port,
+                    full_node[0].root_path,
+                    full_node[0].config,
+                )
+            )
+            yield WalletTestFramework(
+                full_node[0]._api,
+                client_node,
+                trusted_full_node,
+                [
+                    WalletEnvironment(
+                        service=service,
+                        rpc_client=rpc_client,
+                        wallet_states={uint32(1): wallet_state},
+                    )
+                    for service, rpc_client, wallet_state in zip(wallet_services, wallet_rpc_clients, wallet_states)
+                ],
+                tx_config,
+            )

chia/_tests/wallet/dao_wallet/config.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+checkout_blocks_and_plots = True