chia-blockchain 2.5.2rc2__py3-none-any.whl → 2.5.3rc1__py3-none-any.whl

chia/_tests/wallet/db_wallet/test_dl_wallet.py

@@ -1,24 +1,19 @@
 from __future__ import annotations
 
-import asyncio
 import dataclasses
-from typing import Any
 
 import pytest
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
-from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.data_layer.data_layer_errors import LauncherCoinNotFoundError
 from chia.data_layer.data_layer_wallet import DataLayerWallet, Mirror
 from chia.simulator.full_node_simulator import FullNodeSimulator
-from chia.simulator.simulator_protocol import FarmNewBlockProtocol, ReorgProtocol
+from chia.simulator.simulator_protocol import ReorgProtocol
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.types.peer_info import PeerInfo
-from chia.util.ints import uint32, uint64
-from chia.util.timing import adjusted_timeout
 from chia.wallet.db_wallet.db_wallet_puzzles import create_mirror_puzzle
 from chia.wallet.util.merkle_tree import MerkleTree
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
@@ -38,91 +33,97 @@ async def is_singleton_confirmed(dl_wallet: DataLayerWallet, lid: bytes32) -> bo
 
 class TestDLWallet:
     @pytest.mark.parametrize(
-        "trusted,reuse_puzhash",
+        "wallet_environments",
         [
-            (True, True),
-            (True, False),
-            (False, False),
+            {
+                "num_environments": 1,
+                "blocks_needed": [2],
+            }
         ],
+        indirect=True,
     )
+    @pytest.mark.limit_consensus_modes
     @pytest.mark.anyio
-    async def test_initial_creation(
-        self, self_hostname: str, simulator_and_wallet: OldSimulatorsAndWallets, trusted: bool, reuse_puzhash: bool
-    ) -> None:
-        full_nodes, wallets, _ = simulator_and_wallet
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node_0, server_0 = wallets[0]
-        wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
-
-        if trusted:
-            wallet_node_0.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node_0.config["trusted_peers"] = {}
-
-        await server_0.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-
-        funds = await full_node_api.farm_blocks_to_wallet(count=2, wallet=wallet_0)
-
-        await time_out_assert(10, wallet_0.get_unconfirmed_balance, funds)
-        await time_out_assert(10, wallet_0.get_confirmed_balance, funds)
+    async def test_initial_creation(self, wallet_environments: WalletTestFramework) -> None:
+        env = wallet_environments.environments[0]
+        env.wallet_aliases = {
+            "xch": 1,
+            "dl": 2,
+        }
 
-        async with wallet_node_0.wallet_state_manager.lock:
-            dl_wallet = await DataLayerWallet.create_new_dl_wallet(wallet_node_0.wallet_state_manager)
+        dl_wallet = await DataLayerWallet.create_new_dl_wallet(env.wallet_state_manager)
 
         nodes = [Program.to("thing").get_tree_hash(), Program.to([8]).get_tree_hash()]
         current_tree = MerkleTree(nodes)
         current_root = current_tree.calculate_root()
 
-        for i in range(0, 2):
+        fee = uint64(1_999_999_999_999)
+
+        for i in range(2):
             async with dl_wallet.wallet_state_manager.new_action_scope(
-                DEFAULT_TX_CONFIG.override(reuse_puzhash=reuse_puzhash), push=True
+                wallet_environments.tx_config, push=True
             ) as action_scope:
                 launcher_id = await dl_wallet.generate_new_reporter(
                     current_root,
                     action_scope,
-                    fee=uint64(1999999999999),
+                    fee=fee,
                 )
 
             assert await dl_wallet.get_latest_singleton(launcher_id) is not None
-            await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
 
-            await time_out_assert(15, is_singleton_confirmed, True, dl_wallet, launcher_id)
+            await wallet_environments.process_pending_states(
+                [
+                    WalletStateTransition(
+                        pre_block_balance_updates={
+                            "xch": {
+                                "unconfirmed_wallet_balance": -fee - 1,
+                                "spendable_balance": -fee - 1,
+                                "max_send_amount": -fee - 1,
+                                "pending_coin_removal_count": 2,  # creation + launcher
+                            },
+                            "dl": {"init": True} if i == 0 else {},
+                        },
+                        post_block_balance_updates={
+                            "xch": {
+                                "confirmed_wallet_balance": -fee - 1,
+                                "spendable_balance": 0,
+                                "max_send_amount": 0,
+                                "pending_coin_removal_count": -2,
+                                "unspent_coin_count": -2,
+                            },
+                            "dl": {
+                                "unspent_coin_count": 1,
+                            },
+                        },
+                    ),
+                ]
+            )
 
