Add RCATs to wallet (#19795)

* Add RCATs to wallet

* undo outer puzzle changes and fix tests

* logging

* update testnet overrides in wallet

* some empirical debugging

* comments by @altendky

* fix an accident

* a bit better

* comment by @altendky

* Add RCAT to all relevant enumerations

* reorder

---------

Co-authored-by: arvidn <[email protected]>

Author: Quexington

chia/_tests/wallet/cat_wallet/test_cat_wallet.py

@@ -12,6 +12,7 @@
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
 from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia._tests.util.time_out_assert import time_out_assert
+from chia._tests.wallet.cat_wallet.test_cat_wallet import mint_cat
 from chia._tests.wallet.vc_wallet.test_vc_wallet import mint_cr_cat
 from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
@@ -20,6 +21,7 @@
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.hash import std_hash
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
+from chia.wallet.cat_wallet.r_cat_wallet import RCATWallet
 from chia.wallet.conditions import CreateCoinAnnouncement, parse_conditions_non_consensus
 from chia.wallet.did_wallet.did_wallet import DIDWallet
 from chia.wallet.outer_puzzles import AssetType
@@ -96,10 +98,12 @@ async def get_trade_and_status(trade_manager: TradeManager, trade: TradeRecord)
     ],
     indirect=["wallet_environments"],
 )
+@pytest.mark.parametrize("wallet_type", [CATWallet, RCATWallet])
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
 async def test_cat_trades(
     wallet_environments: WalletTestFramework,
     credential_restricted: bool,
+    wallet_type: type[CATWallet],
     active_softfork_height: uint32,
 ) -> None:
     # Setup
@@ -352,52 +356,11 @@ async def test_cat_trades(
         }
 
         # Mint some standard CATs
-        async with wallet_maker.wallet_state_manager.new_action_scope(
-            wallet_environments.tx_config, push=True
-        ) as action_scope:
-            cat_wallet_maker = await CATWallet.create_new_cat_wallet(
-                wallet_node_maker.wallet_state_manager,
-                wallet_maker,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                action_scope,
-            )
-
-        async with wallet_taker.wallet_state_manager.new_action_scope(
-            wallet_environments.tx_config, push=True
-        ) as action_scope:
-            new_cat_wallet_taker = await CATWallet.create_new_cat_wallet(
-                wallet_node_taker.wallet_state_manager,
-                wallet_taker,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                action_scope,
-            )
-
-        await wallet_environments.process_pending_states(
-            [
-                # Balance checking for this scenario is covered in test_cat_wallet
-                WalletStateTransition(
-                    pre_block_balance_updates={
-                        "xch": {"set_remainder": True},
-                        "cat": {"init": True, "set_remainder": True},
-                    },
-                    post_block_balance_updates={
-                        "xch": {"set_remainder": True},
-                        "cat": {"set_remainder": True},
-                    },
-                ),
-                WalletStateTransition(
-                    pre_block_balance_updates={
-                        "xch": {"set_remainder": True},
-                        "new cat": {"init": True, "set_remainder": True},
-                    },
-                    post_block_balance_updates={
-                        "xch": {"set_remainder": True},
-                        "new cat": {"set_remainder": True},
-                    },
-                ),
-            ]
+        cat_wallet_maker = await mint_cat(
+            wallet_environments, env_maker, "xch", "cat", uint64(100), wallet_type, "cat maker"
+        )
+        new_cat_wallet_taker = await mint_cat(
+            wallet_environments, env_taker, "xch", "new cat", uint64(100), wallet_type, "cat taker"
         )
 
     if credential_restricted:
@@ -428,8 +391,12 @@ async def test_cat_trades(
             proofs_checker_taker,
         )
     else:
-        new_cat_wallet_maker = await CATWallet.get_or_create_wallet_for_cat(
-            wallet_node_maker.wallet_state_manager, wallet_maker, new_cat_wallet_taker.get_asset_id()
+        if wallet_type is RCATWallet:
+            extra_args: Any = (bytes32.zeros,)
+        else:
+            extra_args = tuple()
+        new_cat_wallet_maker = await wallet_type.get_or_create_wallet_for_cat(
+            wallet_node_maker.wallet_state_manager, wallet_maker, new_cat_wallet_taker.get_asset_id(), *extra_args
         )
 
     await env_maker.change_balances(

chia/_tests/wallet/cat_wallet/test_trades.py

@@ -132,7 +132,7 @@ def get_mojo_per_unit(wallet_type: WalletType) -> int:
         WalletType.VC,
     }:
         mojo_per_unit = units["chia"]
-    elif wallet_type in {WalletType.CAT, WalletType.CRCAT}:
+    elif wallet_type in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
         mojo_per_unit = units["cat"]
     elif wallet_type in {WalletType.NFT, WalletType.DECENTRALIZED_ID}:
         mojo_per_unit = units["mojo"]
@@ -166,7 +166,7 @@ async def get_unit_name_for_wallet_id(
         WalletType.VC,
     }:
         name: str = config["network_overrides"]["config"][config["selected_network"]]["address_prefix"].upper()
-    elif wallet_type in {WalletType.CAT, WalletType.CRCAT}:
+    elif wallet_type in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
         name = await wallet_client.get_cat_name(wallet_id=wallet_id)
     else:
         raise LookupError(f"Operation is not supported for Wallet type {wallet_type.name}")
@@ -358,7 +358,7 @@ async def send(
                 push=push,
                 timelock_info=condition_valid_times,
             )
-        elif typ in {WalletType.CAT, WalletType.CRCAT}:
+        elif typ in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
             print("Submitting transaction...")
             res = await wallet_client.cat_spend(
                 wallet_id,
@@ -891,7 +891,7 @@ async def cancel_offer(
 
 
 def wallet_coin_unit(typ: WalletType, address_prefix: str) -> tuple[str, int]:
-    if typ in {WalletType.CAT, WalletType.CRCAT}:
+    if typ in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
         return "", units["cat"]
     if typ in {WalletType.STANDARD_WALLET, WalletType.POOLING_WALLET, WalletType.MULTI_SIG}:
         return address_prefix, units["chia"]

chia/cmds/wallet_funcs.py

@@ -19,6 +19,12 @@ class CATInfo(Streamable):
     my_tail: Optional[Program]  # this is the program
 
 
+@streamable
+@dataclass(frozen=True)
+class RCATInfo(CATInfo):
+    hidden_puzzle_hash: bytes32
+
+
 @streamable
 @dataclass(frozen=True)
 class CATCoinData(Streamable):
@@ -41,8 +47,6 @@ class LegacyCATInfo(Streamable):
 
 @streamable
 @dataclass(frozen=True)
-class CRCATInfo(Streamable):
-    limitations_program_hash: bytes32
-    my_tail: Optional[Program]  # this is the program
+class CRCATInfo(CATInfo):
     authorized_providers: list[bytes32]
     proofs_checker: ProofsChecker

chia/wallet/cat_wallet/cat_info.py

@@ -26,7 +26,7 @@ class CATOuterPuzzle:
     _match: Callable[[UncurriedPuzzle], Optional[PuzzleInfo]]
     _construct: Callable[[PuzzleInfo, Program], Program]
     _solve: Callable[[PuzzleInfo, Solver, Program, Program], Program]
-    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle], Optional[Program]]
+    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle, Optional[Program]], Optional[Program]]
     _get_inner_solution: Callable[[PuzzleInfo, Program], Optional[Program]]
 
     def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
