chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/wallet/wallet_rpc_api.py

@@ -3,12 +3,14 @@ from __future__ import annotations
 import dataclasses
 import json
 import logging
+from collections.abc import Callable
+from itertools import count
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
-from chia_rs import AugSchemeMPL, Coin, CoinSpend, CoinState, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, Coin, CoinRecord, CoinSpend, CoinState, G1Element, G2Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint8, uint16, uint32, uint64
+from chia_rs.sized_ints import uint16, uint32, uint64
 from clvm_tools.binutils import assemble
 
 from chia.consensus.block_rewards import calculate_base_farmer_reward
@@ -16,41 +18,39 @@ from chia.data_layer.data_layer_errors import LauncherCoinNotFoundError
 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.pools.pool_wallet_info import (
+    FARMING_TO_POOL,
+    PoolState,
+    PoolWalletInfo,
+    create_pool_state,
+    initial_pool_state_from_dict,
+)
 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.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, run_with_cost
-from chia.types.coin_record import CoinRecord
-from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
+from chia.types.blockchain_format.program import Program
 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
 from chia.util.errors import KeychainIsLocked
-from chia.util.hash import std_hash
 from chia.util.keychain import bytes_to_mnemonic, generate_mnemonic
-from chia.util.path import path_from_root
-from chia.util.streamable import Streamable, UInt32Range, streamable
+from chia.util.streamable import UInt32Range
 from chia.util.ws_message import WsRpcMessage, create_payload_dict
 from chia.wallet.cat_wallet.cat_constants import DEFAULT_CATS
 from chia.wallet.cat_wallet.cat_info import CRCATInfo
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
+from chia.wallet.cat_wallet.r_cat_wallet import RCATWallet
 from chia.wallet.conditions import (
-    AssertCoinAnnouncement,
-    AssertPuzzleAnnouncement,
+    AssertConcurrentSpend,
     Condition,
     ConditionValidTimes,
     CreateCoin,
     CreateCoinAnnouncement,
     CreatePuzzleAnnouncement,
     conditions_from_json_dicts,
-    parse_conditions_non_consensus,
     parse_timelock_info,
 )
 from chia.wallet.derive_keys import (
-    MAX_POOL_WALLETS,
     master_sk_to_farmer_sk,
     master_sk_to_pool_sk,
     match_address_to_sk,
@@ -69,12 +69,9 @@ from chia.wallet.nft_wallet.nft_info import NFTCoinInfo, NFTInfo
 from chia.wallet.nft_wallet.nft_puzzle_utils import get_metadata_and_phs
 from chia.wallet.nft_wallet.nft_wallet import NFTWallet
 from chia.wallet.nft_wallet.uncurry_nft import UncurriedNFT
-from chia.wallet.notification_store import Notification
 from chia.wallet.outer_puzzles import AssetType
-from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
-from chia.wallet.puzzles import p2_delegated_conditions
-from chia.wallet.puzzles.clawback.metadata import AutoClaimSettings, ClawbackMetadata
-from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_synthetic_public_key
+from chia.wallet.puzzle_drivers import PuzzleInfo
+from chia.wallet.puzzles.clawback.metadata import AutoClaimSettings
 from chia.wallet.signer_protocol import SigningResponse
 from chia.wallet.singleton import (
     SINGLETON_LAUNCHER_PUZZLE_HASH,
@@ -82,7 +79,7 @@ from chia.wallet.singleton import (
     get_inner_puzzle_from_singleton,
 )
 from chia.wallet.trade_record import TradeRecord
-from chia.wallet.trading.offer import Offer
+from chia.wallet.trading.offer import Offer, OfferSummary
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.uncurried_puzzle import uncurry_puzzle
 from chia.wallet.util.address_type import AddressType, is_valid_address
@@ -90,7 +87,8 @@ 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
+from chia.wallet.util.query_filter import HashFilter
+from chia.wallet.util.signing import sign_message, verify_signature
 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
@@ -101,17 +99,20 @@ from chia.wallet.vc_wallet.vc_store import VCProofs
 from chia.wallet.vc_wallet.vc_wallet import VCWallet
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_action_scope import WalletActionScope
-from chia.wallet.wallet_coin_record import WalletCoinRecord
+from chia.wallet.wallet_coin_record import WalletCoinRecord, WalletCoinRecordMetadataParsingError
 from chia.wallet.wallet_coin_store import CoinRecordOrder, GetCoinRecords, unspent_range
 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_node import WalletNode, get_wallet_db_path
 from chia.wallet.wallet_request_types import (
     AddKey,
     AddKeyResponse,
     ApplySignatures,
     ApplySignaturesResponse,
     BalanceResponse,
+    CancelOffer,
+    CancelOfferResponse,
+    CancelOffers,
+    CancelOffersResponse,
     CATAssetIDToName,
     CATAssetIDToNameResponse,
     CATGetAssetID,
@@ -128,8 +129,17 @@ from chia.wallet.wallet_request_types import (
     CheckOfferValidityResponse,
     CombineCoins,
     CombineCoinsResponse,
+    CRCATApprovePending,
+    CRCATApprovePendingResponse,
     CreateNewDL,
     CreateNewDLResponse,
+    CreateNewWallet,
+    CreateNewWalletResponse,
+    CreateNewWalletType,
+    CreateOfferForIDs,
+    CreateOfferForIDsResponse,
+    CreateSignedTransaction,
+    CreateSignedTransactionsResponse,
     DefaultCAT,
     DeleteKey,
     DeleteNotifications,
@@ -156,6 +166,7 @@ from chia.wallet.wallet_request_types import (
     DIDSetWalletNameResponse,
     DIDTransferDID,
     DIDTransferDIDResponse,
+    DIDType,
     DIDUpdateMetadata,
     DIDUpdateMetadataResponse,
     DLDeleteMirror,
@@ -185,17 +196,25 @@ from chia.wallet.wallet_request_types import (
     GatherSigningInfo,
     GatherSigningInfoResponse,
     GenerateMnemonicResponse,
+    GetAllOffers,
+    GetAllOffersResponse,
     GetCATListResponse,
     GetCoinRecordsByNames,
     GetCoinRecordsByNamesResponse,
     GetCurrentDerivationIndexResponse,
+    GetFarmedAmount,
+    GetFarmedAmountResponse,
     GetHeightInfoResponse,
     GetLoggedInFingerprintResponse,
     GetNextAddress,
     GetNextAddressResponse,
     GetNotifications,
     GetNotificationsResponse,
+    GetOffer,
+    GetOfferResponse,
     GetOffersCountResponse,
+    GetOfferSummary,
+    GetOfferSummaryResponse,
     GetPrivateKey,
     GetPrivateKeyFormat,
     GetPrivateKeyResponse,
@@ -267,6 +286,8 @@ from chia.wallet.wallet_request_types import (
     SendNotification,
     SendNotificationResponse,
     SendTransaction,
+    SendTransactionMulti,
+    SendTransactionMultiResponse,
     SendTransactionResponse,
     SetWalletResyncOnStartup,
     SignMessageByAddress,
@@ -280,6 +301,8 @@ from chia.wallet.wallet_request_types import (
     StrayCAT,
     SubmitTransactions,
     SubmitTransactionsResponse,
+    TakeOffer,
+    TakeOfferResponse,
     TransactionRecordWithMetadata,
     VCAddProofs,
     VCGet,
@@ -299,6 +322,7 @@ from chia.wallet.wallet_request_types import (
     VCSpendResponse,
     VerifySignature,
     VerifySignatureResponse,
+    WalletCreationMode,
     WalletInfoResponse,
 )
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
@@ -319,6 +343,9 @@ def tx_endpoint(
         async def rpc_endpoint(
             self: WalletRpcApi, request: dict[str, Any], *args: object, **kwargs: object
         ) -> EndpointResult:
+            if await self.service.wallet_state_manager.synced() is False:
+                raise ValueError("Wallet needs to be fully synced before making transactions.")
+
             assert self.service.logged_in_fingerprint is not None
             tx_config_loader: TXConfigLoader = TXConfigLoader.from_json_dict(request)
 
@@ -332,7 +359,7 @@ def tx_endpoint(
                     excluded_coin_amounts=request.get("exclude_coin_amounts"),
                 )
             if tx_config_loader.excluded_coin_ids is None:
-                excluded_coins: Optional[list[dict[str, Any]]] = request.get(
+                excluded_coins: list[dict[str, Any]] | None = request.get(
                     "exclude_coins", request.get("excluded_coins")
                 )
                 if excluded_coins is not None:
@@ -360,25 +387,40 @@ def tx_endpoint(
             ):
                 raise ValueError("Relative timelocks are not currently supported in the RPC")
 
-            async with self.service.wallet_state_manager.new_action_scope(
-                tx_config,
-                push=request.get("push", push),
-                merge_spends=request.get("merge_spends", merge_spends),
-                sign=request.get("sign", self.service.config.get("auto_sign_txs", True)),
-            ) as action_scope:
+            if "action_scope_override" in kwargs:
                 response: EndpointResult = await func(
                     self,
                     request,
                     *args,
-                    action_scope,
+                    kwargs["action_scope_override"],
                     extra_conditions=extra_conditions,
-                    **kwargs,
+                    **{k: v for k, v in kwargs.items() if k != "action_scope_override"},
                 )
+                action_scope = cast(WalletActionScope, kwargs["action_scope_override"])
+            else:
+                async with self.service.wallet_state_manager.new_action_scope(
+                    tx_config,
+                    push=request.get("push", push),
+                    merge_spends=request.get("merge_spends", merge_spends),
+                    sign=request.get("sign", self.service.config.get("auto_sign_txs", True)),
+                ) as action_scope:
+                    response = await func(
+                        self,
+                        request,
+                        *args,
+                        action_scope,
+                        extra_conditions=extra_conditions,
+                        **kwargs,
+                    )
 
             if func.__name__ == "create_new_wallet" and "transactions" not in response:
                 # unfortunately, this API isn't solely a tx endpoint
                 return response
 
+            if "action_scope_override" in kwargs:
+                # deferring to parent action scope
+                return response
+
             unsigned_txs = await self.service.wallet_state_manager.gather_signing_info_for_txs(
                 action_scope.side_effects.transactions
             )
@@ -667,10 +709,10 @@ class WalletRpcApi:
             "/execute_signing_instructions": self.execute_signing_instructions,
         }
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+    def get_connections(self, request_node_type: NodeType | None) -> list[dict[str, Any]]:
         return default_get_connections(server=self.service.server, request_node_type=request_node_type)
 
-    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]]) -> list[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: dict[str, Any] | None) -> list[WsRpcMessage]:
         """
         Called by the WalletNode or WalletStateManager when something has changed in the wallet. This
         gives us an opportunity to send notifications to all connected clients via WebSocket.
@@ -762,10 +804,7 @@ class WalletRpcApi:
     @marshal
     async def get_public_keys(self, request: Empty) -> GetPublicKeysResponse:
         try:
-            fingerprints = [
-                uint32(sk.get_g1().get_fingerprint())
-                for (sk, seed) in await self.service.keychain_proxy.get_all_private_keys()
-            ]
+            fingerprints = [key_data.fingerprint for key_data in await self.service.keychain_proxy.get_keys()]
         except KeychainIsLocked:
             return GetPublicKeysResponse(keyring_is_locked=True)
         except Exception as e:
@@ -776,7 +815,7 @@ class WalletRpcApi:
         else:
             return GetPublicKeysResponse(keyring_is_locked=False, public_key_fingerprints=fingerprints)
 
-    async def _get_private_key(self, fingerprint: int) -> tuple[Optional[PrivateKey], Optional[bytes]]:
+    async def _get_private_key(self, fingerprint: int) -> tuple[PrivateKey | None, bytes | None]:
         try:
             all_keys = await self.service.keychain_proxy.get_all_private_keys()
             for sk, seed in all_keys:
@@ -838,9 +877,10 @@ class WalletRpcApi:
         except Exception as e:
             log.error(f"Failed to delete key by fingerprint: {e}")
             raise e
-        path = path_from_root(
+        path = get_wallet_db_path(
             self.service.root_path,
-            f"{self.service.config['database_path']}-{request.fingerprint}",
+            self.service.config,
+            str(request.fingerprint),
         )
         if path.exists():
             path.unlink()
@@ -928,14 +968,20 @@ class WalletRpcApi:
     @marshal
     async def delete_all_keys(self, request: Empty) -> Empty:
         await self._stop_wallet()
+        all_key_datas = await self.service.keychain_proxy.get_keys()
         try:
             await self.service.keychain_proxy.delete_all_keys()
         except Exception as e:
             log.error(f"Failed to delete all keys: {e}")
             raise e
-        path = path_from_root(self.service.root_path, self.service.config["database_path"])
-        if path.exists():
-            path.unlink()
+        for key_data in all_key_datas:
+            path = get_wallet_db_path(
+                self.service.root_path,
+                self.service.config,
+                str(key_data.fingerprint),
+            )
+            if path.exists():
+                path.unlink()
         return Empty()
 
     ##########################################################################################
@@ -987,50 +1033,21 @@ class WalletRpcApi:
     ) -> PushTransactionsResponse:
         if not action_scope.config.push:
             raise ValueError("Cannot push transactions if push is False")
+        tx_removals = [c for tx in request.transactions for c in tx.removals]
         async with action_scope.use() as interface:
             interface.side_effects.transactions.extend(request.transactions)
-            if request.fee != 0:
-                all_conditions_and_origins = [
-                    (condition, cs.coin.name())
-                    for tx in interface.side_effects.transactions
-                    if tx.spend_bundle is not None
-                    for cs in tx.spend_bundle.coin_spends
-                    for condition in run_with_cost(cs.puzzle_reveal, INFINITE_COST, cs.solution)[1].as_iter()
-                ]
-                create_coin_announcement = next(
-                    condition
-                    for condition in parse_conditions_non_consensus(
-                        [con for con, coin in all_conditions_and_origins], abstractions=False
-                    )
-                    if isinstance(condition, CreateCoinAnnouncement)
-                )
-                announcement_origin = next(
-                    coin
-                    for condition, coin in all_conditions_and_origins
-                    if condition == create_coin_announcement.to_program()
-                )
-                async with self.service.wallet_state_manager.new_action_scope(
-                    dataclasses.replace(
-                        action_scope.config.tx_config,
-                        excluded_coin_ids=[
-                            *action_scope.config.tx_config.excluded_coin_ids,
-                            *(c.name() for tx in interface.side_effects.transactions for c in tx.removals),
-                        ],
-                    ),
-                    push=False,
-                ) as inner_action_scope:
-                    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
-                            ).corresponding_assertion(),
-                        ),
-                    )
-
-                interface.side_effects.transactions.extend(inner_action_scope.side_effects.transactions)
+            interface.side_effects.selected_coins.extend(tx_removals)
+        if request.fee != 0:
+            await self.service.wallet_state_manager.main_wallet.create_tandem_xch_tx(
+                request.fee,
+                action_scope,
+                extra_conditions=(
+                    *extra_conditions,
+                    AssertConcurrentSpend(tx_removals[0].name()),
+                ),
+            )
+        elif extra_conditions != tuple():
+            raise ValueError("Cannot add conditions to a transaction if no new fee spend is being added")
 
         return PushTransactionsResponse([], [])  # tx_endpoint takes care of this
 
@@ -1065,7 +1082,7 @@ class WalletRpcApi:
 
     @marshal
     async def get_wallets(self, request: GetWallets) -> GetWalletsResponse:
-        wallet_type: Optional[WalletType] = None
+        wallet_type: WalletType | None = None
         if request.type is not None:
             wallet_type = WalletType(request.type)
 
@@ -1099,81 +1116,67 @@ class WalletRpcApi:
         return GetWalletsResponse(wallet_infos, uint32.construct_optional(self.service.logged_in_fingerprint))
 
     @tx_endpoint(push=True)
-    async def create_new_wallet(
+    @marshal
+    # Semantics guarantee returning on all paths, or else an error.
+    # It's probably not great to add a bunch of unreachable code for the sake of mypy.
+    async def create_new_wallet(  # type: ignore[return]
         self,
-        request: dict[str, Any],
+        request: CreateNewWallet,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> CreateNewWalletResponse:
         wallet_state_manager = self.service.wallet_state_manager
-
-        if await self.service.wallet_state_manager.synced() is False:
-            raise ValueError("Wallet needs to be fully synced.")
         main_wallet = wallet_state_manager.main_wallet
-        fee = uint64(request.get("fee", 0))
-
-        if request["wallet_type"] == "cat_wallet":
-            # If not provided, the name will be autogenerated based on the tail hash.
-            name = request.get("name", None)
-            if request["mode"] == "new":
-                if request.get("test", False):
-                    if not action_scope.config.push:
-                        raise ValueError("Test CAT minting must be pushed automatically")  # pragma: no cover
-                    async with self.service.wallet_state_manager.lock:
-                        cat_wallet = await CATWallet.create_new_cat_wallet(
-                            wallet_state_manager,
-                            main_wallet,
-                            {"identifier": "genesis_by_id"},
-                            uint64(request["amount"]),
-                            action_scope,
-                            fee,
-                            name,
-                        )
-                        asset_id = cat_wallet.get_asset_id()
-                    self.service.wallet_state_manager.state_changed("wallet_created")
-                    return {
-                        "type": cat_wallet.type(),
-                        "asset_id": asset_id,
-                        "wallet_id": cat_wallet.id(),
-                        "transactions": None,  # tx_endpoint wrapper will take care of this
-                    }
-                else:
-                    raise ValueError(
-                        "Support for this RPC mode has been dropped."
-                        " Please use the CAT Admin Tool @ https://github.com/Chia-Network/CAT-admin-tool instead."
+
+        if request.wallet_type == CreateNewWalletType.CAT_WALLET:
+            if request.mode == WalletCreationMode.NEW:
+                if not action_scope.config.push:
+                    raise ValueError("Test CAT minting must be pushed automatically")  # pragma: no cover
+                async with self.service.wallet_state_manager.lock:
+                    cat_wallet = await CATWallet.create_new_cat_wallet(
+                        wallet_state_manager,
+                        main_wallet,
+                        {"identifier": "genesis_by_id"},
+                        # mypy doesn't know about our __post_init__
+                        request.amount,  # type: ignore[arg-type]
+                        action_scope,
+                        request.fee,
+                        request.name,
                     )
+                    asset_id = cat_wallet.get_asset_id()
+                self.service.wallet_state_manager.state_changed("wallet_created")
+                return CreateNewWalletResponse(
+                    [], [], type=cat_wallet.type().name, asset_id=asset_id, wallet_id=cat_wallet.id()
+                )
 
-            elif request["mode"] == "existing":
+            elif request.mode == WalletCreationMode.EXISTING:
                 async with self.service.wallet_state_manager.lock:
+                    assert request.asset_id is not None  # mypy doesn't know about our __post_init__
                     cat_wallet = await CATWallet.get_or_create_wallet_for_cat(
-                        wallet_state_manager, main_wallet, request["asset_id"], name
+                        wallet_state_manager, main_wallet, request.asset_id, request.name
                     )
-                return {"type": cat_wallet.type(), "asset_id": request["asset_id"], "wallet_id": cat_wallet.id()}
-
-            else:  # undefined mode
-                pass
-
-        elif request["wallet_type"] == "did_wallet":
-            if request["did_type"] == "new":
-                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"]
-
+                return CreateNewWalletResponse(
+                    [],
+                    [],
+                    type=cat_wallet.type().name,
+                    asset_id=request.asset_id,
+                    wallet_id=cat_wallet.id(),
+                )
+        elif request.wallet_type == CreateNewWalletType.DID_WALLET:
+            if request.did_type == DIDType.NEW:
                 async with self.service.wallet_state_manager.lock:
-                    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_name = None
+                    if request.wallet_name is not None:
+                        did_wallet_name = request.wallet_name.strip()
+                    assert request.amount is not None  # mypy doesn't know about our __post_init__
                     did_wallet: DIDWallet = await DIDWallet.create_new_did_wallet(
                         wallet_state_manager,
                         main_wallet,
-                        uint64(request["amount"]),
+                        request.amount,
                         action_scope,
-                        metadata,
+                        request.metadata,
                         did_wallet_name,
-                        uint64(request.get("fee", 0)),
+                        request.fee,
                         extra_conditions=extra_conditions,
                     )
 
@@ -1189,131 +1192,95 @@ class WalletRpcApi:
                     bytes32.fromhex(did_wallet.get_my_DID()),
                     nft_wallet_name,
                 )
-                return {
-                    "success": True,
-                    "type": did_wallet.type(),
-                    "my_did": my_did_id,
-                    "wallet_id": did_wallet.id(),
-                    "transactions": None,  # tx_endpoint wrapper will take care of this
-                }
+                return CreateNewWalletResponse(
+                    [], [], type=did_wallet.type().name, my_did=my_did_id, wallet_id=did_wallet.id()
+                )
 
-            elif request["did_type"] == "recovery":
+            elif request.did_type == DIDType.RECOVERY:
                 async with self.service.wallet_state_manager.lock:
+                    assert request.backup_data is not None  # mypy doesn't know about our __post_init__
                     did_wallet = await DIDWallet.create_new_did_wallet_from_recovery(
-                        wallet_state_manager, main_wallet, request["backup_data"]
+                        wallet_state_manager, main_wallet, request.backup_data
                     )
                 assert did_wallet.did_info.temp_coin is not None
                 assert did_wallet.did_info.temp_puzhash is not None
                 assert did_wallet.did_info.temp_pubkey is not None
                 my_did = did_wallet.get_my_DID()
-                coin_name = did_wallet.did_info.temp_coin.name().hex()
-                coin_list = coin_as_list(did_wallet.did_info.temp_coin)
+                coin_name = did_wallet.did_info.temp_coin.name()
                 newpuzhash = did_wallet.did_info.temp_puzhash
                 pubkey = did_wallet.did_info.temp_pubkey
-                return {
-                    "success": True,
-                    "type": did_wallet.type(),
-                    "my_did": my_did,
-                    "wallet_id": did_wallet.id(),
-                    "coin_name": coin_name,
-                    "coin_list": coin_list,
-                    "newpuzhash": newpuzhash.hex(),
-                    "pubkey": pubkey.hex(),
-                    "backup_dids": did_wallet.did_info.backup_ids,
-                    "num_verifications_required": did_wallet.did_info.num_of_backup_ids_needed,
-                }
-            else:  # undefined did_type
-                pass
-        elif request["wallet_type"] == "nft_wallet":
+                return CreateNewWalletResponse(
+                    [],
+                    [],
+                    type=did_wallet.type().name,
+                    my_did=my_did,
+                    wallet_id=did_wallet.id(),
+                    coin_name=coin_name,
+                    coin_list=did_wallet.did_info.temp_coin,
+                    newpuzhash=newpuzhash,
+                    pubkey=G1Element.from_bytes(pubkey),
+                    backup_dids=did_wallet.did_info.backup_ids,
+                    num_verifications_required=did_wallet.did_info.num_of_backup_ids_needed,
+                )
+        elif request.wallet_type == CreateNewWalletType.NFT_WALLET:
+            did_id: bytes32 | None = None
+            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():
-                did_id: Optional[bytes32] = None
-                if "did_id" in request and request["did_id"] is not None:
-                    did_id = decode_puzzle_hash(request["did_id"])
                 if wallet.type() == WalletType.NFT:
                     assert isinstance(wallet, NFTWallet)
                     if wallet.get_did() == did_id:
                         log.info("NFT wallet already existed, skipping.")
-                        return {
-                            "success": True,
-                            "type": wallet.type(),
-                            "wallet_id": wallet.id(),
-                        }
+                        return CreateNewWalletResponse(
+                            [],
+                            [],
+                            type=wallet.type().name,
+                            wallet_id=wallet.id(),
+                        )
 
             async with self.service.wallet_state_manager.lock:
                 nft_wallet: NFTWallet = await NFTWallet.create_new_nft_wallet(
-                    wallet_state_manager, main_wallet, did_id, request.get("name", None)
+                    wallet_state_manager, main_wallet, did_id, request.name
                 )
-            return {
-                "success": True,
-                "type": nft_wallet.type(),
-                "wallet_id": nft_wallet.id(),
-            }
-        elif request["wallet_type"] == "pool_wallet":
-            if request["mode"] == "new":
-                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 action_scope.get_puzzle_hash(self.service.wallet_state_manager)
-
-                from chia.pools.pool_wallet_info import initial_pool_state_from_dict
-
+            return CreateNewWalletResponse(
+                [],
+                [],
+                type=nft_wallet.type().name,
+                wallet_id=nft_wallet.id(),
+            )
+        elif request.wallet_type == CreateNewWalletType.POOL_WALLET:
+            if request.mode == WalletCreationMode.NEW:
                 async with self.service.wallet_state_manager.lock:
-                    # We assign a pseudo unique id to each pool wallet, so that each one gets its own deterministic
-                    # owner and auth keys. The public keys will go on the blockchain, and the private keys can be found
-                    # using the root SK and trying each index from zero. The indexes are not fully unique though,
-                    # because the PoolWallet is not created until the tx gets confirmed on chain. Therefore if we
-                    # make multiple pool wallets at the same time, they will have the same ID.
-                    max_pwi = 1
-                    for _, wallet in self.service.wallet_state_manager.wallets.items():
-                        if wallet.type() == WalletType.POOLING_WALLET:
-                            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_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]
-                    )
-
+                    assert request.initial_target_state is not None  # mypy doesn't know about our __post_init__
                     initial_target_state = initial_pool_state_from_dict(
-                        request["initial_target_state"], owner_pk, owner_puzzle_hash
+                        request.initial_target_state,
+                        self.service.wallet_state_manager.new_pool_wallet_pubkey(),
+                        await action_scope.get_puzzle_hash(self.service.wallet_state_manager),
                     )
                     assert initial_target_state is not None
 
-                    try:
-                        delayed_address = None
-                        if "p2_singleton_delayed_ph" in request:
-                            delayed_address = bytes32.from_hexstr(request["p2_singleton_delayed_ph"])
-
-                        p2_singleton_puzzle_hash, launcher_id = await PoolWallet.create_new_pool_wallet_transaction(
-                            wallet_state_manager,
-                            main_wallet,
-                            initial_target_state,
-                            action_scope,
-                            fee,
-                            request.get("p2_singleton_delay_time", None),
-                            delayed_address,
-                            extra_conditions=extra_conditions,
-                        )
-
-                    except Exception as e:
-                        raise ValueError(str(e))
-                    return {
-                        "total_fee": fee * 2,
-                        "transaction": None,  # tx_endpoint wrapper will take care of this
-                        "transactions": None,  # tx_endpoint wrapper will take care of this
-                        "launcher_id": launcher_id.hex(),
-                        "p2_singleton_puzzle_hash": p2_singleton_puzzle_hash.hex(),
-                    }
-            elif request["mode"] == "recovery":
-                raise ValueError("Need upgraded singleton for on-chain recovery")
-
-        else:  # undefined wallet_type
-            pass
+                    p2_singleton_puzzle_hash, launcher_id = await PoolWallet.create_new_pool_wallet_transaction(
+                        wallet_state_manager,
+                        main_wallet,
+                        initial_target_state,
+                        action_scope,
+                        request.fee,
+                        request.p2_singleton_delay_time,
+                        request.p2_singleton_delayed_ph,
+                        extra_conditions=extra_conditions,
+                    )
 
-        # TODO: rework this function to report detailed errors for each error case
-        return {"success": False, "error": "invalid request"}
+                    return CreateNewWalletResponse(
+                        [],
+                        [],
+                        transaction=REPLACEABLE_TRANSACTION_RECORD,
+                        total_fee=uint64(request.fee * 2),
+                        launcher_id=launcher_id,
+                        p2_singleton_puzzle_hash=p2_singleton_puzzle_hash,
+                        # irrelevant, will be replaced in serialization
+                        type=WalletType.POOLING_WALLET.name,
+                        wallet_id=uint32(0),
+                    )
 
     ##########################################################################################
     # Wallet
@@ -1329,7 +1296,7 @@ class WalletRpcApi:
             wallet_balance["fingerprint"] = self.service.logged_in_fingerprint
         if wallet.type() in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
             assert isinstance(wallet, CATWallet)
-            wallet_balance["asset_id"] = wallet.get_asset_id()
+            wallet_balance["asset_id"] = wallet.get_asset_id().hex()
             if wallet.type() == WalletType.CRCAT:
                 assert isinstance(wallet, CRCATWallet)
                 wallet_balance["pending_approval_balance"] = await wallet.get_pending_approval_balance()
@@ -1352,9 +1319,7 @@ class WalletRpcApi:
 
     @marshal
     async def get_transaction(self, request: GetTransaction) -> GetTransactionResponse:
-        tr: Optional[TransactionRecord] = await self.service.wallet_state_manager.get_transaction(
-            request.transaction_id
-        )
+        tr: TransactionRecord | None = await self.service.wallet_state_manager.get_transaction(request.transaction_id)
         if tr is None:
             raise ValueError(f"Transaction 0x{request.transaction_id.hex()} not found")
 
@@ -1366,7 +1331,7 @@ class WalletRpcApi:
     @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)
+        tr: TransactionRecord | None = await self.service.wallet_state_manager.get_transaction(transaction_id)
         if tr is None:
             raise ValueError(f"Transaction 0x{transaction_id.hex()} not found")
         if tr.spend_bundle is None or len(tr.spend_bundle.coin_spends) == 0:
@@ -1390,57 +1355,13 @@ class WalletRpcApi:
     async def split_coins(
         self, request: SplitCoins, action_scope: WalletActionScope, extra_conditions: tuple[Condition, ...] = tuple()
     ) -> SplitCoinsResponse:
-        if request.number_of_coins > 500:
-            raise ValueError(f"{request.number_of_coins} coins is greater then the maximum limit of 500 coins.")
-
-        optional_coin = await self.service.wallet_state_manager.coin_store.get_coin_record(request.target_coin_id)
-        if optional_coin is None:
-            raise ValueError(f"Could not find coin with ID {request.target_coin_id}")
-        else:
-            coin = optional_coin.coin
-
-        total_amount = request.amount_per_coin * request.number_of_coins
-
-        if coin.amount < total_amount:
-            raise ValueError(
-                f"Coin amount: {coin.amount} is less than the total amount of the split: {total_amount}, exiting."
-            )
-
-        if request.wallet_id not in self.service.wallet_state_manager.wallets:
-            raise ValueError(f"Wallet with ID {request.wallet_id} does not exist")
-        wallet = self.service.wallet_state_manager.wallets[request.wallet_id]
-        if not isinstance(wallet, (Wallet, CATWallet)):
-            raise ValueError("Cannot split coins from non-fungible wallet types")
-
-        outputs = [
-            CreateCoin(
-                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)
-        ]
-        if len(outputs) == 0:
-            return SplitCoinsResponse([], [])
-
-        if wallet.type() == WalletType.STANDARD_WALLET and coin.amount < total_amount + request.fee:
-            async with action_scope.use() as interface:
-                interface.side_effects.selected_coins.append(coin)
-            coins = await wallet.select_coins(
-                uint64(total_amount + request.fee - coin.amount),
-                action_scope,
-            )
-            coins.add(coin)
-        else:
-            coins = {coin}
-
-        await wallet.generate_signed_transaction(
-            [output.amount for output in outputs],
-            [output.puzzle_hash for output in outputs],
-            action_scope,
-            request.fee,
-            coins=coins,
+        await self.service.wallet_state_manager.split_coins(
+            action_scope=action_scope,
+            wallet_id=request.wallet_id,
+            target_coin_id=request.target_coin_id,
+            amount_per_coin=request.amount_per_coin,
+            number_of_coins=request.number_of_coins,
+            fee=request.fee,
             extra_conditions=extra_conditions,
         )
 
@@ -1451,98 +1372,22 @@ class WalletRpcApi:
     async def combine_coins(
         self, request: CombineCoins, action_scope: WalletActionScope, extra_conditions: tuple[Condition, ...] = tuple()
     ) -> CombineCoinsResponse:
-        # Some "number of coins" validation
-        if request.number_of_coins > request.coin_num_limit:
-            raise ValueError(
-                f"{request.number_of_coins} coins is greater then the maximum limit of {request.coin_num_limit} coins."
-            )
-        if request.number_of_coins < 1:
-            raise ValueError("You need at least two coins to combine")
-        if len(request.target_coin_ids) > request.number_of_coins:
-            raise ValueError("More coin IDs specified than desired number of coins to combine")
-
-        if request.wallet_id not in self.service.wallet_state_manager.wallets:
-            raise ValueError(f"Wallet with ID {request.wallet_id} does not exist")
-        wallet = self.service.wallet_state_manager.wallets[request.wallet_id]
-        if not isinstance(wallet, (Wallet, CATWallet)):
-            raise ValueError("Cannot combine coins from non-fungible wallet types")
-
-        coins: list[Coin] = []
-
-        # First get the coin IDs specified
-        if request.target_coin_ids != []:
-            coins.extend(
-                cr.coin
-                for cr in (
-                    await self.service.wallet_state_manager.coin_store.get_coin_records(
-                        wallet_id=request.wallet_id,
-                        coin_id_filter=HashFilter(request.target_coin_ids, mode=uint8(FilterMode.include.value)),
-                    )
-                ).records
-            )
-
-        async with action_scope.use() as interface:
-            interface.side_effects.selected_coins.extend(coins)
-
-        # Next let's select enough coins to meet the target + fee if there is one
-        fungible_amount_needed = uint64(0) if request.target_coin_amount is None else request.target_coin_amount
-        if isinstance(wallet, Wallet):
-            fungible_amount_needed = uint64(fungible_amount_needed + request.fee)
-        amount_selected = sum(c.amount for c in coins)
-        if amount_selected < fungible_amount_needed:  # implicit fungible_amount_needed > 0 here
-            coins.extend(
-                await wallet.select_coins(
-                    amount=uint64(fungible_amount_needed - amount_selected), action_scope=action_scope
-                )
-            )
-
-        if len(coins) > request.number_of_coins:
-            raise ValueError(
-                f"Options specified cannot be met without selecting more coins than specified: {len(coins)}"
-            )
-
-        # Now let's select enough coins to get to the target number to combine
-        if len(coins) < request.number_of_coins:
-            async with action_scope.use() as interface:
-                coins.extend(
-                    cr.coin
-                    for cr in (
-                        await self.service.wallet_state_manager.coin_store.get_coin_records(
-                            wallet_id=request.wallet_id,
-                            limit=uint32(request.number_of_coins - len(coins)),
-                            order=CoinRecordOrder.amount,
-                            coin_id_filter=HashFilter(
-                                [c.name() for c in interface.side_effects.selected_coins],
-                                mode=uint8(FilterMode.exclude.value),
-                            ),
-                            reverse=request.largest_first,
-                        )
-                    ).records
-                )
-
-        async with action_scope.use() as interface:
-            interface.side_effects.selected_coins.extend(coins)
-
-        primary_output_amount = (
-            uint64(sum(c.amount for c in coins)) if request.target_coin_amount is None else request.target_coin_amount
-        )
-        if isinstance(wallet, Wallet):
-            primary_output_amount = uint64(primary_output_amount - request.fee)
-
-        await wallet.generate_signed_transaction(
-            [primary_output_amount],
-            [await action_scope.get_puzzle_hash(self.service.wallet_state_manager)],
-            action_scope,
-            request.fee,
-            coins=set(coins),
+        await self.service.wallet_state_manager.combine_coins(
+            action_scope=action_scope,
+            wallet_id=request.wallet_id,
+            number_of_coins=request.number_of_coins,
+            largest_first=request.largest_first,
+            coin_num_limit=request.coin_num_limit,
+            fee=request.fee,
+            target_coin_amount=request.target_coin_amount,
+            target_coin_ids=request.target_coin_ids if request.target_coin_ids != [] else None,
             extra_conditions=extra_conditions,
         )
-
         return CombineCoinsResponse([], [])  # tx_endpoint will take care to fill this out
 
     @marshal
     async def get_transactions(self, request: GetTransactions) -> GetTransactionsResponse:
-        to_puzzle_hash: Optional[bytes32] = None
+        to_puzzle_hash: bytes32 | None = None
         if request.to_address is not None:
             to_puzzle_hash = decode_puzzle_hash(request.to_address)
 
@@ -1564,7 +1409,7 @@ class WalletRpcApi:
             if tx["type"] not in CLAWBACK_INCOMING_TRANSACTION_TYPES:
                 continue
             coin: Coin = tr.additions[0]
-            record: Optional[WalletCoinRecord] = await self.service.wallet_state_manager.coin_store.get_coin_record(
+            record: WalletCoinRecord | None = await self.service.wallet_state_manager.coin_store.get_coin_record(
                 coin.name()
             )
             if record is None:
@@ -1624,9 +1469,6 @@ class WalletRpcApi:
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> SendTransactionResponse:
-        if await self.service.wallet_state_manager.synced() is False:
-            raise ValueError("Wallet needs to be fully synced before sending transactions")
-
         wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=Wallet)
 
         # TODO: Add support for multiple puzhash/amount/memo sets
@@ -1651,35 +1493,41 @@ class WalletRpcApi:
         # 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:
+    @tx_endpoint(push=True)
+    @marshal
+    async def send_transaction_multi(
+        self,
+        request: SendTransactionMulti,
+        action_scope: WalletActionScope,
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> SendTransactionMultiResponse:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before sending transactions")
 
-        # This is required because this is a "@tx_endpoint" that calls other @tx_endpoints
-        request.setdefault("push", True)
-        request.setdefault("merge_spends", True)
-
-        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.lock:
-            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"]
-                transactions = response["transactions"]
+            if issubclass(type(wallet), CATWallet):
+                await self.cat_spend(
+                    request.convert_to_proxy(CATSpend).json_serialize_for_transport(
+                        action_scope.config.tx_config, extra_conditions, ConditionValidTimes()
+                    ),
+                    hold_lock=False,
+                    action_scope_override=action_scope,
+                )
             else:
-                response = await self.create_signed_transaction(request, hold_lock=False)
-                transaction = response["signed_tx"]
-                transactions = response["transactions"]
+                await self.create_signed_transaction(
+                    request.convert_to_proxy(CreateSignedTransaction).json_serialize_for_transport(
+                        action_scope.config.tx_config, extra_conditions, ConditionValidTimes()
+                    ),
+                    hold_lock=False,
+                    action_scope_override=action_scope,
+                )
 
-        # Transaction may not have been included in the mempool yet. Use get_transaction to check.
-        return {
-            "transaction": transaction,
-            "transaction_id": TransactionRecord.from_json_dict(transaction).name,
-            "transactions": transactions,
-            "unsigned_transactions": response["unsigned_transactions"],
-        }
+        # tx_endpoint will take care of these values
+        return SendTransactionMultiResponse(
+            [], [], transaction=REPLACEABLE_TRANSACTION_RECORD, transaction_id=bytes32.zeros
+        )
 
     @tx_endpoint(push=True, merge_spends=False)
     @marshal
@@ -1696,7 +1544,6 @@ class WalletRpcApi:
         :param fee: transaction fee in mojos
         :return:
         """
-        # Get inner puzzle
         coin_records = await self.service.wallet_state_manager.coin_store.get_coin_records(
             coin_id_filter=HashFilter.include(request.coin_ids),
             coin_type=CoinType.CLAWBACK,
@@ -1704,31 +1551,23 @@ class WalletRpcApi:
             spent_range=UInt32Range(stop=uint32(0)),
         )
 
-        coins: dict[Coin, ClawbackMetadata] = {}
         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():
+        records_list = list(coin_records.coin_id_to_record.values())
+        for i in range(0, len(records_list), batch_size):
             try:
-                metadata = coin_record.parsed_metadata()
-                assert isinstance(metadata, ClawbackMetadata)
-                coins[coin_record.coin] = metadata
-                if len(coins) >= batch_size:
-                    await self.service.wallet_state_manager.spend_clawback_coins(
-                        coins,
-                        request.fee,
-                        action_scope,
-                        request.force,
-                        extra_conditions=extra_conditions,
-                    )
-                    coins = {}
-            except Exception as e:
-                log.error(f"Failed to spend clawback coin {coin_id.hex()}: %s", e)
-        if len(coins) > 0:
+                coin_batch = {
+                    coin_record.coin: coin_record.parsed_metadata() for coin_record in records_list[i : i + batch_size]
+                }
+            except WalletCoinRecordMetadataParsingError as e:
+                log.error("Failed to spend clawback coin: %s", e)
+                continue
             await self.service.wallet_state_manager.spend_clawback_coins(
-                coins,
+                # Semantically, we're guaranteed the right type here, but the typing isn't there
+                coin_batch,  # type: ignore[arg-type]
                 request.fee,
                 action_scope,
                 request.force,
@@ -1796,58 +1635,43 @@ class WalletRpcApi:
             raise ValueError("Wallet needs to be fully synced before getting all coins")
 
         state_mgr = self.service.wallet_state_manager
-        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(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(request.wallet_id, all_coin_records)
+            # Removals
+            unconfirmed_removals = await state_mgr.unconfirmed_additions_or_removals_for_wallet(
+                wallet_id=request.wallet_id, get="removals"
+            )
+            unconfirmed_removal_ids = {coin.name() for coin in unconfirmed_removals}
+            removal_records: list[CoinRecord] = []
+            for coin_record in (
+                await state_mgr.coin_store.get_coin_records(
+                    coin_id_filter=HashFilter.include(list(unconfirmed_removal_ids))
                 )
+            ).records:
+                removal_records.append(await state_mgr.get_coin_record_by_wallet_record(coin_record))
 
-            # 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(
-                request.wallet_id
+            # Additions
+            unconfirmed_additions = await state_mgr.unconfirmed_additions_or_removals_for_wallet(
+                wallet_id=request.wallet_id, get="additions"
+            )
+
+            # Spendable coins
+            unfiltered_spendable_coin_records = await state_mgr.get_spendable_coins_for_wallet(
+                request.wallet_id, pending_removals=unconfirmed_removal_ids
+            )
+            filtered_spendable_coins = request.autofill(
+                constants=self.service.wallet_state_manager.constants
+            ).filter_coins({cr.coin for cr in unfiltered_spendable_coin_records})
+            filtered_spendable_coin_records = list(
+                cr for cr in unfiltered_spendable_coin_records if cr.coin in filtered_spendable_coins
             )
-            unconfirmed_removal_ids: dict[bytes32, uint64] = {
-                coin.name(): transaction.created_at_time
-                for transaction in unconfirmed_transactions
-                for coin in transaction.removals
-            }
-            unconfirmed_additions: list[Coin] = [
-                coin
-                for transaction in unconfirmed_transactions
-                for coin in transaction.additions
-                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.name() in cs_config.excluded_coin_ids:
-                    continue
-                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 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)
+            for coin_record in filtered_spendable_coin_records:
+                valid_spendable_cr.append(await state_mgr.get_coin_record_by_wallet_record(coin_record))
 
         return GetSpendableCoinsResponse(
             confirmed_records=valid_spendable_cr,
-            unconfirmed_removals=unconfirmed_removals,
-            unconfirmed_additions=unconfirmed_additions,
+            unconfirmed_removals=removal_records,
+            unconfirmed_additions=list(unconfirmed_additions),
         )
 
     @marshal
@@ -1886,7 +1710,7 @@ class WalletRpcApi:
     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()
+        index: uint32 | None = await self.service.wallet_state_manager.puzzle_store.get_last_derivation_path()
 
         return GetCurrentDerivationIndexResponse(index)
 
@@ -1899,7 +1723,7 @@ class WalletRpcApi:
         if synced is False:
             raise ValueError("Wallet needs to be fully synced before extending derivation index")
 
-        current: Optional[uint32] = await self.service.wallet_state_manager.puzzle_store.get_last_derivation_path()
+        current: uint32 | None = await self.service.wallet_state_manager.puzzle_store.get_last_derivation_path()
 
         # Additional sanity check that the wallet is synced
         if current is None:
@@ -1929,29 +1753,17 @@ class WalletRpcApi:
 
     @marshal
     async def get_notifications(self, request: GetNotifications) -> GetNotificationsResponse:
-        if request.ids is None:
-            notifications: list[
-                Notification
-            ] = await self.service.wallet_state_manager.notification_manager.notification_store.get_all_notifications(
-                pagination=(request.start, request.end)
+        return GetNotificationsResponse(
+            await self.service.wallet_state_manager.notification_manager.notification_store.get_notifications(
+                coin_ids=request.ids, pagination=(request.start, request.end)
             )
-        else:
-            notifications = (
-                await self.service.wallet_state_manager.notification_manager.notification_store.get_notifications(
-                    request.ids
-                )
-            )
-
-        return GetNotificationsResponse(notifications)
+        )
 
     @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(
-                request.ids
-            )
+        await self.service.wallet_state_manager.notification_manager.notification_store.delete_notifications(
+            coin_ids=request.ids
+        )
 
         return Empty()
 
@@ -1977,57 +1789,13 @@ class WalletRpcApi:
 
     @marshal
     async def verify_signature(self, request: VerifySignature) -> VerifySignatureResponse:
-        """
-        Given a public key, message and signature, verify if it is valid.
-        :param request:
-        :return:
-        """
-        # 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 request.signing_mode is None:
-            signing_mode = SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT
-        else:
-            try:
-                signing_mode = SigningMode(request.signing_mode)
-            except ValueError:
-                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, 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(request.message)
-        elif signing_mode == SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT:
-            # Message is expected to be a UTF-8 string
-            message_to_verify = bytes(request.message, "utf-8")
-        else:
-            raise ValueError(f"Unsupported signing mode: {request.signing_mode!r}")
-
-        # Verify using the BLS message augmentation scheme
-        is_valid = AugSchemeMPL.verify(
-            request.pubkey,
-            message_to_verify,
-            request.signature,
+        return verify_signature(
+            signing_mode=request.signing_mode_enum,
+            public_key=request.pubkey,
+            message=request.message,
+            signature=request.signature,
+            address=request.address,
         )
-        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(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(request.pubkey))
-                expected_puzzle_hash = bytes32(puzzle.get_tree_hash())
-            else:
-                expected_puzzle_hash = puzzle_hash_for_synthetic_public_key(request.pubkey)
-            if puzzle_hash != expected_puzzle_hash:
-                return VerifySignatureResponse(isValid=False, error="Public key doesn't match the address")
-        if is_valid:
-            return VerifySignatureResponse(isValid=is_valid)
-        else:
-            return VerifySignatureResponse(isValid=False, error="Signature is invalid.")
 
     @marshal
     async def sign_message_by_address(self, request: SignMessageByAddress) -> SignMessageByAddressResponse:
@@ -2036,21 +1804,18 @@ class WalletRpcApi:
         :param request:
         :return:
         """
-        puzzle_hash: bytes32 = decode_puzzle_hash(request.address)
-        mode: SigningMode = SigningMode.CHIP_0002
-        if request.is_hex and request.safe_mode:
-            mode = SigningMode.CHIP_0002_HEX_INPUT
-        elif not request.is_hex and not request.safe_mode:
-            mode = SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT
-        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
+        synthetic_secret_key = self.service.wallet_state_manager.main_wallet.convert_secret_key_to_synthetic(
+            await self.service.wallet_state_manager.get_private_key(decode_puzzle_hash(request.address))
+        )
+        signing_response = sign_message(
+            secret_key=synthetic_secret_key,
+            message=request.message,
+            mode=request.signing_mode_enum,
         )
         return SignMessageByAddressResponse(
-            pubkey=pubkey,
-            signature=signature,
-            signing_mode=mode.value,
+            pubkey=signing_response.pubkey,
+            signature=signing_response.signature,
+            signing_mode=request.signing_mode_enum.value,
         )
 
     @marshal
@@ -2061,53 +1826,67 @@ class WalletRpcApi:
         :return:
         """
         entity_id: bytes32 = decode_puzzle_hash(request.id)
-        selected_wallet: Optional[WalletProtocol[Any]] = None
-        mode: SigningMode = SigningMode.CHIP_0002
-        if request.is_hex and request.safe_mode:
-            mode = SigningMode.CHIP_0002_HEX_INPUT
-        elif not request.is_hex and not request.safe_mode:
-            mode = SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT
-        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):
+            did_wallet: DIDWallet | None = None
             for wallet in self.service.wallet_state_manager.wallets.values():
                 if wallet.type() == WalletType.DECENTRALIZED_ID.value:
                     assert isinstance(wallet, DIDWallet)
                     assert wallet.did_info.origin_coin is not None
                     if wallet.did_info.origin_coin.name() == entity_id:
-                        selected_wallet = wallet
+                        did_wallet = wallet
                         break
-            if selected_wallet is None:
+            if did_wallet is None:
                 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)
-            latest_coin_id = (await selected_wallet.get_coin()).name()
+            synthetic_secret_key = self.service.wallet_state_manager.main_wallet.convert_secret_key_to_synthetic(
+                await self.service.wallet_state_manager.get_private_key(await did_wallet.current_p2_puzzle_hash())
+            )
+            latest_coin_id = (await did_wallet.get_coin()).name()
+            signing_response = sign_message(
+                secret_key=synthetic_secret_key,
+                message=request.message,
+                mode=request.signing_mode_enum,
+            )
+            return SignMessageByIDResponse(
+                pubkey=signing_response.pubkey,
+                signature=signing_response.signature,
+                signing_mode=request.signing_mode_enum.value,
+                latest_coin_id=latest_coin_id,
+            )
         elif is_valid_address(request.id, {AddressType.NFT}, self.service.config):
-            target_nft: Optional[NFTCoinInfo] = None
+            nft_wallet: NFTWallet | None = None
+            target_nft: NFTCoinInfo | None = None
             for wallet in self.service.wallet_state_manager.wallets.values():
                 if wallet.type() == WalletType.NFT.value:
                     assert isinstance(wallet, NFTWallet)
-                    nft: Optional[NFTCoinInfo] = await wallet.get_nft(entity_id)
+                    nft: NFTCoinInfo | None = await wallet.get_nft(entity_id)
                     if nft is not None:
-                        selected_wallet = wallet
+                        nft_wallet = wallet
                         target_nft = nft
                         break
-            if selected_wallet is None or target_nft is None:
+            if nft_wallet is None or target_nft is None:
                 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)
+            assert isinstance(nft_wallet, NFTWallet)
+            synthetic_secret_key = self.service.wallet_state_manager.main_wallet.convert_secret_key_to_synthetic(
+                await self.service.wallet_state_manager.get_private_key(
+                    await nft_wallet.current_p2_puzzle_hash(target_nft)
+                )
+            )
             latest_coin_id = target_nft.coin.name()
+            signing_response = sign_message(
+                secret_key=synthetic_secret_key,
+                message=request.message,
+                mode=request.signing_mode_enum,
+            )
+            return SignMessageByIDResponse(
+                pubkey=signing_response.pubkey,
+                signature=signing_response.signature,
+                signing_mode=request.signing_mode_enum.value,
+                latest_coin_id=latest_coin_id,
+            )
         else:
             raise ValueError(f"Unknown ID type, {request.id}")
 
-        return SignMessageByIDResponse(
-            pubkey=pubkey,
-            signature=signature,
-            latest_coin_id=latest_coin_id,
-            signing_mode=mode.value,
-        )
-
     ##########################################################################################
     # CATs and Trading
     ##########################################################################################
@@ -2147,8 +1926,6 @@ class WalletRpcApi:
         extra_conditions: tuple[Condition, ...] = tuple(),
         hold_lock: bool = True,
     ) -> CATSpendResponse:
-        if await self.service.wallet_state_manager.synced() is False:
-            raise ValueError("Wallet needs to be fully synced.")
         wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet)
 
         amounts: list[uint64] = []
@@ -2168,7 +1945,7 @@ class WalletRpcApi:
             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
+        coins: set[Coin] | None = None
         if request.coins is not None and len(request.coins) > 0:
             coins = set(request.coins)
 
@@ -2202,12 +1979,12 @@ class WalletRpcApi:
     @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 CATGetAssetIDResponse(asset_id=bytes32.from_hexstr(asset_id), wallet_id=request.wallet_id)
+        asset_id = wallet.get_asset_id()
+        return CATGetAssetIDResponse(asset_id=asset_id, wallet_id=request.wallet_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())
+        wallet = await self.service.wallet_state_manager.get_wallet_for_asset_id(request.asset_id)
         if wallet is None:
             if request.asset_id.hex() in DEFAULT_CATS:
                 return CATAssetIDToNameResponse(wallet_id=None, name=DEFAULT_CATS[request.asset_id.hex()]["name"])
@@ -2217,126 +1994,98 @@ class WalletRpcApi:
             return CATAssetIDToNameResponse(wallet_id=wallet.id(), name=wallet.get_name())
 
     @tx_endpoint(push=False)
+    @marshal
     async def create_offer_for_ids(
         self,
-        request: dict[str, Any],
+        request: CreateOfferForIDs,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> CreateOfferForIDsResponse:
         if action_scope.config.push:
-            raise ValueError("Cannot push an incomplete spend")  # pragma: no cover
-
-        offer: dict[str, int] = request["offer"]
-        fee: uint64 = uint64(request.get("fee", 0))
-        validate_only: bool = request.get("validate_only", False)
-        driver_dict_str: Optional[dict[str, Any]] = request.get("driver_dict", None)
-        marshalled_solver = request.get("solver")
-        solver: Optional[Solver]
-        if marshalled_solver is None:
-            solver = None
-        else:
-            solver = Solver(info=marshalled_solver)
+            raise ValueError("Cannot push an incomplete spend")
 
         # This driver_dict construction is to maintain backward compatibility where everything is assumed to be a CAT
         driver_dict: dict[bytes32, PuzzleInfo] = {}
-        if driver_dict_str is None:
-            for key, amount in offer.items():
-                if amount > 0:
-                    try:
-                        driver_dict[bytes32.from_hexstr(key)] = PuzzleInfo(
-                            {"type": AssetType.CAT.value, "tail": "0x" + key}
-                        )
-                    except ValueError:
-                        pass
+        if request.driver_dict is None:
+            for key, amount in request.offer_spec.items():
+                if amount > 0 and isinstance(key, bytes32):
+                    driver_dict[key] = PuzzleInfo({"type": AssetType.CAT.value, "tail": "0x" + key.hex()})
         else:
-            for key, value in driver_dict_str.items():
-                driver_dict[bytes32.from_hexstr(key)] = PuzzleInfo(value)
-
-        modified_offer: dict[Union[int, bytes32], int] = {}
-        for wallet_identifier, change in offer.items():
-            try:
-                modified_offer[bytes32.from_hexstr(wallet_identifier)] = change
-            except ValueError:
-                modified_offer[int(wallet_identifier)] = change
+            driver_dict = request.driver_dict
 
         async with self.service.wallet_state_manager.lock:
             result = await self.service.wallet_state_manager.trade_manager.create_offer_for_ids(
-                modified_offer,
+                request.offer_spec,
                 action_scope,
                 driver_dict,
-                solver=solver,
-                fee=fee,
-                validate_only=validate_only,
+                solver=request.solver,
+                fee=request.fee,
+                validate_only=request.validate_only,
                 extra_conditions=extra_conditions,
             )
-        if result[0]:
-            _success, trade_record, _error = result
-            return {
-                "offer": Offer.from_bytes(trade_record.offer).to_bech32(),
-                "trade_record": trade_record.to_json_dict_convenience(),
-                "transactions": None,  # tx_endpoint wrapper will take care of this
-            }
-        raise ValueError(result[2])
-
-    async def get_offer_summary(self, request: dict[str, Any]) -> EndpointResult:
-        offer_hex: str = request["offer"]
-
-        offer = Offer.from_bech32(offer_hex)
-        offered, requested, infos, valid_times = offer.summary()
-
-        if request.get("advanced", False):
-            response = {
-                "summary": {
-                    "offered": offered,
-                    "requested": requested,
-                    "fees": offer.fees(),
-                    "infos": infos,
-                    "additions": [c.name().hex() for c in offer.additions()],
-                    "removals": [c.name().hex() for c in offer.removals()],
-                    "valid_times": {
-                        k: v
-                        for k, v in valid_times.to_json_dict().items()
-                        if k
-                        not in {
-                            "max_secs_after_created",
-                            "min_secs_since_created",
-                            "max_blocks_after_created",
-                            "min_blocks_since_created",
-                        }
-                    },
-                },
-                "id": offer.name(),
-            }
+
+        return CreateOfferForIDsResponse(
+            [],
+            [],
+            offer=Offer.from_bytes(result[1].offer),
+            trade_record=result[1],
+        )
+
+    @marshal
+    async def get_offer_summary(self, request: GetOfferSummary) -> GetOfferSummaryResponse:
+        dl_summary = None
+        if not request.advanced:
+            dl_summary = await self.service.wallet_state_manager.trade_manager.get_dl_offer_summary(
+                request.parsed_offer
+            )
+        if dl_summary is not None:
+            response = GetOfferSummaryResponse(
+                data_layer_summary=dl_summary,
+                id=request.parsed_offer.name(),
+            )
         else:
-            response = {
-                "summary": await self.service.wallet_state_manager.trade_manager.get_offer_summary(offer),
-                "id": offer.name(),
-            }
+            offered, requested, infos, valid_times = request.parsed_offer.summary()
+            response = GetOfferSummaryResponse(
+                summary=OfferSummary(
+                    offered=offered,
+                    requested=requested,
+                    fees=uint64(request.parsed_offer.fees()),
+                    infos=infos,
+                    additions=[c.name() for c in request.parsed_offer.additions()],
+                    removals=[c.name() for c in request.parsed_offer.removals()],
+                    valid_times=valid_times.only_absolutes(),
+                ),
+                id=request.parsed_offer.name(),
+            )
 
         # This is a bit of a hack in favor of returning some more manageable information about CR-CATs
         # A more general solution surely exists, but I'm not sure what it is right now
-        return {
-            **response,
-            "summary": {
-                **response["summary"],  # type: ignore[dict-item]
-                "infos": {
+        return dataclasses.replace(
+            response,
+            summary=dataclasses.replace(
+                response.summary,
+                infos={
                     key: (
-                        {
-                            **info,
-                            "also": {
-                                **info["also"],
-                                "flags": ProofsChecker.from_program(
-                                    uncurry_puzzle(Program(assemble(info["also"]["proofs_checker"])))
-                                ).flags,
-                            },
-                        }
-                        if "also" in info and "proofs_checker" in info["also"]
+                        PuzzleInfo(
+                            {
+                                **info.info,
+                                "also": {
+                                    **info.info["also"],
+                                    "flags": ProofsChecker.from_program(
+                                        uncurry_puzzle(Program(assemble(info.info["also"]["proofs_checker"])))
+                                    ).flags,
+                                },
+                            }
+                        )
+                        if "also" in info.info and "proofs_checker" in info.info["also"]
                         else info
                     )
-                    for key, info in response["summary"]["infos"].items()  # type: ignore[index]
+                    for key, info in response.summary.infos.items()
                 },
-            },
-        }
+            )
+            if response.summary is not None
+            else None,
+        )
 
     @marshal
     async def check_offer_validity(self, request: CheckOfferValidity) -> CheckOfferValidityResponse:
@@ -2348,88 +2097,76 @@ class WalletRpcApi:
         )
 
     @tx_endpoint(push=True)
+    @marshal
     async def take_offer(
         self,
-        request: dict[str, Any],
+        request: TakeOffer,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
-        offer_hex: str = request["offer"]
-
-        offer = Offer.from_bech32(offer_hex)
-        fee: uint64 = uint64(request.get("fee", 0))
-        maybe_marshalled_solver: Optional[dict[str, Any]] = request.get("solver")
-        solver: Optional[Solver]
-        if maybe_marshalled_solver is None:
-            solver = None
-        else:
-            solver = Solver(info=maybe_marshalled_solver)
-
+    ) -> TakeOfferResponse:
         peer = self.service.get_full_node_peer()
         trade_record = await self.service.wallet_state_manager.trade_manager.respond_to_offer(
-            offer,
+            request.parsed_offer,
             peer,
             action_scope,
-            fee=fee,
-            solver=solver,
+            fee=request.fee,
+            solver=request.solver,
             extra_conditions=extra_conditions,
         )
 
         async with action_scope.use() as interface:
             interface.side_effects.signing_responses.append(
-                SigningResponse(bytes(offer._bundle.aggregated_signature), trade_record.trade_id)
+                SigningResponse(bytes(request.parsed_offer._bundle.aggregated_signature), trade_record.trade_id)
             )
 
-        return {
-            "trade_record": trade_record.to_json_dict_convenience(),
-            "offer": Offer.from_bytes(trade_record.offer).to_bech32(),
-            "transactions": None,  # tx_endpoint wrapper will take care of this
-            "signing_responses": None,  # tx_endpoint wrapper will take care of this
-        }
+        return TakeOfferResponse(
+            [],  # tx_endpoint will fill in this default value
+            [],  # tx_endpoint will fill in this default value
+            Offer.from_bytes(trade_record.offer),
+            trade_record,
+        )
 
-    async def get_offer(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_offer(self, request: GetOffer) -> GetOfferResponse:
         trade_mgr = self.service.wallet_state_manager.trade_manager
 
-        trade_id = bytes32.from_hexstr(request["trade_id"])
-        file_contents: bool = request.get("file_contents", False)
-        trade_record: Optional[TradeRecord] = await trade_mgr.get_trade_by_id(bytes32(trade_id))
+        trade_record: TradeRecord | None = await trade_mgr.get_trade_by_id(request.trade_id)
         if trade_record is None:
-            raise ValueError(f"No trade with trade id: {trade_id.hex()}")
+            raise ValueError(f"No trade with trade id: {request.trade_id.hex()}")
 
         offer_to_return: bytes = trade_record.offer if trade_record.taken_offer is None else trade_record.taken_offer
-        offer_value: Optional[str] = Offer.from_bytes(offer_to_return).to_bech32() if file_contents else None
-        return {"trade_record": trade_record.to_json_dict_convenience(), "offer": offer_value}
+        offer: str | None = Offer.from_bytes(offer_to_return).to_bech32() if request.file_contents else None
+        return GetOfferResponse(
+            offer,
+            trade_record,
+        )
 
-    async def get_all_offers(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_all_offers(self, request: GetAllOffers) -> GetAllOffersResponse:
         trade_mgr = self.service.wallet_state_manager.trade_manager
 
-        start: int = request.get("start", 0)
-        end: int = request.get("end", 10)
-        exclude_my_offers: bool = request.get("exclude_my_offers", False)
-        exclude_taken_offers: bool = request.get("exclude_taken_offers", False)
-        include_completed: bool = request.get("include_completed", False)
-        sort_key: Optional[str] = request.get("sort_key", None)
-        reverse: bool = request.get("reverse", False)
-        file_contents: bool = request.get("file_contents", False)
-
         all_trades = await trade_mgr.trade_store.get_trades_between(
-            start,
-            end,
-            sort_key=sort_key,
-            reverse=reverse,
-            exclude_my_offers=exclude_my_offers,
-            exclude_taken_offers=exclude_taken_offers,
-            include_completed=include_completed,
+            request.start,
+            request.end,
+            sort_key=request.sort_key,
+            reverse=request.reverse,
+            exclude_my_offers=request.exclude_my_offers,
+            exclude_taken_offers=request.exclude_taken_offers,
+            include_completed=request.include_completed,
         )
         result = []
-        offer_values: Optional[list[str]] = [] if file_contents else None
+        offer_values: list[str] | None = [] if request.file_contents else None
         for trade in all_trades:
-            result.append(trade.to_json_dict_convenience())
-            if file_contents and offer_values is not None:
+            result.append(trade)
+            if request.file_contents:
                 offer_to_return: bytes = trade.offer if trade.taken_offer is None else trade.taken_offer
-                offer_values.append(Offer.from_bytes(offer_to_return).to_bech32())
+                # semantics guarantee this to be not None
+                offer_values.append(Offer.from_bytes(offer_to_return).to_bech32())  # type: ignore[union-attr]
 
-        return {"trade_records": result, "offers": offer_values}
+        return GetAllOffersResponse(
+            trade_records=result,
+            offers=offer_values,
+        )
 
     @marshal
     async def get_offers_count(self, request: Empty) -> GetOffersCountResponse:
@@ -2442,88 +2179,67 @@ class WalletRpcApi:
         )
 
     @tx_endpoint(push=True)
+    @marshal
     async def cancel_offer(
         self,
-        request: dict[str, Any],
+        request: CancelOffer,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> CancelOfferResponse:
         wsm = self.service.wallet_state_manager
-        secure = request["secure"]
-        trade_id = bytes32.from_hexstr(request["trade_id"])
-        fee: uint64 = uint64(request.get("fee", 0))
         async with self.service.wallet_state_manager.lock:
             await wsm.trade_manager.cancel_pending_offers(
-                [trade_id], action_scope, fee=fee, secure=secure, extra_conditions=extra_conditions
+                [request.trade_id],
+                action_scope,
+                fee=request.fee,
+                secure=request.secure,
+                extra_conditions=extra_conditions,
             )
 
-        return {"transactions": None}  # tx_endpoint wrapper will take care of this
+        return CancelOfferResponse([], [])  # tx_endpoint will fill in default values here
 
     @tx_endpoint(push=True, merge_spends=False)
+    @marshal
     async def cancel_offers(
         self,
-        request: dict[str, Any],
+        request: CancelOffers,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
-        secure = request["secure"]
-        batch_fee: uint64 = uint64(request.get("batch_fee", 0))
-        batch_size = request.get("batch_size", 5)
-        cancel_all = request.get("cancel_all", False)
-        if cancel_all:
-            asset_id = None
-        else:
-            asset_id = request.get("asset_id", "xch")
-
-        start: int = 0
-        end: int = start + batch_size
+    ) -> CancelOffersResponse:
         trade_mgr = self.service.wallet_state_manager.trade_manager
-        log.info(f"Start cancelling offers for  {'asset_id: ' + asset_id if asset_id is not None else 'all'} ...")
+        log.info(f"Start cancelling offers for  {'all' if request.cancel_all else 'asset_id: ' + request.asset_id} ...")
         # Traverse offers page by page
-        key = None
-        if asset_id is not None and asset_id != "xch":
-            key = bytes32.from_hexstr(asset_id)
-        while True:
-            records: dict[bytes32, TradeRecord] = {}
-            trades = await trade_mgr.trade_store.get_trades_between(
-                start,
-                end,
-                reverse=True,
-                exclude_my_offers=False,
-                exclude_taken_offers=True,
-                include_completed=False,
-            )
-            for trade in trades:
-                if cancel_all:
-                    records[trade.trade_id] = trade
-                    continue
-                if trade.offer and trade.offer != b"":
-                    offer = Offer.from_bytes(trade.offer)
-                    if key in offer.arbitrage():
-                        records[trade.trade_id] = trade
-                        continue
+        for start in count(0, request.batch_size):
+            records = {
+                record.trade_id: record
+                for record in await trade_mgr.trade_store.get_trades_between(
+                    start,
+                    start + request.batch_size,
+                    reverse=True,
+                    exclude_my_offers=False,
+                    exclude_taken_offers=True,
+                    include_completed=False,
+                )
+                if request.cancel_all
+                or (record.offer != b"" and request.query_key in Offer.from_bytes(record.offer).arbitrage())
+            }
 
-            if len(records) == 0:
+            if records == {}:
                 break
 
             async with self.service.wallet_state_manager.lock:
                 await trade_mgr.cancel_pending_offers(
                     list(records.keys()),
                     action_scope,
-                    batch_fee,
-                    secure,
+                    request.batch_fee,
+                    request.secure,
                     records,
                     extra_conditions=extra_conditions,
                 )
 
-            log.info(f"Cancelled offers {start} to {end} ...")
-            # If fewer records were returned than requested, we're done
-            if len(trades) < batch_size:
-                break
-            start = end
-            end += batch_size
+            log.info(f"Created offer cancellations for {start} to {start + request.batch_size} ...")
 
-        return {"transactions": None}  # tx_endpoint wrapper will take care of this
+        return CancelOffersResponse([], [])  # tx_endpoint wrapper will take care of this
 
     ##########################################################################################
     # Distributed Identities
@@ -2621,11 +2337,11 @@ class WalletRpcApi:
         if curried_args is None:
             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())
+        num_verification_int: uint16 | None = uint16(num_verification.as_int())
         assert num_verification_int is not None
         did_data: DIDCoinData = DIDCoinData(
             p2_puzzle,
-            bytes32(recovery_list_hash.as_atom()) if recovery_list_hash != Program.to(None) else None,
+            bytes32(recovery_list_hash.as_atom()) if recovery_list_hash != Program.NIL else None,
             num_verification_int,
             singleton_struct,
             metadata,
@@ -2634,7 +2350,7 @@ class WalletRpcApi:
         )
         hinted_coins, _ = compute_spend_hints_and_additions(coin_spend)
         # Hint is required, if it doesn't have any hint then it should be invalid
-        hint: Optional[bytes32] = None
+        hint: bytes32 | None = None
         for hinted_coin in hinted_coins.values():
             if hinted_coin.coin.amount % 2 == 1 and hinted_coin.hint is not None:
                 hint = hinted_coin.hint
@@ -2667,7 +2383,7 @@ class WalletRpcApi:
                 our_inner_puzzle, NIL_TREEHASH, uint64(0), singleton_struct, metadata
             )
             # Check if we have the DID wallet
-            did_wallet: Optional[DIDWallet] = None
+            did_wallet: DIDWallet | None = None
             for wallet in self.service.wallet_state_manager.wallets.values():
                 if isinstance(wallet, DIDWallet):
                     assert wallet.did_info.origin_coin is not None
@@ -2881,8 +2597,6 @@ class WalletRpcApi:
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> DIDTransferDIDResponse:
-        if await self.service.wallet_state_manager.synced() is False:
-            raise ValueError("Wallet needs to be fully synced.")
         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:
@@ -2935,7 +2649,7 @@ class WalletRpcApi:
         metadata = Program.to(metadata_list)
         if request.did_id is not None:
             if request.did_id == "":
-                did_id: Optional[bytes] = b""
+                did_id: bytes | None = b""
             else:
                 did_id = decode_puzzle_hash(request.did_id)
         else:
@@ -2964,12 +2678,9 @@ class WalletRpcApi:
     async def nft_count_nfts(self, request: NFTCountNFTs) -> NFTCountNFTsResponse:
         count = 0
         if request.wallet_id is not None:
-            try:
-                nft_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=NFTWallet)
-            except KeyError:
-                # wallet not found
-                raise ValueError(f"Wallet {request.wallet_id} not found.")
-            count = await nft_wallet.get_nft_count()
+            count = await self.service.wallet_state_manager.get_wallet(
+                id=request.wallet_id, required_type=NFTWallet
+            ).get_nft_count()
         else:
             count = await self.service.wallet_state_manager.nft_store.count()
         return NFTCountNFTsResponse(request.wallet_id, uint64(count))
@@ -3162,7 +2873,7 @@ class WalletRpcApi:
 
     @marshal
     async def nft_get_by_did(self, request: NFTGetByDID) -> NFTGetByDIDResponse:
-        did_id: Optional[bytes32] = None
+        did_id: bytes32 | None = None
         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():
@@ -3173,7 +2884,7 @@ class WalletRpcApi:
     @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_bytes: bytes32 | None = 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))
@@ -3193,7 +2904,7 @@ class WalletRpcApi:
         did_nft_wallets: list[NFTWalletWithDID] = []
         for wallet in all_wallets:
             if isinstance(wallet, NFTWallet):
-                nft_wallet_did: Optional[bytes32] = wallet.get_did()
+                nft_wallet_did: bytes32 | None = wallet.get_did()
                 if nft_wallet_did is not None:
                     did_wallet_id: uint32 = did_wallets_by_did_id.get(nft_wallet_did, uint32(0))
                     if did_wallet_id == 0:
@@ -3262,7 +2973,7 @@ class WalletRpcApi:
         # 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())
+        uncurried_nft: UncurriedNFT | None = UncurriedNFT.uncurry(*full_puzzle.uncurry())
         if uncurried_nft is None:
             raise ValueError("The coin is not a NFT.")
         metadata, p2_puzzle_hash = get_metadata_and_phs(uncurried_nft, coin_spend.solution)
@@ -3352,8 +3063,6 @@ class WalletRpcApi:
     ) -> 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.")
         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)
@@ -3383,7 +3092,7 @@ class WalletRpcApi:
             metadata_list.append(metadata_dict)
         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"):
+            if request.xch_change_target.startswith(AddressType.XCH.hrp(self.service.config)):
                 xch_change_ph = decode_puzzle_hash(request.xch_change_target)
             else:
                 xch_change_ph = bytes32.from_hexstr(request.xch_change_target)
@@ -3478,7 +3187,8 @@ class WalletRpcApi:
             "total_count": result.total_count,
         }
 
