chia-blockchain 2.5.4rc1__py3-none-any.whl → 2.5.5rc1__py3-none-any.whl

chia/_tests/wallet/db_wallet/test_dl_offers.py

@@ -6,6 +6,7 @@ import pytest
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
+from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.data_layer.data_layer_wallet import DataLayerWallet
 from chia.wallet.puzzle_drivers import Solver
@@ -13,7 +14,6 @@ from chia.wallet.trade_record import TradeRecord
 from chia.wallet.trading.offer import Offer
 from chia.wallet.trading.trade_status import TradeStatus
 from chia.wallet.util.merkle_utils import build_merkle_tree, simplify_merkle_proof
-from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 
 
 async def is_singleton_confirmed_and_root(dl_wallet: DataLayerWallet, lid: bytes32, root: bytes32) -> bool:
@@ -37,50 +37,106 @@ def get_parent_branch(value: bytes32, proof: tuple[int, list[bytes32]]) -> tuple
     return branch, new_proof
 
 
-@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.limit_consensus_modes
+@pytest.mark.parametrize("wallet_environments", [{"num_environments": 2, "blocks_needed": [2, 2]}], indirect=True)
 @pytest.mark.anyio
-async def test_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
-    (
-        [wallet_node_maker, maker_funds],
-        [wallet_node_taker, taker_funds],
-        full_node_api,
-    ) = wallets_prefarm
-    assert wallet_node_maker.wallet_state_manager is not None
-    assert wallet_node_taker.wallet_state_manager is not None
-    wsm_maker = wallet_node_maker.wallet_state_manager
-    wsm_taker = wallet_node_taker.wallet_state_manager
-
-    async with wsm_maker.lock:
-        dl_wallet_maker = await DataLayerWallet.create_new_dl_wallet(wsm_maker)
-    async with wsm_taker.lock:
-        dl_wallet_taker = await DataLayerWallet.create_new_dl_wallet(wsm_taker)
-
-    MAKER_ROWS = [bytes32([i] * 32) for i in range(0, 10)]
-    TAKER_ROWS = [bytes32([i] * 32) for i in range(0, 10)]
+async def test_dl_offers(wallet_environments: WalletTestFramework) -> None:
+    env_maker = wallet_environments.environments[0]
+    env_taker = wallet_environments.environments[1]
+    wsm_maker = env_maker.wallet_state_manager
+    wsm_taker = env_taker.wallet_state_manager
+
+    env_maker.wallet_aliases = {
+        "xch": 1,
+        "dl": 2,
+    }
+    env_taker.wallet_aliases = {
+        "xch": 1,
+        "dl": 2,
+    }
+
+    dl_wallet_maker = await DataLayerWallet.create_new_dl_wallet(wsm_maker)
+    dl_wallet_taker = await DataLayerWallet.create_new_dl_wallet(wsm_taker)
+
+    await env_maker.change_balances({"dl": {"init": True}})
+    await env_taker.change_balances({"dl": {"init": True}})
+
+    MAKER_ROWS = [bytes32([i] * 32) for i in range(10)]
+    TAKER_ROWS = [bytes32([i] * 32) for i in range(10)]
     maker_root, _ = build_merkle_tree(MAKER_ROWS)
     taker_root, _ = build_merkle_tree(TAKER_ROWS)
 
     fee = uint64(1_999_999_999_999)
 
-    async with dl_wallet_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with dl_wallet_maker.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
         launcher_id_maker = await dl_wallet_maker.generate_new_reporter(maker_root, action_scope, fee=fee)
     assert await dl_wallet_maker.get_latest_singleton(launcher_id_maker) is not None
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    maker_funds -= fee
-    maker_funds -= 1
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
+
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_maker, launcher_id_maker, maker_root)
 