-        await time_out_assert(10, wallet_0.get_unconfirmed_balance, 0)
-        await time_out_assert(10, wallet_0.get_confirmed_balance, 0)
+            await time_out_assert(15, is_singleton_confirmed, True, dl_wallet, launcher_id)
 
         new_puz = await dl_wallet.get_new_puzzle()
         assert new_puz
 
     @pytest.mark.parametrize(
-        "trusted",
-        [True, False],
+        "wallet_environments",
+        [
+            {
+                "num_environments": 1,
+                "blocks_needed": [2],
+            }
+        ],
+        indirect=True,
     )
+    @pytest.mark.limit_consensus_modes
     @pytest.mark.anyio
-    async def test_get_owned_singletons(
-        self, self_hostname: str, simulator_and_wallet: OldSimulatorsAndWallets, trusted: bool
-    ) -> None:
-        full_nodes, wallets, _ = simulator_and_wallet
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node_0, server_0 = wallets[0]
-        wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
-
-        if trusted:
-            wallet_node_0.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node_0.config["trusted_peers"] = {}
-
-        await server_0.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-
-        funds = await full_node_api.farm_blocks_to_wallet(count=2, wallet=wallet_0)
-
-        await time_out_assert(10, wallet_0.get_unconfirmed_balance, funds)
-        await time_out_assert(10, wallet_0.get_confirmed_balance, funds)
+    async def test_get_owned_singletons(self, wallet_environments: WalletTestFramework) -> None:
+        env = wallet_environments.environments[0]
+        env.wallet_aliases = {
+            "xch": 1,
+            "dl": 2,
+        }
 
-        async with wallet_node_0.wallet_state_manager.lock:
-            dl_wallet = await DataLayerWallet.create_new_dl_wallet(wallet_node_0.wallet_state_manager)
+        dl_wallet = await DataLayerWallet.create_new_dl_wallet(env.wallet_state_manager)
 
         nodes = [Program.to("thing").get_tree_hash(), Program.to([8]).get_tree_hash()]
         current_tree = MerkleTree(nodes)
@@ -130,16 +131,44 @@ class TestDLWallet:
 
         expected_launcher_ids = set()
 
-        for i in range(0, 2):
-            async with dl_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-                launcher_id = await dl_wallet.generate_new_reporter(
-                    current_root, action_scope, fee=uint64(1999999999999)
-                )
+        fee = uint64(1_999_999_999_999)
+
+        for i in range(2):
+            async with dl_wallet.wallet_state_manager.new_action_scope(
+                wallet_environments.tx_config, push=True
+            ) as action_scope:
+                launcher_id = await dl_wallet.generate_new_reporter(current_root, action_scope, fee=fee)
             expected_launcher_ids.add(launcher_id)
 
             assert await dl_wallet.get_latest_singleton(launcher_id) is not None
 
-            await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
+            await wallet_environments.process_pending_states(
+                [
+                    WalletStateTransition(
+                        pre_block_balance_updates={
+                            "xch": {
+                                "unconfirmed_wallet_balance": -fee - 1,
+                                "spendable_balance": -fee - 1,
+                                "max_send_amount": -fee - 1,
+                                "pending_coin_removal_count": 2,  # creation + launcher
+                            },
+                            "dl": {"init": True} if i == 0 else {},
+                        },
+                        post_block_balance_updates={
+                            "xch": {
+                                "confirmed_wallet_balance": -fee - 1,
+                                "spendable_balance": 0,
+                                "max_send_amount": 0,
+                                "pending_coin_removal_count": -2,
+                                "unspent_coin_count": -2,
+                            },
+                            "dl": {
+                                "unspent_coin_count": 1,
+                            },
+                        },
+                    ),
+                ]
+            )
 
             await time_out_assert(15, is_singleton_confirmed, True, dl_wallet, launcher_id)
 
@@ -147,40 +176,34 @@ class TestDLWallet:
         owned_launcher_ids = sorted(singleton.launcher_id for singleton in owned_singletons)
         assert owned_launcher_ids == sorted(expected_launcher_ids)
 
-    @pytest.mark.parametrize("trusted", [True, False])
+    @pytest.mark.parametrize(
+        "wallet_environments",
+        [
+            {
+                "num_environments": 2,
+                "blocks_needed": [1, 1],
+            }
+        ],
+        indirect=True,
+    )
+    @pytest.mark.limit_consensus_modes
     @pytest.mark.anyio
