chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7rc2__py3-none-any.whl

chia/wallet/wallet_rpc_api.py

@@ -27,7 +27,7 @@ from chia.types.coin_record import CoinRecord
 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
-from chia.util.config import load_config, str2bool
+from chia.util.config import load_config
 from chia.util.errors import KeychainIsLocked
 from chia.util.hash import std_hash
 from chia.util.keychain import bytes_to_mnemonic, generate_mnemonic
@@ -90,7 +90,7 @@ from chia.wallet.util.clvm_streamable import json_serialize_with_clvm_streamable
 from chia.wallet.util.compute_hints import compute_spend_hints_and_additions
 from chia.wallet.util.compute_memos import compute_memos
 from chia.wallet.util.curry_and_treehash import NIL_TREEHASH
-from chia.wallet.util.query_filter import FilterMode, HashFilter, TransactionTypeFilter
+from chia.wallet.util.query_filter import FilterMode, HashFilter
 from chia.wallet.util.transaction_type import CLAWBACK_INCOMING_TRANSACTION_TYPES, TransactionType
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig, TXConfigLoader
 from chia.wallet.util.wallet_sync_utils import fetch_coin_spend_for_coin_state
@@ -111,13 +111,29 @@ from chia.wallet.wallet_request_types import (
     AddKeyResponse,
     ApplySignatures,
     ApplySignaturesResponse,
+    BalanceResponse,
+    CATAssetIDToName,
+    CATAssetIDToNameResponse,
+    CATGetAssetID,
+    CATGetAssetIDResponse,
+    CATGetName,
+    CATGetNameResponse,
+    CATSetName,
+    CATSetNameResponse,
+    CATSpend,
+    CATSpendResponse,
     CheckDeleteKey,
     CheckDeleteKeyResponse,
+    CheckOfferValidity,
+    CheckOfferValidityResponse,
     CombineCoins,
     CombineCoinsResponse,
     CreateNewDL,
     CreateNewDLResponse,
+    DefaultCAT,
     DeleteKey,
+    DeleteNotifications,
+    DeleteUnconfirmedTransactions,
     DIDCreateBackupFile,
     DIDCreateBackupFileResponse,
     DIDFindLostDID,
@@ -132,10 +148,6 @@ from chia.wallet.wallet_request_types import (
     DIDGetMetadataResponse,
     DIDGetPubkey,
     DIDGetPubkeyResponse,
-    DIDGetRecoveryInfo,
-    DIDGetRecoveryInfoResponse,
-    DIDGetRecoveryList,
-    DIDGetRecoveryListResponse,
     DIDGetWalletName,
     DIDGetWalletNameResponse,
     DIDMessageSpend,
@@ -146,8 +158,6 @@ from chia.wallet.wallet_request_types import (
     DIDTransferDIDResponse,
     DIDUpdateMetadata,
     DIDUpdateMetadataResponse,
-    DIDUpdateRecoveryIDs,
-    DIDUpdateRecoveryIDsResponse,
     DLDeleteMirror,
     DLDeleteMirrorResponse,
     DLGetMirrors,
@@ -170,20 +180,46 @@ from chia.wallet.wallet_request_types import (
     Empty,
     ExecuteSigningInstructions,
     ExecuteSigningInstructionsResponse,
+    ExtendDerivationIndex,
+    ExtendDerivationIndexResponse,
     GatherSigningInfo,
     GatherSigningInfoResponse,
     GenerateMnemonicResponse,
+    GetCATListResponse,
+    GetCoinRecordsByNames,
+    GetCoinRecordsByNamesResponse,
+    GetCurrentDerivationIndexResponse,
     GetHeightInfoResponse,
     GetLoggedInFingerprintResponse,
+    GetNextAddress,
+    GetNextAddressResponse,
     GetNotifications,
     GetNotificationsResponse,
+    GetOffersCountResponse,
     GetPrivateKey,
     GetPrivateKeyFormat,
     GetPrivateKeyResponse,
     GetPublicKeysResponse,
+    GetSpendableCoins,
+    GetSpendableCoinsResponse,
+    GetStrayCATsResponse,
     GetSyncStatusResponse,
     GetTimestampForHeight,
     GetTimestampForHeightResponse,
+    GetTransaction,
+    GetTransactionCount,
+    GetTransactionCountResponse,
+    GetTransactionMemo,
+    GetTransactionMemoResponse,
+    GetTransactionResponse,
+    GetTransactions,
+    GetTransactionsResponse,
+    GetWalletBalance,
+    GetWalletBalanceResponse,
+    GetWalletBalances,
+    GetWalletBalancesResponse,
+    GetWallets,
+    GetWalletsResponse,
     LogIn,
     LogInResponse,
     NFTAddURI,
@@ -226,11 +262,25 @@ from chia.wallet.wallet_request_types import (
     PWSelfPoolResponse,
     PWStatus,
     PWStatusResponse,
+    SelectCoins,
+    SelectCoinsResponse,
+    SendNotification,
+    SendNotificationResponse,
+    SendTransaction,
+    SendTransactionResponse,
     SetWalletResyncOnStartup,
+    SignMessageByAddress,
+    SignMessageByAddressResponse,
+    SignMessageByID,
+    SignMessageByIDResponse,
+    SpendClawbackCoins,
+    SpendClawbackCoinsResponse,
     SplitCoins,
     SplitCoinsResponse,
+    StrayCAT,
     SubmitTransactions,
     SubmitTransactionsResponse,
+    TransactionRecordWithMetadata,
     VCAddProofs,
     VCGet,
     VCGetList,
@@ -247,6 +297,9 @@ from chia.wallet.wallet_request_types import (
     VCRevokeResponse,
     VCSpend,
     VCSpendResponse,
+    VerifySignature,
+    VerifySignatureResponse,
+    WalletInfoResponse,
 )
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
@@ -343,10 +396,7 @@ def tx_endpoint(
             else:
                 response["unsigned_transactions"] = [tx.to_json_dict() for tx in unsigned_txs]
 
-            response["transactions"] = [
-                TransactionRecord.to_json_dict_convenience(tx, self.service.config)
-                for tx in action_scope.side_effects.transactions
-            ]
+            response["transactions"] = [tx.to_json_dict() for tx in action_scope.side_effects.transactions]
 
             # Some backwards compatibility code here because transaction information being returned was not uniform
             # until the "transactions" key was applied to all of them. Unfortunately, since .add_pending_transactions
@@ -450,6 +500,7 @@ REPLACEABLE_TRANSACTION_RECORD = TransactionRecord(
     confirmed_at_height=uint32(0),
     created_at_time=uint64(0),
     to_puzzle_hash=bytes32.zeros,
+    to_address=encode_puzzle_hash(bytes32.zeros, "replace"),
     amount=uint64(0),
     fee_amount=uint64(0),
     confirmed=False,
@@ -462,7 +513,7 @@ REPLACEABLE_TRANSACTION_RECORD = TransactionRecord(
     trade_id=None,
     type=uint32(0),
     name=bytes32.zeros,
-    memos=[],
+    memos={},
     valid_times=ConditionValidTimes(),
 )
 
@@ -553,15 +604,10 @@ class WalletRpcApi:
             # DID Wallet
             "/did_set_wallet_name": self.did_set_wallet_name,
             "/did_get_wallet_name": self.did_get_wallet_name,
-            "/did_update_recovery_ids": self.did_update_recovery_ids,
             "/did_update_metadata": self.did_update_metadata,
             "/did_get_pubkey": self.did_get_pubkey,
             "/did_get_did": self.did_get_did,
-            "/did_recovery_spend": self.did_recovery_spend,
-            "/did_get_recovery_list": self.did_get_recovery_list,
             "/did_get_metadata": self.did_get_metadata,
-            "/did_create_attest": self.did_create_attest,
-            "/did_get_information_needed_for_recovery": self.did_get_information_needed_for_recovery,
             "/did_get_current_coin_info": self.did_get_current_coin_info,
             "/did_create_backup_file": self.did_create_backup_file,
             "/did_transfer_did": self.did_transfer_did,
@@ -766,7 +812,7 @@ class WalletRpcApi:
     async def add_key(self, request: AddKey) -> AddKeyResponse:
         # Adding a key from 24 word mnemonic
         try:
-            sk = await self.service.keychain_proxy.add_key(" ".join(request.mnemonic))
+            sk = await self.service.keychain_proxy.add_key(" ".join(request.mnemonic), label=request.label)
         except KeyError as e:
             raise ValueError(f"The word '{e.args[0]}' is incorrect.")
 
@@ -1017,39 +1063,40 @@ class WalletRpcApi:
     # Wallet Management
     ##########################################################################################
 
-    async def get_wallets(self, request: dict[str, Any]) -> EndpointResult:
-        include_data: bool = request.get("include_data", True)
+    @marshal
+    async def get_wallets(self, request: GetWallets) -> GetWalletsResponse:
         wallet_type: Optional[WalletType] = None
-        if "type" in request:
-            wallet_type = WalletType(request["type"])
+        if request.type is not None:
+            wallet_type = WalletType(request.type)
 
         wallets: list[WalletInfo] = await self.service.wallet_state_manager.get_all_wallet_info_entries(wallet_type)
-        if not include_data:
-            result: list[WalletInfo] = []
-            for wallet in wallets:
-                result.append(WalletInfo(wallet.id, wallet.name, wallet.type, ""))
-            wallets = result
-        response: EndpointResult = {"wallets": wallets}
-        if include_data:
-            response = {
-                "wallets": [
-                    (
-                        wallet
-                        if wallet.type != WalletType.CRCAT
-                        else {
-                            **wallet.to_json_dict(),
-                            "authorized_providers": [
-                                p.hex() for p in CRCATInfo.from_bytes(bytes.fromhex(wallet.data)).authorized_providers
-                            ],
-                            "flags_needed": CRCATInfo.from_bytes(bytes.fromhex(wallet.data)).proofs_checker.flags,
-                        }
-                    )
-                    for wallet in response["wallets"]
-                ]
-            }
-        if self.service.logged_in_fingerprint is not None:
-            response["fingerprint"] = self.service.logged_in_fingerprint
-        return response
+        wallet_infos: list[WalletInfoResponse] = []
+        for wallet in wallets:
+            if request.include_data:
+                data = wallet.data
+            else:
+                data = ""
+
+            if request.include_data and WalletType(wallet.type) is WalletType.CRCAT:
+                crcat_info = CRCATInfo.from_bytes(bytes.fromhex(wallet.data))
+                authorized_providers = crcat_info.authorized_providers
+                proofs_checker_flags = crcat_info.proofs_checker.flags
+            else:
+                authorized_providers = []
+                proofs_checker_flags = []
+
+            wallet_infos.append(
+                WalletInfoResponse(
+                    wallet.id,
+                    wallet.name,
+                    wallet.type,
+                    data,
+                    authorized_providers,
+                    proofs_checker_flags,
+                )
+            )
+
+        return GetWalletsResponse(wallet_infos, uint32.construct_optional(self.service.logged_in_fingerprint))
 
     @tx_endpoint(push=True)
     async def create_new_wallet(
@@ -1108,19 +1155,15 @@ class WalletRpcApi:
 
         elif request["wallet_type"] == "did_wallet":
             if request["did_type"] == "new":
-                backup_dids = []
-                num_needed = 0
-                for d in request["backup_dids"]:
-                    backup_dids.append(decode_puzzle_hash(d))
-                if len(backup_dids) > 0:
-                    num_needed = uint64(request["num_of_backup_ids_needed"])
+                if "backup_dids" in request and request["backup_dids"] != []:
+                    raise ValueError("Recovery options are no longer supported. `backup_dids` cannot be set.")
                 metadata: dict[str, str] = {}
                 if "metadata" in request:
                     if type(request["metadata"]) is dict:
                         metadata = request["metadata"]
 
                 async with self.service.wallet_state_manager.lock:
-                    did_wallet_name: str = request.get("wallet_name", None)
+                    did_wallet_name: Optional[str] = request.get("wallet_name", None)
                     if did_wallet_name is not None:
                         did_wallet_name = did_wallet_name.strip()
                     did_wallet: DIDWallet = await DIDWallet.create_new_did_wallet(
@@ -1128,8 +1171,6 @@ class WalletRpcApi:
                         main_wallet,
                         uint64(request["amount"]),
                         action_scope,
-                        backup_dids,
-                        uint64(num_needed),
                         metadata,
                         did_wallet_name,
                         uint64(request.get("fee", 0)),
@@ -1278,7 +1319,7 @@ class WalletRpcApi:
     # Wallet
     ##########################################################################################
 
-    async def _get_wallet_balance(self, wallet_id: uint32) -> dict[str, Any]:
+    async def _get_wallet_balance(self, wallet_id: uint32) -> BalanceResponse:
         wallet = self.service.wallet_state_manager.wallets[wallet_id]
         balance = await self.service.get_balance(wallet_id)
         wallet_balance = balance.to_json_dict()
@@ -1293,36 +1334,38 @@ class WalletRpcApi:
                 assert isinstance(wallet, CRCATWallet)
                 wallet_balance["pending_approval_balance"] = await wallet.get_pending_approval_balance()
 
-        return wallet_balance
+        return BalanceResponse.from_json_dict(wallet_balance)
 
-    async def get_wallet_balance(self, request: dict[str, Any]) -> EndpointResult:
-        wallet_id = uint32(int(request["wallet_id"]))
-        wallet_balance = await self._get_wallet_balance(wallet_id)
-        return {"wallet_balance": wallet_balance}
+    @marshal
+    async def get_wallet_balance(self, request: GetWalletBalance) -> GetWalletBalanceResponse:
+        return GetWalletBalanceResponse(await self._get_wallet_balance(request.wallet_id))
 
-    async def get_wallet_balances(self, request: dict[str, Any]) -> EndpointResult:
-        try:
-            wallet_ids: list[uint32] = [uint32(int(wallet_id)) for wallet_id in request["wallet_ids"]]
-        except (TypeError, KeyError):
+    @marshal
+    async def get_wallet_balances(self, request: GetWalletBalances) -> GetWalletBalancesResponse:
+        if request.wallet_ids is not None:
+            wallet_ids = request.wallet_ids
+        else:
             wallet_ids = list(self.service.wallet_state_manager.wallets.keys())
-        wallet_balances: dict[uint32, dict[str, Any]] = {}
-        for wallet_id in wallet_ids:
-            wallet_balances[wallet_id] = await self._get_wallet_balance(wallet_id)
-        return {"wallet_balances": wallet_balances}
+        return GetWalletBalancesResponse(
+            {wallet_id: await self._get_wallet_balance(wallet_id) for wallet_id in wallet_ids}
+        )
 
-    async def get_transaction(self, request: dict[str, Any]) -> EndpointResult:
-        transaction_id: bytes32 = bytes32.from_hexstr(request["transaction_id"])
-        tr: Optional[TransactionRecord] = await self.service.wallet_state_manager.get_transaction(transaction_id)
+    @marshal
+    async def get_transaction(self, request: GetTransaction) -> GetTransactionResponse:
+        tr: Optional[TransactionRecord] = await self.service.wallet_state_manager.get_transaction(
+            request.transaction_id
+        )
         if tr is None:
-            raise ValueError(f"Transaction 0x{transaction_id.hex()} not found")
+            raise ValueError(f"Transaction 0x{request.transaction_id.hex()} not found")
 
-        return {
-            "transaction": (await self._convert_tx_puzzle_hash(tr)).to_json_dict_convenience(self.service.config),
-            "transaction_id": tr.name,
-        }
+        return GetTransactionResponse(
+            await self._convert_tx_puzzle_hash(tr),
+            tr.name,
+        )
 
-    async def get_transaction_memo(self, request: dict[str, Any]) -> EndpointResult:
-        transaction_id: bytes32 = bytes32.from_hexstr(request["transaction_id"])
+    @marshal
+    async def get_transaction_memo(self, request: GetTransactionMemo) -> GetTransactionMemoResponse:
+        transaction_id: bytes32 = request.transaction_id
         tr: Optional[TransactionRecord] = await self.service.wallet_state_manager.get_transaction(transaction_id)
         if tr is None:
             raise ValueError(f"Transaction 0x{transaction_id.hex()} not found")
@@ -1340,12 +1383,7 @@ class WalletRpcApi:
             else:
                 raise ValueError(f"Transaction 0x{transaction_id.hex()} doesn't have any coin spend.")
         assert tr.spend_bundle is not None
-        memos: dict[bytes32, list[bytes]] = compute_memos(tr.spend_bundle)
-        response = {}
-        # Convert to hex string
-        for coin_id, memo_list in memos.items():
-            response[coin_id.hex()] = [memo.hex() for memo in memo_list]
-        return {transaction_id.hex(): response}
+        return GetTransactionMemoResponse({transaction_id: compute_memos(tr.spend_bundle)})
 
     @tx_endpoint(push=False)
     @marshal
@@ -1502,36 +1540,26 @@ class WalletRpcApi:
 
         return CombineCoinsResponse([], [])  # tx_endpoint will take care to fill this out
 
-    async def get_transactions(self, request: dict[str, Any]) -> EndpointResult:
-        wallet_id = int(request["wallet_id"])
-
-        start = request.get("start", 0)
-        end = request.get("end", 50)
-        sort_key = request.get("sort_key", None)
-        reverse = request.get("reverse", False)
-
-        to_address = request.get("to_address", None)
+    @marshal
+    async def get_transactions(self, request: GetTransactions) -> GetTransactionsResponse:
         to_puzzle_hash: Optional[bytes32] = None
-        if to_address is not None:
-            to_puzzle_hash = decode_puzzle_hash(to_address)
-        type_filter = None
-        if "type_filter" in request:
-            type_filter = TransactionTypeFilter.from_json_dict(request["type_filter"])
+        if request.to_address is not None:
+            to_puzzle_hash = decode_puzzle_hash(request.to_address)
 
         transactions = await self.service.wallet_state_manager.tx_store.get_transactions_between(
-            wallet_id,
-            start,
-            end,
-            sort_key=sort_key,
-            reverse=reverse,
+            wallet_id=request.wallet_id,
+            start=uint16(0) if request.start is None else request.start,
+            end=uint16(50) if request.end is None else request.end,
+            sort_key=request.sort_key,
+            reverse=request.reverse,
             to_puzzle_hash=to_puzzle_hash,
-            type_filter=type_filter,
-            confirmed=request.get("confirmed", None),
+            type_filter=request.type_filter,
+            confirmed=request.confirmed,
         )
         tx_list = []
         # Format for clawback transactions
         for tr in transactions:
-            tx = (await self._convert_tx_puzzle_hash(tr)).to_json_dict_convenience(self.service.config)
+            tx = (await self._convert_tx_puzzle_hash(tr)).to_json_dict()
             tx_list.append(tx)
             if tx["type"] not in CLAWBACK_INCOMING_TRANSACTION_TYPES:
                 continue
@@ -1549,98 +1577,79 @@ class WalletRpcApi:
                 continue
             tx["metadata"]["coin_id"] = coin.name().hex()
             tx["metadata"]["spent"] = record.spent
-        return {
-            "transactions": tx_list,
-            "wallet_id": wallet_id,
-        }
+        return GetTransactionsResponse(
+            transactions=[TransactionRecordWithMetadata.from_json_dict(tx) for tx in tx_list],
+            wallet_id=request.wallet_id,
+        )
 
-    async def get_transaction_count(self, request: dict[str, Any]) -> EndpointResult:
-        wallet_id = int(request["wallet_id"])
-        type_filter = None
-        if "type_filter" in request:
-            type_filter = TransactionTypeFilter.from_json_dict(request["type_filter"])
+    @marshal
+    async def get_transaction_count(self, request: GetTransactionCount) -> GetTransactionCountResponse:
         count = await self.service.wallet_state_manager.tx_store.get_transaction_count_for_wallet(
-            wallet_id, confirmed=request.get("confirmed", None), type_filter=type_filter
+            request.wallet_id, confirmed=request.confirmed, type_filter=request.type_filter
+        )
+        return GetTransactionCountResponse(
+            request.wallet_id,
+            uint16(count),
         )
-        return {
-            "count": count,
-            "wallet_id": wallet_id,
-        }
 
-    async def get_next_address(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_next_address(self, request: GetNextAddress) -> GetNextAddressResponse:
         """
         Returns a new address
         """
-        if request["new_address"] is True:
-            create_new = True
-        else:
-            create_new = False
-        wallet_id = uint32(int(request["wallet_id"]))
-        wallet = self.service.wallet_state_manager.wallets[wallet_id]
+        wallet = self.service.wallet_state_manager.wallets[request.wallet_id]
         selected = self.service.config["selected_network"]
         prefix = self.service.config["network_overrides"]["config"][selected]["address_prefix"]
         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)
+                DEFAULT_TX_CONFIG, push=request.save_derivations
             ) as action_scope:
                 raw_puzzle_hash = await action_scope.get_puzzle_hash(
-                    self.service.wallet_state_manager, override_reuse_puzhash_with=not create_new
+                    self.service.wallet_state_manager, override_reuse_puzhash_with=not request.new_address
                 )
             address = encode_puzzle_hash(raw_puzzle_hash, prefix)
         else:
             raise ValueError(f"Wallet type {wallet.type()} cannot create puzzle hashes")
 
-        return {
-            "wallet_id": wallet_id,
-            "address": address,
-        }
+        return GetNextAddressResponse(
+            request.wallet_id,
+            address,
+        )
 
     @tx_endpoint(push=True)
+    @marshal
     async def send_transaction(
         self,
-        request: dict[str, Any],
+        request: SendTransaction,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> SendTransactionResponse:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before sending transactions")
 
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=Wallet)
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=Wallet)
 
         # TODO: Add support for multiple puzhash/amount/memo sets
-        if not isinstance(request["amount"], int) or not isinstance(request["fee"], int):
-            raise ValueError("An integer amount or fee is required (too many decimals)")
-        amount: uint64 = uint64(request["amount"])
-        address = request["address"]
         selected_network = self.service.config["selected_network"]
         expected_prefix = self.service.config["network_overrides"]["config"][selected_network]["address_prefix"]
-        if address[0 : len(expected_prefix)] != expected_prefix:
+        if request.address[0 : len(expected_prefix)] != expected_prefix:
             raise ValueError("Unexpected Address Prefix")
-        puzzle_hash: bytes32 = decode_puzzle_hash(address)
-
-        memos: list[bytes] = []
-        if "memos" in request:
-            memos = [mem.encode("utf-8") for mem in request["memos"]]
-
-        fee: uint64 = uint64(request.get("fee", 0))
 
         await wallet.generate_signed_transaction(
-            [amount],
-            [puzzle_hash],
+            [request.amount],
+            [decode_puzzle_hash(request.address)],
             action_scope,
-            fee,
-            memos=[memos],
-            puzzle_decorator_override=request.get("puzzle_decorator", None),
+            request.fee,
+            memos=[[mem.encode("utf-8") for mem in request.memos]],
+            puzzle_decorator_override=[request.puzzle_decorator[0].to_json_dict()]
+            if request.puzzle_decorator is not None
+            else None,
             extra_conditions=extra_conditions,
         )
 
         # Transaction may not have been included in the mempool yet. Use get_transaction to check.
-        return {
-            "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
-        }
+        # tx_endpoint will take care of the default values here
+        return SendTransactionResponse([], [], transaction=REPLACEABLE_TRANSACTION_RECORD, transaction_id=bytes32.zeros)
 
     async def send_transaction_multi(self, request: dict[str, Any]) -> EndpointResult:
         if await self.service.wallet_state_manager.synced() is False:
@@ -1667,18 +1676,19 @@ class WalletRpcApi:
         # Transaction may not have been included in the mempool yet. Use get_transaction to check.
         return {
             "transaction": transaction,
-            "transaction_id": TransactionRecord.from_json_dict_convenience(transaction).name,
+            "transaction_id": TransactionRecord.from_json_dict(transaction).name,
             "transactions": transactions,
             "unsigned_transactions": response["unsigned_transactions"],
         }
 
     @tx_endpoint(push=True, merge_spends=False)
+    @marshal
     async def spend_clawback_coins(
         self,
-        request: dict[str, Any],
+        request: SpendClawbackCoins,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> SpendClawbackCoinsResponse:
         """Spend clawback coins that were sent (to claw them back) or received (to claim them).
 
         :param coin_ids: list of coin ids to be spent
@@ -1686,21 +1696,19 @@ class WalletRpcApi:
         :param fee: transaction fee in mojos
         :return:
         """
-        if "coin_ids" not in request:
-            raise ValueError("Coin IDs are required.")
-        coin_ids: list[bytes32] = [bytes32.from_hexstr(coin) for coin in request["coin_ids"]]
-        tx_fee: uint64 = uint64(request.get("fee", 0))
         # Get inner puzzle
         coin_records = await self.service.wallet_state_manager.coin_store.get_coin_records(
-            coin_id_filter=HashFilter.include(coin_ids),
+            coin_id_filter=HashFilter.include(request.coin_ids),
             coin_type=CoinType.CLAWBACK,
             wallet_type=WalletType.STANDARD_WALLET,
             spent_range=UInt32Range(stop=uint32(0)),
         )
 
         coins: dict[Coin, ClawbackMetadata] = {}
-        batch_size = request.get(
-            "batch_size", self.service.wallet_state_manager.config.get("auto_claim", {}).get("batch_size", 50)
+        batch_size = (
+            request.batch_size
+            if request.batch_size is not None
+            else self.service.wallet_state_manager.config.get("auto_claim", {}).get("batch_size", 50)
         )
         for coin_id, coin_record in coin_records.coin_id_to_record.items():
             try:
@@ -1710,9 +1718,9 @@ class WalletRpcApi:
                 if len(coins) >= batch_size:
                     await self.service.wallet_state_manager.spend_clawback_coins(
                         coins,
-                        tx_fee,
+                        request.fee,
                         action_scope,
-                        request.get("force", False),
+                        request.force,
                         extra_conditions=extra_conditions,
                     )
                     coins = {}
@@ -1721,101 +1729,87 @@ class WalletRpcApi:
         if len(coins) > 0:
             await self.service.wallet_state_manager.spend_clawback_coins(
                 coins,
-                tx_fee,
+                request.fee,
                 action_scope,
-                request.get("force", False),
+                request.force,
                 extra_conditions=extra_conditions,
             )
 
-        return {
-            "success": True,
-            "transaction_ids": None,  # tx_endpoint wrapper will take care of this
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-        }
+        # tx_endpoint will fill in the default values here
+        return SpendClawbackCoinsResponse([], [], transaction_ids=[])
 
-    async def delete_unconfirmed_transactions(self, request: dict[str, Any]) -> EndpointResult:
-        wallet_id = uint32(request["wallet_id"])
-        if wallet_id not in self.service.wallet_state_manager.wallets:
-            raise ValueError(f"Wallet id {wallet_id} does not exist")
+    @marshal
+    async def delete_unconfirmed_transactions(self, request: DeleteUnconfirmedTransactions) -> Empty:
+        if request.wallet_id not in self.service.wallet_state_manager.wallets:
+            raise ValueError(f"Wallet id {request.wallet_id} does not exist")
         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.db_wrapper.writer():
-            await self.service.wallet_state_manager.tx_store.delete_unconfirmed_transactions(wallet_id)
-            wallet = self.service.wallet_state_manager.wallets[wallet_id]
+            await self.service.wallet_state_manager.tx_store.delete_unconfirmed_transactions(request.wallet_id)
+            wallet = self.service.wallet_state_manager.wallets[request.wallet_id]
             if wallet.type() == WalletType.POOLING_WALLET.value:
                 assert isinstance(wallet, PoolWallet)
                 wallet.target_state = None
-            return {}
+            return Empty()
 
+    @marshal
     async def select_coins(
         self,
-        request: dict[str, Any],
-    ) -> EndpointResult:
+        request: SelectCoins,
+    ) -> SelectCoinsResponse:
         assert self.service.logged_in_fingerprint is not None
-        tx_config_loader: TXConfigLoader = TXConfigLoader.from_json_dict(request)
 
         # Some backwards compat fill-ins
-        if tx_config_loader.excluded_coin_ids is None:
-            excluded_coins: Optional[list[dict[str, Any]]] = request.get("excluded_coins", request.get("exclude_coins"))
-            if excluded_coins is not None:
-                tx_config_loader = tx_config_loader.override(
-                    excluded_coin_ids=[Coin.from_json_dict(c).name() for c in excluded_coins],
+        if request.excluded_coin_ids is None:
+            if request.exclude_coins is not None:
+                request = request.override(
+                    excluded_coin_ids=[c.name() for c in request.exclude_coins],
+                    exclude_coins=None,
                 )
 
-        tx_config: TXConfig = tx_config_loader.autofill(
+        # don't love this snippet of code
+        # but I think action scopes need to accept CoinSelectionConfigs
+        # instead of solely TXConfigs in order for this to be less ugly
+        autofilled_cs_config = request.autofill(
             constants=self.service.wallet_state_manager.constants,
         )
+        tx_config = DEFAULT_TX_CONFIG.override(
+            **{
+                field.name: getattr(autofilled_cs_config, field.name)
+                for field in dataclasses.fields(autofilled_cs_config)
+            }
+        )
 
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before selecting coins")
 
-        amount = uint64(request["amount"])
-        wallet_id = uint32(request["wallet_id"])
-
-        wallet = self.service.wallet_state_manager.wallets[wallet_id]
+        wallet = self.service.wallet_state_manager.wallets[request.wallet_id]
         async with self.service.wallet_state_manager.new_action_scope(tx_config, push=False) as action_scope:
-            selected_coins = await wallet.select_coins(amount, action_scope)
+            selected_coins = await wallet.select_coins(request.amount, action_scope)
 
-        return {"coins": [coin.to_json_dict() for coin in selected_coins]}
+        return SelectCoinsResponse(coins=list(selected_coins))
 
-    async def get_spendable_coins(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_spendable_coins(self, request: GetSpendableCoins) -> GetSpendableCoinsResponse:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before getting all coins")
 
-        wallet_id = uint32(request["wallet_id"])
-        min_coin_amount = uint64(request.get("min_coin_amount", 0))
-        max_coin_amount: uint64 = uint64(request.get("max_coin_amount", 0))
-        if max_coin_amount == 0:
-            max_coin_amount = uint64(self.service.wallet_state_manager.constants.MAX_COIN_AMOUNT)
-        excluded_coin_amounts: Optional[list[uint64]] = request.get("excluded_coin_amounts")
-        if excluded_coin_amounts is not None:
-            excluded_coin_amounts = [uint64(a) for a in excluded_coin_amounts]
-        else:
-            excluded_coin_amounts = []
-        excluded_coins_input: Optional[dict[str, dict[str, Any]]] = request.get("excluded_coins")
-        if excluded_coins_input is not None:
-            excluded_coins = [Coin.from_json_dict(json_coin) for json_coin in excluded_coins_input.values()]
-        else:
-            excluded_coins = []
-        excluded_coin_ids_input: Optional[list[str]] = request.get("excluded_coin_ids")
-        if excluded_coin_ids_input is not None:
-            excluded_coin_ids = [bytes32.from_hexstr(hex_id) for hex_id in excluded_coin_ids_input]
-        else:
-            excluded_coin_ids = []
         state_mgr = self.service.wallet_state_manager
-        wallet = state_mgr.wallets[wallet_id]
+        wallet = state_mgr.wallets[request.wallet_id]
         async with state_mgr.lock:
-            all_coin_records = await state_mgr.coin_store.get_unspent_coins_for_wallet(wallet_id)
+            all_coin_records = await state_mgr.coin_store.get_unspent_coins_for_wallet(request.wallet_id)
             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:
-                spendable_coins = list(await state_mgr.get_spendable_coins_for_wallet(wallet_id, all_coin_records))
+                spendable_coins = list(
+                    await state_mgr.get_spendable_coins_for_wallet(request.wallet_id, all_coin_records)
+                )
 
             # Now we get the unconfirmed transactions and manually derive the additions and removals.
             unconfirmed_transactions: list[TransactionRecord] = await state_mgr.tx_store.get_unconfirmed_for_wallet(
-                wallet_id
+                request.wallet_id
             )
             unconfirmed_removal_ids: dict[bytes32, uint64] = {
                 coin.name(): transaction.created_at_time
@@ -1826,54 +1820,54 @@ class WalletRpcApi:
                 coin
                 for transaction in unconfirmed_transactions
                 for coin in transaction.additions
-                if await state_mgr.does_coin_belong_to_wallet(coin, wallet_id)
+                if await state_mgr.does_coin_belong_to_wallet(coin, request.wallet_id)
             ]
             valid_spendable_cr: list[CoinRecord] = []
             unconfirmed_removals: list[CoinRecord] = []
             for coin_record in all_coin_records:
                 if coin_record.name() in unconfirmed_removal_ids:
                     unconfirmed_removals.append(coin_record.to_coin_record(unconfirmed_removal_ids[coin_record.name()]))
+
+            cs_config = request.autofill(constants=self.service.wallet_state_manager.constants)
             for coin_record in spendable_coins:  # remove all the unconfirmed coins, exclude coins and dust.
                 if coin_record.name() in unconfirmed_removal_ids:
                     continue
-                if coin_record.coin in excluded_coins:
+                if coin_record.coin.name() in cs_config.excluded_coin_ids:
                     continue
-                if coin_record.name() in excluded_coin_ids:
-                    continue
-                if coin_record.coin.amount < min_coin_amount or coin_record.coin.amount > max_coin_amount:
+                if (coin_record.coin.amount < cs_config.min_coin_amount) or (
+                    coin_record.coin.amount > cs_config.max_coin_amount
+                ):
                     continue
-                if coin_record.coin.amount in excluded_coin_amounts:
+                if coin_record.coin.amount in cs_config.excluded_coin_amounts:
                     continue
                 c_r = await state_mgr.get_coin_record_by_wallet_record(coin_record)
                 assert c_r is not None and c_r.coin == coin_record.coin  # this should never happen
                 valid_spendable_cr.append(c_r)
 
-        return {
-            "confirmed_records": [cr.to_json_dict() for cr in valid_spendable_cr],
-            "unconfirmed_removals": [cr.to_json_dict() for cr in unconfirmed_removals],
-            "unconfirmed_additions": [coin.to_json_dict() for coin in unconfirmed_additions],
-        }
+        return GetSpendableCoinsResponse(
+            confirmed_records=valid_spendable_cr,
+            unconfirmed_removals=unconfirmed_removals,
+            unconfirmed_additions=unconfirmed_additions,
+        )
 
-    async def get_coin_records_by_names(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_coin_records_by_names(self, request: GetCoinRecordsByNames) -> GetCoinRecordsByNamesResponse:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before finding coin information")
 
-        if "names" not in request:
-            raise ValueError("Names not in request")
-        coin_ids = [bytes32.from_hexstr(name) for name in request["names"]]
         kwargs: dict[str, Any] = {
-            "coin_id_filter": HashFilter.include(coin_ids),
+            "coin_id_filter": HashFilter.include(request.names),
         }
 
         confirmed_range = UInt32Range()
-        if "start_height" in request:
-            confirmed_range = dataclasses.replace(confirmed_range, start=uint32(request["start_height"]))
-        if "end_height" in request:
-            confirmed_range = dataclasses.replace(confirmed_range, stop=uint32(request["end_height"]))
+        if request.start_height is not None:
+            confirmed_range = dataclasses.replace(confirmed_range, start=request.start_height)
+        if request.end_height is not None:
+            confirmed_range = dataclasses.replace(confirmed_range, stop=request.end_height)
         if confirmed_range != UInt32Range():
             kwargs["confirmed_range"] = confirmed_range
 
-        if "include_spent_coins" in request and not str2bool(request["include_spent_coins"]):
+        if not request.include_spent_coins:
             kwargs["spent_range"] = unspent_range
 
         async with self.service.wallet_state_manager.lock:
@@ -1881,33 +1875,30 @@ class WalletRpcApi:
                 **kwargs
             )
             missed_coins: list[str] = [
-                "0x" + c_id.hex() for c_id in coin_ids if c_id not in [cr.name for cr in coin_records]
+                "0x" + c_id.hex() for c_id in request.names if c_id not in [cr.name for cr in coin_records]
             ]
             if missed_coins:
                 raise ValueError(f"Coin ID's: {missed_coins} not found.")
 
-        return {"coin_records": [cr.to_json_dict() for cr in coin_records]}
+        return GetCoinRecordsByNamesResponse(coin_records)
 
-    async def get_current_derivation_index(self, request: dict[str, Any]) -> dict[str, Any]:
+    @marshal
+    async def get_current_derivation_index(self, request: Empty) -> GetCurrentDerivationIndexResponse:
         assert self.service.wallet_state_manager is not None
 
         index: Optional[uint32] = await self.service.wallet_state_manager.puzzle_store.get_last_derivation_path()
 
-        return {"success": True, "index": index}
+        return GetCurrentDerivationIndexResponse(index)
 
-    async def extend_derivation_index(self, request: dict[str, Any]) -> dict[str, Any]:
+    @marshal
+    async def extend_derivation_index(self, request: ExtendDerivationIndex) -> ExtendDerivationIndexResponse:
         assert self.service.wallet_state_manager is not None
 
-        # Require a new max derivation index
-        if "index" not in request:
-            raise ValueError("Derivation index is required")
-
         # Require that the wallet is fully synced
         synced = await self.service.wallet_state_manager.synced()
         if synced is False:
             raise ValueError("Wallet needs to be fully synced before extending derivation index")
 
-        index = uint32(request["index"])
         current: Optional[uint32] = await self.service.wallet_state_manager.puzzle_store.get_last_derivation_path()
 
         # Additional sanity check that the wallet is synced
@@ -1915,10 +1906,10 @@ class WalletRpcApi:
             raise ValueError("No current derivation record found, unable to extend index")
 
         # Require that the new index is greater than the current index
-        if index <= current:
+        if request.index <= current:
             raise ValueError(f"New derivation index must be greater than current index: {current}")
 
-        if index - current > MAX_DERIVATION_INDEX_DELTA:
+        if request.index - current > MAX_DERIVATION_INDEX_DELTA:
             raise ValueError(
                 "Too many derivations requested. "
                 f"Use a derivation index less than {current + MAX_DERIVATION_INDEX_DELTA + 1}"
@@ -1928,14 +1919,13 @@ class WalletRpcApi:
         # to preserve the current last used index, so we call create_more_puzzle_hashes with
         # mark_existing_as_used=False
         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
+            from_zero=False, mark_existing_as_used=False, up_to_index=request.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
+        updated_index = await self.service.wallet_state_manager.puzzle_store.get_last_derivation_path()
 
-        return {"success": True, "index": updated_index}
+        return ExtendDerivationIndexResponse(updated_index)
 
     @marshal
     async def get_notifications(self, request: GetNotifications) -> GetNotificationsResponse:
@@ -1954,145 +1944,132 @@ class WalletRpcApi:
 
         return GetNotificationsResponse(notifications)
 
-    async def delete_notifications(self, request: dict[str, Any]) -> EndpointResult:
-        ids: Optional[list[str]] = request.get("ids", None)
-        if ids is None:
+    @marshal
+    async def delete_notifications(self, request: DeleteNotifications) -> Empty:
+        if request.ids is None:
             await self.service.wallet_state_manager.notification_manager.notification_store.delete_all_notifications()
         else:
             await self.service.wallet_state_manager.notification_manager.notification_store.delete_notifications(
-                [bytes32.from_hexstr(id) for id in ids]
+                request.ids
             )
 
-        return {}
+        return Empty()
 
     @tx_endpoint(push=True)
+    @marshal
     async def send_notification(
         self,
-        request: dict[str, Any],
+        request: SendNotification,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> SendNotificationResponse:
         await self.service.wallet_state_manager.notification_manager.send_new_notification(
-            bytes32.from_hexstr(request["target"]),
-            bytes.fromhex(request["message"]),
-            uint64(request["amount"]),
+            request.target,
+            request.message,
+            request.amount,
             action_scope,
-            request.get("fee", uint64(0)),
+            request.fee,
             extra_conditions=extra_conditions,
         )
 
-        return {"tx": None, "transactions": None}  # tx_endpoint wrapper will take care of this
+        # tx_endpoint will take care of these default values
+        return SendNotificationResponse([], [], tx=REPLACEABLE_TRANSACTION_RECORD)
 
-    async def verify_signature(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def verify_signature(self, request: VerifySignature) -> VerifySignatureResponse:
         """
         Given a public key, message and signature, verify if it is valid.
         :param request:
         :return:
         """
-        input_message: str = request["message"]
-        signing_mode_str: Optional[str] = request.get("signing_mode")
         # Default to BLS_MESSAGE_AUGMENTATION_HEX_INPUT as this RPC was originally designed to verify
         # signatures made by `chia keys sign`, which uses BLS_MESSAGE_AUGMENTATION_HEX_INPUT
-        if signing_mode_str is None:
+        if request.signing_mode is None:
             signing_mode = SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT
         else:
             try:
-                signing_mode = SigningMode(signing_mode_str)
+                signing_mode = SigningMode(request.signing_mode)
             except ValueError:
-                raise ValueError(f"Invalid signing mode: {signing_mode_str!r}")
+                raise ValueError(f"Invalid signing mode: {request.signing_mode!r}")
 
         if signing_mode in {SigningMode.CHIP_0002, SigningMode.CHIP_0002_P2_DELEGATED_CONDITIONS}:
             # CHIP-0002 message signatures are made over the tree hash of:
             #   ("Chia Signed Message", message)
-            message_to_verify: bytes = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, input_message)).get_tree_hash()
+            message_to_verify: bytes = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, request.message)).get_tree_hash()
         elif signing_mode == SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT:
             # Message is expected to be a hex string
-            message_to_verify = hexstr_to_bytes(input_message)
+            message_to_verify = hexstr_to_bytes(request.message)
         elif signing_mode == SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT:
             # Message is expected to be a UTF-8 string
-            message_to_verify = bytes(input_message, "utf-8")
+            message_to_verify = bytes(request.message, "utf-8")
         else:
-            raise ValueError(f"Unsupported signing mode: {signing_mode_str!r}")
+            raise ValueError(f"Unsupported signing mode: {request.signing_mode!r}")
 
         # Verify using the BLS message augmentation scheme
         is_valid = AugSchemeMPL.verify(
-            G1Element.from_bytes(hexstr_to_bytes(request["pubkey"])),
+            request.pubkey,
             message_to_verify,
-            G2Element.from_bytes(hexstr_to_bytes(request["signature"])),
+            request.signature,
         )
-        address = request.get("address")
-        if address is not None:
+        if request.address is not None:
             # For signatures made by the sign_message_by_address/sign_message_by_id
             # endpoints, the "address" field should contain the p2_address of the NFT/DID
             # that was used to sign the message.
-            puzzle_hash: bytes32 = decode_puzzle_hash(address)
+            puzzle_hash: bytes32 = decode_puzzle_hash(request.address)
             expected_puzzle_hash: Optional[bytes32] = None
             if signing_mode == SigningMode.CHIP_0002_P2_DELEGATED_CONDITIONS:
-                puzzle = p2_delegated_conditions.puzzle_for_pk(Program.to(hexstr_to_bytes(request["pubkey"])))
+                puzzle = p2_delegated_conditions.puzzle_for_pk(Program.to(request.pubkey))
                 expected_puzzle_hash = bytes32(puzzle.get_tree_hash())
             else:
-                expected_puzzle_hash = puzzle_hash_for_synthetic_public_key(
-                    G1Element.from_bytes(hexstr_to_bytes(request["pubkey"]))
-                )
+                expected_puzzle_hash = puzzle_hash_for_synthetic_public_key(request.pubkey)
             if puzzle_hash != expected_puzzle_hash:
-                return {"isValid": False, "error": "Public key doesn't match the address"}
+                return VerifySignatureResponse(isValid=False, error="Public key doesn't match the address")
         if is_valid:
-            return {"isValid": is_valid}
+            return VerifySignatureResponse(isValid=is_valid)
         else:
-            return {"isValid": False, "error": "Signature is invalid."}
+            return VerifySignatureResponse(isValid=False, error="Signature is invalid.")
 
-    async def sign_message_by_address(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def sign_message_by_address(self, request: SignMessageByAddress) -> SignMessageByAddressResponse:
         """
         Given a derived P2 address, sign the message by its private key.
         :param request:
         :return:
         """
-        puzzle_hash: bytes32 = decode_puzzle_hash(request["address"])
-        is_hex: bool = request.get("is_hex", False)
-        if isinstance(is_hex, str):
-            is_hex = True if is_hex.lower() == "true" else False
-        safe_mode: bool = request.get("safe_mode", True)
-        if isinstance(safe_mode, str):
-            safe_mode = True if safe_mode.lower() == "true" else False
+        puzzle_hash: bytes32 = decode_puzzle_hash(request.address)
         mode: SigningMode = SigningMode.CHIP_0002
-        if is_hex and safe_mode:
+        if request.is_hex and request.safe_mode:
             mode = SigningMode.CHIP_0002_HEX_INPUT
-        elif not is_hex and not safe_mode:
+        elif not request.is_hex and not request.safe_mode:
             mode = SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT
-        elif is_hex and not safe_mode:
+        elif request.is_hex and not request.safe_mode:
             mode = SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT
         pubkey, signature = await self.service.wallet_state_manager.main_wallet.sign_message(
-            request["message"], puzzle_hash, mode
+            request.message, puzzle_hash, mode
+        )
+        return SignMessageByAddressResponse(
+            pubkey=pubkey,
+            signature=signature,
+            signing_mode=mode.value,
         )
-        return {
-            "success": True,
-            "pubkey": str(pubkey),
-            "signature": str(signature),
-            "signing_mode": mode.value,
-        }
 
-    async def sign_message_by_id(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def sign_message_by_id(self, request: SignMessageByID) -> SignMessageByIDResponse:
         """
         Given a NFT/DID ID, sign the message by the P2 private key.
         :param request:
         :return:
         """
-        entity_id: bytes32 = decode_puzzle_hash(request["id"])
+        entity_id: bytes32 = decode_puzzle_hash(request.id)
         selected_wallet: Optional[WalletProtocol[Any]] = None
-        is_hex: bool = request.get("is_hex", False)
-        if isinstance(is_hex, str):
-            is_hex = True if is_hex.lower() == "true" else False
-        safe_mode: bool = request.get("safe_mode", True)
-        if isinstance(safe_mode, str):
-            safe_mode = True if safe_mode.lower() == "true" else False
         mode: SigningMode = SigningMode.CHIP_0002
-        if is_hex and safe_mode:
+        if request.is_hex and request.safe_mode:
             mode = SigningMode.CHIP_0002_HEX_INPUT
-        elif not is_hex and not safe_mode:
+        elif not request.is_hex and not request.safe_mode:
             mode = SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT
-        elif is_hex and not safe_mode:
+        elif request.is_hex and not request.safe_mode:
             mode = SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT
-        if is_valid_address(request["id"], {AddressType.DID}, self.service.config):
+        if is_valid_address(request.id, {AddressType.DID}, self.service.config):
             for wallet in self.service.wallet_state_manager.wallets.values():
                 if wallet.type() == WalletType.DECENTRALIZED_ID.value:
                     assert isinstance(wallet, DIDWallet)
@@ -2101,11 +2078,11 @@ class WalletRpcApi:
                         selected_wallet = wallet
                         break
             if selected_wallet is None:
-                return {"success": False, "error": f"DID for {entity_id.hex()} doesn't exist."}
+                raise ValueError(f"DID for {entity_id.hex()} doesn't exist.")
             assert isinstance(selected_wallet, DIDWallet)
-            pubkey, signature = await selected_wallet.sign_message(request["message"], mode)
+            pubkey, signature = await selected_wallet.sign_message(request.message, mode)
             latest_coin_id = (await selected_wallet.get_coin()).name()
-        elif is_valid_address(request["id"], {AddressType.NFT}, self.service.config):
+        elif is_valid_address(request.id, {AddressType.NFT}, self.service.config):
             target_nft: Optional[NFTCoinInfo] = None
             for wallet in self.service.wallet_state_manager.wallets.values():
                 if wallet.type() == WalletType.NFT.value:
@@ -2116,117 +2093,93 @@ class WalletRpcApi:
                         target_nft = nft
                         break
             if selected_wallet is None or target_nft is None:
-                return {"success": False, "error": f"NFT for {entity_id.hex()} doesn't exist."}
+                raise ValueError(f"NFT for {entity_id.hex()} doesn't exist.")
 
             assert isinstance(selected_wallet, NFTWallet)
-            pubkey, signature = await selected_wallet.sign_message(request["message"], target_nft, mode)
+            pubkey, signature = await selected_wallet.sign_message(request.message, target_nft, mode)
             latest_coin_id = target_nft.coin.name()
         else:
-            return {"success": False, "error": f"Unknown ID type, {request['id']}"}
+            raise ValueError(f"Unknown ID type, {request.id}")
 
-        return {
-            "success": True,
-            "pubkey": str(pubkey),
-            "signature": str(signature),
-            "latest_coin_id": latest_coin_id.hex() if latest_coin_id is not None else None,
-            "signing_mode": mode.value,
-        }
+        return SignMessageByIDResponse(
+            pubkey=pubkey,
+            signature=signature,
+            latest_coin_id=latest_coin_id,
+            signing_mode=mode.value,
+        )
 
     ##########################################################################################
     # CATs and Trading
     ##########################################################################################
 
-    async def get_cat_list(self, request: dict[str, Any]) -> EndpointResult:
-        return {"cat_list": list(DEFAULT_CATS.values())}
+    @marshal
+    async def get_cat_list(self, request: Empty) -> GetCATListResponse:
+        return GetCATListResponse([DefaultCAT.from_json_dict(default_cat) for default_cat in DEFAULT_CATS.values()])
 
-    async def cat_set_name(self, request: dict[str, Any]) -> EndpointResult:
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=CATWallet)
-        await wallet.set_name(str(request["name"]))
-        return {"wallet_id": wallet_id}
+    @marshal
+    async def cat_set_name(self, request: CATSetName) -> CATSetNameResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet)
+        await wallet.set_name(request.name)
+        return CATSetNameResponse(wallet_id=request.wallet_id)
 
-    async def cat_get_name(self, request: dict[str, Any]) -> EndpointResult:
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=CATWallet)
+    @marshal
+    async def cat_get_name(self, request: CATGetName) -> CATGetNameResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet)
         name: str = wallet.get_name()
-        return {"wallet_id": wallet_id, "name": name}
+        return CATGetNameResponse(wallet_id=request.wallet_id, name=name)
 
-    async def get_stray_cats(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_stray_cats(self, request: Empty) -> GetStrayCATsResponse:
         """
         Get a list of all unacknowledged CATs
         :param request: RPC request
         :return: A list of unacknowledged CATs
         """
         cats = await self.service.wallet_state_manager.interested_store.get_unacknowledged_tokens()
-        return {"stray_cats": cats}
+        return GetStrayCATsResponse(stray_cats=[StrayCAT.from_json_dict(cat) for cat in cats])
 
     @tx_endpoint(push=True)
+    @marshal
     async def cat_spend(
         self,
-        request: dict[str, Any],
+        request: CATSpend,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
         hold_lock: bool = True,
-    ) -> EndpointResult:
+    ) -> CATSpendResponse:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced.")
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=CATWallet)
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet)
 
         amounts: list[uint64] = []
         puzzle_hashes: list[bytes32] = []
         memos: list[list[bytes]] = []
-        additions: Optional[list[dict[str, Any]]] = request.get("additions")
-        if not isinstance(request["fee"], int) or (additions is None and not isinstance(request["amount"], int)):
-            raise ValueError("An integer amount or fee is required (too many decimals)")
-        if additions is not None:
-            for addition in additions:
-                receiver_ph = bytes32.from_hexstr(addition["puzzle_hash"])
-                if len(receiver_ph) != 32:
-                    raise ValueError(f"Address must be 32 bytes. {receiver_ph.hex()}")
-                amount = uint64(addition["amount"])
-                if amount > self.service.constants.MAX_COIN_AMOUNT:
+        if request.additions is not None:
+            for addition in request.additions:
+                if addition.amount > self.service.constants.MAX_COIN_AMOUNT:
                     raise ValueError(f"Coin amount cannot exceed {self.service.constants.MAX_COIN_AMOUNT}")
-                amounts.append(amount)
-                puzzle_hashes.append(receiver_ph)
-                if "memos" in addition:
-                    memos.append([mem.encode("utf-8") for mem in addition["memos"]])
+                amounts.append(addition.amount)
+                puzzle_hashes.append(addition.puzzle_hash)
+                if addition.memos is not None:
+                    memos.append([mem.encode("utf-8") for mem in addition.memos])
         else:
-            amounts.append(uint64(request["amount"]))
-            puzzle_hashes.append(decode_puzzle_hash(request["inner_address"]))
-            if "memos" in request:
-                memos.append([mem.encode("utf-8") for mem in request["memos"]])
+            # Our __post_init__ guards against these not being None
+            amounts.append(request.amount)  # type: ignore[arg-type]
+            puzzle_hashes.append(decode_puzzle_hash(request.inner_address))  # type: ignore[arg-type]
+            if request.memos is not None:
+                memos.append([mem.encode("utf-8") for mem in request.memos])
         coins: Optional[set[Coin]] = None
-        if "coins" in request and len(request["coins"]) > 0:
-            coins = {Coin.from_json_dict(coin_json) for coin_json in request["coins"]}
-        fee: uint64 = uint64(request.get("fee", 0))
+        if request.coins is not None and len(request.coins) > 0:
+            coins = set(request.coins)
 
-        cat_discrepancy_params: tuple[Optional[int], Optional[str], Optional[str]] = (
-            request.get("extra_delta", None),
-            request.get("tail_reveal", None),
-            request.get("tail_solution", None),
-        )
-        cat_discrepancy: Optional[tuple[int, Program, Program]] = None
-        if cat_discrepancy_params != (None, None, None):
-            if None in cat_discrepancy_params:
-                raise ValueError("Specifying extra_delta, tail_reveal, or tail_solution requires specifying the others")
-            else:
-                assert cat_discrepancy_params[0] is not None
-                assert cat_discrepancy_params[1] is not None
-                assert cat_discrepancy_params[2] is not None
-                cat_discrepancy = (
-                    cat_discrepancy_params[0],  # mypy sanitization
-                    Program.fromhex(cat_discrepancy_params[1]),
-                    Program.fromhex(cat_discrepancy_params[2]),
-                )
         if hold_lock:
             async with self.service.wallet_state_manager.lock:
                 await wallet.generate_signed_transaction(
                     amounts,
                     puzzle_hashes,
                     action_scope,
-                    fee,
-                    cat_discrepancy=cat_discrepancy,
+                    request.fee,
+                    cat_discrepancy=request.cat_discrepancy,
                     coins=coins,
                     memos=memos if memos else None,
                     extra_conditions=extra_conditions,
@@ -2236,34 +2189,32 @@ class WalletRpcApi:
                 amounts,
                 puzzle_hashes,
                 action_scope,
-                fee,
-                cat_discrepancy=cat_discrepancy,
+                request.fee,
+                cat_discrepancy=request.cat_discrepancy,
                 coins=coins,
                 memos=memos if memos else None,
                 extra_conditions=extra_conditions,
             )
 
-        return {
-            "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
-        }
+        # tx_endpoint will fill in these default values
+        return CATSpendResponse([], [], transaction=REPLACEABLE_TRANSACTION_RECORD, transaction_id=bytes32.zeros)
 
-    async def cat_get_asset_id(self, request: dict[str, Any]) -> EndpointResult:
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=CATWallet)
+    @marshal
+    async def cat_get_asset_id(self, request: CATGetAssetID) -> CATGetAssetIDResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet)
         asset_id: str = wallet.get_asset_id()
-        return {"asset_id": asset_id, "wallet_id": wallet_id}
+        return CATGetAssetIDResponse(asset_id=bytes32.from_hexstr(asset_id), wallet_id=request.wallet_id)
 
-    async def cat_asset_id_to_name(self, request: dict[str, Any]) -> EndpointResult:
-        wallet = await self.service.wallet_state_manager.get_wallet_for_asset_id(request["asset_id"])
+    @marshal
+    async def cat_asset_id_to_name(self, request: CATAssetIDToName) -> CATAssetIDToNameResponse:
+        wallet = await self.service.wallet_state_manager.get_wallet_for_asset_id(request.asset_id.hex())
         if wallet is None:
-            if request["asset_id"] in DEFAULT_CATS:
-                return {"wallet_id": None, "name": DEFAULT_CATS[request["asset_id"]]["name"]}
+            if request.asset_id.hex() in DEFAULT_CATS:
+                return CATAssetIDToNameResponse(wallet_id=None, name=DEFAULT_CATS[request.asset_id.hex()]["name"])
             else:
-                raise ValueError("The asset ID specified does not belong to a wallet")
+                return CATAssetIDToNameResponse(wallet_id=None, name=None)
         else:
-            return {"wallet_id": wallet.id(), "name": (wallet.get_name())}
+            return CATAssetIDToNameResponse(wallet_id=wallet.id(), name=wallet.get_name())
 
     @tx_endpoint(push=False)
     async def create_offer_for_ids(
@@ -2387,15 +2338,14 @@ class WalletRpcApi:
             },
         }
 
-    async def check_offer_validity(self, request: dict[str, Any]) -> EndpointResult:
-        offer_hex: str = request["offer"]
-
-        offer = Offer.from_bech32(offer_hex)
+    @marshal
+    async def check_offer_validity(self, request: CheckOfferValidity) -> CheckOfferValidityResponse:
+        offer = Offer.from_bech32(request.offer)
         peer = self.service.get_full_node_peer()
-        return {
-            "valid": (await self.service.wallet_state_manager.trade_manager.check_offer_validity(offer, peer)),
-            "id": offer.name(),
-        }
+        return CheckOfferValidityResponse(
+            valid=(await self.service.wallet_state_manager.trade_manager.check_offer_validity(offer, peer)),
+            id=offer.name(),
+        )
 
     @tx_endpoint(push=True)
     async def take_offer(
@@ -2481,12 +2431,15 @@ class WalletRpcApi:
 
         return {"trade_records": result, "offers": offer_values}
 
-    async def get_offers_count(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_offers_count(self, request: Empty) -> GetOffersCountResponse:
         trade_mgr = self.service.wallet_state_manager.trade_manager
 
         (total, my_offers_count, taken_offers_count) = await trade_mgr.trade_store.get_trades_count()
 
-        return {"total": total, "my_offers_count": my_offers_count, "taken_offers_count": taken_offers_count}
+        return GetOffersCountResponse(
+            total=uint16(total), my_offers_count=uint16(my_offers_count), taken_offers_count=uint16(taken_offers_count)
+        )
 
     @tx_endpoint(push=True)
     async def cancel_offer(
@@ -2587,31 +2540,6 @@ class WalletRpcApi:
         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: DIDUpdateRecoveryIDs,
-        action_scope: WalletActionScope,
-        extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> 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=request.fee, extra_conditions=extra_conditions)
-                # tx_endpoint will take care of default values here
-                return DIDUpdateRecoveryIDsResponse([], [])
-            else:
-                raise RuntimeError("updating recovery list failed")
-
     @tx_endpoint(push=False)
     @marshal
     async def did_message_spend(
@@ -2906,68 +2834,14 @@ class WalletRpcApi:
             except RuntimeError:
                 return DIDGetDIDResponse(wallet_id=request.wallet_id, my_did=my_did)
 
-    @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 DIDGetRecoveryListResponse(
-            wallet_id=request.wallet_id,
-            recovery_list=recovery_dids,
-            num_required=uint16(wallet.did_info.num_of_backup_ids_needed),
-        )
-
     @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 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
-    async def did_recovery_spend(self, request: dict[str, Any]) -> EndpointResult:  # pragma: no cover
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
-        if len(request["attest_data"]) < wallet.did_info.num_of_backup_ids_needed:
-            return {"success": False, "reason": "insufficient messages"}
-        async with self.service.wallet_state_manager.lock:
-            (
-                info_list,
-                message_spend_bundle,
-            ) = await wallet.load_attest_files_for_recovery_spend(request["attest_data"])
-
-            if "pubkey" in request:
-                pubkey = G1Element.from_bytes(hexstr_to_bytes(request["pubkey"]))
-            else:
-                assert wallet.did_info.temp_pubkey is not None
-                pubkey = G1Element.from_bytes(wallet.did_info.temp_pubkey)
-
-            if "puzhash" in request:
-                puzhash = bytes32.from_hexstr(request["puzhash"])
-            else:
-                assert wallet.did_info.temp_puzhash is not None
-                puzhash = wallet.did_info.temp_puzhash
-
-            assert wallet.did_info.temp_coin is not None
-            async with self.service.wallet_state_manager.new_action_scope(
-                DEFAULT_TX_CONFIG, push=request.get("push", True)
-            ) as action_scope:
-                await wallet.recovery_spend(
-                    wallet.did_info.temp_coin,
-                    puzhash,
-                    info_list,
-                    pubkey,
-                    message_spend_bundle,
-                    action_scope,
-                )
-            [tx] = action_scope.side_effects.transactions
-        return {
-            "success": True,
-            "spend_bundle": tx.spend_bundle,
-            "transactions": [tx.to_json_dict_convenience(self.service.config)],
-        }
+        return DIDGetMetadataResponse(
+            wallet_id=request.wallet_id,
+            metadata=metadata,
+        )
 
     @marshal
     async def did_get_pubkey(self, request: DIDGetPubkey) -> DIDGetPubkeyResponse:
@@ -2976,57 +2850,6 @@ class WalletRpcApi:
             (await wallet.wallet_state_manager.get_unused_derivation_record(request.wallet_id)).pubkey
         )
 
-    # TODO: this needs a test
-    @tx_endpoint(push=True)
-    async def did_create_attest(
-        self,
-        request: dict[str, Any],
-        action_scope: WalletActionScope,
-        extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:  # pragma: no cover
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=DIDWallet)
-        async with self.service.wallet_state_manager.lock:
-            info = await wallet.get_info_for_recovery()
-            coin = bytes32.from_hexstr(request["coin_name"])
-            pubkey = G1Element.from_bytes(hexstr_to_bytes(request["pubkey"]))
-            message_spend_bundle, attest_data = await wallet.create_attestment(
-                coin,
-                bytes32.from_hexstr(request["puzhash"]),
-                pubkey,
-                action_scope,
-                extra_conditions=extra_conditions,
-            )
-        if info is not None:
-            return {
-                "success": True,
-                "message_spend_bundle": bytes(message_spend_bundle).hex(),
-                "info": [info[0].hex(), info[1].hex(), info[2]],
-                "attest_data": attest_data,
-                "transactions": None,  # tx_endpoint wrapper will take care of this
-            }
-        else:
-            return {"success": False}
-
-    @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()
-        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,
-        )
-
     @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)
@@ -3034,15 +2857,15 @@ class WalletRpcApi:
             bytes32.from_hexstr(did_wallet.get_my_DID()), AddressType.DID.hrp(self.service.config)
         )
 
-        did_coin_threeple = await did_wallet.get_info_for_recovery()
+        assert did_wallet.did_info.current_inner is not None
+        parent_coin = await did_wallet.get_coin()
         assert my_did is not None
-        assert did_coin_threeple is not None
         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],
+            did_parent=parent_coin.parent_coin_info,
+            did_innerpuz=did_wallet.did_info.current_inner.get_tree_hash(),
+            did_amount=parent_coin.amount,
         )
 
     @marshal
@@ -3066,7 +2889,6 @@ class WalletRpcApi:
             await did_wallet.transfer_did(
                 puzzle_hash,
                 request.fee,
-                request.with_recovery_info,
                 action_scope,
                 extra_conditions=extra_conditions,
             )
@@ -3664,12 +3486,18 @@ class WalletRpcApi:
         fee_amount = 0
         blocks_won = 0
         last_height_farmed = uint32(0)
+
+        include_pool_rewards = request.get("include_pool_rewards", False)
+
         for record in tx_records:
             if record.wallet_id not in self.service.wallet_state_manager.wallets:
                 continue
             if record.type == TransactionType.COINBASE_REWARD.value:
-                if self.service.wallet_state_manager.wallets[record.wallet_id].type() == WalletType.POOLING_WALLET:
-                    # Don't add pool rewards for pool wallets.
+                if (
+                    not include_pool_rewards
+                    and self.service.wallet_state_manager.wallets[record.wallet_id].type() == WalletType.POOLING_WALLET
+                ):
+                    # Don't add pool rewards for pool wallets unless explicitly requested
                     continue
                 pool_reward_amount += record.amount
             height = record.height_farmed(self.service.constants.GENESIS_CHALLENGE)