-    async with dl_wallet_taker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with dl_wallet_taker.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
         launcher_id_taker = await dl_wallet_taker.generate_new_reporter(taker_root, action_scope, fee=fee)
     assert await dl_wallet_taker.get_latest_singleton(launcher_id_taker) is not None
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    taker_funds -= fee
-    taker_funds -= 1
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+            ),
+        ]
+    )
+
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_taker, launcher_id_taker, taker_root)
 
-    peer = wallet_node_taker.get_full_node_peer()
+    peer = env_taker.node.get_full_node_peer()
     await dl_wallet_maker.track_new_launcher_id(launcher_id_taker, peer)
     await dl_wallet_taker.track_new_launcher_id(launcher_id_maker, peer)
+    await env_maker.change_balances({"dl": {"unspent_coin_count": 1}})
+    await env_taker.change_balances({"dl": {"unspent_coin_count": 1}})
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_maker, launcher_id_taker, taker_root)
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_taker, launcher_id_maker, maker_root)
 
@@ -98,7 +154,9 @@ async def test_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
 
     fee = uint64(2_000_000_000_000)
 
-    async with trade_manager_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
+    async with trade_manager_maker.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=False
+    ) as action_scope:
         success, offer_maker, error = await trade_manager_maker.create_offer_for_ids(
             {launcher_id_maker: -1, launcher_id_taker: 1},
             action_scope,
@@ -136,11 +194,9 @@ async def test_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
         ]
     }
 
-    [_maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
-        [Offer.from_bytes(offer_maker.offer)]
-    )
+    [_maker_offer], signing_response = await wsm_maker.sign_offers([Offer.from_bytes(offer_maker.offer)])
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
-        DEFAULT_TX_CONFIG, push=True, additional_signing_responses=signing_response
+        wallet_environments.tx_config, push=True, additional_signing_responses=signing_response
     ) as action_scope:
         offer_taker = await trade_manager_taker.respond_to_offer(
             Offer.from_bytes(offer_maker.offer),
@@ -200,20 +256,56 @@ async def test_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
         ]
     }
 
-    wallet_maker = wsm_maker.main_wallet
-    wallet_taker = wsm_taker.main_wallet
-
-    await time_out_assert(15, wallet_maker.get_unconfirmed_balance, maker_funds)
-    await time_out_assert(15, wallet_taker.get_unconfirmed_balance, taker_funds - fee)
-
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    maker_funds -= fee
-    taker_funds -= fee
-
-    await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
-    await time_out_assert(15, wallet_maker.get_unconfirmed_balance, maker_funds)
-    await time_out_assert(15, wallet_taker.get_confirmed_balance, taker_funds)
-    await time_out_assert(15, wallet_taker.get_unconfirmed_balance, taker_funds)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "spendable_balance": -fee,
+                        "max_send_amount": -fee,
+                        "pending_coin_removal_count": 2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": 1,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "unconfirmed_wallet_balance": -fee,
+                        "confirmed_wallet_balance": -fee,
+                        "pending_coin_removal_count": -2,
+                        "unspent_coin_count": -2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": -1,
+                    },
+                },
+            ),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "unconfirmed_wallet_balance": -fee,
+                        "spendable_balance": -fee,
+                        "max_send_amount": -fee,
+                        "pending_coin_removal_count": 2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": 2,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "confirmed_wallet_balance": -fee,
+                        "pending_coin_removal_count": -2,
+                        "unspent_coin_count": -2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": -2,
+                    },
+                },
+            ),
+        ]
+    )
 
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_maker, launcher_id_taker, taker_root)
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_taker, launcher_id_maker, maker_root)
@@ -229,43 +321,121 @@ async def test_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
 
     await time_out_assert(15, is_singleton_generation, True, dl_wallet_taker, launcher_id_taker, 2)
 
-    async with dl_wallet_taker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with dl_wallet_taker.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
         await dl_wallet_taker.create_update_state_spend(launcher_id_taker, bytes32([2] * 32), action_scope)
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
 
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+            ),
+        ]
+    )
 
