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

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -6,18 +6,21 @@ import io
 import json
 import logging
 import random
+from collections.abc import AsyncIterator
 from operator import attrgetter
 from typing import Any, Optional, cast
 from unittest.mock import patch
 
 import aiosqlite
 import pytest
-from chia_rs import G1Element, G2Element
+from chia_rs import CoinSpend, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint16, uint32, uint64
+from chia_rs.sized_ints import uint16, uint32, uint64, uint128
 
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
+from chia._tests.util.setup_nodes import SimulatorsAndWalletsServices
 from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_not_none
+from chia._tests.wallet.cat_wallet.test_cat_wallet import mint_cat
 from chia._tests.wallet.test_wallet_coin_store import (
     get_coin_records_amount_filter_tests,
     get_coin_records_amount_range_tests,
@@ -47,39 +50,16 @@ from chia._tests.wallet.test_wallet_coin_store import (
 from chia.cmds.coins import CombineCMD, SplitCMD
 from chia.cmds.param_types import CliAmount
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
-from chia.consensus.coinbase import create_puzzlehash_for_pk
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 from chia.rpc.rpc_client import ResponseFailureError
-from chia.rpc.rpc_server import RpcServer
-from chia.rpc.wallet_request_types import (
-    AddKey,
-    CheckDeleteKey,
-    CombineCoins,
-    DefaultCAT,
-    DeleteKey,
-    DIDGetPubkey,
-    GetNotifications,
-    GetPrivateKey,
-    GetSyncStatusResponse,
-    GetTimestampForHeight,
-    LogIn,
-    PushTransactions,
-    PushTX,
-    SetWalletResyncOnStartup,
-    SplitCoins,
-    VerifySignature,
-    VerifySignatureResponse,
-)
-from chia.rpc.wallet_rpc_api import WalletRpcApi
-from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.server.aliases import WalletService
 from chia.server.server import ChiaServer
-from chia.server.start_service import Service
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
 from chia.types.blockchain_format.coin import Coin, coin_as_list
 from chia.types.blockchain_format.program import Program
 from chia.types.coin_record import CoinRecord
-from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.coin_spend import make_spend
 from chia.types.peer_info import PeerInfo
 from chia.types.signing_mode import SigningMode
 from chia.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
@@ -90,6 +70,7 @@ from chia.util.streamable import ConversionError, InvalidTypeError
 from chia.wallet.cat_wallet.cat_constants import DEFAULT_CATS
 from chia.wallet.cat_wallet.cat_utils import CAT_MOD, construct_cat_puzzle
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
+from chia.wallet.cat_wallet.r_cat_wallet import RCATWallet
 from chia.wallet.conditions import (
     ConditionValidTimes,
     CreateCoinAnnouncement,
@@ -101,7 +82,10 @@ from chia.wallet.derive_keys import master_sk_to_wallet_sk, master_sk_to_wallet_
 from chia.wallet.did_wallet.did_wallet import DIDWallet
 from chia.wallet.nft_wallet.nft_wallet import NFTWallet
 from chia.wallet.puzzles.clawback.metadata import AutoClaimSettings
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 from chia.wallet.signer_protocol import UnsignedTransaction
+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.transaction_record import TransactionRecord
 from chia.wallet.transaction_sorting import SortKey
@@ -119,6 +103,44 @@ from chia.wallet.wallet_coin_record import WalletCoinRecord
 from chia.wallet.wallet_coin_store import GetCoinRecords
 from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_protocol import WalletProtocol
+from chia.wallet.wallet_request_types import (
+    AddKey,
+    CheckDeleteKey,
+    CombineCoins,
+    DefaultCAT,
+    DeleteKey,
+    DIDCreateBackupFile,
+    DIDGetDID,
+    DIDGetMetadata,
+    DIDGetPubkey,
+    DIDGetRecoveryList,
+    DIDGetWalletName,
+    DIDMessageSpend,
+    DIDSetWalletName,
+    DIDTransferDID,
+    DIDUpdateMetadata,
+    DIDUpdateRecoveryIDs,
+    FungibleAsset,
+    GetNotifications,
+    GetPrivateKey,
+    GetSyncStatusResponse,
+    GetTimestampForHeight,
+    LogIn,
+    NFTCalculateRoyalties,
+    NFTGetInfo,
+    NFTGetNFTs,
+    NFTMintNFTRequest,
+    NFTTransferNFT,
+    PushTransactions,
+    PushTX,
+    RoyaltyAsset,
+    SetWalletResyncOnStartup,
+    SplitCoins,
+    VerifySignature,
+    VerifySignatureResponse,
+)
+from chia.wallet.wallet_rpc_api import WalletRpcApi
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 log = logging.getLogger(__name__)
@@ -126,7 +148,7 @@ log = logging.getLogger(__name__)
 
 @dataclasses.dataclass
 class WalletBundle:
-    service: Service
+    service: WalletService
     node: WalletNode
     rpc_client: WalletRpcClient
     wallet: Wallet
@@ -150,29 +172,30 @@ async def check_client_synced(wallet_client: WalletRpcClient) -> bool:
     return (await wallet_client.get_sync_status()).synced
 
 
-async def farm_transaction_block(full_node_api: FullNodeSimulator, wallet_node: WalletNode):
+async def farm_transaction_block(full_node_api: FullNodeSimulator, wallet_node: WalletNode) -> None:
     await full_node_api.farm_blocks_to_puzzlehash(count=1)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
 
-def check_mempool_spend_count(full_node_api: FullNodeSimulator, num_of_spends):
+def check_mempool_spend_count(full_node_api: FullNodeSimulator, num_of_spends: int) -> bool:
     return full_node_api.full_node.mempool_manager.mempool.size() == num_of_spends
 
 
-async def farm_transaction(full_node_api: FullNodeSimulator, wallet_node: WalletNode, spend_bundle: WalletSpendBundle):
-    await time_out_assert(
-        20, full_node_api.full_node.mempool_manager.get_spendbundle, spend_bundle, spend_bundle.name()
-    )
+async def farm_transaction(
+    full_node_api: FullNodeSimulator, wallet_node: WalletNode, spend_bundle: WalletSpendBundle
+) -> None:
+    spend_bundle_name = spend_bundle.name()
+    await time_out_assert(20, full_node_api.full_node.mempool_manager.get_spendbundle, spend_bundle, spend_bundle_name)
     await farm_transaction_block(full_node_api, wallet_node)
-    assert full_node_api.full_node.mempool_manager.get_spendbundle(spend_bundle.name()) is None
+    assert full_node_api.full_node.mempool_manager.get_spendbundle(spend_bundle_name) is None
 
 
-async def generate_funds(full_node_api: FullNodeSimulator, wallet_bundle: WalletBundle, num_blocks: int = 1):
+async def generate_funds(full_node_api: FullNodeSimulator, wallet_bundle: WalletBundle, num_blocks: int = 1) -> int:
     wallet_id = 1
     initial_balances = await wallet_bundle.rpc_client.get_wallet_balance(wallet_id)
     ph: bytes32 = decode_puzzle_hash(await wallet_bundle.rpc_client.get_next_address(wallet_id, True))
     generated_funds = 0
-    for i in range(0, num_blocks):
+    for _ in range(num_blocks):
         await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
         peak_height = full_node_api.full_node.blockchain.get_peak_height()
         assert peak_height is not None
@@ -191,7 +214,9 @@ async def generate_funds(full_node_api: FullNodeSimulator, wallet_bundle: Wallet
 
 
 @pytest.fixture(scope="function", params=[True, False])
-async def wallet_rpc_environment(two_wallet_nodes_services, request, self_hostname):
+async def wallet_rpc_environment(
+    two_wallet_nodes_services: SimulatorsAndWalletsServices, request: pytest.FixtureRequest, self_hostname: str
+) -> AsyncIterator[WalletRpcTestEnvironment]:
     full_node, wallets, bt = two_wallet_nodes_services
     full_node_service = full_node[0]
     full_node_api = full_node_service._api
@@ -216,33 +241,42 @@ async def wallet_rpc_environment(two_wallet_nodes_services, request, self_hostna
     await wallet_node.server.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
     await wallet_node_2.server.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
 
+    assert wallet_service.rpc_server is not None
     async with WalletRpcClient.create_as_context(
         hostname, wallet_service.rpc_server.listen_port, wallet_service.root_path, wallet_service.config
     ) as client:
+        assert wallet_service_2.rpc_server is not None
         async with WalletRpcClient.create_as_context(
             hostname, wallet_service_2.rpc_server.listen_port, wallet_service_2.root_path, wallet_service_2.config
         ) as client_2:
+            assert full_node_service.rpc_server is not None
             async with FullNodeRpcClient.create_as_context(
                 hostname,
                 full_node_service.rpc_server.listen_port,
                 full_node_service.root_path,
                 full_node_service.config,
             ) as client_node:
-                wallet_bundle_1: WalletBundle = WalletBundle(wallet_service, wallet_node, client, wallet)
-                wallet_bundle_2: WalletBundle = WalletBundle(wallet_service_2, wallet_node_2, client_2, wallet_2)
-                node_bundle: FullNodeBundle = FullNodeBundle(full_node_server, full_node_api, client_node)
+                wallet_bundle_1 = WalletBundle(wallet_service, wallet_node, client, wallet)
+                wallet_bundle_2 = WalletBundle(wallet_service_2, wallet_node_2, client_2, wallet_2)
+                node_bundle = FullNodeBundle(full_node_server, full_node_api, client_node)
 
                 yield WalletRpcTestEnvironment(wallet_bundle_1, wallet_bundle_2, node_bundle)
 
 
 async def create_tx_outputs(wallet: Wallet, output_args: list[tuple[int, Optional[list[str]]]]) -> list[dict[str, Any]]:
     outputs = []
-    for args in output_args:
-        output = {"amount": uint64(args[0]), "puzzle_hash": await wallet.get_new_puzzlehash()}
-        if args[1] is not None:
-            assert len(args[1]) > 0
-            output["memos"] = args[1]
-        outputs.append(output)
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        for args in output_args:
+            output = {
+                "amount": uint64(args[0]),
+                "puzzle_hash": await action_scope.get_puzzle_hash(
+                    wallet.wallet_state_manager, override_reuse_puzhash_with=False
+                ),
+            }
+            if args[1] is not None:
+                assert len(args[1]) > 0
+                output["memos"] = args[1]
+            outputs.append(output)
     return outputs
 
 
@@ -278,7 +312,7 @@ def assert_tx_amounts(
         assert (sum(removal_amounts) - sum(addition_amounts)) == amount_fee
 
 
-async def assert_push_tx_error(node_rpc: FullNodeRpcClient, tx: TransactionRecord):
+async def assert_push_tx_error(node_rpc: FullNodeRpcClient, tx: TransactionRecord) -> None:
     spend_bundle = tx.spend_bundle
     assert spend_bundle is not None
     # check error for a ASSERT_ANNOUNCE_CONSUMED_FAILED and if the error is not there throw a value error
@@ -290,7 +324,7 @@ async def assert_push_tx_error(node_rpc: FullNodeRpcClient, tx: TransactionRecor
             raise ValueError from error
 
 
-async def assert_get_balance(rpc_client: WalletRpcClient, wallet_node: WalletNode, wallet: WalletProtocol) -> None:
+async def assert_get_balance(rpc_client: WalletRpcClient, wallet_node: WalletNode, wallet: WalletProtocol[Any]) -> None:
     expected_balance = await wallet_node.get_balance(wallet.id())
     expected_balance_dict = expected_balance.to_json_dict()
     expected_balance_dict["wallet_id"] = wallet.id()
@@ -302,21 +336,25 @@ async def assert_get_balance(rpc_client: WalletRpcClient, wallet_node: WalletNod
     assert await rpc_client.get_wallet_balance(wallet.id()) == expected_balance_dict
 
 
-async def tx_in_mempool(client: WalletRpcClient, transaction_id: bytes32):
+async def tx_in_mempool(client: WalletRpcClient, transaction_id: bytes32) -> bool:
     tx = await client.get_transaction(transaction_id)
     return tx.is_in_mempool()
 
 
-async def get_confirmed_balance(client: WalletRpcClient, wallet_id: int):
-    return (await client.get_wallet_balance(wallet_id))["confirmed_wallet_balance"]
+async def get_confirmed_balance(client: WalletRpcClient, wallet_id: int) -> uint128:
+    balance = await client.get_wallet_balance(wallet_id)
+    # TODO: casting due to lack of type checked deserialization
+    return cast(uint128, balance["confirmed_wallet_balance"])
 
 
-async def get_unconfirmed_balance(client: WalletRpcClient, wallet_id: int):
-    return (await client.get_wallet_balance(wallet_id))["unconfirmed_wallet_balance"]
+async def get_unconfirmed_balance(client: WalletRpcClient, wallet_id: int) -> uint128:
+    balance = await client.get_wallet_balance(wallet_id)
+    # TODO: casting due to lack of type checked deserialization
+    return cast(uint128, balance["unconfirmed_wallet_balance"])
 
 
 @pytest.mark.anyio
-async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_2: Wallet = env.wallet_2.wallet
@@ -326,7 +364,8 @@ async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment
 
     generated_funds = await generate_funds(full_node_api, env.wallet_1)
 
-    addr = encode_puzzle_hash(await wallet_2.get_new_puzzlehash(), "txch")
+    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        addr = encode_puzzle_hash(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager), "txch")
     tx_amount = uint64(15600000)
     with pytest.raises(ValueError):
         await client.send_transaction(1, uint64(100000000000000001), addr, DEFAULT_TX_CONFIG)
@@ -396,7 +435,7 @@ async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment
 
 
 @pytest.mark.anyio
-async def test_push_transactions(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_push_transactions(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet: Wallet = env.wallet_1.wallet
@@ -443,7 +482,7 @@ async def test_push_transactions(wallet_rpc_environment: WalletRpcTestEnvironmen
 
 
 @pytest.mark.anyio
-async def test_get_balance(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_get_balance(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env = wallet_rpc_environment
     wallet: Wallet = env.wallet_1.wallet
     wallet_node: WalletNode = env.wallet_1.node
@@ -465,7 +504,7 @@ async def test_get_balance(wallet_rpc_environment: WalletRpcTestEnvironment):
 
 
 @pytest.mark.anyio
-async def test_get_farmed_amount(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_get_farmed_amount(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env = wallet_rpc_environment
     wallet: Wallet = env.wallet_1.wallet
     full_node_api: FullNodeSimulator = env.full_node.api
@@ -491,7 +530,7 @@ async def test_get_farmed_amount(wallet_rpc_environment: WalletRpcTestEnvironmen
 
 
 @pytest.mark.anyio
-async def test_get_farmed_amount_with_fee(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_get_farmed_amount_with_fee(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env = wallet_rpc_environment
     wallet: Wallet = env.wallet_1.wallet
     full_node_api: FullNodeSimulator = env.full_node.api
@@ -508,8 +547,8 @@ async def test_get_farmed_amount_with_fee(wallet_rpc_environment: WalletRpcTestE
             action_scope=action_scope,
             fee=uint64(fee_amount),
         )
+        our_ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
 
-    our_ph = await wallet.get_new_puzzlehash()
     await full_node_api.wait_transaction_records_entered_mempool(records=action_scope.side_effects.transactions)
     await full_node_api.farm_blocks_to_puzzlehash(count=2, farm_to=our_ph, guarantee_transaction_blocks=True)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
@@ -519,7 +558,7 @@ async def test_get_farmed_amount_with_fee(wallet_rpc_environment: WalletRpcTestE
 
 
 @pytest.mark.anyio
-async def test_get_timestamp_for_height(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_get_timestamp_for_height(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     full_node_api: FullNodeSimulator = env.full_node.api
@@ -554,7 +593,7 @@ async def test_create_signed_transaction(
     fee: int,
     select_coin: bool,
     is_cat: bool,
-):
+) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_2: Wallet = env.wallet_2.wallet
@@ -574,7 +613,7 @@ async def test_create_signed_transaction(
         wallet_id = res["wallet_id"]
 
         await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
-        for i in range(5):
+        for _ in range(5):
             if check_mempool_spend_count(full_node_api, 0):
                 break
             await farm_transaction_block(full_node_api, wallet_1_node)
@@ -652,7 +691,9 @@ async def test_create_signed_transaction(
 
 
 @pytest.mark.anyio
-async def test_create_signed_transaction_with_coin_announcement(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_create_signed_transaction_with_coin_announcement(
+    wallet_rpc_environment: WalletRpcTestEnvironment,
+) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_2: Wallet = env.wallet_2.wallet
@@ -684,7 +725,9 @@ async def test_create_signed_transaction_with_coin_announcement(wallet_rpc_envir
 
 
 @pytest.mark.anyio
-async def test_create_signed_transaction_with_puzzle_announcement(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_create_signed_transaction_with_puzzle_announcement(
+    wallet_rpc_environment: WalletRpcTestEnvironment,
+) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_2: Wallet = env.wallet_2.wallet
@@ -765,7 +808,7 @@ async def test_create_signed_transaction_with_excluded_coins(wallet_rpc_environm
 
 
 @pytest.mark.anyio
-async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_1_node: WalletNode = env.wallet_1.node
@@ -779,9 +822,11 @@ async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnviron
 
     generated_funds = await generate_funds(full_node_api, env.wallet_1, 1)
     await generate_funds(full_node_api, env.wallet_2, 1)
-    wallet_1_puzhash = await wallet_1.get_new_puzzlehash()
+    async with wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        wallet_1_puzhash = await action_scope.get_puzzle_hash(wallet_1.wallet_state_manager)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_1_node, timeout=20)
-    wallet_2_puzhash = await wallet_2.get_new_puzzlehash()
+    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        wallet_2_puzhash = await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager)
     tx = (
         await wallet_1_rpc.send_transaction(
             wallet_id=1,
@@ -884,7 +929,7 @@ async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnviron
 
 
 @pytest.mark.anyio
-async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_2: Wallet = env.wallet_2.wallet
@@ -935,7 +980,7 @@ async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvir
 
 
 @pytest.mark.anyio
-async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet: Wallet = env.wallet_1.wallet
@@ -960,7 +1005,8 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
     assert all_transactions == sorted(all_transactions, key=attrgetter("confirmed_at_height"), reverse=True)
 
     # Test RELEVANCE
-    puzhash = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        puzhash = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
     await client.send_transaction(
         1, uint64(1), encode_puzzle_hash(puzhash, "txch"), DEFAULT_TX_CONFIG
@@ -979,7 +1025,8 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
     assert all_transactions == sorted_transactions
 
     # Test get_transactions to address
-    ph_by_addr = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph_by_addr = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
     await client.send_transaction(1, uint64(1), encode_puzzle_hash(ph_by_addr, "txch"), DEFAULT_TX_CONFIG)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
@@ -992,7 +1039,7 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
         1, type_filter=TransactionTypeFilter.include([TransactionType.COINBASE_REWARD])
     )
     assert len(all_transactions) == 5
-    assert all(transaction.type == TransactionType.COINBASE_REWARD for transaction in all_transactions)
+    assert all(transaction.type == TransactionType.COINBASE_REWARD.value for transaction in all_transactions)
     # Test confirmed filter
     all_transactions = await client.get_transactions(1, confirmed=True)
     assert len(all_transactions) == 10
@@ -1012,7 +1059,7 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
 
 
 @pytest.mark.anyio
-async def test_get_transaction_count(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_get_transaction_count(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     full_node_api: FullNodeSimulator = env.full_node.api
@@ -1032,23 +1079,34 @@ async def test_get_transaction_count(wallet_rpc_environment: WalletRpcTestEnviro
     assert transaction_count == 0
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [
+        {
+            "num_environments": 2,
+            "blocks_needed": [1, 1],
+        }
+    ],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
+@pytest.mark.parametrize("wallet_type", [CATWallet, RCATWallet])
 @pytest.mark.anyio
-async def test_cat_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    wallet_node: WalletNode = env.wallet_1.node
-
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    client_2: WalletRpcClient = env.wallet_2.rpc_client
-
-    full_node_api: FullNodeSimulator = env.full_node.api
-
-    await generate_funds(full_node_api, env.wallet_1, 1)
-    await generate_funds(full_node_api, env.wallet_2, 1)
-
+async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_type: type[CATWallet]) -> None:
+    env_0 = wallet_environments.environments[0]
+    env_1 = wallet_environments.environments[1]
+    env_0.wallet_aliases = {
+        "xch": 1,
+        "cat0": 2,
+        "cat1": 3,
+    }
+    env_1.wallet_aliases = {
+        "xch": 1,
+        "cat0": 2,
+    }
     # Test a deprecated path
     with pytest.raises(ValueError, match="dropped"):
-        await client.fetch(
+        await env_0.rpc_client.fetch(
             "create_new_wallet",
             {
                 "wallet_type": "cat_wallet",
@@ -1057,82 +1115,85 @@ async def test_cat_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
         )
 
     # Creates a CAT wallet with 100 mojos and a CAT with 20 mojos and fee=10
-    await client.create_new_cat_and_wallet(uint64(100), fee=uint64(10), test=True)
-    await time_out_assert(20, check_client_synced, True, client)
+    await mint_cat(
+        wallet_environments,
+        env_0,
+        "xch",
+        "cat0",
+        uint64(100),
+        wallet_type,
+        "cat0",
+    )
+    await mint_cat(
+        wallet_environments,
+        env_0,
+        "xch",
+        "cat1",
+        uint64(20),
+        wallet_type,
+        "cat1",
+    )
 
-    res = await client.create_new_cat_and_wallet(uint64(20), test=True)
-    assert res["success"]
-    cat_0_id = res["wallet_id"]
-    asset_id = bytes32.fromhex(res["asset_id"])
-    assert len(asset_id) > 0
-
-    await assert_wallet_types(client, {WalletType.STANDARD_WALLET: 1, WalletType.CAT: 2})
-    await assert_wallet_types(client_2, {WalletType.STANDARD_WALLET: 1})
-
-    bal_0 = await client.get_wallet_balance(cat_0_id)
-    assert bal_0["confirmed_wallet_balance"] == 0
-    assert bal_0["pending_coin_removal_count"] == 1
-    col = await client.get_cat_asset_id(cat_0_id)
-    assert col == asset_id
-    assert (await client.get_cat_name(cat_0_id)) == CATWallet.default_wallet_name_for_unknown_cat(asset_id.hex())
-    await client.set_cat_name(cat_0_id, "My cat")
-    assert (await client.get_cat_name(cat_0_id)) == "My cat"
-    result = await client.cat_asset_id_to_name(col)
+    cat_0_id = env_0.wallet_aliases["cat0"]
+    # The RPC response contains more than just the balance info but all the
+    # balance info should match. We're leveraging the `<=` operator to check
+    # for subset on `dict` `.items()`.
+    assert (
+        env_0.wallet_states[uint32(env_0.wallet_aliases["cat0"])].balance.to_json_dict().items()
+        <= (await env_0.rpc_client.get_wallet_balance(cat_0_id)).items()
+    )
+    asset_id = await env_0.rpc_client.get_cat_asset_id(cat_0_id)
+    assert (await env_0.rpc_client.get_cat_name(cat_0_id)) == wallet_type.default_wallet_name_for_unknown_cat(
+        asset_id.hex()
+    )
+    await env_0.rpc_client.set_cat_name(cat_0_id, "My cat")
+    assert (await env_0.rpc_client.get_cat_name(cat_0_id)) == "My cat"
+    result = await env_0.rpc_client.cat_asset_id_to_name(asset_id)
     assert result is not None
     wid, name = result
     assert wid == cat_0_id
     assert name == "My cat"
-    result = await client.cat_asset_id_to_name(bytes32.zeros)
+    result = await env_0.rpc_client.cat_asset_id_to_name(bytes32.zeros)
     assert result is None
     verified_asset_id = next(iter(DEFAULT_CATS.items()))[1]["asset_id"]
-    result = await client.cat_asset_id_to_name(bytes32.from_hexstr(verified_asset_id))
+    result = await env_0.rpc_client.cat_asset_id_to_name(bytes32.from_hexstr(verified_asset_id))
     assert result is not None
     should_be_none, name = result
     assert should_be_none is None
     assert name == next(iter(DEFAULT_CATS.items()))[1]["name"]
 
-    # make sure spend is in mempool before farming tx block
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 2)
-    for i in range(5):
-        if check_mempool_spend_count(full_node_api, 0):
-            break
-        await farm_transaction_block(full_node_api, wallet_node)
-
-    # check that we farmed the transaction
-    assert check_mempool_spend_count(full_node_api, 0)
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=5)
-
-    await time_out_assert(5, get_confirmed_balance, 20, client, cat_0_id)
-    bal_0 = await client.get_wallet_balance(cat_0_id)
-    assert bal_0["pending_coin_removal_count"] == 0
-    assert bal_0["unspent_coin_count"] == 1
-
     # Creates a second wallet with the same CAT
-    res = await client_2.create_wallet_for_existing_cat(asset_id)
+    res = await env_1.rpc_client.create_wallet_for_existing_cat(asset_id)
     assert res["success"]
     cat_1_id = res["wallet_id"]
     cat_1_asset_id = bytes.fromhex(res["asset_id"])
     assert cat_1_asset_id == asset_id
 
-    await assert_wallet_types(client, {WalletType.STANDARD_WALLET: 1, WalletType.CAT: 2})
-    await assert_wallet_types(client_2, {WalletType.STANDARD_WALLET: 1, WalletType.CAT: 1})
-
-    await farm_transaction_block(full_node_api, wallet_node)
-
-    bal_1 = await client_2.get_wallet_balance(cat_1_id)
-    assert bal_1["confirmed_wallet_balance"] == 0
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "cat0": {
+                        "init": True,
+                    }
+                },
+                post_block_balance_updates={},
+            ),
+        ]
+    )
 
-    addr_0 = await client.get_next_address(cat_0_id, False)
-    addr_1 = await client_2.get_next_address(cat_1_id, False)
+    addr_0 = await env_0.rpc_client.get_next_address(cat_0_id, False)
+    addr_1 = await env_1.rpc_client.get_next_address(cat_1_id, False)
 
     assert addr_0 != addr_1
 
     # Test CAT spend without a fee
     with pytest.raises(ValueError):
-        await client.cat_spend(
+        await env_0.rpc_client.cat_spend(
             cat_0_id,
             DEFAULT_TX_CONFIG.override(
-                excluded_coin_amounts=[uint64(20)],
+                excluded_coin_amounts=[uint64(100)],
                 excluded_coin_ids=[bytes32.zeros],
             ),
             uint64(4),
@@ -1140,53 +1201,146 @@ async def test_cat_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
             uint64(0),
             ["the cat memo"],
         )
-    tx_res = await client.cat_spend(cat_0_id, DEFAULT_TX_CONFIG, uint64(4), addr_1, uint64(0), ["the cat memo"])
+    tx_res = await env_0.rpc_client.cat_spend(
+        cat_0_id, wallet_environments.tx_config, uint64(4), addr_1, uint64(0), ["the cat memo"]
+    )
 
     spend_bundle = tx_res.transaction.spend_bundle
     assert spend_bundle is not None
     assert uncurry_puzzle(spend_bundle.coin_spends[0].puzzle_reveal).mod == CAT_MOD
-    await farm_transaction(full_node_api, wallet_node, spend_bundle)
 
-    await farm_transaction_block(full_node_api, wallet_node)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "cat0": {
+                        "unconfirmed_wallet_balance": -4,
+                        "spendable_balance": -100,
+                        "max_send_amount": -100,
+                        "pending_change": 96,
+                        "pending_coin_removal_count": 1,
+                    }
+                },
+                post_block_balance_updates={
+                    "cat0": {
+                        "confirmed_wallet_balance": -4,
+                        "spendable_balance": 96,
+                        "max_send_amount": 96,
+                        "pending_change": -96,
+                        "pending_coin_removal_count": -1,
+                    }
+                },
+            ),
+            WalletStateTransition(
+                pre_block_balance_updates={},
+                post_block_balance_updates={
+                    "cat0": {
+                        "confirmed_wallet_balance": 4,
+                        "unconfirmed_wallet_balance": 4,
+                        "spendable_balance": 4,
+                        "max_send_amount": 4,
+                        "unspent_coin_count": 1,
+                    }
+                },
+            ),
+        ]
+    )
 
     # Test CAT spend with a fee
-    tx_res = await client.cat_spend(cat_0_id, DEFAULT_TX_CONFIG, uint64(1), addr_1, uint64(5_000_000), ["the cat memo"])
+    tx_res = await env_0.rpc_client.cat_spend(
+        cat_0_id, wallet_environments.tx_config, uint64(1), addr_1, uint64(5_000_000), ["the cat memo"]
+    )
 
     spend_bundle = tx_res.transaction.spend_bundle
     assert spend_bundle is not None
-    await farm_transaction(full_node_api, wallet_node, spend_bundle)
+
+    cat_spend_changes = [
+        WalletStateTransition(
+            pre_block_balance_updates={
+                "xch": {
+                    "unconfirmed_wallet_balance": -5_000_000,
+                    "<=#spendable_balance": -5_000_000,
+                    "<=#max_send_amount": -5_000_000,
+                    ">=#pending_change": 1,  # any amount increase
+                    "unspent_coin_count": 0,
+                    "pending_coin_removal_count": 1,
+                },
+                "cat0": {
+                    "unconfirmed_wallet_balance": -1,
+                    "<=#spendable_balance": -1,
+                    "<=#max_send_amount": -1,
+                    ">=#pending_change": 1,
+                    "pending_coin_removal_count": 1,
+                },
+            },
+            post_block_balance_updates={
+                "xch": {
+                    "confirmed_wallet_balance": -5_000_000,
+                    ">=#spendable_balance": 1,  # any amount increase
+                    ">=#max_send_amount": 1,  # any amount increase
+                    "<=#pending_change": -1,  # any amount decrease
+                    "unspent_coin_count": 0,
+                    "pending_coin_removal_count": -1,
+                },
+                "cat0": {
+                    "confirmed_wallet_balance": -1,
+                    ">=#spendable_balance": 1,  # any amount increase
+                    ">=#max_send_amount": 1,  # any amount increase
+                    "<=#pending_change": -1,  # any amount decrease
+                    "pending_coin_removal_count": -1,
+                },
+            },
+        ),
+        WalletStateTransition(
+            pre_block_balance_updates={},
+            post_block_balance_updates={
+                "cat0": {
+                    "confirmed_wallet_balance": 1,
+                    "unconfirmed_wallet_balance": 1,
+                    "spendable_balance": 1,
+                    "max_send_amount": 1,
+                    "unspent_coin_count": 1,
+                },
+            },
+        ),
+    ]
+    await wallet_environments.process_pending_states(cat_spend_changes)
 
     # Test CAT spend with a fee and pre-specified removals / coins
-    removals = await client.select_coins(
-        amount=uint64(2), wallet_id=cat_0_id, coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+    removals = await env_0.rpc_client.select_coins(
+        amount=uint64(2), wallet_id=cat_0_id, coin_selection_config=wallet_environments.tx_config.coin_selection_config
     )
-    tx_res = await client.cat_spend(
-        cat_0_id, DEFAULT_TX_CONFIG, uint64(1), addr_1, uint64(5_000_000), ["the cat memo"], removals=removals
+    tx_res = await env_0.rpc_client.cat_spend(
+        cat_0_id,
+        wallet_environments.tx_config,
+        uint64(1),
+        addr_1,
+        uint64(5_000_000),
+        ["the cat memo"],
+        removals=removals,
     )
 
     spend_bundle = tx_res.transaction.spend_bundle
     assert spend_bundle is not None
     assert removals[0] in {removal for tx in tx_res.transactions for removal in tx.removals}
-    await farm_transaction(full_node_api, wallet_node, spend_bundle)
+
+    await wallet_environments.process_pending_states(cat_spend_changes)
 
     # Test unacknowledged CAT
-    await wallet_node.wallet_state_manager.interested_store.add_unacknowledged_token(
+    await env_0.wallet_state_manager.interested_store.add_unacknowledged_token(
         asset_id, "Unknown", uint32(10000), bytes32(b"\00" * 32)
     )
-    cats = await client.get_stray_cats()
+    cats = await env_0.rpc_client.get_stray_cats()
     assert len(cats) == 1
 
-    await time_out_assert(20, get_confirmed_balance, 14, client, cat_0_id)
-    await time_out_assert(20, get_confirmed_balance, 6, client_2, cat_1_id)
-
     # Test CAT coin selection
-    selected_coins = await client.select_coins(
-        amount=1, wallet_id=cat_0_id, coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+    selected_coins = await env_0.rpc_client.select_coins(
+        amount=1, wallet_id=cat_0_id, coin_selection_config=wallet_environments.tx_config.coin_selection_config
     )
     assert len(selected_coins) > 0
 
     # Test get_cat_list
-    cat_list = (await client.get_cat_list()).cat_list
+    cat_list = (await env_0.rpc_client.get_cat_list()).cat_list
     assert len(DEFAULT_CATS) == len(cat_list)
     default_cats_set = {
         DefaultCAT(asset_id=bytes32.from_hexstr(cat["asset_id"]), name=cat["name"], symbol=cat["symbol"])
@@ -1196,7 +1350,7 @@ async def test_cat_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
 
 
 @pytest.mark.anyio
-async def test_offer_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_offer_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_node: WalletNode = env.wallet_1.node
@@ -1315,14 +1469,14 @@ async def test_offer_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment)
 
     await farm_transaction_block(full_node_api, wallet_node)
 
-    async def is_trade_confirmed(client, trade) -> bool:
-        trade_record = await client.get_offer(trade.name())
+    async def is_trade_confirmed(client: WalletRpcClient, offer: Offer) -> bool:
+        trade_record = await client.get_offer(offer.name())
         return TradeStatus(trade_record.status) == TradeStatus.CONFIRMED
 
     await time_out_assert(15, is_trade_confirmed, True, wallet_1_rpc, offer)
 
     # Test trade sorting
-    def only_ids(trades):
+    def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
         return [t.trade_id for t in trades]
 
     trade_record = await wallet_1_rpc.get_offer(offer.name())
@@ -1403,7 +1557,10 @@ async def test_get_coin_records_by_names(wallet_rpc_environment: WalletRpcTestEn
     full_node_api = env.full_node.api
     # Generate some funds
     generated_funds = await generate_funds(full_node_api, env.wallet_1, 5)
-    address = encode_puzzle_hash(await env.wallet_1.wallet.get_new_puzzlehash(), "txch")
+    async with env.wallet_1.wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        address = encode_puzzle_hash(
+            await action_scope.get_puzzle_hash(env.wallet_1.wallet.wallet_state_manager), "txch"
+        )
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
     # Spend half of it back to the same wallet get some spent coins in the wallet
@@ -1448,7 +1605,7 @@ async def test_get_coin_records_by_names(wallet_rpc_environment: WalletRpcTestEn
 
 
 @pytest.mark.anyio
-async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_1: Wallet = env.wallet_1.wallet
@@ -1469,57 +1626,67 @@ async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
     did_id_0 = res["my_did"]
 
     # Get wallet name
-    res = await wallet_1_rpc.did_get_wallet_name(did_wallet_id_0)
-    assert res["success"]
-    assert res["name"] == "Profile 1"
-    nft_wallet: WalletProtocol = wallet_1_node.wallet_state_manager.wallets[did_wallet_id_0 + 1]
+    get_name_res = await wallet_1_rpc.did_get_wallet_name(DIDGetWalletName(did_wallet_id_0))
+    assert get_name_res.name == "Profile 1"
+    nft_wallet = wallet_1_node.wallet_state_manager.wallets[did_wallet_id_0 + 1]
     assert isinstance(nft_wallet, NFTWallet)
     assert nft_wallet.get_name() == "Profile 1 NFT Wallet"
 
     # Set wallet name
     new_wallet_name = "test name"
-    res = await wallet_1_rpc.did_set_wallet_name(did_wallet_id_0, new_wallet_name)
-    assert res["success"]
-    res = await wallet_1_rpc.did_get_wallet_name(did_wallet_id_0)
-    assert res["success"]
-    assert res["name"] == new_wallet_name
+    await wallet_1_rpc.did_set_wallet_name(DIDSetWalletName(did_wallet_id_0, new_wallet_name))
+    get_name_res = await wallet_1_rpc.did_get_wallet_name(DIDGetWalletName(did_wallet_id_0))
+    assert get_name_res.name == new_wallet_name
     with pytest.raises(ValueError, match="wallet id 1 is of type Wallet but type DIDWallet is required"):
-        await wallet_1_rpc.did_set_wallet_name(wallet_1_id, new_wallet_name)
+        await wallet_1_rpc.did_set_wallet_name(DIDSetWalletName(wallet_1_id, new_wallet_name))
 
     # Check DID ID
-    res = await wallet_1_rpc.get_did_id(did_wallet_id_0)
-    assert res["success"]
-    assert did_id_0 == res["my_did"]
+    did_id_res = await wallet_1_rpc.get_did_id(DIDGetDID(did_wallet_id_0))
+    assert did_id_0 == did_id_res.my_did
     # Create backup file
-    res = await wallet_1_rpc.create_did_backup_file(did_wallet_id_0, "backup.did")
-    assert res["success"]
+    await wallet_1_rpc.create_did_backup_file(DIDCreateBackupFile(did_wallet_id_0))
 
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
     await farm_transaction_block(full_node_api, wallet_1_node)
     # Update recovery list
-    update_res = await wallet_1_rpc.update_did_recovery_list(did_wallet_id_0, [did_id_0], 1, DEFAULT_TX_CONFIG)
+    update_res = await wallet_1_rpc.update_did_recovery_list(
+        DIDUpdateRecoveryIDs(
+            wallet_id=uint32(did_wallet_id_0), new_list=[did_id_0], num_verifications_required=uint64(1), push=True
+        ),
+        DEFAULT_TX_CONFIG,
+    )
     assert len(update_res.transactions) > 0
-    res = await wallet_1_rpc.get_did_recovery_list(did_wallet_id_0)
-    assert res["num_required"] == 1
-    assert res["recovery_list"][0] == did_id_0
+    recovery_list_res = await wallet_1_rpc.get_did_recovery_list(DIDGetRecoveryList(did_wallet_id_0))
+    assert recovery_list_res.num_required == 1
+    assert recovery_list_res.recovery_list[0] == did_id_0
 
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
     await farm_transaction_block(full_node_api, wallet_1_node)
 
     # Update metadata
     with pytest.raises(ValueError, match="wallet id 1 is of type Wallet but type DIDWallet is required"):
-        await wallet_1_rpc.update_did_metadata(wallet_1_id, {"Twitter": "Https://test"}, DEFAULT_TX_CONFIG)
-    await wallet_1_rpc.update_did_metadata(did_wallet_id_0, {"Twitter": "Https://test"}, DEFAULT_TX_CONFIG)
+        await wallet_1_rpc.update_did_metadata(
+            DIDUpdateMetadata(wallet_id=wallet_1_id, metadata={"Twitter": "Https://test"}, push=True), DEFAULT_TX_CONFIG
+        )
+    await wallet_1_rpc.update_did_metadata(
+        DIDUpdateMetadata(wallet_id=did_wallet_id_0, metadata={"Twitter": "Https://test"}, push=True), DEFAULT_TX_CONFIG
+    )
 
-    res = await wallet_1_rpc.get_did_metadata(did_wallet_id_0)
-    assert res["metadata"]["Twitter"] == "Https://test"
+    get_metadata_res = await wallet_1_rpc.get_did_metadata(DIDGetMetadata(did_wallet_id_0))
+    assert get_metadata_res.metadata["Twitter"] == "Https://test"
 
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
     await farm_transaction_block(full_node_api, wallet_1_node)
 
     # Transfer DID
-    addr = encode_puzzle_hash(await wallet_2.get_new_puzzlehash(), "txch")
-    await wallet_1_rpc.did_transfer_did(did_wallet_id_0, addr, 0, True, DEFAULT_TX_CONFIG)
+    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        addr = encode_puzzle_hash(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager), "txch")
+    await wallet_1_rpc.did_transfer_did(
+        DIDTransferDID(
+            wallet_id=did_wallet_id_0, inner_address=addr, fee=uint64(0), with_recovery_info=True, push=True
+        ),
+        DEFAULT_TX_CONFIG,
+    )
 
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
     await farm_transaction_block(full_node_api, wallet_1_node)
@@ -1531,11 +1698,11 @@ async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
 
     did_wallets = list(
         filter(
-            lambda w: (w.type == WalletType.DECENTRALIZED_ID),
+            lambda w: (w.type == WalletType.DECENTRALIZED_ID.value),
             await wallet_2_node.wallet_state_manager.get_all_wallet_info_entries(),
         )
     )
-    did_wallet_2: WalletProtocol = wallet_2_node.wallet_state_manager.wallets[did_wallets[0].id]
+    did_wallet_2 = wallet_2_node.wallet_state_manager.wallets[did_wallets[0].id]
     assert isinstance(did_wallet_2, DIDWallet)
     assert (
         encode_puzzle_hash(bytes32.from_hexstr(did_wallet_2.get_my_DID()), AddressType.DID.hrp(wallet_2_node.config))
@@ -1545,7 +1712,7 @@ async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
     assert metadata["Twitter"] == "Https://test"
 
     last_did_coin = await did_wallet_2.get_coin()
-    await wallet_2_rpc.did_message_spend(did_wallet_2.id(), DEFAULT_TX_CONFIG, push=True)
+    await wallet_2_rpc.did_message_spend(DIDMessageSpend(wallet_id=did_wallet_2.id(), push=True), DEFAULT_TX_CONFIG)
     await wallet_2_node.wallet_state_manager.add_interested_coin_ids([last_did_coin.name()])
 
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
@@ -1555,7 +1722,9 @@ async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
     assert next_did_coin.parent_coin_info == last_did_coin.name()
     last_did_coin = next_did_coin
 
-    await wallet_2_rpc.did_message_spend(did_wallet_2.id(), DEFAULT_TX_CONFIG.override(reuse_puzhash=True), push=True)
+    await wallet_2_rpc.did_message_spend(
+        DIDMessageSpend(wallet_id=did_wallet_2.id(), push=True), DEFAULT_TX_CONFIG.override(reuse_puzhash=True)
+    )
     await wallet_2_node.wallet_state_manager.add_interested_coin_ids([last_did_coin.name()])
 
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
@@ -1571,7 +1740,7 @@ async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
 
 
 @pytest.mark.anyio
-async def test_nft_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_nft_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
     wallet_1_node: WalletNode = env.wallet_1.node
     wallet_1_rpc: WalletRpcClient = env.wallet_1.rpc_client
@@ -1585,12 +1754,15 @@ async def test_nft_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
     res = await wallet_1_rpc.create_new_nft_wallet(None)
     nft_wallet_id = res["wallet_id"]
     mint_res = await wallet_1_rpc.mint_nft(
-        nft_wallet_id,
-        None,
-        None,
-        "0xD4584AD463139FA8C0D9F68F4B59F185",
-        ["https://www.chia.net/img/branding/chia-logo.svg"],
-        DEFAULT_TX_CONFIG,
+        request=NFTMintNFTRequest(
+            wallet_id=nft_wallet_id,
+            royalty_address=None,
+            target_address=None,
+            hash=bytes32.from_hexstr("0xD4584AD463139FA8C0D9F68F4B59F185D4584AD463139FA8C0D9F68F4B59F185"),
+            uris=["https://www.chia.net/img/branding/chia-logo.svg"],
+            push=True,
+        ),
+        tx_config=DEFAULT_TX_CONFIG,
     )
 
     spend_bundle = mint_res.spend_bundle
@@ -1599,27 +1771,32 @@ async def test_nft_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
 
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_1_node, timeout=15)
 
-    nft_wallet: WalletProtocol = wallet_1_node.wallet_state_manager.wallets[nft_wallet_id]
+    nft_wallet = wallet_1_node.wallet_state_manager.wallets[nft_wallet_id]
     assert isinstance(nft_wallet, NFTWallet)
 
-    async def have_nfts():
+    async def have_nfts() -> bool:
         return await nft_wallet.get_nft_count() > 0
 
     await time_out_assert(15, have_nfts, True)
 
     # Test with the hex version of nft_id
     nft_id = (await nft_wallet.get_current_nfts())[0].coin.name().hex()
-    nft_info = (await wallet_1_rpc.get_nft_info(nft_id))["nft_info"]
-    assert nft_info["nft_coin_id"][2:] == (await nft_wallet.get_current_nfts())[0].coin.name().hex()
+    with pytest.raises(ResponseFailureError, match="Invalid Coin ID format for 'coin_id'"):
+        await wallet_1_rpc.get_nft_info(NFTGetInfo("error"))
+    nft_info = (await wallet_1_rpc.get_nft_info(NFTGetInfo(nft_id))).nft_info
+    assert nft_info.nft_coin_id == (await nft_wallet.get_current_nfts())[0].coin.name()
     # Test with the bech32m version of nft_id
     hmr_nft_id = encode_puzzle_hash(
         (await nft_wallet.get_current_nfts())[0].coin.name(), AddressType.NFT.hrp(wallet_1_node.config)
     )
-    nft_info = (await wallet_1_rpc.get_nft_info(hmr_nft_id))["nft_info"]
-    assert nft_info["nft_coin_id"][2:] == (await nft_wallet.get_current_nfts())[0].coin.name().hex()
+    nft_info = (await wallet_1_rpc.get_nft_info(NFTGetInfo(hmr_nft_id))).nft_info
+    assert nft_info.nft_coin_id == (await nft_wallet.get_current_nfts())[0].coin.name()
 
-    addr = encode_puzzle_hash(await wallet_2.get_new_puzzlehash(), "txch")
-    await wallet_1_rpc.transfer_nft(nft_wallet_id, nft_id, addr, 0, DEFAULT_TX_CONFIG)
+    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        addr = encode_puzzle_hash(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager), "txch")
+    await wallet_1_rpc.transfer_nft(
+        NFTTransferNFT(wallet_id=nft_wallet_id, nft_coin_id=nft_id, target_address=addr, push=True), DEFAULT_TX_CONFIG
+    )
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
     await farm_transaction_block(full_node_api, wallet_1_node)
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 0)
@@ -1630,26 +1807,71 @@ async def test_nft_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
     nft_wallet_id_1 = (
         await wallet_2_node.wallet_state_manager.get_all_wallet_info_entries(wallet_type=WalletType.NFT)
     )[0].id
-    nft_wallet_1: WalletProtocol = wallet_2_node.wallet_state_manager.wallets[nft_wallet_id_1]
+    nft_wallet_1 = wallet_2_node.wallet_state_manager.wallets[nft_wallet_id_1]
     assert isinstance(nft_wallet_1, NFTWallet)
-    nft_info_1 = (await wallet_1_rpc.get_nft_info(nft_id, False))["nft_info"]
+    nft_info_1 = (await wallet_1_rpc.get_nft_info(NFTGetInfo(nft_id, False))).nft_info
     assert nft_info_1 == nft_info
-    nft_info_1 = (await wallet_1_rpc.get_nft_info(nft_id))["nft_info"]
-    assert nft_info_1["nft_coin_id"][2:] == (await nft_wallet_1.get_current_nfts())[0].coin.name().hex()
+    nft_info_1 = (await wallet_1_rpc.get_nft_info(NFTGetInfo(nft_id))).nft_info
+    assert nft_info_1.nft_coin_id == (await nft_wallet_1.get_current_nfts())[0].coin.name()
     # Cross-check NFT
-    nft_info_2 = (await wallet_2_rpc.list_nfts(nft_wallet_id_1))["nft_list"][0]
+    nft_info_2 = (await wallet_2_rpc.list_nfts(NFTGetNFTs(nft_wallet_id_1))).nft_list[0]
+    assert nft_info_1 == nft_info_2
+    nft_info_2 = (await wallet_2_rpc.list_nfts(NFTGetNFTs())).nft_list[0]
     assert nft_info_1 == nft_info_2
 
     # Test royalty endpoint
+    with pytest.raises(ValueError, match="Multiple royalty assets with same name specified"):
+        await wallet_1_rpc.nft_calculate_royalties(
+            NFTCalculateRoyalties(
+                [
+                    RoyaltyAsset(
+                        "my asset",
+                        "my address",
+                        uint16(10000),
+                    ),
+                    RoyaltyAsset(
+                        "my asset",
+                        "some other address",
+                        uint16(11111),
+                    ),
+                ],
+                [],
+            )
+        )
+    with pytest.raises(ValueError, match="Multiple fungible assets with same name specified"):
+        await wallet_1_rpc.nft_calculate_royalties(
+            NFTCalculateRoyalties(
+                [],
+                [
+                    FungibleAsset(
+                        None,
+                        uint64(10000),
+                    ),
+                    FungibleAsset(
+                        None,
+                        uint64(11111),
+                    ),
+                ],
+            )
+        )
     royalty_summary = await wallet_1_rpc.nft_calculate_royalties(
-        {
-            "my asset": ("my address", uint16(10000)),
-        },
-        {
-            None: uint64(10000),
-        },
+        NFTCalculateRoyalties(
+            [
+                RoyaltyAsset(
+                    "my asset",
+                    "my address",
+                    uint16(10000),
+                )
+            ],
+            [
+                FungibleAsset(
+                    None,
+                    uint64(10000),
+                )
+            ],
+        )
     )
-    assert royalty_summary == {
+    assert royalty_summary.to_json_dict() == {
         "my asset": [
             {
                 "asset": None,
@@ -1669,11 +1891,11 @@ async def _check_delete_key(
 
     sk = await wallet_node.get_key_for_fingerprint(farmer_fp, private=True)
     assert sk is not None
-    farmer_ph = create_puzzlehash_for_pk(create_sk(sk, uint32(0)).get_g1())
+    farmer_ph = puzzle_hash_for_pk(create_sk(sk, uint32(0)).get_g1())
 
     sk = await wallet_node.get_key_for_fingerprint(pool_fp, private=True)
     assert sk is not None
-    pool_ph = create_puzzlehash_for_pk(create_sk(sk, uint32(0)).get_g1())
+    pool_ph = puzzle_hash_for_pk(create_sk(sk, uint32(0)).get_g1())
 
     with lock_and_load_config(wallet_node.root_path, "config.yaml") as test_config:
         test_config["farmer"]["xch_target_address"] = encode_puzzle_hash(farmer_ph, "txch")
@@ -1700,7 +1922,7 @@ async def _check_delete_key(
 
 
 @pytest.mark.anyio
-async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet: Wallet = env.wallet_1.wallet
@@ -1717,7 +1939,8 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
 
     assert (await client.get_height_info()).height > 0
 
-    ph = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
     addr = encode_puzzle_hash(ph, "txch")
     tx_amount = uint64(15600000)
     await env.full_node.api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
@@ -1792,7 +2015,7 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
 
 
 @pytest.mark.anyio
-async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_2: Wallet = env.wallet_2.wallet
@@ -1803,7 +2026,8 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
 
     funds = await generate_funds(full_node_api, env.wallet_1)
 
-    addr = encode_puzzle_hash(await wallet_2.get_new_puzzlehash(), "txch")
+    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        addr = encode_puzzle_hash(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager), "txch")
     coin_300: list[Coin]
     tx_amounts: list[uint64] = [uint64(1000), uint64(300), uint64(1000), uint64(1000), uint64(10000)]
     for tx_amount in tx_amounts:
@@ -1923,7 +2147,7 @@ async def test_get_coin_records_rpc(wallet_rpc_environment: WalletRpcTestEnviron
         test_request: GetCoinRecords,
         test_total_count: Optional[int],
         test_records: list[WalletCoinRecord],
-    ):
+    ) -> None:
         response = await client.get_coin_records(test_request)
         assert response["coin_records"] == [coin.to_json_dict_parsed_metadata() for coin in test_records], test_case
         assert response["total_count"] == test_total_count, test_case
@@ -1962,9 +2186,9 @@ async def test_get_coin_records_rpc_limits(
     env: WalletRpcTestEnvironment = wallet_rpc_environment
     wallet_node: WalletNode = env.wallet_1.node
     client: WalletRpcClient = env.wallet_1.rpc_client
-    rpc_server: Optional[RpcServer] = wallet_rpc_environment.wallet_1.service.rpc_server
+    rpc_server = wallet_rpc_environment.wallet_1.service.rpc_server
     assert rpc_server is not None
-    api: WalletRpcApi = cast(WalletRpcApi, rpc_server.rpc_api)
+    api: WalletRpcApi = rpc_server.rpc_api
     store = wallet_node.wallet_state_manager.coin_store
 
     # Adjust the limits for faster testing
@@ -2034,9 +2258,9 @@ async def test_get_coin_records_rpc_failures(
 ) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
     client: WalletRpcClient = env.wallet_1.rpc_client
-    rpc_server: Optional[RpcServer] = wallet_rpc_environment.wallet_1.service.rpc_server
+    rpc_server = wallet_rpc_environment.wallet_1.service.rpc_server
     assert rpc_server is not None
-    api = cast(WalletRpcApi, rpc_server.rpc_api)
+    api = rpc_server.rpc_api
 
     too_many_hashes = [bytes32.random(seeded_random) for _ in range(api.max_get_coin_records_filter_items + 1)]
     too_many_amounts = [
@@ -2076,7 +2300,7 @@ async def test_get_coin_records_rpc_failures(
 
 
 @pytest.mark.anyio
-async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_2: Wallet = env.wallet_2.wallet
@@ -2089,12 +2313,13 @@ async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironmen
 
     env.wallet_2.node.config["enable_notifications"] = True
     env.wallet_2.node.config["required_notification_amount"] = 100000000000
-    tx = await client.send_notification(
-        await wallet_2.get_new_puzzlehash(),
-        b"hello",
-        uint64(100000000000),
-        fee=uint64(100000000000),
-    )
+    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        tx = await client.send_notification(
+            await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager),
+            b"hello",
+            uint64(100000000000),
+            fee=uint64(100000000000),
+        )
 
     assert tx.spend_bundle is not None
     await time_out_assert(
@@ -2115,12 +2340,13 @@ async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironmen
     assert await client_2.delete_notifications()
     assert [] == (await client_2.get_notifications(GetNotifications([notification.id]))).notifications
 
-    tx = await client.send_notification(
-        await wallet_2.get_new_puzzlehash(),
-        b"hello",
-        uint64(100000000000),
-        fee=uint64(100000000000),
-    )
+    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        tx = await client.send_notification(
+            await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager),
+            b"hello",
+            uint64(100000000000),
+            fee=uint64(100000000000),
+        )
 
     assert tx.spend_bundle is not None
     await time_out_assert(
@@ -2277,10 +2503,10 @@ async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironmen
 async def test_verify_signature(
     wallet_rpc_environment: WalletRpcTestEnvironment,
     rpc_request: dict[str, Any],
-    rpc_response: dict[str, Any],
+    rpc_response: VerifySignatureResponse,
     prefix_hex_strings: bool,
-):
-    rpc_server: Optional[RpcServer] = wallet_rpc_environment.wallet_1.service.rpc_server
+) -> None:
+    rpc_server = wallet_rpc_environment.wallet_1.service.rpc_server
     assert rpc_server is not None
     updated_request = rpc_request.copy()
     updated_request["pubkey"] = ("0x" if prefix_hex_strings else "") + updated_request["pubkey"]
@@ -2293,13 +2519,13 @@ async def test_verify_signature(
 
 @pytest.mark.anyio
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
-async def test_set_auto_claim(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_set_auto_claim(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
     full_node_api: FullNodeSimulator = env.full_node.api
-    rpc_server: Optional[RpcServer] = wallet_rpc_environment.wallet_1.service.rpc_server
+    rpc_server = wallet_rpc_environment.wallet_1.service.rpc_server
     await generate_funds(full_node_api, env.wallet_1)
     assert rpc_server is not None
-    api: WalletRpcApi = cast(WalletRpcApi, rpc_server.rpc_api)
+    api: WalletRpcApi = rpc_server.rpc_api
     req = {"enabled": False, "tx_fee": -1, "min_amount": 100}
     has_exception = False
     try:
@@ -2320,10 +2546,10 @@ async def test_set_auto_claim(wallet_rpc_environment: WalletRpcTestEnvironment):
 
 @pytest.mark.anyio
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
-async def test_get_auto_claim(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_get_auto_claim(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
     full_node_api: FullNodeSimulator = env.full_node.api
-    rpc_server: Optional[RpcServer] = wallet_rpc_environment.wallet_1.service.rpc_server
+    rpc_server = wallet_rpc_environment.wallet_1.service.rpc_server
     await generate_funds(full_node_api, env.wallet_1)
     assert rpc_server is not None
     res = await env.wallet_1.rpc_client.get_auto_claim()
@@ -2334,7 +2560,7 @@ async def test_get_auto_claim(wallet_rpc_environment: WalletRpcTestEnvironment):
 
 
 @pytest.mark.anyio
-async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
     full_node_api: FullNodeSimulator = env.full_node.api
     client: WalletRpcClient = env.wallet_1.rpc_client
@@ -2349,12 +2575,15 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
     nft_wallet_id = nft_wallet["wallet_id"]
     address = await wc.get_next_address(env.wallet_1.wallet.id(), True)
     await wc.mint_nft(
-        nft_wallet_id,
+        request=NFTMintNFTRequest(
+            wallet_id=nft_wallet_id,
+            royalty_address=address,
+            target_address=address,
+            hash=bytes32.from_hexstr("0xD4584AD463139FA8C0D9F68F4B59F185D4584AD463139FA8C0D9F68F4B59F185"),
+            uris=["http://test.nft"],
+            push=True,
+        ),
         tx_config=DEFAULT_TX_CONFIG,
-        royalty_address=address,
-        target_address=address,
-        hash="deadbeef",
-        uris=["http://test.nft"],
     )
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
     await farm_transaction_block(full_node_api, env.wallet_1.node)
@@ -2431,7 +2660,7 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
 
 
 @pytest.mark.anyio
-async def test_set_wallet_resync_on_startup_disable(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_set_wallet_resync_on_startup_disable(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
     full_node_api: FullNodeSimulator = env.full_node.api
     client: WalletRpcClient = env.wallet_1.rpc_client
@@ -2471,13 +2700,13 @@ async def test_set_wallet_resync_on_startup_disable(wallet_rpc_environment: Wall
 
 @pytest.mark.anyio
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
-async def test_set_wallet_resync_schema(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_set_wallet_resync_schema(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
     full_node_api: FullNodeSimulator = env.full_node.api
     await generate_funds(full_node_api, env.wallet_1)
     wallet_node: WalletNode = env.wallet_1.node
     fingerprint = wallet_node.logged_in_fingerprint
-    assert fingerprint
+    assert fingerprint is not None
     db_path = wallet_node.wallet_state_manager.db_path
     assert await wallet_node.reset_sync_db(db_path, fingerprint), (
         "Schema has been changed, reset sync db won't work, please update WalletNode.reset_sync_db function"
@@ -2493,7 +2722,7 @@ async def test_set_wallet_resync_schema(wallet_rpc_environment: WalletRpcTestEnv
 
 
 @pytest.mark.anyio
-async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_node: WalletNode = env.wallet_1.node
@@ -2504,7 +2733,8 @@ async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironme
     await generate_funds(full_node_api, env.wallet_1, 1)
 
     # Send to a CAT with an anyone can spend TAIL
-    our_ph: bytes32 = await env.wallet_1.wallet.get_new_puzzlehash()
+    async with env.wallet_1.wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        our_ph = await action_scope.get_puzzle_hash(env.wallet_1.wallet.wallet_state_manager)
     cat_puzzle: Program = construct_cat_puzzle(CAT_MOD, Program.to(None).get_tree_hash(), Program.to(1))
     addr = encode_puzzle_hash(
         cat_puzzle.get_tree_hash(),
@@ -2572,7 +2802,7 @@ async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironme
 
 
 @pytest.mark.anyio
-async def test_get_balances(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_get_balances(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     client: WalletRpcClient = env.wallet_1.rpc_client
@@ -2930,7 +3160,7 @@ async def test_combine_coins(wallet_environments: WalletTestFramework, capsys: p
     async with env.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         await cat_wallet.generate_signed_transaction(
             [BIG_COIN_AMOUNT, SMALL_COIN_AMOUNT, REALLY_SMALL_COIN_AMOUNT],
-            [await env.xch_wallet.get_puzzle_hash(new=not action_scope.config.tx_config.reuse_puzhash)] * 3,
+            [await action_scope.get_puzzle_hash(env.wallet_state_manager)] * 3,
             action_scope,
         )