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

chia/util/keyring_wrapper.py

@@ -24,10 +24,10 @@ from chia.util.file_keyring import FileKeyring
 # WARNING: Changing the default passphrase will prevent passphrase-less users from accessing
 # their existing keys. Using a new default passphrase requires migrating existing users to
 # the new passphrase.
-DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE = "$ chia passphrase set # all the cool kids are doing it!"
+DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE = "$ chia passphrase set # all the cool kids are doing it!"  # noqa: S105
 
-MASTER_PASSPHRASE_SERVICE_NAME = "Chia Passphrase"
-MASTER_PASSPHRASE_USER_NAME = "Chia Passphrase"
+MASTER_PASSPHRASE_SERVICE_NAME = "Chia Passphrase"  # noqa: S105
+MASTER_PASSPHRASE_USER_NAME = "Chia Passphrase"  # noqa: S105
 
 
 OSPassphraseStore = Union[MacKeyring, WinKeyring]
@@ -112,7 +112,7 @@ def obtain_current_passphrase(prompt: str = DEFAULT_PASSPHRASE_PROMPT, use_passp
 
         time.sleep(FAILED_ATTEMPT_DELAY)
         print("Incorrect passphrase\n")
-    raise KeychainMaxUnlockAttempts()
+    raise KeychainMaxUnlockAttempts
 
 
 class KeyringWrapper:
@@ -254,7 +254,7 @@ class KeyringWrapper:
             and current_passphrase is not None
             and not self.master_passphrase_is_valid(current_passphrase)
         ):
-            raise KeychainCurrentPassphraseIsInvalid()
+            raise KeychainCurrentPassphraseIsInvalid
 
         self.set_cached_master_passphrase(new_passphrase, validated=True)
 

chia/util/limited_semaphore.py

@@ -31,7 +31,7 @@ class LimitedSemaphore:
     @contextlib.asynccontextmanager
     async def acquire(self) -> AsyncIterator[int]:
         if self._available_count < 1:
-            raise LimitedSemaphoreFullError()
+            raise LimitedSemaphoreFullError
 
         self._available_count -= 1
         try:

chia/util/priority_mutex.py

@@ -66,7 +66,7 @@ class PriorityMutex(Generic[_T_Priority]):
         if task is None:
             raise Exception(f"unable to check current task, got: {task!r}")
         if self._active is not None and self._active.task is task:
-            raise NestedLockUnsupportedError()
+            raise NestedLockUnsupportedError
 
         element = _Element(task=task)
 

chia/util/streamable.py

@@ -13,7 +13,7 @@ from typing import TYPE_CHECKING, Any, BinaryIO, Callable, ClassVar, Optional, T
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint32, uint64
-from typing_extensions import Literal, get_args, get_origin
+from typing_extensions import Literal, Self, get_args, get_origin
 
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.hash import std_hash
@@ -126,6 +126,10 @@ def is_type_Tuple(f_type: object) -> bool:
     return get_origin(f_type) is tuple or f_type is tuple
 
 
+def is_type_Dict(f_type: object) -> bool:
+    return get_origin(f_type) is dict or f_type is dict
+
+
 def convert_optional(convert_func: ConvertFunctionType, item: Any) -> Any:
     if item is None:
         return None
