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

chia/_tests/wallet/cat_wallet/test_cat_wallet.py

@@ -6,10 +6,15 @@ from pathlib import Path
 import pytest
 
 from chia._tests.conftest import ConsensusMode
-from chia._tests.environments.wallet import WalletEnvironment, WalletStateTransition, WalletTestFramework
+from chia._tests.environments.wallet import (
+    NewPuzzleHashError,
+    WalletEnvironment,
+    WalletStateTransition,
+    WalletTestFramework,
+)
 from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_not_none
 from chia.protocols.wallet_protocol import CoinState
-from chia.rpc.wallet_request_types import GetTransactionMemo
+from chia.rpc.wallet_request_types import GetTransactionMemo, PushTX
 from chia.simulator.simulator_protocol import ReorgProtocol
 from chia.types.blockchain_format.coin import Coin, coin_as_list
 from chia.types.blockchain_format.program import Program
@@ -54,7 +59,7 @@ async def test_cat_creation(wallet_environments: WalletTestFramework) -> None:
     full_node_api = wallet_environments.full_node
     wsm = wallet_environments.environments[0].wallet_state_manager
     wallet = wallet_environments.environments[0].xch_wallet
-
+    wallet_node = wallet_environments.environments[0].node
     wallet_environments.environments[0].wallet_aliases = {
         "xch": 1,
         "cat": 2,
@@ -138,7 +143,7 @@ async def test_cat_creation(wallet_environments: WalletTestFramework) -> None:
     await full_node_api.reorg_from_index_to_new_index(
         ReorgProtocol(uint32(height - 1), uint32(height + 1), bytes32(32 * b"1"), None)
     )
-
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, peak_height=uint32(height + 1))
     # The "set_remainder" sections here are due to a peculiarity with how the creation method creates an incoming TX
     # The creation method is for testing purposes only so we're not going to bother fixing it for any real reason
     await wallet_environments.process_pending_states(
@@ -318,7 +323,7 @@ async def test_cat_spend(wallet_environments: WalletTestFramework) -> None:
 
     assert cat_wallet.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
 
-    cat_2_hash = await cat_wallet_2.get_new_inner_hash()
+    cat_2_hash = await cat_wallet_2.standard_wallet.get_puzzle_hash(new=False)
     async with cat_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await cat_wallet.generate_signed_transaction([uint64(60)], [cat_2_hash], action_scope, fee=uint64(1))
     tx_id = None
@@ -389,7 +394,6 @@ async def test_cat_spend(wallet_environments: WalletTestFramework) -> None:
                     "cat": {
                         "confirmed_wallet_balance": 60,
                         "unconfirmed_wallet_balance": 60,
-                        "pending_coin_removal_count": 0,
                         "spendable_balance": 60,
                         "max_send_amount": 60,
                         "pending_change": 0,
@@ -409,7 +413,7 @@ async def test_cat_spend(wallet_environments: WalletTestFramework) -> None:
     memos = await env_2.rpc_client.get_transaction_memo(GetTransactionMemo(transaction_id=tx_id))
     assert len(memos.coins_with_memos) == 2
     assert memos.coins_with_memos[1].memos[0] == cat_2_hash
-    cat_hash = await cat_wallet.get_new_inner_hash()
+    cat_hash = await cat_wallet.standard_wallet.get_puzzle_hash(new=False)
     async with cat_wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await cat_wallet_2.generate_signed_transaction([uint64(15)], [cat_hash], action_scope)
 
@@ -459,7 +463,7 @@ async def test_cat_spend(wallet_environments: WalletTestFramework) -> None:
     await full_node_api.reorg_from_index_to_new_index(
         ReorgProtocol(uint32(height - 1), uint32(height + 1), bytes32(32 * b"1"), None)
     )
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node)
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, peak_height=uint32(height + 1))
     await env_1.change_balances(
         {
             "cat": {
@@ -611,7 +615,7 @@ async def test_cat_doesnt_see_eve(wallet_environments: WalletTestFramework) -> N
 
     assert cat_wallet.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
 
-    cat_2_hash = await cat_wallet_2.get_new_inner_hash()
+    cat_2_hash = await cat_wallet_2.standard_wallet.get_puzzle_hash(new=False)
     async with cat_wallet.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=True
     ) as action_scope:
@@ -674,7 +678,6 @@ async def test_cat_doesnt_see_eve(wallet_environments: WalletTestFramework) -> N
                     "cat": {
                         "confirmed_wallet_balance": 60,
                         "unconfirmed_wallet_balance": 60,
-                        "pending_coin_removal_count": 0,
                         "spendable_balance": 60,
                         "max_send_amount": 60,
                         "pending_change": 0,
@@ -686,7 +689,7 @@ async def test_cat_doesnt_see_eve(wallet_environments: WalletTestFramework) -> N
         ]
     )
 
-    cc2_ph = await cat_wallet_2.get_new_cat_puzzle_hash()
+    cc2_ph = await cat_wallet_2.get_cat_puzzle_hash(new=False)
     async with wallet.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         await wallet.wallet_state_manager.main_wallet.generate_signed_transaction(uint64(10), cc2_ph, action_scope)
 
@@ -819,8 +822,8 @@ async def test_cat_spend_multiple(wallet_environments: WalletTestFramework) -> N
     assert cat_wallet_0.cat_info.limitations_program_hash == cat_wallet_1.cat_info.limitations_program_hash
     assert cat_wallet_0.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
 
-    cat_1_hash = await cat_wallet_1.get_new_inner_hash()
-    cat_2_hash = await cat_wallet_2.get_new_inner_hash()
+    cat_1_hash = await cat_wallet_1.standard_wallet.get_puzzle_hash(new=False)
+    cat_2_hash = await cat_wallet_2.standard_wallet.get_puzzle_hash(new=False)
 
     async with cat_wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await cat_wallet_0.generate_signed_transaction([uint64(60), uint64(20)], [cat_1_hash, cat_2_hash], action_scope)
@@ -866,7 +869,6 @@ async def test_cat_spend_multiple(wallet_environments: WalletTestFramework) -> N
                     "cat": {
                         "confirmed_wallet_balance": 60,
                         "unconfirmed_wallet_balance": 60,
-                        "pending_coin_removal_count": 0,
                         "spendable_balance": 60,
                         "max_send_amount": 60,
                         "pending_change": 0,
@@ -892,7 +894,6 @@ async def test_cat_spend_multiple(wallet_environments: WalletTestFramework) -> N
                     "cat": {
                         "confirmed_wallet_balance": 20,
                         "unconfirmed_wallet_balance": 20,
-                        "pending_coin_removal_count": 0,
                         "spendable_balance": 20,
                         "max_send_amount": 20,
                         "pending_change": 0,
@@ -904,7 +905,7 @@ async def test_cat_spend_multiple(wallet_environments: WalletTestFramework) -> N
         ]
     )
 
-    cat_hash = await cat_wallet_0.get_new_inner_hash()
+    cat_hash = await cat_wallet_0.standard_wallet.get_puzzle_hash(new=False)
 
     async with cat_wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await cat_wallet_1.generate_signed_transaction([uint64(15)], [cat_hash], action_scope)
@@ -1049,7 +1050,7 @@ async def test_cat_spend_multiple(wallet_environments: WalletTestFramework) -> N
             assert len(memos) == 2  # One for tx, one for change
             assert b"Markus Walburg" in [v for v_list in memos.values() for v in v_list]
             assert tx.spend_bundle is not None
-            assert list(memos.keys())[0] in [a.name() for a in tx.spend_bundle.additions()]
+            assert next(iter(memos.keys())) in [a.name() for a in tx.spend_bundle.additions()]
 
 
 @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
@@ -1111,7 +1112,7 @@ async def test_cat_max_amount_send(wallet_environments: WalletTestFramework) ->
 
     assert cat_wallet.cat_info.limitations_program_hash is not None
 
-    cat_2 = await cat_wallet.get_new_inner_puzzle()
+    cat_2 = await cat_wallet.standard_wallet.get_puzzle(new=False)
     cat_2_hash = cat_2.get_tree_hash()
     amounts = []
     puzzle_hashes = []
@@ -1170,14 +1171,14 @@ async def test_cat_max_amount_send(wallet_environments: WalletTestFramework) ->
     async with cat_wallet.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
     ) as action_scope:
-        await cat_wallet.generate_signed_transaction([uint64(max_sent_amount - 1)], [bytes32([0] * 32)], action_scope)
+        await cat_wallet.generate_signed_transaction([uint64(max_sent_amount - 1)], [bytes32.zeros], action_scope)
     assert action_scope.side_effects.transactions[0].amount == uint64(max_sent_amount - 1)
 
     # 2) Generate transaction that is equal to limit
     async with cat_wallet.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
     ) as action_scope:
-        await cat_wallet.generate_signed_transaction([uint64(max_sent_amount)], [bytes32([0] * 32)], action_scope)
+        await cat_wallet.generate_signed_transaction([uint64(max_sent_amount)], [bytes32.zeros], action_scope)
     assert action_scope.side_effects.transactions[0].amount == uint64(max_sent_amount)
 
     # 3) Generate transaction that is greater than limit
@@ -1185,9 +1186,7 @@ async def test_cat_max_amount_send(wallet_environments: WalletTestFramework) ->
         async with cat_wallet.wallet_state_manager.new_action_scope(
             wallet_environments.tx_config, push=False
         ) as action_scope:
-            await cat_wallet.generate_signed_transaction(
-                [uint64(max_sent_amount + 1)], [bytes32([0] * 32)], action_scope
-            )
+            await cat_wallet.generate_signed_transaction([uint64(max_sent_amount + 1)], [bytes32.zeros], action_scope)
 
 
 @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
