Port cat_asset_id_to_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 (
+    CATAssetIDToName,
+    CATAssetIDToNameResponse,
     CATGetName,
     CATGetNameResponse,
     GetSyncStatusResponse,
@@ -184,15 +186,15 @@ async def sign_message_by_id(self, request: SignMessageByID) -> SignMessageByIDR
         signing_mode = SigningMode.CHIP_0002.value
         return SignMessageByIDResponse(pubkey, signature, bytes32.zeros, signing_mode)
 
-    async def cat_asset_id_to_name(self, asset_id: bytes32) -> Optional[tuple[Optional[uint32], str]]:
+    async def cat_asset_id_to_name(self, request: CATAssetIDToName) -> CATAssetIDToNameResponse:
         """
         if bytes32([1] * 32), return (uint32(2), "test1"), if bytes32([1] * 32), return (uint32(3), "test2")
         """
-        self.add_to_log("cat_asset_id_to_name", (asset_id,))
+        self.add_to_log("cat_asset_id_to_name", (request.asset_id,))
         for i in range(256):
-            if asset_id == get_bytes32(i):
-                return uint32(i + 1), "test" + str(i)
-        return None
+            if request.asset_id == get_bytes32(i):
+                return CATAssetIDToNameResponse(uint32(i + 1), "test" + str(i))
+        return CATAssetIDToNameResponse(wallet_id=None, name=None)
 
     async def get_nft_info(self, request: NFTGetInfo) -> NFTGetInfoResponse:
         self.add_to_log("get_nft_info", (request.coin_id, request.latest))

chia/_tests/cmds/wallet/test_wallet.py

@@ -43,6 +43,8 @@
 from chia.wallet.wallet_request_types import (
     BalanceResponse,
     CancelOfferResponse,
+    CATAssetIDToName,
+    CATAssetIDToNameResponse,
     CATSetName,
     CATSetNameResponse,
     CATSpendResponse,
@@ -1054,14 +1056,14 @@ async def take_offer(
                 ),
             )
 
-        async def cat_asset_id_to_name(self, asset_id: bytes32) -> Optional[tuple[Optional[uint32], str]]:
-            self.add_to_log("cat_asset_id_to_name", (asset_id,))
-            if asset_id == cat_offered_id:
-                return uint32(2), "offered cat"
-            elif asset_id == cat_requested_id:
-                return uint32(3), "requested cat"
+        async def cat_asset_id_to_name(self, request: CATAssetIDToName) -> CATAssetIDToNameResponse:
+            self.add_to_log("cat_asset_id_to_name", (request.asset_id,))
+            if request.asset_id == cat_offered_id:
+                return CATAssetIDToNameResponse(uint32(2), "offered cat")
+            elif request.asset_id == cat_requested_id:
+                return CATAssetIDToNameResponse(uint32(3), "requested cat")
             else:
-                return None
+                return CATAssetIDToNameResponse(wallet_id=None, name=None)
 
     inst_rpc_client = TakeOfferRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client

chia/_tests/core/cmds/test_wallet.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
 from chia.cmds.wallet_funcs import print_offer_summary
+from chia.wallet.wallet_request_types import CATAssetIDToName, CATAssetIDToNameResponse
 
 TEST_DUCKSAUCE_ASSET_ID = "1000000000000000000000000000000000000000000000000000000000000001"
 TEST_CRUNCHBERRIES_ASSET_ID = "1000000000000000000000000000000000000000000000000000000000000002"
@@ -19,8 +20,8 @@
 }
 
 
-async def cat_name_resolver(asset_id: bytes32) -> Optional[tuple[Optional[uint32], str]]:
-    return TEST_ASSET_ID_NAME_MAPPING.get(asset_id)
+async def cat_name_resolver(request: CATAssetIDToName) -> CATAssetIDToNameResponse:
+    return CATAssetIDToNameResponse(*TEST_ASSET_ID_NAME_MAPPING.get(request.asset_id, (None, None)))
 
 
 @pytest.mark.anyio

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,
+    CATAssetIDToName,
     CATGetAssetID,
     CATGetName,
     CATSetName,
@@ -1212,19 +1213,17 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
     ).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(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
-    assert wid == cat_0_id
-    assert name == "My cat"
-    result = await env_0.rpc_client.cat_asset_id_to_name(bytes32.zeros)
-    assert result is None
+    asset_to_name_response = await env_0.rpc_client.cat_asset_id_to_name(CATAssetIDToName(asset_id))
+    assert asset_to_name_response.wallet_id == cat_0_id
+    assert asset_to_name_response.name == "My cat"
+    asset_to_name_response = await env_0.rpc_client.cat_asset_id_to_name(CATAssetIDToName(bytes32.zeros))
+    assert asset_to_name_response.name is None
     verified_asset_id = next(iter(DEFAULT_CATS.items()))[1]["asset_id"]
-    result = await env_0.rpc_client.cat_asset_id_to_name(bytes32.from_hexstr(verified_asset_id))
-    assert result is not None
-    should_be_none, name = result
-    assert should_be_none is None
-    assert name == next(iter(DEFAULT_CATS.items()))[1]["name"]
+    asset_to_name_response = await env_0.rpc_client.cat_asset_id_to_name(
+        CATAssetIDToName(bytes32.from_hexstr(verified_asset_id))
+    )
+    assert asset_to_name_response.wallet_id is None
+    assert asset_to_name_response.name == next(iter(DEFAULT_CATS.items()))[1]["name"]
 
     # Creates a second wallet with the same CAT
     res = await env_1.rpc_client.create_wallet_for_existing_cat(asset_id)

chia/cmds/wallet_funcs.py

@@ -45,6 +45,8 @@
 from chia.wallet.vc_wallet.vc_store import VCProofs
 from chia.wallet.wallet_coin_store import GetCoinRecords
 from chia.wallet.wallet_request_types import (
+    CATAssetIDToName,
+    CATAssetIDToNameResponse,
     CATGetName,
     CATSetName,
     CATSpendResponse,
@@ -94,7 +96,7 @@
 )
 from chia.wallet.wallet_rpc_client import WalletRpcClient
 
-CATNameResolver = Callable[[bytes32], Awaitable[Optional[tuple[Optional[uint32], str]]]]
+CATNameResolver = Callable[[CATAssetIDToName], Awaitable[CATAssetIDToNameResponse]]
 
 transaction_type_descriptions = {
     TransactionType.INCOMING_TX: "received",
@@ -471,21 +473,19 @@ async def add_token(
     root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], asset_id: bytes32, token_name: str
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, fingerprint, _):
-        existing_info: Optional[tuple[Optional[uint32], str]] = await wallet_client.cat_asset_id_to_name(asset_id)
-        if existing_info is None:
-            wallet_id = None
-            old_name = None
-        else:
-            wallet_id, old_name = existing_info
+        existing_info = await wallet_client.cat_asset_id_to_name(CATAssetIDToName(asset_id))
 
-        if wallet_id is None:
+        if existing_info.wallet_id is None:
             response = await wallet_client.create_wallet_for_existing_cat(asset_id)
             wallet_id = response["wallet_id"]
             await wallet_client.set_cat_name(CATSetName(wallet_id, token_name))
             print(f"Successfully added {token_name} with wallet id {wallet_id} on key {fingerprint}")
         else:
-            await wallet_client.set_cat_name(CATSetName(wallet_id, token_name))
-            print(f"Successfully renamed {old_name} with wallet_id {wallet_id} on key {fingerprint} to {token_name}")
+            await wallet_client.set_cat_name(CATSetName(existing_info.wallet_id, token_name))
+            print(
+                f"Successfully renamed {existing_info.name} with wallet_id {existing_info.wallet_id}"
+                f" on key {fingerprint} to {token_name}"
+            )
 
 
 async def make_offer(
@@ -514,9 +514,9 @@ async def make_offer(
                 try:
                     b32_id = bytes32.from_hexstr(name)
                     id: Union[uint32, str] = b32_id.hex()
-                    result = await wallet_client.cat_asset_id_to_name(b32_id)
-                    if result is not None:
-                        name = result[1]
+                    result = await wallet_client.cat_asset_id_to_name(CATAssetIDToName(b32_id))
+                    if result.name is not None:
+                        name = result.name
                     else:
                         name = "Unknown CAT"
                     unit = units["cat"]
@@ -680,10 +680,10 @@ async def print_offer_summary(
                     description = " [Typically represents change returned from the included fee]"
             else:
                 unit = units["cat"]
-                result = await cat_name_resolver(bytes32.from_hexstr(asset_id))
-                if result is not None:
-                    wid = str(result[0])
-                    name = result[1]
+                result = await cat_name_resolver(CATAssetIDToName(bytes32.from_hexstr(asset_id)))
+                if result.name is not None:
+                    wid = str(result.wallet_id)
+                    name = result.name
         output: str = f"    - {name}"
         mojo_str: str = f"{mojo_amount} {'mojo' if mojo_amount == 1 else 'mojos'}"
         if len(wid) > 0:
@@ -846,9 +846,9 @@ async def take_offer(
                     if fungible_asset_id is None:
                         nft_royalty_currency = network_xch
                     else:
-                        result = await wallet_client.cat_asset_id_to_name(fungible_asset_id)
-                        if result is not None:
-                            nft_royalty_currency = result[1]
+                        result = await wallet_client.cat_asset_id_to_name(CATAssetIDToName(fungible_asset_id))
+                        if result.name is not None:
+                            nft_royalty_currency = result.name
                     fungible_assets.append(
                         FungibleAsset(nft_royalty_currency, uint64(requested[fungible_asset_id_str]))
                     )

chia/wallet/wallet_request_types.py

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

chia/wallet/wallet_rpc_api.py

@@ -112,6 +112,8 @@
     ApplySignatures,
     ApplySignaturesResponse,
     BalanceResponse,
+    CATAssetIDToName,
+    CATAssetIDToNameResponse,
     CATGetAssetID,
     CATGetAssetIDResponse,
     CATGetName,
@@ -2226,15 +2228,16 @@ async def cat_get_asset_id(self, request: CATGetAssetID) -> CATGetAssetIDRespons
         asset_id: str = wallet.get_asset_id()
         return CATGetAssetIDResponse(asset_id=bytes32.from_hexstr(asset_id), wallet_id=request.wallet_id)
 
-    async def cat_asset_id_to_name(self, request: dict[str, Any]) -> EndpointResult:
-        wallet = await self.service.wallet_state_manager.get_wallet_for_asset_id(request["asset_id"])
+    @marshal
+    async def cat_asset_id_to_name(self, request: CATAssetIDToName) -> CATAssetIDToNameResponse:
+        wallet = await self.service.wallet_state_manager.get_wallet_for_asset_id(request.asset_id.hex())
         if wallet is None:
-            if request["asset_id"] in DEFAULT_CATS:
-                return {"wallet_id": None, "name": DEFAULT_CATS[request["asset_id"]]["name"]}
+            if request.asset_id.hex() in DEFAULT_CATS:
+                return CATAssetIDToNameResponse(wallet_id=None, name=DEFAULT_CATS[request.asset_id.hex()]["name"])
             else:
-                raise ValueError("The asset ID specified does not belong to a wallet")
+                return CATAssetIDToNameResponse(wallet_id=None, name=None)
         else:
-            return {"wallet_id": wallet.id(), "name": (wallet.get_name())}
+            return CATAssetIDToNameResponse(wallet_id=wallet.id(), name=wallet.get_name())
 
     @tx_endpoint(push=False)
     async def create_offer_for_ids(

chia/wallet/wallet_rpc_client.py

@@ -24,6 +24,8 @@
     ApplySignaturesResponse,
     CancelOfferResponse,
     CancelOffersResponse,
+    CATAssetIDToName,
+    CATAssetIDToNameResponse,
     CATGetAssetID,
     CATGetAssetIDResponse,
     CATGetName,
@@ -637,15 +639,8 @@ async def get_cat_asset_id(self, request: CATGetAssetID) -> CATGetAssetIDRespons
     async def get_stray_cats(self) -> GetStrayCATsResponse:
         return GetStrayCATsResponse.from_json_dict(await self.fetch("get_stray_cats", {}))
 
-    async def cat_asset_id_to_name(self, asset_id: bytes32) -> Optional[tuple[Optional[uint32], str]]:
-        request = {"asset_id": asset_id.hex()}
-        try:
-            res = await self.fetch("cat_asset_id_to_name", request)
-        except ValueError:  # This happens if the asset_id is unknown
-            return None
-
-        wallet_id: Optional[uint32] = None if res["wallet_id"] is None else uint32(res["wallet_id"])
-        return wallet_id, res["name"]
+    async def cat_asset_id_to_name(self, request: CATAssetIDToName) -> CATAssetIDToNameResponse:
+        return CATAssetIDToNameResponse.from_json_dict(await self.fetch("cat_asset_id_to_name", request.to_json_dict()))
 
     async def get_cat_name(self, request: CATGetName) -> CATGetNameResponse:
         return CATGetNameResponse.from_json_dict(await self.fetch("cat_get_name", request.to_json_dict()))