chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/rpc/wallet_rpc_api.py

@@ -5,9 +5,9 @@ import json
 import logging
 import zlib
 from pathlib import Path
-from typing import Any, ClassVar, Dict, List, Optional, Set, Tuple, Union
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Union, cast
 
-from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, Coin, G1Element, G2Element, PrivateKey
 from clvm_tools.binutils import assemble
 
 from chia.consensus.block_rewards import calculate_base_farmer_reward
@@ -18,7 +18,7 @@ from chia.pools.pool_wallet import PoolWallet
 from chia.pools.pool_wallet_info import FARMING_TO_POOL, PoolState, PoolWalletInfo, create_pool_state
 from chia.protocols.wallet_protocol import CoinState
 from chia.rpc.rpc_server import Endpoint, EndpointResult, default_get_connections
-from chia.rpc.util import marshal, tx_endpoint
+from chia.rpc.util import ALL_TRANSLATION_LAYERS, RpcEndpoint, marshal
 from chia.rpc.wallet_request_types import (
     AddKey,
     AddKeyResponse,
@@ -35,6 +35,7 @@ from chia.rpc.wallet_request_types import (
     GatherSigningInfo,
     GatherSigningInfoResponse,
     GenerateMnemonicResponse,
+    GetHeightInfoResponse,
     GetLoggedInFingerprintResponse,
     GetNotifications,
     GetNotificationsResponse,
@@ -42,16 +43,39 @@ from chia.rpc.wallet_request_types import (
     GetPrivateKeyFormat,
     GetPrivateKeyResponse,
     GetPublicKeysResponse,
+    GetSyncStatusResponse,
+    GetTimestampForHeight,
+    GetTimestampForHeightResponse,
     LogIn,
     LogInResponse,
+    PushTransactions,
+    PushTransactionsResponse,
+    PushTX,
+    SetWalletResyncOnStartup,
     SplitCoins,
     SplitCoinsResponse,
     SubmitTransactions,
     SubmitTransactionsResponse,
+    VCAddProofs,
+    VCGet,
+    VCGetList,
+    VCGetListResponse,
+    VCGetProofsForRoot,
+    VCGetProofsForRootResponse,
+    VCGetResponse,
+    VCMint,
+    VCMintResponse,
+    VCProofsRPC,
+    VCProofWithHash,
+    VCRecordWithCoinID,
+    VCRevoke,
+    VCRevokeResponse,
+    VCSpend,
+    VCSpendResponse,
 )
 from chia.server.outbound_message import NodeType
 from chia.server.ws_connection import WSChiaConnection
-from chia.types.blockchain_format.coin import Coin, coin_as_list
+from chia.types.blockchain_format.coin import coin_as_list
 from chia.types.blockchain_format.program import INFINITE_COST, Program
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_record import CoinRecord
@@ -76,9 +100,12 @@ from chia.wallet.conditions import (
     AssertCoinAnnouncement,
     AssertPuzzleAnnouncement,
     Condition,
+    ConditionValidTimes,
     CreateCoinAnnouncement,
     CreatePuzzleAnnouncement,
+    conditions_from_json_dicts,
     parse_conditions_non_consensus,
+    parse_timelock_info,
 )
 from chia.wallet.dao_wallet.dao_info import DAORules
 from chia.wallet.dao_wallet.dao_utils import (
@@ -127,6 +154,7 @@ from chia.wallet.trading.offer import Offer
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.uncurried_puzzle import uncurry_puzzle
 from chia.wallet.util.address_type import AddressType, is_valid_address
+from chia.wallet.util.clvm_streamable import json_serialize_with_clvm_streamable
 from chia.wallet.util.compute_hints import compute_spend_hints_and_additions
 from chia.wallet.util.compute_memos import compute_memos
 from chia.wallet.util.curry_and_treehash import NIL_TREEHASH
@@ -156,7 +184,200 @@ MAX_NFT_CHUNK_SIZE = 25
 log = logging.getLogger(__name__)
 
 
+def tx_endpoint(
+    push: bool = False,
+    merge_spends: bool = True,
+) -> Callable[[RpcEndpoint], RpcEndpoint]:
+    def _inner(func: RpcEndpoint) -> RpcEndpoint:
+        async def rpc_endpoint(
+            self: WalletRpcApi, request: dict[str, Any], *args: object, **kwargs: object
+        ) -> EndpointResult:
+            assert self.service.logged_in_fingerprint is not None
+            tx_config_loader: TXConfigLoader = TXConfigLoader.from_json_dict(request)
+
+            # Some backwards compat fill-ins
+            if tx_config_loader.excluded_coin_ids is None:
+                tx_config_loader = tx_config_loader.override(
+                    excluded_coin_ids=request.get("exclude_coin_ids"),
+                )
+            if tx_config_loader.excluded_coin_amounts is None:
+                tx_config_loader = tx_config_loader.override(
+                    excluded_coin_amounts=request.get("exclude_coin_amounts"),
+                )
+            if tx_config_loader.excluded_coin_ids is None:
+                excluded_coins: Optional[list[dict[str, Any]]] = request.get(
+                    "exclude_coins", request.get("excluded_coins")
+                )
+                if excluded_coins is not None:
+                    tx_config_loader = tx_config_loader.override(
+                        excluded_coin_ids=[Coin.from_json_dict(c).name() for c in excluded_coins],
+                    )
+
+            tx_config: TXConfig = tx_config_loader.autofill(
+                constants=self.service.wallet_state_manager.constants,
+                config=self.service.wallet_state_manager.config,
+                logged_in_fingerprint=self.service.logged_in_fingerprint,
+            )
+
+            extra_conditions: tuple[Condition, ...] = tuple()
+            if "extra_conditions" in request:
+                extra_conditions = tuple(conditions_from_json_dicts(request["extra_conditions"]))
+            extra_conditions = (*extra_conditions, *ConditionValidTimes.from_json_dict(request).to_conditions())
+
+            valid_times: ConditionValidTimes = parse_timelock_info(extra_conditions)
+            if (
+                valid_times.max_secs_after_created is not None
+                or valid_times.min_secs_since_created is not None
+                or valid_times.max_blocks_after_created is not None
+                or valid_times.min_blocks_since_created is not None
+            ):
+                raise ValueError("Relative timelocks are not currently supported in the RPC")
+
+            async with self.service.wallet_state_manager.new_action_scope(
+                tx_config,
+                push=request.get("push", push),
+                merge_spends=request.get("merge_spends", merge_spends),
+                sign=request.get("sign", self.service.config.get("auto_sign_txs", True)),
+            ) as action_scope:
+                response: EndpointResult = await func(
+                    self,
+                    request,
+                    *args,
+                    action_scope,
+                    extra_conditions=extra_conditions,
+                    **kwargs,
+                )
+
+            if func.__name__ == "create_new_wallet" and "transactions" not in response:
+                # unfortunately, this API isn't solely a tx endpoint
+                return response
+
+            unsigned_txs = await self.service.wallet_state_manager.gather_signing_info_for_txs(
+                action_scope.side_effects.transactions
+            )
+
+            if request.get("CHIP-0029", False):
+                response["unsigned_transactions"] = [
+                    json_serialize_with_clvm_streamable(
+                        tx,
+                        translation_layer=(
+                            ALL_TRANSLATION_LAYERS[request["translation"]] if "translation" in request else None
+                        ),
+                    )
+                    for tx in unsigned_txs
+                ]
+            else:
+                response["unsigned_transactions"] = [tx.to_json_dict() for tx in unsigned_txs]
+
+            response["transactions"] = [
+                TransactionRecord.to_json_dict_convenience(tx, self.service.config)
+                for tx in action_scope.side_effects.transactions
+            ]
+
+            # Some backwards compatibility code here because transaction information being returned was not uniform
+            # until the "transactions" key was applied to all of them. Unfortunately, since .add_pending_transactions
+            # now applies transformations to the transactions, we have to special case edit all of the previous
+            # spots where the information was being surfaced outside of the knowledge of this wrapper.
+            new_txs = action_scope.side_effects.transactions
+            if "transaction" in response:
+                if (
+                    func.__name__ == "create_new_wallet" and request["wallet_type"] == "pool_wallet"
+                ) or func.__name__ in {"pw_join_pool", "pw_self_pool", "pw_absorb_rewards"}:
+                    # Theses RPCs return not "convenience" for some reason
+                    response["transaction"] = new_txs[-1].to_json_dict()
+                else:
+                    response["transaction"] = response["transactions"][0]
+            if "tx_record" in response:
+                response["tx_record"] = response["transactions"][0]
+            if "fee_transaction" in response:
+                # Theses RPCs return not "convenience" for some reason
+                fee_transactions = [tx for tx in new_txs if tx.wallet_id == 1]
+                if len(fee_transactions) == 0:
+                    response["fee_transaction"] = None
+                else:
+                    response["fee_transaction"] = fee_transactions[0].to_json_dict()
+            if "transaction_id" in response:
+                response["transaction_id"] = new_txs[0].name
+            if "transaction_ids" in response:
+                response["transaction_ids"] = [
+                    tx.name.hex() for tx in new_txs if tx.type == TransactionType.OUTGOING_CLAWBACK.value
+                ]
+            if "spend_bundle" in response:
+                response["spend_bundle"] = WalletSpendBundle.aggregate(
+                    [tx.spend_bundle for tx in new_txs if tx.spend_bundle is not None]
+                )
+            if "signed_txs" in response:
+                response["signed_txs"] = response["transactions"]
+            if "signed_tx" in response:
+                response["signed_tx"] = response["transactions"][0]
+            if "tx" in response:
+                if func.__name__ == "send_notification":
+                    response["tx"] = response["transactions"][0]
+                else:
+                    response["tx"] = new_txs[0].to_json_dict()
+            if "txs" in response:
+                response["txs"] = [tx.to_json_dict() for tx in new_txs]
+            if "tx_id" in response:
+                response["tx_id"] = new_txs[0].name
+            if "trade_record" in response:
+                old_offer: Offer = Offer.from_bech32(response["offer"])
+                signed_coin_spends: list[CoinSpend] = [
+                    coin_spend
+                    for tx in new_txs
+                    if tx.spend_bundle is not None
+                    for coin_spend in tx.spend_bundle.coin_spends
+                ]
+                involved_coins: list[Coin] = [spend.coin for spend in signed_coin_spends]
+                signed_coin_spends.extend(
+                    [spend for spend in old_offer._bundle.coin_spends if spend.coin not in involved_coins]
+                )
+                new_offer_bundle = WalletSpendBundle(
+                    signed_coin_spends,
+                    AugSchemeMPL.aggregate(
+                        [tx.spend_bundle.aggregated_signature for tx in new_txs if tx.spend_bundle is not None]
+                    ),
+                )
+                new_offer: Offer = Offer(old_offer.requested_payments, new_offer_bundle, old_offer.driver_dict)
+                response["offer"] = new_offer.to_bech32()
+                old_trade_record: TradeRecord = TradeRecord.from_json_dict_convenience(
+                    response["trade_record"], bytes(old_offer).hex()
+                )
+                new_trade: TradeRecord = dataclasses.replace(
+                    old_trade_record,
+                    offer=bytes(new_offer),
+                    trade_id=new_offer.name(),
+                )
+                response["trade_record"] = new_trade.to_json_dict_convenience()
+                if (
+                    await self.service.wallet_state_manager.trade_manager.trade_store.get_trade_record(
+                        old_trade_record.trade_id
+                    )
+                    is not None
+                ):
+                    await self.service.wallet_state_manager.trade_manager.trade_store.delete_trade_record(
+                        old_trade_record.trade_id
+                    )
+                    await self.service.wallet_state_manager.trade_manager.save_trade(new_trade, new_offer)
+                for tx in await self.service.wallet_state_manager.tx_store.get_transactions_by_trade_id(
+                    old_trade_record.trade_id
+                ):
+                    await self.service.wallet_state_manager.tx_store.add_transaction_record(
+                        dataclasses.replace(tx, trade_id=new_trade.trade_id)
+                    )
+
+            return response
+
+        return rpc_endpoint
+
+    return _inner
+
+
 class WalletRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("WalletRpcApi", None)
+
     max_get_coin_records_limit: ClassVar[uint32] = uint32(1000)
     max_get_coin_records_filter_items: ClassVar[uint32] = uint32(1000)
 
@@ -165,7 +386,7 @@ class WalletRpcApi:
         self.service = wallet_node
         self.service_name = "chia_wallet"
 
-    def get_routes(self) -> Dict[str, Endpoint]:
+    def get_routes(self) -> dict[str, Endpoint]:
         return {
             # Key management
             "/log_in": self.log_in,
@@ -320,10 +541,10 @@ class WalletRpcApi:
             "/execute_signing_instructions": self.execute_signing_instructions,
         }
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> List[Dict[str, Any]]:
+    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
         return default_get_connections(server=self.service.server, request_node_type=request_node_type)
 
-    async def _state_changed(self, change: str, change_data: Optional[Dict[str, Any]]) -> List[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]]) -> list[WsRpcMessage]:
         """
         Called by the WalletNode or WalletStateManager when something has changed in the wallet. This
         gives us an opportunity to send notifications to all connected clients via WebSocket.
@@ -356,8 +577,8 @@ class WalletRpcApi:
 
     async def get_latest_singleton_coin_spend(
         self, peer: WSChiaConnection, coin_id: bytes32, latest: bool = True
-    ) -> Tuple[CoinSpend, CoinState]:
-        coin_state_list: List[CoinState] = await self.service.wallet_state_manager.wallet_node.get_coin_state(
+    ) -> tuple[CoinSpend, CoinState]:
+        coin_state_list: list[CoinState] = await self.service.wallet_state_manager.wallet_node.get_coin_state(
             [coin_id], peer=peer
         )
         if coin_state_list is None or len(coin_state_list) < 1:
@@ -379,7 +600,7 @@ class WalletRpcApi:
                     raise ValueError("Cannot find child coin, please wait then retry.")
                 coin_state = odd_coin
         # Get parent coin
-        parent_coin_state_list: List[CoinState] = await self.service.wallet_state_manager.wallet_node.get_coin_state(
+        parent_coin_state_list: list[CoinState] = await self.service.wallet_state_manager.wallet_node.get_coin_state(
             [coin_state.coin.parent_coin_info], peer=peer
         )
         if parent_coin_state_list is None or len(parent_coin_state_list) < 1:
@@ -429,7 +650,7 @@ class WalletRpcApi:
         else:
             return GetPublicKeysResponse(keyring_is_locked=False, public_key_fingerprints=fingerprints)
 
-    async def _get_private_key(self, fingerprint: int) -> Tuple[Optional[PrivateKey], Optional[bytes]]:
+    async def _get_private_key(self, fingerprint: int) -> tuple[Optional[PrivateKey], Optional[bytes]]:
         try:
             all_keys = await self.service.keychain_proxy.get_all_private_keys()
             for sk, seed in all_keys:
@@ -501,7 +722,7 @@ class WalletRpcApi:
 
     async def _check_key_used_for_rewards(
         self, new_root: Path, sk: PrivateKey, max_ph_to_search: int
-    ) -> Tuple[bool, bool]:
+    ) -> tuple[bool, bool]:
         """Checks if the given key is used for either the farmer rewards or pool rewards
         returns a tuple of two booleans
         The first is true if the key is used as the Farmer rewards, otherwise false
@@ -511,10 +732,10 @@ class WalletRpcApi:
         if sk is None:
             return False, False
 
-        config: Dict[str, Any] = load_config(new_root, "config.yaml")
+        config: dict[str, Any] = load_config(new_root, "config.yaml")
         farmer_target = config["farmer"].get("xch_target_address", "")
         pool_target = config["pool"].get("xch_target_address", "")
-        address_to_check: List[bytes32] = []
+        address_to_check: list[bytes32] = []
 
         try:
             farmer_decoded = decode_puzzle_hash(farmer_target)
@@ -528,7 +749,7 @@ class WalletRpcApi:
         except ValueError:
             pool_decoded = None
 
-        found_addresses: Set[bytes32] = match_address_to_sk(sk, address_to_check, max_ph_to_search)
+        found_addresses: set[bytes32] = match_address_to_sk(sk, address_to_check, max_ph_to_search)
         found_farmer = False
         found_pool = False
 
@@ -560,7 +781,7 @@ class WalletRpcApi:
                 await self._stop_wallet()
                 await self.service._start_with_fingerprint(fingerprint=request.fingerprint)
 
-            wallets: List[WalletInfo] = await self.service.wallet_state_manager.get_all_wallet_info_entries()
+            wallets: list[WalletInfo] = await self.service.wallet_state_manager.get_all_wallet_info_entries()
             for w in wallets:
                 wallet = self.service.wallet_state_manager.wallets[w.id]
                 unspent = await self.service.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(w.id)
@@ -594,64 +815,55 @@ class WalletRpcApi:
     ##########################################################################################
     # Wallet Node
     ##########################################################################################
-    async def set_wallet_resync_on_startup(self, request: Dict[str, Any]) -> Dict[str, Any]:
+    @marshal
+    async def set_wallet_resync_on_startup(self, request: SetWalletResyncOnStartup) -> Empty:
         """
         Resync the current logged in wallet. The transaction and offer records will be kept.
         :param request: optionally pass in `enable` as bool to enable/disable resync
         :return:
         """
         assert self.service.wallet_state_manager is not None
-        try:
-            enable = bool(request.get("enable", True))
-        except ValueError:
-            raise ValueError("Please provide a boolean value for `enable` parameter in request")
         fingerprint = self.service.logged_in_fingerprint
         if fingerprint is not None:
-            self.service.set_resync_on_startup(fingerprint, enable)
+            self.service.set_resync_on_startup(fingerprint, request.enable)
         else:
             raise ValueError("You need to login into wallet to use this RPC call")
-        return {"success": True}
+        return Empty()
 
-    async def get_sync_status(self, request: Dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_sync_status(self, request: Empty) -> GetSyncStatusResponse:
         sync_mode = self.service.wallet_state_manager.sync_mode
         has_pending_queue_items = self.service.new_peak_queue.has_pending_data_process_items()
         syncing = sync_mode or has_pending_queue_items
         synced = await self.service.wallet_state_manager.synced()
-        return {"synced": synced, "syncing": syncing, "genesis_initialized": True}
+        return GetSyncStatusResponse(synced=synced, syncing=syncing)
 
-    async def get_height_info(self, request: Dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_height_info(self, request: Empty) -> GetHeightInfoResponse:
         height = await self.service.wallet_state_manager.blockchain.get_finished_sync_up_to()
-        return {"height": height}
+        return GetHeightInfoResponse(height=height)
 
-    async def push_tx(self, request: Dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def push_tx(self, request: PushTX) -> Empty:
         nodes = self.service.server.get_connections(NodeType.FULL_NODE)
         if len(nodes) == 0:
             raise ValueError("Wallet is not currently connected to any full node peers")
-        await self.service.push_tx(WalletSpendBundle.from_bytes(hexstr_to_bytes(request["spend_bundle"])))
-        return {}
+        await self.service.push_tx(request.spend_bundle)
+        return Empty()
 
     @tx_endpoint(push=True)
+    @marshal
     async def push_transactions(
         self,
-        request: Dict[str, Any],
+        request: PushTransactions,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> PushTransactionsResponse:
         if not action_scope.config.push:
             raise ValueError("Cannot push transactions if push is False")
         async with action_scope.use() as interface:
-            for transaction_hexstr_or_json in request["transactions"]:
-                if isinstance(transaction_hexstr_or_json, str):
-                    tx = TransactionRecord.from_bytes(hexstr_to_bytes(transaction_hexstr_or_json))
-                    interface.side_effects.transactions.append(tx)
-                else:
-                    try:
-                        tx = TransactionRecord.from_json_dict_convenience(transaction_hexstr_or_json)
-                    except AttributeError:
-                        tx = TransactionRecord.from_json_dict(transaction_hexstr_or_json)
-                    interface.side_effects.transactions.append(tx)
-
-            if request.get("fee", 0) != 0:
+            interface.side_effects.transactions.extend(request.transactions)
+            if request.fee != 0:
                 all_conditions_and_origins = [
                     (condition, cs.coin.name())
                     for tx in interface.side_effects.transactions
@@ -682,7 +894,7 @@ class WalletRpcApi:
                     push=False,
                 ) as inner_action_scope:
                     await self.service.wallet_state_manager.main_wallet.create_tandem_xch_tx(
-                        uint64(request["fee"]),
+                        request.fee,
                         inner_action_scope,
                         (
                             *extra_conditions,
@@ -694,20 +906,23 @@ class WalletRpcApi:
 
                 interface.side_effects.transactions.extend(inner_action_scope.side_effects.transactions)
 
-        return {}
+        return PushTransactionsResponse([], [])  # tx_endpoint takes care of this
 
-    async def get_timestamp_for_height(self, request: Dict[str, Any]) -> EndpointResult:
-        return {"timestamp": await self.service.get_timestamp_for_height(uint32(request["height"]))}
+    @marshal
+    async def get_timestamp_for_height(self, request: GetTimestampForHeight) -> GetTimestampForHeightResponse:
+        return GetTimestampForHeightResponse(await self.service.get_timestamp_for_height(request.height))
 
-    async def set_auto_claim(self, request: Dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def set_auto_claim(self, request: AutoClaimSettings) -> AutoClaimSettings:
         """
         Set auto claim merkle coins config
         :param request: Example {"enable": true, "tx_fee": 100000, "min_amount": 0, "batch_size": 50}
         :return:
         """
-        return self.service.set_auto_claim(AutoClaimSettings.from_json_dict(request))
+        return AutoClaimSettings.from_json_dict(self.service.set_auto_claim(request))
 
-    async def get_auto_claim(self, request: Dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_auto_claim(self, request: Empty) -> AutoClaimSettings:
         """
         Get auto claim merkle coins config
         :param request: None
@@ -716,21 +931,21 @@ class WalletRpcApi:
         auto_claim_settings = AutoClaimSettings.from_json_dict(
             self.service.wallet_state_manager.config.get("auto_claim", {})
         )
-        return auto_claim_settings.to_json_dict()
+        return auto_claim_settings
 
     ##########################################################################################
     # Wallet Management
     ##########################################################################################
 
-    async def get_wallets(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_wallets(self, request: dict[str, Any]) -> EndpointResult:
         include_data: bool = request.get("include_data", True)
         wallet_type: Optional[WalletType] = None
         if "type" in request:
             wallet_type = WalletType(request["type"])
 
-        wallets: List[WalletInfo] = await self.service.wallet_state_manager.get_all_wallet_info_entries(wallet_type)
+        wallets: list[WalletInfo] = await self.service.wallet_state_manager.get_all_wallet_info_entries(wallet_type)
         if not include_data:
-            result: List[WalletInfo] = []
+            result: list[WalletInfo] = []
             for wallet in wallets:
                 result.append(WalletInfo(wallet.id, wallet.name, wallet.type, ""))
             wallets = result
@@ -759,9 +974,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def create_new_wallet(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_state_manager = self.service.wallet_state_manager
 
@@ -819,7 +1034,7 @@ class WalletRpcApi:
                     backup_dids.append(decode_puzzle_hash(d))
                 if len(backup_dids) > 0:
                     num_needed = uint64(request["num_of_backup_ids_needed"])
-                metadata: Dict[str, str] = {}
+                metadata: dict[str, str] = {}
                 if "metadata" in request:
                     if type(request["metadata"]) is dict:
                         metadata = request["metadata"]
@@ -959,7 +1174,9 @@ class WalletRpcApi:
                 if "initial_target_state" not in request:
                     raise AttributeError("Daemon didn't send `initial_target_state`. Try updating the daemon.")
 
-                owner_puzzle_hash: bytes32 = await self.service.wallet_state_manager.main_wallet.get_puzzle_hash(True)
+                owner_puzzle_hash: bytes32 = await self.service.wallet_state_manager.main_wallet.get_puzzle_hash(
+                    new=not action_scope.config.tx_config.reuse_puzhash
+                )
 
                 from chia.pools.pool_wallet_info import initial_pool_state_from_dict
 
@@ -1027,7 +1244,7 @@ class WalletRpcApi:
     # Wallet
     ##########################################################################################
 
-    async def _get_wallet_balance(self, wallet_id: uint32) -> Dict[str, Any]:
+    async def _get_wallet_balance(self, wallet_id: uint32) -> dict[str, Any]:
         wallet = self.service.wallet_state_manager.wallets[wallet_id]
         balance = await self.service.get_balance(wallet_id)
         wallet_balance = balance.to_json_dict()
@@ -1044,22 +1261,22 @@ class WalletRpcApi:
 
         return wallet_balance
 
-    async def get_wallet_balance(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_wallet_balance(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(int(request["wallet_id"]))
         wallet_balance = await self._get_wallet_balance(wallet_id)
         return {"wallet_balance": wallet_balance}
 
-    async def get_wallet_balances(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_wallet_balances(self, request: dict[str, Any]) -> EndpointResult:
         try:
-            wallet_ids: List[uint32] = [uint32(int(wallet_id)) for wallet_id in request["wallet_ids"]]
+            wallet_ids: list[uint32] = [uint32(int(wallet_id)) for wallet_id in request["wallet_ids"]]
         except (TypeError, KeyError):
             wallet_ids = list(self.service.wallet_state_manager.wallets.keys())
-        wallet_balances: Dict[uint32, Dict[str, Any]] = {}
+        wallet_balances: dict[uint32, dict[str, Any]] = {}
         for wallet_id in wallet_ids:
             wallet_balances[wallet_id] = await self._get_wallet_balance(wallet_id)
         return {"wallet_balances": wallet_balances}
 
-    async def get_transaction(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_transaction(self, request: dict[str, Any]) -> EndpointResult:
         transaction_id: bytes32 = bytes32.from_hexstr(request["transaction_id"])
         tr: Optional[TransactionRecord] = await self.service.wallet_state_manager.get_transaction(transaction_id)
         if tr is None:
@@ -1070,7 +1287,7 @@ class WalletRpcApi:
             "transaction_id": tr.name,
         }
 
-    async def get_transaction_memo(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_transaction_memo(self, request: dict[str, Any]) -> EndpointResult:
         transaction_id: bytes32 = bytes32.from_hexstr(request["transaction_id"])
         tr: Optional[TransactionRecord] = await self.service.wallet_state_manager.get_transaction(transaction_id)
         if tr is None:
@@ -1080,7 +1297,7 @@ class WalletRpcApi:
                 # Fetch incoming tx coin spend
                 peer = self.service.get_full_node_peer()
                 assert len(tr.additions) == 1
-                coin_state_list: List[CoinState] = await self.service.wallet_state_manager.wallet_node.get_coin_state(
+                coin_state_list: list[CoinState] = await self.service.wallet_state_manager.wallet_node.get_coin_state(
                     [tr.additions[0].parent_coin_info], peer=peer
                 )
                 assert len(coin_state_list) == 1
@@ -1089,7 +1306,7 @@ class WalletRpcApi:
             else:
                 raise ValueError(f"Transaction 0x{transaction_id.hex()} doesn't have any coin spend.")
         assert tr.spend_bundle is not None
-        memos: Dict[bytes32, List[bytes]] = compute_memos(tr.spend_bundle)
+        memos: dict[bytes32, list[bytes]] = compute_memos(tr.spend_bundle)
         response = {}
         # Convert to hex string
         for coin_id, memo_list in memos.items():
@@ -1099,7 +1316,7 @@ class WalletRpcApi:
     @tx_endpoint(push=False)
     @marshal
     async def split_coins(
-        self, request: SplitCoins, action_scope: WalletActionScope, extra_conditions: Tuple[Condition, ...] = tuple()
+        self, request: SplitCoins, action_scope: WalletActionScope, extra_conditions: tuple[Condition, ...] = tuple()
     ) -> SplitCoinsResponse:
         if request.number_of_coins > 500:
             raise ValueError(f"{request.number_of_coins} coins is greater then the maximum limit of 500 coins.")
@@ -1124,7 +1341,12 @@ class WalletRpcApi:
             raise ValueError("Cannot split coins from non-fungible wallet types")
 
         outputs = [
-            Payment(await wallet.get_puzzle_hash(new=True), request.amount_per_coin)
+            Payment(
+                await wallet.get_puzzle_hash(new=True)
+                if isinstance(wallet, Wallet)
+                else await wallet.standard_wallet.get_puzzle_hash(new=True),
+                request.amount_per_coin,
+            )
             for _ in range(request.number_of_coins)
         ]
         if len(outputs) == 0:
@@ -1168,9 +1390,8 @@ class WalletRpcApi:
     @tx_endpoint(push=False)
     @marshal
     async def combine_coins(
-        self, request: CombineCoins, action_scope: WalletActionScope, extra_conditions: Tuple[Condition, ...] = tuple()
+        self, request: CombineCoins, action_scope: WalletActionScope, extra_conditions: tuple[Condition, ...] = tuple()
     ) -> CombineCoinsResponse:
-
         # Some "number of coins" validation
         if request.number_of_coins > request.coin_num_limit:
             raise ValueError(
@@ -1187,7 +1408,7 @@ class WalletRpcApi:
         if not isinstance(wallet, (Wallet, CATWallet)):
             raise ValueError("Cannot combine coins from non-fungible wallet types")
 
-        coins: List[Coin] = []
+        coins: list[Coin] = []
 
         # First get the coin IDs specified
         if request.target_coin_ids != []:
@@ -1250,7 +1471,7 @@ class WalletRpcApi:
             primary_output_amount = uint64(primary_output_amount - request.fee)
             await wallet.generate_signed_transaction(
                 primary_output_amount,
-                await wallet.get_puzzle_hash(new=action_scope.config.tx_config.reuse_puzhash),
+                await wallet.get_puzzle_hash(new=not action_scope.config.tx_config.reuse_puzhash),
                 action_scope,
                 request.fee,
                 set(coins),
@@ -1260,7 +1481,7 @@ class WalletRpcApi:
             assert isinstance(wallet, CATWallet)
             await wallet.generate_signed_transaction(
                 [primary_output_amount],
-                [await wallet.get_puzzle_hash(new=action_scope.config.tx_config.reuse_puzhash)],
+                [await wallet.standard_wallet.get_puzzle_hash(new=not action_scope.config.tx_config.reuse_puzhash)],
                 action_scope,
                 request.fee,
                 coins=set(coins),
@@ -1269,7 +1490,7 @@ class WalletRpcApi:
 
         return CombineCoinsResponse([], [])  # tx_endpoint will take care to fill this out
 
-    async def get_transactions(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_transactions(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = int(request["wallet_id"])
 
         start = request.get("start", 0)
@@ -1321,7 +1542,7 @@ class WalletRpcApi:
             "wallet_id": wallet_id,
         }
 
-    async def get_transaction_count(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_transaction_count(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = int(request["wallet_id"])
         type_filter = None
         if "type_filter" in request:
@@ -1334,7 +1555,7 @@ class WalletRpcApi:
             "wallet_id": wallet_id,
         }
 
-    async def get_next_address(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_next_address(self, request: dict[str, Any]) -> EndpointResult:
         """
         Returns a new address
         """
@@ -1365,9 +1586,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def send_transaction(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before sending transactions")
@@ -1385,7 +1606,7 @@ class WalletRpcApi:
             raise ValueError("Unexpected Address Prefix")
         puzzle_hash: bytes32 = decode_puzzle_hash(address)
 
-        memos: List[bytes] = []
+        memos: list[bytes] = []
         if "memos" in request:
             memos = [mem.encode("utf-8") for mem in request["memos"]]
 
@@ -1409,7 +1630,7 @@ class WalletRpcApi:
             "transaction_id": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def send_transaction_multi(self, request: Dict[str, Any]) -> EndpointResult:
+    async def send_transaction_multi(self, request: dict[str, Any]) -> EndpointResult:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before sending transactions")
 
@@ -1442,9 +1663,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True, merge_spends=False)
     async def spend_clawback_coins(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         """Spend clawback coins that were sent (to claw them back) or received (to claim them).
 
@@ -1455,7 +1676,7 @@ class WalletRpcApi:
         """
         if "coin_ids" not in request:
             raise ValueError("Coin IDs are required.")
-        coin_ids: List[bytes32] = [bytes32.from_hexstr(coin) for coin in request["coin_ids"]]
+        coin_ids: list[bytes32] = [bytes32.from_hexstr(coin) for coin in request["coin_ids"]]
         tx_fee: uint64 = uint64(request.get("fee", 0))
         # Get inner puzzle
         coin_records = await self.service.wallet_state_manager.coin_store.get_coin_records(
@@ -1465,7 +1686,7 @@ class WalletRpcApi:
             spent_range=UInt32Range(stop=uint32(0)),
         )
 
-        coins: Dict[Coin, ClawbackMetadata] = {}
+        coins: dict[Coin, ClawbackMetadata] = {}
         batch_size = request.get(
             "batch_size", self.service.wallet_state_manager.config.get("auto_claim", {}).get("batch_size", 50)
         )
@@ -1482,18 +1703,6 @@ class WalletRpcApi:
                         request.get("force", False),
                         extra_conditions=extra_conditions,
                     )
-                    async with action_scope.use() as interface:
-                        # TODO: editing this is not ideal.  Action scopes should know what coins have been spent.
-                        action_scope._config = dataclasses.replace(
-                            action_scope._config,
-                            tx_config=dataclasses.replace(
-                                action_scope._config.tx_config,
-                                excluded_coin_ids=[
-                                    *action_scope._config.tx_config.excluded_coin_ids,
-                                    *(c.name() for tx in interface.side_effects.transactions for c in tx.removals),
-                                ],
-                            ),
-                        )
                     coins = {}
             except Exception as e:
                 log.error(f"Failed to spend clawback coin {coin_id.hex()}: %s", e)
@@ -1512,7 +1721,7 @@ class WalletRpcApi:
             "transactions": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def delete_unconfirmed_transactions(self, request: Dict[str, Any]) -> EndpointResult:
+    async def delete_unconfirmed_transactions(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         if wallet_id not in self.service.wallet_state_manager.wallets:
             raise ValueError(f"Wallet id {wallet_id} does not exist")
@@ -1529,14 +1738,14 @@ class WalletRpcApi:
 
     async def select_coins(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
     ) -> EndpointResult:
         assert self.service.logged_in_fingerprint is not None
         tx_config_loader: TXConfigLoader = TXConfigLoader.from_json_dict(request)
 
         # Some backwards compat fill-ins
         if tx_config_loader.excluded_coin_ids is None:
-            excluded_coins: Optional[List[Dict[str, Any]]] = request.get("excluded_coins", request.get("exclude_coins"))
+            excluded_coins: Optional[list[dict[str, Any]]] = request.get("excluded_coins", request.get("exclude_coins"))
             if excluded_coins is not None:
                 tx_config_loader = tx_config_loader.override(
                     excluded_coin_ids=[Coin.from_json_dict(c).name() for c in excluded_coins],
@@ -1558,7 +1767,7 @@ class WalletRpcApi:
 
         return {"coins": [coin.to_json_dict() for coin in selected_coins]}
 
-    async def get_spendable_coins(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_spendable_coins(self, request: dict[str, Any]) -> EndpointResult:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before getting all coins")
 
@@ -1567,17 +1776,17 @@ class WalletRpcApi:
         max_coin_amount: uint64 = uint64(request.get("max_coin_amount", 0))
         if max_coin_amount == 0:
             max_coin_amount = uint64(self.service.wallet_state_manager.constants.MAX_COIN_AMOUNT)
-        excluded_coin_amounts: Optional[List[uint64]] = request.get("excluded_coin_amounts")
+        excluded_coin_amounts: Optional[list[uint64]] = request.get("excluded_coin_amounts")
         if excluded_coin_amounts is not None:
             excluded_coin_amounts = [uint64(a) for a in excluded_coin_amounts]
         else:
             excluded_coin_amounts = []
-        excluded_coins_input: Optional[Dict[str, Dict[str, Any]]] = request.get("excluded_coins")
+        excluded_coins_input: Optional[dict[str, dict[str, Any]]] = request.get("excluded_coins")
         if excluded_coins_input is not None:
             excluded_coins = [Coin.from_json_dict(json_coin) for json_coin in excluded_coins_input.values()]
         else:
             excluded_coins = []
-        excluded_coin_ids_input: Optional[List[str]] = request.get("excluded_coin_ids")
+        excluded_coin_ids_input: Optional[list[str]] = request.get("excluded_coin_ids")
         if excluded_coin_ids_input is not None:
             excluded_coin_ids = [bytes32.from_hexstr(hex_id) for hex_id in excluded_coin_ids_input]
         else:
@@ -1588,27 +1797,27 @@ class WalletRpcApi:
             all_coin_records = await state_mgr.coin_store.get_unspent_coins_for_wallet(wallet_id)
             if wallet.type() in {WalletType.CAT, WalletType.CRCAT}:
                 assert isinstance(wallet, CATWallet)
-                spendable_coins: List[WalletCoinRecord] = await wallet.get_cat_spendable_coins(all_coin_records)
+                spendable_coins: list[WalletCoinRecord] = await wallet.get_cat_spendable_coins(all_coin_records)
             else:
                 spendable_coins = list(await state_mgr.get_spendable_coins_for_wallet(wallet_id, all_coin_records))
 
             # Now we get the unconfirmed transactions and manually derive the additions and removals.
-            unconfirmed_transactions: List[TransactionRecord] = await state_mgr.tx_store.get_unconfirmed_for_wallet(
+            unconfirmed_transactions: list[TransactionRecord] = await state_mgr.tx_store.get_unconfirmed_for_wallet(
                 wallet_id
             )
-            unconfirmed_removal_ids: Dict[bytes32, uint64] = {
+            unconfirmed_removal_ids: dict[bytes32, uint64] = {
                 coin.name(): transaction.created_at_time
                 for transaction in unconfirmed_transactions
                 for coin in transaction.removals
             }
-            unconfirmed_additions: List[Coin] = [
+            unconfirmed_additions: list[Coin] = [
                 coin
                 for transaction in unconfirmed_transactions
                 for coin in transaction.additions
                 if await state_mgr.does_coin_belong_to_wallet(coin, wallet_id)
             ]
-            valid_spendable_cr: List[CoinRecord] = []
-            unconfirmed_removals: List[CoinRecord] = []
+            valid_spendable_cr: list[CoinRecord] = []
+            unconfirmed_removals: list[CoinRecord] = []
             for coin_record in all_coin_records:
                 if coin_record.name() in unconfirmed_removal_ids:
                     unconfirmed_removals.append(coin_record.to_coin_record(unconfirmed_removal_ids[coin_record.name()]))
@@ -1633,14 +1842,14 @@ class WalletRpcApi:
             "unconfirmed_additions": [coin.to_json_dict() for coin in unconfirmed_additions],
         }
 
-    async def get_coin_records_by_names(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_coin_records_by_names(self, request: dict[str, Any]) -> EndpointResult:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before finding coin information")
 
         if "names" not in request:
             raise ValueError("Names not in request")
         coin_ids = [bytes32.from_hexstr(name) for name in request["names"]]
-        kwargs: Dict[str, Any] = {
+        kwargs: dict[str, Any] = {
             "coin_id_filter": HashFilter.include(coin_ids),
         }
 
@@ -1656,10 +1865,10 @@ class WalletRpcApi:
             kwargs["spent_range"] = unspent_range
 
         async with self.service.wallet_state_manager.lock:
-            coin_records: List[CoinRecord] = await self.service.wallet_state_manager.get_coin_records_by_coin_ids(
+            coin_records: list[CoinRecord] = await self.service.wallet_state_manager.get_coin_records_by_coin_ids(
                 **kwargs
             )
-            missed_coins: List[str] = [
+            missed_coins: list[str] = [
                 "0x" + c_id.hex() for c_id in coin_ids if c_id not in [cr.name for cr in coin_records]
             ]
             if missed_coins:
@@ -1667,14 +1876,14 @@ class WalletRpcApi:
 
         return {"coin_records": [cr.to_json_dict() for cr in coin_records]}
 
-    async def get_current_derivation_index(self, request: Dict[str, Any]) -> Dict[str, Any]:
+    async def get_current_derivation_index(self, request: dict[str, Any]) -> dict[str, Any]:
         assert self.service.wallet_state_manager is not None
 
         index: Optional[uint32] = await self.service.wallet_state_manager.puzzle_store.get_last_derivation_path()
 
         return {"success": True, "index": index}
 
-    async def extend_derivation_index(self, request: Dict[str, Any]) -> Dict[str, Any]:
+    async def extend_derivation_index(self, request: dict[str, Any]) -> dict[str, Any]:
         assert self.service.wallet_state_manager is not None
 
         # Require a new max derivation index
@@ -1718,10 +1927,10 @@ class WalletRpcApi:
     @marshal
     async def get_notifications(self, request: GetNotifications) -> GetNotificationsResponse:
         if request.ids is None:
-            notifications: List[Notification] = (
-                await self.service.wallet_state_manager.notification_manager.notification_store.get_all_notifications(
-                    pagination=(request.start, request.end)
-                )
+            notifications: list[
+                Notification
+            ] = await self.service.wallet_state_manager.notification_manager.notification_store.get_all_notifications(
+                pagination=(request.start, request.end)
             )
         else:
             notifications = (
@@ -1732,8 +1941,8 @@ class WalletRpcApi:
 
         return GetNotificationsResponse(notifications)
 
-    async def delete_notifications(self, request: Dict[str, Any]) -> EndpointResult:
-        ids: Optional[List[str]] = request.get("ids", None)
+    async def delete_notifications(self, request: dict[str, Any]) -> EndpointResult:
+        ids: Optional[list[str]] = request.get("ids", None)
         if ids is None:
             await self.service.wallet_state_manager.notification_manager.notification_store.delete_all_notifications()
         else:
@@ -1746,9 +1955,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def send_notification(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         await self.service.wallet_state_manager.notification_manager.send_new_notification(
             bytes32.from_hexstr(request["target"]),
@@ -1761,7 +1970,7 @@ class WalletRpcApi:
 
         return {"tx": None, "transactions": None}  # tx_endpoint wrapper will take care of this
 
-    async def verify_signature(self, request: Dict[str, Any]) -> EndpointResult:
+    async def verify_signature(self, request: dict[str, Any]) -> EndpointResult:
         """
         Given a public key, message and signature, verify if it is valid.
         :param request:
@@ -1779,7 +1988,7 @@ class WalletRpcApi:
             except ValueError:
                 raise ValueError(f"Invalid signing mode: {signing_mode_str!r}")
 
-        if signing_mode == SigningMode.CHIP_0002 or signing_mode == SigningMode.CHIP_0002_P2_DELEGATED_CONDITIONS:
+        if signing_mode in {SigningMode.CHIP_0002, SigningMode.CHIP_0002_P2_DELEGATED_CONDITIONS}:
             # CHIP-0002 message signatures are made over the tree hash of:
             #   ("Chia Signed Message", message)
             message_to_verify: bytes = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, input_message)).get_tree_hash()
@@ -1819,7 +2028,7 @@ class WalletRpcApi:
         else:
             return {"isValid": False, "error": "Signature is invalid."}
 
-    async def sign_message_by_address(self, request: Dict[str, Any]) -> EndpointResult:
+    async def sign_message_by_address(self, request: dict[str, Any]) -> EndpointResult:
         """
         Given a derived P2 address, sign the message by its private key.
         :param request:
@@ -1849,7 +2058,7 @@ class WalletRpcApi:
             "signing_mode": mode.value,
         }
 
-    async def sign_message_by_id(self, request: Dict[str, Any]) -> EndpointResult:
+    async def sign_message_by_id(self, request: dict[str, Any]) -> EndpointResult:
         """
         Given a NFT/DID ID, sign the message by the P2 private key.
         :param request:
@@ -1914,22 +2123,22 @@ class WalletRpcApi:
     # CATs and Trading
     ##########################################################################################
 
-    async def get_cat_list(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_cat_list(self, request: dict[str, Any]) -> EndpointResult:
         return {"cat_list": list(DEFAULT_CATS.values())}
 
-    async def cat_set_name(self, request: Dict[str, Any]) -> EndpointResult:
+    async def cat_set_name(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=CATWallet)
         await wallet.set_name(str(request["name"]))
         return {"wallet_id": wallet_id}
 
-    async def cat_get_name(self, request: Dict[str, Any]) -> EndpointResult:
+    async def cat_get_name(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=CATWallet)
         name: str = wallet.get_name()
         return {"wallet_id": wallet_id, "name": name}
 
-    async def get_stray_cats(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_stray_cats(self, request: dict[str, Any]) -> EndpointResult:
         """
         Get a list of all unacknowledged CATs
         :param request: RPC request
@@ -1941,9 +2150,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def cat_spend(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
         hold_lock: bool = True,
     ) -> EndpointResult:
         if await self.service.wallet_state_manager.synced() is False:
@@ -1951,10 +2160,10 @@ class WalletRpcApi:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=CATWallet)
 
-        amounts: List[uint64] = []
-        puzzle_hashes: List[bytes32] = []
-        memos: List[List[bytes]] = []
-        additions: Optional[List[Dict[str, Any]]] = request.get("additions")
+        amounts: list[uint64] = []
+        puzzle_hashes: list[bytes32] = []
+        memos: list[list[bytes]] = []
+        additions: Optional[list[dict[str, Any]]] = request.get("additions")
         if not isinstance(request["fee"], int) or (additions is None and not isinstance(request["amount"], int)):
             raise ValueError("An integer amount or fee is required (too many decimals)")
         if additions is not None:
@@ -1974,17 +2183,17 @@ class WalletRpcApi:
             puzzle_hashes.append(decode_puzzle_hash(request["inner_address"]))
             if "memos" in request:
                 memos.append([mem.encode("utf-8") for mem in request["memos"]])
-        coins: Optional[Set[Coin]] = None
+        coins: Optional[set[Coin]] = None
         if "coins" in request and len(request["coins"]) > 0:
             coins = {Coin.from_json_dict(coin_json) for coin_json in request["coins"]}
         fee: uint64 = uint64(request.get("fee", 0))
 
-        cat_discrepancy_params: Tuple[Optional[int], Optional[str], Optional[str]] = (
+        cat_discrepancy_params: tuple[Optional[int], Optional[str], Optional[str]] = (
             request.get("extra_delta", None),
             request.get("tail_reveal", None),
             request.get("tail_solution", None),
         )
-        cat_discrepancy: Optional[Tuple[int, Program, Program]] = None
+        cat_discrepancy: Optional[tuple[int, Program, Program]] = None
         if cat_discrepancy_params != (None, None, None):
             if None in cat_discrepancy_params:
                 raise ValueError("Specifying extra_delta, tail_reveal, or tail_solution requires specifying the others")
@@ -2027,13 +2236,13 @@ class WalletRpcApi:
             "transaction_id": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def cat_get_asset_id(self, request: Dict[str, Any]) -> EndpointResult:
+    async def cat_get_asset_id(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=CATWallet)
         asset_id: str = wallet.get_asset_id()
         return {"asset_id": asset_id, "wallet_id": wallet_id}
 
-    async def cat_asset_id_to_name(self, request: Dict[str, Any]) -> EndpointResult:
+    async def cat_asset_id_to_name(self, request: dict[str, Any]) -> EndpointResult:
         wallet = await self.service.wallet_state_manager.get_wallet_for_asset_id(request["asset_id"])
         if wallet is None:
             if request["asset_id"] in DEFAULT_CATS:
@@ -2046,17 +2255,17 @@ class WalletRpcApi:
     @tx_endpoint(push=False)
     async def create_offer_for_ids(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         if action_scope.config.push:
             raise ValueError("Cannot push an incomplete spend")  # pragma: no cover
 
-        offer: Dict[str, int] = request["offer"]
+        offer: dict[str, int] = request["offer"]
         fee: uint64 = uint64(request.get("fee", 0))
         validate_only: bool = request.get("validate_only", False)
-        driver_dict_str: Optional[Dict[str, Any]] = request.get("driver_dict", None)
+        driver_dict_str: Optional[dict[str, Any]] = request.get("driver_dict", None)
         marshalled_solver = request.get("solver")
         solver: Optional[Solver]
         if marshalled_solver is None:
@@ -2065,7 +2274,7 @@ class WalletRpcApi:
             solver = Solver(info=marshalled_solver)
 
         # This driver_dict construction is to maintain backward compatibility where everything is assumed to be a CAT
-        driver_dict: Dict[bytes32, PuzzleInfo] = {}
+        driver_dict: dict[bytes32, PuzzleInfo] = {}
         if driver_dict_str is None:
             for key, amount in offer.items():
                 if amount > 0:
@@ -2079,12 +2288,12 @@ class WalletRpcApi:
             for key, value in driver_dict_str.items():
                 driver_dict[bytes32.from_hexstr(key)] = PuzzleInfo(value)
 
-        modified_offer: Dict[Union[int, bytes32], int] = {}
-        for key in offer:
+        modified_offer: dict[Union[int, bytes32], int] = {}
+        for wallet_identifier, change in offer.items():
             try:
-                modified_offer[bytes32.from_hexstr(key)] = offer[key]
+                modified_offer[bytes32.from_hexstr(wallet_identifier)] = change
             except ValueError:
-                modified_offer[int(key)] = offer[key]
+                modified_offer[int(wallet_identifier)] = change
 
         async with self.service.wallet_state_manager.lock:
             result = await self.service.wallet_state_manager.trade_manager.create_offer_for_ids(
@@ -2097,7 +2306,7 @@ class WalletRpcApi:
                 extra_conditions=extra_conditions,
             )
         if result[0]:
-            success, trade_record, error = result
+            _success, trade_record, _error = result
             return {
                 "offer": Offer.from_bytes(trade_record.offer).to_bech32(),
                 "trade_record": trade_record.to_json_dict_convenience(),
@@ -2105,7 +2314,7 @@ class WalletRpcApi:
             }
         raise ValueError(result[2])
 
-    async def get_offer_summary(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_offer_summary(self, request: dict[str, Any]) -> EndpointResult:
         offer_hex: str = request["offer"]
 
         ###
@@ -2114,7 +2323,7 @@ class WalletRpcApi:
         from chia.util.bech32m import bech32_decode, convertbits
         from chia.wallet.util.puzzle_compression import OFFER_MOD_OLD, decompress_object_with_puzzles
 
-        hrpgot, data = bech32_decode(offer_hex, max_length=len(offer_hex))
+        _hrpgot, data = bech32_decode(offer_hex, max_length=len(offer_hex))
         if data is None:
             raise ValueError("Invalid Offer")
         decoded = convertbits(list(data), 5, 8, False)
@@ -2143,12 +2352,12 @@ class WalletRpcApi:
                         k: v
                         for k, v in valid_times.to_json_dict().items()
                         if k
-                        not in (
+                        not in {
                             "max_secs_after_created",
                             "min_secs_since_created",
                             "max_blocks_after_created",
                             "min_blocks_since_created",
-                        )
+                        }
                     },
                 },
                 "id": offer.name(),
@@ -2184,7 +2393,7 @@ class WalletRpcApi:
             },
         }
 
-    async def check_offer_validity(self, request: Dict[str, Any]) -> EndpointResult:
+    async def check_offer_validity(self, request: dict[str, Any]) -> EndpointResult:
         offer_hex: str = request["offer"]
 
         ###
@@ -2193,7 +2402,7 @@ class WalletRpcApi:
         from chia.util.bech32m import bech32_decode, convertbits
         from chia.wallet.util.puzzle_compression import OFFER_MOD_OLD, decompress_object_with_puzzles
 
-        hrpgot, data = bech32_decode(offer_hex, max_length=len(offer_hex))
+        _hrpgot, data = bech32_decode(offer_hex, max_length=len(offer_hex))
         if data is None:
             raise ValueError("Invalid Offer")  # pragma: no cover
         decoded = convertbits(list(data), 5, 8, False)
@@ -2216,9 +2425,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def take_offer(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         offer_hex: str = request["offer"]
 
@@ -2228,7 +2437,7 @@ class WalletRpcApi:
         from chia.util.bech32m import bech32_decode, convertbits
         from chia.wallet.util.puzzle_compression import OFFER_MOD_OLD, decompress_object_with_puzzles
 
-        hrpgot, data = bech32_decode(offer_hex, max_length=len(offer_hex))
+        _hrpgot, data = bech32_decode(offer_hex, max_length=len(offer_hex))
         if data is None:
             raise ValueError("Invalid Offer")  # pragma: no cover
         decoded = convertbits(list(data), 5, 8, False)
@@ -2243,7 +2452,7 @@ class WalletRpcApi:
 
         offer = Offer.from_bech32(offer_hex)
         fee: uint64 = uint64(request.get("fee", 0))
-        maybe_marshalled_solver: Optional[Dict[str, Any]] = request.get("solver")
+        maybe_marshalled_solver: Optional[dict[str, Any]] = request.get("solver")
         solver: Optional[Solver]
         if maybe_marshalled_solver is None:
             solver = None
@@ -2272,7 +2481,7 @@ class WalletRpcApi:
             "signing_responses": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def get_offer(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_offer(self, request: dict[str, Any]) -> EndpointResult:
         trade_mgr = self.service.wallet_state_manager.trade_manager
 
         trade_id = bytes32.from_hexstr(request["trade_id"])
@@ -2285,7 +2494,7 @@ class WalletRpcApi:
         offer_value: Optional[str] = Offer.from_bytes(offer_to_return).to_bech32() if file_contents else None
         return {"trade_record": trade_record.to_json_dict_convenience(), "offer": offer_value}
 
-    async def get_all_offers(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_all_offers(self, request: dict[str, Any]) -> EndpointResult:
         trade_mgr = self.service.wallet_state_manager.trade_manager
 
         start: int = request.get("start", 0)
@@ -2307,7 +2516,7 @@ class WalletRpcApi:
             include_completed=include_completed,
         )
         result = []
-        offer_values: Optional[List[str]] = [] if file_contents else None
+        offer_values: Optional[list[str]] = [] if file_contents else None
         for trade in all_trades:
             result.append(trade.to_json_dict_convenience())
             if file_contents and offer_values is not None:
@@ -2316,7 +2525,7 @@ class WalletRpcApi:
 
         return {"trade_records": result, "offers": offer_values}
 
-    async def get_offers_count(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_offers_count(self, request: dict[str, Any]) -> EndpointResult:
         trade_mgr = self.service.wallet_state_manager.trade_manager
 
         (total, my_offers_count, taken_offers_count) = await trade_mgr.trade_store.get_trades_count()
@@ -2326,9 +2535,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def cancel_offer(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wsm = self.service.wallet_state_manager
         secure = request["secure"]
@@ -2336,7 +2545,7 @@ class WalletRpcApi:
         fee: uint64 = uint64(request.get("fee", 0))
         async with self.service.wallet_state_manager.lock:
             await wsm.trade_manager.cancel_pending_offers(
-                [bytes32(trade_id)], action_scope, fee=fee, secure=secure, extra_conditions=extra_conditions
+                [trade_id], action_scope, fee=fee, secure=secure, extra_conditions=extra_conditions
             )
 
         return {"transactions": None}  # tx_endpoint wrapper will take care of this
@@ -2344,9 +2553,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True, merge_spends=False)
     async def cancel_offers(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         secure = request["secure"]
         batch_fee: uint64 = uint64(request.get("batch_fee", 0))
@@ -2366,7 +2575,7 @@ class WalletRpcApi:
         if asset_id is not None and asset_id != "xch":
             key = bytes32.from_hexstr(asset_id)
         while True:
-            records: Dict[bytes32, TradeRecord] = {}
+            records: dict[bytes32, TradeRecord] = {}
             trades = await trade_mgr.trade_store.get_trades_between(
                 start,
                 end,
@@ -2411,13 +2620,13 @@ class WalletRpcApi:
     # Distributed Identities
     ##########################################################################################
 
-    async def did_set_wallet_name(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_set_wallet_name(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
         await wallet.set_name(str(request["name"]))
         return {"success": True, "wallet_id": wallet_id}
 
-    async def did_get_wallet_name(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_get_wallet_name(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
         name: str = wallet.get_name()  # type: ignore[no-untyped-call]  # Missing hint in `did_wallet.py`
@@ -2426,9 +2635,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def did_update_recovery_ids(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
@@ -2456,9 +2665,9 @@ class WalletRpcApi:
     @tx_endpoint(push=False)
     async def did_message_spend(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
@@ -2477,7 +2686,7 @@ class WalletRpcApi:
             "transactions": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def did_get_info(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_get_info(self, request: dict[str, Any]) -> EndpointResult:
         if "coin_id" not in request:
             return {"success": False, "error": "Coin ID is required."}
         coin_id = request["coin_id"]
@@ -2517,7 +2726,7 @@ class WalletRpcApi:
             "hints": hints,
         }
 
-    async def did_find_lost_did(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_find_lost_did(self, request: dict[str, Any]) -> EndpointResult:
         """
         Recover a missing or unspendable DID wallet by a coin id of the DID
         :param coin_id: It can be DID ID, launcher coin ID or any coin ID of the DID you want to find.
@@ -2556,21 +2765,22 @@ class WalletRpcApi:
             if hinted_coin.coin.amount % 2 == 1 and hinted_coin.hint is not None:
                 hint = hinted_coin.hint
                 break
-        if hint is None:
+        derivation_record = None
+        if hint is not None:
+            derivation_record = (
+                await self.service.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(hint)
+            )
+        if derivation_record is None:
             # This is an invalid DID, check if we are owner
             derivation_record = (
                 await self.service.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
                     p2_puzzle.get_tree_hash()
                 )
             )
-        else:
-            derivation_record = (
-                await self.service.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(hint)
-            )
 
         launcher_id = bytes32(singleton_struct.rest().first().as_atom())
         if derivation_record is None:
-            return {"success": False, "error": f"This DID {launcher_id} is not belong to the connected wallet"}
+            return {"success": False, "error": f"This DID {launcher_id} does not belong to the connected wallet"}
         else:
             our_inner_puzzle: Program = self.service.wallet_state_manager.main_wallet.puzzle_for_pk(
                 derivation_record.pubkey
@@ -2650,7 +2860,7 @@ class WalletRpcApi:
 
             if did_wallet is None:
                 # Create DID wallet
-                response: List[CoinState] = await self.service.get_coin_state([launcher_id], peer=peer)
+                response: list[CoinState] = await self.service.get_coin_state([launcher_id], peer=peer)
                 if len(response) == 0:
                     return {"success": False, "error": f"Could not find the launch coin with ID: {launcher_id}"}
                 launcher_coin: CoinState = response[0]
@@ -2668,7 +2878,7 @@ class WalletRpcApi:
                     # Inner DID puzzle doesn't match, we need to update the DID info
                     full_solution: Program = Program.from_bytes(bytes(coin_spend.solution))
                     inner_solution: Program = full_solution.rest().rest().first()
-                    recovery_list: List[bytes32] = []
+                    recovery_list: list[bytes32] = []
                     backup_required: int = num_verification.as_int()
                     if recovery_list_hash != NIL_TREEHASH:
                         try:
@@ -2718,13 +2928,13 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def did_update_metadata(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
-        metadata: Dict[str, str] = {}
+        metadata: dict[str, str] = {}
         if "metadata" in request and type(request["metadata"]) is dict:
             metadata = request["metadata"]
         async with self.service.wallet_state_manager.lock:
@@ -2743,7 +2953,7 @@ class WalletRpcApi:
             else:
                 return {"success": False, "error": f"Couldn't update metadata with input: {metadata}"}
 
-    async def did_get_did(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_get_did(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
         my_did: str = encode_puzzle_hash(bytes32.fromhex(wallet.get_my_DID()), AddressType.DID.hrp(self.service.config))
@@ -2754,7 +2964,7 @@ class WalletRpcApi:
             except RuntimeError:
                 return {"success": True, "wallet_id": wallet_id, "my_did": my_did}
 
-    async def did_get_recovery_list(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_get_recovery_list(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
         recovery_list = wallet.did_info.backup_ids
@@ -2768,7 +2978,7 @@ class WalletRpcApi:
             "num_required": wallet.did_info.num_of_backup_ids_needed,
         }
 
-    async def did_get_metadata(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_get_metadata(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
         metadata = json.loads(wallet.did_info.metadata)
@@ -2780,7 +2990,7 @@ class WalletRpcApi:
 
     # TODO: this needs a test
     # Don't need full @tx_endpoint decorator here, but "push" is still a valid option
-    async def did_recovery_spend(self, request: Dict[str, Any]) -> EndpointResult:  # pragma: no cover
+    async def did_recovery_spend(self, request: dict[str, Any]) -> EndpointResult:  # pragma: no cover
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
         if len(request["attest_data"]) < wallet.did_info.num_of_backup_ids_needed:
@@ -2822,7 +3032,7 @@ class WalletRpcApi:
             "transactions": [tx.to_json_dict_convenience(self.service.config)],
         }
 
-    async def did_get_pubkey(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_get_pubkey(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
         pubkey = bytes((await wallet.wallet_state_manager.get_unused_derivation_record(wallet_id)).pubkey).hex()
@@ -2832,9 +3042,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def did_create_attest(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:  # pragma: no cover
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
@@ -2860,7 +3070,7 @@ class WalletRpcApi:
         else:
             return {"success": False}
 
-    async def did_get_information_needed_for_recovery(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_get_information_needed_for_recovery(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         did_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
         my_did = encode_puzzle_hash(
@@ -2878,7 +3088,7 @@ class WalletRpcApi:
             "backup_dids": did_wallet.did_info.backup_ids,
         }
 
-    async def did_get_current_coin_info(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_get_current_coin_info(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         did_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
         my_did = encode_puzzle_hash(
@@ -2897,7 +3107,7 @@ class WalletRpcApi:
             "did_amount": did_coin_threeple[2],
         }
 
-    async def did_create_backup_file(self, request: Dict[str, Any]) -> EndpointResult:
+    async def did_create_backup_file(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         did_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
         return {"wallet_id": wallet_id, "success": True, "backup_data": did_wallet.create_backup()}
@@ -2905,9 +3115,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def did_transfer_did(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced.")
@@ -2934,7 +3144,7 @@ class WalletRpcApi:
     # DAO Wallet
     ##########################################################################################
 
-    async def dao_adjust_filter_level(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dao_adjust_filter_level(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
         await dao_wallet.adjust_filter_level(uint64(request["filter_level"]))
@@ -2946,9 +3156,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dao_add_funds_to_treasury(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
@@ -2956,7 +3166,7 @@ class WalletRpcApi:
         wallet_type = self.service.wallet_state_manager.wallets[funding_wallet_id].type()
         amount = request.get("amount")
         assert amount
-        if wallet_type not in [WalletType.STANDARD_WALLET, WalletType.CAT]:  # pragma: no cover
+        if wallet_type not in {WalletType.STANDARD_WALLET, WalletType.CAT}:  # pragma: no cover
             raise ValueError(f"Cannot fund a treasury with assets from a {wallet_type.name} wallet")
         await dao_wallet.create_add_funds_to_treasury_spend(
             uint64(amount),
@@ -2972,7 +3182,7 @@ class WalletRpcApi:
             "transactions": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def dao_get_treasury_balance(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dao_get_treasury_balance(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
         assert dao_wallet is not None
@@ -2986,14 +3196,14 @@ class WalletRpcApi:
                 balances[asset_id.hex()] = balance
         return {"success": True, "balances": balances}
 
-    async def dao_get_treasury_id(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dao_get_treasury_id(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
         assert dao_wallet is not None
         treasury_id = dao_wallet.dao_info.treasury_id
         return {"treasury_id": treasury_id}
 
-    async def dao_get_rules(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dao_get_rules(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
         assert dao_wallet is not None
@@ -3003,9 +3213,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dao_send_to_lockup(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
@@ -3027,7 +3237,7 @@ class WalletRpcApi:
             "transactions": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def dao_get_proposals(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dao_get_proposals(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         include_closed = request.get("include_closed", True)
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
@@ -3043,7 +3253,7 @@ class WalletRpcApi:
             "soft_close_length": dao_rules.soft_close_length,
         }
 
-    async def dao_get_proposal_state(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dao_get_proposal_state(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
         assert dao_wallet is not None
@@ -3053,9 +3263,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dao_exit_lockup(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
@@ -3066,7 +3276,7 @@ class WalletRpcApi:
         assert dao_cat_wallet is not None
         if request["coins"]:  # pragma: no cover
             coin_list = [Coin.from_json_dict(coin) for coin in request["coins"]]
-            coins: List[LockedCoinInfo] = []
+            coins: list[LockedCoinInfo] = []
             for lci in dao_cat_wallet.dao_cat_info.locked_coins:
                 if lci.coin in coin_list:
                     coins.append(lci)
@@ -3094,19 +3304,19 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dao_create_proposal(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
         assert dao_wallet is not None
 
         if request["proposal_type"] == "spend":
-            amounts: List[uint64] = []
-            puzzle_hashes: List[bytes32] = []
-            asset_types: List[Optional[bytes32]] = []
-            additions: Optional[List[Dict[str, Any]]] = request.get("additions")
+            amounts: list[uint64] = []
+            puzzle_hashes: list[bytes32] = []
+            asset_types: list[Optional[bytes32]] = []
+            additions: Optional[list[dict[str, Any]]] = request.get("additions")
             if additions is not None:
                 for addition in additions:
                     if "asset_id" in addition:
@@ -3183,7 +3393,7 @@ class WalletRpcApi:
         return {
             "success": True,
             # Semantics guarantee proposal_id here
-            "proposal_id": proposal_id,  # pylint: disable=possibly-used-before-assignment
+            "proposal_id": proposal_id,
             "tx_id": None,  # tx_endpoint wrapper will take care of this
             "tx": None,  # tx_endpoint wrapper will take care of this
             "transactions": None,  # tx_endpoint wrapper will take care of this
@@ -3192,9 +3402,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dao_vote_on_proposal(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
@@ -3218,7 +3428,7 @@ class WalletRpcApi:
             "transactions": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def dao_parse_proposal(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dao_parse_proposal(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
         assert dao_wallet is not None
@@ -3230,9 +3440,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dao_close_proposal(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         dao_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DAOWallet)
@@ -3261,9 +3471,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dao_free_coins_from_finished_proposals(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         fee = uint64(request.get("fee", 0))
@@ -3288,9 +3498,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def nft_mint_nft(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         log.debug("Got minting RPC request: %s", request)
         wallet_id = uint32(request["wallet_id"])
@@ -3303,14 +3513,18 @@ class WalletRpcApi:
         if isinstance(royalty_address, str):
             royalty_puzhash = decode_puzzle_hash(royalty_address)
         elif royalty_address is None:
-            royalty_puzhash = await nft_wallet.standard_wallet.get_new_puzzlehash()
+            royalty_puzhash = await nft_wallet.standard_wallet.get_puzzle_hash(
+                new=not action_scope.config.tx_config.reuse_puzhash
+            )
         else:
             royalty_puzhash = royalty_address
         target_address = request.get("target_address")
         if isinstance(target_address, str):
             target_puzhash = decode_puzzle_hash(target_address)
         elif target_address is None:
-            target_puzhash = await nft_wallet.standard_wallet.get_new_puzzlehash()
+            target_puzhash = await nft_wallet.standard_wallet.get_puzzle_hash(
+                new=not action_scope.config.tx_config.reuse_puzhash
+            )
         else:
             target_puzhash = target_address
         if "uris" not in request:
@@ -3361,7 +3575,7 @@ class WalletRpcApi:
             "transactions": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def nft_count_nfts(self, request: Dict[str, Any]) -> EndpointResult:
+    async def nft_count_nfts(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = request.get("wallet_id", None)
         count = 0
         if wallet_id is not None:
@@ -3375,9 +3589,9 @@ class WalletRpcApi:
             count = await self.service.wallet_state_manager.nft_store.count()
         return {"wallet_id": wallet_id, "success": True, "count": count}
 
-    async def nft_get_nfts(self, request: Dict[str, Any]) -> EndpointResult:
+    async def nft_get_nfts(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = request.get("wallet_id", None)
-        nfts: List[NFTCoinInfo] = []
+        nfts: list[NFTCoinInfo] = []
         if wallet_id is not None:
             nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
         else:
@@ -3403,9 +3617,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def nft_set_nft_did(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
@@ -3436,9 +3650,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def nft_set_did_bulk(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         """
         Bulk set DID for NFTs across different wallets.
@@ -3454,7 +3668,7 @@ class WalletRpcApi:
         did_id = request.get("did_id", b"")
         if did_id != b"":
             did_id = decode_puzzle_hash(did_id)
-        nft_dict: Dict[uint32, List[NFTCoinInfo]] = {}
+        nft_dict: dict[uint32, list[NFTCoinInfo]] = {}
         coin_ids = []
         nft_ids = []
         fee = uint64(request.get("fee", 0))
@@ -3514,9 +3728,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def nft_transfer_bulk(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         """
         Bulk transfer NFTs to an address.
@@ -3534,7 +3748,7 @@ class WalletRpcApi:
             puzzle_hash = decode_puzzle_hash(address)
         else:
             return dict(success=False, error="target_address parameter missing")
-        nft_dict: Dict[uint32, List[NFTCoinInfo]] = {}
+        nft_dict: dict[uint32, list[NFTCoinInfo]] = {}
         coin_ids = []
         fee = uint64(request.get("fee", 0))
 
@@ -3585,7 +3799,7 @@ class WalletRpcApi:
                 "transactions": None,  # tx_endpoint wrapper will take care of this
             }
 
-    async def nft_get_by_did(self, request: Dict[str, Any]) -> EndpointResult:
+    async def nft_get_by_did(self, request: dict[str, Any]) -> EndpointResult:
         did_id: Optional[bytes32] = None
         if request.get("did_id", None) is not None:
             did_id = decode_puzzle_hash(request["did_id"])
@@ -3594,7 +3808,7 @@ class WalletRpcApi:
                 return {"wallet_id": wallet.wallet_id, "success": True}
         return {"error": f"Cannot find a NFT wallet DID = {did_id}", "success": False}
 
-    async def nft_get_wallet_did(self, request: Dict[str, Any]) -> EndpointResult:
+    async def nft_get_wallet_did(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
         did_bytes: Optional[bytes32] = nft_wallet.get_did()
@@ -3603,9 +3817,9 @@ class WalletRpcApi:
             did_id = encode_puzzle_hash(did_bytes, AddressType.DID.hrp(self.service.config))
         return {"success": True, "did_id": None if len(did_id) == 0 else did_id}
 
-    async def nft_get_wallets_with_dids(self, request: Dict[str, Any]) -> EndpointResult:
+    async def nft_get_wallets_with_dids(self, request: dict[str, Any]) -> EndpointResult:
         all_wallets = self.service.wallet_state_manager.wallets.values()
-        did_wallets_by_did_id: Dict[bytes32, uint32] = {}
+        did_wallets_by_did_id: dict[bytes32, uint32] = {}
 
         for wallet in all_wallets:
             if wallet.type() == WalletType.DECENTRALIZED_ID:
@@ -3613,7 +3827,7 @@ class WalletRpcApi:
                 if wallet.did_info.origin_coin is not None:
                     did_wallets_by_did_id[wallet.did_info.origin_coin.name()] = wallet.id()
 
-        did_nft_wallets: List[Dict[str, Any]] = []
+        did_nft_wallets: list[dict[str, Any]] = []
         for wallet in all_wallets:
             if isinstance(wallet, NFTWallet):
                 nft_wallet_did: Optional[bytes32] = wallet.get_did()
@@ -3631,7 +3845,7 @@ class WalletRpcApi:
                         )
         return {"success": True, "nft_wallets": did_nft_wallets}
 
-    async def nft_set_nft_status(self, request: Dict[str, Any]) -> EndpointResult:
+    async def nft_set_nft_status(self, request: dict[str, Any]) -> EndpointResult:
         wallet_id: uint32 = uint32(request["wallet_id"])
         coin_id: bytes32 = bytes32.from_hexstr(request["coin_id"])
         status: bool = request["in_transaction"]
@@ -3643,9 +3857,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def nft_transfer_nft(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         address = request["target_address"]
@@ -3686,7 +3900,7 @@ class WalletRpcApi:
             log.exception(f"Failed to transfer NFT: {e}")
             return {"success": False, "error": str(e)}
 
-    async def nft_get_info(self, request: Dict[str, Any]) -> EndpointResult:
+    async def nft_get_info(self, request: dict[str, Any]) -> EndpointResult:
         if "coin_id" not in request:
             return {"success": False, "error": "Coin ID is required."}
         coin_id = request["coin_id"]
@@ -3726,7 +3940,7 @@ class WalletRpcApi:
         )
 
         # Get launcher coin
-        launcher_coin: List[CoinState] = await self.service.wallet_state_manager.wallet_node.get_coin_state(
+        launcher_coin: list[CoinState] = await self.service.wallet_state_manager.wallet_node.get_coin_state(
             [uncurried_nft.singleton_launcher_id], peer=peer
         )
         if launcher_coin is None or len(launcher_coin) < 1 or launcher_coin[0].spent_height is None:
@@ -3755,9 +3969,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def nft_add_uri(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         wallet_id = uint32(request["wallet_id"])
         # Note metadata updater can only add one uri for one field per spend.
@@ -3783,7 +3997,7 @@ class WalletRpcApi:
             "transactions": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def nft_calculate_royalties(self, request: Dict[str, Any]) -> EndpointResult:
+    async def nft_calculate_royalties(self, request: dict[str, Any]) -> EndpointResult:
         return NFTWallet.royalty_calculation(
             {
                 asset["asset"]: (asset["royalty_address"], uint16(asset["royalty_percentage"]))
@@ -3795,9 +4009,9 @@ class WalletRpcApi:
     @tx_endpoint(push=False)
     async def nft_mint_bulk(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         if action_scope.config.push:
             raise ValueError("Automatic pushing of nft minting transactions not yet available")  # pragma: no cover
@@ -3808,7 +4022,7 @@ class WalletRpcApi:
         royalty_address = request.get("royalty_address", None)
         if isinstance(royalty_address, str) and royalty_address != "":
             royalty_puzhash = decode_puzzle_hash(royalty_address)
-        elif royalty_address in [None, ""]:
+        elif royalty_address in {None, ""}:
             royalty_puzhash = await nft_wallet.standard_wallet.get_new_puzzlehash()
         else:
             royalty_puzhash = bytes32.from_hexstr(royalty_address)
@@ -3924,7 +4138,7 @@ class WalletRpcApi:
             "transactions": None,  # tx_endpoint wrapper will take care of this
         }
 
-    async def get_coin_records(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_coin_records(self, request: dict[str, Any]) -> EndpointResult:
         parsed_request = GetCoinRecords.from_json_dict(request)
 
         if parsed_request.limit != uint32.MAXIMUM and parsed_request.limit > self.max_get_coin_records_limit:
@@ -3966,8 +4180,8 @@ class WalletRpcApi:
             "total_count": result.total_count,
         }
 
-    async def get_farmed_amount(self, request: Dict[str, Any]) -> EndpointResult:
-        tx_records: List[TransactionRecord] = await self.service.wallet_state_manager.tx_store.get_farming_rewards()
+    async def get_farmed_amount(self, request: dict[str, Any]) -> EndpointResult:
+        tx_records: list[TransactionRecord] = await self.service.wallet_state_manager.tx_store.get_farming_rewards()
         amount = 0
         pool_reward_amount = 0
         farmer_reward_amount = 0
@@ -4013,9 +4227,9 @@ class WalletRpcApi:
     @tx_endpoint(push=False)
     async def create_signed_transaction(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
         hold_lock: bool = True,
     ) -> EndpointResult:
         if "wallet_id" in request:
@@ -4031,7 +4245,7 @@ class WalletRpcApi:
         if "additions" not in request or len(request["additions"]) < 1:
             raise ValueError("Specify additions list")
 
-        additions: List[Dict[str, Any]] = request["additions"]
+        additions: list[dict[str, Any]] = request["additions"]
         amount_0: uint64 = uint64(additions[0]["amount"])
         assert amount_0 <= self.service.constants.MAX_COIN_AMOUNT
         puzzle_hash_0 = bytes32.from_hexstr(additions[0]["puzzle_hash"])
@@ -4040,7 +4254,7 @@ class WalletRpcApi:
 
         memos_0 = [] if "memos" not in additions[0] else [mem.encode("utf-8") for mem in additions[0]["memos"]]
 
-        additional_outputs: List[Payment] = []
+        additional_outputs: list[Payment] = []
         for addition in additions[1:]:
             receiver_ph = bytes32.from_hexstr(addition["puzzle_hash"])
             if len(receiver_ph) != 32:
@@ -4147,9 +4361,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def pw_join_pool(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         fee = uint64(request.get("fee", 0))
         wallet_id = uint32(request["wallet_id"])
@@ -4185,9 +4399,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def pw_self_pool(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         # Leaving a pool requires two state transitions.
         # First we transition to PoolSingletonState.LEAVING_POOL
@@ -4211,9 +4425,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def pw_absorb_rewards(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         """Perform a sweep of the p2_singleton rewards controlled by the pool wallet singleton"""
         if await self.service.wallet_state_manager.synced() is False:
@@ -4234,14 +4448,14 @@ class WalletRpcApi:
                 "transactions": None,  # tx_endpoint wrapper will take care of this
             }
 
-    async def pw_status(self, request: Dict[str, Any]) -> EndpointResult:
+    async def pw_status(self, request: dict[str, Any]) -> EndpointResult:
         """Return the complete state of the Pool wallet with id `request["wallet_id"]`"""
         wallet_id = uint32(request["wallet_id"])
         wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=PoolWallet)
 
         assert isinstance(wallet, PoolWallet)
         state: PoolWalletInfo = await wallet.get_current_state()
-        unconfirmed_transactions: List[TransactionRecord] = await wallet.get_unconfirmed_transactions()
+        unconfirmed_transactions: list[TransactionRecord] = await wallet.get_unconfirmed_transactions()
         return {
             "state": state.to_json_dict(),
             "unconfirmed_transactions": unconfirmed_transactions,
@@ -4253,9 +4467,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def create_new_dl(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         """Initialize the DataLayer Wallet (only one can exist)"""
         if self.service.wallet_state_manager is None:
@@ -4284,7 +4498,7 @@ class WalletRpcApi:
             "launcher_id": launcher_id,
         }
 
-    async def dl_track_new(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dl_track_new(self, request: dict[str, Any]) -> EndpointResult:
         """Initialize the DataLayer Wallet (only one can exist)"""
         if self.service.wallet_state_manager is None:
             raise ValueError("The wallet service is not currently initialized")
@@ -4309,7 +4523,7 @@ class WalletRpcApi:
                 continue  # try some other peers, maybe someone has it
         return {}
 
-    async def dl_stop_tracking(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dl_stop_tracking(self, request: dict[str, Any]) -> EndpointResult:
         """Initialize the DataLayer Wallet (only one can exist)"""
         if self.service.wallet_state_manager is None:
             raise ValueError("The wallet service is not currently initialized")
@@ -4318,7 +4532,7 @@ class WalletRpcApi:
         await dl_wallet.stop_tracking_singleton(bytes32.from_hexstr(request["launcher_id"]))
         return {}
 
-    async def dl_latest_singleton(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dl_latest_singleton(self, request: dict[str, Any]) -> EndpointResult:
         """Get the singleton record for the latest singleton of a launcher ID"""
         if self.service.wallet_state_manager is None:
             raise ValueError("The wallet service is not currently initialized")
@@ -4330,7 +4544,7 @@ class WalletRpcApi:
         record = await wallet.get_latest_singleton(bytes32.from_hexstr(request["launcher_id"]), only_confirmed)
         return {"singleton": None if record is None else record.to_json_dict()}
 
-    async def dl_singletons_by_root(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dl_singletons_by_root(self, request: dict[str, Any]) -> EndpointResult:
         """Get the singleton records that contain the specified root"""
         if self.service.wallet_state_manager is None:
             raise ValueError("The wallet service is not currently initialized")
@@ -4345,9 +4559,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dl_update_root(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         """Get the singleton record for the latest singleton of a launcher ID"""
         if self.service.wallet_state_manager is None:
@@ -4371,9 +4585,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dl_update_multiple(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         """Update multiple singletons with new merkle roots"""
         if self.service.wallet_state_manager is None:
@@ -4397,7 +4611,7 @@ class WalletRpcApi:
                 "transactions": None,  # tx_endpoint wrapper will take care of this
             }
 
-    async def dl_history(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dl_history(self, request: dict[str, Any]) -> EndpointResult:
         """Get the singleton record for the latest singleton of a launcher ID"""
         if self.service.wallet_state_manager is None:
             raise ValueError("The wallet service is not currently initialized")
@@ -4416,7 +4630,7 @@ class WalletRpcApi:
         history_json = [rec.to_json_dict() for rec in history]
         return {"history": history_json, "count": len(history_json)}
 
-    async def dl_owned_singletons(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dl_owned_singletons(self, request: dict[str, Any]) -> EndpointResult:
         """Get all owned singleton records"""
         if self.service.wallet_state_manager is None:
             raise ValueError("The wallet service is not currently initialized")
@@ -4431,7 +4645,7 @@ class WalletRpcApi:
 
         return {"singletons": singletons_json, "count": len(singletons_json)}
 
-    async def dl_get_mirrors(self, request: Dict[str, Any]) -> EndpointResult:
+    async def dl_get_mirrors(self, request: dict[str, Any]) -> EndpointResult:
         """Get all of the mirrors for a specific singleton"""
         if self.service.wallet_state_manager is None:
             raise ValueError("The wallet service is not currently initialized")
@@ -4446,9 +4660,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dl_new_mirror(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         """Add a new on chain message for a specific singleton"""
         if self.service.wallet_state_manager is None:
@@ -4472,9 +4686,9 @@ class WalletRpcApi:
     @tx_endpoint(push=True)
     async def dl_delete_mirror(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         """Remove an existing mirror for a specific singleton"""
         if self.service.wallet_state_manager is None:
@@ -4497,7 +4711,7 @@ class WalletRpcApi:
 
     async def dl_verify_proof(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
     ) -> EndpointResult:
         """Verify a proof of inclusion for a DL singleton"""
         res = await dl_verify_proof(
@@ -4512,12 +4726,13 @@ class WalletRpcApi:
     # Verified Credential
     ##########################################################################################
     @tx_endpoint(push=True)
+    @marshal
     async def vc_mint(
         self,
-        request: Dict[str, Any],
+        request: VCMint,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> VCMintResponse:
         """
         Mint a verified credential using the assigned DID
         :param request: We require 'did_id' that will be minting the VC and options for a new 'target_address' as well
@@ -4525,84 +4740,58 @@ class WalletRpcApi:
         :return: a 'vc_record' containing all the information of the soon-to-be-confirmed vc as well as any relevant
         'transactions'
         """
-
-        @streamable
-        @dataclasses.dataclass(frozen=True)
-        class VCMint(Streamable):
-            did_id: str
-            target_address: Optional[str] = None
-            fee: uint64 = uint64(0)
-
-        parsed_request = VCMint.from_json_dict(request)
-
-        did_id = decode_puzzle_hash(parsed_request.did_id)
+        did_id = decode_puzzle_hash(request.did_id)
         puzhash: Optional[bytes32] = None
-        if parsed_request.target_address is not None:
-            puzhash = decode_puzzle_hash(parsed_request.target_address)
+        if request.target_address is not None:
+            puzhash = decode_puzzle_hash(request.target_address)
 
         vc_wallet: VCWallet = await self.service.wallet_state_manager.get_or_create_vc_wallet()
         vc_record = await vc_wallet.launch_new_vc(
-            did_id, action_scope, puzhash, parsed_request.fee, extra_conditions=extra_conditions
+            did_id, action_scope, puzhash, request.fee, extra_conditions=extra_conditions
         )
-        return {
-            "vc_record": vc_record.to_json_dict(),
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        return VCMintResponse([], [], vc_record)
 
-    async def vc_get(self, request: Dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def vc_get(self, request: VCGet) -> VCGetResponse:
         """
         Given a launcher ID get the verified credential
         :param request: the 'vc_id' launcher id of a verifiable credential
         :return: the 'vc_record' representing the specified verifiable credential
         """
+        vc_record = await self.service.wallet_state_manager.vc_store.get_vc_record(request.vc_id)
+        return VCGetResponse(vc_record)
 
-        @streamable
-        @dataclasses.dataclass(frozen=True)
-        class VCGet(Streamable):
-            vc_id: bytes32
-
-        parsed_request = VCGet.from_json_dict(request)
-
-        vc_record = await self.service.wallet_state_manager.vc_store.get_vc_record(parsed_request.vc_id)
-        return {"vc_record": vc_record}
-
-    async def vc_get_list(self, request: Dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def vc_get_list(self, request: VCGetList) -> VCGetListResponse:
         """
         Get a list of verified credentials
         :param request: optional parameters for pagination 'start' and 'count'
         :return: all 'vc_records' in the specified range and any 'proofs' associated with the roots contained within
         """
 
-        @streamable
-        @dataclasses.dataclass(frozen=True)
-        class VCGetList(Streamable):
-            start: uint32 = uint32(0)
-            end: uint32 = uint32(50)
-
-        parsed_request = VCGetList.from_json_dict(request)
-
-        vc_list = await self.service.wallet_state_manager.vc_store.get_vc_record_list(
-            parsed_request.start, parsed_request.end
-        )
-        return {
-            "vc_records": [{"coin_id": "0x" + vc.vc.coin.name().hex(), **vc.to_json_dict()} for vc in vc_list],
-            "proofs": {
-                rec.vc.proof_hash.hex(): None if fetched_proof is None else fetched_proof.key_value_pairs
+        vc_list = await self.service.wallet_state_manager.vc_store.get_vc_record_list(request.start, request.end)
+        return VCGetListResponse(
+            [VCRecordWithCoinID.from_vc_record(vc) for vc in vc_list],
+            [
+                VCProofWithHash(
+                    rec.vc.proof_hash, None if fetched_proof is None else VCProofsRPC.from_vc_proofs(fetched_proof)
+                )
                 for rec in vc_list
                 if rec.vc.proof_hash is not None
                 for fetched_proof in (
                     await self.service.wallet_state_manager.vc_store.get_proofs_for_root(rec.vc.proof_hash),
                 )
-            },
-        }
+            ],
+        )
 
     @tx_endpoint(push=True)
+    @marshal
     async def vc_spend(
         self,
-        request: Dict[str, Any],
+        request: VCSpend,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> VCSpendResponse:
         """
         Spend a verified credential
         :param request: Required 'vc_id' launcher id of the vc we wish to spend. Optional parameters for a 'new_puzhash'
@@ -4611,34 +4800,22 @@ class WalletRpcApi:
         :return: a list of all relevant 'transactions' (TransactionRecord) that this spend generates (VC TX + fee TX)
         """
 
-        @streamable
-        @dataclasses.dataclass(frozen=True)
-        class VCSpend(Streamable):
-            vc_id: bytes32
-            new_puzhash: Optional[bytes32] = None
-            new_proof_hash: Optional[bytes32] = None
-            provider_inner_puzhash: Optional[bytes32] = None
-            fee: uint64 = uint64(0)
-
-        parsed_request = VCSpend.from_json_dict(request)
-
         vc_wallet: VCWallet = await self.service.wallet_state_manager.get_or_create_vc_wallet()
 
         await vc_wallet.generate_signed_transaction(
-            parsed_request.vc_id,
+            request.vc_id,
             action_scope,
-            parsed_request.fee,
-            parsed_request.new_puzhash,
-            new_proof_hash=parsed_request.new_proof_hash,
-            provider_inner_puzhash=parsed_request.provider_inner_puzhash,
+            request.fee,
+            request.new_puzhash,
+            new_proof_hash=request.new_proof_hash,
+            provider_inner_puzhash=request.provider_inner_puzhash,
             extra_conditions=extra_conditions,
         )
 
-        return {
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        return VCSpendResponse([], [])  # tx_endpoint takes care of filling this out
 
-    async def vc_add_proofs(self, request: Dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def vc_add_proofs(self, request: VCAddProofs) -> Empty:
         """
         Add a set of proofs to the DB that can be used when spending a VC. VCs are near useless until their proofs have
         been added.
@@ -4647,70 +4824,57 @@ class WalletRpcApi:
         """
         vc_wallet: VCWallet = await self.service.wallet_state_manager.get_or_create_vc_wallet()
 
-        await vc_wallet.store.add_vc_proofs(VCProofs(request["proofs"]))
+        await vc_wallet.store.add_vc_proofs(request.to_vc_proofs())
 
-        return {}
+        return Empty()
 
-    async def vc_get_proofs_for_root(self, request: Dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def vc_get_proofs_for_root(self, request: VCGetProofsForRoot) -> VCGetProofsForRootResponse:
         """
         Given a specified vc root, get any proofs associated with that root.
         :param request: must specify 'root' representing the tree hash of some set of proofs
         :return: a dictionary of root hashes mapped to dictionaries of key value pairs of 'proofs'
         """
 
-        @streamable
-        @dataclasses.dataclass(frozen=True)
-        class VCGetProofsForRoot(Streamable):
-            root: bytes32
-
-        parsed_request = VCGetProofsForRoot.from_json_dict(request)
         vc_wallet: VCWallet = await self.service.wallet_state_manager.get_or_create_vc_wallet()
 
-        vc_proofs: Optional[VCProofs] = await vc_wallet.store.get_proofs_for_root(parsed_request.root)
+        vc_proofs: Optional[VCProofs] = await vc_wallet.store.get_proofs_for_root(request.root)
         if vc_proofs is None:
             raise ValueError("no proofs found for specified root")  # pragma: no cover
-        return {"proofs": vc_proofs.key_value_pairs}
+        return VCGetProofsForRootResponse.from_vc_proofs(vc_proofs)
 
     @tx_endpoint(push=True)
+    @marshal
     async def vc_revoke(
         self,
-        request: Dict[str, Any],
+        request: VCRevoke,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> VCRevokeResponse:
         """
         Revoke an on chain VC provided the correct DID is available
         :param request: required 'vc_parent_id' for the VC coin. Standard transaction params 'fee' & 'reuse_puzhash'.
         :return: a list of all relevant 'transactions' (TransactionRecord) that this spend generates (VC TX + fee TX)
         """
 
-        @streamable
-        @dataclasses.dataclass(frozen=True)
-        class VCRevoke(Streamable):
-            vc_parent_id: bytes32
-            fee: uint64 = uint64(0)
-
-        parsed_request = VCRevoke.from_json_dict(request)
         vc_wallet: VCWallet = await self.service.wallet_state_manager.get_or_create_vc_wallet()
 
         await vc_wallet.revoke_vc(
-            parsed_request.vc_parent_id,
+            request.vc_parent_id,
             self.service.get_full_node_peer(),
             action_scope,
-            parsed_request.fee,
+            request.fee,
             extra_conditions=extra_conditions,
         )
 
-        return {
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        return VCRevokeResponse([], [])  # tx_endpoint takes care of filling this out
 
     @tx_endpoint(push=True)
     async def crcat_approve_pending(
         self,
-        request: Dict[str, Any],
+        request: dict[str, Any],
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> EndpointResult:
         """
         Moving any "pending approval" CR-CATs into the spendable balance of the wallet