chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/wallet/db_wallet/config.py

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

chia/_tests/wallet/db_wallet/test_db_graftroot.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import pytest
+from chia_rs import G2Element
+
+from chia._tests.util.spend_sim import CostLogger, sim_and_client
+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.coin_spend import make_spend
+from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.util.errors import Err
+from chia.wallet.puzzles.load_clvm import load_clvm
+from chia.wallet.util.merkle_utils import build_merkle_tree, build_merkle_tree_from_binary_tree, simplify_merkle_proof
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+GRAFTROOT_MOD = load_clvm("graftroot_dl_offers.clsp", package_or_requirement="chia.data_layer.puzzles")
+
+# Always returns the last value
+# (mod solution
+#
+#   (defun recurse (solution last_value)
+#     (if solution
+#         (recurse (r solution) (f solution))
+#         last_value
+#     )
+#   )
+#
+#   (recurse solution ())
+# )
+ACS = Program.fromhex(
+    "ff02ffff01ff02ff02ffff04ff02ffff04ff03ffff01ff8080808080ffff04ffff01ff02ffff03ff05ffff01ff02ff02ffff04ff02ffff04ff0dffff04ff09ff8080808080ffff010b80ff0180ff018080"
+)
+ACS_PH = ACS.get_tree_hash()
+
+NIL_PH = Program.to(None).get_tree_hash()
+
+
+@pytest.mark.anyio
+async def test_graftroot(cost_logger: CostLogger) -> None:
+    async with sim_and_client() as (sim, sim_client):
+        # Create the coin we're testing
+        all_values: list[bytes32] = [bytes32([x] * 32) for x in range(0, 100)]
+        root, proofs = build_merkle_tree(all_values)
+        p2_conditions = Program.to((1, [[51, ACS_PH, 0]]))  # An coin to create to make sure this hits the blockchain
+        desired_key_values = ((bytes32.zeros, bytes32([1] * 32)), (bytes32([7] * 32), bytes32([8] * 32)))
+        desired_row_hashes: list[bytes32] = [build_merkle_tree_from_binary_tree(kv)[0] for kv in desired_key_values]
+        fake_struct: Program = Program.to((ACS_PH, NIL_PH))
+        graftroot_puzzle: Program = GRAFTROOT_MOD.curry(
+            # Do everything twice to test depending on multiple singleton updates
+            p2_conditions,
+            [fake_struct, fake_struct],
+            [ACS_PH, ACS_PH],
+            [desired_row_hashes, desired_row_hashes],
+        )
+        await sim.farm_block(graftroot_puzzle.get_tree_hash())
+        graftroot_coin: Coin = (await sim_client.get_coin_records_by_puzzle_hash(graftroot_puzzle.get_tree_hash()))[
+            0
+        ].coin
+
+        # Build some merkle trees that won't satidy the requirements
+        def filter_all(values: list[bytes32]) -> list[bytes32]:
+            return [h for i, h in enumerate(values) if (h, values[min(i, i + 1)]) not in desired_key_values]
+
+        def filter_to_only_one(values: list[bytes32]) -> list[bytes32]:
+            return [h for i, h in enumerate(values) if (h, values[min(i, i + 1)]) not in desired_key_values[1:]]
+
+        # And one that will
+        def filter_none(values: list[bytes32]) -> list[bytes32]:
+            return values
+
+        for list_filter in (filter_all, filter_to_only_one, filter_none):
+            # Create the "singleton"
+            filtered_values = list_filter(all_values)
+            root, proofs = build_merkle_tree(filtered_values)
+            filtered_row_hashes: dict[bytes32, tuple[int, list[bytes32]]] = {
+                simplify_merkle_proof(v, (proofs[v][0], [proofs[v][1][0]])): (proofs[v][0] >> 1, proofs[v][1][1:])
+                for v in filtered_values
+            }
+            fake_puzzle: Program = ACS.curry(fake_struct, ACS.curry(ACS_PH, (root, None), NIL_PH, None))
+            await sim.farm_block(fake_puzzle.get_tree_hash())
+            fake_coin: Coin = (await sim_client.get_coin_records_by_puzzle_hash(fake_puzzle.get_tree_hash()))[0].coin
+
+            # Create the spend
+            fake_spend = make_spend(
+                fake_coin,
+                fake_puzzle,
+                Program.to([[[62, "$"]]]),
+            )
+
+            proofs_of_inclusion = []
+            for row_hash in desired_row_hashes:
+                if row_hash in filtered_row_hashes:
+                    proofs_of_inclusion.append(filtered_row_hashes[row_hash])
+                else:
+                    proofs_of_inclusion.append((0, []))
+
+            graftroot_spend = make_spend(
+                graftroot_coin,
+                graftroot_puzzle,
+                Program.to(
+                    [
+                        # Again, everything twice
+                        [proofs_of_inclusion] * 2,
+                        [(root, None), (root, None)],
+                        [NIL_PH, NIL_PH],
+                        [NIL_PH, NIL_PH],
+                        [],
+                    ]
+                ),
+            )
+
+            final_bundle = WalletSpendBundle([fake_spend, graftroot_spend], G2Element())
+            result = await sim_client.push_tx(final_bundle)
+
+            # If this is the satisfactory merkle tree
+            if filtered_values == all_values:
+                cost_logger.add_cost(
+                    "DL Graftroot - fake singleton w/ announce + prove two rows in a DL merkle tree + create one child",
+                    final_bundle,
+                )
+                assert result == (MempoolInclusionStatus.SUCCESS, None)
+                # clear the mempool
+                same_height = sim.block_height
+                await sim.farm_block()
+                assert len(await sim_client.get_coin_records_by_puzzle_hash(ACS_PH)) > 0
+                await sim.rewind(same_height)
+
+                # try with a bad merkle root announcement
+                new_fake_spend = make_spend(
+                    fake_coin,
+                    ACS.curry(fake_struct, ACS.curry(ACS_PH, (bytes32.zeros, None), None, None)),
+                    Program.to([[[62, "$"]]]),
+                )
+                new_final_bundle = WalletSpendBundle([new_fake_spend, graftroot_spend], G2Element())
+                result = await sim_client.push_tx(new_final_bundle)
+                assert result == (MempoolInclusionStatus.FAILED, Err.ASSERT_ANNOUNCE_CONSUMED_FAILED)
+            else:
+                assert result == (MempoolInclusionStatus.FAILED, Err.GENERATOR_RUNTIME_ERROR)
+                with pytest.raises(ValueError, match="clvm raise"):
+                    graftroot_puzzle.run(graftroot_spend.solution.to_program())