-@pytest.mark.parametrize(
-    "trusted",
-    [True, False],
-)
+
+@pytest.mark.limit_consensus_modes
+@pytest.mark.parametrize("wallet_environments", [{"num_environments": 1, "blocks_needed": [3]}], indirect=True)
 @pytest.mark.anyio
-async def test_dl_offer_cancellation(wallets_prefarm: Any, trusted: bool) -> None:
-    [wallet_node, _], [_, _], full_node_api = wallets_prefarm
-    assert wallet_node.wallet_state_manager is not None
-    wsm = wallet_node.wallet_state_manager
+async def test_dl_offer_cancellation(wallet_environments: WalletTestFramework) -> None:
+    env_maker = wallet_environments.environments[0]
+    env_maker.wallet_aliases = {
+        "xch": 1,
+        "dl": 2,
+    }
 
-    async with wsm.lock:
-        dl_wallet = await DataLayerWallet.create_new_dl_wallet(wsm)
+    dl_wallet = await DataLayerWallet.create_new_dl_wallet(env_maker.wallet_state_manager)
+    await env_maker.change_balances({"dl": {"init": True}})
 
-    ROWS = [bytes32([i] * 32) for i in range(0, 10)]
+    ROWS = [bytes32([i] * 32) for i in range(10)]
     root, _ = build_merkle_tree(ROWS)
 
-    async with dl_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) 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(root, action_scope)
     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": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+            ),
+        ]
+    )
+
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet, launcher_id, root)
-    async with dl_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with dl_wallet.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
         launcher_id_2 = await dl_wallet.generate_new_reporter(root, action_scope)
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
 
-    trade_manager = wsm.trade_manager
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+            ),
+        ]
+    )
+
+    trade_manager = env_maker.wallet_state_manager.trade_manager
 
     addition = bytes32([101] * 32)
     ROWS.append(addition)
     root, _proofs = build_merkle_tree(ROWS)
 
-    async with trade_manager.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
+    FEE = uint64(2_000_000_000_000)
+
+    async with trade_manager.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=False
+    ) as action_scope:
         success, offer, error = await trade_manager.create_offer_for_ids(
             {launcher_id: -1, launcher_id_2: 1},
             action_scope,
@@ -282,83 +452,181 @@ async def test_dl_offer_cancellation(wallets_prefarm: Any, trusted: bool) -> Non
                     }
                 }
             ),
-            fee=uint64(2_000_000_000_000),
+            fee=FEE,
         )
     assert error is None
     assert success is True
     assert offer is not None
 
-    async with trade_manager.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        await trade_manager.cancel_pending_offers(
-            [offer.trade_id], action_scope, fee=uint64(2_000_000_000_000), secure=True
-        )
+    await env_maker.change_balances(
+        {
+            "xch": {
+                "spendable_balance": -FEE,
+                "max_send_amount": -FEE,
+                "pending_coin_removal_count": 2,
+            },
+            "dl": {
+                "pending_coin_removal_count": 1,
+            },
+        }
+    )
+    await env_maker.check_balances()
+
+    async with trade_manager.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
+        await trade_manager.cancel_pending_offers([offer.trade_id], action_scope, fee=FEE, secure=True)
+
     # One outgoing for cancel, one outgoing for fee, one incoming from cancel
     assert len(action_scope.side_effects.transactions) == 3
     await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CANCEL, trade_manager, offer)
-    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,
+                        "spendable_balance": -FEE,
+                        "max_send_amount": -FEE,
+                        "pending_coin_removal_count": 2,
+                    },
+                    "dl": {},
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "confirmed_wallet_balance": -FEE,
+                        "spendable_balance": FEE,
+                        "max_send_amount": FEE,
+                        "pending_coin_removal_count": -4,
+                        "unspent_coin_count": -2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": -1,
+                    },
+                },
+            )
+        ]
+    )
+
     await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager, offer)
 
 
