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

chia/wallet/wallet_request_types.py

@@ -1,21 +1,21 @@
 from __future__ import annotations
 
-import sys
 from dataclasses import dataclass, field
-from typing import Any, Optional, final
+from typing import Any, BinaryIO, Optional, final
 
 from chia_rs import Coin, G1Element, G2Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint16, uint32, uint64
-from typing_extensions import Self, dataclass_transform
+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.singleton_record import SingletonRecord
 from chia.pools.pool_wallet_info import PoolWalletInfo
 from chia.types.blockchain_format.program import Program
+from chia.types.coin_record import CoinRecord
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.streamable import Streamable, streamable
-from chia.wallet.conditions import Condition, ConditionValidTimes
+from chia.wallet.conditions import 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.signer_protocol import (
@@ -28,20 +28,17 @@ from chia.wallet.signer_protocol import (
 from chia.wallet.trade_record import TradeRecord
 from chia.wallet.trading.offer import Offer
 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.tx_config import TXConfig
+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.vc_wallet.vc_store import VCProofs, VCRecord
+from chia.wallet.wallet_info import WalletInfo
+from chia.wallet.wallet_node import Balance
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
-@dataclass_transform(frozen_default=True, kw_only_default=True)
-def kw_only_dataclass(cls: type[Any]) -> type[Any]:
-    if sys.version_info >= (3, 10):
-        return dataclass(frozen=True, kw_only=True)(cls)
-    else:
-        return dataclass(frozen=True)(cls)  # pragma: no cover
-
-
 def default_raise() -> Any:  # pragma: no cover
     raise RuntimeError("This should be impossible to hit and is just for < 3.10 compatibility")
 
@@ -119,6 +116,7 @@ class GenerateMnemonicResponse(Streamable):
 @dataclass(frozen=True)
 class AddKey(Streamable):
     mnemonic: list[str]
+    label: Optional[str] = None
 
 
 @streamable
@@ -198,6 +196,143 @@ class GetTimestampForHeightResponse(Streamable):
     timestamp: uint64
 
 
+@streamable
+@dataclass(frozen=True)
+class GetWallets(Streamable):
+    type: Optional[uint16] = None
+    include_data: bool = True
+
+
+# utility for GetWalletsResponse
+@streamable
+@dataclass(frozen=True)
+class WalletInfoResponse(WalletInfo):
+    authorized_providers: list[bytes32] = field(default_factory=list)
+    flags_needed: list[str] = field(default_factory=list)
+
+
+@streamable
+@dataclass(frozen=True)
+class GetWalletsResponse(Streamable):
+    wallets: list[WalletInfoResponse]
+    fingerprint: Optional[uint32] = None
+
+
+@streamable
+@dataclass(frozen=True)
+class GetWalletBalance(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class GetWalletBalances(Streamable):
+    wallet_ids: Optional[list[uint32]] = None
+
+
+# utility for GetWalletBalanceResponse(s)
+@streamable
+@dataclass(frozen=True, kw_only=True)
+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
+
+
+@streamable
+@dataclass(frozen=True)
+class GetWalletBalanceResponse(Streamable):
+    wallet_balance: BalanceResponse
+
+
+@streamable
+@dataclass(frozen=True)
+class GetWalletBalancesResponse(Streamable):
+    wallet_balances: dict[uint32, BalanceResponse]
+
+
+@streamable
+@dataclass(frozen=True)
+class GetTransaction(Streamable):
+    transaction_id: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class GetTransactionResponse(Streamable):
+    transaction: TransactionRecord
+    transaction_id: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class GetTransactions(Streamable):
+    wallet_id: uint32
+    start: Optional[uint16] = None
+    end: Optional[uint16] = None
+    sort_key: Optional[str] = None
+    reverse: bool = False
+    to_address: Optional[str] = None
+    type_filter: Optional[TransactionTypeFilter] = None
+    confirmed: Optional[bool] = None
+
+    def __post_init__(self) -> None:
+        if self.sort_key is not None and not hasattr(SortKey, self.sort_key):
+            raise ValueError(f"There is no known sort {self.sort_key}")
+
+
+# utility for GetTransactionsResponse
+# this class cannot be a dataclass because if it is, streamable will assume it knows how to serialize it
+# TODO: We should put some thought into deprecating this and separating the metadata more reasonably
+class TransactionRecordMetadata:
+    content: dict[str, Any]
+    coin_id: bytes32
+    spent: bool
+
+    def __init__(self, content: dict[str, Any], coin_id: bytes32, spent: bool) -> None:
+        self.content = content
+        self.coin_id = coin_id
+        self.spent = spent
+
+    def __bytes__(self) -> bytes:
+        raise NotImplementedError("Should not be serializing this object as bytes, it's only for RPC")
+
+    @classmethod
+    def parse(cls, f: BinaryIO) -> TransactionRecordMetadata:
+        raise NotImplementedError("Should not be deserializing this object from a stream, it's only for RPC")
+
+    def to_json_dict(self) -> dict[str, Any]:
+        return {
+            **self.content,
+            "coin_id": "0x" + self.coin_id.hex(),
+            "spent": self.spent,
+        }
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> TransactionRecordMetadata:
+        return TransactionRecordMetadata(
+            coin_id=bytes32.from_hexstr(json_dict["coin_id"]),
+            spent=json_dict["spent"],
+            content={k: v for k, v in json_dict.items() if k not in {"coin_id", "spent"}},
+        )
+
+
+# utility for GetTransactionsResponse
+@streamable
+@dataclass(frozen=True)
+class TransactionRecordWithMetadata(TransactionRecord):
+    metadata: Optional[TransactionRecordMetadata] = None
+
+
+@streamable
+@dataclass(frozen=True)
+class GetTransactionsResponse(Streamable):
+    transactions: list[TransactionRecordWithMetadata]
+    wallet_id: uint32
+
+
 @streamable
 @dataclass(frozen=True)
 class GetNotifications(Streamable):
@@ -212,6 +347,12 @@ class GetNotificationsResponse(Streamable):
     notifications: list[Notification]
 
 
+@streamable
+@dataclass(frozen=True)
+class DeleteNotifications(Streamable):
+    ids: Optional[list[bytes32]] = None
+
+
 @streamable
 @dataclass(frozen=True)
 class VerifySignature(Streamable):
@@ -231,43 +372,198 @@ class VerifySignatureResponse(Streamable):
 
 @streamable
 @dataclass(frozen=True)
-class GetTransactionMemo(Streamable):
-    transaction_id: bytes32
+class SignMessageByAddress(Streamable):
+    address: str
+    message: str
+    is_hex: bool = False
+    safe_mode: bool = True
 
 
-# utility type for GetTransactionMemoResponse
 @streamable
 @dataclass(frozen=True)
-class CoinIDWithMemos(Streamable):
-    coin_id: bytes32
-    memos: list[bytes]
+class SignMessageByAddressResponse(Streamable):
+    pubkey: G1Element
+    signature: G2Element
+    signing_mode: str
 
 
 @streamable
 @dataclass(frozen=True)
-class GetTransactionMemoResponse(Streamable):
+class SignMessageByID(Streamable):
+    id: str
+    message: str
+    is_hex: bool = False
+    safe_mode: bool = True
+
+
+@streamable
+@dataclass(frozen=True)
+class SignMessageByIDResponse(Streamable):
+    pubkey: G1Element
+    signature: G2Element
+    latest_coin_id: bytes32
+    signing_mode: str
+
+
+@streamable
+@dataclass(frozen=True)
+class GetTransactionMemo(Streamable):
     transaction_id: bytes32
-    coins_with_memos: list[CoinIDWithMemos]
+
+
+@streamable
+@dataclass(frozen=True)
+class GetTransactionMemoResponse(Streamable):
+    transaction_memos: dict[bytes32, dict[bytes32, list[bytes]]]
+
+    @property
+    def memo_dict(self) -> dict[bytes32, list[bytes]]:
+        return next(iter(self.transaction_memos.values()))
 
     # TODO: deprecate the kinda silly format of this RPC and delete these functions
     def to_json_dict(self) -> dict[str, Any]:
-        return {
-            self.transaction_id.hex(): {
-                cwm.coin_id.hex(): [memo.hex() for memo in cwm.memos] for cwm in self.coins_with_memos
-            }
-        }
+        # This is semantically guaranteed but mypy can't know that
+        return super().to_json_dict()["transaction_memos"]  # type: ignore[no-any-return]
 
     @classmethod
     def from_json_dict(cls, json_dict: dict[str, Any]) -> GetTransactionMemoResponse:
+        return super().from_json_dict(
+            # We have to filter out the "success" key here
+            # because it doesn't match our `transaction_memos` hint
+            #
+            # We do this by only allowing the keys with "0x"
+            # which we can assume exist because we serialize all responses
+            {"transaction_memos": {key: value for key, value in json_dict.items() if key.startswith("0x")}}
+        )
+
+
+@streamable
+@dataclass(frozen=True)
+class GetTransactionCount(Streamable):
+    wallet_id: uint32
+    confirmed: Optional[bool] = None
+    type_filter: Optional[TransactionTypeFilter] = None
+
+
+@streamable
+@dataclass(frozen=True)
+class GetTransactionCountResponse(Streamable):
+    wallet_id: uint32
+    count: uint16
+
+
+@streamable
+@dataclass(frozen=True)
+class GetNextAddress(Streamable):
+    wallet_id: uint32
+    new_address: bool = False
+    save_derivations: bool = True
+
+
+@streamable
+@dataclass(frozen=True)
+class GetNextAddressResponse(Streamable):
+    wallet_id: uint32
+    address: str
+
+
+@streamable
+@dataclass(frozen=True)
+class DeleteUnconfirmedTransactions(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+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
+
+    def __post_init__(self) -> None:
+        if self.excluded_coin_ids is not None and self.exclude_coins is not None:
+            raise ValueError(
+                "Cannot specify both excluded_coin_ids/excluded_coins and exclude_coins (the latter is deprecated)"
+            )
+        super().__post_init__()
+
+    @classmethod
+    def from_coin_selection_config(
+        cls, wallet_id: uint32, amount: uint64, coin_selection_config: CoinSelectionConfig
+    ) -> Self:
         return cls(
-            bytes32.from_hexstr(next(iter(json_dict.keys()))),
-            [
-                CoinIDWithMemos(bytes32.from_hexstr(coin_id), [bytes32.from_hexstr(memo) for memo in memos])
-                for coin_id, memos in next(iter(json_dict.values())).items()
-            ],
+            wallet_id=wallet_id,
+            amount=amount,
+            min_coin_amount=coin_selection_config.min_coin_amount,
+            max_coin_amount=coin_selection_config.max_coin_amount,
+            excluded_coin_amounts=coin_selection_config.excluded_coin_amounts,
+            excluded_coin_ids=coin_selection_config.excluded_coin_ids,
+        )
+
+
+@streamable
+@dataclass(frozen=True)
+class SelectCoinsResponse(Streamable):
+    coins: list[Coin]
+
+
+@streamable
+@dataclass(frozen=True)
+class GetSpendableCoins(CoinSelectionConfigLoader):
+    wallet_id: uint32 = field(default_factory=default_raise)
+
+    @classmethod
+    def from_coin_selection_config(cls, wallet_id: uint32, coin_selection_config: CoinSelectionConfig) -> Self:
+        return cls(
+            wallet_id=wallet_id,
+            min_coin_amount=coin_selection_config.min_coin_amount,
+            max_coin_amount=coin_selection_config.max_coin_amount,
+            excluded_coin_amounts=coin_selection_config.excluded_coin_amounts,
+            excluded_coin_ids=coin_selection_config.excluded_coin_ids,
         )
 
 
+@streamable
+@dataclass(frozen=True)
+class GetSpendableCoinsResponse(Streamable):
+    confirmed_records: list[CoinRecord]
+    unconfirmed_removals: list[CoinRecord]
+    unconfirmed_additions: list[Coin]
+
+
+@streamable
+@dataclass(frozen=True)
+class GetCoinRecordsByNames(Streamable):
+    names: list[bytes32]
+    start_height: Optional[uint32] = None
+    end_height: Optional[uint32] = None
+    include_spent_coins: bool = True
+
+
+@streamable
+@dataclass(frozen=True)
+class GetCoinRecordsByNamesResponse(Streamable):
+    coin_records: list[CoinRecord]
+
+
+@streamable
+@dataclass(frozen=True)
+class GetCurrentDerivationIndexResponse(Streamable):
+    index: Optional[uint32]
+
+
+@streamable
+@dataclass(frozen=True)
+class ExtendDerivationIndex(Streamable):
+    index: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class ExtendDerivationIndexResponse(Streamable):
+    index: Optional[uint32]
+
+
 @streamable
 @dataclass(frozen=True)
 class GetOffersCountResponse(Streamable):
@@ -290,6 +586,86 @@ class GetCATListResponse(Streamable):
     cat_list: list[DefaultCAT]
 
 
+@streamable
+@dataclass(frozen=True)
+class CATSetName(Streamable):
+    wallet_id: uint32
+    name: str
+
+
+@streamable
+@dataclass(frozen=True)
+class CATSetNameResponse(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class CATGetName(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class CATGetNameResponse(Streamable):
+    wallet_id: uint32
+    name: str
+
+
+@streamable
+@dataclass(frozen=True)
+class StrayCAT(Streamable):
+    asset_id: bytes32
+    name: str
+    first_seen_height: uint32
+    sender_puzzle_hash: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class GetStrayCATsResponse(Streamable):
+    stray_cats: list[StrayCAT]
+
+
+@streamable
+@dataclass(frozen=True)
+class CATGetAssetID(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class CATGetAssetIDResponse(Streamable):
+    wallet_id: uint32
+    asset_id: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class CATAssetIDToName(Streamable):
+    asset_id: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class CATAssetIDToNameResponse(Streamable):
+    wallet_id: Optional[uint32]
+    name: Optional[str]
+
+
+@streamable
+@dataclass(frozen=True)
+class CheckOfferValidity(Streamable):
+    offer: str
+
+
+@streamable
+@dataclass(frozen=True)
+class CheckOfferValidityResponse(Streamable):
+    valid: bool
+    id: bytes32
+
+
 @streamable
 @dataclass(frozen=True)
 class DIDSetWalletName(Streamable):
@@ -366,23 +742,6 @@ class DIDGetPubkeyResponse(Streamable):
     pubkey: G1Element
 
 
-@streamable
-@dataclass(frozen=True)
-class DIDGetRecoveryInfo(Streamable):
-    wallet_id: uint32
-
-
-@streamable
-@dataclass(frozen=True)
-class DIDGetRecoveryInfoResponse(Streamable):
-    wallet_id: uint32
-    my_did: str
-    coin_name: bytes32
-    newpuzhash: Optional[bytes32]
-    pubkey: Optional[G1Element]
-    backup_dids: list[bytes32]
-
-
 @streamable
 @dataclass(frozen=True)
 class DIDGetCurrentCoinInfo(Streamable):
@@ -426,20 +785,6 @@ class DIDGetDIDResponse(Streamable):
     coin_id: Optional[bytes32] = None
 
 
-@streamable
-@dataclass(frozen=True)
-class DIDGetRecoveryList(Streamable):
-    wallet_id: uint32
-
-
-@streamable
-@dataclass(frozen=True)
-class DIDGetRecoveryListResponse(Streamable):
-    wallet_id: uint32
-    recovery_list: list[str]
-    num_required: uint16
-
-
 @streamable
 @dataclass(frozen=True)
 class DIDGetMetadata(Streamable):
@@ -882,7 +1227,7 @@ class ExecuteSigningInstructionsResponse(Streamable):
 # field(default_factory=default_raise)
 # (this is for < 3.10 compatibility)
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class TransactionEndpointRequest(Streamable):
     fee: uint64 = uint64(0)
     push: Optional[bool] = None
@@ -902,7 +1247,7 @@ class TransactionEndpointRequest(Streamable):
         return {
             **tx_config.to_json_dict(),
             **timelock_info.to_json_dict(),
-            "extra_conditions": [condition.to_json_dict() for condition in extra_conditions],
+            "extra_conditions": conditions_to_json_dicts(extra_conditions),
             **self.to_json_dict(_avoid_ban=True),
         }
 
@@ -914,6 +1259,67 @@ class TransactionEndpointResponse(Streamable):
     transactions: list[TransactionRecord]
 
 
+# utility for SendTransaction
+@streamable
+@dataclass(frozen=True)
+class ClawbackPuzzleDecoratorOverride(Streamable):
+    decorator: str
+    clawback_timelock: uint64
+
+    def __post_init__(self) -> None:
+        if self.decorator != PuzzleDecoratorType.CLAWBACK.name:
+            raise ValueError("Invalid clawback puzzle decorator override specified")
+        super().__post_init__()
+
+
+@streamable
+@dataclass(frozen=True)
+class SendTransaction(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+    amount: uint64 = field(default_factory=default_raise)
+    address: str = field(default_factory=default_raise)
+    memos: list[str] = field(default_factory=list)
+    # 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
+
+
+@streamable
+@dataclass(frozen=True)
+class SendTransactionResponse(TransactionEndpointResponse):
+    transaction: TransactionRecord
+    transaction_id: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class SpendClawbackCoins(TransactionEndpointRequest):
+    coin_ids: list[bytes32] = field(default_factory=default_raise)
+    batch_size: Optional[uint16] = None
+    force: bool = False
+
+
+@streamable
+@dataclass(frozen=True)
+class SpendClawbackCoinsResponse(TransactionEndpointResponse):
+    transaction_ids: list[bytes32]
+
+
+@streamable
+@dataclass(frozen=True)
+class SendNotification(TransactionEndpointRequest):
+    target: bytes32 = field(default_factory=default_raise)
+    message: bytes = field(default_factory=default_raise)
+    amount: uint64 = uint64(0)
+
+
+@streamable
+@dataclass(frozen=True)
+class SendNotificationResponse(TransactionEndpointResponse):
+    tx: TransactionRecord
+
+
 @streamable
 @dataclass(frozen=True)
 class PushTransactions(TransactionEndpointRequest):
@@ -928,10 +1334,7 @@ class PushTransactions(TransactionEndpointRequest):
             if isinstance(transaction_hexstr_or_json, str):
                 tx = TransactionRecord.from_bytes(hexstr_to_bytes(transaction_hexstr_or_json))
             else:
-                try:
-                    tx = TransactionRecord.from_json_dict_convenience(transaction_hexstr_or_json)
-                except AttributeError:
-                    tx = TransactionRecord.from_json_dict(transaction_hexstr_or_json)
+                tx = TransactionRecord.from_json_dict(transaction_hexstr_or_json)
             transactions.append(tx)
 
         json_dict["transactions"] = [tx.to_json_dict() for tx in transactions]
@@ -945,7 +1348,7 @@ class PushTransactionsResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class SplitCoins(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
     number_of_coins: uint16 = field(default_factory=default_raise)
@@ -960,7 +1363,7 @@ class SplitCoinsResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class CombineCoins(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
     number_of_coins: uint16 = uint16(500)
@@ -976,22 +1379,63 @@ class CombineCoinsResponse(TransactionEndpointResponse):
     pass
 
 
+# utility for CATSpend
+# 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
+
+
 @streamable
-@kw_only_dataclass
-class DIDUpdateRecoveryIDs(TransactionEndpointRequest):
+@dataclass(frozen=True, kw_only=True)
+class CATSpend(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
-    new_list: list[str] = field(default_factory=default_raise)
-    num_verifications_required: Optional[uint64] = None
+    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
+
+    def __post_init__(self) -> None:
+        if (
+            self.additions is not None
+            and (self.amount is not None or self.inner_address is not None or self.memos is not None)
+        ) or (self.additions is None and self.amount is None and self.inner_address is None and self.memos is None):
+            raise ValueError('Must specify "additions" or "amount"+"inner_address"+"memos", but not both.')
+        elif self.additions is None and None in {self.amount, self.inner_address}:
+            raise ValueError('Must specify "amount" and "inner_address" together.')
+        super().__post_init__()
+
+    @property
+    def cat_discrepancy(self) -> Optional[tuple[int, Program, Program]]:
+        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}:
+            raise ValueError('Must specify "extra_delta", "tail_reveal" and "tail_solution" together.')
+        else:
+            # Curious that mypy doesn't see the elif and know that none of these are None
+            return (
+                int(self.extra_delta),  # type: ignore[arg-type]
+                Program.from_bytes(self.tail_reveal),  # type: ignore[arg-type]
+                Program.from_bytes(self.tail_solution),  # type: ignore[arg-type]
+            )
 
 
 @streamable
 @dataclass(frozen=True)
-class DIDUpdateRecoveryIDsResponse(TransactionEndpointResponse):
-    pass
+class CATSpendResponse(TransactionEndpointResponse):
+    transaction: TransactionRecord
+    transaction_id: bytes32
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class DIDMessageSpend(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
     coin_announcements: list[bytes] = field(default_factory=list)
@@ -1005,7 +1449,7 @@ class DIDMessageSpendResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class DIDUpdateMetadata(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
     metadata: dict[str, str] = field(default_factory=dict)
@@ -1019,12 +1463,17 @@ class DIDUpdateMetadataResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class DIDTransferDID(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
     inner_address: str = field(default_factory=default_raise)
     with_recovery_info: bool = True
 
+    def __post_init__(self) -> None:
+        if self.with_recovery_info is False:
+            raise ValueError("Recovery related options are no longer supported. `with_recovery` must always be true.")
+        return super().__post_init__()
+
 
 @streamable
 @dataclass(frozen=True)
@@ -1034,7 +1483,7 @@ class DIDTransferDIDResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@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)
@@ -1060,7 +1509,7 @@ class NFTMintNFTResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class NFTSetNFTDID(TransactionEndpointRequest):
     wallet_id: uint32 = field(default_factory=default_raise)
     nft_coin_id: bytes32 = field(default_factory=default_raise)
@@ -1075,7 +1524,7 @@ class NFTSetNFTDIDResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class NFTSetDIDBulk(TransactionEndpointRequest):
     nft_coin_list: list[NFTCoin] = field(default_factory=default_raise)
     did_id: Optional[str] = None
@@ -1090,7 +1539,7 @@ class NFTSetDIDBulkResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class NFTTransferBulk(TransactionEndpointRequest):
     nft_coin_list: list[NFTCoin] = field(default_factory=default_raise)
     target_address: str = field(default_factory=default_raise)
@@ -1105,7 +1554,7 @@ class NFTTransferBulkResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class CreateNewDL(TransactionEndpointRequest):
     root: bytes32 = field(default_factory=default_raise)
 
@@ -1117,7 +1566,7 @@ class CreateNewDLResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class DLUpdateRoot(TransactionEndpointRequest):
     launcher_id: bytes32 = field(default_factory=default_raise)
     new_root: bytes32 = field(default_factory=default_raise)
@@ -1161,7 +1610,7 @@ class DLUpdateMultipleUpdates(Streamable):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class DLUpdateMultiple(TransactionEndpointRequest):
     updates: DLUpdateMultipleUpdates = field(default_factory=default_raise)
 
@@ -1177,7 +1626,7 @@ class DLUpdateMultipleResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class DLNewMirror(TransactionEndpointRequest):
     launcher_id: bytes32 = field(default_factory=default_raise)
     amount: uint64 = field(default_factory=default_raise)
@@ -1191,7 +1640,7 @@ class DLNewMirrorResponse(TransactionEndpointResponse):
 
 
 @streamable
-@kw_only_dataclass
+@dataclass(frozen=True, kw_only=True)
 class DLDeleteMirror(TransactionEndpointRequest):
     coin_id: bytes32 = field(default_factory=default_raise)
 
@@ -1361,11 +1810,6 @@ class VCRevokeResponse(TransactionEndpointResponse):
 
 # 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 SendTransactionResponse(TransactionEndpointResponse):
-    transaction: TransactionRecord
-    transaction_id: bytes32
 
 
 @streamable
@@ -1382,13 +1826,6 @@ class CreateSignedTransactionsResponse(TransactionEndpointResponse):
     signed_tx: TransactionRecord
 
 
-@streamable
-@dataclass(frozen=True)
-class CATSpendResponse(TransactionEndpointResponse):
-    transaction: TransactionRecord
-    transaction_id: bytes32
-
-
 @streamable
 @dataclass(frozen=True)
 class _OfferEndpointResponse(TransactionEndpointResponse):