-    async def test_tracking_non_owned(
-        self, self_hostname: str, two_wallet_nodes: OldSimulatorsAndWallets, trusted: bool
-    ) -> None:
-        full_nodes, wallets, _ = two_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node_0, server_0 = wallets[0]
-        wallet_node_1, server_1 = wallets[1]
-        wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
-
-        if trusted:
-            wallet_node_0.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-            wallet_node_1.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node_0.config["trusted_peers"] = {}
-            wallet_node_1.config["trusted_peers"] = {}
-
-        await server_0.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        await server_1.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-
-        funds = await full_node_api.farm_blocks_to_wallet(count=2, wallet=wallet_0)
-
-        await time_out_assert(10, wallet_0.get_unconfirmed_balance, funds)
-        await time_out_assert(10, wallet_0.get_confirmed_balance, funds)
-
-        async with wallet_node_0.wallet_state_manager.lock:
-            dl_wallet_0 = await DataLayerWallet.create_new_dl_wallet(wallet_node_0.wallet_state_manager)
+    async def test_tracking_non_owned(self, wallet_environments: WalletTestFramework) -> None:
+        env_0 = wallet_environments.environments[0]
+        env_1 = wallet_environments.environments[1]
+        env_0.wallet_aliases = {
+            "xch": 1,
+            "dl": 2,
+        }
+        env_1.wallet_aliases = {
+            "xch": 1,
+            "dl": 2,
+        }
 
-        async with wallet_node_1.wallet_state_manager.lock:
-            dl_wallet_1 = await DataLayerWallet.create_new_dl_wallet(wallet_node_1.wallet_state_manager)
+        dl_wallet_0 = await DataLayerWallet.create_new_dl_wallet(env_0.wallet_state_manager)
+        dl_wallet_1 = await DataLayerWallet.create_new_dl_wallet(env_1.wallet_state_manager)
 
-        peer = wallet_node_1.get_full_node_peer()
+        peer = env_1.node.get_full_node_peer()
 
         # Test tracking a launcher id that does not exist
         with pytest.raises(LauncherCoinNotFoundError):
@@ -190,25 +213,72 @@ class TestDLWallet:
         current_tree = MerkleTree(nodes)
         current_root = current_tree.calculate_root()
 
-        async with dl_wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        async with dl_wallet_0.wallet_state_manager.new_action_scope(
+            wallet_environments.tx_config, push=True
+        ) as action_scope:
             launcher_id = await dl_wallet_0.generate_new_reporter(current_root, action_scope)
 
         assert await dl_wallet_0.get_latest_singleton(launcher_id) is not None
-        await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
+
+        await wallet_environments.process_pending_states(
+            [
+                WalletStateTransition(
+                    pre_block_balance_updates={
+                        "xch": {
+                            "unconfirmed_wallet_balance": -1,
+                            "<=#spendable_balance": -1,
+                            "<=#max_send_amount": -1,
+                            ">=#pending_change": 1,
+                            "pending_coin_removal_count": 1,  # creation + launcher
+                        },
+                        "dl": {
+                            "init": True,
+                        },
+                    },
+                    post_block_balance_updates={
+                        "xch": {
+                            "confirmed_wallet_balance": -1,
+                            ">=#spendable_balance": 0,
+                            ">=#max_send_amount": 0,
+                            "<=#pending_change": -1,
+                            "pending_coin_removal_count": -1,
+                        },
+                        "dl": {
+                            "unspent_coin_count": 1,
+                        },
+                    },
+                ),
+            ]
+        )
 
         await time_out_assert(15, is_singleton_confirmed, True, dl_wallet_0, launcher_id)
-        await asyncio.sleep(0.5)
 
         await dl_wallet_1.track_new_launcher_id(launcher_id, peer)
         await time_out_assert(15, is_singleton_confirmed, True, dl_wallet_1, launcher_id)
-        await asyncio.sleep(0.5)
 
-        for i in range(0, 5):
+        for _ in range(5):
             new_root = MerkleTree([Program.to("root").get_tree_hash()]).calculate_root()
-            async with dl_wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            async with dl_wallet_0.wallet_state_manager.new_action_scope(
+                wallet_environments.tx_config, push=True
+            ) as action_scope:
                 await dl_wallet_0.create_update_state_spend(launcher_id, new_root, action_scope)
 
-            await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
+            await wallet_environments.process_pending_states(
+                [
+                    WalletStateTransition(
+                        pre_block_balance_updates={
+                            "dl": {
+                                "pending_coin_removal_count": 1,
+                            },
+                        },
+                        post_block_balance_updates={
+                            "dl": {
+                                "pending_coin_removal_count": -1,
+                            },
+                        },
+                    ),
+                ]
+            )
 
             await time_out_assert(15, is_singleton_confirmed, True, dl_wallet_0, launcher_id)
 
@@ -226,47 +296,67 @@ class TestDLWallet:
         await time_out_assert(15, do_tips_match, True)
 
     @pytest.mark.parametrize(
-        "trusted",
-        [True, False],
+        "wallet_environments",
+        [
+            {
+                "num_environments": 2,
+                "blocks_needed": [1, 1],
+            }
+        ],
+        indirect=True,
     )
+    @pytest.mark.limit_consensus_modes
     @pytest.mark.anyio