@@ -146,6 +150,12 @@ def convert_list(convert_func: ConvertFunctionType, items: list[Any]) -> list[An
     return [convert_func(item) for item in items]
 
 
+def convert_dict(
+    key_converter: ConvertFunctionType, value_converter: ConvertFunctionType, mapping: dict[Any, Any]
+) -> dict[Any, Any]:
+    return {key_converter(key): value_converter(value) for key, value in mapping.items()}
+
+
 def convert_hex_string(item: str) -> bytes:
     if not isinstance(item, str):
         raise InvalidTypeError(str, type(item))
@@ -213,6 +223,11 @@ def function_to_convert_one_item(
         convert_inner_func = function_to_convert_one_item(inner_type, json_parser)
         # Ignoring for now as the proper solution isn't obvious
         return lambda items: convert_list(convert_inner_func, items)  # type: ignore[arg-type]
+    elif is_type_Dict(f_type):
+        inner_types = get_args(f_type)
+        key_converter = function_to_convert_one_item(inner_types[0], json_parser)
+        value_converter = function_to_convert_one_item(inner_types[1], json_parser)
+        return lambda mapping: convert_dict(key_converter, value_converter, mapping)  # type: ignore[arg-type]
     elif hasattr(f_type, "from_json_dict"):
         if json_parser is None:
             json_parser = f_type.from_json_dict
@@ -257,6 +272,11 @@ def function_to_post_init_process_one_item(f_type: type[object]) -> ConvertFunct
         inner_type = get_args(f_type)[0]
         process_inner_func = function_to_post_init_process_one_item(inner_type)
         return lambda items: convert_list(process_inner_func, items)  # type: ignore[arg-type]
+    if is_type_Dict(f_type):
+        inner_types = get_args(f_type)
+        key_converter = function_to_post_init_process_one_item(inner_types[0])
+        value_converter = function_to_post_init_process_one_item(inner_types[1])
+        return lambda mapping: convert_dict(key_converter, value_converter, mapping)  # type: ignore[arg-type]
     return lambda item: post_init_process_item(f_type, item)
 
 
@@ -365,6 +385,19 @@ def parse_tuple(f: BinaryIO, list_parse_inner_type_f: list[ParseFunctionType]) -
     return tuple(full_list)
 
 
+def parse_dict(
+    f: BinaryIO, key_parse_inner_type_f: ParseFunctionType, value_parse_inner_type_f: ParseFunctionType
+) -> dict[object, object]:
+    # We know this is a list of tuples but our parse_list hint doesn't help us here
+    keys_and_values: list[tuple[object, object]] = parse_list(  # type: ignore[assignment]
+        f, lambda inner_f: parse_tuple(inner_f, [key_parse_inner_type_f, value_parse_inner_type_f])
+    )
+    parsed_dict: dict[object, object] = dict(keys_and_values)
+    if len(parsed_dict) < len(keys_and_values):
+        raise ValueError("duplicate dict keys found when deserializing")
+    return parsed_dict
+
+
 def parse_str(f: BinaryIO) -> str:
     str_size = parse_uint32(f)
     str_read_bytes = f.read(str_size)
@@ -399,6 +432,11 @@ def function_to_parse_one_item(f_type: type[Any]) -> ParseFunctionType:
         inner_types = get_args(f_type)
         list_parse_inner_type_f = [function_to_parse_one_item(_) for _ in inner_types]
         return lambda f: parse_tuple(f, list_parse_inner_type_f)
+    if is_type_Dict(f_type):
+        inner_types = get_args(f_type)
+        key_parse_inner_type_f = function_to_parse_one_item(inner_types[0])
+        value_parse_inner_type_f = function_to_parse_one_item(inner_types[1])
+        return lambda f: parse_dict(f, key_parse_inner_type_f, value_parse_inner_type_f)
     if f_type is str:
         return parse_str
     raise UnsupportedType(f"Type {f_type} does not have parse")
@@ -429,6 +467,21 @@ def stream_tuple(stream_inner_type_funcs: list[StreamFunctionType], item: Any, f
         stream_inner_type_funcs[i](item[i], f)
 
 
+def stream_dict(
+    key_stream_inner_type_func: StreamFunctionType,
+    value_stream_inner_type_func: StreamFunctionType,
+    item: Any,
+    f: BinaryIO,
+) -> None:
+    return stream_list(
+        lambda inner_item, inner_f: stream_tuple(
+            [key_stream_inner_type_func, value_stream_inner_type_func], inner_item, inner_f
+        ),
+        list(item.items()),
+        f,
+    )
+
+
 def stream_str(item: Any, f: BinaryIO) -> None:
     str_bytes = item.encode("utf-8")
     write_uint32(f, uint32(len(str_bytes)))
@@ -469,6 +522,11 @@ def function_to_stream_one_item(f_type: type[Any]) -> StreamFunctionType:
         for i in range(len(inner_types)):
             stream_inner_type_funcs.append(function_to_stream_one_item(inner_types[i]))
         return lambda item, f: stream_tuple(stream_inner_type_funcs, item, f)
+    elif is_type_Dict(f_type):
+        inner_types = get_args(f_type)
+        key_stream_inner_type_func = function_to_stream_one_item(inner_types[0])
+        value_stream_inner_type_func = function_to_stream_one_item(inner_types[1])
+        return lambda item, f: stream_dict(key_stream_inner_type_func, value_stream_inner_type_func, item, f)
     elif f_type is str:
         return stream_str
     elif f_type is bool:
@@ -575,9 +633,9 @@ class Streamable:
             raise
 
     @classmethod
-    def parse(cls: type[_T_Streamable], f: BinaryIO) -> _T_Streamable:
+    def parse(cls, f: BinaryIO) -> Self:
         # Create the object without calling __init__() to avoid unnecessary post-init checks in strictdataclass
-        obj: _T_Streamable = object.__new__(cls)
+        obj: Self = object.__new__(cls)
         for field in cls._streamable_fields:
             object.__setattr__(obj, field.name, field.parse_function(f))
         return obj
@@ -590,7 +648,7 @@ class Streamable:
         return std_hash(bytes(self), skip_bytes_conversion=True)
 
     @classmethod
-    def from_bytes(cls: type[_T_Streamable], blob: bytes) -> _T_Streamable:
+    def from_bytes(cls, blob: bytes) -> Self:
         f = io.BytesIO(blob)
         parsed = cls.parse(f)
         assert f.read() == b""
@@ -617,7 +675,7 @@ class Streamable:
         return ret
 
     @classmethod
-    def from_json_dict(cls: type[_T_Streamable], json_dict: dict[str, Any]) -> _T_Streamable:
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
         return streamable_from_dict(cls, json_dict)
 
 

chia/util/task_timing.py

@@ -250,7 +250,7 @@ def start_task_instrumentation() -> None:
 
 def color(pct: float) -> str:
     assert pct >= 0 and pct <= 100
-    return f"{((100 - pct) // 10) + 1}"
+    return f"{int((100 - pct) // 10) + 1}"
 
 
 def fontcolor(pct: float) -> str:

chia/util/virtual_project_analysis.py

@@ -161,7 +161,7 @@ def find_all_dependency_paths(dependency_graph: dict[str, list[str]], start: str
         if current in visited:
             return
         if current == target and len(path) > 0:
-            all_paths.append(path[1:] + [current])
+            all_paths.append([*path[1:], current])
             return
         visited.add(current)
         for provider in sorted(dependency_graph.get(current, [])):

chia/wallet/cat_wallet/cat_info.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_outer_puzzle.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Callable, Optional
 
+from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_spend import CoinSpend
 from chia.wallet.cat_wallet.cat_utils import (
     CAT_MOD,
     SpendableCAT,
@@ -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 @@ class CATOuterPuzzle:
             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
@@ -118,4 +122,4 @@ class CATOuterPuzzle:
                 )
             )
         bundle = unsigned_spend_bundle_for_spendable_cats(CAT_MOD, spendable_cats)
-        return next(cs.solution.to_program() for cs in bundle.coin_spends if cs.coin == target_coin)
+        return next(Program.from_serialized(cs.solution) for cs in bundle.coin_spends if cs.coin == target_coin)

chia/wallet/cat_wallet/cat_utils.py

@@ -8,11 +8,11 @@ from chia_puzzles_py.programs import CAT_PUZZLE, CAT_PUZZLE_HASH
 from chia_rs import G2Element
 from chia_rs.sized_bytes import bytes32
 
+from chia.consensus.condition_tools import conditions_dict_for_solution
 from chia.types.blockchain_format.coin import Coin, coin_as_list
 from chia.types.blockchain_format.program import INFINITE_COST, Program
 from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
-from chia.util.condition_tools import conditions_dict_for_solution
 from chia.wallet.lineage_proof import LineageProof
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle
 from chia.wallet.util.curry_and_treehash import calculate_hash_of_quoted_mod_hash

chia/wallet/cat_wallet/cat_wallet.py

@@ -9,13 +9,12 @@ from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 from chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64, uint128
-from typing_extensions import Unpack
+from typing_extensions import Self, Unpack
 
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import Program
-from chia.types.coin_spend import compute_additions_with_cost
+from chia.types.blockchain_format.program import Program, run
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.errors import Err, ValidationError
@@ -49,6 +48,7 @@ from chia.wallet.puzzle_drivers import PuzzleInfo
 from chia.wallet.puzzles.tails import ALL_LIMITATIONS_PROGRAMS
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.uncurried_puzzle import uncurry_puzzle
+from chia.wallet.util.compute_additions import compute_additions_with_cost
 from chia.wallet.util.compute_memos import compute_memos
 from chia.wallet.util.curry_and_treehash import curry_and_treehash
 from chia.wallet.util.transaction_type import TransactionType
@@ -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,7 +122,7 @@ class CATWallet:
 
         # 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
@@ -128,7 +130,7 @@ class CATWallet:
         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(
@@ -193,22 +195,23 @@ class CATWallet:
             interface.side_effects.transactions.append(cat_record)
         return self
 
-    @staticmethod
+    @classmethod
     async def get_or_create_wallet_for_cat(
+        cls,
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
         limitations_program_hash_hex: str,
         name: Optional[str] = None,
-    ) -> CATWallet:
-        self = CATWallet()
+    ) -> 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() == CATWallet.type():
-                assert isinstance(w, CATWallet)
+            if w.type() == cls.type():
+                assert isinstance(w, cls)
                 if w.get_asset_id() == limitations_program_hash_hex:
                     self.log.warning("Not creating wallet for already existing CAT wallet")
                     return w
@@ -221,9 +224,9 @@ class CATWallet:
             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)
@@ -272,13 +275,14 @@ class CATWallet:
             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__)
 
@@ -286,12 +290,12 @@ class CATWallet:
         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)