@@ -1388,7 +1387,7 @@ async def test_cat_hint(wallet_environments: WalletTestFramework) -> None:
     cat_wallet_2 = wallet_node_2.wallet_state_manager.wallets[uint32(2)]
     assert isinstance(cat_wallet_2, CATWallet)
 
-    cat_hash = await cat_wallet.get_new_inner_hash()
+    cat_hash = await cat_wallet.standard_wallet.get_puzzle_hash(new=False)
     async with cat_wallet_2.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=True
     ) as action_scope:
@@ -1537,7 +1536,7 @@ async def test_cat_change_detection(wallet_environments: WalletTestFramework) ->
                                 1,
                                 [
                                     [51, inner_puzhash, cat_amount_1],
-                                    [51, bytes32([0] * 32), cat_amount_0 - cat_amount_1],
+                                    [51, bytes32.zeros, cat_amount_0 - cat_amount_1],
                                 ],
                             ),
                             None,
@@ -1555,7 +1554,7 @@ async def test_cat_change_detection(wallet_environments: WalletTestFramework) ->
             ),
         ],
     )
-    await env.rpc_client.push_tx(eve_spend)
+    await env.rpc_client.push_tx(PushTX(eve_spend))
     await time_out_assert_not_none(5, full_node_api.full_node.mempool_manager.get_spendbundle, eve_spend.name())
     await wallet_environments.process_pending_states(
         [
@@ -1590,7 +1589,7 @@ async def test_unacknowledged_cat_table() -> None:
                 return bytes32([i] * 32)
 
             def coin_state(i: int) -> CoinState:
-                return CoinState(Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(i)), None, None)
+                return CoinState(Coin(bytes32.zeros, bytes32.zeros, uint64(i)), None, None)
 
             await interested_store.add_unacknowledged_coin_state(asset_id(0), coin_state(0), None)
             await interested_store.add_unacknowledged_coin_state(asset_id(1), coin_state(1), 100)
@@ -1667,7 +1666,7 @@ async def test_cat_melt_balance(wallet_environments: WalletTestFramework) -> Non
             )
         ],
     )