-    async def test_lifecycle(
-        self, self_hostname: str, simulator_and_wallet: OldSimulatorsAndWallets, trusted: bool
-    ) -> None:
-        full_nodes, wallets, _ = simulator_and_wallet
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node_0, server_0 = wallets[0]
-        wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
-
-        if trusted:
-            wallet_node_0.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node_0.config["trusted_peers"] = {}
-
-        await server_0.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-
-        funds = await full_node_api.farm_blocks_to_wallet(count=5, wallet=wallet_0)
-
-        await time_out_assert(10, wallet_0.get_unconfirmed_balance, funds)
-        await time_out_assert(10, wallet_0.get_confirmed_balance, funds)
+    async def test_lifecycle(self, wallet_environments: WalletTestFramework) -> None:
+        env = wallet_environments.environments[0]
+        env.wallet_aliases = {
+            "xch": 1,
+            "dl": 2,
+        }
 
-        async with wallet_node_0.wallet_state_manager.lock:
-            dl_wallet = await DataLayerWallet.create_new_dl_wallet(wallet_node_0.wallet_state_manager)
+        dl_wallet = await DataLayerWallet.create_new_dl_wallet(env.wallet_state_manager)
 
         nodes = [Program.to("thing").get_tree_hash(), Program.to([8]).get_tree_hash()]
         current_tree = MerkleTree(nodes)
         current_root = current_tree.calculate_root()
 
-        async with dl_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
+        async with dl_wallet.wallet_state_manager.new_action_scope(
+            wallet_environments.tx_config, push=True
+        ) as action_scope:
             launcher_id = await dl_wallet.generate_new_reporter(current_root, action_scope)
 
         assert await dl_wallet.get_latest_singleton(launcher_id) is not None
 
-        [std_record] = await wallet_node_0.wallet_state_manager.add_pending_transactions(
-            action_scope.side_effects.transactions
+        await wallet_environments.process_pending_states(
+            [
+                WalletStateTransition(
+                    pre_block_balance_updates={
+                        "xch": {
+                            "unconfirmed_wallet_balance": -1,
+                            "<=#spendable_balance": -1,
+                            "<=#max_send_amount": -1,
+                            ">=#pending_change": 1,
+                            "pending_coin_removal_count": 1,  # creation + launcher
+                        },
+                        "dl": {
+                            "init": True,
+                        },
+                    },
+                    post_block_balance_updates={
+                        "xch": {
+                            "confirmed_wallet_balance": -1,
+                            ">=#spendable_balance": 0,
+                            ">=#max_send_amount": 0,
+                            "<=#pending_change": -1,
+                            "pending_coin_removal_count": -1,
+                        },
+                        "dl": {
+                            "unspent_coin_count": 1,
+                        },
+                    },
+                ),
+            ]
         )
-        await full_node_api.process_transaction_records(records=[std_record])
 
         await time_out_assert(15, is_singleton_confirmed, True, dl_wallet, launcher_id)
 
@@ -276,19 +366,23 @@ class TestDLWallet:
 
         new_root = MerkleTree([Program.to("root").get_tree_hash()]).calculate_root()
 
-        async with dl_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
+        fee = uint64(1_999_999_999_999)
+
+        async with dl_wallet.wallet_state_manager.new_action_scope(
+            wallet_environments.tx_config, push=True
+        ) as action_scope:
             await dl_wallet.generate_signed_transaction(
                 [previous_record.lineage_proof.amount],
                 [previous_record.inner_puzzle_hash],
                 action_scope,
                 launcher_id=previous_record.launcher_id,
                 new_root_hash=new_root,
-                fee=uint64(1999999999999),
+                fee=fee,
             )
         assert action_scope.side_effects.transactions[0].spend_bundle is not None
         with pytest.raises(ValueError, match="is currently pending"):
             async with dl_wallet.wallet_state_manager.new_action_scope(
-                DEFAULT_TX_CONFIG, push=False
+                wallet_environments.tx_config, push=False
             ) as failed_action_scope:
                 await dl_wallet.generate_signed_transaction(
                     [previous_record.lineage_proof.amount],
@@ -301,7 +395,7 @@ class TestDLWallet:
                             if rem.amount == 1
                         )
                     },
-                    fee=uint64(1999999999999),
+                    fee=fee,
                 )
 
         new_record = await dl_wallet.get_latest_singleton(launcher_id)
@@ -309,13 +403,38 @@ class TestDLWallet:
         assert new_record != previous_record
         assert not new_record.confirmed
 
