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

chia/{rpc → wallet}/wallet_rpc_api.py

@@ -6,80 +6,24 @@ import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Union, cast
 
-from chia_rs import AugSchemeMPL, Coin, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, Coin, CoinSpend, CoinState, G1Element, G2Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 from clvm_tools.binutils import assemble
 
 from chia.consensus.block_rewards import calculate_base_farmer_reward
 from chia.data_layer.data_layer_errors import LauncherCoinNotFoundError
-from chia.data_layer.data_layer_util import dl_verify_proof
-from chia.data_layer.data_layer_wallet import DataLayerWallet
+from chia.data_layer.data_layer_util import DLProof, VerifyProofResponse, dl_verify_proof
+from chia.data_layer.data_layer_wallet import DataLayerWallet, Mirror
 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.protocols.outbound_message import NodeType
 from chia.rpc.rpc_server import Endpoint, EndpointResult, default_get_connections
 from chia.rpc.util import ALL_TRANSLATION_LAYERS, RpcEndpoint, marshal
-from chia.rpc.wallet_request_types import (
-    AddKey,
-    AddKeyResponse,
-    ApplySignatures,
-    ApplySignaturesResponse,
-    CheckDeleteKey,
-    CheckDeleteKeyResponse,
-    CombineCoins,
-    CombineCoinsResponse,
-    DeleteKey,
-    Empty,
-    ExecuteSigningInstructions,
-    ExecuteSigningInstructionsResponse,
-    GatherSigningInfo,
-    GatherSigningInfoResponse,
-    GenerateMnemonicResponse,
-    GetHeightInfoResponse,
-    GetLoggedInFingerprintResponse,
-    GetNotifications,
-    GetNotificationsResponse,
-    GetPrivateKey,
-    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_as_list
-from chia.types.blockchain_format.program import INFINITE_COST, Program
+from chia.types.blockchain_format.program import INFINITE_COST, Program, run_with_cost
 from chia.types.coin_record import CoinRecord
-from chia.types.coin_spend import CoinSpend
 from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
 from chia.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
 from chia.util.byte_types import hexstr_to_bytes
@@ -109,11 +53,10 @@ from chia.wallet.derive_keys import (
     MAX_POOL_WALLETS,
     master_sk_to_farmer_sk,
     master_sk_to_pool_sk,
-    master_sk_to_singleton_owner_sk,
     match_address_to_sk,
 )
 from chia.wallet.did_wallet import did_wallet_puzzles
-from chia.wallet.did_wallet.did_info import DIDCoinData, DIDInfo
+from chia.wallet.did_wallet.did_info import DIDCoinData, DIDInfo, did_recovery_is_nil
 from chia.wallet.did_wallet.did_wallet import DIDWallet
 from chia.wallet.did_wallet.did_wallet_puzzles import (
     DID_INNERPUZ_MOD,
@@ -163,6 +106,148 @@ from chia.wallet.wallet_coin_store import CoinRecordOrder, GetCoinRecords, unspe
 from chia.wallet.wallet_info import WalletInfo
 from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_protocol import WalletProtocol
+from chia.wallet.wallet_request_types import (
+    AddKey,
+    AddKeyResponse,
+    ApplySignatures,
+    ApplySignaturesResponse,
+    CheckDeleteKey,
+    CheckDeleteKeyResponse,
+    CombineCoins,
+    CombineCoinsResponse,
+    CreateNewDL,
+    CreateNewDLResponse,
+    DeleteKey,
+    DIDCreateBackupFile,
+    DIDCreateBackupFileResponse,
+    DIDFindLostDID,
+    DIDFindLostDIDResponse,
+    DIDGetCurrentCoinInfo,
+    DIDGetCurrentCoinInfoResponse,
+    DIDGetDID,
+    DIDGetDIDResponse,
+    DIDGetInfo,
+    DIDGetInfoResponse,
+    DIDGetMetadata,
+    DIDGetMetadataResponse,
+    DIDGetPubkey,
+    DIDGetPubkeyResponse,
+    DIDGetRecoveryInfo,
+    DIDGetRecoveryInfoResponse,
+    DIDGetRecoveryList,
+    DIDGetRecoveryListResponse,
+    DIDGetWalletName,
+    DIDGetWalletNameResponse,
+    DIDMessageSpend,
+    DIDMessageSpendResponse,
+    DIDSetWalletName,
+    DIDSetWalletNameResponse,
+    DIDTransferDID,
+    DIDTransferDIDResponse,
+    DIDUpdateMetadata,
+    DIDUpdateMetadataResponse,
+    DIDUpdateRecoveryIDs,
+    DIDUpdateRecoveryIDsResponse,
+    DLDeleteMirror,
+    DLDeleteMirrorResponse,
+    DLGetMirrors,
+    DLGetMirrorsResponse,
+    DLHistory,
+    DLHistoryResponse,
+    DLLatestSingleton,
+    DLLatestSingletonResponse,
+    DLNewMirror,
+    DLNewMirrorResponse,
+    DLOwnedSingletonsResponse,
+    DLSingletonsByRoot,
+    DLSingletonsByRootResponse,
+    DLStopTracking,
+    DLTrackNew,
+    DLUpdateMultiple,
+    DLUpdateMultipleResponse,
+    DLUpdateRoot,
+    DLUpdateRootResponse,
+    Empty,
+    ExecuteSigningInstructions,
+    ExecuteSigningInstructionsResponse,
+    GatherSigningInfo,
+    GatherSigningInfoResponse,
+    GenerateMnemonicResponse,
+    GetHeightInfoResponse,
+    GetLoggedInFingerprintResponse,
+    GetNotifications,
+    GetNotificationsResponse,
+    GetPrivateKey,
+    GetPrivateKeyFormat,
+    GetPrivateKeyResponse,
+    GetPublicKeysResponse,
+    GetSyncStatusResponse,
+    GetTimestampForHeight,
+    GetTimestampForHeightResponse,
+    LogIn,
+    LogInResponse,
+    NFTAddURI,
+    NFTAddURIResponse,
+    NFTCalculateRoyalties,
+    NFTCalculateRoyaltiesResponse,
+    NFTCountNFTs,
+    NFTCountNFTsResponse,
+    NFTGetByDID,
+    NFTGetByDIDResponse,
+    NFTGetInfo,
+    NFTGetInfoResponse,
+    NFTGetNFTs,
+    NFTGetNFTsResponse,
+    NFTGetWalletDID,
+    NFTGetWalletDIDResponse,
+    NFTGetWalletsWithDIDsResponse,
+    NFTMintBulk,
+    NFTMintBulkResponse,
+    NFTMintNFTRequest,
+    NFTMintNFTResponse,
+    NFTSetDIDBulk,
+    NFTSetDIDBulkResponse,
+    NFTSetNFTDID,
+    NFTSetNFTDIDResponse,
+    NFTSetNFTStatus,
+    NFTTransferBulk,
+    NFTTransferBulkResponse,
+    NFTTransferNFT,
+    NFTTransferNFTResponse,
+    NFTWalletWithDID,
+    PushTransactions,
+    PushTransactionsResponse,
+    PushTX,
+    PWAbsorbRewards,
+    PWAbsorbRewardsResponse,
+    PWJoinPool,
+    PWJoinPoolResponse,
+    PWSelfPool,
+    PWSelfPoolResponse,
+    PWStatus,
+    PWStatusResponse,
+    SetWalletResyncOnStartup,
+    SplitCoins,
+    SplitCoinsResponse,
+    SubmitTransactions,
+    SubmitTransactionsResponse,
+    VCAddProofs,
+    VCGet,
+    VCGetList,
+    VCGetListResponse,
+    VCGetProofsForRoot,
+    VCGetProofsForRootResponse,
+    VCGetResponse,
+    VCMint,
+    VCMintResponse,
+    VCProofsRPC,
+    VCProofWithHash,
+    VCRecordWithCoinID,
+    VCRevoke,
+    VCRevokeResponse,
+    VCSpend,
+    VCSpendResponse,
+)
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 # Timeout for response from wallet/full node for sending a transaction
@@ -361,6 +446,27 @@ def tx_endpoint(
     return _inner
 
 
+REPLACEABLE_TRANSACTION_RECORD = TransactionRecord(
+    confirmed_at_height=uint32(0),
+    created_at_time=uint64(0),
+    to_puzzle_hash=bytes32.zeros,
+    amount=uint64(0),
+    fee_amount=uint64(0),
+    confirmed=False,
+    sent=uint32(0),
+    spend_bundle=WalletSpendBundle([], G2Element()),
+    additions=[],
+    removals=[],
+    wallet_id=uint32(0),
+    sent_to=[],
+    trade_id=None,
+    type=uint32(0),
+    name=bytes32.zeros,
+    memos=[],
+    valid_times=ConditionValidTimes(),
+)
+
+
 class WalletRpcApi:
     if TYPE_CHECKING:
         from chia.rpc.rpc_server import RpcApiProtocol
@@ -843,7 +949,7 @@ class WalletRpcApi:
                     for tx in interface.side_effects.transactions
                     if tx.spend_bundle is not None
                     for cs in tx.spend_bundle.coin_spends
-                    for condition in cs.puzzle_reveal.run_with_cost(INFINITE_COST, cs.solution)[1].as_iter()
+                    for condition in run_with_cost(cs.puzzle_reveal, INFINITE_COST, cs.solution)[1].as_iter()
                 ]
                 create_coin_announcement = next(
                     condition
@@ -870,7 +976,7 @@ class WalletRpcApi:
                     await self.service.wallet_state_manager.main_wallet.create_tandem_xch_tx(
                         request.fee,
                         inner_action_scope,
-                        (
+                        extra_conditions=(
                             *extra_conditions,
                             CreateCoinAnnouncement(
                                 create_coin_announcement.msg, announcement_origin
@@ -1106,9 +1212,7 @@ 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(
-                    new=not action_scope.config.tx_config.reuse_puzhash
-                )
+                owner_puzzle_hash: bytes32 = await action_scope.get_puzzle_hash(self.service.wallet_state_manager)
 
                 from chia.pools.pool_wallet_info import initial_pool_state_from_dict
 
@@ -1121,17 +1225,15 @@ class WalletRpcApi:
                     max_pwi = 1
                     for _, wallet in self.service.wallet_state_manager.wallets.items():
                         if wallet.type() == WalletType.POOLING_WALLET:
-                            assert isinstance(wallet, PoolWallet)
-                            pool_wallet_index = await wallet.get_pool_wallet_index()
-                            max_pwi = max(max_pwi, pool_wallet_index)
+                            max_pwi += 1
 
                     if max_pwi + 1 >= (MAX_POOL_WALLETS - 1):
                         raise ValueError(f"Too many pool wallets ({max_pwi}), cannot create any more on this key.")
 
-                    owner_sk: PrivateKey = master_sk_to_singleton_owner_sk(
-                        self.service.wallet_state_manager.get_master_private_key(), uint32(max_pwi + 1)
+                    owner_pk: G1Element = self.service.wallet_state_manager.main_wallet.hardened_pubkey_for_path(
+                        # copied from chia.wallet.derive_keys. Could maybe be an exported constant in the future.
+                        [12381, 8444, 5, max_pwi]
                     )
-                    owner_pk: G1Element = owner_sk.get_g1()
 
                     initial_target_state = initial_pool_state_from_dict(
                         request["initial_target_state"], owner_pk, owner_puzzle_hash
@@ -1184,7 +1286,7 @@ class WalletRpcApi:
         wallet_balance["wallet_type"] = wallet.type()
         if self.service.logged_in_fingerprint is not None:
             wallet_balance["fingerprint"] = self.service.logged_in_fingerprint
-        if wallet.type() in {WalletType.CAT, WalletType.CRCAT}:
+        if wallet.type() in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
             assert isinstance(wallet, CATWallet)
             wallet_balance["asset_id"] = wallet.get_asset_id()
             if wallet.type() == WalletType.CRCAT:
@@ -1274,9 +1376,9 @@ class WalletRpcApi:
 
         outputs = [
             CreateCoin(
-                await wallet.get_puzzle_hash(new=True)
-                if isinstance(wallet, Wallet)
-                else await wallet.standard_wallet.get_puzzle_hash(new=True),
+                await action_scope.get_puzzle_hash(
+                    self.service.wallet_state_manager, override_reuse_puzhash_with=False
+                ),
                 request.amount_per_coin,
             )
             for _ in range(request.number_of_coins)
@@ -1388,13 +1490,10 @@ class WalletRpcApi:
         )
         if isinstance(wallet, Wallet):
             primary_output_amount = uint64(primary_output_amount - request.fee)
-            main_wallet = wallet
-        else:
-            main_wallet = wallet.standard_wallet
 
         await wallet.generate_signed_transaction(
             [primary_output_amount],
-            [await main_wallet.get_puzzle_hash(new=not action_scope.config.tx_config.reuse_puzhash)],
+            [await action_scope.get_puzzle_hash(self.service.wallet_state_manager)],
             action_scope,
             request.fee,
             coins=set(coins),
@@ -1480,13 +1579,13 @@ class WalletRpcApi:
         wallet = self.service.wallet_state_manager.wallets[wallet_id]
         selected = self.service.config["selected_network"]
         prefix = self.service.config["network_overrides"]["config"][selected]["address_prefix"]
-        if wallet.type() == WalletType.STANDARD_WALLET:
-            assert isinstance(wallet, Wallet)
-            raw_puzzle_hash = await wallet.get_puzzle_hash(create_new)
-            address = encode_puzzle_hash(raw_puzzle_hash, prefix)
-        elif wallet.type() in {WalletType.CAT, WalletType.CRCAT}:
-            assert isinstance(wallet, CATWallet)
-            raw_puzzle_hash = await wallet.standard_wallet.get_puzzle_hash(create_new)
+        if wallet.type() in {WalletType.STANDARD_WALLET, WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
+            async with self.service.wallet_state_manager.new_action_scope(
+                DEFAULT_TX_CONFIG, push=request.get("save_derivations", True)
+            ) as action_scope:
+                raw_puzzle_hash = await action_scope.get_puzzle_hash(
+                    self.service.wallet_state_manager, override_reuse_puzhash_with=not create_new
+                )
             address = encode_puzzle_hash(raw_puzzle_hash, prefix)
         else:
             raise ValueError(f"Wallet type {wallet.type()} cannot create puzzle hashes")
@@ -1555,7 +1654,7 @@ class WalletRpcApi:
         wallet = self.service.wallet_state_manager.wallets[wallet_id]
 
         async with self.service.wallet_state_manager.lock:
-            if wallet.type() in {WalletType.CAT, WalletType.CRCAT}:
+            if wallet.type() in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
                 assert isinstance(wallet, CATWallet)
                 response = await self.cat_spend(request, hold_lock=False)
                 transaction = response["transaction"]
@@ -1708,7 +1807,7 @@ class WalletRpcApi:
         wallet = state_mgr.wallets[wallet_id]
         async with state_mgr.lock:
             all_coin_records = await state_mgr.coin_store.get_unspent_coins_for_wallet(wallet_id)
-            if wallet.type() in {WalletType.CAT, WalletType.CRCAT}:
+            if wallet.type() in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
                 assert isinstance(wallet, CATWallet)
                 spendable_coins: list[WalletCoinRecord] = await wallet.get_cat_spendable_coins(all_coin_records)
             else:
@@ -1828,9 +1927,10 @@ class WalletRpcApi:
         # Since we've bumping the derivation index without having found any new puzzles, we want
         # to preserve the current last used index, so we call create_more_puzzle_hashes with
         # mark_existing_as_used=False
-        await self.service.wallet_state_manager.create_more_puzzle_hashes(
+        result = await self.service.wallet_state_manager.create_more_puzzle_hashes(
             from_zero=False, mark_existing_as_used=False, up_to_index=index, num_additional_phs=0
         )
+        await result.commit(self.service.wallet_state_manager)
 
         updated: Optional[uint32] = await self.service.wallet_state_manager.puzzle_store.get_last_derivation_path()
         updated_index = updated if updated is not None else None
@@ -2476,88 +2576,79 @@ class WalletRpcApi:
     # Distributed Identities
     ##########################################################################################
 
-    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}
+    @marshal
+    async def did_set_wallet_name(self, request: DIDSetWalletName) -> DIDSetWalletNameResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
+        await wallet.set_name(request.name)
+        return DIDSetWalletNameResponse(request.wallet_id)
 
-    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`
-        return {"success": True, "wallet_id": wallet_id, "name": name}
+    @marshal
+    async def did_get_wallet_name(self, request: DIDGetWalletName) -> DIDGetWalletNameResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
+        return DIDGetWalletNameResponse(request.wallet_id, wallet.get_name())
 
     @tx_endpoint(push=True)
+    @marshal
     async def did_update_recovery_ids(
         self,
-        request: dict[str, Any],
+        request: DIDUpdateRecoveryIDs,
         action_scope: WalletActionScope,
         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)
-        recovery_list = []
-        for _ in request["new_list"]:
-            recovery_list.append(decode_puzzle_hash(_))
-        if "num_verifications_required" in request:
-            new_amount_verifications_required = uint64(request["num_verifications_required"])
-        else:
-            new_amount_verifications_required = uint64(len(recovery_list))
+    ) -> DIDUpdateRecoveryIDsResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
+        recovery_list = [decode_puzzle_hash(puzzle_hash) for puzzle_hash in request.new_list]
+        new_amount_verifications_required = (
+            request.num_verifications_required
+            if request.num_verifications_required is not None
+            else uint64(len(recovery_list))
+        )
         async with self.service.wallet_state_manager.lock:
             update_success = await wallet.update_recovery_list(recovery_list, new_amount_verifications_required)
             # Update coin with new ID info
             if update_success:
-                await wallet.create_update_spend(
-                    action_scope, fee=uint64(request.get("fee", 0)), extra_conditions=extra_conditions
-                )
-                return {
-                    "success": True,
-                    "transactions": None,  # tx_endpoint wrapper will take care of this
-                }
+                await wallet.create_update_spend(action_scope, fee=request.fee, extra_conditions=extra_conditions)
+                # tx_endpoint will take care of default values here
+                return DIDUpdateRecoveryIDsResponse([], [])
             else:
-                return {"success": False, "transactions": []}  # pragma: no cover
+                raise RuntimeError("updating recovery list failed")
 
     @tx_endpoint(push=False)
+    @marshal
     async def did_message_spend(
         self,
-        request: dict[str, Any],
+        request: DIDMessageSpend,
         action_scope: WalletActionScope,
         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)
+    ) -> DIDMessageSpendResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
 
         await wallet.create_message_spend(
             action_scope,
             extra_conditions=(
                 *extra_conditions,
-                *(CreateCoinAnnouncement(hexstr_to_bytes(ca)) for ca in request.get("coin_announcements", [])),
-                *(CreatePuzzleAnnouncement(hexstr_to_bytes(pa)) for pa in request.get("puzzle_announcements", [])),
+                *(CreateCoinAnnouncement(ca) for ca in request.coin_announcements),
+                *(CreatePuzzleAnnouncement(pa) for pa in request.puzzle_announcements),
             ),
         )
-        return {
-            "success": True,
-            "spend_bundle": None,  # tx_endpoint wrapper will take care of this
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
 
-    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"]
-        if coin_id.startswith(AddressType.DID.hrp(self.service.config)):
-            coin_id = decode_puzzle_hash(coin_id)
+        # tx_endpoint will take care of the default values here
+        return DIDMessageSpendResponse([], [], WalletSpendBundle([], G2Element()))
+
+    @marshal
+    async def did_get_info(self, request: DIDGetInfo) -> DIDGetInfoResponse:
+        if request.coin_id.startswith(AddressType.DID.hrp(self.service.config)):
+            coin_id = decode_puzzle_hash(request.coin_id)
         else:
-            coin_id = bytes32.from_hexstr(coin_id)
+            coin_id = bytes32.from_hexstr(request.coin_id)
         # Get coin state
         peer = self.service.get_full_node_peer()
-        coin_spend, coin_state = await self.get_latest_singleton_coin_spend(peer, coin_id, request.get("latest", True))
+        coin_spend, coin_state = await self.get_latest_singleton_coin_spend(peer, coin_id, request.latest)
         uncurried = uncurry_puzzle(coin_spend.puzzle_reveal)
         curried_args = match_did_puzzle(uncurried.mod, uncurried.args)
         if curried_args is None:
-            return {"success": False, "error": "The coin is not a DID."}
+            raise ValueError("The coin is not a DID.")
         p2_puzzle, recovery_list_hash, num_verification, singleton_struct, metadata = curried_args
+        recovery_list_hash_bytes = recovery_list_hash.as_atom()
         launcher_id = bytes32(singleton_struct.rest().first().as_atom())
         uncurried_p2 = uncurry_puzzle(p2_puzzle)
         (public_key,) = uncurried_p2.args.as_iter()
@@ -2566,49 +2657,48 @@ class WalletRpcApi:
         coin_memos = memos.get(coin_state.coin.name())
         if coin_memos is not None:
             for memo in coin_memos:
-                hints.append(memo.hex())
-        return {
-            "success": True,
-            "did_id": encode_puzzle_hash(launcher_id, AddressType.DID.hrp(self.service.config)),
-            "latest_coin": coin_state.coin.name().hex(),
-            "p2_address": encode_puzzle_hash(p2_puzzle.get_tree_hash(), AddressType.XCH.hrp(self.service.config)),
-            "public_key": public_key.as_atom().hex(),
-            "recovery_list_hash": recovery_list_hash.as_atom().hex(),
-            "num_verification": num_verification.as_int(),
-            "metadata": did_program_to_metadata(metadata),
-            "launcher_id": launcher_id.hex(),
-            "full_puzzle": coin_spend.puzzle_reveal,
-            "solution": coin_spend.solution.to_program().as_python(),
-            "hints": hints,
-        }
+                hints.append(memo)
+        return DIDGetInfoResponse(
+            did_id=encode_puzzle_hash(launcher_id, AddressType.DID.hrp(self.service.config)),
+            latest_coin=coin_state.coin.name(),
+            p2_address=encode_puzzle_hash(p2_puzzle.get_tree_hash(), AddressType.XCH.hrp(self.service.config)),
+            public_key=public_key.as_atom(),
+            recovery_list_hash=bytes32(recovery_list_hash_bytes) if recovery_list_hash_bytes != b"" else None,
+            num_verification=uint16(num_verification.as_int()),
+            metadata=did_program_to_metadata(metadata),
+            launcher_id=launcher_id,
+            full_puzzle=Program.from_serialized(coin_spend.puzzle_reveal),
+            solution=Program.from_serialized(coin_spend.solution),
+            hints=hints,
+        )
 
-    async def did_find_lost_did(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def did_find_lost_did(self, request: DIDFindLostDID) -> DIDFindLostDIDResponse:
         """
         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.
         The latest coin ID will take less time.
         :return:
         """
-        if "coin_id" not in request:
-            return {"success": False, "error": "DID coin ID is required."}
-        coin_id = request["coin_id"]
         # Check if we have a DID wallet for this
-        if coin_id.startswith(AddressType.DID.hrp(self.service.config)):
-            coin_id = decode_puzzle_hash(coin_id)
+        if request.coin_id.startswith(AddressType.DID.hrp(self.service.config)):
+            coin_id = decode_puzzle_hash(request.coin_id)
         else:
-            coin_id = bytes32.from_hexstr(coin_id)
+            coin_id = bytes32.from_hexstr(request.coin_id)
         # Get coin state
         peer = self.service.get_full_node_peer()
         coin_spend, coin_state = await self.get_latest_singleton_coin_spend(peer, coin_id)
         uncurried = uncurry_puzzle(coin_spend.puzzle_reveal)
         curried_args = match_did_puzzle(uncurried.mod, uncurried.args)
         if curried_args is None:
-            return {"success": False, "error": "The coin is not a DID."}
+            raise ValueError("The coin is not a DID.")
         p2_puzzle, recovery_list_hash, num_verification, singleton_struct, metadata = curried_args
+        num_verification_int: Optional[uint16] = uint16(num_verification.as_int())
+        assert num_verification_int is not None
         did_data: DIDCoinData = DIDCoinData(
             p2_puzzle,
-            bytes32(recovery_list_hash.as_atom()),
-            uint16(num_verification.as_int()),
+            bytes32(recovery_list_hash.as_atom()) if recovery_list_hash != Program.to(None) else None,
+            num_verification_int,
             singleton_struct,
             metadata,
             get_inner_puzzle_from_singleton(coin_spend.puzzle_reveal),
@@ -2636,7 +2726,7 @@ class WalletRpcApi:
 
         launcher_id = bytes32(singleton_struct.rest().first().as_atom())
         if derivation_record is None:
-            return {"success": False, "error": f"This DID {launcher_id} does not belong to the connected wallet"}
+            raise ValueError(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
@@ -2672,11 +2762,12 @@ class WalletRpcApi:
                     did_puzzle = did_wallet.did_info.current_inner
                 else:
                     # Try override
-                    if "recovery_list_hash" in request:
-                        recovery_list_hash = Program.from_bytes(bytes.fromhex(request["recovery_list_hash"]))
-                    num_verification = request.get("num_verification", num_verification)
-                    if "metadata" in request:
-                        metadata = metadata_to_program(request["metadata"])
+                    if request.recovery_list_hash is not None:
+                        recovery_list_hash = Program.from_bytes(request.recovery_list_hash)
+                    if request.num_verification is not None:
+                        num_verification_int = request.num_verification
+                    if request.metadata is not None:
+                        metadata = metadata_to_program(request.metadata)
                     did_puzzle = DID_INNERPUZ_MOD.curry(
                         our_inner_puzzle, recovery_list_hash, num_verification, singleton_struct, metadata
                     )
@@ -2708,17 +2799,16 @@ class WalletRpcApi:
                             )
 
                     if not matched:
-                        return {
-                            "success": False,
-                            "error": f"Cannot recover DID {launcher_id}"
-                            f" because the last spend updated recovery_list_hash/num_verification/metadata.",
-                        }
+                        raise RuntimeError(
+                            f"Cannot recover DID {launcher_id} "
+                            f"because the last spend updated recovery_list_hash/num_verification/metadata."
+                        )
 
             if did_wallet is None:
                 # Create DID wallet
                 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}"}
+                    raise ValueError(f"Could not find the launch coin with ID: {launcher_id}")
                 launcher_coin: CoinState = response[0]
                 did_wallet = await DIDWallet.create_new_did_wallet_from_coin_spend(
                     self.service.wallet_state_manager,
@@ -2736,7 +2826,7 @@ class WalletRpcApi:
                     inner_solution: Program = full_solution.rest().rest().first()
                     recovery_list: list[bytes32] = []
                     backup_required: int = num_verification.as_int()
-                    if recovery_list_hash != NIL_TREEHASH:
+                    if not did_recovery_is_nil(recovery_list_hash):
                         try:
                             for did in inner_solution.rest().rest().rest().rest().rest().as_python():
                                 recovery_list.append(did[0])
@@ -2761,7 +2851,7 @@ class WalletRpcApi:
             try:
                 coin = await did_wallet.get_coin()
                 if coin.name() == coin_state.coin.name():
-                    return {"success": True, "latest_coin_id": coin.name().hex()}
+                    return DIDFindLostDIDResponse(coin.name())
             except RuntimeError:
                 # We don't have any coin for this wallet, add the coin
                 pass
@@ -2779,70 +2869,61 @@ class WalletRpcApi:
                 peer,
                 did_data,
             )
-            return {"success": True, "latest_coin_id": coin_state.coin.name().hex()}
+            return DIDFindLostDIDResponse(coin_state.coin.name())
 
     @tx_endpoint(push=True)
+    @marshal
     async def did_update_metadata(
         self,
-        request: dict[str, Any],
+        request: DIDUpdateMetadata,
         action_scope: WalletActionScope,
         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] = {}
-        if "metadata" in request and type(request["metadata"]) is dict:
-            metadata = request["metadata"]
+    ) -> DIDUpdateMetadataResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
         async with self.service.wallet_state_manager.lock:
-            update_success = await wallet.update_metadata(metadata)
+            update_success = await wallet.update_metadata(request.metadata)
             # Update coin with new ID info
             if update_success:
-                await wallet.create_update_spend(
-                    action_scope, uint64(request.get("fee", 0)), extra_conditions=extra_conditions
+                await wallet.create_update_spend(action_scope, request.fee, extra_conditions=extra_conditions)
+                # tx_endpoint wrapper will take care of these default values
+                return DIDUpdateMetadataResponse(
+                    [],
+                    [],
+                    wallet_id=request.wallet_id,
+                    spend_bundle=WalletSpendBundle([], G2Element()),
                 )
-                return {
-                    "wallet_id": wallet_id,
-                    "success": True,
-                    "spend_bundle": None,  # tx_endpoint wrapper will take care of this
-                    "transactions": None,  # tx_endpoint wrapper will take care of this
-                }
             else:
-                return {"success": False, "error": f"Couldn't update metadata with input: {metadata}"}
+                raise ValueError(f"Couldn't update metadata with input: {request.metadata}")
 
-    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)
+    @marshal
+    async def did_get_did(self, request: DIDGetDID) -> DIDGetDIDResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
         my_did: str = encode_puzzle_hash(bytes32.fromhex(wallet.get_my_DID()), AddressType.DID.hrp(self.service.config))
         async with self.service.wallet_state_manager.lock:
             try:
                 coin = await wallet.get_coin()
-                return {"success": True, "wallet_id": wallet_id, "my_did": my_did, "coin_id": coin.name()}
+                return DIDGetDIDResponse(wallet_id=request.wallet_id, my_did=my_did, coin_id=coin.name())
             except RuntimeError:
-                return {"success": True, "wallet_id": wallet_id, "my_did": my_did}
+                return DIDGetDIDResponse(wallet_id=request.wallet_id, my_did=my_did)
 
-    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)
+    @marshal
+    async def did_get_recovery_list(self, request: DIDGetRecoveryList) -> DIDGetRecoveryListResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
         recovery_list = wallet.did_info.backup_ids
         recovery_dids = []
         for backup_id in recovery_list:
             recovery_dids.append(encode_puzzle_hash(backup_id, AddressType.DID.hrp(self.service.config)))
-        return {
-            "success": True,
-            "wallet_id": wallet_id,
-            "recovery_list": recovery_dids,
-            "num_required": wallet.did_info.num_of_backup_ids_needed,
-        }
+        return DIDGetRecoveryListResponse(
+            wallet_id=request.wallet_id,
+            recovery_list=recovery_dids,
+            num_required=uint16(wallet.did_info.num_of_backup_ids_needed),
+        )
 
-    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)
+    @marshal
+    async def did_get_metadata(self, request: DIDGetMetadata) -> DIDGetMetadataResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
         metadata = json.loads(wallet.did_info.metadata)
-        return {
-            "success": True,
-            "wallet_id": wallet_id,
-            "metadata": metadata,
-        }
+        return DIDGetMetadataResponse(wallet_id=request.wallet_id, metadata=metadata)
 
     # TODO: this needs a test
     # Don't need full @tx_endpoint decorator here, but "push" is still a valid option
@@ -2888,11 +2969,12 @@ class WalletRpcApi:
             "transactions": [tx.to_json_dict_convenience(self.service.config)],
         }
 
-    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()
-        return {"success": True, "pubkey": pubkey}
+    @marshal
+    async def did_get_pubkey(self, request: DIDGetPubkey) -> DIDGetPubkeyResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
+        return DIDGetPubkeyResponse(
+            (await wallet.wallet_state_manager.get_unused_derivation_record(request.wallet_id)).pubkey
+        )
 
     # TODO: this needs a test
     @tx_endpoint(push=True)
@@ -2926,27 +3008,28 @@ class WalletRpcApi:
         else:
             return {"success": False}
 
-    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)
+    @marshal
+    async def did_get_information_needed_for_recovery(self, request: DIDGetRecoveryInfo) -> DIDGetRecoveryInfoResponse:
+        did_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
         my_did = encode_puzzle_hash(
             bytes32.from_hexstr(did_wallet.get_my_DID()), AddressType.DID.hrp(self.service.config)
         )
         assert did_wallet.did_info.temp_coin is not None
-        coin_name = did_wallet.did_info.temp_coin.name().hex()
-        return {
-            "success": True,
-            "wallet_id": wallet_id,
-            "my_did": my_did,
-            "coin_name": coin_name,
-            "newpuzhash": did_wallet.did_info.temp_puzhash,
-            "pubkey": did_wallet.did_info.temp_pubkey,
-            "backup_dids": did_wallet.did_info.backup_ids,
-        }
+        coin_name = did_wallet.did_info.temp_coin.name()
+        return DIDGetRecoveryInfoResponse(
+            wallet_id=request.wallet_id,
+            my_did=my_did,
+            coin_name=coin_name,
+            newpuzhash=did_wallet.did_info.temp_puzhash,
+            pubkey=G1Element.from_bytes(did_wallet.did_info.temp_pubkey)
+            if did_wallet.did_info.temp_pubkey is not None
+            else None,
+            backup_dids=did_wallet.did_info.backup_ids,
+        )
 
-    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)
+    @marshal
+    async def did_get_current_coin_info(self, request: DIDGetCurrentCoinInfo) -> DIDGetCurrentCoinInfoResponse:
+        did_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
         my_did = encode_puzzle_hash(
             bytes32.from_hexstr(did_wallet.get_my_DID()), AddressType.DID.hrp(self.service.config)
         )
@@ -2954,210 +3037,177 @@ class WalletRpcApi:
         did_coin_threeple = await did_wallet.get_info_for_recovery()
         assert my_did is not None
         assert did_coin_threeple is not None
-        return {
-            "success": True,
-            "wallet_id": wallet_id,
-            "my_did": my_did,
-            "did_parent": did_coin_threeple[0],
-            "did_innerpuz": did_coin_threeple[1],
-            "did_amount": did_coin_threeple[2],
-        }
+        return DIDGetCurrentCoinInfoResponse(
+            wallet_id=request.wallet_id,
+            my_did=my_did,
+            did_parent=did_coin_threeple[0],
+            did_innerpuz=did_coin_threeple[1],
+            did_amount=did_coin_threeple[2],
+        )
 
-    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()}
+    @marshal
+    async def did_create_backup_file(self, request: DIDCreateBackupFile) -> DIDCreateBackupFileResponse:
+        did_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
+        return DIDCreateBackupFileResponse(wallet_id=request.wallet_id, backup_data=did_wallet.create_backup())
 
     @tx_endpoint(push=True)
+    @marshal
     async def did_transfer_did(
         self,
-        request: dict[str, Any],
+        request: DIDTransferDID,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> DIDTransferDIDResponse:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced.")
-        wallet_id = uint32(request["wallet_id"])
-        did_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
-        puzzle_hash: bytes32 = decode_puzzle_hash(request["inner_address"])
+        did_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
+        puzzle_hash: bytes32 = decode_puzzle_hash(request.inner_address)
         async with self.service.wallet_state_manager.lock:
             await did_wallet.transfer_did(
                 puzzle_hash,
-                uint64(request.get("fee", 0)),
-                request.get("with_recovery_info", True),
+                request.fee,
+                request.with_recovery_info,
                 action_scope,
                 extra_conditions=extra_conditions,
             )
 
-        return {
-            "success": True,
-            "transaction": None,  # tx_endpoint wrapper will take care of this
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-            "transaction_id": None,  # tx_endpoint wrapper will take care of this
-        }
+        # The tx_endpoint wrapper will take care of these default values
+        return DIDTransferDIDResponse([], [], transaction=REPLACEABLE_TRANSACTION_RECORD, transaction_id=bytes32.zeros)
 
     ##########################################################################################
     # NFT Wallet
     ##########################################################################################
     @tx_endpoint(push=True)
+    @marshal
     async def nft_mint_nft(
         self,
-        request: dict[str, Any],
+        request: NFTMintNFTRequest,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> NFTMintNFTResponse:
         log.debug("Got minting RPC request: %s", request)
-        wallet_id = uint32(request["wallet_id"])
         assert self.service.wallet_state_manager
-        nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
-        royalty_address = request.get("royalty_address")
-        royalty_amount = uint16(request.get("royalty_percentage", 0))
-        if royalty_amount == 10000:
+        nft_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=NFTWallet)
+        if request.royalty_amount == 10000:
             raise ValueError("Royalty percentage cannot be 100%")
-        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_puzzle_hash(
-                new=not action_scope.config.tx_config.reuse_puzhash
-            )
+        if request.royalty_address is not None:
+            royalty_puzhash = decode_puzzle_hash(request.royalty_address)
         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_puzzle_hash(
-                new=not action_scope.config.tx_config.reuse_puzhash
-            )
+            royalty_puzhash = await action_scope.get_puzzle_hash(self.service.wallet_state_manager)
+        if request.target_address is not None:
+            target_puzhash = decode_puzzle_hash(request.target_address)
         else:
-            target_puzhash = target_address
-        if "uris" not in request:
-            return {"success": False, "error": "Data URIs is required"}
-        if not isinstance(request["uris"], list):
-            return {"success": False, "error": "Data URIs must be a list"}
-        if not isinstance(request.get("meta_uris", []), list):
-            return {"success": False, "error": "Metadata URIs must be a list"}
-        if not isinstance(request.get("license_uris", []), list):
-            return {"success": False, "error": "License URIs must be a list"}
+            target_puzhash = await action_scope.get_puzzle_hash(self.service.wallet_state_manager)
         metadata_list = [
-            ("u", request["uris"]),
-            ("h", hexstr_to_bytes(request["hash"])),
-            ("mu", request.get("meta_uris", [])),
-            ("lu", request.get("license_uris", [])),
-            ("sn", uint64(request.get("edition_number", 1))),
-            ("st", uint64(request.get("edition_total", 1))),
+            ("u", request.uris),
+            ("h", request.hash),
+            ("mu", request.meta_uris),
+            ("lu", request.license_uris),
+            ("sn", request.edition_number),
+            ("st", request.edition_total),
         ]
-        if "meta_hash" in request and len(request["meta_hash"]) > 0:
-            metadata_list.append(("mh", hexstr_to_bytes(request["meta_hash"])))
-        if "license_hash" in request and len(request["license_hash"]) > 0:
-            metadata_list.append(("lh", hexstr_to_bytes(request["license_hash"])))
+        if request.meta_hash is not None:
+            metadata_list.append(("mh", request.meta_hash))
+        if request.license_hash is not None:
+            metadata_list.append(("lh", request.license_hash))
         metadata = Program.to(metadata_list)
-        fee = uint64(request.get("fee", 0))
-        did_id = request.get("did_id", None)
-        if did_id is not None:
-            if did_id == "":
-                did_id = b""
+        if request.did_id is not None:
+            if request.did_id == "":
+                did_id: Optional[bytes] = b""
             else:
-                did_id = decode_puzzle_hash(did_id)
+                did_id = decode_puzzle_hash(request.did_id)
+        else:
+            did_id = request.did_id
 
         nft_id = await nft_wallet.generate_new_nft(
             metadata,
             action_scope,
             target_puzhash,
             royalty_puzhash,
-            royalty_amount,
+            request.royalty_amount,
             did_id,
-            fee,
+            request.fee,
             extra_conditions=extra_conditions,
         )
         nft_id_bech32 = encode_puzzle_hash(nft_id, AddressType.NFT.hrp(self.service.config))
-        return {
-            "wallet_id": wallet_id,
-            "success": True,
-            "spend_bundle": None,  # tx_endpoint wrapper will take care of this
-            "nft_id": nft_id_bech32,
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        return NFTMintNFTResponse(
+            [],
+            [],
+            wallet_id=request.wallet_id,
+            spend_bundle=WalletSpendBundle([], G2Element()),  # tx_endpoint wrapper will take care of this
+            nft_id=nft_id_bech32,
+        )
 
-    async def nft_count_nfts(self, request: dict[str, Any]) -> EndpointResult:
-        wallet_id = request.get("wallet_id", None)
+    @marshal
+    async def nft_count_nfts(self, request: NFTCountNFTs) -> NFTCountNFTsResponse:
         count = 0
-        if wallet_id is not None:
+        if request.wallet_id is not None:
             try:
-                nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
+                nft_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=NFTWallet)
             except KeyError:
                 # wallet not found
-                return {"success": False, "error": f"Wallet {wallet_id} not found."}
+                raise ValueError(f"Wallet {request.wallet_id} not found.")
             count = await nft_wallet.get_nft_count()
         else:
             count = await self.service.wallet_state_manager.nft_store.count()
-        return {"wallet_id": wallet_id, "success": True, "count": count}
+        return NFTCountNFTsResponse(request.wallet_id, uint64(count))
 
-    async def nft_get_nfts(self, request: dict[str, Any]) -> EndpointResult:
-        wallet_id = request.get("wallet_id", None)
+    @marshal
+    async def nft_get_nfts(self, request: NFTGetNFTs) -> NFTGetNFTsResponse:
         nfts: list[NFTCoinInfo] = []
-        if wallet_id is not None:
-            nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
+        if request.wallet_id is not None:
+            nft_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=NFTWallet)
         else:
             nft_wallet = None
-        try:
-            start_index = int(request.get("start_index", 0))
-        except (TypeError, ValueError):
-            start_index = 0
-        try:
-            count = int(request.get("num", 50))
-        except (TypeError, ValueError):
-            count = 50
         nft_info_list = []
         if nft_wallet is not None:
-            nfts = await nft_wallet.get_current_nfts(start_index=start_index, count=count)
+            nfts = await nft_wallet.get_current_nfts(start_index=request.start_index, count=request.num)
         else:
-            nfts = await self.service.wallet_state_manager.nft_store.get_nft_list(start_index=start_index, count=count)
+            nfts = await self.service.wallet_state_manager.nft_store.get_nft_list(
+                start_index=request.start_index, count=request.num
+            )
         for nft in nfts:
             nft_info = await nft_puzzle_utils.get_nft_info_from_puzzle(nft, self.service.wallet_state_manager.config)
             nft_info_list.append(nft_info)
-        return {"wallet_id": wallet_id, "success": True, "nft_list": nft_info_list}
+        return NFTGetNFTsResponse(request.wallet_id, nft_info_list)
 
     @tx_endpoint(push=True)
+    @marshal
     async def nft_set_nft_did(
         self,
-        request: dict[str, Any],
+        request: NFTSetNFTDID,
         action_scope: WalletActionScope,
         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)
-        did_id = request.get("did_id", b"")
-        if did_id != b"":
-            did_id = decode_puzzle_hash(did_id)
-        nft_coin_info = await nft_wallet.get_nft_coin_by_id(bytes32.from_hexstr(request["nft_coin_id"]))
+    ) -> NFTSetNFTDIDResponse:
+        nft_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=NFTWallet)
+        if request.did_id is not None:
+            did_id: bytes = decode_puzzle_hash(request.did_id)
+        else:
+            did_id = b""
+        nft_coin_info = await nft_wallet.get_nft_coin_by_id(request.nft_coin_id)
         if not (
             await nft_puzzle_utils.get_nft_info_from_puzzle(nft_coin_info, self.service.wallet_state_manager.config)
         ).supports_did:
-            return {"success": False, "error": "The NFT doesn't support setting a DID."}
+            raise ValueError("The NFT doesn't support setting a DID.")
 
-        fee = uint64(request.get("fee", 0))
         await nft_wallet.set_nft_did(
             nft_coin_info,
             did_id,
             action_scope,
-            fee=fee,
+            fee=request.fee,
             extra_conditions=extra_conditions,
         )
-        return {
-            "wallet_id": wallet_id,
-            "success": True,
-            "spend_bundle": None,  # tx_endpoint wrapper will take care of this
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        # tx_endpoint wrapper takes care of setting most of these default values
+        return NFTSetNFTDIDResponse([], [], request.wallet_id, WalletSpendBundle([], G2Element()))
 
     @tx_endpoint(push=True)
+    @marshal
     async def nft_set_did_bulk(
         self,
-        request: dict[str, Any],
+        request: NFTSetDIDBulk,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> NFTSetDIDBulkResponse:
         """
         Bulk set DID for NFTs across different wallets.
         accepted `request` dict keys:
@@ -3167,40 +3217,34 @@ class WalletRpcApi:
         :param request:
         :return:
         """
-        if len(request["nft_coin_list"]) > MAX_NFT_CHUNK_SIZE:
-            return {"success": False, "error": f"You can only set {MAX_NFT_CHUNK_SIZE} NFTs at once"}
-        did_id = request.get("did_id", b"")
-        if did_id != b"":
-            did_id = decode_puzzle_hash(did_id)
+        if len(request.nft_coin_list) > MAX_NFT_CHUNK_SIZE:
+            raise ValueError(f"You can only set {MAX_NFT_CHUNK_SIZE} NFTs at once")
+
+        if request.did_id is not None:
+            did_id: bytes = decode_puzzle_hash(request.did_id)
+        else:
+            did_id = b""
         nft_dict: dict[uint32, list[NFTCoinInfo]] = {}
         coin_ids = []
         nft_ids = []
-        fee = uint64(request.get("fee", 0))
 
         nft_wallet: NFTWallet
-        for nft_coin in request["nft_coin_list"]:
-            if "nft_coin_id" not in nft_coin or "wallet_id" not in nft_coin:
-                log.error(f"Cannot set DID for NFT :{nft_coin}, missing nft_coin_id or wallet_id.")
-                continue
-            wallet_id = uint32(nft_coin["wallet_id"])
-            nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
-            nft_coin_id = nft_coin["nft_coin_id"]
-            if nft_coin_id.startswith(AddressType.NFT.hrp(self.service.config)):
-                nft_id = decode_puzzle_hash(nft_coin_id)
-                nft_coin_info = await nft_wallet.get_nft(nft_id)
+        for nft_coin in request.nft_coin_list:
+            nft_wallet = self.service.wallet_state_manager.get_wallet(id=nft_coin.wallet_id, required_type=NFTWallet)
+            if nft_coin.nft_coin_id.startswith(AddressType.NFT.hrp(self.service.config)):
+                nft_coin_info = await nft_wallet.get_nft(decode_puzzle_hash(nft_coin.nft_coin_id))
             else:
-                nft_coin_id = bytes32.from_hexstr(nft_coin_id)
-                nft_coin_info = await nft_wallet.get_nft_coin_by_id(nft_coin_id)
+                nft_coin_info = await nft_wallet.get_nft_coin_by_id(bytes32.from_hexstr(nft_coin.nft_coin_id))
             assert nft_coin_info is not None
             if not (
                 await nft_puzzle_utils.get_nft_info_from_puzzle(nft_coin_info, self.service.wallet_state_manager.config)
             ).supports_did:
                 log.warning(f"Skipping NFT {nft_coin_info.nft_id.hex()}, doesn't support setting a DID.")
                 continue
-            if wallet_id in nft_dict:
-                nft_dict[wallet_id].append(nft_coin_info)
+            if nft_coin.wallet_id in nft_dict:
+                nft_dict[nft_coin.wallet_id].append(nft_coin_info)
             else:
-                nft_dict[wallet_id] = [nft_coin_info]
+                nft_dict[nft_coin.wallet_id] = [nft_coin_info]
             nft_ids.append(nft_coin_info.nft_id)
         first = True
         for wallet_id, nft_list in nft_dict.items():
@@ -3209,7 +3253,7 @@ class WalletRpcApi:
                 await nft_wallet.set_bulk_nft_did(nft_list, did_id, action_scope, extra_conditions=extra_conditions)
             else:
                 await nft_wallet.set_bulk_nft_did(
-                    nft_list, did_id, action_scope, fee, nft_ids, extra_conditions=extra_conditions
+                    nft_list, did_id, action_scope, request.fee, nft_ids, extra_conditions=extra_conditions
                 )
             for coin in nft_list:
                 coin_ids.append(coin.coin.name())
@@ -3221,21 +3265,22 @@ class WalletRpcApi:
             self.service.wallet_state_manager.state_changed("nft_coin_did_set", wallet_id)
 
         async with action_scope.use() as interface:
-            return {
-                "wallet_id": list(nft_dict.keys()),
-                "success": True,
-                "spend_bundle": None,  # Backwards compat code in @tx_endpoint wrapper will fix this
-                "tx_num": len(interface.side_effects.transactions),
-                "transactions": None,  # tx_endpoint wrapper will take care of this
-            }
+            return NFTSetDIDBulkResponse(
+                [],
+                [],
+                wallet_id=list(nft_dict.keys()),
+                spend_bundle=WalletSpendBundle([], G2Element()),
+                tx_num=uint16(len(interface.side_effects.transactions)),
+            )
 
     @tx_endpoint(push=True)
+    @marshal
     async def nft_transfer_bulk(
         self,
-        request: dict[str, Any],
+        request: NFTTransferBulk,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> NFTTransferBulkResponse:
         """
         Bulk transfer NFTs to an address.
         accepted `request` dict keys:
@@ -3245,36 +3290,26 @@ class WalletRpcApi:
         :param request:
         :return:
         """
-        if len(request["nft_coin_list"]) > MAX_NFT_CHUNK_SIZE:
-            return {"success": False, "error": f"You can only transfer {MAX_NFT_CHUNK_SIZE} NFTs at once"}
-        address = request["target_address"]
-        if isinstance(address, str):
-            puzzle_hash = decode_puzzle_hash(address)
-        else:
-            return dict(success=False, error="target_address parameter missing")
+        if len(request.nft_coin_list) > MAX_NFT_CHUNK_SIZE:
+            raise ValueError(f"You can only transfer {MAX_NFT_CHUNK_SIZE} NFTs at once")
+        address = request.target_address
+        puzzle_hash = decode_puzzle_hash(address)
         nft_dict: dict[uint32, list[NFTCoinInfo]] = {}
         coin_ids = []
-        fee = uint64(request.get("fee", 0))
 
         nft_wallet: NFTWallet
-        for nft_coin in request["nft_coin_list"]:
-            if "nft_coin_id" not in nft_coin or "wallet_id" not in nft_coin:
-                log.error(f"Cannot transfer NFT :{nft_coin}, missing nft_coin_id or wallet_id.")
-                continue
-            wallet_id = uint32(nft_coin["wallet_id"])
-            nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
-            nft_coin_id = nft_coin["nft_coin_id"]
+        for nft_coin in request.nft_coin_list:
+            nft_wallet = self.service.wallet_state_manager.get_wallet(id=nft_coin.wallet_id, required_type=NFTWallet)
+            nft_coin_id = nft_coin.nft_coin_id
             if nft_coin_id.startswith(AddressType.NFT.hrp(self.service.config)):
-                nft_id = decode_puzzle_hash(nft_coin_id)
-                nft_coin_info = await nft_wallet.get_nft(nft_id)
+                nft_coin_info = await nft_wallet.get_nft(decode_puzzle_hash(nft_coin_id))
             else:
-                nft_coin_id = bytes32.from_hexstr(nft_coin_id)
-                nft_coin_info = await nft_wallet.get_nft_coin_by_id(nft_coin_id)
+                nft_coin_info = await nft_wallet.get_nft_coin_by_id(bytes32.from_hexstr(nft_coin_id))
             assert nft_coin_info is not None
-            if wallet_id in nft_dict:
-                nft_dict[wallet_id].append(nft_coin_info)
+            if nft_coin.wallet_id in nft_dict:
+                nft_dict[nft_coin.wallet_id].append(nft_coin_info)
             else:
-                nft_dict[wallet_id] = [nft_coin_info]
+                nft_dict[nft_coin.wallet_id] = [nft_coin_info]
         first = True
         for wallet_id, nft_list in nft_dict.items():
             nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
@@ -3284,7 +3319,7 @@ class WalletRpcApi:
                 )
             else:
                 await nft_wallet.bulk_transfer_nft(
-                    nft_list, puzzle_hash, action_scope, fee, extra_conditions=extra_conditions
+                    nft_list, puzzle_hash, action_scope, request.fee, extra_conditions=extra_conditions
                 )
             for coin in nft_list:
                 coin_ids.append(coin.coin.name())
@@ -3295,33 +3330,35 @@ class WalletRpcApi:
         for wallet_id in nft_dict.keys():
             self.service.wallet_state_manager.state_changed("nft_coin_did_set", wallet_id)
         async with action_scope.use() as interface:
-            return {
-                "wallet_id": list(nft_dict.keys()),
-                "success": True,
-                "spend_bundle": None,  # tx_endpoint wrapper will take care of this
-                "tx_num": len(interface.side_effects.transactions),
-                "transactions": None,  # tx_endpoint wrapper will take care of this
-            }
+            return NFTTransferBulkResponse(
+                [],
+                [],
+                wallet_id=list(nft_dict.keys()),
+                spend_bundle=WalletSpendBundle([], G2Element()),
+                tx_num=uint16(len(interface.side_effects.transactions)),
+            )
 
-    async def nft_get_by_did(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def nft_get_by_did(self, request: NFTGetByDID) -> NFTGetByDIDResponse:
         did_id: Optional[bytes32] = None
-        if request.get("did_id", None) is not None:
-            did_id = decode_puzzle_hash(request["did_id"])
+        if request.did_id is not None:
+            did_id = decode_puzzle_hash(request.did_id)
         for wallet in self.service.wallet_state_manager.wallets.values():
             if isinstance(wallet, NFTWallet) and wallet.get_did() == did_id:
-                return {"wallet_id": wallet.wallet_id, "success": True}
-        return {"error": f"Cannot find a NFT wallet DID = {did_id}", "success": False}
+                return NFTGetByDIDResponse(uint32(wallet.wallet_id))
+        raise ValueError(f"Cannot find a NFT wallet DID = {did_id}")
 
-    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)
+    @marshal
+    async def nft_get_wallet_did(self, request: NFTGetWalletDID) -> NFTGetWalletDIDResponse:
+        nft_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=NFTWallet)
         did_bytes: Optional[bytes32] = nft_wallet.get_did()
         did_id = ""
         if did_bytes is not None:
             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}
+        return NFTGetWalletDIDResponse(None if len(did_id) == 0 else did_id)
 
-    async def nft_get_wallets_with_dids(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def nft_get_wallets_with_dids(self, request: Empty) -> NFTGetWalletsWithDIDsResponse:
         all_wallets = self.service.wallet_state_manager.wallets.values()
         did_wallets_by_did_id: dict[bytes32, uint32] = {}
 
@@ -3331,7 +3368,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[NFTWalletWithDID] = []
         for wallet in all_wallets:
             if isinstance(wallet, NFTWallet):
                 nft_wallet_did: Optional[bytes32] = wallet.get_did()
@@ -3341,97 +3378,78 @@ class WalletRpcApi:
                         log.warning(f"NFT wallet {wallet.id()} has DID {nft_wallet_did.hex()} but no DID wallet")
                     else:
                         did_nft_wallets.append(
-                            {
-                                "wallet_id": wallet.id(),
-                                "did_id": encode_puzzle_hash(nft_wallet_did, AddressType.DID.hrp(self.service.config)),
-                                "did_wallet_id": did_wallet_id,
-                            }
+                            NFTWalletWithDID(
+                                wallet_id=wallet.id(),
+                                did_id=encode_puzzle_hash(nft_wallet_did, AddressType.DID.hrp(self.service.config)),
+                                did_wallet_id=did_wallet_id,
+                            )
                         )
-        return {"success": True, "nft_wallets": did_nft_wallets}
+        return NFTGetWalletsWithDIDsResponse(did_nft_wallets)
 
-    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"]
+    @marshal
+    async def nft_set_nft_status(self, request: NFTSetNFTStatus) -> Empty:
         assert self.service.wallet_state_manager is not None
-        nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
-        await nft_wallet.update_coin_status(coin_id, status)
-        return {"success": True}
+        nft_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=NFTWallet)
+        await nft_wallet.update_coin_status(request.coin_id, request.in_transaction)
+        return Empty()
 
     @tx_endpoint(push=True)
+    @marshal
     async def nft_transfer_nft(
         self,
-        request: dict[str, Any],
+        request: NFTTransferNFT,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
-        wallet_id = uint32(request["wallet_id"])
-        address = request["target_address"]
-        if isinstance(address, str):
-            puzzle_hash = decode_puzzle_hash(address)
+    ) -> NFTTransferNFTResponse:
+        puzzle_hash = decode_puzzle_hash(request.target_address)
+        nft_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=NFTWallet)
+        nft_coin_id = request.nft_coin_id
+        if nft_coin_id.startswith(AddressType.NFT.hrp(self.service.config)):
+            nft_coin_info = await nft_wallet.get_nft(decode_puzzle_hash(nft_coin_id))
         else:
-            return dict(success=False, error="target_address parameter missing")
-        nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
-        try:
-            nft_coin_id = request["nft_coin_id"]
-            if nft_coin_id.startswith(AddressType.NFT.hrp(self.service.config)):
-                nft_id = decode_puzzle_hash(nft_coin_id)
-                nft_coin_info = await nft_wallet.get_nft(nft_id)
-            else:
-                nft_coin_id = bytes32.from_hexstr(nft_coin_id)
-                nft_coin_info = await nft_wallet.get_nft_coin_by_id(nft_coin_id)
-            assert nft_coin_info is not None
+            nft_coin_info = await nft_wallet.get_nft_coin_by_id(bytes32.from_hexstr(nft_coin_id))
+        assert nft_coin_info is not None
 
-            fee = uint64(request.get("fee", 0))
-            await nft_wallet.generate_signed_transaction(
-                [uint64(nft_coin_info.coin.amount)],
-                [puzzle_hash],
-                action_scope,
-                coins={nft_coin_info.coin},
-                fee=fee,
-                new_owner=b"",
-                new_did_inner_hash=b"",
-                extra_conditions=extra_conditions,
-            )
-            await nft_wallet.update_coin_status(nft_coin_info.coin.name(), True)
-            return {
-                "wallet_id": wallet_id,
-                "success": True,
-                "spend_bundle": None,  # tx_endpoint wrapper will take care of this
-                "transactions": None,  # tx_endpoint wrapper will take care of this
-            }
-        except Exception as e:
-            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:
-        if "coin_id" not in request:
-            return {"success": False, "error": "Coin ID is required."}
-        coin_id = request["coin_id"]
-        if coin_id.startswith(AddressType.NFT.hrp(self.service.config)):
-            coin_id = decode_puzzle_hash(coin_id)
+        await nft_wallet.generate_signed_transaction(
+            [uint64(nft_coin_info.coin.amount)],
+            [puzzle_hash],
+            action_scope,
+            coins={nft_coin_info.coin},
+            fee=request.fee,
+            new_owner=b"",
+            new_did_inner_hash=b"",
+            extra_conditions=extra_conditions,
+        )
+        await nft_wallet.update_coin_status(nft_coin_info.coin.name(), True)
+        # tx_endpoint takes care of filling in default values here
+        return NFTTransferNFTResponse([], [], request.wallet_id, WalletSpendBundle([], G2Element()))
+
+    @marshal
+    async def nft_get_info(self, request: NFTGetInfo) -> NFTGetInfoResponse:
+        if request.coin_id.startswith(AddressType.NFT.hrp(self.service.config)):
+            coin_id = decode_puzzle_hash(request.coin_id)
         else:
             try:
-                coin_id = bytes32.from_hexstr(coin_id)
+                coin_id = bytes32.from_hexstr(request.coin_id)
             except ValueError:
-                return {"success": False, "error": f"Invalid Coin ID format for 'coin_id': {request['coin_id']!r}"}
+                raise ValueError(f"Invalid Coin ID format for 'coin_id': {request.coin_id!r}")
         # Get coin state
         peer = self.service.get_full_node_peer()
-        coin_spend, coin_state = await self.get_latest_singleton_coin_spend(peer, coin_id, request.get("latest", True))
+        coin_spend, coin_state = await self.get_latest_singleton_coin_spend(peer, coin_id, request.latest)
         # convert to NFTInfo
         # Check if the metadata is updated
         full_puzzle: Program = Program.from_bytes(bytes(coin_spend.puzzle_reveal))
 
         uncurried_nft: Optional[UncurriedNFT] = UncurriedNFT.uncurry(*full_puzzle.uncurry())
         if uncurried_nft is None:
-            return {"success": False, "error": "The coin is not a NFT."}
+            raise ValueError("The coin is not a NFT.")
         metadata, p2_puzzle_hash = get_metadata_and_phs(uncurried_nft, coin_spend.solution)
         # Note: This is not the actual unspent NFT full puzzle.
         # There is no way to rebuild the full puzzle in a different wallet.
         # But it shouldn't have impact on generating the NFTInfo, since inner_puzzle is not used there.
         if uncurried_nft.supports_did:
             inner_puzzle = nft_puzzle_utils.recurry_nft_puzzle(
-                uncurried_nft, coin_spend.solution.to_program(), uncurried_nft.p2_puzzle
+                uncurried_nft, Program.from_serialized(coin_spend.solution), uncurried_nft.p2_puzzle
             )
         else:
             inner_puzzle = uncurried_nft.p2_puzzle
@@ -3448,10 +3466,7 @@ class WalletRpcApi:
             [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:
-            return {
-                "success": False,
-                "error": f"Launcher coin record 0x{uncurried_nft.singleton_launcher_id.hex()} not found",
-            }
+            raise ValueError(f"Launcher coin record 0x{uncurried_nft.singleton_launcher_id.hex()} not found")
         minter_did = await self.service.wallet_state_manager.get_minter_did(launcher_coin[0].coin, peer)
 
         nft_info: NFTInfo = await nft_puzzle_utils.get_nft_info_from_puzzle(
@@ -3468,179 +3483,136 @@ class WalletRpcApi:
         )
         # This is a bit hacky, it should just come out like this, but this works for this RPC
         nft_info = dataclasses.replace(nft_info, p2_address=p2_puzzle_hash)
-        return {"success": True, "nft_info": nft_info}
+        return NFTGetInfoResponse(nft_info)
 
     @tx_endpoint(push=True)
+    @marshal
     async def nft_add_uri(
         self,
-        request: dict[str, Any],
+        request: NFTAddURI,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
-        wallet_id = uint32(request["wallet_id"])
+    ) -> NFTAddURIResponse:
         # Note metadata updater can only add one uri for one field per spend.
         # If you want to add multiple uris for one field, you need to spend multiple times.
-        nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
-        uri = request["uri"]
-        key = request["key"]
-        nft_coin_id = request["nft_coin_id"]
-        if nft_coin_id.startswith(AddressType.NFT.hrp(self.service.config)):
-            nft_coin_id = decode_puzzle_hash(nft_coin_id)
+        nft_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=NFTWallet)
+        if request.nft_coin_id.startswith(AddressType.NFT.hrp(self.service.config)):
+            nft_coin_id = decode_puzzle_hash(request.nft_coin_id)
         else:
-            nft_coin_id = bytes32.from_hexstr(nft_coin_id)
+            nft_coin_id = bytes32.from_hexstr(request.nft_coin_id)
         nft_coin_info = await nft_wallet.get_nft_coin_by_id(nft_coin_id)
 
-        fee = uint64(request.get("fee", 0))
         await nft_wallet.update_metadata(
-            nft_coin_info, key, uri, action_scope, fee=fee, extra_conditions=extra_conditions
+            nft_coin_info, request.key, request.uri, action_scope, fee=request.fee, extra_conditions=extra_conditions
         )
-        return {
-            "wallet_id": wallet_id,
-            "success": True,
-            "spend_bundle": None,  # tx_endpoint wrapper will take care of this
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        # tx_endpoint takes care of setting the default values here
+        return NFTAddURIResponse([], [], request.wallet_id, WalletSpendBundle([], G2Element()))
 
-    async def nft_calculate_royalties(self, request: dict[str, Any]) -> EndpointResult:
-        return NFTWallet.royalty_calculation(
-            {
-                asset["asset"]: (asset["royalty_address"], uint16(asset["royalty_percentage"]))
-                for asset in request.get("royalty_assets", [])
-            },
-            {asset["asset"]: uint64(asset["amount"]) for asset in request.get("fungible_assets", [])},
+    @marshal
+    async def nft_calculate_royalties(self, request: NFTCalculateRoyalties) -> NFTCalculateRoyaltiesResponse:
+        return NFTCalculateRoyaltiesResponse.from_json_dict(
+            NFTWallet.royalty_calculation(
+                {
+                    asset.asset: (asset.royalty_address, uint16(asset.royalty_percentage))
+                    for asset in request.royalty_assets
+                },
+                {asset.asset: asset.amount for asset in request.fungible_assets},
+            )
         )
 
     @tx_endpoint(push=False)
+    @marshal
     async def nft_mint_bulk(
         self,
-        request: dict[str, Any],
+        request: NFTMintBulk,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> NFTMintBulkResponse:
         if action_scope.config.push:
             raise ValueError("Automatic pushing of nft minting transactions not yet available")  # pragma: no cover
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced.")
-        wallet_id = uint32(request["wallet_id"])
-        nft_wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=NFTWallet)
-        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, ""}:
-            royalty_puzhash = await nft_wallet.standard_wallet.get_new_puzzlehash()
+        nft_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=NFTWallet)
+        if request.royalty_address in {None, ""}:
+            royalty_puzhash = await action_scope.get_puzzle_hash(self.service.wallet_state_manager)
         else:
-            royalty_puzhash = bytes32.from_hexstr(royalty_address)
-        royalty_percentage = request.get("royalty_percentage", None)
-        if royalty_percentage is None:
-            royalty_percentage = uint16(0)
-        else:
-            royalty_percentage = uint16(int(royalty_percentage))
+            assert request.royalty_address is not None  # hello mypy
+            royalty_puzhash = decode_puzzle_hash(request.royalty_address)
         metadata_list = []
-        for meta in request["metadata_list"]:
-            if "uris" not in meta.keys():
-                return {"success": False, "error": "Data URIs is required"}
-            if not isinstance(meta["uris"], list):
-                return {"success": False, "error": "Data URIs must be a list"}
-            if not isinstance(meta.get("meta_uris", []), list):
-                return {"success": False, "error": "Metadata URIs must be a list"}
-            if not isinstance(meta.get("license_uris", []), list):
-                return {"success": False, "error": "License URIs must be a list"}
+        for meta in request.metadata_list:
             nft_metadata = [
-                ("u", meta["uris"]),
-                ("h", hexstr_to_bytes(meta["hash"])),
-                ("mu", meta.get("meta_uris", [])),
-                ("lu", meta.get("license_uris", [])),
-                ("sn", uint64(meta.get("edition_number", 1))),
-                ("st", uint64(meta.get("edition_total", 1))),
+                ("u", meta.uris),
+                ("h", meta.hash),
+                ("mu", meta.meta_uris),
+                ("lu", meta.license_uris),
+                ("sn", meta.edition_number),
+                ("st", meta.edition_total),
             ]
-            if "meta_hash" in meta and len(meta["meta_hash"]) > 0:
-                nft_metadata.append(("mh", hexstr_to_bytes(meta["meta_hash"])))
-            if "license_hash" in meta and len(meta["license_hash"]) > 0:
-                nft_metadata.append(("lh", hexstr_to_bytes(meta["license_hash"])))
+            if meta.meta_hash is not None:
+                nft_metadata.append(("mh", meta.meta_hash))
+            if meta.license_hash is not None:
+                nft_metadata.append(("lh", meta.license_hash))
             metadata_program = Program.to(nft_metadata)
             metadata_dict = {
                 "program": metadata_program,
-                "royalty_pc": royalty_percentage,
+                "royalty_pc": request.royalty_percentage,
                 "royalty_ph": royalty_puzhash,
             }
             metadata_list.append(metadata_dict)
-        target_address_list = request.get("target_list", None)
-        target_list = []
-        if target_address_list:
-            for target in target_address_list:
-                target_list.append(decode_puzzle_hash(target))
-        mint_number_start = request.get("mint_number_start", 1)
-        mint_total = request.get("mint_total", None)
-        xch_coin_list = request.get("xch_coins", None)
-        xch_coins = None
-        if xch_coin_list:
-            xch_coins = {Coin.from_json_dict(xch_coin) for xch_coin in xch_coin_list}
-        xch_change_target = request.get("xch_change_target", None)
-        if xch_change_target is not None:
-            if xch_change_target[:2] == "xch":
-                xch_change_ph = decode_puzzle_hash(xch_change_target)
+        target_list = [decode_puzzle_hash(target) for target in request.target_list]
+        if request.xch_change_target is not None:
+            if request.xch_change_target.startswith("xch"):
+                xch_change_ph = decode_puzzle_hash(request.xch_change_target)
             else:
-                xch_change_ph = bytes32.from_hexstr(xch_change_target)
+                xch_change_ph = bytes32.from_hexstr(request.xch_change_target)
         else:
             xch_change_ph = None
-        new_innerpuzhash = request.get("new_innerpuzhash", None)
-        new_p2_puzhash = request.get("new_p2_puzhash", None)
-        did_coin_dict = request.get("did_coin", None)
-        if did_coin_dict:
-            did_coin = Coin.from_json_dict(did_coin_dict)
-        else:
-            did_coin = None
-        did_lineage_parent_hex = request.get("did_lineage_parent", None)
-        if did_lineage_parent_hex:
-            did_lineage_parent = bytes32.from_hexstr(did_lineage_parent_hex)
-        else:
-            did_lineage_parent = None
-        mint_from_did = request.get("mint_from_did", False)
-        fee = uint64(request.get("fee", 0))
 
-        if mint_from_did:
+        if request.mint_from_did:
             await nft_wallet.mint_from_did(
                 metadata_list,
-                mint_number_start=mint_number_start,
-                mint_total=mint_total,
+                mint_number_start=request.mint_number_start,
+                mint_total=request.mint_total,
                 target_list=target_list,
-                xch_coins=xch_coins,
+                xch_coins=set(request.xch_coins) if request.xch_coins is not None else None,
                 xch_change_ph=xch_change_ph,
-                new_innerpuzhash=new_innerpuzhash,
-                new_p2_puzhash=new_p2_puzhash,
-                did_coin=did_coin,
-                did_lineage_parent=did_lineage_parent,
-                fee=fee,
+                new_innerpuzhash=request.new_innerpuzhash,
+                new_p2_puzhash=request.new_p2_puzhash,
+                did_coin=request.did_coin,
+                did_lineage_parent=request.did_lineage_parent,
+                fee=request.fee,
                 action_scope=action_scope,
                 extra_conditions=extra_conditions,
             )
         else:
             await nft_wallet.mint_from_xch(
                 metadata_list,
-                mint_number_start=mint_number_start,
-                mint_total=mint_total,
+                mint_number_start=request.mint_number_start,
+                mint_total=request.mint_total,
                 target_list=target_list,
-                xch_coins=xch_coins,
+                xch_coins=set(request.xch_coins) if request.xch_coins is not None else None,
                 xch_change_ph=xch_change_ph,
-                fee=fee,
+                fee=request.fee,
                 action_scope=action_scope,
                 extra_conditions=extra_conditions,
             )
         async with action_scope.use() as interface:
             sb = WalletSpendBundle.aggregate(
                 [tx.spend_bundle for tx in interface.side_effects.transactions if tx.spend_bundle is not None]
+                + [sb for sb in interface.side_effects.extra_spends]
             )
         nft_id_list = []
         for cs in sb.coin_spends:
             if cs.coin.puzzle_hash == SINGLETON_LAUNCHER_PUZZLE_HASH:
                 nft_id_list.append(encode_puzzle_hash(cs.coin.name(), AddressType.NFT.hrp(self.service.config)))
 
-        return {
-            "success": True,
-            "spend_bundle": None,  # tx_endpoint wrapper will take care of this
-            "nft_id_list": nft_id_list,
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        # tx_endpoint will take care of the default values here
+        return NFTMintBulkResponse(
+            [],
+            [],
+            WalletSpendBundle([], G2Element()),
+            nft_id_list,
+        )
 
     async def get_coin_records(self, request: dict[str, Any]) -> EndpointResult:
         parsed_request = GetCoinRecords.from_json_dict(request)
@@ -3822,118 +3794,119 @@ class WalletRpcApi:
     # Pool Wallet
     ##########################################################################################
     @tx_endpoint(push=True)
+    @marshal
     async def pw_join_pool(
         self,
-        request: dict[str, Any],
+        request: PWJoinPool,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
-        fee = uint64(request.get("fee", 0))
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=PoolWallet)
-
-        pool_wallet_info: PoolWalletInfo = await wallet.get_current_state()
-        owner_pubkey = pool_wallet_info.current.owner_pubkey
-        target_puzzlehash = None
+    ) -> PWJoinPoolResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=PoolWallet)
 
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced.")
 
-        if "target_puzzlehash" in request:
-            target_puzzlehash = bytes32.from_hexstr(request["target_puzzlehash"])
-        assert target_puzzlehash is not None
+        pool_wallet_info: PoolWalletInfo = await wallet.get_current_state()
+        if (
+            pool_wallet_info.current.state == FARMING_TO_POOL.value
+            and pool_wallet_info.current.pool_url == request.pool_url
+        ):
+            raise ValueError(f"Already farming to pool {pool_wallet_info.current.pool_url}")
+
+        owner_pubkey = pool_wallet_info.current.owner_pubkey
         new_target_state: PoolState = create_pool_state(
             FARMING_TO_POOL,
-            target_puzzlehash,
+            request.target_puzzlehash,
             owner_pubkey,
-            request["pool_url"],
-            uint32(request["relative_lock_height"]),
+            request.pool_url,
+            request.relative_lock_height,
         )
 
-        async with self.service.wallet_state_manager.lock:
-            total_fee = await wallet.join_pool(new_target_state, fee, action_scope)
-            return {
-                "total_fee": total_fee,
-                "transaction": None,  # tx_endpoint wrapper will take care of this
-                "fee_transaction": None,  # tx_endpoint wrapper will take care of this
-                "transactions": None,  # tx_endpoint wrapper will take care of this
-            }
+        total_fee = await wallet.join_pool(new_target_state, request.fee, action_scope)
+        # tx_endpoint will take care of filling in these default values
+        return PWJoinPoolResponse(
+            [],
+            [],
+            total_fee=total_fee,
+            transaction=REPLACEABLE_TRANSACTION_RECORD,
+            fee_transaction=REPLACEABLE_TRANSACTION_RECORD,
+        )
 
     @tx_endpoint(push=True)
+    @marshal
     async def pw_self_pool(
         self,
-        request: dict[str, Any],
+        request: PWSelfPool,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> PWSelfPoolResponse:
         # Leaving a pool requires two state transitions.
         # First we transition to PoolSingletonState.LEAVING_POOL
         # Then we transition to FARMING_TO_POOL or SELF_POOLING
-        fee = uint64(request.get("fee", 0))
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=PoolWallet)
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=PoolWallet)
 
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced.")
 
-        async with self.service.wallet_state_manager.lock:
-            total_fee = await wallet.self_pool(fee, action_scope)
-            return {
-                "total_fee": total_fee,
-                "transaction": None,  # tx_endpoint wrapper will take care of this
-                "fee_transaction": None,  # tx_endpoint wrapper will take care of this
-                "transactions": None,  # tx_endpoint wrapper will take care of this
-            }
+        total_fee = await wallet.self_pool(request.fee, action_scope)
+        # tx_endpoint will take care of filling in these default values
+        return PWSelfPoolResponse(
+            [],
+            [],
+            total_fee=total_fee,
+            transaction=REPLACEABLE_TRANSACTION_RECORD,
+            fee_transaction=REPLACEABLE_TRANSACTION_RECORD,
+        )
 
     @tx_endpoint(push=True)
+    @marshal
     async def pw_absorb_rewards(
         self,
-        request: dict[str, Any],
+        request: PWAbsorbRewards,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> PWAbsorbRewardsResponse:
         """Perform a sweep of the p2_singleton rewards controlled by the pool wallet singleton"""
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before collecting rewards")
-        fee = uint64(request.get("fee", 0))
-        max_spends_in_tx = request.get("max_spends_in_tx", None)
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=PoolWallet)
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=PoolWallet)
 
         assert isinstance(wallet, PoolWallet)
         async with self.service.wallet_state_manager.lock:
-            await wallet.claim_pool_rewards(fee, max_spends_in_tx, action_scope)
+            await wallet.claim_pool_rewards(request.fee, request.max_spends_in_tx, action_scope)
             state: PoolWalletInfo = await wallet.get_current_state()
-            return {
-                "state": state.to_json_dict(),
-                "transaction": None,  # tx_endpoint wrapper will take care of this
-                "fee_transaction": None,  # tx_endpoint wrapper will take care of this
-                "transactions": None,  # tx_endpoint wrapper will take care of this
-            }
+            return PWAbsorbRewardsResponse(
+                [],
+                [],
+                state=state,
+                transaction=REPLACEABLE_TRANSACTION_RECORD,
+                fee_transaction=REPLACEABLE_TRANSACTION_RECORD,
+            )
 
-    async def pw_status(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def pw_status(self, request: PWStatus) -> PWStatusResponse:
         """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)
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.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()
-        return {
-            "state": state.to_json_dict(),
-            "unconfirmed_transactions": unconfirmed_transactions,
-        }
+        return PWStatusResponse(
+            state=state,
+            unconfirmed_transactions=unconfirmed_transactions,
+        )
 
     ##########################################################################################
     # DataLayer Wallet
     ##########################################################################################
     @tx_endpoint(push=True)
+    @marshal
     async def create_new_dl(
         self,
-        request: dict[str, Any],
+        request: CreateNewDL,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> CreateNewDLResponse:
         """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")
@@ -3944,24 +3917,19 @@ class WalletRpcApi:
             async with self.service.wallet_state_manager.lock:
                 dl_wallet = await DataLayerWallet.create_new_dl_wallet(self.service.wallet_state_manager)
 
-        try:
-            async with self.service.wallet_state_manager.lock:
-                launcher_id = await dl_wallet.generate_new_reporter(
-                    bytes32.from_hexstr(request["root"]),
-                    action_scope,
-                    fee=request.get("fee", uint64(0)),
-                    extra_conditions=extra_conditions,
-                )
-        except ValueError as e:
-            log.error(f"Error while generating new reporter {e}")
-            return {"success": False, "error": str(e)}
+        async with self.service.wallet_state_manager.lock:
+            launcher_id = await dl_wallet.generate_new_reporter(
+                request.root,
+                action_scope,
+                fee=request.fee,
+                extra_conditions=extra_conditions,
+            )
 
-        return {
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-            "launcher_id": launcher_id,
-        }
+        # tx_endpoint will take care of these default values
+        return CreateNewDLResponse([], [], launcher_id=launcher_id)
 
-    async def dl_track_new(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def dl_track_new(self, request: DLTrackNew) -> Empty:
         """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")
@@ -3977,55 +3945,53 @@ class WalletRpcApi:
         for i, peer in enumerate(peer_list):
             try:
                 await dl_wallet.track_new_launcher_id(
-                    bytes32.from_hexstr(request["launcher_id"]),
+                    request.launcher_id,
                     peer,
                 )
             except LauncherCoinNotFoundError as e:
                 if i == peer_length - 1:
                     raise e  # raise the error if we've tried all peers
                 continue  # try some other peers, maybe someone has it
-        return {}
+        return Empty()
 
-    async def dl_stop_tracking(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def dl_stop_tracking(self, request: DLStopTracking) -> Empty:
         """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")
 
         dl_wallet = self.service.wallet_state_manager.get_dl_wallet()
-        await dl_wallet.stop_tracking_singleton(bytes32.from_hexstr(request["launcher_id"]))
-        return {}
+        await dl_wallet.stop_tracking_singleton(request.launcher_id)
+        return Empty()
 
-    async def dl_latest_singleton(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def dl_latest_singleton(self, request: DLLatestSingleton) -> DLLatestSingletonResponse:
         """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")
 
-        only_confirmed = request.get("only_confirmed")
-        if only_confirmed is None:
-            only_confirmed = False
         wallet = self.service.wallet_state_manager.get_dl_wallet()
-        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()}
+        record = await wallet.get_latest_singleton(request.launcher_id, request.only_confirmed)
+        return DLLatestSingletonResponse(record)
 
-    async def dl_singletons_by_root(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def dl_singletons_by_root(self, request: DLSingletonsByRoot) -> DLSingletonsByRootResponse:
         """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")
 
         wallet = self.service.wallet_state_manager.get_dl_wallet()
-        records = await wallet.get_singletons_by_root(
-            bytes32.from_hexstr(request["launcher_id"]), bytes32.from_hexstr(request["root"])
-        )
-        records_json = [rec.to_json_dict() for rec in records]
-        return {"singletons": records_json}
+        records = await wallet.get_singletons_by_root(request.launcher_id, request.root)
+        return DLSingletonsByRootResponse(records)
 
     @tx_endpoint(push=True)
+    @marshal
     async def dl_update_root(
         self,
-        request: dict[str, Any],
+        request: DLUpdateRoot,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> DLUpdateRootResponse:
         """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")
@@ -4033,48 +3999,55 @@ class WalletRpcApi:
         wallet = self.service.wallet_state_manager.get_dl_wallet()
         async with self.service.wallet_state_manager.lock:
             await wallet.create_update_state_spend(
-                bytes32.from_hexstr(request["launcher_id"]),
-                bytes32.from_hexstr(request["new_root"]),
+                request.launcher_id,
+                request.new_root,
                 action_scope,
-                fee=uint64(request.get("fee", 0)),
+                fee=request.fee,
                 extra_conditions=extra_conditions,
             )
 
-        return {
-            "tx_record": None,  # tx_endpoint wrapper will take care of this
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        # tx_endpoint will take care of default values here
+        return DLUpdateRootResponse(
+            [],
+            [],
+            REPLACEABLE_TRANSACTION_RECORD,
+        )
 
     @tx_endpoint(push=True)
+    @marshal
     async def dl_update_multiple(
         self,
-        request: dict[str, Any],
+        request: DLUpdateMultiple,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> DLUpdateMultipleResponse:
         """Update multiple singletons with new merkle roots"""
         if self.service.wallet_state_manager is None:
-            return {"success": False, "error": "not_initialized"}
+            raise RuntimeError("not initialized")
 
         wallet = self.service.wallet_state_manager.get_dl_wallet()
         async with self.service.wallet_state_manager.lock:
             # TODO: This method should optionally link the singletons with announcements.
             #       Otherwise spends are vulnerable to signature subtraction.
-            fee_per_launcher = uint64(request.get("fee", 0) // len(request["updates"]))
-            for launcher, root in request["updates"].items():
+            # TODO: This method should natively support spending many and attaching one fee
+            fee_per_launcher = uint64(request.fee // len(request.updates.launcher_root_pairs))
+            for launcher_root_pair in request.updates.launcher_root_pairs:
                 await wallet.create_update_state_spend(
-                    bytes32.from_hexstr(launcher),
-                    bytes32.from_hexstr(root),
+                    launcher_root_pair.launcher_id,
+                    launcher_root_pair.new_root,
                     action_scope,
                     fee=fee_per_launcher,
                     extra_conditions=extra_conditions,
                 )
 
-            return {
-                "transactions": None,  # tx_endpoint wrapper will take care of this
-            }
+            # tx_endpoint will take care of default values here
+            return DLUpdateMultipleResponse(
+                [],
+                [],
+            )
 
-    async def dl_history(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def dl_history(self, request: DLHistory) -> DLHistoryResponse:
         """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")
@@ -4082,51 +4055,44 @@ class WalletRpcApi:
         wallet = self.service.wallet_state_manager.get_dl_wallet()
         additional_kwargs = {}
 
-        if "min_generation" in request:
-            additional_kwargs["min_generation"] = uint32(request["min_generation"])
-        if "max_generation" in request:
-            additional_kwargs["max_generation"] = uint32(request["max_generation"])
-        if "num_results" in request:
-            additional_kwargs["num_results"] = uint32(request["num_results"])
+        if request.min_generation is not None:
+            additional_kwargs["min_generation"] = uint32(request.min_generation)
+        if request.max_generation is not None:
+            additional_kwargs["max_generation"] = uint32(request.max_generation)
+        if request.num_results is not None:
+            additional_kwargs["num_results"] = uint32(request.num_results)
 
-        history = await wallet.get_history(bytes32.from_hexstr(request["launcher_id"]), **additional_kwargs)
-        history_json = [rec.to_json_dict() for rec in history]
-        return {"history": history_json, "count": len(history_json)}
+        history = await wallet.get_history(request.launcher_id, **additional_kwargs)
+        return DLHistoryResponse(history, uint32(len(history)))
 
-    async def dl_owned_singletons(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def dl_owned_singletons(self, request: Empty) -> DLOwnedSingletonsResponse:
         """Get all owned singleton records"""
         if self.service.wallet_state_manager is None:
             raise ValueError("The wallet service is not currently initialized")
 
-        try:
-            wallet = self.service.wallet_state_manager.get_dl_wallet()
-        except ValueError:
-            return {"success": False, "error": "no DataLayer wallet available"}
-
+        wallet = self.service.wallet_state_manager.get_dl_wallet()
         singletons = await wallet.get_owned_singletons()
-        singletons_json = [singleton.to_json_dict() for singleton in singletons]
 
-        return {"singletons": singletons_json, "count": len(singletons_json)}
+        return DLOwnedSingletonsResponse(singletons, uint32(len(singletons)))
 
-    async def dl_get_mirrors(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def dl_get_mirrors(self, request: DLGetMirrors) -> DLGetMirrorsResponse:
         """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")
 
         wallet = self.service.wallet_state_manager.get_dl_wallet()
-        mirrors_json = []
-        for mirror in await wallet.get_mirrors_for_launcher(bytes32.from_hexstr(request["launcher_id"])):
-            mirrors_json.append(mirror.to_json_dict())
-
-        return {"mirrors": mirrors_json}
+        return DLGetMirrorsResponse(await wallet.get_mirrors_for_launcher(request.launcher_id))
 
     @tx_endpoint(push=True)
+    @marshal
     async def dl_new_mirror(
         self,
-        request: dict[str, Any],
+        request: DLNewMirror,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> DLNewMirrorResponse:
         """Add a new on chain message for a specific singleton"""
         if self.service.wallet_state_manager is None:
             raise ValueError("The wallet service is not currently initialized")
@@ -4134,48 +4100,53 @@ class WalletRpcApi:
         dl_wallet = self.service.wallet_state_manager.get_dl_wallet()
         async with self.service.wallet_state_manager.lock:
             await dl_wallet.create_new_mirror(
-                bytes32.from_hexstr(request["launcher_id"]),
-                request["amount"],
-                [bytes(url, "utf8") for url in request["urls"]],
+                request.launcher_id,
+                request.amount,
+                Mirror.encode_urls(request.urls),
                 action_scope,
-                fee=request.get("fee", uint64(0)),
+                fee=request.fee,
                 extra_conditions=extra_conditions,
             )
 
-        return {
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        # tx_endpoint will take care of default values here
+        return DLNewMirrorResponse(
+            [],
+            [],
+        )
 
     @tx_endpoint(push=True)
+    @marshal
     async def dl_delete_mirror(
         self,
-        request: dict[str, Any],
+        request: DLDeleteMirror,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> DLDeleteMirrorResponse:
         """Remove an existing mirror for a specific singleton"""
         if self.service.wallet_state_manager is None:
             raise ValueError("The wallet service is not currently initialized")
 
         dl_wallet = self.service.wallet_state_manager.get_dl_wallet()
-
         async with self.service.wallet_state_manager.lock:
             await dl_wallet.delete_mirror(
-                bytes32.from_hexstr(request["coin_id"]),
+                request.coin_id,
                 self.service.get_full_node_peer(),
                 action_scope,
-                fee=request.get("fee", uint64(0)),
+                fee=request.fee,
                 extra_conditions=extra_conditions,
             )
 
-        return {
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        # tx_endpoint will take care of default values here
+        return DLDeleteMirrorResponse(
+            [],
+            [],
+        )
 
+    @marshal
     async def dl_verify_proof(
         self,
-        request: dict[str, Any],
-    ) -> EndpointResult:
+        request: DLProof,
+    ) -> VerifyProofResponse:
         """Verify a proof of inclusion for a DL singleton"""
         res = await dl_verify_proof(
             request,
@@ -4270,9 +4241,7 @@ class WalletRpcApi:
             [
                 request.new_puzhash
                 if request.new_puzhash is not None
-                else await vc_wallet.standard_wallet.get_puzzle_hash(
-                    new=not action_scope.config.tx_config.reuse_puzhash
-                )
+                else await action_scope.get_puzzle_hash(self.service.wallet_state_manager)
             ],
             action_scope,
             request.fee,