-    await env.rpc_client.push_tx(spend_to_wallet)
+    await env.rpc_client.push_tx(PushTX(spend_to_wallet))
     await time_out_assert(10, simulator.tx_id_in_mempool, True, spend_to_wallet.name())
 
     await wallet_environments.process_pending_states(
@@ -1717,7 +1716,7 @@ async def test_cat_melt_balance(wallet_environments: WalletTestFramework) -> Non
             ],
         )
         signed_spend, _ = await env.wallet_state_manager.sign_bundle(new_spend.coin_spends)
-        await env.rpc_client.push_tx(signed_spend)
+        await env.rpc_client.push_tx(PushTX(signed_spend))
         await time_out_assert(10, simulator.tx_id_in_mempool, True, signed_spend.name())
 
         await wallet_environments.process_pending_states(
@@ -1736,3 +1735,92 @@ async def test_cat_melt_balance(wallet_environments: WalletTestFramework) -> Non
                 )
             ]
         )
+
+
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [
+        {
+            "num_environments": 1,
+            "blocks_needed": [1],
+            "trusted": True,  # Parameter doesn't matter for this test
+            "reuse_puzhash": True,  # Important to test this is ignored in the duplicate change scenario
+        }
+    ],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes([ConsensusMode.PLAIN], reason="irrelevant")
+@pytest.mark.anyio
+async def test_cat_puzzle_hashes(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    wallet = env.xch_wallet
+
+    env.wallet_aliases = {
+        "xch": 1,
+        "cat": 2,
+    }
+
+    async with env.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
+        cat_wallet = await CATWallet.create_new_cat_wallet(
+            env.node.wallet_state_manager,
+            wallet,
+            {"identifier": "genesis_by_id"},
+            uint64(100),
+            action_scope,
+        )
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "cat": {"init": True, "set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "cat": {
+                        "confirmed_wallet_balance": 100,
+                        "unconfirmed_wallet_balance": 0,
+                        "spendable_balance": 100,
+                        "max_send_amount": 100,
+                        "pending_change": -100,
+                        "pending_coin_removal_count": -1,
+                        "unspent_coin_count": 1,
+                    },
+                },
+            ),
+        ]
+    )
+
+    # Test that we attempt a new puzzle hash here even though everything says we shouldn't
+    with pytest.raises(NewPuzzleHashError):
+        async with env.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
+            await cat_wallet.generate_signed_transaction(
+                [uint64(50)], [await cat_wallet.standard_wallet.get_puzzle_hash(new=False)], action_scope
+            )
+
+    # Test new puzzle hash getting
+    current_derivation_index = await env.wallet_state_manager.puzzle_store.get_current_derivation_record_for_wallet(
+        uint32(env.wallet_aliases["cat"])
+    )
+    assert current_derivation_index is not None
+    await cat_wallet.get_cat_puzzle_hash(new=True)
+    next_derivation_index = await env.wallet_state_manager.puzzle_store.get_current_derivation_record_for_wallet(
+        uint32(env.wallet_aliases["cat"])
+    )
+    assert next_derivation_index is not None
+    assert current_derivation_index.index < next_derivation_index.index
+
+    # Test a weird edge case where a new puzzle hash needs to get generated
+    # First, we reset the used status of all puzzle hashes by re-adding them
+    for puzhash in await env.wallet_state_manager.puzzle_store.get_all_puzzle_hashes():
+        dr = await env.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(puzhash)
+        assert dr is not None
+        await env.wallet_state_manager.puzzle_store.add_derivation_paths([dr])
+
+    # Then we make sure that even though we asked for a used puzzle hash, it still gives us an unused one
+    unused_count = await env.wallet_state_manager.puzzle_store.get_unused_count(uint32(env.wallet_aliases["cat"]))
+    await cat_wallet.get_cat_puzzle_hash(new=False)
+    assert unused_count < await env.wallet_state_manager.puzzle_store.get_unused_count(
+        uint32(env.wallet_aliases["cat"])
+    )