-        txs = await wallet_node_0.wallet_state_manager.add_pending_transactions(action_scope.side_effects.transactions)
-        await full_node_api.process_transaction_records(records=txs)
+        await wallet_environments.process_pending_states(
+            [
+                WalletStateTransition(
+                    pre_block_balance_updates={
+                        "xch": {
+                            "unconfirmed_wallet_balance": -fee,
+                            # these match exactly because of our change from the creation
+                            "spendable_balance": -fee,
+                            "max_send_amount": -fee,
+                            "pending_coin_removal_count": 2,
+                        },
+                        "dl": {
+                            "pending_coin_removal_count": 1,
+                        },
+                    },
+                    post_block_balance_updates={
+                        "xch": {
+                            "confirmed_wallet_balance": -fee,
+                            "spendable_balance": 0,
+                            "max_send_amount": 0,
+                            "pending_coin_removal_count": -2,
+                            "unspent_coin_count": -2,
+                        },
+                        "dl": {
+                            "pending_coin_removal_count": -1,
+                        },
+                    },
+                ),
+            ]
+        )
 
         await time_out_assert(15, is_singleton_confirmed, True, dl_wallet, launcher_id)
-        await time_out_assert(10, wallet_0.get_unconfirmed_balance, funds - 2000000000000)
-        await time_out_assert(10, wallet_0.get_confirmed_balance, funds - 2000000000000)
-        await asyncio.sleep(0.5)
 
         dl_coin_record = await dl_wallet.wallet_state_manager.coin_store.get_coin_record(new_record.coin_id)
         assert dl_coin_record is not None
@@ -324,217 +443,33 @@ class TestDLWallet:
         previous_record = await dl_wallet.get_latest_singleton(launcher_id)
 
         new_root = MerkleTree([Program.to("new root").get_tree_hash()]).calculate_root()
-        async with dl_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
+        async with dl_wallet.wallet_state_manager.new_action_scope(
+            wallet_environments.tx_config, push=True
+        ) as action_scope:
             await dl_wallet.create_update_state_spend(launcher_id, new_root, action_scope)
         new_record = await dl_wallet.get_latest_singleton(launcher_id)
         assert new_record is not None
         assert new_record != previous_record
         assert not new_record.confirmed
 