@@ -301,7 +305,7 @@ class CATWallet:
 
     @classmethod
     def type(cls) -> WalletType:
-        return WalletType.CAT
+        return cls.wallet_type
 
     def id(self) -> uint32:
         return self.wallet_info.id
@@ -352,15 +356,6 @@ class CATWallet:
     def get_asset_id(self) -> str:
         return bytes(self.cat_info.limitations_program_hash).hex()
 
-    async def set_tail_program(self, tail_program: str) -> None:
-        assert Program.fromhex(tail_program).get_tree_hash() == self.cat_info.limitations_program_hash
-        await self.save_info(
-            CATInfo(
-                self.cat_info.limitations_program_hash,
-                Program.fromhex(tail_program),
-            )
-        )
-
     async def coin_added(
         self, coin: Coin, height: uint32, peer: WSChiaConnection, parent_coin_data: Optional[CATCoinData]
     ) -> None:
@@ -583,7 +578,7 @@ class CATWallet:
                 selected_amount = sum(c.amount for c in chia_coins)
                 await self.standard_wallet.generate_signed_transaction(
                     [uint64(selected_amount + amount_to_claim - fee)],
-                    [(await self.standard_wallet.get_puzzle_hash(not action_scope.config.tx_config.reuse_puzhash))],
+                    [await action_scope.get_puzzle_hash(self.wallet_state_manager)],
                     inner_action_scope,
                     coins=chia_coins,
                     negative_change_allowed=True,
@@ -596,7 +591,7 @@ class CATWallet:
                 continue
             for spend in tx.spend_bundle.coin_spends:
                 if spend.coin.name() == origin_id:
-                    conditions = spend.puzzle_reveal.to_program().run(spend.solution.to_program()).as_python()
+                    conditions = run(spend.puzzle_reveal, Program.from_serialized(spend.solution)).as_python()
                     for condition in conditions:
                         if condition[0] == ConditionOpcode.CREATE_COIN_ANNOUNCEMENT:
                             message = condition[1]
@@ -609,6 +604,14 @@ class CATWallet:
 
         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],
@@ -657,10 +660,12 @@ class CATWallet:
                 for payment in payments:
                     if change_puzhash == payment.puzzle_hash and change == payment.amount:
                         # We cannot create two coins has same id, create a new puzhash for the change
-                        change_puzhash = await self.standard_wallet.get_puzzle_hash(new=True)
+                        change_puzhash = await action_scope.get_puzzle_hash(
+                            self.wallet_state_manager, override_reuse_puzhash_with=False
+                        )
                         break
             else:
-                change_puzhash = await self.standard_wallet.get_puzzle_hash(new=True)
+                change_puzhash = await action_scope.get_puzzle_hash(self.wallet_state_manager)
             primaries.append(CreateCoin(change_puzhash, uint64(change), [change_puzhash]))
 
         # Loop through the coins we've selected and gather the information we need to spend them
@@ -692,7 +697,8 @@ class CATWallet:
                             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),
                         )
@@ -703,7 +709,8 @@ class CATWallet:
                             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),
                         )
@@ -711,13 +718,14 @@ class CATWallet:
                         # 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/lineage_store.py

@@ -73,3 +73,10 @@ class CATLineageStore:
             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)