chia/_tests/wallet/db_wallet/test_dl_offers.py

@@ -0,0 +1,491 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from chia._tests.util.time_out_assert import time_out_assert
+from chia.data_layer.data_layer_wallet import DataLayerWallet
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint64
+from chia.wallet.puzzle_drivers import Solver
+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:
+    rec = await dl_wallet.get_latest_singleton(lid)
+    if rec is None:
+        return False
+    if rec.confirmed is True:
+        assert rec.confirmed_at_height > 0
+        assert rec.timestamp > 0
+    return rec.confirmed and rec.root == root
+
+
+async def get_trade_and_status(trade_manager: Any, trade: TradeRecord) -> TradeStatus:
+    trade_rec = await trade_manager.get_trade_by_id(trade.trade_id)
+    return TradeStatus(trade_rec.status)
+
+
+def get_parent_branch(value: bytes32, proof: tuple[int, list[bytes32]]) -> tuple[bytes32, tuple[int, list[bytes32]]]:
+    branch: bytes32 = simplify_merkle_proof(value, (proof[0], [proof[1][0]]))
+    new_proof: tuple[int, list[bytes32]] = (proof[0] >> 1, proof[1][1:])
+    return branch, new_proof
+
+
+@pytest.mark.parametrize("trusted", [True, False])
+@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)]
+    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:
+        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 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:
+        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 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()
+    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 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)
+
+    trade_manager_maker = wsm_maker.trade_manager
+    trade_manager_taker = wsm_taker.trade_manager
+
+    maker_addition = bytes32([101] * 32)
+    taker_addition = bytes32([101] * 32)
+    MAKER_ROWS.append(maker_addition)
+    TAKER_ROWS.append(taker_addition)
+    maker_root, maker_proofs = build_merkle_tree(MAKER_ROWS)
+    taker_root, taker_proofs = build_merkle_tree(TAKER_ROWS)
+    maker_branch, maker_branch_proof = get_parent_branch(maker_addition, maker_proofs[maker_addition])
+    taker_branch, taker_branch_proof = get_parent_branch(taker_addition, taker_proofs[taker_addition])
+
+    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:
+        success, offer_maker, error = await trade_manager_maker.create_offer_for_ids(
+            {launcher_id_maker: -1, launcher_id_taker: 1},
+            action_scope,
+            solver=Solver(
+                {
+                    launcher_id_maker.hex(): {
+                        "new_root": "0x" + maker_root.hex(),
+                        "dependencies": [
+                            {
+                                "launcher_id": "0x" + launcher_id_taker.hex(),
+                                "values_to_prove": ["0x" + taker_branch.hex()],
+                            },
+                        ],
+                    }
+                }
+            ),
+            fee=fee,
+        )
+    assert error is None
+    assert success is True
+    assert offer_maker is not None
+
+    assert await trade_manager_taker.get_offer_summary(Offer.from_bytes(offer_maker.offer)) == {
+        "offered": [
+            {
+                "launcher_id": launcher_id_maker.hex(),
+                "new_root": maker_root.hex(),
+                "dependencies": [
+                    {
+                        "launcher_id": launcher_id_taker.hex(),
+                        "values_to_prove": [taker_branch.hex()],
+                    }
+                ],
+            }
+        ]
+    }
+
+    [_maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.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
+    ) as action_scope:
+        offer_taker = await trade_manager_taker.respond_to_offer(
+            Offer.from_bytes(offer_maker.offer),
+            peer,
+            action_scope,
+            solver=Solver(
+                {
+                    launcher_id_taker.hex(): {
+                        "new_root": "0x" + taker_root.hex(),
+                        "dependencies": [
+                            {
+                                "launcher_id": "0x" + launcher_id_maker.hex(),
+                                "values_to_prove": ["0x" + maker_branch.hex()],
+                            },
+                        ],
+                    },
+                    "proofs_of_inclusion": [
+                        [
+                            maker_root.hex(),
+                            str(maker_branch_proof[0]),
+                            ["0x" + sibling.hex() for sibling in maker_branch_proof[1]],
+                        ],
+                        [
+                            taker_root.hex(),
+                            str(taker_branch_proof[0]),
+                            ["0x" + sibling.hex() for sibling in taker_branch_proof[1]],
+                        ],
+                    ],
+                }
+            ),
+            fee=fee,
+        )
+    assert offer_taker is not None
+
+    assert await trade_manager_maker.get_offer_summary(Offer.from_bytes(offer_taker.offer)) == {
+        "offered": [
+            {
+                "launcher_id": launcher_id_maker.hex(),
+                "new_root": maker_root.hex(),
+                "dependencies": [
+                    {
+                        "launcher_id": launcher_id_taker.hex(),
+                        "values_to_prove": [taker_branch.hex()],
+                    }
+                ],
+            },
+            {
+                "launcher_id": launcher_id_taker.hex(),
+                "new_root": taker_root.hex(),
+                "dependencies": [
+                    {
+                        "launcher_id": launcher_id_maker.hex(),
+                        "values_to_prove": [maker_branch.hex()],
+                    }
+                ],
+            },
+        ]
+    }
+
+    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 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)
+
+    await time_out_assert(15, get_trade_and_status, TradeStatus.CONFIRMED, trade_manager_maker, offer_maker)
+    await time_out_assert(15, get_trade_and_status, TradeStatus.CONFIRMED, trade_manager_taker, offer_taker)
+
+    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
+
+    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:
+        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)
+
+
+@pytest.mark.parametrize(
+    "trusted",
+    [True, False],
+)
+@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 with wsm.lock:
+        dl_wallet = await DataLayerWallet.create_new_dl_wallet(wsm)
+
+    ROWS = [bytes32([i] * 32) for i in range(0, 10)]
+    root, _ = build_merkle_tree(ROWS)
+
+    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(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 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:
+        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
+
+    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:
+        success, offer, error = await trade_manager.create_offer_for_ids(
+            {launcher_id: -1, launcher_id_2: 1},
+            action_scope,
+            solver=Solver(
+                {
+                    launcher_id.hex(): {
+                        "new_root": "0x" + root.hex(),
+                        "dependencies": [
+                            {
+                                "launcher_id": "0x" + launcher_id_2.hex(),
+                                "values_to_prove": ["0x" + addition.hex()],
+                            },
+                        ],
+                    }
+                }
+            ),
+            fee=uint64(2_000_000_000_000),
+        )
+    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
+        )
+    # 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 time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager, offer)
+
+
+@pytest.mark.parametrize("trusted", [True, False])
+@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)]
+    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:
+        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:
+        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 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:
+        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:
+        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 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()
+    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 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)
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_taker, launcher_id_maker_2, maker_root)
+
+    trade_manager_maker = wsm_maker.trade_manager
+    trade_manager_taker = wsm_taker.trade_manager
+
+    maker_addition = bytes32([101] * 32)
+    taker_addition = bytes32([202] * 32)
+    MAKER_ROWS.append(maker_addition)
+    TAKER_ROWS.append(taker_addition)
+    maker_root, maker_proofs = build_merkle_tree(MAKER_ROWS)
+    taker_root, taker_proofs = build_merkle_tree(TAKER_ROWS)
+    maker_branch, maker_branch_proof = get_parent_branch(maker_addition, maker_proofs[maker_addition])
+    taker_branch, taker_branch_proof = get_parent_branch(taker_addition, taker_proofs[taker_addition])
+
+    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:
+        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,
+            solver=Solver(
+                {
+                    launcher_id_maker_1.hex(): {
+                        "new_root": "0x" + maker_root.hex(),
+                        "dependencies": [
+                            {
+                                "launcher_id": "0x" + launcher_id_taker_1.hex(),
+                                "values_to_prove": ["0x" + taker_branch.hex(), "0x" + taker_branch.hex()],
+                            }
+                        ],
+                    },
+                    launcher_id_maker_2.hex(): {
+                        "new_root": "0x" + maker_root.hex(),
+                        "dependencies": [
+                            {
+                                "launcher_id": "0x" + launcher_id_taker_1.hex(),
+                                "values_to_prove": ["0x" + taker_branch.hex()],
+                            },
+                            {
+                                "launcher_id": "0x" + launcher_id_taker_2.hex(),
+                                "values_to_prove": ["0x" + taker_branch.hex()],
+                            },
+                        ],
+                    },
+                }
+            ),
+            fee=fee,
+        )
+    assert error is 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)]
+    )
+    async with trade_manager_taker.wallet_state_manager.new_action_scope(
+        DEFAULT_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),
+            peer,
+            action_scope,
+            solver=Solver(
+                {
+                    launcher_id_taker_1.hex(): {
+                        "new_root": "0x" + taker_root.hex(),
+                        "dependencies": [
+                            {
+                                "launcher_id": "0x" + launcher_id_maker_1.hex(),
+                                "values_to_prove": ["0x" + maker_branch.hex(), "0x" + maker_branch.hex()],
+                            }
+                        ],
+                    },
+                    launcher_id_taker_2.hex(): {
+                        "new_root": "0x" + taker_root.hex(),
+                        "dependencies": [
+                            {
+                                "launcher_id": "0x" + launcher_id_maker_1.hex(),
+                                "values_to_prove": ["0x" + maker_branch.hex()],
+                            },
+                            {
+                                "launcher_id": "0x" + launcher_id_maker_2.hex(),
+                                "values_to_prove": ["0x" + maker_branch.hex()],
+                            },
+                        ],
+                    },
+                    "proofs_of_inclusion": [
+                        [
+                            maker_root.hex(),
+                            str(maker_branch_proof[0]),
+                            ["0x" + sibling.hex() for sibling in maker_branch_proof[1]],
+                        ],
+                        [
+                            taker_root.hex(),
+                            str(taker_branch_proof[0]),
+                            ["0x" + sibling.hex() for sibling in taker_branch_proof[1]],
+                        ],
+                    ],
+                }
+            ),
+            fee=fee,
+        )
+    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 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)
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_taker, launcher_id_maker_2, maker_root)
+
+    await time_out_assert(15, get_trade_and_status, TradeStatus.CONFIRMED, trade_manager_maker, offer_maker)
+    await time_out_assert(15, get_trade_and_status, TradeStatus.CONFIRMED, trade_manager_taker, offer_taker)