-        txs = await wallet_node_0.wallet_state_manager.add_pending_transactions(action_scope.side_effects.transactions)
-        await full_node_api.process_transaction_records(records=txs)
-
-        await time_out_assert(15, is_singleton_confirmed, True, dl_wallet, launcher_id)
-        await asyncio.sleep(0.5)
-
-    @pytest.mark.skip(reason="maybe no longer relevant, needs to be rewritten at least")
-    @pytest.mark.parametrize(
-        "trusted",
-        [True, False],
-    )
-    @pytest.mark.anyio
-    async def test_rebase(
-        self,
-        self_hostname: str,
-        two_wallet_nodes: OldSimulatorsAndWallets,
-        trusted: bool,
-    ) -> None:  # pragma: no cover
-        full_nodes, wallets, _ = two_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node_0, server_0 = wallets[0]
-        wallet_node_1, server_1 = wallets[1]
-        wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
-        wallet_1 = wallet_node_1.wallet_state_manager.main_wallet
-
-        if trusted:
-            wallet_node_0.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-            wallet_node_1.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node_0.config["trusted_peers"] = {}
-            wallet_node_1.config["trusted_peers"] = {}
-
-        await server_0.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        await server_1.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-
-        funds = await full_node_api.farm_blocks_to_wallet(count=5, wallet=wallet_0)
-        await full_node_api.farm_blocks_to_wallet(count=5, wallet=wallet_1)
-
-        await time_out_assert(10, wallet_0.get_unconfirmed_balance, funds)
-        await time_out_assert(10, wallet_0.get_confirmed_balance, funds)
-        await time_out_assert(10, wallet_1.get_unconfirmed_balance, funds)
-        await time_out_assert(10, wallet_1.get_confirmed_balance, funds)
-
-        async with wallet_node_0.wallet_state_manager.lock:
-            dl_wallet_0 = await DataLayerWallet.create_new_dl_wallet(wallet_node_0.wallet_state_manager)
-
-        async with wallet_node_1.wallet_state_manager.lock:
-            dl_wallet_1 = await DataLayerWallet.create_new_dl_wallet(wallet_node_1.wallet_state_manager)
-
-        nodes = [Program.to("thing").get_tree_hash(), Program.to([8]).get_tree_hash()]
-        current_tree = MerkleTree(nodes)
-        current_root = current_tree.calculate_root()
-
-        async def is_singleton_confirmed(wallet: DataLayerWallet, lid: bytes32) -> bool:
-            latest_singleton = await wallet.get_latest_singleton(lid)
-            if latest_singleton is None:
-                return False
-            return latest_singleton.confirmed
-
-        async with dl_wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
-            launcher_id = await dl_wallet_0.generate_new_reporter(current_root, action_scope)
-
-        initial_record = await dl_wallet_0.get_latest_singleton(launcher_id)
-        assert initial_record is not None
-
-        [std_record] = await wallet_node_0.wallet_state_manager.add_pending_transactions(
-            action_scope.side_effects.transactions
-        )
-        await asyncio.wait_for(
-            full_node_api.process_transaction_records(records=[std_record]),
-            timeout=adjusted_timeout(timeout=15),
-        )
-
-        await time_out_assert(15, is_singleton_confirmed, True, dl_wallet_0, launcher_id)
-        await asyncio.sleep(0.5)
-
-        peer = wallet_node_1.get_full_node_peer()
-        await dl_wallet_1.track_new_launcher_id(launcher_id, peer)
-        await time_out_assert(15, is_singleton_confirmed, True, dl_wallet_1, launcher_id)
-        current_record = await dl_wallet_1.get_latest_singleton(launcher_id)
-        assert current_record is not None
-        await asyncio.sleep(0.5)
-
-        # Because these have the same fee, the one that gets pushed first will win
-        async with dl_wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-            await dl_wallet_1.create_update_state_spend(
-                launcher_id, current_record.root, action_scope, fee=uint64(2000000000000)
-            )
-        report_txs = action_scope.side_effects.transactions
-        record_1 = await dl_wallet_1.get_latest_singleton(launcher_id)
-        assert record_1 is not None
-        assert current_record != record_1
-        async with dl_wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-            await dl_wallet_0.create_update_state_spend(
-                launcher_id, bytes32.zeros, action_scope, fee=uint64(2000000000000)
-            )
-        update_txs = action_scope.side_effects.transactions
-        record_0 = await dl_wallet_0.get_latest_singleton(launcher_id)
-        assert record_0 is not None
-        assert initial_record != record_0
-        assert record_0 != record_1
-
-        report_txs = await wallet_node_1.wallet_state_manager.add_pending_transactions(report_txs)
-
-        await asyncio.wait_for(
-            full_node_api.wait_transaction_records_entered_mempool(records=report_txs),
-            timeout=adjusted_timeout(timeout=15),
-        )
-
-        update_txs = await wallet_node_0.wallet_state_manager.add_pending_transactions(update_txs)
-
-        await asyncio.wait_for(
-            full_node_api.process_transaction_records(records=report_txs), timeout=adjusted_timeout(timeout=15)
-        )
-
-        funds -= 2000000000001
-
-        async def is_singleton_generation(wallet: DataLayerWallet, launcher_id: bytes32, generation: int) -> bool:
-            latest = await wallet.get_latest_singleton(launcher_id)
-            if latest is not None and latest.generation == generation:
-                return True
-            return False
-
-        next_generation = current_record.generation + 2
-        await time_out_assert(15, is_singleton_generation, True, dl_wallet_0, launcher_id, next_generation)
-
-        for i in range(0, 2):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
-            await asyncio.sleep(0.5)
-
-        await time_out_assert(15, is_singleton_confirmed, True, dl_wallet_0, launcher_id)
-        await time_out_assert(15, is_singleton_generation, True, dl_wallet_1, launcher_id, next_generation)
-        latest = await dl_wallet_0.get_latest_singleton(launcher_id)
-        assert latest is not None
-        assert latest == (await dl_wallet_1.get_latest_singleton(launcher_id))
-        await time_out_assert(15, wallet_0.get_confirmed_balance, funds)
-        await time_out_assert(15, wallet_0.get_unconfirmed_balance, funds)
-        assert (
-            len(
-                await dl_wallet_0.get_history(
-                    launcher_id, min_generation=uint32(next_generation - 1), max_generation=uint32(next_generation - 1)
-                )
-            )
-            == 1
-        )
-        for tx in update_txs:
-            assert await wallet_node_0.wallet_state_manager.tx_store.get_transaction_record(tx.name) is None
-        assert await dl_wallet_0.get_singleton_record(record_0.coin_id) is None
-
-        async with dl_wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
-            await dl_wallet_0.create_update_state_spend(
-                launcher_id, bytes32([1] * 32), action_scope, fee=uint64(2000000000000)
-            )
-        record_1 = await dl_wallet_0.get_latest_singleton(launcher_id)
-        assert record_1 is not None
-        update_txs_1 = await wallet_node_0.wallet_state_manager.add_pending_transactions(
-            action_scope.side_effects.transactions
-        )
-        await full_node_api.wait_transaction_records_entered_mempool(update_txs_1)
-
-        # Delete any trace of that update
-        await wallet_node_0.wallet_state_manager.dl_store.delete_singleton_record(record_1.coin_id)
-        for tx in update_txs_1:
-            await wallet_node_0.wallet_state_manager.tx_store.delete_transaction_record(tx.name)
-
-        async with dl_wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
-            await dl_wallet_0.create_update_state_spend(launcher_id, bytes32([2] * 32), action_scope)
-        record_0 = await dl_wallet_0.get_latest_singleton(launcher_id)
-        assert record_0 is not None
-        assert record_0 != record_1
-
-        update_txs_0 = await wallet_node_0.wallet_state_manager.add_pending_transactions(
-            action_scope.side_effects.transactions
-        )
-
-        await asyncio.wait_for(
-            full_node_api.process_transaction_records(records=update_txs_1), timeout=adjusted_timeout(timeout=15)
+        await wallet_environments.process_pending_states(
+            [
+                WalletStateTransition(
+                    pre_block_balance_updates={
+                        "dl": {
+                            "pending_coin_removal_count": 1,
+                        },
+                    },
+                    post_block_balance_updates={
+                        "dl": {
+                            "pending_coin_removal_count": -1,
+                        },
+                    },
+                ),
+            ]
         )
 
-        async def does_singleton_have_root(wallet: DataLayerWallet, lid: bytes32, root: bytes32) -> bool:
-            latest_singleton = await wallet.get_latest_singleton(lid)
-            if latest_singleton is None:
-                return False
-            return latest_singleton.root == root
-
-        funds -= 2000000000000
-
-        next_generation += 1
-        await time_out_assert(15, is_singleton_generation, True, dl_wallet_0, launcher_id, next_generation)
-        await time_out_assert(15, does_singleton_have_root, True, dl_wallet_0, launcher_id, bytes32([1] * 32))
-        await time_out_assert(15, wallet_0.get_confirmed_balance, funds)
-        await time_out_assert(15, wallet_0.get_unconfirmed_balance, funds)
-        assert (
-            len(
-                await dl_wallet_0.get_history(
-                    launcher_id, min_generation=uint32(next_generation), max_generation=uint32(next_generation)
-                )
-            )
-            == 1
-        )
-        for tx in update_txs_0:
-            assert await wallet_node_0.wallet_state_manager.tx_store.get_transaction_record(tx.name) is None
-        assert await dl_wallet_0.get_singleton_record(record_0.coin_id) is None
+        await time_out_assert(15, is_singleton_confirmed, True, dl_wallet, launcher_id)
 
 
 async def is_singleton_confirmed_and_root(dl_wallet: DataLayerWallet, lid: bytes32, root: bytes32) -> bool:
@@ -548,54 +483,132 @@ async def is_singleton_confirmed_and_root(dl_wallet: DataLayerWallet, lid: bytes
 
 
 @pytest.mark.parametrize(
-    "trusted",
-    [True, False],
+    "wallet_environments",
+    [
+        {
+            "num_environments": 2,
+            "blocks_needed": [3, 1],
+        }
+    ],
+    indirect=True,
 )
+@pytest.mark.limit_consensus_modes
 @pytest.mark.anyio
-async def test_mirrors(wallets_prefarm: Any, trusted: bool) -> None:
-    (
-        [wallet_node_1, _],
-        [wallet_node_2, _],
-        full_node_api,
-    ) = wallets_prefarm
-    assert wallet_node_1.wallet_state_manager is not None
-    assert wallet_node_2.wallet_state_manager is not None
-    wsm_1 = wallet_node_1.wallet_state_manager
-    wsm_2 = wallet_node_2.wallet_state_manager
-
-    async with wsm_1.lock:
-        dl_wallet_1 = await DataLayerWallet.create_new_dl_wallet(wsm_1)
-    async with wsm_2.lock:
-        dl_wallet_2 = await DataLayerWallet.create_new_dl_wallet(wsm_2)
-
-    async with dl_wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+async def test_mirrors(wallet_environments: WalletTestFramework) -> None:
+    env_1 = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
+    env_1.wallet_aliases = {
+        "xch": 1,
+        "dl": 2,
+    }
+    env_2.wallet_aliases = {
+        "xch": 1,
+        "dl": 2,
+    }
+
+    dl_wallet_1 = await DataLayerWallet.create_new_dl_wallet(env_1.wallet_state_manager)
+    dl_wallet_2 = await DataLayerWallet.create_new_dl_wallet(env_2.wallet_state_manager)
+
+    async with dl_wallet_1.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
         launcher_id_1 = await dl_wallet_1.generate_new_reporter(bytes32.zeros, action_scope)
-    assert await dl_wallet_1.get_latest_singleton(launcher_id_1) is not None
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_1, launcher_id_1, bytes32.zeros)
 
-    async with dl_wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with dl_wallet_2.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
         launcher_id_2 = await dl_wallet_2.generate_new_reporter(bytes32.zeros, action_scope)
+
+    assert await dl_wallet_1.get_latest_singleton(launcher_id_1) is not None
     assert await dl_wallet_2.get_latest_singleton(launcher_id_2) is not None
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "unconfirmed_wallet_balance": -1,
+                        "<=#spendable_balance": -1,
+                        "<=#max_send_amount": -1,
+                        ">=#pending_change": 1,
+                        "pending_coin_removal_count": 1,  # creation + launcher
+                    },
+                    "dl": {
+                        "init": True,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "confirmed_wallet_balance": -1,
+                        ">=#spendable_balance": 0,
+                        ">=#max_send_amount": 0,
+                        "<=#pending_change": -1,
+                        "pending_coin_removal_count": -1,
+                    },
+                    "dl": {
+                        "unspent_coin_count": 1,
+                    },
+                },
+            ),
+        ]
+        * 2
+    )
+
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_1, launcher_id_1, bytes32.zeros)
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_2, launcher_id_2, bytes32.zeros)
 