chia/_tests/wallet/cat_wallet/test_offer_lifecycle.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 import pytest
 from chia_rs import G2Element
 
-from chia.clvm.spend_sim import CostLogger, SimClient, SpendSim, sim_and_client
+from chia._tests.util.spend_sim import CostLogger, SimClient, SpendSim, sim_and_client
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
@@ -45,10 +45,10 @@ def str_to_cat_hash(tail_str: str) -> bytes32:
 
 # This method takes a dictionary of strings mapping to amounts and generates the appropriate CAT/XCH coins
 async def generate_coins(
-    sim: SpendSim, sim_client: SimClient, requested_coins: Dict[Optional[str], List[int]]
-) -> Dict[Optional[str], List[Coin]]:
+    sim: SpendSim, sim_client: SimClient, requested_coins: dict[Optional[str], list[int]]
+) -> dict[Optional[str], list[Coin]]:
     await sim.farm_block(acs_ph)
-    parent_coin = [cr.coin for cr in await sim_client.get_coin_records_by_puzzle_hash(acs_ph)][0]
+    parent_coin = next(cr.coin for cr in await sim_client.get_coin_records_by_puzzle_hash(acs_ph))
 
     # We need to gather a list of initial coins to create as well as spends that do the eve spend for every CAT
     payments = []