-@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.limit_consensus_modes
+@pytest.mark.parametrize("wallet_environments", [{"num_environments": 2, "blocks_needed": [3, 3]}], indirect=True)
 @pytest.mark.anyio
-async def test_multiple_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
-    (
-        [wallet_node_maker, maker_funds],
-        [wallet_node_taker, taker_funds],
-        full_node_api,
-    ) = wallets_prefarm
-    assert wallet_node_maker.wallet_state_manager is not None
-    assert wallet_node_taker.wallet_state_manager is not None
-    wsm_maker = wallet_node_maker.wallet_state_manager
-    wsm_taker = wallet_node_taker.wallet_state_manager
-
-    async with wsm_maker.lock:
-        dl_wallet_maker = await DataLayerWallet.create_new_dl_wallet(wsm_maker)
-    async with wsm_taker.lock:
-        dl_wallet_taker = await DataLayerWallet.create_new_dl_wallet(wsm_taker)
-
-    MAKER_ROWS = [bytes32([i] * 32) for i in range(0, 10)]
+async def test_multiple_dl_offers(wallet_environments: WalletTestFramework) -> None:
+    env_maker = wallet_environments.environments[0]
+    env_taker = wallet_environments.environments[1]
+    wsm_maker = env_maker.wallet_state_manager
+    wsm_taker = env_taker.wallet_state_manager
+
+    env_maker.wallet_aliases = {
+        "xch": 1,
+        "dl": 2,
+    }
+    env_taker.wallet_aliases = {
+        "xch": 1,
+        "dl": 2,
+    }
+
+    dl_wallet_maker = await DataLayerWallet.create_new_dl_wallet(wsm_maker)
+    dl_wallet_taker = await DataLayerWallet.create_new_dl_wallet(wsm_taker)
+    await env_maker.change_balances({"dl": {"init": True}})
+    await env_taker.change_balances({"dl": {"init": True}})
+
+    MAKER_ROWS = [bytes32([i] * 32) for i in range(10)]
     TAKER_ROWS = [bytes32([i] * 32) for i in range(10, 20)]
     maker_root, _ = build_merkle_tree(MAKER_ROWS)
     taker_root, _ = build_merkle_tree(TAKER_ROWS)
 
     fee = uint64(1_999_999_999_999)
 
-    async with dl_wallet_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with dl_wallet_maker.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
         launcher_id_maker_1 = await dl_wallet_maker.generate_new_reporter(maker_root, action_scope, fee=fee)
     assert await dl_wallet_maker.get_latest_singleton(launcher_id_maker_1) is not None
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    maker_funds -= fee
-    maker_funds -= 1
-    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_maker, launcher_id_maker_1, maker_root)
-    async with dl_wallet_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+
+    async with dl_wallet_maker.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
         launcher_id_maker_2 = await dl_wallet_maker.generate_new_reporter(maker_root, action_scope, fee=fee)
     assert await dl_wallet_maker.get_latest_singleton(launcher_id_maker_2) is not None
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    maker_funds -= fee
-    maker_funds -= 1
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
+
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_maker, launcher_id_maker_1, maker_root)
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_maker, launcher_id_maker_2, maker_root)
 
-    async with dl_wallet_taker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with dl_wallet_taker.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
         launcher_id_taker_1 = await dl_wallet_taker.generate_new_reporter(taker_root, action_scope, fee=fee)
     assert await dl_wallet_taker.get_latest_singleton(launcher_id_taker_1) is not None
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    taker_funds -= fee
-    taker_funds -= 1
-    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_taker, launcher_id_taker_1, taker_root)
-    async with dl_wallet_taker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+
+    async with dl_wallet_taker.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
         launcher_id_taker_2 = await dl_wallet_taker.generate_new_reporter(taker_root, action_scope, fee=fee)
     assert await dl_wallet_taker.get_latest_singleton(launcher_id_taker_2) is not None
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    taker_funds -= fee
-    taker_funds -= 1
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "set_remainder": True,
+                    },
+                    "dl": {
+                        "set_remainder": True,
+                    },
+                },
+            ),
+        ]
+    )
+
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_taker, launcher_id_taker_1, taker_root)
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_taker, launcher_id_taker_2, taker_root)
 