-    peer_1 = wallet_node_1.get_full_node_peer()
+    peer_1 = env_1.node.get_full_node_peer()
     await dl_wallet_1.track_new_launcher_id(launcher_id_2, peer_1)
-    peer_2 = wallet_node_2.get_full_node_peer()
+    await env_1.change_balances({"dl": {"unspent_coin_count": 1}})
+    peer_2 = env_2.node.get_full_node_peer()
     await dl_wallet_2.track_new_launcher_id(launcher_id_1, peer_2)
+    await env_2.change_balances({"dl": {"unspent_coin_count": 1}})
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_1, launcher_id_2, bytes32.zeros)
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_2, launcher_id_1, bytes32.zeros)
 
-    async with dl_wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        await dl_wallet_1.create_new_mirror(
-            launcher_id_2, uint64(3), [b"foo", b"bar"], action_scope, fee=uint64(1_999_999_999_999)
-        )
+    fee = uint64(1_999_999_999_999)
+    mirror_amount = uint64(3)
+
+    async with dl_wallet_1.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
+        await dl_wallet_1.create_new_mirror(launcher_id_2, mirror_amount, [b"foo", b"bar"], action_scope, fee=fee)
+
     additions: list[Coin] = []
     for tx in action_scope.side_effects.transactions:
         if tx.spend_bundle is not None:
             additions.extend(tx.spend_bundle.additions())
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "unconfirmed_wallet_balance": -fee - mirror_amount,
+                        # these match exactly because of our change from the creation
+                        "<=#spendable_balance": -fee - mirror_amount,
+                        "<=#max_send_amount": -fee - mirror_amount,
+                        ">=#pending_change": 1,
+                        "pending_coin_removal_count": 3,
+                    },
+                    "dl": {},
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "confirmed_wallet_balance": -fee - mirror_amount,
+                        ">=#spendable_balance": 1,
+                        ">=#max_send_amount": 1,
+                        "<=#pending_change": -1,
+                        "pending_coin_removal_count": -3,
+                        "unspent_coin_count": -2,
+                    },
+                    "dl": {
+                        "unspent_coin_count": 1,
+                    },
+                },
+            ),
+        ]
+    )
 
     mirror_coin: Coin = next(c for c in additions if c.puzzle_hash == create_mirror_puzzle().get_tree_hash())
     mirror = Mirror(
@@ -604,16 +617,52 @@ async def test_mirrors(wallets_prefarm: Any, trusted: bool) -> None:
         uint64(mirror_coin.amount),
         [b"foo", b"bar"],
         True,
-        full_node_api.full_node.blockchain.get_peak_height(),
+        wallet_environments.full_node.full_node.blockchain.get_peak_height(),
     )
     await time_out_assert(15, dl_wallet_1.get_mirrors_for_launcher, [mirror], launcher_id_2)
     await time_out_assert(
         15, dl_wallet_2.get_mirrors_for_launcher, [dataclasses.replace(mirror, ours=False)], launcher_id_2
     )
 
