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

chia/wallet/did_wallet/did_wallet.py

@@ -7,16 +7,15 @@ import re
 import time
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
-from chia_rs import AugSchemeMPL, G1Element, G2Element
+from chia_rs import AugSchemeMPL, CoinSpend, CoinState, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint32, uint64, uint128
 from typing_extensions import Unpack
 
-from chia.protocols.wallet_protocol import CoinState
 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 CoinSpend, make_spend
+from chia.types.coin_spend import make_spend
 from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
 from chia.wallet.conditions import (
     AssertCoinAnnouncement,
@@ -28,7 +27,7 @@ from chia.wallet.conditions import (
 )
 from chia.wallet.derivation_record import DerivationRecord
 from chia.wallet.did_wallet import did_wallet_puzzles
-from chia.wallet.did_wallet.did_info import DIDCoinData, DIDInfo
+from chia.wallet.did_wallet.did_info import DIDCoinData, DIDInfo, did_recovery_is_nil
 from chia.wallet.did_wallet.did_wallet_puzzles import match_did_puzzle, uncurry_innerpuz
 from chia.wallet.lineage_proof import LineageProof
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
@@ -48,6 +47,7 @@ from chia.wallet.uncurried_puzzle import uncurry_puzzle
 from chia.wallet.util.compute_memos import compute_memos
 from chia.wallet.util.curry_and_treehash import NIL_TREEHASH, shatree_int, shatree_pair
 from chia.wallet.util.transaction_type import TransactionType
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.util.wallet_sync_utils import fetch_coin_spend, fetch_coin_spend_for_coin_state
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet import Wallet
@@ -228,7 +228,7 @@ class DIDWallet:
         inner_solution: Program = full_solution.rest().rest().first()
         recovery_list: list[bytes32] = []
         backup_required: int = num_verification.as_int()
-        if recovery_list_hash != NIL_TREEHASH:
+        if not did_recovery_is_nil(recovery_list_hash):
             try:
                 for did in inner_solution.rest().rest().rest().rest().rest().as_python():
                     recovery_list.append(bytes32(did[0]))
@@ -386,7 +386,9 @@ class DIDWallet:
             p2_puzzle, recovery_list_hash, num_verification, singleton_struct, metadata = did_curried_args
             did_data = DIDCoinData(
                 p2_puzzle=p2_puzzle,
-                recovery_list_hash=bytes32(recovery_list_hash.as_atom()),
+                recovery_list_hash=bytes32(recovery_list_hash.as_atom())
+                if recovery_list_hash != Program.to(None)
+                else None,
                 num_verification=uint16(num_verification.as_int()),
                 singleton_struct=singleton_struct,
                 metadata=metadata,
@@ -415,8 +417,10 @@ class DIDWallet:
         if not self._coin_is_first_singleton(coin):
             full_puzzle = create_singleton_puzzle(inner_puzzle, self.did_info.origin_coin.name())
             assert full_puzzle.get_tree_hash() == coin.puzzle_hash
+
         if self.did_info.temp_coin is not None:
             self.wallet_state_manager.state_changed("did_coin_added", self.wallet_info.id)
+
         new_info = DIDInfo(
             origin_coin=self.did_info.origin_coin,
             backup_ids=self.did_info.backup_ids,
@@ -467,63 +471,67 @@ class DIDWallet:
         # full_puz = did_wallet_puzzles.create_fullpuz(innerpuz, origin.name())
         # All additions in this block here:
 
-        new_puzhash = await self.wallet_state_manager.main_wallet.get_puzzle_hash(new=False)
-        new_pubkey = await self.wallet_state_manager.get_public_key(new_puzhash)
-        parent_info = None
-        assert did_info.origin_coin is not None
-        assert did_info.current_inner is not None
-        new_did_inner_puzhash = did_wallet_puzzles.get_inner_puzhash_by_p2(
-            p2_puzhash=new_puzhash,
-            recovery_list=did_info.backup_ids,
-            num_of_backup_ids_needed=did_info.num_of_backup_ids_needed,
-            launcher_id=did_info.origin_coin.name(),
-            metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
-        )
-        wallet_node = self.wallet_state_manager.wallet_node
-        parent_coin: Coin = did_info.origin_coin
-        while True:
-            peer = wallet_node.get_full_node_peer()
-            children = await wallet_node.fetch_children(parent_coin.name(), peer)
-            if len(children) == 0:
-                break
-
-            children_state: CoinState = children[0]
-            child_coin = children_state.coin
+        async with self.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            new_puzhash = await action_scope.get_puzzle_hash(
+                self.wallet_state_manager, override_reuse_puzhash_with=True
+            )
+            new_pubkey = await self.wallet_state_manager.get_public_key(new_puzhash)
+            parent_info = None
+            assert did_info.origin_coin is not None
             assert did_info.current_inner is not None
-            future_parent = LineageProof(
-                parent_name=child_coin.parent_coin_info,
-                inner_puzzle_hash=did_info.current_inner.get_tree_hash(),
-                amount=uint64(child_coin.amount),
+            new_did_inner_puzhash = did_wallet_puzzles.get_inner_puzhash_by_p2(
+                p2_puzhash=new_puzhash,
+                recovery_list=did_info.backup_ids,
+                num_of_backup_ids_needed=did_info.num_of_backup_ids_needed,
+                launcher_id=did_info.origin_coin.name(),
+                metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
+                recovery_list_hash=self.reset_recovery_list(),
             )
-            await self.add_parent(child_coin.name(), future_parent)
-            if children_state.spent_height != children_state.created_height:
-                did_info = DIDInfo(
-                    origin_coin=did_info.origin_coin,
-                    backup_ids=did_info.backup_ids,
-                    num_of_backup_ids_needed=did_info.num_of_backup_ids_needed,
-                    parent_info=self.did_info.parent_info,
-                    current_inner=did_info.current_inner,
-                    temp_coin=child_coin,
-                    temp_puzhash=new_did_inner_puzhash,
-                    temp_pubkey=bytes(new_pubkey),
-                    sent_recovery_transaction=did_info.sent_recovery_transaction,
-                    metadata=did_info.metadata,
-                )
+            wallet_node = self.wallet_state_manager.wallet_node
+            parent_coin: Coin = did_info.origin_coin
+            while True:
+                peer = wallet_node.get_full_node_peer()
+                children = await wallet_node.fetch_children(parent_coin.name(), peer)
+                if len(children) == 0:
+                    break
 
-                await self.save_info(did_info)
-                assert children_state.created_height
-                parent_spend = await fetch_coin_spend(uint32(children_state.created_height), parent_coin, peer)
-                assert parent_spend is not None
-                parent_innerpuz = get_inner_puzzle_from_singleton(parent_spend.puzzle_reveal)
-                assert parent_innerpuz is not None
-                parent_info = LineageProof(
-                    parent_name=parent_coin.parent_coin_info,
-                    inner_puzzle_hash=parent_innerpuz.get_tree_hash(),
-                    amount=uint64(parent_coin.amount),
+                children_state: CoinState = children[0]
+                child_coin = children_state.coin
+                assert did_info.current_inner is not None
+                future_parent = LineageProof(
+                    parent_name=child_coin.parent_coin_info,
+                    inner_puzzle_hash=did_info.current_inner.get_tree_hash(),
+                    amount=uint64(child_coin.amount),
                 )
-                await self.add_parent(child_coin.parent_coin_info, parent_info)
-            parent_coin = child_coin
-        assert parent_info is not None
+                await self.add_parent(child_coin.name(), future_parent)
+                if children_state.spent_height != children_state.created_height:
+                    did_info = DIDInfo(
+                        origin_coin=did_info.origin_coin,
+                        backup_ids=did_info.backup_ids,
+                        num_of_backup_ids_needed=did_info.num_of_backup_ids_needed,
+                        parent_info=self.did_info.parent_info,
+                        current_inner=did_info.current_inner,
+                        temp_coin=child_coin,
+                        temp_puzhash=new_did_inner_puzhash,
+                        temp_pubkey=bytes(new_pubkey),
+                        sent_recovery_transaction=did_info.sent_recovery_transaction,
+                        metadata=did_info.metadata,
+                    )
+
+                    await self.save_info(did_info)
+                    assert children_state.created_height
+                    parent_spend = await fetch_coin_spend(uint32(children_state.created_height), parent_coin, peer)
+                    assert parent_spend is not None
+                    parent_innerpuz = get_inner_puzzle_from_singleton(parent_spend.puzzle_reveal)
+                    assert parent_innerpuz is not None
+                    parent_info = LineageProof(
+                        parent_name=parent_coin.parent_coin_info,
+                        inner_puzzle_hash=parent_innerpuz.get_tree_hash(),
+                        amount=uint64(parent_coin.amount),
+                    )
+                    await self.add_parent(child_coin.parent_coin_info, parent_info)
+                parent_coin = child_coin
+            assert parent_info is not None
 
     def puzzle_for_pk(self, pubkey: G1Element) -> Program:
         if self.did_info.origin_coin is not None:
@@ -533,6 +541,7 @@ class DIDWallet:
                 num_of_backup_ids_needed=self.did_info.num_of_backup_ids_needed,
                 launcher_id=self.did_info.origin_coin.name(),
                 metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
+                recovery_list_hash=self.reset_recovery_list(),
             )
             return create_singleton_puzzle(innerpuz, self.did_info.origin_coin.name())
         else:
@@ -552,6 +561,7 @@ class DIDWallet:
             num_of_backup_ids_needed=self.did_info.num_of_backup_ids_needed,
             launcher_id=origin_coin_name,
             metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
+            recovery_list_hash=self.reset_recovery_list(),
         )
         return create_singleton_puzzle_hash(innerpuz_hash, origin_coin_name)
 
@@ -566,7 +576,7 @@ class DIDWallet:
         self.wallet_info = new_info
         await self.wallet_state_manager.user_store.update_wallet(self.wallet_info)
 
-    def get_name(self):
+    def get_name(self) -> str:
         return self.wallet_info.name
 
     async def create_update_spend(
@@ -578,7 +588,7 @@ class DIDWallet:
         assert self.did_info.current_inner is not None
         assert self.did_info.origin_coin is not None
         coin = await self.get_coin()
-        new_inner_puzzle = await self.get_did_innerpuz(new=not action_scope.config.tx_config.reuse_puzhash)
+        new_inner_puzzle = await self.get_did_innerpuz(action_scope)
         uncurried = did_wallet_puzzles.uncurry_innerpuz(new_inner_puzzle)
         assert uncurried is not None
         p2_puzzle = uncurried[0]
@@ -646,7 +656,9 @@ class DIDWallet:
         did_record = TransactionRecord(
             confirmed_at_height=uint32(0),
             created_at_time=uint64(int(time.time())),
-            to_puzzle_hash=await self.standard_wallet.get_puzzle_hash(False),
+            to_puzzle_hash=await action_scope.get_puzzle_hash(
+                self.wallet_state_manager, override_reuse_puzhash_with=True
+            ),
             amount=uint64(coin.amount),
             fee_amount=uint64(0),
             confirmed=False,
@@ -695,6 +707,7 @@ class DIDWallet:
             num_of_backup_ids_needed=backup_required,
             launcher_id=self.did_info.origin_coin.name(),
             metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
+            recovery_list_hash=self.reset_recovery_list(),
         )
         p2_solution = self.standard_wallet.make_solution(
             primaries=[CreateCoin(new_did_puzhash, uint64(coin.amount), [new_puzhash])],
@@ -737,7 +750,9 @@ class DIDWallet:
         did_record = TransactionRecord(
             confirmed_at_height=uint32(0),
             created_at_time=uint64(int(time.time())),
-            to_puzzle_hash=await self.standard_wallet.get_puzzle_hash(False),
+            to_puzzle_hash=await action_scope.get_puzzle_hash(
+                self.wallet_state_manager, override_reuse_puzhash_with=True
+            ),
             amount=uint64(coin.amount),
             fee_amount=fee,
             confirmed=False,
@@ -776,20 +791,16 @@ class DIDWallet:
         )
         uncurried = did_wallet_puzzles.uncurry_innerpuz(innerpuz)
         assert uncurried is not None
-        p2_puzzle, id_list_hash, num_of_backup_ids_needed, _, metadata = uncurried
+        _p2_puzzle, id_list_hash, num_of_backup_ids_needed, _, metadata = uncurried
         # Quote message puzzle & solution
-        if action_scope.config.tx_config.reuse_puzhash:
-            new_innerpuzzle_hash = innerpuz.get_tree_hash()
-            p2_ph = p2_puzzle.get_tree_hash()
-        else:
-            p2_ph = await self.standard_wallet.get_puzzle_hash(new=True)
-            new_innerpuzzle_hash = did_wallet_puzzles.get_inner_puzhash_by_p2(
-                p2_puzhash=p2_ph,
-                recovery_list_hash=bytes32(id_list_hash.as_atom()),
-                num_of_backup_ids_needed=uint64(num_of_backup_ids_needed.as_int()),
-                launcher_id=self.did_info.origin_coin.name(),
-                metadata=metadata,
-            )
+        p2_ph = await action_scope.get_puzzle_hash(self.wallet_state_manager)
+        new_innerpuzzle_hash = did_wallet_puzzles.get_inner_puzhash_by_p2(
+            p2_puzhash=p2_ph,
+            recovery_list_hash=id_list_hash,
+            num_of_backup_ids_needed=uint64(num_of_backup_ids_needed.as_int()),
+            launcher_id=self.did_info.origin_coin.name(),
+            metadata=metadata,
+        )
         p2_solution = self.standard_wallet.make_solution(
             primaries=[CreateCoin(puzzle_hash=new_innerpuzzle_hash, amount=uint64(coin.amount), memos=[p2_ph])],
             conditions=extra_conditions,
@@ -876,7 +887,9 @@ class DIDWallet:
                 TransactionRecord(
                     confirmed_at_height=uint32(0),
                     created_at_time=uint64(int(time.time())),
-                    to_puzzle_hash=await self.standard_wallet.get_puzzle_hash(False),
+                    to_puzzle_hash=await action_scope.get_puzzle_hash(
+                        self.wallet_state_manager, override_reuse_puzhash_with=True
+                    ),
                     amount=uint64(coin.amount),
                     fee_amount=uint64(0),
                     confirmed=False,
@@ -959,7 +972,9 @@ class DIDWallet:
         did_record = TransactionRecord(
             confirmed_at_height=uint32(0),
             created_at_time=uint64(int(time.time())),
-            to_puzzle_hash=await self.standard_wallet.get_puzzle_hash(False),
+            to_puzzle_hash=await action_scope.get_puzzle_hash(
+                self.wallet_state_manager, override_reuse_puzhash_with=True
+            ),
             amount=uint64(coin.amount),
             fee_amount=uint64(0),
             confirmed=False,
@@ -1076,7 +1091,9 @@ class DIDWallet:
                 TransactionRecord(
                     confirmed_at_height=uint32(0),
                     created_at_time=uint64(int(time.time())),
-                    to_puzzle_hash=await self.standard_wallet.get_puzzle_hash(False),
+                    to_puzzle_hash=await action_scope.get_puzzle_hash(
+                        self.wallet_state_manager, override_reuse_puzhash_with=True
+                    ),
                     amount=uint64(coin.amount),
                     fee_amount=uint64(0),
                     confirmed=False,
@@ -1107,31 +1124,30 @@ class DIDWallet:
         )
         await self.save_info(new_did_info)
 
-    async def get_p2_inner_hash(self, new: bool) -> bytes32:
-        return await self.standard_wallet.get_puzzle_hash(new=new)
-
-    async def get_p2_inner_puzzle(self, new: bool) -> Program:
-        return await self.standard_wallet.get_puzzle(new=new)
-
-    async def get_did_innerpuz(self, new: bool, origin_id: Optional[bytes32] = None) -> Program:
+    async def get_did_innerpuz(
+        self,
+        action_scope: WalletActionScope,
+        origin_id: Optional[bytes32] = None,
+        override_reuse_puzhash_with: Optional[bool] = None,
+    ) -> Program:
         if self.did_info.origin_coin is not None:
             launcher_id = self.did_info.origin_coin.name()
         elif origin_id is not None:
             launcher_id = origin_id
         else:
             raise ValueError("must have origin coin")
+
         return did_wallet_puzzles.create_innerpuz(
-            p2_puzzle_or_hash=await self.get_p2_inner_puzzle(new=new),
+            p2_puzzle_or_hash=await action_scope.get_puzzle(
+                self.wallet_state_manager, override_reuse_puzhash_with=override_reuse_puzhash_with
+            ),
             recovery_list=self.did_info.backup_ids,
             num_of_backup_ids_needed=self.did_info.num_of_backup_ids_needed,
             launcher_id=launcher_id,
             metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
+            recovery_list_hash=self.reset_recovery_list(),
         )
 
-    async def get_did_inner_hash(self, new: bool) -> bytes32:
-        innerpuz = await self.get_did_innerpuz(new=new)
-        return innerpuz.get_tree_hash()
-
     async def get_innerpuz_for_new_innerhash(self, pubkey: G1Element):
         """
         Get the inner puzzle for a new owner
@@ -1147,6 +1163,7 @@ class DIDWallet:
             num_of_backup_ids_needed=uint64(self.did_info.num_of_backup_ids_needed),
             launcher_id=self.did_info.origin_coin.name(),
             metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
+            recovery_list_hash=self.reset_recovery_list(),
         )
 
     async def inner_puzzle_for_did_puzzle(self, did_hash: bytes32) -> Program:
@@ -1157,15 +1174,11 @@ class DIDWallet:
         assert self.did_info.current_inner is not None
         uncurried_args = uncurry_innerpuz(self.did_info.current_inner)
         assert uncurried_args is not None
-        old_recovery_list_hash: Optional[Program] = None
-        p2_puzzle, old_recovery_list_hash, _, _, _ = uncurried_args
+        p2_puzzle, _, _, _, _ = uncurried_args
         if record is None:
             record = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
                 p2_puzzle.get_tree_hash()
             )
-        if not (self.did_info.num_of_backup_ids_needed > 0 and len(self.did_info.backup_ids) == 0):
-            # We have the recovery list, don't reset it
-            old_recovery_list_hash = None
 
         inner_puzzle: Program = did_wallet_puzzles.create_innerpuz(
             p2_puzzle_or_hash=puzzle_for_pk(record.pubkey),
@@ -1173,10 +1186,27 @@ class DIDWallet:
             num_of_backup_ids_needed=self.did_info.num_of_backup_ids_needed,
             launcher_id=self.did_info.origin_coin.name(),
             metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
-            recovery_list_hash=old_recovery_list_hash,
+            recovery_list_hash=self.reset_recovery_list(),
         )
         return inner_puzzle
 
+    def reset_recovery_list(self) -> Optional[Program]:
+        if self.did_info.current_inner is None:
+            return None
+
+        uncurried_args = uncurry_innerpuz(self.did_info.current_inner)
+        if uncurried_args is None:
+            return None
+
+        _, og_recovery_list_hash, _, _, _ = uncurried_args
+        if self.did_info.num_of_backup_ids_needed == 0 and not did_recovery_is_nil(og_recovery_list_hash):
+            return None
+
+        if len(self.did_info.backup_ids) > 0:
+            return None
+
+        return og_recovery_list_hash
+
     def get_parent_for_coin(self, coin) -> Optional[LineageProof]:
         parent_info = None
         for name, ccparent in self.did_info.parent_info:
@@ -1224,9 +1254,7 @@ class DIDWallet:
         genesis_launcher_puz = SINGLETON_LAUNCHER_PUZZLE
         launcher_coin = Coin(origin.name(), genesis_launcher_puz.get_tree_hash(), amount)
 
-        did_inner: Program = await self.get_did_innerpuz(
-            new=not action_scope.config.tx_config.reuse_puzhash, origin_id=launcher_coin.name()
-        )
+        did_inner: Program = await self.get_did_innerpuz(action_scope, origin_id=launcher_coin.name())
         did_inner_hash = did_inner.get_tree_hash()
         did_full_puz = create_singleton_puzzle(did_inner, launcher_coin.name())
         did_puzzle_hash = did_full_puz.get_tree_hash()
@@ -1287,7 +1315,9 @@ class DIDWallet:
             confirmed_at_height=uint32(0),
             created_at_time=uint64(int(time.time())),
             amount=uint64(amount),
-            to_puzzle_hash=await self.standard_wallet.get_puzzle_hash(False),
+            to_puzzle_hash=await action_scope.get_puzzle_hash(
+                self.wallet_state_manager, override_reuse_puzhash_with=True
+            ),
             fee_amount=fee,
             confirmed=False,
             sent=uint32(0),
@@ -1496,6 +1526,7 @@ class DIDWallet:
                     num_of_backup_ids_needed=uint64(self.did_info.num_of_backup_ids_needed),
                     launcher_id=self.did_info.origin_coin.name(),
                     metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
+                    recovery_list_hash=self.reset_recovery_list(),
                 ),
                 self.did_info.origin_coin.name(),
             ).get_tree_hash_precalc(hint)

chia/wallet/did_wallet/did_wallet_puzzles.py

@@ -4,13 +4,13 @@ from collections.abc import Iterator
 from typing import Optional, Union
 
 from chia_puzzles_py.programs import DID_INNERPUZ, DID_INNERPUZ_HASH, NFT_INTERMEDIATE_LAUNCHER
-from chia_rs import G1Element
+from chia_rs import CoinSpend, G1Element
 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, make_spend
+from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.wallet.singleton import (
     SINGLETON_LAUNCHER_PUZZLE_HASH,
@@ -70,7 +70,7 @@ def get_inner_puzhash_by_p2(
     launcher_id: bytes32,
     metadata: Program = Program.to([]),
     recovery_list: Optional[list[bytes32]] = None,
-    recovery_list_hash: Optional[bytes32] = None,
+    recovery_list_hash: Optional[Program] = None,
 ) -> bytes32:
     """
     Calculate DID inner puzzle hash based on a P2 puzzle hash
@@ -84,14 +84,14 @@ def get_inner_puzhash_by_p2(
 
     if recovery_list is None and recovery_list_hash is None:
         raise ValueError("Cannot construct DID inner puzzle without information about recovery list")
-    if recovery_list is not None and recovery_list_hash is not None:
-        raise ValueError("Must only specify recovery information a single way to construct DID inner puzzle")
 
-    if recovery_list is not None:
+    # Allow both recovery_list and recovery_list_hash to be provided but
+    # in that case the list is ignored and the hash is used
+    # this matches the behaviour of create_innerpuz
+    if recovery_list_hash is not None:
+        backup_ids_hash = recovery_list_hash.as_atom()
+    elif recovery_list is not None:
         backup_ids_hash = shatree_atom_list(recovery_list)
-    else:
-        assert recovery_list_hash is not None
-        backup_ids_hash = recovery_list_hash
 
     # singleton_struct = (MOD_HASH . (LAUNCHER_ID . LAUNCHER_PUZZLE_HASH))
     singleton_struct = shatree_pair(

chia/wallet/driver_protocol.py

@@ -13,7 +13,9 @@ from chia.wallet.uncurried_puzzle import UncurriedPuzzle
 class DriverProtocol(Protocol):
     def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]: ...
 
-    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] = ...
+    ) -> Optional[Program]: ...
 
     def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]: ...
 

chia/{types/spend_bundle.py → wallet/estimate_fees.py}

@@ -1,15 +1,10 @@
 from __future__ import annotations
 
-from typing import TypeVar
-
-import chia_rs
+from chia_rs import SpendBundle
 
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.types.coin_spend import compute_additions_with_cost
 from chia.util.errors import Err, ValidationError
-
-SpendBundle = chia_rs.SpendBundle
-T_SpendBundle = TypeVar("T_SpendBundle", bound="SpendBundle")
+from chia.wallet.util.compute_additions import compute_additions_with_cost
 
 
 # This function executes all the puzzles to compute the difference between

chia/wallet/nft_wallet/metadata_outer_puzzle.py

@@ -33,7 +33,7 @@ class MetadataOuterPuzzle:
     _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]:
@@ -62,13 +62,15 @@ class MetadataOuterPuzzle:
             inner_puzzle = self._construct(also, inner_puzzle)
         return puzzle_for_metadata_layer(constructor["metadata"], constructor["updater_hash"], inner_puzzle)
 
-    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]:
         matched, curried_args = match_metadata_layer_puzzle(puzzle_reveal)
         if matched:
             _, _, _, inner_puzzle = curried_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), None)
                 return deep_inner_puzzle
             else:
                 return inner_puzzle

chia/wallet/nft_wallet/nft_puzzle_utils.py

@@ -228,7 +228,7 @@ def create_ownership_layer_transfer_solution(
 
 
 def get_metadata_and_phs(unft: UncurriedNFT, solution: SerializedProgram) -> tuple[Program, bytes32]:
-    conditions = unft.p2_puzzle.run(unft.get_innermost_solution(solution.to_program()))
+    conditions = unft.p2_puzzle.run(unft.get_innermost_solution(Program.from_serialized(solution)))
     metadata = unft.metadata
     puzhash_for_derivation: Optional[bytes32] = None
     for condition in conditions.as_iter():