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

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -6,17 +6,19 @@ 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.test_wallet_coin_store import (
     get_coin_records_amount_filter_tests,
@@ -47,39 +49,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
@@ -101,7 +80,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 +101,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 +146,7 @@ log = logging.getLogger(__name__)
 
 @dataclasses.dataclass
 class WalletBundle:
-    service: Service
+    service: WalletService
     node: WalletNode
     rpc_client: WalletRpcClient
     wallet: Wallet
@@ -150,29 +170,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 +212,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 +239,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 +310,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 +322,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 +334,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 +362,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 +433,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 +480,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 +502,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 +528,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 +545,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 +556,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 +591,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 +611,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 +689,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 +723,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 +806,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 +820,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 +927,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 +978,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 +1003,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 +1023,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 +1037,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 +1057,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
@@ -1033,7 +1078,7 @@ async def test_get_transaction_count(wallet_rpc_environment: WalletRpcTestEnviro
 
 
 @pytest.mark.anyio
-async def test_cat_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
+async def test_cat_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
     env: WalletRpcTestEnvironment = wallet_rpc_environment
 
     wallet_node: WalletNode = env.wallet_1.node
@@ -1196,7 +1241,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 +1360,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 +1448,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 +1496,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 +1517,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 +1589,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 +1603,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 +1613,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 +1631,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 +1645,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 +1662,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 +1698,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 +1782,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 +1813,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 +1830,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 +1906,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 +1917,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 +2038,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 +2077,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 +2149,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 +2191,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 +2204,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 +2231,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 +2394,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 +2410,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 +2437,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 +2451,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 +2466,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 +2551,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 +2591,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 +2613,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 +2624,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 +2693,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 +3051,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,
         )