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

chia/wallet/wallet_request_types.py

@@ -1,23 +1,34 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
-from typing import Any, BinaryIO, Optional, final
+from dataclasses import dataclass, field, fields
+from enum import Enum
+from functools import cached_property
+from typing import Any, BinaryIO, TypeVar, final
 
-from chia_rs import Coin, G1Element, G2Element, PrivateKey
+from chia_rs import Coin, CoinRecord, G1Element, G2Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 from typing_extensions import Self
 
-from chia.data_layer.data_layer_wallet import Mirror
+from chia.data_layer.data_layer_wallet import DataLayerSummary, Mirror
 from chia.data_layer.singleton_record import SingletonRecord
-from chia.pools.pool_wallet_info import PoolWalletInfo
+from chia.pools.pool_wallet_info import NewPoolWalletInitialTargetState, PoolWalletInfo
+from chia.types.blockchain_format.coin import coin_as_list
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_record import CoinRecord
+from chia.types.signing_mode import SigningMode
 from chia.util.byte_types import hexstr_to_bytes
-from chia.util.streamable import Streamable, streamable
-from chia.wallet.conditions import Condition, ConditionValidTimes, conditions_to_json_dicts
+from chia.util.hash import std_hash
+from chia.util.streamable import Streamable, streamable, streamable_enum
+from chia.wallet.conditions import (
+    AssertCoinAnnouncement,
+    AssertPuzzleAnnouncement,
+    Condition,
+    ConditionValidTimes,
+    conditions_to_json_dicts,
+)
 from chia.wallet.nft_wallet.nft_info import NFTInfo
 from chia.wallet.notification_store import Notification