-    peer = wallet_node_taker.get_full_node_peer()
+    peer = env_taker.node.get_full_node_peer()
     await dl_wallet_maker.track_new_launcher_id(launcher_id_taker_1, peer)
     await dl_wallet_maker.track_new_launcher_id(launcher_id_taker_2, peer)
     await dl_wallet_taker.track_new_launcher_id(launcher_id_maker_1, peer)
     await dl_wallet_taker.track_new_launcher_id(launcher_id_maker_2, peer)
+    await env_maker.change_balances({"dl": {"unspent_coin_count": 2}})
+    await env_taker.change_balances({"dl": {"unspent_coin_count": 2}})
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_maker, launcher_id_taker_1, taker_root)
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_maker, launcher_id_taker_2, taker_root)
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_taker, launcher_id_maker_1, maker_root)
@@ -378,7 +646,9 @@ async def test_multiple_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
 
     fee = uint64(2_000_000_000_000)
 
-    async with trade_manager_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
+    async with trade_manager_maker.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=False
+    ) as action_scope:
         success, offer_maker, error = await trade_manager_maker.create_offer_for_ids(
             {launcher_id_maker_1: -1, launcher_id_taker_1: 1, launcher_id_maker_2: -1, launcher_id_taker_2: 1},
             action_scope,
@@ -414,11 +684,9 @@ async def test_multiple_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
     assert success is True
     assert offer_maker is not None
 
-    [_maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
-        [Offer.from_bytes(offer_maker.offer)]
-    )
+    [_maker_offer], signing_response = await wsm_maker.sign_offers([Offer.from_bytes(offer_maker.offer)])
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
-        DEFAULT_TX_CONFIG, push=True, additional_signing_responses=signing_response
+        wallet_environments.tx_config, push=True, additional_signing_responses=signing_response
     ) as action_scope:
         offer_taker = await trade_manager_taker.respond_to_offer(
             Offer.from_bytes(offer_maker.offer),
@@ -466,21 +734,56 @@ async def test_multiple_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
         )
     assert offer_taker is not None
 
-    wallet_maker = wsm_maker.main_wallet
-    wallet_taker = wsm_taker.main_wallet
-
-    await time_out_assert(15, wallet_maker.get_unconfirmed_balance, maker_funds)
-    await time_out_assert(15, wallet_taker.get_unconfirmed_balance, taker_funds - fee)
-
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-
-    maker_funds -= fee
-    taker_funds -= fee
-
-    await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
-    await time_out_assert(15, wallet_maker.get_unconfirmed_balance, maker_funds)
-    await time_out_assert(15, wallet_taker.get_confirmed_balance, taker_funds)
-    await time_out_assert(15, wallet_taker.get_unconfirmed_balance, taker_funds)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "spendable_balance": -fee,
+                        "max_send_amount": -fee,
+                        "pending_coin_removal_count": 2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": 2,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "unconfirmed_wallet_balance": -fee,
+                        "confirmed_wallet_balance": -fee,
+                        "pending_coin_removal_count": -2,
+                        "unspent_coin_count": -2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": -2,
+                    },
+                },
+            ),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "unconfirmed_wallet_balance": -fee,
+                        "spendable_balance": -fee,
+                        "max_send_amount": -fee,
+                        "pending_coin_removal_count": 2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": 4,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "confirmed_wallet_balance": -fee,
+                        "pending_coin_removal_count": -2,
+                        "unspent_coin_count": -2,
+                    },
+                    "dl": {
+                        "pending_coin_removal_count": -4,
+                    },
+                },
+            ),
+        ]
+    )
 
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_maker, launcher_id_taker_1, taker_root)
     await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_maker, launcher_id_taker_2, taker_root)