@@ -43,14 +43,18 @@ def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
             constructor_dict["also"] = next_constructor.info
         return PuzzleInfo(constructor_dict)
 
-    def get_inner_puzzle(self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle) -> Optional[Program]:
+    def get_inner_puzzle(
+        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Optional[Program] = None
+    ) -> Optional[Program]:
         args = match_cat_puzzle(puzzle_reveal)
         if args is None:
             raise ValueError("This driver is not for the specified puzzle reveal")
         _, _, inner_puzzle = args
         also = constructor.also()
         if also is not None:
-            deep_inner_puzzle: Optional[Program] = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle))
+            deep_inner_puzzle: Optional[Program] = self._get_inner_puzzle(
+                also, uncurry_puzzle(inner_puzzle), solution.first() if solution is not None else None
+            )
             return deep_inner_puzzle
         else:
             return inner_puzzle

chia/wallet/cat_wallet/cat_outer_puzzle.py

@@ -93,6 +93,8 @@ class CATWallet:
     cat_info: CATInfo
     standard_wallet: Wallet
     lineage_store: CATLineageStore
+    wallet_type: ClassVar[WalletType] = WalletType.CAT
+    wallet_info_type: ClassVar[type[CATInfo]] = CATInfo
 
     @staticmethod
     def default_wallet_name_for_unknown_cat(limitations_program_hash_hex: str) -> str:
@@ -120,15 +122,15 @@ async def create_new_cat_wallet(
 
         # We use 00 bytes because it's not optional. We must check this is overridden during issuance.
         empty_bytes = bytes32(32 * b"\0")
-        self.cat_info = CATInfo(empty_bytes, None)
+        self.cat_info = self.wallet_info_type(empty_bytes, None)
         info_as_string = bytes(self.cat_info).hex()
         # If the name is not provided, it will be autogenerated based on the resulting tail hash.
         # For now, give the wallet a temporary name "CAT WALLET" until we get the tail hash
         original_name = name
         if name is None:
             name = "CAT WALLET"
 
-        self.wallet_info = await wallet_state_manager.user_store.create_wallet(name, WalletType.CAT, info_as_string)
+        self.wallet_info = await wallet_state_manager.user_store.create_wallet(name, self.wallet_type, info_as_string)
 
         try:
             spend_bundle = await ALL_LIMITATIONS_PROGRAMS[cat_tail_info["identifier"]].generate_issuance_bundle(
@@ -222,9 +224,9 @@ async def get_or_create_wallet_for_cat(
             name = self.default_wallet_name_for_unknown_cat(limitations_program_hash_hex)
 
         limitations_program_hash = bytes32.from_hexstr(limitations_program_hash_hex)
-        self.cat_info = CATInfo(limitations_program_hash, None)
+        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, WalletType.CAT, info_as_string)
+        self.wallet_info = await wallet_state_manager.user_store.create_wallet(name, self.wallet_type, info_as_string)
 
         self.lineage_store = await CATLineageStore.create(self.wallet_state_manager.db_wrapper, self.get_asset_id())
         await self.wallet_state_manager.add_new_wallet(self)
@@ -273,26 +275,27 @@ async def create_from_puzzle_info(
             name,
         )
 
-    @staticmethod
+    @classmethod
     async def create(
+        cls,
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
         wallet_info: WalletInfo,
-    ) -> CATWallet:
-        self = CATWallet()
+    ) -> Self:
+        self = cls()
 
         self.log = logging.getLogger(__name__)
 
         self.wallet_state_manager = wallet_state_manager
         self.wallet_info = wallet_info
         self.standard_wallet = wallet
         try:
-            self.cat_info = CATInfo.from_bytes(hexstr_to_bytes(self.wallet_info.data))
+            self.cat_info = cls.wallet_info_type.from_bytes(hexstr_to_bytes(self.wallet_info.data))
             self.lineage_store = await CATLineageStore.create(self.wallet_state_manager.db_wrapper, self.get_asset_id())
         except AssertionError:
             # Do a migration of the lineage proofs
             cat_info = LegacyCATInfo.from_bytes(hexstr_to_bytes(self.wallet_info.data))
-            self.cat_info = CATInfo(cat_info.limitations_program_hash, cat_info.my_tail)
+            self.cat_info = cls.wallet_info_type(cat_info.limitations_program_hash, cat_info.my_tail)
             self.lineage_store = await CATLineageStore.create(self.wallet_state_manager.db_wrapper, self.get_asset_id())
             for coin_id, lineage in cat_info.lineage_proofs:
                 await self.add_lineage(coin_id, lineage)
@@ -302,7 +305,7 @@ async def create(
 
     @classmethod
     def type(cls) -> WalletType:
-        return WalletType.CAT
+        return cls.wallet_type
 
     def id(self) -> uint32:
         return self.wallet_info.id
@@ -601,6 +604,14 @@ async def create_tandem_xch_tx(
 
         return announcement
 
+    async def make_inner_solution(
+        self,
+        coin: Coin,
+        primaries: list[CreateCoin],
+        conditions: tuple[Condition, ...] = tuple(),
+    ) -> Program:
+        return self.standard_wallet.make_solution(primaries=primaries, conditions=conditions)
+
     async def generate_unsigned_spendbundle(
         self,
         payments: list[CreateCoin],
@@ -686,7 +697,8 @@ async def generate_unsigned_spendbundle(
                             action_scope,
                             extra_conditions=(announcement.corresponding_assertion(),),
                         )
-                        innersol = self.standard_wallet.make_solution(
+                        innersol = await self.make_inner_solution(
+                            coin=coin,
                             primaries=primaries,
                             conditions=(*extra_conditions, announcement),
                         )
@@ -697,21 +709,23 @@ async def generate_unsigned_spendbundle(
                             action_scope,
                         )
                         assert xch_announcement is not None
-                        innersol = self.standard_wallet.make_solution(
+                        innersol = await self.make_inner_solution(
+                            coin=coin,
                             primaries=primaries,
                             conditions=(*extra_conditions, xch_announcement, announcement),
                         )
                     else:
                         # TODO: what about when they are equal?
                         raise Exception("Equality not handled")
                 else:
-                    innersol = self.standard_wallet.make_solution(
+                    innersol = await self.make_inner_solution(
+                        coin=coin,
                         primaries=primaries,
                         conditions=(*extra_conditions, announcement),
                     )
             else:
-                innersol = self.standard_wallet.make_solution(
-                    primaries=[], conditions=(announcement.corresponding_assertion(),)
+                innersol = await self.make_inner_solution(
+                    coin=coin, primaries=[], conditions=(announcement.corresponding_assertion(),)
                 )
             inner_puzzle = await self.inner_puzzle_for_cat_puzhash(coin.puzzle_hash)
             lineage_proof = await self.get_lineage_proof_for_coin(coin)

chia/wallet/cat_wallet/cat_wallet.py

@@ -73,3 +73,10 @@ async def get_all_lineage_proofs(self) -> dict[bytes32, LineageProof]:
             lineage_dict[bytes32.from_hexstr(row[0])] = LineageProof.from_bytes(row[1])
 
         return lineage_dict
+
+    async def is_empty(self) -> bool:
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            cursor = await conn.execute(f"SELECT COUNT(*) FROM {self.table_name}")
+            row_count = await cursor.fetchone()
+            assert row_count is not None
+            return bool(row_count[0] == 0)