@@ -87,7 +87,7 @@ async def generate_coins(
     await sim.farm_block()
 
     # Search for all of the coins and put them into a dictionary
-    coin_dict: Dict[Optional[str], List[Coin]] = {}
+    coin_dict: dict[Optional[str], list[Coin]] = {}
     for tail_str, _ in requested_coins.items():
         if tail_str:
             tail_hash = str_to_tail_hash(tail_str)
@@ -112,15 +112,15 @@ async def generate_coins(
 # `generate_secure_bundle` simulates a wallet's `generate_signed_transaction`
 # but doesn't bother with non-offer announcements
 def generate_secure_bundle(
-    selected_coins: List[Coin],
-    announcements: List[AssertPuzzleAnnouncement],
+    selected_coins: list[Coin],
+    announcements: list[AssertPuzzleAnnouncement],
     offered_amount: uint64,
     tail_str: Optional[str] = None,
 ) -> WalletSpendBundle:
     announcement_assertions = [a.to_program() for a in announcements]
     selected_coin_amount = sum(c.amount for c in selected_coins)
     non_primaries = [] if len(selected_coins) < 2 else selected_coins[1:]
-    inner_solution: List[Any] = [
+    inner_solution: list[Any] = [
         [51, Offer.ph(), offered_amount],  # Offered coin
         [51, acs_ph, uint64(selected_coin_amount - offered_amount)],  # Change
         *announcement_assertions,
@@ -178,7 +178,7 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
         driver_dict_as_infos = {key.hex(): value.info for key, value in driver_dict.items()}
 
         # Create an XCH Offer for RED
-        chia_requested_payments: Dict[Optional[bytes32], List[Payment]] = {
+        chia_requested_payments: dict[Optional[bytes32], list[Payment]] = {
             str_to_tail_hash("red"): [Payment(acs_ph, uint64(100), [b"memo"]), Payment(acs_ph, uint64(200), [b"memo"])]
         }
         chia_notarized_payments = Offer.notarize_payments(chia_requested_payments, chia_coins)
@@ -190,7 +190,7 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
         # Create a RED Offer for XCH
         red_coins_1 = red_coins[0:1]
         red_coins_2 = red_coins[1:]
-        red_requested_payments: Dict[Optional[bytes32], List[Payment]] = {
+        red_requested_payments: dict[Optional[bytes32], list[Payment]] = {
             None: [Payment(acs_ph, uint64(300), [b"red memo"]), Payment(acs_ph, uint64(350), [b"red memo"])]
         }
         red_notarized_payments = Offer.notarize_payments(red_requested_payments, red_coins_1)
@@ -201,7 +201,7 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
         red_offer = Offer(red_notarized_payments, red_secured_bundle, driver_dict)
         assert not red_offer.is_valid()
 
-        red_requested_payments_2: Dict[Optional[bytes32], List[Payment]] = {
+        red_requested_payments_2: dict[Optional[bytes32], list[Payment]] = {
             None: [Payment(acs_ph, uint64(50), [b"red memo"])]
         }
         red_notarized_payments_2 = Offer.notarize_payments(red_requested_payments_2, red_coins_2)
@@ -219,7 +219,7 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
         assert new_offer.is_valid()
 
         # Create yet another offer of BLUE for XCH and RED
-        blue_requested_payments: Dict[Optional[bytes32], List[Payment]] = {
+        blue_requested_payments: dict[Optional[bytes32], list[Payment]] = {
             None: [Payment(acs_ph, uint64(200), [b"blue memo"])],
             str_to_tail_hash("red"): [Payment(acs_ph, uint64(50), [b"blue memo"])],
         }
@@ -252,7 +252,7 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
 
         # Test preventing TAIL from running during exchange
         blue_cat_puz = construct_cat_puzzle(CAT_MOD, str_to_tail_hash("blue"), OFFER_MOD)
-        random_hash = bytes32([0] * 32)
+        random_hash = bytes32.zeros
         blue_spend = make_spend(
             Coin(random_hash, blue_cat_puz.get_tree_hash(), uint64(0)),
             blue_cat_puz,
@@ -261,7 +261,7 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
         new_spends_list = [blue_spend, *new_offer.to_spend_bundle().coin_spends]
         tail_offer = Offer.from_spend_bundle(WalletSpendBundle(new_spends_list, G2Element()))
         valid_spend = tail_offer.to_valid_spend(random_hash)
-        real_blue_spend = [spend for spend in valid_spend.coin_spends if b"hey there" in bytes(spend)][0]
+        real_blue_spend = next(spend for spend in valid_spend.coin_spends if b"hey there" in bytes(spend))
         real_blue_spend_replaced = real_blue_spend.replace(
             solution=SerializedProgram.from_program(
                 real_blue_spend.solution.to_program().replace(

chia/_tests/wallet/cat_wallet/test_trades.py

@@ -1,22 +1,24 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Dict, List, Union
+from typing import Any, Union
 
 import pytest
 from chia_rs import G2Element
 
 from chia._tests.conftest import SOFTFORK_HEIGHTS
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia._tests.util.time_out_assert import time_out_assert
 from chia._tests.wallet.vc_wallet.test_vc_wallet import mint_cr_cat
 from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bundle_tools import simple_solution_generator
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
+from chia.rpc.wallet_request_types import VCAddProofs, VCGetList, VCGetProofsForRoot, VCMint, VCSpend
 from chia.types.blockchain_format.program import INFINITE_COST, Program
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.spend_bundle import SpendBundle
+from chia.util.bech32m import encode_puzzle_hash
 from chia.util.hash import std_hash
 from chia.util.ints import uint32, uint64
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
@@ -36,7 +38,7 @@ from chia.wallet.vc_wallet.vc_store import VCProofs
 from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
-OfferSummary = Dict[Union[int, bytes32], int]
+OfferSummary = dict[Union[int, bytes32], int]
 
 
 async def get_trade_and_status(trade_manager: TradeManager, trade: TradeRecord) -> TradeStatus:
@@ -166,7 +168,7 @@ async def test_cat_trades(
         tail_taker = Program.to([3, (1, "taker"), None, None])
         proofs_checker_maker = ProofsChecker(["foo", "bar"])
         proofs_checker_taker = ProofsChecker(["bar", "zap"])
-        authorized_providers: List[bytes32] = [did_id_maker, did_id_taker]
+        authorized_providers: list[bytes32] = [did_id_maker, did_id_taker]
         cat_wallet_maker: CATWallet = await CRCATWallet.get_or_create_wallet_for_cat(
             wallet_node_maker.wallet_state_manager,
             wallet_maker,
@@ -237,12 +239,22 @@ async def test_cat_trades(
         # Mint some VCs that can spend the CR-CATs
         vc_record_maker = (
             await client_maker.vc_mint(
-                did_id_maker, wallet_environments.tx_config, target_address=await wallet_maker.get_new_puzzlehash()
+                VCMint(
+                    did_id=encode_puzzle_hash(did_id_maker, "did"),
+                    target_address=encode_puzzle_hash(await wallet_maker.get_new_puzzlehash(), "txch"),
+                    push=True,
+                ),
+                wallet_environments.tx_config,
             )
         ).vc_record
         vc_record_taker = (
             await client_taker.vc_mint(
-                did_id_taker, wallet_environments.tx_config, target_address=await wallet_taker.get_new_puzzlehash()
+                VCMint(
+                    did_id=encode_puzzle_hash(did_id_taker, "did"),
+                    target_address=encode_puzzle_hash(await wallet_taker.get_new_puzzlehash(), "txch"),
+                    push=True,
+                ),
+                wallet_environments.tx_config,
             )
         ).vc_record
         await wallet_environments.process_pending_states(
@@ -274,17 +286,23 @@ async def test_cat_trades(
         proofs_maker = VCProofs({"foo": "1", "bar": "1", "zap": "1"})
         proof_root_maker: bytes32 = proofs_maker.root()
         await client_maker.vc_spend(
-            vc_record_maker.vc.launcher_id,
+            VCSpend(
+                vc_id=vc_record_maker.vc.launcher_id,
+                new_proof_hash=proof_root_maker,
+                push=True,
+            ),
             wallet_environments.tx_config,
-            new_proof_hash=proof_root_maker,
         )
 
         proofs_taker = VCProofs({"foo": "1", "bar": "1", "zap": "1"})
         proof_root_taker: bytes32 = proofs_taker.root()
         await client_taker.vc_spend(
-            vc_record_taker.vc.launcher_id,
+            VCSpend(
+                vc_id=vc_record_taker.vc.launcher_id,
+                new_proof_hash=proof_root_taker,
+                push=True,
+            ),
             wallet_environments.tx_config,
-            new_proof_hash=proof_root_taker,
         )
         await wallet_environments.process_pending_states(
             [
@@ -374,17 +392,21 @@ async def test_cat_trades(
         )
 
     if credential_restricted:
-        await client_maker.vc_add_proofs(proofs_maker.key_value_pairs)
-        assert await client_maker.vc_get_proofs_for_root(proof_root_maker) == proofs_maker.key_value_pairs
-        vc_records, fetched_proofs = await client_maker.vc_get_list()
-        assert len(vc_records) == 1
-        assert fetched_proofs[proof_root_maker.hex()] == proofs_maker.key_value_pairs
-
-        await client_taker.vc_add_proofs(proofs_taker.key_value_pairs)
-        assert await client_taker.vc_get_proofs_for_root(proof_root_taker) == proofs_taker.key_value_pairs
-        vc_records, fetched_proofs = await client_taker.vc_get_list()
-        assert len(vc_records) == 1
-        assert fetched_proofs[proof_root_taker.hex()] == proofs_taker.key_value_pairs
+        await client_maker.vc_add_proofs(VCAddProofs.from_vc_proofs(proofs_maker))
+        assert (
+            await client_maker.vc_get_proofs_for_root(VCGetProofsForRoot(proof_root_maker))
+        ).to_vc_proofs().key_value_pairs == proofs_maker.key_value_pairs
+        get_list_reponse = await client_maker.vc_get_list(VCGetList())
+        assert len(get_list_reponse.vc_records) == 1
+        assert get_list_reponse.proof_dict[proof_root_maker] == proofs_maker.key_value_pairs
+
+        await client_taker.vc_add_proofs(VCAddProofs.from_vc_proofs(proofs_taker))
+        assert (
+            await client_taker.vc_get_proofs_for_root(VCGetProofsForRoot(proof_root_taker))
+        ).to_vc_proofs().key_value_pairs == proofs_taker.key_value_pairs
+        get_list_reponse = await client_taker.vc_get_list(VCGetList())
+        assert len(get_list_reponse.vc_records) == 1
+        assert get_list_reponse.proof_dict[proof_root_taker] == proofs_taker.key_value_pairs
 
     # Add the taker's CAT to the maker's wallet
     if credential_restricted:
@@ -445,10 +467,10 @@ async def test_cat_trades(
         new_cat_wallet_maker.id(): 15,
     }
 
-    driver_dict: Dict[bytes32, PuzzleInfo] = {}
+    driver_dict: dict[bytes32, PuzzleInfo] = {}
     for wallet in (cat_wallet_maker, new_cat_wallet_maker):
         asset_id: str = wallet.get_asset_id()
-        driver_item: Dict[str, Any] = {
+        driver_item: dict[str, Any] = {
             "type": AssetType.CAT.value,
             "tail": "0x" + asset_id,
         }
@@ -1701,7 +1723,7 @@ async def test_trade_cancellation(wallet_environments: WalletTestFramework) -> N
         wallet_environments.tx_config, push=False
     ) as action_scope:
         await trade_manager_maker.cancel_pending_offers(
-            [trade_make.trade_id, bytes32([0] * 32)], action_scope, secure=False
+            [trade_make.trade_id, bytes32.zeros], action_scope, secure=False
         )
     await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
 
@@ -1851,7 +1873,7 @@ async def test_trade_cancellation(wallet_environments: WalletTestFramework) -> N
     chia_and_cat_for_something: OfferSummary = {
         env_maker.wallet_aliases["xch"]: -5,
         env_maker.wallet_aliases["cat"]: -6,
-        bytes32([0] * 32): 1,  # Doesn't matter
+        bytes32.zeros: 1,  # Doesn't matter
     }
 
     # Now we're going to create the other way around for test coverage sake
@@ -1861,7 +1883,7 @@ async def test_trade_cancellation(wallet_environments: WalletTestFramework) -> N
         success, trade_make, error = await trade_manager_maker.create_offer_for_ids(
             chia_and_cat_for_something,
             action_scope,
-            driver_dict={bytes32([0] * 32): PuzzleInfo({"type": AssetType.CAT.value, "tail": "0x" + bytes(32).hex()})},
+            driver_dict={bytes32.zeros: PuzzleInfo({"type": AssetType.CAT.value, "tail": "0x" + bytes(32).hex()})},
         )
     assert error is None
     assert success is True
@@ -1876,8 +1898,8 @@ async def test_trade_cancellation(wallet_environments: WalletTestFramework) -> N
     total_spend = SpendBundle.aggregate(
         [tx.spend_bundle for tx in action_scope.side_effects.transactions if tx.spend_bundle is not None]
     )
-    all_conditions: List[Program] = []
-    creations: List[CreateCoinAnnouncement] = []
+    all_conditions: list[Program] = []
+    creations: list[CreateCoinAnnouncement] = []
     announcement_nonce = std_hash(trade_make.trade_id)
     for spend in total_spend.coin_spends:
         all_conditions.extend(

chia/_tests/wallet/clawback/test_clawback_decorator.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List, Tuple
-
 import pytest
 
 from chia.server.server import ChiaServer
@@ -19,7 +17,7 @@ from chia.wallet.wallet_node import WalletNode
 )
 @pytest.mark.anyio
 async def test_missing_decorator(
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
     trusted: bool,
     self_hostname: str,
 ) -> None:
@@ -39,7 +37,7 @@ async def test_missing_decorator(
 )
 @pytest.mark.anyio
 async def test_unknown_decorator(
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
     trusted: bool,
     self_hostname: str,
 ) -> None:
@@ -59,7 +57,7 @@ async def test_unknown_decorator(
 )
 @pytest.mark.anyio
 async def test_decorator(
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
     trusted: bool,
     self_hostname: str,
 ) -> None: