[LABS-288] Less asset_id: str (#20261)

* Less `asset_id: str`

* Missed a couple

* Missed a couple more

* Missed another?

Author: Quexington

chia/_tests/wallet/cat_wallet/test_cat_wallet.py

@@ -121,7 +121,7 @@ async def mint_cat(
             )
 
     cat_wallet = await wallet_type.get_or_create_wallet_for_cat(
-        environment.wallet_state_manager, environment.xch_wallet, tail_hash.hex(), *extra_args
+        environment.wallet_state_manager, environment.xch_wallet, tail_hash, *extra_args
     )
 
     await wallet_environments.process_pending_states(
@@ -577,7 +577,7 @@ async def test_get_wallet_for_asset_id(wallet_environments: WalletTestFramework,
 
     # Test that the a default CAT will initialize correctly
     asset = DEFAULT_CATS[next(iter(DEFAULT_CATS))]
-    asset_id = asset["asset_id"]
+    asset_id = bytes32.from_hexstr(asset["asset_id"])
     if wallet_type is RCATWallet:
         extra_args: Any = (bytes32.zeros,)
     else:

chia/_tests/wallet/cat_wallet/test_trades.py

@@ -173,15 +173,15 @@ async def test_cat_trades(
         cat_wallet_maker: CATWallet = await CRCATWallet.get_or_create_wallet_for_cat(
             wallet_node_maker.wallet_state_manager,
             wallet_maker,
-            tail_maker.get_tree_hash().hex(),
+            tail_maker.get_tree_hash(),
             None,
             authorized_providers,
             proofs_checker_maker,
         )
         new_cat_wallet_taker: CATWallet = await CRCATWallet.get_or_create_wallet_for_cat(
             wallet_node_taker.wallet_state_manager,
             wallet_taker,
-            tail_taker.get_tree_hash().hex(),
+            tail_taker.get_tree_hash(),
             None,
             authorized_providers,
             proofs_checker_taker,
@@ -417,14 +417,14 @@ async def test_cat_trades(
     # Create the trade parameters
     chia_for_cat: OfferSpecification = {
         wallet_maker.id(): -1,
-        bytes32.from_hexstr(new_cat_wallet_maker.get_asset_id()): 2,  # This is the CAT that the taker made
+        new_cat_wallet_maker.get_asset_id(): 2,  # This is the CAT that the taker made
     }
     cat_for_chia: OfferSpecification = {
         wallet_maker.id(): 3,
         cat_wallet_maker.id(): -4,  # The taker has no knowledge of this CAT yet
     }
     cat_for_cat: OfferSpecification = {
-        bytes32.from_hexstr(cat_wallet_maker.get_asset_id()): -5,
+        cat_wallet_maker.get_asset_id(): -5,
         new_cat_wallet_maker.id(): 6,
     }
     chia_for_multiple_cat: OfferSpecification = {
@@ -445,10 +445,10 @@ async def test_cat_trades(
 
     driver_dict: dict[bytes32, PuzzleInfo] = {}
     for wallet in (cat_wallet_maker, new_cat_wallet_maker):
-        asset_id: str = wallet.get_asset_id()
+        asset_id = wallet.get_asset_id()
         driver_item: dict[str, Any] = {
             "type": AssetType.CAT.value,
-            "tail": "0x" + asset_id,
+            "tail": "0x" + asset_id.hex(),
         }
         if credential_restricted:
             driver_item["also"] = {
@@ -460,7 +460,7 @@ async def test_cat_trades(
                     else proofs_checker_taker.as_program()
                 ),
             }
-        driver_dict[bytes32.from_hexstr(asset_id)] = PuzzleInfo(driver_item)
+        driver_dict[asset_id] = PuzzleInfo(driver_item)
 
     trade_manager_maker = env_maker.wallet_state_manager.trade_manager
     trade_manager_taker = env_taker.wallet_state_manager.trade_manager
@@ -1805,7 +1805,7 @@ async def test_trade_cancellation(wallet_environments: WalletTestFramework, wall
     # This take should fail since we have no CATs to fulfill it with
     with pytest.raises(
         ValueError,
-        match=f"Do not have a wallet for asset ID: {cat_wallet_maker.get_asset_id()} to fulfill offer",
+        match=f"Do not have a wallet for asset ID: {cat_wallet_maker.get_asset_id().hex()} to fulfill offer",
     ):
         async with env_taker.wallet_state_manager.new_action_scope(
             wallet_environments.tx_config, push=False

chia/_tests/wallet/nft_wallet/test_nft_1_offers.py

@@ -1982,7 +1982,7 @@ async def test_complex_nft_offer(
         1: XCH_REQUESTED,
         nft_to_offer_asset_id_taker_1: 1,
         nft_to_offer_asset_id_taker_2: 1,
-        bytes32.from_hexstr(cat_wallet_taker.get_asset_id()): CAT_REQUESTED,
+        cat_wallet_taker.get_asset_id(): CAT_REQUESTED,
     }
 
     nft_taker_1_info = match_puzzle(uncurry_puzzle(taker_nfts[0].full_puzzle))
@@ -1992,10 +1992,10 @@ async def test_complex_nft_offer(
     driver_dict = {
         nft_to_offer_asset_id_taker_1: nft_taker_1_info,
         nft_to_offer_asset_id_taker_2: nft_taker_2_info,
-        bytes32.from_hexstr(cat_wallet_taker.get_asset_id()): PuzzleInfo(
+        cat_wallet_taker.get_asset_id(): PuzzleInfo(
             {
                 "type": "CAT",
-                "tail": "0x" + cat_wallet_taker.get_asset_id(),
+                "tail": "0x" + cat_wallet_taker.get_asset_id().hex(),
                 **(
                     {}
                     if wallet_type is CATWallet
@@ -2047,7 +2047,7 @@ async def test_complex_nft_offer(
         },
         {
             None: uint64(XCH_REQUESTED),
-            bytes32.from_hexstr(cat_wallet_taker.get_asset_id()): uint64(CAT_REQUESTED),
+            cat_wallet_taker.get_asset_id(): uint64(CAT_REQUESTED),
         },
     )
     taker_royalty_summary = NFTWallet.royalty_calculation(
@@ -2056,7 +2056,7 @@ async def test_complex_nft_offer(
             nft_to_offer_asset_id_taker_2: (royalty_puzhash_taker, royalty_basis_pts_taker_2),
         },
         {
-            bytes32.from_hexstr(cat_wallet_maker.get_asset_id()): uint64(CAT_REQUESTED),
+            cat_wallet_maker.get_asset_id(): uint64(CAT_REQUESTED),
         },
     )
     maker_xch_royalties_expected = maker_royalty_summary[nft_to_offer_asset_id_maker][0]["amount"]
@@ -2198,18 +2198,18 @@ async def test_complex_nft_offer(
     complex_nft_offer = {
         cat_wallet_maker.id(): CAT_REQUESTED * -1,
         1: HALF_XCH_REQUESTED,
-        bytes32.from_hexstr(cat_wallet_taker.get_asset_id()): CAT_REQUESTED,
+        cat_wallet_taker.get_asset_id(): CAT_REQUESTED,
         nft_to_offer_asset_id_maker: 1,
     }
 
     maker_nft_info = match_puzzle(uncurry_puzzle(taker_nfts[0].full_puzzle))
     assert maker_nft_info is not None
     driver_dict = {
         nft_to_offer_asset_id_maker: maker_nft_info,
-        bytes32.from_hexstr(cat_wallet_taker.get_asset_id()): PuzzleInfo(
+        cat_wallet_taker.get_asset_id(): PuzzleInfo(
             {
                 "type": "CAT",
-                "tail": "0x" + cat_wallet_taker.get_asset_id(),
+                "tail": "0x" + cat_wallet_taker.get_asset_id().hex(),
             }
         ),
     }

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -239,7 +239,7 @@ async def assert_get_balance(rpc_client: WalletRpcClient, wallet_node: WalletNod
     expected_balance_dict["fingerprint"] = wallet_node.logged_in_fingerprint
     if wallet.type() in {WalletType.CAT, WalletType.CRCAT}:
         assert isinstance(wallet, CATWallet)
-        expected_balance_dict["asset_id"] = "0x" + wallet.get_asset_id()
+        expected_balance_dict["asset_id"] = "0x" + wallet.get_asset_id().hex()
     else:
         expected_balance_dict["asset_id"] = None
     assert (
@@ -1137,7 +1137,7 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
     asset_id = (await env_0.rpc_client.get_cat_asset_id(CATGetAssetID(cat_0_id))).asset_id
     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())
+    ).name == wallet_type.default_wallet_name_for_unknown_cat(asset_id)
     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"
     asset_to_name_response = await env_0.rpc_client.cat_asset_id_to_name(CATAssetIDToName(asset_id))

chia/_tests/wallet/test_wallet_test_framework.py

@@ -2,6 +2,7 @@
 
 import pytest
 from chia_rs import BlockRecord
+from chia_rs.sized_bytes import bytes32
 
 from chia._tests.environments.wallet import (
     BalanceCheckingError,
@@ -145,7 +146,7 @@ async def test_balance_checking(
             )
         ]
     )
-    await CATWallet.get_or_create_wallet_for_cat(env_0.wallet_state_manager, env_0.xch_wallet, "00" * 32)
+    await CATWallet.get_or_create_wallet_for_cat(env_0.wallet_state_manager, env_0.xch_wallet, bytes32.zeros)
     with pytest.raises(KeyError, match="No wallet state for wallet id 2"):
         await env_0.check_balances()
 

chia/_tests/wallet/vc_wallet/test_vc_wallet.py

@@ -849,7 +849,7 @@ async def test_cat_wallet_conversion(
 
     # Key point of test: create a normal CAT wallet first, and see if it gets converted to CR-CAT wallet
     await CATWallet.get_or_create_wallet_for_cat(
-        wallet_node_0.wallet_state_manager, wallet_0, Program.NIL.get_tree_hash().hex()
+        wallet_node_0.wallet_state_manager, wallet_0, Program.NIL.get_tree_hash()
     )
 
     did_id = bytes32.zeros

chia/wallet/cat_wallet/cat_wallet.py

@@ -95,8 +95,8 @@ class CATWallet:
     wallet_info_type: ClassVar[type[CATInfo]] = CATInfo
 
     @staticmethod
-    def default_wallet_name_for_unknown_cat(limitations_program_hash_hex: str) -> str:
-        return f"CAT {limitations_program_hash_hex[:16]}..."
+    def default_wallet_name_for_unknown_cat(limitations_program_hash: bytes32) -> str:
+        return f"CAT {limitations_program_hash.hex()[:16]}..."
 
     @staticmethod
     async def create_new_cat_wallet(
@@ -152,7 +152,7 @@ async def create_new_cat_wallet(
         # since we didn't yet know the TAIL. Now we know the TAIL, we can update the name
         # according to the template name for unknown/new CATs.
         if original_name is None:
-            name = self.default_wallet_name_for_unknown_cat(self.cat_info.limitations_program_hash.hex())
+            name = self.default_wallet_name_for_unknown_cat(self.cat_info.limitations_program_hash)
             await self.set_name(name)
 
         # Change and actual CAT coin
@@ -200,30 +200,27 @@ async def get_or_create_wallet_for_cat(
         cls,
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
-        limitations_program_hash_hex: str,
+        limitations_program_hash: bytes32,
         name: str | None = None,
     ) -> Self:
         self = cls()
         self.standard_wallet = wallet
         self.log = logging.getLogger(__name__)
 
-        limitations_program_hash_hex = bytes32.from_hexstr(limitations_program_hash_hex).hex()  # Normalize the format
-
         for id, w in wallet_state_manager.wallets.items():
             if w.type() == cls.type():
                 assert isinstance(w, cls)
-                if w.get_asset_id() == limitations_program_hash_hex:
+                if w.get_asset_id() == limitations_program_hash:
                     self.log.warning("Not creating wallet for already existing CAT wallet")
                     return w
 
         self.wallet_state_manager = wallet_state_manager
-        if limitations_program_hash_hex in DEFAULT_CATS:
-            cat_info = DEFAULT_CATS[limitations_program_hash_hex]
+        if limitations_program_hash.hex() in DEFAULT_CATS:
+            cat_info = DEFAULT_CATS[limitations_program_hash.hex()]
             name = cat_info["name"]
         elif name is None:
-            name = self.default_wallet_name_for_unknown_cat(limitations_program_hash_hex)
+            name = self.default_wallet_name_for_unknown_cat(limitations_program_hash)
 
-        limitations_program_hash = bytes32.from_hexstr(limitations_program_hash_hex)
         self.cat_info = cls.wallet_info_type(limitations_program_hash, None)
         info_as_string = bytes(self.cat_info).hex()
         self.wallet_info = await wallet_state_manager.user_store.create_wallet(name, self.wallet_type, info_as_string)
@@ -274,7 +271,7 @@ async def create_from_puzzle_info(
         return await cls.get_or_create_wallet_for_cat(
             wallet_state_manager,
             wallet,
-            puzzle_driver["tail"].hex(),
+            puzzle_driver["tail"],
             name,
         )
 
@@ -356,8 +353,8 @@ async def set_name(self, new_name: str) -> None:
         self.wallet_info = new_info
         await self.wallet_state_manager.user_store.update_wallet(self.wallet_info)
 
-    def get_asset_id(self) -> str:
-        return bytes(self.cat_info.limitations_program_hash).hex()
+    def get_asset_id(self) -> bytes32:
+        return self.cat_info.limitations_program_hash
 
     async def coin_added(
         self, coin: Coin, height: uint32, peer: WSChiaConnection, parent_coin_data: CATCoinData | None
@@ -821,12 +818,12 @@ async def save_info(self, cat_info: CATInfo) -> None:
     async def match_puzzle_info(self, puzzle_driver: PuzzleInfo) -> bool:
         return (
             AssetType(puzzle_driver.type()) == AssetType.CAT
-            and puzzle_driver["tail"] == bytes.fromhex(self.get_asset_id())
+            and puzzle_driver["tail"] == self.get_asset_id()
             and puzzle_driver.also() is None
         )
 
     async def get_puzzle_info(self, asset_id: bytes32) -> PuzzleInfo:
-        return PuzzleInfo({"type": AssetType.CAT.value, "tail": "0x" + self.get_asset_id()})
+        return PuzzleInfo({"type": AssetType.CAT.value, "tail": "0x" + self.get_asset_id().hex()})
 
     async def get_coins_to_offer(
         self,

chia/wallet/cat_wallet/lineage_store.py

@@ -21,9 +21,9 @@ class CATLineageStore:
     table_name: str
 
     @classmethod
-    async def create(cls, db_wrapper: DBWrapper2, asset_id: str) -> CATLineageStore:
+    async def create(cls, db_wrapper: DBWrapper2, asset_id: bytes32) -> CATLineageStore:
         self = cls()
-        self.table_name = f"lineage_proofs_{asset_id}"
+        self.table_name = f"lineage_proofs_{asset_id.hex()}"
         self.db_wrapper = db_wrapper
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             await conn.execute(f"CREATE TABLE IF NOT EXISTS {self.table_name}(coin_id text PRIMARY KEY, lineage blob)")

chia/wallet/cat_wallet/r_cat_wallet.py

@@ -71,8 +71,8 @@ class RCATWallet(CATWallet):
     create_new_cat_wallet = None  # type: ignore[assignment]
 
     @staticmethod
-    def default_wallet_name_for_unknown_cat(limitations_program_hash_hex: str) -> str:
-        return f"Revocable-CAT {limitations_program_hash_hex[:16]}..."
+    def default_wallet_name_for_unknown_cat(limitations_program_hash: bytes32) -> str:
+        return f"Revocable-CAT {limitations_program_hash.hex()[:16]}..."
 
     # We need to override this with a different signature.
     # It's not immediately clear what is proper here, likely needs a bit of a refactor.
@@ -81,31 +81,28 @@ async def get_or_create_wallet_for_cat(  # type: ignore[override]
         cls,
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
-        limitations_program_hash_hex: str,
+        limitations_program_hash: bytes32,
         hidden_puzzle_hash: bytes32,
         name: str | None = None,
     ) -> Self:
         self = cls()
         self.standard_wallet = wallet
         self.log = logging.getLogger(__name__)
 
-        limitations_program_hash_hex = bytes32.from_hexstr(limitations_program_hash_hex).hex()  # Normalize the format
-
         for id, w in wallet_state_manager.wallets.items():
             if w.type() == cls.type():
                 assert isinstance(w, cls)
-                if w.get_asset_id() == limitations_program_hash_hex:
+                if w.get_asset_id() == limitations_program_hash:
                     self.log.warning("Not creating wallet for already existing CAT wallet")
                     return w
 
         self.wallet_state_manager = wallet_state_manager
-        if limitations_program_hash_hex in DEFAULT_CATS:
-            cat_info = DEFAULT_CATS[limitations_program_hash_hex]
+        if limitations_program_hash.hex() in DEFAULT_CATS:
+            cat_info = DEFAULT_CATS[limitations_program_hash.hex()]
             name = cat_info["name"]
         elif name is None:
-            name = self.default_wallet_name_for_unknown_cat(limitations_program_hash_hex)
+            name = self.default_wallet_name_for_unknown_cat(limitations_program_hash)
 
-        limitations_program_hash = bytes32.from_hexstr(limitations_program_hash_hex)
         self.cat_info = cls.wallet_info_type(limitations_program_hash, None, hidden_puzzle_hash)
         info_as_string = bytes(self.cat_info).hex()
         self.wallet_info = await wallet_state_manager.user_store.create_wallet(name, cls.wallet_type, info_as_string)
@@ -150,7 +147,7 @@ async def create_from_puzzle_info(
         return await cls.get_or_create_wallet_for_cat(
             wallet_state_manager,
             wallet,
-            puzzle_driver["tail"].hex(),
+            puzzle_driver["tail"],
             bytes32(rev_layer["hidden_puzzle_hash"]),
             name,
         )
@@ -247,7 +244,7 @@ async def get_puzzle_info(self, asset_id: bytes32) -> PuzzleInfo:
         return PuzzleInfo(
             {
                 "type": AssetType.CAT.value,
-                "tail": "0x" + self.get_asset_id(),
+                "tail": "0x" + self.get_asset_id().hex(),
                 "also": {
                     "type": AssetType.REVOCATION_LAYER.value,
                     "hidden_puzzle_hash": "0x" + self.cat_info.hidden_puzzle_hash.hex(),

chia/wallet/nft_wallet/nft_wallet.py

@@ -821,7 +821,7 @@ async def make_nft1_offer(
                 if asset is None:
                     wallet = wallet_state_manager.main_wallet
                 else:
-                    wallet = await wallet_state_manager.get_wallet_for_asset_id(asset.hex())
+                    wallet = await wallet_state_manager.get_wallet_for_asset_id(asset)
                 if asset in royalty_payments:
                     royalty_amount: int = sum(p.amount for _, p in royalty_payments[asset])
                 else:
@@ -872,7 +872,7 @@ async def make_nft1_offer(
                 if asset is None:
                     wallet = wallet_state_manager.main_wallet
                 else:
-                    wallet = await wallet_state_manager.get_wallet_for_asset_id(asset.hex())
+                    wallet = await wallet_state_manager.get_wallet_for_asset_id(asset)
 
                 # First, sending all the coins to the OFFER_MOD
                 async with wallet_state_manager.new_action_scope(