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

chia/{rpc → wallet}/wallet_request_types.py

@@ -2,16 +2,21 @@ from __future__ import annotations
 
 import sys
 from dataclasses import dataclass, field
-from typing import Any, Optional, TypeVar, final
+from typing import Any, Optional, final
 
-from chia_rs import G1Element, G2Element, PrivateKey
+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 dataclass_transform
+from typing_extensions import Self, dataclass_transform
 
+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.util.byte_types import hexstr_to_bytes
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.conditions import Condition, ConditionValidTimes
+from chia.wallet.nft_wallet.nft_info import NFTInfo
 from chia.wallet.notification_store import Notification
 from chia.wallet.signer_protocol import (
     SignedTransaction,
@@ -28,15 +33,13 @@ from chia.wallet.util.tx_config import TXConfig
 from chia.wallet.vc_wallet.vc_store import VCProofs, VCRecord
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
-_T_OfferEndpointResponse = TypeVar("_T_OfferEndpointResponse", bound="_OfferEndpointResponse")
-
 
 @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)(cls)  # pragma: no cover
-    else:
+    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
@@ -287,6 +290,70 @@ class GetCATListResponse(Streamable):
     cat_list: list[DefaultCAT]
 
 
+@streamable
+@dataclass(frozen=True)
+class DIDSetWalletName(Streamable):
+    wallet_id: uint32
+    name: str
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDSetWalletNameResponse(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDGetWalletName(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDGetWalletNameResponse(Streamable):
+    wallet_id: uint32
+    name: str
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDGetInfo(Streamable):
+    coin_id: str
+    latest: bool = True
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDGetInfoResponse(Streamable):
+    did_id: str
+    latest_coin: bytes32
+    p2_address: str
+    public_key: bytes
+    recovery_list_hash: Optional[bytes32]
+    num_verification: uint16
+    metadata: dict[str, str]
+    launcher_id: bytes32
+    full_puzzle: Program
+    solution: Program
+    hints: list[bytes]
+
+
+@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
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDFindLostDIDResponse(Streamable):
+    latest_coin_id: bytes32
+
+
 @streamable
 @dataclass(frozen=True)
 class DIDGetPubkey(Streamable):
@@ -311,8 +378,8 @@ class DIDGetRecoveryInfoResponse(Streamable):
     wallet_id: uint32
     my_did: str
     coin_name: bytes32
-    newpuzhash: bytes32
-    pubkey: G1Element
+    newpuzhash: Optional[bytes32]
+    pubkey: Optional[G1Element]
     backup_dids: list[bytes32]
 
 
@@ -332,6 +399,88 @@ class DIDGetCurrentCoinInfoResponse(Streamable):
     did_amount: uint64
 
 
+@streamable
+@dataclass(frozen=True)
+class DIDCreateBackupFile(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDCreateBackupFileResponse(Streamable):
+    wallet_id: uint32
+    backup_data: str
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDGetDID(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDGetDIDResponse(Streamable):
+    wallet_id: uint32
+    my_did: str
+    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):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDGetMetadataResponse(Streamable):
+    wallet_id: uint32
+    metadata: dict[str, str]
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTCountNFTs(Streamable):
+    wallet_id: Optional[uint32] = None
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTCountNFTsResponse(Streamable):
+    wallet_id: Optional[uint32]
+    count: uint64
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTGetNFTs(Streamable):
+    wallet_id: Optional[uint32] = None
+    start_index: uint32 = uint32(0)
+    num: uint32 = uint32(50)
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTGetNFTsResponse(Streamable):
+    wallet_id: Optional[uint32]
+    nft_list: list[NFTInfo]
+
+
 @streamable
 @dataclass(frozen=True)
 class NFTGetByDID(Streamable):
@@ -344,6 +493,18 @@ class NFTGetByDIDResponse(Streamable):
     wallet_id: uint32
 
 
+@streamable
+@dataclass(frozen=True)
+class NFTGetWalletDID(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTGetWalletDIDResponse(Streamable):
+    did_id: Optional[str]
+
+
 @streamable
 @dataclass(frozen=True)
 class NFTSetNFTStatus(Streamable):
@@ -367,6 +528,103 @@ class NFTGetWalletsWithDIDsResponse(Streamable):
     nft_wallets: list[NFTWalletWithDID]
 
 
+@streamable
+@dataclass(frozen=True)
+class NFTGetInfo(Streamable):
+    coin_id: str
+    latest: bool = True
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTGetInfoResponse(Streamable):
+    nft_info: NFTInfo
+
+
+# utility for NFTCalculateRoyalties
+@streamable
+@dataclass(frozen=True)
+class RoyaltyAsset(Streamable):
+    asset: str
+    royalty_address: str
+    royalty_percentage: uint16
+
+
+# utility for NFTCalculateRoyalties
+@streamable
+@dataclass(frozen=True)
+class FungibleAsset(Streamable):
+    asset: Optional[str]
+    amount: uint64
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTCalculateRoyalties(Streamable):
+    royalty_assets: list[RoyaltyAsset] = field(default_factory=list)
+    fungible_assets: list[FungibleAsset] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        if len(set(a.asset for a in self.royalty_assets)) != len(self.royalty_assets):
+            raise ValueError("Multiple royalty assets with same name specified")
+        if len(set(a.asset for a in self.fungible_assets)) != len(self.fungible_assets):
+            raise ValueError("Multiple fungible assets with same name specified")
+
+
+# utility for NFTCalculateRoyaltiesResponse
+@streamable
+@dataclass(frozen=True)
+class RoyaltySummary(Streamable):
+    royalty_asset: str
+    fungible_asset: Optional[str]
+    royalty_address: str
+    royalty_amount: uint64
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTCalculateRoyaltiesResponse(Streamable):
+    nft_info: list[RoyaltySummary]
+
+    # old response is a dict with arbitrary keys so we must override serialization for backwards compatibility
+    def to_json_dict(self) -> dict[str, Any]:
+        summary_dict: dict[str, Any] = {}
+        for info in self.nft_info:
+            summary_dict.setdefault(info.royalty_asset, [])
+            summary_dict[info.royalty_asset].append(
+                {
+                    "asset": info.fungible_asset,
+                    "address": info.royalty_address,
+                    "amount": info.royalty_amount,
+                }
+            )
+
+        return summary_dict
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> NFTCalculateRoyaltiesResponse:
+        # There's some awkwardness here because the canonical format of this response
+        # returns all of the asset information on the same level as the "success"
+        # key that gets automatically returned by the RPC
+        #
+        # This is an unfortunate design choice, but one we must preserve for
+        # backwards compatibility. This means the code below has some logic it
+        # probably shouldn't have ignoring "assets" named "success".
+        return cls(
+            [
+                RoyaltySummary(
+                    royalty_asset,
+                    summary["asset"],
+                    summary["address"],
+                    uint64(summary["amount"]),
+                )
+                for royalty_asset, summaries in json_dict.items()
+                if royalty_asset != "success"
+                for summary in summaries
+            ]
+        )
+
+
 # utility for NFTSetDIDBulk
 @streamable
 @dataclass(frozen=True)
@@ -375,6 +633,92 @@ class NFTCoin(Streamable):
     wallet_id: uint32
 
 
+@streamable
+@dataclass(frozen=True)
+class PWStatus(Streamable):
+    wallet_id: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class PWStatusResponse(Streamable):
+    state: PoolWalletInfo
+    unconfirmed_transactions: list[TransactionRecord]
+
+
+@streamable
+@dataclass(frozen=True)
+class DLTrackNew(Streamable):
+    launcher_id: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class DLStopTracking(Streamable):
+    launcher_id: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class DLLatestSingleton(Streamable):
+    launcher_id: bytes32
+    only_confirmed: bool = False
+
+
+@streamable
+@dataclass(frozen=True)
+class DLLatestSingletonResponse(Streamable):
+    singleton: Optional[SingletonRecord]
+
+
+@streamable
+@dataclass(frozen=True)
+class DLSingletonsByRoot(Streamable):
+    launcher_id: bytes32
+    root: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class DLSingletonsByRootResponse(Streamable):
+    singletons: list[SingletonRecord]
+
+
+@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
+
+
+@streamable
+@dataclass(frozen=True)
+class DLHistoryResponse(Streamable):
+    history: list[SingletonRecord]
+    count: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class DLOwnedSingletonsResponse(Streamable):
+    singletons: list[SingletonRecord]
+    count: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class DLGetMirrors(Streamable):
+    launcher_id: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class DLGetMirrorsResponse(Streamable):
+    mirrors: list[Mirror]
+
+
 @streamable
 @dataclass(frozen=True)
 class VCGet(Streamable):
@@ -404,13 +748,10 @@ class VCProofsRPC(Streamable):
         return VCProofs({key: value for key, value in self.key_value_pairs})
 
     @classmethod
-    def from_vc_proofs(cls: type[_T_VCProofsRPC], vc_proofs: VCProofs) -> _T_VCProofsRPC:
+    def from_vc_proofs(cls, vc_proofs: VCProofs) -> Self:
         return cls([(key, value) for key, value in vc_proofs.key_value_pairs.items()])
 
 
-_T_VCProofsRPC = TypeVar("_T_VCProofsRPC", bound=VCProofsRPC)
-
-
 # utility for VCGetListResponse
 @streamable
 @dataclass(frozen=True)
@@ -471,13 +812,10 @@ class VCAddProofs(VCProofsRPC):
         return {"proofs": self.to_vc_proofs().key_value_pairs}
 
     @classmethod
-    def from_json_dict(cls: type[_T_VCAddProofs], json_dict: dict[str, Any]) -> _T_VCAddProofs:
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
         return cls([(key, value) for key, value in json_dict["proofs"].items()])
 
 
-_T_VCAddProofs = TypeVar("_T_VCAddProofs", bound=VCAddProofs)
-
-
 @streamable
 @dataclass(frozen=True)
 class VCGetProofsForRoot(Streamable):
@@ -638,6 +976,104 @@ class CombineCoinsResponse(TransactionEndpointResponse):
     pass
 
 
+@streamable
+@kw_only_dataclass
+class DIDUpdateRecoveryIDs(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+    new_list: list[str] = field(default_factory=default_raise)
+    num_verifications_required: Optional[uint64] = None
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDUpdateRecoveryIDsResponse(TransactionEndpointResponse):
+    pass
+
+
+@streamable
+@kw_only_dataclass
+class DIDMessageSpend(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+    coin_announcements: list[bytes] = field(default_factory=list)
+    puzzle_announcements: list[bytes] = field(default_factory=list)
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDMessageSpendResponse(TransactionEndpointResponse):
+    spend_bundle: WalletSpendBundle
+
+
+@streamable
+@kw_only_dataclass
+class DIDUpdateMetadata(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+    metadata: dict[str, str] = field(default_factory=dict)
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDUpdateMetadataResponse(TransactionEndpointResponse):
+    spend_bundle: WalletSpendBundle
+    wallet_id: uint32
+
+
+@streamable
+@kw_only_dataclass
+class DIDTransferDID(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+    inner_address: str = field(default_factory=default_raise)
+    with_recovery_info: bool = True
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDTransferDIDResponse(TransactionEndpointResponse):
+    transaction: TransactionRecord
+    transaction_id: bytes32
+
+
+@streamable
+@kw_only_dataclass
+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)
+    uris: list[str] = field(default_factory=default_raise)
+    hash: bytes32 = field(default_factory=default_raise)
+    royalty_amount: uint16 = uint16(0)
+    meta_uris: list[str] = field(default_factory=list)
+    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
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTMintNFTResponse(TransactionEndpointResponse):
+    wallet_id: uint32
+    spend_bundle: WalletSpendBundle
+    nft_id: str
+
+
+@streamable
+@kw_only_dataclass
+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
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTSetNFTDIDResponse(TransactionEndpointResponse):
+    wallet_id: uint32
+    spend_bundle: WalletSpendBundle
+
+
 @streamable
 @kw_only_dataclass
 class NFTSetDIDBulk(TransactionEndpointRequest):
@@ -668,6 +1104,221 @@ class NFTTransferBulkResponse(TransactionEndpointResponse):
     spend_bundle: WalletSpendBundle
 
 
+@streamable
+@kw_only_dataclass
+class CreateNewDL(TransactionEndpointRequest):
+    root: bytes32 = field(default_factory=default_raise)
+
+
+@streamable
+@dataclass(frozen=True)
+class CreateNewDLResponse(TransactionEndpointResponse):
+    launcher_id: bytes32
+
+
+@streamable
+@kw_only_dataclass
+class DLUpdateRoot(TransactionEndpointRequest):
+    launcher_id: bytes32 = field(default_factory=default_raise)
+    new_root: bytes32 = field(default_factory=default_raise)
+
+
+@streamable
+@dataclass(frozen=True)
+class DLUpdateRootResponse(TransactionEndpointResponse):
+    tx_record: TransactionRecord
+
+
+# utilities for DLUpdateMultiple
+@streamable
+@dataclass(frozen=True)
+class LauncherRootPair(Streamable):
+    launcher_id: bytes32
+    new_root: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class DLUpdateMultipleUpdates(Streamable):
+    launcher_root_pairs: list[LauncherRootPair]
+
+    def __post_init__(self) -> None:
+        if len(set(pair.launcher_id for pair in self.launcher_root_pairs)) < len(self.launcher_root_pairs):
+            raise ValueError("Multiple updates specified for a single launcher in `DLUpdateMultiple`")
+
+    # TODO: deprecate the kinda silly format of this RPC and delete this function
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
+        return cls(
+            [
+                LauncherRootPair(
+                    bytes32.from_hexstr(key),
+                    bytes32.from_hexstr(value),
+                )
+                for key, value in json_dict.items()
+            ]
+        )
+
+
+@streamable
+@kw_only_dataclass
+class DLUpdateMultiple(TransactionEndpointRequest):
+    updates: DLUpdateMultipleUpdates = field(default_factory=default_raise)
+
+    # TODO: deprecate the kinda silly format of this RPC and delete this function
+    def to_json_dict(self, _avoid_ban: bool = False) -> dict[str, Any]:
+        return {"updates": {pair.launcher_id.hex(): pair.new_root.hex() for pair in self.updates.launcher_root_pairs}}
+
+
+@streamable
+@dataclass(frozen=True)
+class DLUpdateMultipleResponse(TransactionEndpointResponse):
+    pass
+
+
+@streamable
+@kw_only_dataclass
+class DLNewMirror(TransactionEndpointRequest):
+    launcher_id: bytes32 = field(default_factory=default_raise)
+    amount: uint64 = field(default_factory=default_raise)
+    urls: list[str] = field(default_factory=default_raise)
+
+
+@streamable
+@dataclass(frozen=True)
+class DLNewMirrorResponse(TransactionEndpointResponse):
+    pass
+
+
+@streamable
+@kw_only_dataclass
+class DLDeleteMirror(TransactionEndpointRequest):
+    coin_id: bytes32 = field(default_factory=default_raise)
+
+
+@streamable
+@dataclass(frozen=True)
+class DLDeleteMirrorResponse(TransactionEndpointResponse):
+    pass
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTTransferNFT(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+    target_address: str = field(default_factory=default_raise)
+    nft_coin_id: str = field(default_factory=default_raise)
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTTransferNFTResponse(TransactionEndpointResponse):
+    wallet_id: uint32
+    spend_bundle: WalletSpendBundle
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTAddURI(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+    uri: str = field(default_factory=default_raise)
+    key: str = field(default_factory=default_raise)
+    nft_coin_id: str = field(default_factory=default_raise)
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTAddURIResponse(TransactionEndpointResponse):
+    wallet_id: uint32
+    spend_bundle: WalletSpendBundle
+
+
+# utility for NFTBulkMint
+@streamable
+@dataclass(frozen=True)
+class NFTMintMetadata(Streamable):
+    uris: list[str]
+    hash: bytes32
+    meta_uris: list[str] = field(default_factory=list)
+    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
+
+
+@streamable
+@dataclass(frozen=True)
+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
+    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_from_did: bool = False
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTMintBulkResponse(TransactionEndpointResponse):
+    spend_bundle: WalletSpendBundle
+    nft_id_list: list[str]
+
+
+@streamable
+@dataclass(frozen=True)
+class PWJoinPool(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+    pool_url: str = field(default_factory=default_raise)
+    target_puzzlehash: bytes32 = field(default_factory=default_raise)
+    relative_lock_height: uint32 = field(default_factory=default_raise)
+
+
+@streamable
+@dataclass(frozen=True)
+class PWJoinPoolResponse(TransactionEndpointResponse):
+    total_fee: uint64
+    transaction: TransactionRecord
+    fee_transaction: Optional[TransactionRecord]
+
+
+@streamable
+@dataclass(frozen=True)
+class PWSelfPool(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+
+
+@streamable
+@dataclass(frozen=True)
+class PWSelfPoolResponse(TransactionEndpointResponse):
+    total_fee: uint64
+    transaction: TransactionRecord
+    fee_transaction: Optional[TransactionRecord]
+
+
+@streamable
+@dataclass(frozen=True)
+class PWAbsorbRewards(TransactionEndpointRequest):
+    wallet_id: uint32 = field(default_factory=default_raise)
+    max_spends_in_tx: Optional[uint16] = None
+
+
+@streamable
+@dataclass(frozen=True)
+class PWAbsorbRewardsResponse(TransactionEndpointResponse):
+    state: PoolWalletInfo
+    transaction: TransactionRecord
+    fee_transaction: Optional[TransactionRecord]
+
+
 @streamable
 @dataclass(frozen=True)
 class VCMint(TransactionEndpointRequest):
@@ -731,32 +1382,6 @@ class CreateSignedTransactionsResponse(TransactionEndpointResponse):
     signed_tx: TransactionRecord
 
 
-@streamable
-@dataclass(frozen=True)
-class DIDUpdateRecoveryIDsResponse(TransactionEndpointResponse):
-    pass
-
-
-@streamable
-@dataclass(frozen=True)
-class DIDMessageSpendResponse(TransactionEndpointResponse):
-    spend_bundle: WalletSpendBundle
-
-
-@streamable
-@dataclass(frozen=True)
-class DIDUpdateMetadataResponse(TransactionEndpointResponse):
-    spend_bundle: WalletSpendBundle
-    wallet_id: uint32
-
-
-@streamable
-@dataclass(frozen=True)
-class DIDTransferDIDResponse(TransactionEndpointResponse):
-    transaction: TransactionRecord
-    transaction_id: bytes32
-
-
 @streamable
 @dataclass(frozen=True)
 class CATSpendResponse(TransactionEndpointResponse):
@@ -771,7 +1396,7 @@ class _OfferEndpointResponse(TransactionEndpointResponse):
     trade_record: TradeRecord
 
     @classmethod
-    def from_json_dict(cls: type[_T_OfferEndpointResponse], json_dict: dict[str, Any]) -> _T_OfferEndpointResponse:
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
         tx_endpoint: TransactionEndpointResponse = json_deserialize_with_clvm_streamable(
             json_dict, TransactionEndpointResponse
         )
@@ -806,39 +1431,3 @@ class CancelOfferResponse(TransactionEndpointResponse):
 @dataclass(frozen=True)
 class CancelOffersResponse(TransactionEndpointResponse):
     pass
-
-
-@streamable
-@dataclass(frozen=True)
-class NFTMintNFTResponse(TransactionEndpointResponse):
-    wallet_id: uint32
-    spend_bundle: WalletSpendBundle
-    nft_id: str
-
-
-@streamable
-@dataclass(frozen=True)
-class NFTAddURIResponse(TransactionEndpointResponse):
-    wallet_id: uint32
-    spend_bundle: WalletSpendBundle
-
-
-@streamable
-@dataclass(frozen=True)
-class NFTTransferNFTResponse(TransactionEndpointResponse):
-    wallet_id: uint32
-    spend_bundle: WalletSpendBundle
-
-
-@streamable
-@dataclass(frozen=True)
-class NFTSetNFTDIDResponse(TransactionEndpointResponse):
-    wallet_id: uint32
-    spend_bundle: WalletSpendBundle
-
-
-@streamable
-@dataclass(frozen=True)
-class NFTMintBulkResponse(TransactionEndpointResponse):
-    spend_bundle: WalletSpendBundle
-    nft_id_list: list[str]