-    async with dl_wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        await dl_wallet_1.delete_mirror(mirror.coin_id, peer_1, action_scope, fee=uint64(2_000_000_000_000))
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
+    fee = uint64(2_000_000_000_000)
+
+    async with dl_wallet_1.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
+        await dl_wallet_1.delete_mirror(mirror.coin_id, peer_1, action_scope, fee=fee)
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "unconfirmed_wallet_balance": -fee + mirror.amount,
+                        # these match exactly because of our change from the creation
+                        "<=#spendable_balance": -fee + mirror.amount,
+                        "<=#max_send_amount": -fee + mirror.amount,
+                        ">=#pending_change": 1,
+                        "pending_coin_removal_count": 2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": 1,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "confirmed_wallet_balance": -fee + mirror.amount,
+                        ">=#spendable_balance": 1,
+                        ">=#max_send_amount": 1,
+                        "<=#pending_change": -1,
+                        "pending_coin_removal_count": -2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": -1,
+                        "unspent_coin_count": -1,
+                    },
+                },
+            ),
+        ]
+    )
 
     await time_out_assert(15, dl_wallet_1.get_mirrors_for_launcher, [], launcher_id_2)
     await time_out_assert(15, dl_wallet_2.get_mirrors_for_launcher, [], launcher_id_2)