-    async def get_farmed_amount(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_farmed_amount(self, request: GetFarmedAmount) -> GetFarmedAmountResponse:
         tx_records: list[TransactionRecord] = await self.service.wallet_state_manager.tx_store.get_farming_rewards()
         amount = 0
         pool_reward_amount = 0
@@ -3487,14 +3197,12 @@ class WalletRpcApi:
         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 (
-                    not include_pool_rewards
+                    not request.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
@@ -3514,103 +3222,74 @@ class WalletRpcApi:
             last_height_farmed = max(last_height_farmed, height)
             amount += record.amount
 
-        last_time_farmed = uint64(
+        last_time_farmed = (
             await self.service.get_timestamp_for_height(last_height_farmed) if last_height_farmed > 0 else 0
         )
         assert amount == pool_reward_amount + farmer_reward_amount + fee_amount
-        return {
-            "farmed_amount": amount,
-            "pool_reward_amount": pool_reward_amount,
-            "farmer_reward_amount": farmer_reward_amount,
-            "fee_amount": fee_amount,
-            "last_height_farmed": last_height_farmed,
-            "last_time_farmed": last_time_farmed,
-            "blocks_won": blocks_won,
-        }
+        return GetFarmedAmountResponse(
+            farmed_amount=uint64(amount),
+            pool_reward_amount=uint64(pool_reward_amount),
+            farmer_reward_amount=uint64(farmer_reward_amount),
+            fee_amount=uint64(fee_amount),
+            last_height_farmed=uint32(last_height_farmed),
+            last_time_farmed=uint64(last_time_farmed),
+            blocks_won=uint32(blocks_won),
+        )
 
     @tx_endpoint(push=False)
+    @marshal
     async def create_signed_transaction(
         self,
-        request: dict[str, Any],
+        request: CreateSignedTransaction,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
         hold_lock: bool = True,
-    ) -> EndpointResult:
-        if "wallet_id" in request:
-            wallet_id = uint32(request["wallet_id"])
-            wallet = self.service.wallet_state_manager.wallets[wallet_id]
+    ) -> CreateSignedTransactionsResponse:
+        if request.wallet_id is not None:
+            wallet = self.service.wallet_state_manager.wallets[request.wallet_id]
         else:
             wallet = self.service.wallet_state_manager.main_wallet
 
-        assert isinstance(wallet, (Wallet, CATWallet, CRCATWallet)), (
+        assert isinstance(wallet, (Wallet, CATWallet, CRCATWallet, RCATWallet)), (
             "create_signed_transaction only works for standard and CAT wallets"
         )
 
-        if "additions" not in request or len(request["additions"]) < 1:
+        if len(request.additions) < 1:
             raise ValueError("Specify additions list")
 
-        additions: list[dict[str, Any]] = request["additions"]
-        amount_0: uint64 = uint64(additions[0]["amount"])
+        amount_0: uint64 = uint64(request.additions[0].amount)
         assert amount_0 <= self.service.constants.MAX_COIN_AMOUNT
-        puzzle_hash_0 = bytes32.from_hexstr(additions[0]["puzzle_hash"])
+        puzzle_hash_0 = request.additions[0].puzzle_hash
         if len(puzzle_hash_0) != 32:
             raise ValueError(f"Address must be 32 bytes. {puzzle_hash_0.hex()}")
 
-        memos_0 = [] if "memos" not in additions[0] else [mem.encode("utf-8") for mem in additions[0]["memos"]]
+        memos_0 = (
+            [] if request.additions[0].memos is None else [mem.encode("utf-8") for mem in request.additions[0].memos]
+        )
 
         additional_outputs: list[CreateCoin] = []
-        for addition in additions[1:]:
-            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:
+        for addition in request.additions[1:]:
+            if addition.amount > self.service.constants.MAX_COIN_AMOUNT:
                 raise ValueError(f"Coin amount cannot exceed {self.service.constants.MAX_COIN_AMOUNT}")
-            memos = [] if "memos" not in addition else [mem.encode("utf-8") for mem in addition["memos"]]
-            additional_outputs.append(CreateCoin(receiver_ph, amount, memos))
-
-        fee: uint64 = uint64(request.get("fee", 0))
+            memos = [] if addition.memos is None else [mem.encode("utf-8") for mem in addition.memos]
+            additional_outputs.append(CreateCoin(addition.puzzle_hash, addition.amount, memos))
 
-        coins = None
-        if "coins" in request and len(request["coins"]) > 0:
-            coins = {Coin.from_json_dict(coin_json) for coin_json in request["coins"]}
-
-        async def _generate_signed_transaction() -> EndpointResult:
+        async def _generate_signed_transaction() -> CreateSignedTransactionsResponse:
             await wallet.generate_signed_transaction(
                 [amount_0] + [output.amount for output in additional_outputs],
                 [bytes32(puzzle_hash_0)] + [output.puzzle_hash for output in additional_outputs],
                 action_scope,
-                fee,
-                coins=coins,
+                request.fee,
+                coins=request.coin_set,
                 memos=[memos_0] + [output.memos if output.memos is not None else [] for output in additional_outputs],
                 extra_conditions=(
                     *extra_conditions,
-                    *(
-                        AssertCoinAnnouncement(
-                            asserted_id=bytes32.from_hexstr(ca["coin_id"]),
-                            asserted_msg=(
-                                hexstr_to_bytes(ca["message"])
-                                if request.get("morph_bytes") is None
-                                else std_hash(hexstr_to_bytes(ca["morph_bytes"]) + hexstr_to_bytes(ca["message"]))
-                            ),
-                        )
-                        for ca in request.get("coin_announcements", [])
-                    ),
-                    *(
-                        AssertPuzzleAnnouncement(
-                            asserted_ph=bytes32.from_hexstr(pa["puzzle_hash"]),
-                            asserted_msg=(
-                                hexstr_to_bytes(pa["message"])
-                                if request.get("morph_bytes") is None
-                                else std_hash(hexstr_to_bytes(pa["morph_bytes"]) + hexstr_to_bytes(pa["message"]))
-                            ),
-                        )
-                        for pa in request.get("puzzle_announcements", [])
-                    ),
+                    *request.asserted_coin_announcements,
+                    *request.asserted_puzzle_announcements,
                 ),
             )
-            # tx_endpoint wrapper will take care of this
-            return {"signed_txs": None, "signed_tx": None, "transactions": None}
+            # tx_endpoint wrapper will take care of these default values
+            return CreateSignedTransactionsResponse([], [], [], REPLACEABLE_TRANSACTION_RECORD)
 
         if hold_lock:
             async with self.service.wallet_state_manager.lock:
@@ -3631,9 +3310,6 @@ class WalletRpcApi:
     ) -> 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.")
-
         pool_wallet_info: PoolWalletInfo = await wallet.get_current_state()
         if (
             pool_wallet_info.current.state == FARMING_TO_POOL.value
@@ -3673,9 +3349,6 @@ class WalletRpcApi:
         # Then we transition to FARMING_TO_POOL or SELF_POOLING
         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.")
-
         total_fee = await wallet.self_pool(request.fee, action_scope)
         # tx_endpoint will take care of filling in these default values
         return PWSelfPoolResponse(
@@ -3695,8 +3368,6 @@ class WalletRpcApi:
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> 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")
         wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=PoolWallet)
 
         assert isinstance(wallet, PoolWallet)
@@ -4003,7 +3674,7 @@ class WalletRpcApi:
         'transactions'
         """
         did_id = decode_puzzle_hash(request.did_id)
-        puzhash: Optional[bytes32] = None
+        puzhash: bytes32 | None = None
         if request.target_address is not None:
             puzhash = decode_puzzle_hash(request.target_address)
 
@@ -4105,7 +3776,7 @@ class WalletRpcApi:
 
         vc_wallet: VCWallet = await self.service.wallet_state_manager.get_or_create_vc_wallet()
 
-        vc_proofs: Optional[VCProofs] = await vc_wallet.store.get_proofs_for_root(request.root)
+        vc_proofs: VCProofs | None = await vc_wallet.store.get_proofs_for_root(request.root)
         if vc_proofs is None:
             raise ValueError("no proofs found for specified root")  # pragma: no cover
         return VCGetProofsForRootResponse.from_vc_proofs(vc_proofs)
@@ -4137,12 +3808,13 @@ class WalletRpcApi:
         return VCRevokeResponse([], [])  # tx_endpoint takes care of filling this out
 
     @tx_endpoint(push=True)
+    @marshal
     async def crcat_approve_pending(
         self,
-        request: dict[str, Any],
+        request: CRCATApprovePending,
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> EndpointResult:
+    ) -> CRCATApprovePendingResponse:
         """
         Moving any "pending approval" CR-CATs into the spendable balance of the wallet
         :param request: Required 'wallet_id'. Optional 'min_amount_to_claim' (default: full balance).
@@ -4151,27 +3823,18 @@ class WalletRpcApi:
         (CRCAT TX + fee TX)
         """
 
-        @streamable
-        @dataclasses.dataclass(frozen=True)
-        class CRCATApprovePending(Streamable):
-            wallet_id: uint32
-            min_amount_to_claim: uint64
-            fee: uint64 = uint64(0)
-
-        parsed_request = CRCATApprovePending.from_json_dict(request)
-        cr_cat_wallet = self.service.wallet_state_manager.wallets[parsed_request.wallet_id]
+        cr_cat_wallet = self.service.wallet_state_manager.wallets[request.wallet_id]
         assert isinstance(cr_cat_wallet, CRCATWallet)
 
         await cr_cat_wallet.claim_pending_approval_balance(
-            parsed_request.min_amount_to_claim,
+            request.min_amount_to_claim,
             action_scope,
-            fee=parsed_request.fee,
+            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 CRCATApprovePendingResponse([], [])
 
     @marshal
     async def gather_signing_info(