+from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
 from chia.wallet.signer_protocol import (
     SignedTransaction,
     SigningInstructions,
@@ -26,13 +37,18 @@ from chia.wallet.signer_protocol import (
     UnsignedTransaction,
 )
 from chia.wallet.trade_record import TradeRecord
-from chia.wallet.trading.offer import Offer
+from chia.wallet.trading.offer import Offer, OfferSummary
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.transaction_sorting import SortKey
 from chia.wallet.util.clvm_streamable import json_deserialize_with_clvm_streamable
 from chia.wallet.util.puzzle_decorator_type import PuzzleDecoratorType
 from chia.wallet.util.query_filter import TransactionTypeFilter
-from chia.wallet.util.tx_config import CoinSelectionConfig, CoinSelectionConfigLoader, TXConfig
+from chia.wallet.util.tx_config import (
+    CoinSelectionConfig,
+    CoinSelectionConfigLoader,
+    TXConfig,
+)
+from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.vc_wallet.vc_store import VCProofs, VCRecord
 from chia.wallet.wallet_info import WalletInfo
 from chia.wallet.wallet_node import Balance
@@ -64,14 +80,14 @@ class LogInResponse(Streamable):
 @streamable
 @dataclass(frozen=True)
 class GetLoggedInFingerprintResponse(Streamable):
-    fingerprint: Optional[uint32]
+    fingerprint: uint32 | None
 
 
 @streamable
 @dataclass(frozen=True)
 class GetPublicKeysResponse(Streamable):
     keyring_is_locked: bool
-    public_key_fingerprints: Optional[list[uint32]] = None
+    public_key_fingerprints: list[uint32] | None = None
 
     @property
     def pk_fingerprints(self) -> list[uint32]:
@@ -97,7 +113,7 @@ class GetPrivateKeyFormat(Streamable):
     pk: G1Element
     farmer_pk: G1Element
     pool_pk: G1Element
-    seed: Optional[str]
+    seed: str | None
 
 
 @streamable
@@ -116,7 +132,7 @@ class GenerateMnemonicResponse(Streamable):
 @dataclass(frozen=True)
 class AddKey(Streamable):
     mnemonic: list[str]
-    label: Optional[str] = None
+    label: str | None = None
 
 
 @streamable
@@ -199,7 +215,7 @@ class GetTimestampForHeightResponse(Streamable):
 @streamable
 @dataclass(frozen=True)
 class GetWallets(Streamable):
-    type: Optional[uint16] = None
+    type: uint16 | None = None
     include_data: bool = True
 
 
@@ -215,7 +231,7 @@ class WalletInfoResponse(WalletInfo):
 @dataclass(frozen=True)
 class GetWalletsResponse(Streamable):
     wallets: list[WalletInfoResponse]
-    fingerprint: Optional[uint32] = None
+    fingerprint: uint32 | None = None
 
 
 @streamable
@@ -227,7 +243,7 @@ class GetWalletBalance(Streamable):
 @streamable
 @dataclass(frozen=True)
 class GetWalletBalances(Streamable):
-    wallet_ids: Optional[list[uint32]] = None
+    wallet_ids: list[uint32] | None = None
 
 
 # utility for GetWalletBalanceResponse(s)
@@ -236,9 +252,9 @@ class GetWalletBalances(Streamable):
 class BalanceResponse(Balance):
     wallet_id: uint32 = field(default_factory=default_raise)
     wallet_type: uint8 = field(default_factory=default_raise)
-    fingerprint: Optional[uint32] = None
-    asset_id: Optional[bytes32] = None
-    pending_approval_balance: Optional[uint64] = None
+    fingerprint: uint32 | None = None
+    asset_id: bytes32 | None = None
+    pending_approval_balance: uint64 | None = None
 
 
 @streamable
@@ -270,13 +286,13 @@ class GetTransactionResponse(Streamable):
 @dataclass(frozen=True)
 class GetTransactions(Streamable):
     wallet_id: uint32
-    start: Optional[uint16] = None
-    end: Optional[uint16] = None
-    sort_key: Optional[str] = None
+    start: uint32 | None = None
+    end: uint32 | None = None
+    sort_key: str | None = None
     reverse: bool = False
-    to_address: Optional[str] = None
-    type_filter: Optional[TransactionTypeFilter] = None
-    confirmed: Optional[bool] = None
+    to_address: str | None = None
+    type_filter: TransactionTypeFilter | None = None
+    confirmed: bool | None = None
 
     def __post_init__(self) -> None:
         if self.sort_key is not None and not hasattr(SortKey, self.sort_key):
@@ -323,7 +339,7 @@ class TransactionRecordMetadata:
 @streamable
 @dataclass(frozen=True)
 class TransactionRecordWithMetadata(TransactionRecord):
-    metadata: Optional[TransactionRecordMetadata] = None
+    metadata: TransactionRecordMetadata | None = None
 
 
 @streamable
@@ -336,9 +352,9 @@ class GetTransactionsResponse(Streamable):
 @streamable
 @dataclass(frozen=True)
 class GetNotifications(Streamable):
-    ids: Optional[list[bytes32]] = None
-    start: Optional[uint32] = None
-    end: Optional[uint32] = None
+    ids: list[bytes32] | None = None
+    start: uint32 | None = None
+    end: uint32 | None = None
 
 
 @streamable
@@ -350,7 +366,7 @@ class GetNotificationsResponse(Streamable):
 @streamable
 @dataclass(frozen=True)
 class DeleteNotifications(Streamable):
-    ids: Optional[list[bytes32]] = None
+    ids: list[bytes32] | None = None
 
 
 @streamable
@@ -359,15 +375,38 @@ class VerifySignature(Streamable):
     message: str
     pubkey: G1Element
     signature: G2Element
-    signing_mode: Optional[str] = None
-    address: Optional[str] = None
+    signing_mode: str | None = None
+    address: str | None = None
+
+    @property
+    def signing_mode_enum(self) -> SigningMode:
+        # 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 self.signing_mode is None:
+            return SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT
+        else:
+            try:
+                return SigningMode(self.signing_mode)
+            except ValueError:
+                raise ValueError(f"Invalid signing mode: {self.signing_mode!r}")
 
 
 @streamable
 @dataclass(frozen=True)
 class VerifySignatureResponse(Streamable):
     isValid: bool
-    error: Optional[str] = None
+    error: str | None = None
+
+
+def signing_mode_enum(request: SignMessageByAddress | SignMessageByID) -> SigningMode:
+    if request.is_hex and request.safe_mode:
+        return SigningMode.CHIP_0002_HEX_INPUT
+    elif not request.is_hex and not request.safe_mode:
+        return SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT
+    elif request.is_hex and not request.safe_mode:
+        return SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT
+
+    return SigningMode.CHIP_0002
 
 
 @streamable
@@ -378,6 +417,10 @@ class SignMessageByAddress(Streamable):
     is_hex: bool = False
     safe_mode: bool = True
 
+    @property
+    def signing_mode_enum(self) -> SigningMode:
+        return signing_mode_enum(self)
+
 
 @streamable
 @dataclass(frozen=True)
@@ -395,6 +438,10 @@ class SignMessageByID(Streamable):
     is_hex: bool = False
     safe_mode: bool = True
 
+    @property
+    def signing_mode_enum(self) -> SigningMode:
+        return signing_mode_enum(self)
+
 
 @streamable
 @dataclass(frozen=True)
@@ -441,8 +488,8 @@ class GetTransactionMemoResponse(Streamable):
 @dataclass(frozen=True)
 class GetTransactionCount(Streamable):
     wallet_id: uint32
-    confirmed: Optional[bool] = None
-    type_filter: Optional[TransactionTypeFilter] = None
+    confirmed: bool | None = None
+    type_filter: TransactionTypeFilter | None = None
 
 
 @streamable
@@ -478,7 +525,7 @@ class DeleteUnconfirmedTransactions(Streamable):
 class SelectCoins(CoinSelectionConfigLoader):
     wallet_id: uint32 = field(default_factory=default_raise)
     amount: uint64 = field(default_factory=default_raise)
-    exclude_coins: Optional[list[Coin]] = None  # for backwards compatibility
+    exclude_coins: list[Coin] | None = None  # for backwards compatibility
 
     def __post_init__(self) -> None:
         if self.excluded_coin_ids is not None and self.exclude_coins is not None:
@@ -489,7 +536,10 @@ class SelectCoins(CoinSelectionConfigLoader):
 
     @classmethod
     def from_coin_selection_config(
-        cls, wallet_id: uint32, amount: uint64, coin_selection_config: CoinSelectionConfig
+        cls,
+        wallet_id: uint32,
+        amount: uint64,
+        coin_selection_config: CoinSelectionConfig,
     ) -> Self:
         return cls(
             wallet_id=wallet_id,
@@ -535,8 +585,8 @@ class GetSpendableCoinsResponse(Streamable):
 @dataclass(frozen=True)
 class GetCoinRecordsByNames(Streamable):
     names: list[bytes32]
-    start_height: Optional[uint32] = None
-    end_height: Optional[uint32] = None
+    start_height: uint32 | None = None
+    end_height: uint32 | None = None
     include_spent_coins: bool = True
 
 
@@ -549,7 +599,7 @@ class GetCoinRecordsByNamesResponse(Streamable):
 @streamable
 @dataclass(frozen=True)
 class GetCurrentDerivationIndexResponse(Streamable):
-    index: Optional[uint32]
+    index: uint32 | None
 
 
 @streamable
@@ -561,7 +611,7 @@ class ExtendDerivationIndex(Streamable):
 @streamable
 @dataclass(frozen=True)
 class ExtendDerivationIndexResponse(Streamable):
-    index: Optional[uint32]
+    index: uint32 | None
 
 
 @streamable
@@ -649,8 +699,53 @@ class CATAssetIDToName(Streamable):
 @streamable
 @dataclass(frozen=True)
 class CATAssetIDToNameResponse(Streamable):
-    wallet_id: Optional[uint32]
-    name: Optional[str]
+    wallet_id: uint32 | None
+    name: str | None
+
+
+@streamable
+@dataclass(frozen=True)
+class GetOfferSummary(Streamable):
+    offer: str
+    advanced: bool = False
+
+    @cached_property
+    def parsed_offer(self) -> Offer:
+        return Offer.from_bech32(self.offer)
+
+
+@streamable
+@dataclass(frozen=True)
+class GetOfferSummaryResponse(Streamable):
+    id: bytes32
+    summary: OfferSummary | None = None
+    data_layer_summary: DataLayerSummary | None = None
+
+    def __post_init__(self) -> None:
+        if self.summary is not None and self.data_layer_summary is not None:
+            raise ValueError("Cannot have both summary and data_layer_summary")
+        elif self.summary is None and self.data_layer_summary is None:
+            raise ValueError("Must have either summary or data_layer_summary")
+        super().__post_init__()
+
+    def to_json_dict(self) -> dict[str, Any]:
+        serialized = super().to_json_dict()
+        if self.data_layer_summary is not None:
+            serialized["summary"] = serialized["data_layer_summary"]
+        del serialized["data_layer_summary"]
+        return serialized
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
+        if isinstance(json_dict["summary"]["offered"], dict):
+            summary: OfferSummary | DataLayerSummary = OfferSummary.from_json_dict(json_dict["summary"])
+        else:
+            summary = DataLayerSummary.from_json_dict(json_dict["summary"])
+        return cls(
+            id=bytes32.from_hexstr(json_dict["id"]),
+            summary=summary if isinstance(summary, OfferSummary) else None,
+            data_layer_summary=summary if isinstance(summary, DataLayerSummary) else None,
+        )
 
 
 @streamable
@@ -706,7 +801,7 @@ class DIDGetInfoResponse(Streamable):
     latest_coin: bytes32
     p2_address: str
     public_key: bytes
-    recovery_list_hash: Optional[bytes32]
+    recovery_list_hash: bytes32 | None
     num_verification: uint16
     metadata: dict[str, str]
     launcher_id: bytes32
@@ -719,9 +814,9 @@ class DIDGetInfoResponse(Streamable):
 @dataclass(frozen=True)
 class DIDFindLostDID(Streamable):
     coin_id: str
-    recovery_list_hash: Optional[bytes32] = None
-    num_verification: Optional[uint16] = None
-    metadata: Optional[dict[str, str]] = None
+    recovery_list_hash: bytes32 | None = None
+    num_verification: uint16 | None = None
+    metadata: dict[str, str] | None = None
 
 
 @streamable
@@ -782,7 +877,7 @@ class DIDGetDID(Streamable):
 class DIDGetDIDResponse(Streamable):
     wallet_id: uint32
     my_did: str
-    coin_id: Optional[bytes32] = None
+    coin_id: bytes32 | None = None
 
 
 @streamable
@@ -801,20 +896,20 @@ class DIDGetMetadataResponse(Streamable):
 @streamable
 @dataclass(frozen=True)
 class NFTCountNFTs(Streamable):
-    wallet_id: Optional[uint32] = None
+    wallet_id: uint32 | None = None
 
 
 @streamable
 @dataclass(frozen=True)
 class NFTCountNFTsResponse(Streamable):
-    wallet_id: Optional[uint32]
+    wallet_id: uint32 | None
     count: uint64
 
 
 @streamable
 @dataclass(frozen=True)
 class NFTGetNFTs(Streamable):
-    wallet_id: Optional[uint32] = None
+    wallet_id: uint32 | None = None
     start_index: uint32 = uint32(0)
     num: uint32 = uint32(50)
 
@@ -822,14 +917,14 @@ class NFTGetNFTs(Streamable):
 @streamable
 @dataclass(frozen=True)
 class NFTGetNFTsResponse(Streamable):
-    wallet_id: Optional[uint32]
+    wallet_id: uint32 | None
     nft_list: list[NFTInfo]
 
 
 @streamable
 @dataclass(frozen=True)
 class NFTGetByDID(Streamable):
-    did_id: Optional[str] = None
+    did_id: str | None = None
 
 
 @streamable
@@ -847,7 +942,7 @@ class NFTGetWalletDID(Streamable):
 @streamable
 @dataclass(frozen=True)
 class NFTGetWalletDIDResponse(Streamable):
-    did_id: Optional[str]
+    did_id: str | None
 
 
 @streamable
@@ -899,7 +994,7 @@ class RoyaltyAsset(Streamable):
 @streamable
 @dataclass(frozen=True)
 class FungibleAsset(Streamable):
-    asset: Optional[str]
+    asset: str | None
     amount: uint64
 
 
@@ -921,7 +1016,7 @@ class NFTCalculateRoyalties(Streamable):
 @dataclass(frozen=True)
 class RoyaltySummary(Streamable):
     royalty_asset: str
-    fungible_asset: Optional[str]
+    fungible_asset: str | None
     royalty_address: str
     royalty_amount: uint64
 
@@ -1013,7 +1108,7 @@ class DLLatestSingleton(Streamable):
 @streamable
 @dataclass(frozen=True)
 class DLLatestSingletonResponse(Streamable):
-    singleton: Optional[SingletonRecord]
+    singleton: SingletonRecord | None
 
 
 @streamable
@@ -1033,9 +1128,9 @@ class DLSingletonsByRootResponse(Streamable):
 @dataclass(frozen=True)
 class DLHistory(Streamable):
     launcher_id: bytes32
-    min_generation: Optional[uint32] = None
-    max_generation: Optional[uint32] = None
-    num_results: Optional[uint32] = None
+    min_generation: uint32 | None = None
+    max_generation: uint32 | None = None
+    num_results: uint32 | None = None
 
 
 @streamable
@@ -1073,7 +1168,7 @@ class VCGet(Streamable):
 @streamable
 @dataclass(frozen=True)
 class VCGetResponse(Streamable):
-    vc_record: Optional[VCRecord]
+    vc_record: VCRecord | None
 
 
 @streamable
@@ -1102,7 +1197,7 @@ class VCProofsRPC(Streamable):
 @dataclass(frozen=True)
 class VCProofWithHash(Streamable):
     hash: bytes32
-    proof: Optional[VCProofsRPC]
+    proof: VCProofsRPC | None
 
 
 # utility for VCGetListResponse
@@ -1124,7 +1219,7 @@ class VCGetListResponse(Streamable):
     proofs: list[VCProofWithHash]
 
     @property
-    def proof_dict(self) -> dict[bytes32, Optional[dict[str, str]]]:
+    def proof_dict(self) -> dict[bytes32, dict[str, str] | None]:
         return {
             pwh.hash: None if pwh.proof is None else {key: value for key, value in pwh.proof.key_value_pairs}
             for pwh in self.proofs
@@ -1230,8 +1325,8 @@ class ExecuteSigningInstructionsResponse(Streamable):
 @dataclass(frozen=True, kw_only=True)
 class TransactionEndpointRequest(Streamable):
     fee: uint64 = uint64(0)
-    push: Optional[bool] = None
-    sign: Optional[bool] = None
+    push: bool | None = None
+    sign: bool | None = None
 
     def to_json_dict(self, _avoid_ban: bool = False) -> dict[str, Any]:
         if not _avoid_ban:
@@ -1242,7 +1337,10 @@ class TransactionEndpointRequest(Streamable):
             return super().to_json_dict()
 
     def json_serialize_for_transport(
-        self, tx_config: TXConfig, extra_conditions: tuple[Condition, ...], timelock_info: ConditionValidTimes
+        self,
+        tx_config: TXConfig,
+        extra_conditions: tuple[Condition, ...],
+        timelock_info: ConditionValidTimes,
     ) -> dict[str, Any]:
         return {
             **tx_config.to_json_dict(),
@@ -1282,7 +1380,7 @@ class SendTransaction(TransactionEndpointRequest):
     # Technically this value was meant to support many types here
     # However, only one is supported right now and there are no plans to extend
     # So, as a slight hack, we'll specify that only Clawback is supported
-    puzzle_decorator: Optional[list[ClawbackPuzzleDecoratorOverride]] = None
+    puzzle_decorator: list[ClawbackPuzzleDecoratorOverride] | None = None
 
 
 @streamable
@@ -1296,7 +1394,7 @@ class SendTransactionResponse(TransactionEndpointResponse):
 @dataclass(frozen=True)
 class SpendClawbackCoins(TransactionEndpointRequest):
     coin_ids: list[bytes32] = field(default_factory=default_raise)
-    batch_size: Optional[uint16] = None
+    batch_size: uint16 | None = None
     force: bool = False
 
 
@@ -1324,7 +1422,7 @@ class SendNotificationResponse(TransactionEndpointResponse):
 @dataclass(frozen=True)
 class PushTransactions(TransactionEndpointRequest):
     transactions: list[TransactionRecord] = field(default_factory=default_raise)
-    push: Optional[bool] = True
+    push: bool | None = True
 
     # We allow for flexibility in transaction parsing here so we need to override
     @classmethod
@@ -1355,6 +1453,12 @@ class SplitCoins(TransactionEndpointRequest):
     amount_per_coin: uint64 = field(default_factory=default_raise)
     target_coin_id: bytes32 = field(default_factory=default_raise)
 
+    def __post_init__(self) -> None:
+        if self.number_of_coins > 500:
+            raise ValueError(f"{self.number_of_coins} coins is greater then the maximum limit of 500 coins.")
+        if self.number_of_coins == 0:
+            raise ValueError("Cannot split into 0 new coins")
+
 
 @streamable
 @dataclass(frozen=True)
@@ -1369,9 +1473,19 @@ class CombineCoins(TransactionEndpointRequest):
     number_of_coins: uint16 = uint16(500)
     largest_first: bool = False
     target_coin_ids: list[bytes32] = field(default_factory=list)
-    target_coin_amount: Optional[uint64] = None
+    target_coin_amount: uint64 | None = None
     coin_num_limit: uint16 = uint16(500)
 
+    def __post_init__(self) -> None:
+        if self.number_of_coins > self.coin_num_limit:
+            raise ValueError(
+                f"{self.number_of_coins} coins is greater then the maximum limit of {self.coin_num_limit} coins."
+            )
+        if self.number_of_coins < 2:
+            raise ValueError("You need at least two coins to combine")
+        if len(self.target_coin_ids) > self.number_of_coins:
+            raise ValueError("More coin IDs specified than desired number of coins to combine")
+
 
 @streamable
 @dataclass(frozen=True)
@@ -1379,28 +1493,28 @@ class CombineCoinsResponse(TransactionEndpointResponse):
     pass
 
 
-# utility for CATSpend
+# utility for CATSpend/CreateSignedTransaction
 # unfortunate that we can't use CreateCoin but the memos are taken as strings not bytes
 @streamable
 @dataclass(frozen=True)
 class Addition(Streamable):
     amount: uint64
     puzzle_hash: bytes32
-    memos: Optional[list[str]] = None
+    memos: list[str] | None = None
 
 
 @streamable
 @dataclass(frozen=True, kw_only=True)
 class CATSpend(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
-    additions: Optional[list[Addition]] = None
-    amount: Optional[uint64] = None
-    inner_address: Optional[str] = None
-    memos: Optional[list[str]] = None
-    coins: Optional[list[Coin]] = None
-    extra_delta: Optional[str] = None  # str to support negative ints :(
-    tail_reveal: Optional[bytes] = None
-    tail_solution: Optional[bytes] = None
+    additions: list[Addition] | None = None
+    amount: uint64 | None = None
+    inner_address: str | None = None
+    memos: list[str] | None = None
+    coins: list[Coin] | None = None
+    extra_delta: str | None = None  # str to support negative ints :(
+    tail_reveal: bytes | None = None
+    tail_solution: bytes | None = None
 
     def __post_init__(self) -> None:
         if (
@@ -1413,7 +1527,7 @@ class CATSpend(TransactionEndpointRequest):
         super().__post_init__()
 
     @property
-    def cat_discrepancy(self) -> Optional[tuple[int, Program, Program]]:
+    def cat_discrepancy(self) -> tuple[int, Program, Program] | None:
         if self.extra_delta is None and self.tail_reveal is None and self.tail_solution is None:
             return None
         elif None in {self.extra_delta, self.tail_reveal, self.tail_solution}:
@@ -1486,8 +1600,8 @@ class DIDTransferDIDResponse(TransactionEndpointResponse):
 @dataclass(frozen=True, kw_only=True)
 class NFTMintNFTRequest(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
-    royalty_address: Optional[str] = field(default_factory=default_raise)
-    target_address: Optional[str] = field(default_factory=default_raise)
+    royalty_address: str | None = field(default_factory=default_raise)
+    target_address: str | None = field(default_factory=default_raise)
     uris: list[str] = field(default_factory=default_raise)
     hash: bytes32 = field(default_factory=default_raise)
     royalty_amount: uint16 = uint16(0)
@@ -1495,9 +1609,9 @@ class NFTMintNFTRequest(TransactionEndpointRequest):
     license_uris: list[str] = field(default_factory=list)
     edition_number: uint64 = uint64(1)
     edition_total: uint64 = uint64(1)
-    meta_hash: Optional[bytes32] = None
-    license_hash: Optional[bytes32] = None
-    did_id: Optional[str] = None
+    meta_hash: bytes32 | None = None
+    license_hash: bytes32 | None = None
+    did_id: str | None = None
 
 
 @streamable
@@ -1513,7 +1627,7 @@ class NFTMintNFTResponse(TransactionEndpointResponse):
 class NFTSetNFTDID(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
     nft_coin_id: bytes32 = field(default_factory=default_raise)
-    did_id: Optional[str] = None
+    did_id: str | None = None
 
 
 @streamable
@@ -1527,7 +1641,7 @@ class NFTSetNFTDIDResponse(TransactionEndpointResponse):
 @dataclass(frozen=True, kw_only=True)
 class NFTSetDIDBulk(TransactionEndpointRequest):
     nft_coin_list: list[NFTCoin] = field(default_factory=default_raise)
-    did_id: Optional[str] = None
+    did_id: str | None = None
 
 
 @streamable
@@ -1692,8 +1806,8 @@ class NFTMintMetadata(Streamable):
     license_uris: list[str] = field(default_factory=list)
     edition_number: uint64 = uint64(1)
     edition_total: uint64 = uint64(1)
-    meta_hash: Optional[bytes32] = None
-    license_hash: Optional[bytes32] = None
+    meta_hash: bytes32 | None = None
+    license_hash: bytes32 | None = None
 
 
 @streamable
@@ -1701,17 +1815,17 @@ class NFTMintMetadata(Streamable):
 class NFTMintBulk(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
     metadata_list: list[NFTMintMetadata] = field(default_factory=default_raise)
-    royalty_address: Optional[str] = None
-    royalty_percentage: Optional[uint16] = None
+    royalty_address: str | None = None
+    royalty_percentage: uint16 | None = None
     target_list: list[str] = field(default_factory=list)
     mint_number_start: uint16 = uint16(1)
-    mint_total: Optional[uint16] = None
-    xch_coins: Optional[list[Coin]] = None
-    xch_change_target: Optional[str] = None
-    new_innerpuzhash: Optional[bytes32] = None
-    new_p2_puzhash: Optional[bytes32] = None
-    did_coin: Optional[Coin] = None
-    did_lineage_parent: Optional[bytes32] = None
+    mint_total: uint16 | None = None
+    xch_coins: list[Coin] | None = None
+    xch_change_target: str | None = None
+    new_innerpuzhash: bytes32 | None = None
+    new_p2_puzhash: bytes32 | None = None
+    did_coin: Coin | None = None
+    did_lineage_parent: bytes32 | None = None
     mint_from_did: bool = False
 
 
@@ -1736,7 +1850,7 @@ class PWJoinPool(TransactionEndpointRequest):
 class PWJoinPoolResponse(TransactionEndpointResponse):
     total_fee: uint64
     transaction: TransactionRecord
-    fee_transaction: Optional[TransactionRecord]
+    fee_transaction: TransactionRecord | None
 
 
 @streamable
@@ -1750,14 +1864,14 @@ class PWSelfPool(TransactionEndpointRequest):
 class PWSelfPoolResponse(TransactionEndpointResponse):
     total_fee: uint64
     transaction: TransactionRecord
-    fee_transaction: Optional[TransactionRecord]
+    fee_transaction: TransactionRecord | None
 
 
 @streamable
 @dataclass(frozen=True)
 class PWAbsorbRewards(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
-    max_spends_in_tx: Optional[uint16] = None
+    max_spends_in_tx: uint16 | None = None
 
 
 @streamable
@@ -1765,14 +1879,14 @@ class PWAbsorbRewards(TransactionEndpointRequest):
 class PWAbsorbRewardsResponse(TransactionEndpointResponse):
     state: PoolWalletInfo
     transaction: TransactionRecord
-    fee_transaction: Optional[TransactionRecord]
+    fee_transaction: TransactionRecord | None
 
 
 @streamable
 @dataclass(frozen=True)
 class VCMint(TransactionEndpointRequest):
     did_id: str = field(default_factory=default_raise)
-    target_address: Optional[str] = None
+    target_address: str | None = None
 
 
 @streamable
@@ -1785,9 +1899,9 @@ class VCMintResponse(TransactionEndpointResponse):
 @dataclass(frozen=True)
 class VCSpend(TransactionEndpointRequest):
     vc_id: bytes32 = field(default_factory=default_raise)
-    new_puzhash: Optional[bytes32] = None
-    new_proof_hash: Optional[bytes32] = None
-    provider_inner_puzhash: Optional[bytes32] = None
+    new_puzhash: bytes32 | None = None
+    new_proof_hash: bytes32 | None = None
+    provider_inner_puzhash: bytes32 | None = None
 
 
 @streamable
@@ -1808,15 +1922,61 @@ class VCRevokeResponse(TransactionEndpointResponse):
     pass
 
 
-# TODO: The section below needs corresponding request types
-# TODO: The section below should be added to the API (currently only for client)
+@streamable
+@dataclass(frozen=True)
+class CSTCoinAnnouncement(Streamable):
+    coin_id: bytes32
+    message: bytes
 
 
 @streamable
 @dataclass(frozen=True)
-class SendTransactionMultiResponse(TransactionEndpointResponse):
-    transaction: TransactionRecord
-    transaction_id: bytes32
+class CSTPuzzleAnnouncement(Streamable):
+    puzzle_hash: bytes32
+    message: bytes
+
+
+@streamable
+@dataclass(frozen=True)
+class CreateSignedTransaction(TransactionEndpointRequest):
+    additions: list[Addition] = field(default_factory=default_raise)
+    wallet_id: uint32 | None = None
+    coins: list[Coin] | None = None
+    morph_bytes: bytes | None = None
+    coin_announcements: list[CSTCoinAnnouncement] = field(default_factory=list)
+    puzzle_announcements: list[CSTPuzzleAnnouncement] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        if len(self.additions) < 1:
+            raise ValueError("Must have at least one addition")
+        super().__post_init__()
+
+    @property
+    def coin_set(self) -> set[Coin] | None:
+        if self.coins is None:
+            return None
+        else:
+            return set(self.coins)
+
+    @property
+    def asserted_coin_announcements(self) -> tuple[AssertCoinAnnouncement, ...]:
+        return tuple(
+            AssertCoinAnnouncement(
+                asserted_id=ca.coin_id,
+                asserted_msg=(ca.message if self.morph_bytes is None else std_hash(self.morph_bytes + ca.message)),
+            )
+            for ca in self.coin_announcements
+        )
+
+    @property
+    def asserted_puzzle_announcements(self) -> tuple[AssertPuzzleAnnouncement, ...]:
+        return tuple(
+            AssertPuzzleAnnouncement(
+                asserted_ph=pa.puzzle_hash,
+                asserted_msg=(pa.message if self.morph_bytes is None else std_hash(self.morph_bytes + pa.message)),
+            )
+            for pa in self.puzzle_announcements
+        )
 
 
 @streamable
@@ -1826,12 +1986,113 @@ class CreateSignedTransactionsResponse(TransactionEndpointResponse):
     signed_tx: TransactionRecord
 
 
+_T_SendTransactionMultiProxy = TypeVar("_T_SendTransactionMultiProxy", CATSpend, CreateSignedTransaction)
+
+
+@streamable
+@dataclass(frozen=True)
+class SendTransactionMulti(TransactionEndpointRequest):
+    # primarily for cat_spend
+    wallet_id: uint32 = field(default_factory=default_raise)
+    additions: list[Addition] | None = None  # for both
+    amount: uint64 | None = None
+    inner_address: str | None = None
+    memos: list[str] | None = None
+    coins: list[Coin] | None = None  # for both
+    extra_delta: str | None = None  # str to support negative ints :(
+    tail_reveal: bytes | None = None
+    tail_solution: bytes | None = None
+    # for create_signed_transaction
+    morph_bytes: bytes | None = None
+    coin_announcements: list[CSTCoinAnnouncement] | None = None
+    puzzle_announcements: list[CSTPuzzleAnnouncement] | None = None
+
+    def convert_to_proxy(self, proxy_type: type[_T_SendTransactionMultiProxy]) -> _T_SendTransactionMultiProxy:
+        if proxy_type is CATSpend:
+            if self.morph_bytes is not None:
+                raise ValueError(
+                    'Specified "morph_bytes" for a CAT-type wallet. Maybe you meant to specify an XCH wallet?'
+                )
+            elif self.coin_announcements is not None or self.puzzle_announcements is not None:
+                raise ValueError(
+                    'Specified "coin/puzzle_announcements" for a CAT-type wallet.'
+                    "Maybe you meant to specify an XCH wallet?"
+                )
+
+            # not sure why mypy hasn't understood this is purely a CATSpend
+            return proxy_type(
+                wallet_id=self.wallet_id,
+                additions=self.additions,  # type: ignore[arg-type]
+                amount=self.amount,  # type: ignore[call-arg]
+                inner_address=self.inner_address,
+                memos=self.memos,
+                coins=self.coins,
+                extra_delta=self.extra_delta,
+                tail_reveal=self.tail_reveal,
+                tail_solution=self.tail_solution,
+                fee=self.fee,
+                push=self.push,
+                sign=self.sign,
+            )
+        elif proxy_type is CreateSignedTransaction:
+            if self.amount is not None:
+                raise ValueError('Specified "amount" for an XCH wallet. Maybe you meant to specify a CAT-type wallet?')
+            elif self.inner_address is not None:
+                raise ValueError(
+                    'Specified "inner_address" for an XCH wallet. Maybe you meant to specify a CAT-type wallet?'
+                )
+            elif self.memos is not None:
+                raise ValueError('Specified "memos" for an XCH wallet. Maybe you meant to specify a CAT-type wallet?')
+            elif self.extra_delta is not None or self.tail_reveal is not None or self.tail_solution is not None:
+                raise ValueError(
+                    'Specified "extra_delta", "tail_reveal", or "tail_solution" for an XCH wallet.'
+                    "Maybe you meant to specify a CAT-type wallet?"
+                )
+            elif self.additions is None:
+                raise ValueError('"additions" are required for XCH wallets.')
+
+            # not sure why mypy hasn't understood this is purely a CreateSignedTransaction
+            return proxy_type(
+                additions=self.additions,
+                wallet_id=self.wallet_id,
+                coins=self.coins,
+                morph_bytes=self.morph_bytes,  # type: ignore[call-arg]
+                coin_announcements=self.coin_announcements if self.coin_announcements is not None else [],
+                puzzle_announcements=self.puzzle_announcements if self.puzzle_announcements is not None else [],
+                fee=self.fee,
+                push=self.push,
+                sign=self.sign,
+            )
+        else:
+            raise ValueError("An unsupported wallet type was selected for `send_transaction_multi`")
+
+
+@streamable
+@dataclass(frozen=True)
+class SendTransactionMultiResponse(TransactionEndpointResponse):
+    transaction: TransactionRecord
+    transaction_id: bytes32
+
+
 @streamable
 @dataclass(frozen=True)
 class _OfferEndpointResponse(TransactionEndpointResponse):
-    offer: Offer
+    offer: Offer  # gotta figure out how to ignore this in streamable
     trade_record: TradeRecord
 
+    def to_json_dict(self) -> dict[str, Any]:
+        old_offer_override = getattr(self.offer, "json_serialization_override", None)
+        object.__setattr__(self.offer, "json_serialization_override", lambda o: o.to_bech32())
+        try:
+            response = {
+                **super().to_json_dict(),
+                "trade_record": self.trade_record.to_json_dict_convenience(),
+            }
+        except Exception:
+            object.__setattr__(self.offer, "json_serialization_override", old_offer_override)
+            raise
+        return response
+
     @classmethod
     def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
         tx_endpoint: TransactionEndpointResponse = json_deserialize_with_clvm_streamable(
@@ -1846,25 +2107,428 @@ class _OfferEndpointResponse(TransactionEndpointResponse):
         )
 
 
+@streamable
+@dataclass(frozen=True)
+class CreateOfferForIDs(TransactionEndpointRequest):
+    # a hack for dict[str, int] because streamable doesn't support negative ints
+    offer: dict[str, str] = field(default_factory=default_raise)
+    driver_dict: dict[bytes32, PuzzleInfo] | None = None
+    solver: Solver | None = None
+    validate_only: bool = False
+
+    @property
+    def offer_spec(self) -> dict[int | bytes32, int]:
+        modified_offer: dict[int | bytes32, int] = {}
+        for wallet_identifier, change in self.offer.items():
+            if len(wallet_identifier) > 16:  # wallet IDs are uint32 therefore no longer than 8 bytes :P
+                modified_offer[bytes32.from_hexstr(wallet_identifier)] = int(change)
+            else:
+                modified_offer[int(wallet_identifier)] = int(change)
+
+        return modified_offer
+
+
 @streamable
 @dataclass(frozen=True)
 class CreateOfferForIDsResponse(_OfferEndpointResponse):
     pass
 
 
+@streamable
+@dataclass(frozen=True)
+class TakeOffer(TransactionEndpointRequest):
+    offer: str = field(default_factory=default_raise)
+    solver: Solver | None = None
+
+    @cached_property
+    def parsed_offer(self) -> Offer:
+        return Offer.from_bech32(self.offer)
+
+
 @streamable
 @dataclass(frozen=True)
 class TakeOfferResponse(_OfferEndpointResponse):  # Inheriting for de-dup sake
     pass
 
 
+@streamable
+@dataclass(frozen=True)
+class GetOffer(Streamable):
+    trade_id: bytes32
+    file_contents: bool = False
+
+
+@streamable
+@dataclass(frozen=True)
+class GetOfferResponse(Streamable):
+    offer: str | None
+    trade_record: TradeRecord
+
+    def to_json_dict(self) -> dict[str, Any]:
+        return {
+            **super().to_json_dict(),
+            "trade_record": self.trade_record.to_json_dict_convenience(),
+        }
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
+        return cls(
+            offer=json_dict["offer"],
+            trade_record=TradeRecord.from_json_dict_convenience(
+                json_dict["trade_record"],
+                bytes(Offer.from_bech32(json_dict["offer"])).hex() if json_dict["offer"] is not None else "",
+            ),
+        )
+
+
+@streamable
+@dataclass(frozen=True)
+class GetAllOffers(Streamable):
+    start: uint16 = uint16(0)
+    end: uint16 = uint16(10)
+    exclude_my_offers: bool = False
+    exclude_taken_offers: bool = False
+    include_completed: bool = False
+    sort_key: str | None = None
+    reverse: bool = False
+    file_contents: bool = False
+
+
+@streamable
+@dataclass(frozen=True)
+class GetAllOffersResponse(Streamable):
+    offers: list[str] | None
+    trade_records: list[TradeRecord]
+
+    def to_json_dict(self) -> dict[str, Any]:
+        return {
+            **super().to_json_dict(),
+            "trade_records": [tr.to_json_dict_convenience() for tr in self.trade_records],
+        }
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
+        return cls(
+            offers=json_dict["offers"],
+            trade_records=[
+                TradeRecord.from_json_dict_convenience(
+                    json_tr,
+                    bytes(Offer.from_bech32(json_dict["offers"][i])).hex() if json_dict["offers"] is not None else "",
+                )
+                for i, json_tr in enumerate(json_dict["trade_records"])
+            ],
+        )
+
+
+@streamable
+@dataclass(frozen=True)
+class CancelOffer(TransactionEndpointRequest):
+    trade_id: bytes32 = field(default_factory=default_raise)
+    secure: bool = field(default_factory=default_raise)
+
+
 @streamable
 @dataclass(frozen=True)
 class CancelOfferResponse(TransactionEndpointResponse):
     pass
 
 
+@streamable
+@dataclass(frozen=True)
+class CancelOffers(TransactionEndpointRequest):
+    secure: bool = field(default_factory=default_raise)
+    batch_fee: uint64 = uint64(0)
+    batch_size: uint16 = uint16(5)
+    cancel_all: bool = False
+    asset_id: str = "xch"
+
+    @property
+    def query_key(self) -> bytes32 | None:
+        if self.cancel_all:
+            return None
+        if self.asset_id != "xch":
+            return bytes32.from_hexstr(self.asset_id)
+        return None
+
+
 @streamable
 @dataclass(frozen=True)
 class CancelOffersResponse(TransactionEndpointResponse):
     pass
+
+
+# utilities for CreateNewWallet
+@streamable_enum(str)
+class CreateNewWalletType(Enum):
+    CAT_WALLET = "cat_wallet"
+    DID_WALLET = "did_wallet"
+    NFT_WALLET = "nft_wallet"
+    POOL_WALLET = "pool_wallet"
+
+
+@streamable_enum(str)
+class WalletCreationMode(Enum):
+    NEW = "new"
+    EXISTING = "existing"
+
+
+@streamable_enum(str)
+class DIDType(Enum):
+    NEW = "new"
+    RECOVERY = "recovery"
+
+
+@streamable
+@dataclass(frozen=True)
+class CreateNewWallet(TransactionEndpointRequest):
+    wallet_type: CreateNewWalletType = field(default_factory=default_raise)
+    # CAT_WALLET
+    mode: WalletCreationMode | None = None  # required
+    amount: uint64 | None = None  # required in "new"
+    name: str | None = None  # If not provided, the name will be autogenerated based on the tail hash
+    test: bool = False  # must be True in "new"
+    asset_id: bytes32 | None = None  # required in "existing"
+
+    # DID_WALLET
+    did_type: DIDType | None = None  # required
+    # only in "new"
+    # amount: uint64  # already defined, required
+    backup_dids: list[str] = field(default_factory=list)  # must error if not []
+    metadata: dict[str, str] = field(default_factory=dict)
+    wallet_name: str | None = None
+    # only in "recovery"
+    backup_data: str | None = None  # required
+
+    # NFT_WALLET
+    did_id: str | None = None
+    # name: Optional[str] = None  # already defined
+
+    # POOL_WALLET
+    # mode: WalletCreationMode  # already defined, required, must be "new"
+    initial_target_state: NewPoolWalletInitialTargetState | None = None  # required
+    p2_singleton_delayed_ph: bytes32 | None = None
+    p2_singleton_delay_time: uint64 | None = None
+
+    def __post_init__(self) -> None:
+        if self.wallet_type == CreateNewWalletType.CAT_WALLET:
+            if self.mode is None:
+                raise ValueError('Must specify a "mode" when creating a new CAT wallet')
+            if self.mode == WalletCreationMode.NEW:
+                if not self.test:
+                    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 self.amount is None:
+                    raise ValueError('Must specify an "amount" of CATs to generate')
+                if self.asset_id is not None:
+                    raise ValueError('"asset_id" is not an argument for new CAT wallets. Maybe you meant existing?')
+            if self.mode == WalletCreationMode.EXISTING:
+                if self.asset_id is None:
+                    raise ValueError('Must specify an "asset_id" when creating an existing CAT wallet')
+                if self.amount is not None:
+                    raise ValueError('"amount" is not an argument for existing CAT wallets')
+        elif self.test:
+            raise ValueError('"test" mode is not supported except for new CAT wallets')
+        else:
+            if self.asset_id is not None:
+                raise ValueError(
+                    '"asset_id" is not a valid argument. Maybe you meant to create an existing CAT wallet?'
+                )
+            if self.mode is not None and self.mode != WalletCreationMode.NEW:
+                raise ValueError('"mode": "existing" is only valid for CAT wallets')
+
+        if self.wallet_type == CreateNewWalletType.DID_WALLET:
+            if self.did_type is None:
+                raise ValueError('Must specify "did_type": "new/recovery"')
+            if self.did_type == DIDType.NEW:
+                if self.amount is None:
+                    raise ValueError('Must specify an "amount" when creating a new DID')
+                if self.backup_dids != []:
+                    raise ValueError('Recovery options are no longer supported. "backup_dids" cannot be set.')
+                if self.backup_data is not None:
+                    raise ValueError('"backup_data" is only an option in "did_type": "recovery"')
+            if self.did_type == DIDType.RECOVERY:
+                if self.amount is not None:
+                    raise ValueError('Cannot specify an "amount" when recovering a DID')
+                if self.backup_dids != []:
+                    raise ValueError('Cannot specify "backup_dids" when recovering a DID')
+                if self.metadata != {}:
+                    raise ValueError('Cannot specify "metadata" when recovering a DID')
+                if self.backup_data is None:
+                    raise ValueError('Must specify "backup_data" when recovering a DID')
+        else:
+            if self.did_type is not None:
+                raise ValueError('"did_type" is only a valid argument for DID wallets')
+            if self.backup_dids != []:
+                raise ValueError('"backup_dids" is only a valid argument for DID wallets')
+            if self.metadata != {}:
+                raise ValueError('"metadata" is only a valid argument for DID wallets')
+            if self.wallet_name is not None:
+                raise ValueError('"wallet_name" is only a valid argument for DID wallets')
+            if self.backup_data is not None:
+                raise ValueError('"backup_data" is only a valid argument for DID wallets')
+
+        if self.wallet_type != CreateNewWalletType.NFT_WALLET and self.did_id is not None:
+            raise ValueError('"did_id" is only a valid argument for NFT wallets')
+
+        if self.wallet_type == CreateNewWalletType.POOL_WALLET:
+            if self.initial_target_state is None:
+                raise ValueError('"initial_target_state" is required for new pool wallets')
+        else:
+            if self.initial_target_state is not None:
+                raise ValueError('"initial_target_state" is only a valid argument for pool wallets')
+            if self.p2_singleton_delayed_ph is not None:
+                raise ValueError('"p2_singleton_delayed_ph" is only a valid argument for pool wallets')
+            if self.p2_singleton_delay_time is not None:
+                raise ValueError('"p2_singleton_delay_time" is only a valid argument for pool wallets')
+
+        super().__post_init__()
+
+
+@streamable
+@dataclass(frozen=True)
+class CreateNewWalletResponse(TransactionEndpointResponse):
+    type: str  # Alias for WalletType which is IntEnum and therefore incompatible
+    wallet_id: uint32
+    # Nothing below is truly optional when that type is being returned
+    # CAT_WALLET (TXEndpoint)
+    asset_id: bytes32 | None = None
+    # DID_WALLET - NEW (TXEndpoint) / RECOVERY
+    my_did: str | None = None
+    # DID_WALLET - RECOVERY
+    coin_name: bytes32 | None = None
+    coin_list: Coin | None = None
+    newpuzhash: bytes32 | None = None
+    pubkey: G1Element | None = None
+    backup_dids: list[bytes32] | None = None
+    num_verifications_required: uint64 | None = None
+    # NFT_WALLET
+    # ...
+    # POOL_WALLET (TXEndpoint)
+    total_fee: uint64 | None = None
+    transaction: TransactionRecord | None = None
+    launcher_id: bytes32 | None = None
+    p2_singleton_puzzle_hash: bytes32 | None = None
+
+    def __post_init__(self) -> None:
+        if self.type not in {member.name for member in WalletType}:
+            raise ValueError(f"Invalid wallet type: {self.type}")
+        super().__post_init__()
+
+    def to_json_dict(self) -> dict[str, Any]:
+        field_names = {"type", "wallet_id"}
+        tx_endpoint_field_names = set(field.name for field in fields(TransactionEndpointResponse))
+        serialization_updates: dict[str, Any] = {}
+        wallet_type = next(member for member in WalletType if member.name == self.type)
+        if wallet_type == WalletType.CAT:
+            if self.asset_id is None:
+                raise ValueError("`asset_id` is required for CAT wallets")
+            field_names |= {"asset_id"}
+            field_names |= tx_endpoint_field_names
+        elif wallet_type == WalletType.DECENTRALIZED_ID:
+            if self.my_did is None:
+                raise ValueError("`my_did` is required for DID wallets")
+            field_names |= {"my_did"}
+            if (
+                self.coin_name is not None
+                and self.coin_list is not None
+                and self.newpuzhash is not None
+                and self.pubkey is not None
+                and self.backup_dids is not None
+                and self.num_verifications_required is not None
+            ):
+                field_names |= {
+                    "coin_name",
+                    "coin_list",
+                    "newpuzhash",
+                    "pubkey",
+                    "backup_dids",
+                    "num_verifications_required",
+                }
+                serialization_updates["coin_list"] = coin_as_list(self.coin_list)
+            elif not (
+                self.coin_name is None
+                and self.coin_list is None
+                and self.newpuzhash is None
+                and self.pubkey is None
+                and self.backup_dids is None
+                and self.num_verifications_required is None
+            ):
+                raise ValueError("Must specify all recovery options or none of them")
+            else:
+                field_names |= tx_endpoint_field_names
+        elif wallet_type == WalletType.POOLING_WALLET:
+            if not (
+                (
+                    self.total_fee is None
+                    and self.transaction is None
+                    and self.launcher_id is None
+                    and self.p2_singleton_puzzle_hash is None
+                )
+                or (
+                    self.total_fee is not None
+                    and self.transaction is not None
+                    and self.launcher_id is not None
+                    and self.p2_singleton_puzzle_hash is not None
+                )
+            ):
+                raise ValueError("Must specify all pooling options or none of them")
+            else:
+                field_names = {  # leaves out wallet_id
+                    "type",
+                    "total_fee",
+                    "transaction",
+                    "launcher_id",
+                    "p2_singleton_puzzle_hash",
+                }
+                field_names |= tx_endpoint_field_names
+
+        return {**{k: v for k, v in super().to_json_dict().items() if k in field_names}, **serialization_updates}
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
+        if "wallet_id" not in json_dict:
+            json_dict["wallet_id"] = uint32(0)
+        if "transactions" not in json_dict:
+            json_dict["transactions"] = []
+        if "unsigned_transactions" not in json_dict:
+            json_dict["unsigned_transactions"] = []
+        if "coin_list" in json_dict:
+            parent_hex, ph_hex, amt = json_dict["coin_list"]
+            json_dict["coin_list"] = Coin(
+                bytes32.from_hexstr(parent_hex), bytes32.from_hexstr(ph_hex), uint64(amt)
+            ).to_json_dict()
+
+        return super().from_json_dict(json_dict)
+
+
+@streamable
+@dataclass(frozen=True)
+class CRCATApprovePending(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+    min_amount_to_claim: uint64 = field(default_factory=default_raise)
+
+
+@streamable
+@dataclass(frozen=True)
+class CRCATApprovePendingResponse(TransactionEndpointResponse):
+    pass
+
+
+@streamable
+@dataclass(frozen=True)
+class GetFarmedAmount(Streamable):
+    include_pool_rewards: bool = False
+
+
+@streamable
+@dataclass(frozen=True)
+class GetFarmedAmountResponse(Streamable):
+    farmed_amount: uint64
+    pool_reward_amount: uint64
+    farmer_reward_amount: uint64
+    fee_amount: uint64
+    last_height_farmed: uint32
+    last_time_farmed: uint64
+    blocks_won: uint32