Port cat_get_name

Author: Quexington

chia/_tests/cmds/cmd_test_utils.py

@@ -33,6 +33,8 @@
 from chia.wallet.util.tx_config import TXConfig
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet_request_types import (
+    CATGetName,
+    CATGetNameResponse,
     GetSyncStatusResponse,
     GetTransaction,
     GetTransactionResponse,
@@ -146,9 +148,9 @@ async def get_transaction(self, request: GetTransaction) -> GetTransactionRespon
             bytes32([2] * 32),
         )
 
-    async def get_cat_name(self, wallet_id: int) -> str:
-        self.add_to_log("get_cat_name", (wallet_id,))
-        return "test" + str(wallet_id)
+    async def get_cat_name(self, request: CATGetName) -> CATGetNameResponse:
+        self.add_to_log("get_cat_name", (request.wallet_id,))
+        return CATGetNameResponse(request.wallet_id, "test" + str(request.wallet_id))
 
     async def sign_message_by_address(self, request: SignMessageByAddress) -> SignMessageByAddressResponse:
         self.add_to_log("sign_message_by_address", (request.address, request.message))

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -104,6 +104,7 @@
 from chia.wallet.wallet_protocol import WalletProtocol
 from chia.wallet.wallet_request_types import (
     AddKey,
+    CATGetName,
     CATSetName,
     CheckDeleteKey,
     ClawbackPuzzleDecoratorOverride,
@@ -1205,11 +1206,11 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
         <= (await env_0.rpc_client.get_wallet_balance(GetWalletBalance(cat_0_id))).wallet_balance.to_json_dict().items()
     )
     asset_id = await env_0.rpc_client.get_cat_asset_id(cat_0_id)
-    assert (await env_0.rpc_client.get_cat_name(cat_0_id)) == wallet_type.default_wallet_name_for_unknown_cat(
-        asset_id.hex()
-    )
+    assert (
+        await env_0.rpc_client.get_cat_name(CATGetName(cat_0_id))
+    ).name == wallet_type.default_wallet_name_for_unknown_cat(asset_id.hex())
     await env_0.rpc_client.set_cat_name(CATSetName(cat_0_id, "My cat"))
-    assert (await env_0.rpc_client.get_cat_name(cat_0_id)) == "My cat"
+    assert (await env_0.rpc_client.get_cat_name(CATGetName(cat_0_id))).name == "My cat"
     result = await env_0.rpc_client.cat_asset_id_to_name(asset_id)
     assert result is not None
     wid, name = result

chia/cmds/wallet_funcs.py

@@ -45,6 +45,7 @@
 from chia.wallet.vc_wallet.vc_store import VCProofs
 from chia.wallet.wallet_coin_store import GetCoinRecords
 from chia.wallet.wallet_request_types import (
+    CATGetName,
     CATSetName,
     CATSpendResponse,
     ClawbackPuzzleDecoratorOverride,
@@ -185,7 +186,7 @@ async def get_unit_name_for_wallet_id(
     }:
         name: str = config["network_overrides"]["config"][config["selected_network"]]["address_prefix"].upper()
     elif wallet_type in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
-        name = await wallet_client.get_cat_name(wallet_id=wallet_id)
+        name = (await wallet_client.get_cat_name(CATGetName(wallet_id=uint32(wallet_id)))).name
     else:
         raise LookupError(f"Operation is not supported for Wallet type {wallet_type.name}")
 
@@ -571,7 +572,7 @@ async def make_offer(
                             name = "XCH"
                             unit = units["chia"]
                         else:
-                            name = await wallet_client.get_cat_name(id)
+                            name = (await wallet_client.get_cat_name(CATGetName(id))).name
                             unit = units["cat"]
                         if item in offers:
                             fungible_assets.append(FungibleAsset(name, uint64(abs(int(Decimal(amount) * unit)))))

chia/wallet/wallet_request_types.py

@@ -607,6 +607,19 @@ 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 DIDSetWalletName(Streamable):

chia/wallet/wallet_rpc_api.py

@@ -112,6 +112,8 @@
     ApplySignatures,
     ApplySignaturesResponse,
     BalanceResponse,
+    CATGetName,
+    CATGetNameResponse,
     CATSetName,
     CATSetNameResponse,
     CheckDeleteKey,
@@ -2106,11 +2108,11 @@ async def cat_set_name(self, request: CATSetName) -> CATSetNameResponse:
         await wallet.set_name(request.name)
         return CATSetNameResponse(wallet_id=request.wallet_id)
 
-    async def cat_get_name(self, request: dict[str, Any]) -> EndpointResult:
-        wallet_id = uint32(request["wallet_id"])
-        wallet = self.service.wallet_state_manager.get_wallet(id=wallet_id, required_type=CATWallet)
+    @marshal
+    async def cat_get_name(self, request: CATGetName) -> CATGetNameResponse:
+        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet)
         name: str = wallet.get_name()
-        return {"wallet_id": wallet_id, "name": name}
+        return CATGetNameResponse(wallet_id=request.wallet_id, name=name)
 
     async def get_stray_cats(self, request: dict[str, Any]) -> EndpointResult:
         """

chia/wallet/wallet_rpc_client.py

@@ -24,6 +24,8 @@
     ApplySignaturesResponse,
     CancelOfferResponse,
     CancelOffersResponse,
+    CATGetName,
+    CATGetNameResponse,
     CATSetName,
     CATSetNameResponse,
     CATSpendResponse,
@@ -645,11 +647,8 @@ async def cat_asset_id_to_name(self, asset_id: bytes32) -> Optional[tuple[Option
         wallet_id: Optional[uint32] = None if res["wallet_id"] is None else uint32(res["wallet_id"])
         return wallet_id, res["name"]
 
-    async def get_cat_name(self, wallet_id: int) -> str:
-        request = {"wallet_id": wallet_id}
-        response = await self.fetch("cat_get_name", request)
-        # TODO: casting due to lack of type checked deserialization
-        return cast(str, response["name"])
+    async def get_cat_name(self, request: CATGetName) -> CATGetNameResponse:
+        return CATGetNameResponse.from_json_dict(await self.fetch("cat_get_name", request.to_json_dict()))
 
     async def set_cat_name(self, request: CATSetName) -> CATSetNameResponse:
         return CATSetNameResponse.from_json_dict(await self.fetch("cat_set_name", request.to_json_dict()))