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

chia/wallet/vc_wallet/cr_cat_drivers.py

@@ -4,7 +4,7 @@ import functools
 from collections.abc import Iterable
 from dataclasses import dataclass, replace
 from enum import IntEnum
-from typing import Optional, TypeVar
+from typing import Optional
 
 from chia_puzzles_py.programs import (
     CONDITIONS_W_FEE_ANNOUNCE,
@@ -16,13 +16,15 @@ from chia_puzzles_py.programs import (
 from chia_puzzles_py.programs import (
     CREDENTIAL_RESTRICTION_HASH as CREDENTIAL_RESTRICTION_HASH_BYTES,
 )
+from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint64
-from clvm.casts import int_to_bytes
+from typing_extensions import Self
 
 from chia.types.blockchain_format.coin import Coin, coin_as_list
 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.util.casts import int_to_bytes
 from chia.util.hash import std_hash
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.cat_wallet.cat_utils import CAT_MOD, construct_cat_puzzle
@@ -165,9 +167,6 @@ def construct_pending_approval_state(puzzle_hash: bytes32, amount: uint64) -> Pr
     return PENDING_VC_ANNOUNCEMENT.curry(Program.to([[51, puzzle_hash, amount, [puzzle_hash]]]))
 
 
-_T_CRCAT = TypeVar("_T_CRCAT", bound="CRCAT")
-
-
 @dataclass(frozen=True)
 class CRCAT:
     coin: Coin
@@ -179,7 +178,7 @@ class CRCAT:
 
     @classmethod
     def launch(
-        cls: type[_T_CRCAT],
+        cls,
         # General CAT launching info
         origin_coin: Coin,
         payment: CreateCoin,
@@ -307,12 +306,12 @@ class CRCAT:
         return solution.at("f").at("rrrrrrf")
 
     @classmethod
-    def get_current_from_coin_spend(cls: type[_T_CRCAT], spend: CoinSpend) -> CRCAT:  # pragma: no cover
+    def get_current_from_coin_spend(cls, spend: CoinSpend) -> CRCAT:  # pragma: no cover
         uncurried_puzzle: UncurriedPuzzle = uncurry_puzzle(spend.puzzle_reveal)
         first_uncurried_cr_layer: UncurriedPuzzle = uncurry_puzzle(uncurried_puzzle.args.at("rrf"))
         second_uncurried_cr_layer: UncurriedPuzzle = uncurry_puzzle(first_uncurried_cr_layer.mod)
         lineage_proof = LineageProof.from_program(
-            spend.solution.to_program().at("rf"),
+            Program.from_serialized(spend.solution).at("rf"),
             [LineageProofField.PARENT_NAME, LineageProofField.INNER_PUZZLE_HASH, LineageProofField.AMOUNT],
         )
         return CRCAT(
@@ -326,7 +325,7 @@ class CRCAT:
 
     @classmethod
     def get_next_from_coin_spend(
-        cls: type[_T_CRCAT],
+        cls,
         parent_spend: CoinSpend,
         conditions: Optional[Program] = None,  # For optimization purposes, the conditions may already have been run
     ) -> list[CRCAT]:
@@ -338,8 +337,8 @@ class CRCAT:
         as the spend output a remark condition that was (REMARK authorized_providers proofs_checker)
         """
         coin_name: bytes32 = parent_spend.coin.name()
-        puzzle: Program = parent_spend.puzzle_reveal.to_program()
-        solution: Program = parent_spend.solution.to_program()
+        puzzle = Program.from_serialized(parent_spend.puzzle_reveal)
+        solution = Program.from_serialized(parent_spend.solution)
 
         # Get info by uncurrying
         _, tail_hash_as_prog, potential_cr_layer = puzzle.uncurry()[1].as_iter()
@@ -515,8 +514,8 @@ class CRCAT:
 
     @classmethod
     def spend_many(
-        cls: type[_T_CRCAT],
-        inner_spends: list[tuple[_T_CRCAT, int, Program, Program]],  # CRCAT, extra_delta, inner puzzle, inner solution
+        cls,
+        inner_spends: list[tuple[Self, int, Program, Program]],  # CRCAT, extra_delta, inner puzzle, inner solution
         # CR layer solving info
         proof_of_inclusions: Program,
         proof_checker_solution: Program,
@@ -538,7 +537,7 @@ class CRCAT:
         def prev_index(index: int) -> int:
             return index - 1
 
-        sorted_inner_spends: list[tuple[_T_CRCAT, int, Program, Program]] = sorted(
+        sorted_inner_spends: list[tuple[Self, int, Program, Program]] = sorted(
             inner_spends,
             key=lambda spend: spend[0].coin.name(),
         )
@@ -609,16 +608,16 @@ class CRCATSpend:
     @classmethod
     def from_coin_spend(cls, spend: CoinSpend) -> CRCATSpend:  # pragma: no cover
         inner_puzzle: Program = CRCAT.get_inner_puzzle(uncurry_puzzle(spend.puzzle_reveal))
-        inner_solution: Program = CRCAT.get_inner_solution(spend.solution.to_program())
+        inner_solution: Program = CRCAT.get_inner_solution(Program.from_serialized(spend.solution))
         inner_conditions: Program = inner_puzzle.run(inner_solution)
         return cls(
             CRCAT.get_current_from_coin_spend(spend),
             inner_puzzle,
             inner_solution,
             CRCAT.get_next_from_coin_spend(spend, conditions=inner_conditions),
-            spend.solution.to_program().at("f").at("rrrrf") == Program.to(None),
+            Program.from_serialized(spend.solution).at("f").at("rrrrf") == Program.to(None),
             list(inner_conditions.as_iter()),
-            spend.solution.to_program().at("f").at("f"),
+            Program.from_serialized(spend.solution).at("f").at("f"),
         )
 
 

chia/wallet/vc_wallet/cr_cat_wallet.py

@@ -3,17 +3,16 @@ from __future__ import annotations
 import logging
 import time
 import traceback
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, ClassVar, Optional
 
-from chia_rs import G1Element, G2Element
+from chia_rs import CoinSpend, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
-from typing_extensions import Unpack
+from typing_extensions import Self, Unpack
 
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin, coin_as_list
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_spend import CoinSpend
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.hash import std_hash
 from chia.util.streamable import VersionedBlob
@@ -69,6 +68,8 @@ class CRCATWallet(CATWallet):
     wallet_info: WalletInfo
     info: CRCATInfo
     standard_wallet: Wallet
+    wallet_type: ClassVar[WalletType] = WalletType.CRCAT
+    wallet_info_type: ClassVar[type[CRCATInfo]] = CRCATInfo
 
     @staticmethod
     def default_wallet_name_for_unknown_cat(limitations_program_hash_hex: str) -> str:
@@ -91,18 +92,19 @@ class CRCATWallet(CATWallet):
     ) -> CATWallet:  # pragma: no cover
         raise NotImplementedError("create_new_cat_wallet is a legacy method and is not available on CR-CAT wallets")
 
-    @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,
         authorized_providers: Optional[list[bytes32]] = None,
         proofs_checker: Optional[ProofsChecker] = None,
-    ) -> CRCATWallet:
+    ) -> Self:
         if authorized_providers is None or proofs_checker is None:  # pragma: no cover
             raise ValueError("get_or_create_wallet_for_cat was call on CRCATWallet without proper arguments")
-        self = CRCATWallet()
+        self = cls()
         self.standard_wallet = wallet
         if name is None:
             name = self.default_wallet_name_for_unknown_cat(limitations_program_hash_hex)
@@ -111,15 +113,15 @@ class CRCATWallet(CATWallet):
         tail_hash = bytes32.from_hexstr(limitations_program_hash_hex)
 
         for id, w in wallet_state_manager.wallets.items():
-            if w.type() == CRCATWallet.type():
-                assert isinstance(w, CRCATWallet)
+            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 CR-CAT wallet")
                     return w
 
         self.wallet_state_manager = wallet_state_manager
 
-        self.info = CRCATInfo(tail_hash, None, authorized_providers, proofs_checker)
+        self.info = cls.wallet_info_type(tail_hash, None, authorized_providers, proofs_checker)
         info_as_string = bytes(self.info).hex()
         self.wallet_info = await wallet_state_manager.user_store.create_wallet(name, WalletType.CRCAT, info_as_string)
 
@@ -160,7 +162,7 @@ class CRCATWallet(CATWallet):
         self.wallet_state_manager = wallet_state_manager
         self.wallet_info = wallet_info
         self.standard_wallet = wallet
-        self.info = CRCATInfo.from_bytes(hexstr_to_bytes(self.wallet_info.data))
+        self.info = self.wallet_info_type.from_bytes(hexstr_to_bytes(self.wallet_info.data))
         return self
 
     @classmethod
@@ -175,7 +177,7 @@ class CRCATWallet(CATWallet):
         replace_self.log = logging.getLogger(cat_wallet.get_name())
         replace_self.log.info(f"Converting CAT wallet {cat_wallet.id()} to CR-CAT wallet")
         replace_self.wallet_state_manager = cat_wallet.wallet_state_manager
-        replace_self.info = CRCATInfo(
+        replace_self.info = cls.wallet_info_type(
             cat_wallet.cat_info.limitations_program_hash, None, authorized_providers, proofs_checker
         )
         await cat_wallet.wallet_state_manager.user_store.update_wallet(
@@ -197,7 +199,7 @@ class CRCATWallet(CATWallet):
         return self.wallet_info.id
 
     def get_asset_id(self) -> str:
-        return self.info.limitations_program_hash.hex()
+        return bytes(self.info.limitations_program_hash).hex()
 
     async def set_tail_program(self, tail_program: str) -> None:  # pragma: no cover
         raise NotImplementedError("set_tail_program is a legacy method and is not available on CR-CAT wallets")
@@ -449,19 +451,18 @@ class CRCATWallet(CATWallet):
             if origin_crcat_record is None:
                 raise RuntimeError("A CR-CAT coin was selected that we don't have a record for")  # pragma: no cover
             origin_crcat = self.coin_record_to_crcat(origin_crcat_record)
-            if action_scope.config.tx_config.override(
-                reuse_puzhash=(
-                    True if not add_authorizations_to_cr_cats else action_scope.config.tx_config.reuse_puzhash
-                )
-            ).reuse_puzhash:
-                change_puzhash = origin_crcat.inner_puzzle_hash
-                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)
-                        break
+
+            if add_authorizations_to_cr_cats:
+                change_puzhash = await action_scope.get_puzzle_hash(self.wallet_state_manager)
             else:
-                change_puzhash = await self.standard_wallet.get_puzzle_hash(new=True)
+                change_puzhash = origin_crcat.inner_puzzle_hash
+            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 action_scope.get_puzzle_hash(
+                        self.wallet_state_manager, override_reuse_puzhash_with=False
+                    )
+                    break
             primaries.append(CreateCoin(change_puzhash, uint64(change), [change_puzhash]))
 
         # Find the VC Wallet
@@ -586,7 +587,7 @@ class CRCATWallet(CATWallet):
         if add_authorizations_to_cr_cats:
             await vc_wallet.generate_signed_transaction(
                 [uint64(1)],
-                [await self.standard_wallet.get_puzzle_hash(new=not action_scope.config.tx_config.reuse_puzhash)],
+                [await action_scope.get_puzzle_hash(self.wallet_state_manager)],
                 action_scope,
                 vc_id=vc.launcher_id,
                 extra_conditions=(
@@ -769,7 +770,7 @@ class CRCATWallet(CATWallet):
         # Make the VC TX
         await vc_wallet.generate_signed_transaction(
             [uint64(1)],
-            [await self.standard_wallet.get_puzzle_hash(new=not action_scope.config.tx_config.reuse_puzhash)],
+            [await action_scope.get_puzzle_hash(self.wallet_state_manager)],
             action_scope,
             vc_id=vc.launcher_id,
             extra_conditions=(
@@ -780,6 +781,7 @@ class CRCATWallet(CATWallet):
             ),
         )
 
+        to_puzzle_hash = await action_scope.get_puzzle_hash(self.wallet_state_manager, override_reuse_puzhash_with=True)
         async with action_scope.use() as interface:
             other_additions: set[Coin] = {rem for tx in interface.side_effects.transactions for rem in tx.additions}
             other_removals: set[Coin] = {rem for tx in interface.side_effects.transactions for rem in tx.removals}
@@ -787,7 +789,7 @@ class CRCATWallet(CATWallet):
                 TransactionRecord(
                     confirmed_at_height=uint32(0),
                     created_at_time=uint64(int(time.time())),
-                    to_puzzle_hash=await self.wallet_state_manager.main_wallet.get_puzzle_hash(False),
+                    to_puzzle_hash=to_puzzle_hash,
                     amount=uint64(sum(c.amount for c in coins)),
                     fee_amount=fee,
                     confirmed=False,

chia/wallet/vc_wallet/cr_outer_puzzle.py

@@ -19,7 +19,7 @@ class CROuterPuzzle:
     _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]:
@@ -37,14 +37,16 @@ class CROuterPuzzle:
             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: Optional[tuple[list[bytes32], Program, Program]] = match_cr_layer(puzzle_reveal)
         if args is None:
             raise ValueError("This driver is not for the specified puzzle reveal")  # pragma: no cover
         _, _, 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), None)
             return deep_inner_puzzle
         else:
             return inner_puzzle

chia/wallet/vc_wallet/vc_drivers.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, replace
-from typing import Optional, TypeVar
+from typing import Any, Optional
 
 from chia_puzzles_py.programs import ACS_TRANSFER_PROGRAM as ACS_TRANSFER_PROGRAM_BYTES
 from chia_puzzles_py.programs import COVENANT_LAYER as COVENANT_LAYER_BYTES
@@ -20,16 +20,19 @@ from chia_puzzles_py.programs import REVOCATION_LAYER_HASH as REVOCATION_LAYER_H
 from chia_puzzles_py.programs import STANDARD_VC_REVOCATION_PUZZLE as STANDARD_VC_REVOCATION_PUZZLE_BYTES
 from chia_puzzles_py.programs import STD_PARENT_MORPHER as STD_PARENT_MORPHER_BYTES
 from chia_puzzles_py.programs import STD_PARENT_MORPHER_HASH as STD_PARENT_MORPHER_HASH_BYTES
+from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
+from typing_extensions import Self
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_spend import CoinSpend, compute_additions, make_spend
+from chia.types.coin_spend import make_spend
 from chia.util.hash import std_hash
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.conditions import Condition, CreatePuzzleAnnouncement
 from chia.wallet.lineage_proof import LineageProof
+from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
 from chia.wallet.puzzles.singleton_top_layer_v1_1 import (
     SINGLETON_LAUNCHER,
     SINGLETON_LAUNCHER_HASH,
@@ -40,6 +43,7 @@ from chia.wallet.puzzles.singleton_top_layer_v1_1 import (
     solution_for_singleton,
 )
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
+from chia.wallet.util.compute_additions import compute_additions
 
 # Mods
 EXTIGENT_METADATA_LAYER = Program.from_bytes(EXIGENT_METADATA_LAYER_BYTES)
@@ -288,7 +292,6 @@ OWNERSHIP_LAYER_LAUNCHER_HASH = OWNERSHIP_LAYER_LAUNCHER.get_tree_hash()
 ########################
 # Verified Credentials #
 ########################
-_T_VerifiedCredential = TypeVar("_T_VerifiedCredential", bound="VerifiedCredential")
 
 
 @streamable
@@ -310,14 +313,14 @@ class VerifiedCredential(Streamable):
 
     @classmethod
     def launch(
-        cls: type[_T_VerifiedCredential],
+        cls,
         origin_coins: list[Coin],
         provider_id: bytes32,
         new_inner_puzzle_hash: bytes32,
         memos: list[bytes32],
         fee: uint64 = uint64(0),
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> tuple[list[Program], list[CoinSpend], _T_VerifiedCredential]:
+    ) -> tuple[list[Program], list[CoinSpend], Self]:
         """
         Launch a VC.
 
@@ -537,7 +540,7 @@ class VerifiedCredential(Streamable):
         return True, ""
 
     @classmethod
-    def get_next_from_coin_spend(cls: type[_T_VerifiedCredential], parent_spend: CoinSpend) -> _T_VerifiedCredential:
+    def get_next_from_coin_spend(cls, parent_spend: CoinSpend) -> Self:
         """
         Given a coin spend, this will return the next VC that was create as an output of that spend. This is the main
         method to use when syncing. If a spend has been identified as having a VC puzzle reveal, running this method
@@ -548,7 +551,7 @@ class VerifiedCredential(Streamable):
 
         # BEGIN CODE
         parent_coin: Coin = parent_spend.coin
-        solution: Program = parent_spend.solution.to_program()
+        solution = Program.from_serialized(parent_spend.solution)
 
         singleton: UncurriedPuzzle = uncurry_puzzle(parent_spend.puzzle_reveal)
         launcher_id: bytes32 = bytes32(singleton.args.at("frf").as_atom())
@@ -606,7 +609,7 @@ class VerifiedCredential(Streamable):
                 parent_proof_hash=None if parent_proof_hash == Program.to(None) else parent_proof_hash,
             )
 
-        new_vc: _T_VerifiedCredential = cls(
+        new_vc: Self = cls(
             coin,
             singleton_lineage_proof,
             eml_lineage_proof,
@@ -818,3 +821,42 @@ class VerifiedCredential(Streamable):
                 slightly_incomplete_vc.coin.amount,
             ),
         )
+
+
+# This class is sort of unparadigmatic as an outer puzzle.
+# It lives somewhere between outer puzzle and inner puzzle, but the most convenient
+# way to present it in this wallet is as an outer puzzle.
+# This may lead to some peculiarities if use cases are to be expanded beyond simply using this
+# inside of a CAT.
+@dataclass(frozen=True)
+class RevocationOuterPuzzle:
+    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+        args = match_revocation_layer(puzzle)
+        if args is None:
+            return None
+        hidden_puzzle_hash, _ = args
+        constructor_dict: dict[str, Any] = {
+            "type": "revocation layer",
+            "hidden_puzzle_hash": "0x" + hidden_puzzle_hash.hex(),
+        }
+        return PuzzleInfo(constructor_dict)
+
+    def get_inner_puzzle(
+        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Optional[Program] = None
+    ) -> Optional[Program]:
+        if solution is None:
+            raise ValueError("Cannot get_inner_puzzle of revocation layer without solution")
+
+        return solution.at("rf")
+
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+        return solution.at("rrf")
+
+    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+        return bytes32(constructor["hidden_puzzle_hash"])
+
+    def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:
+        return create_revocation_layer(constructor["hidden_puzzle_hash"], inner_puzzle.get_tree_hash())
+
+    def solve(self, constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program) -> Program:
+        return solve_revocation_layer(inner_puzzle, inner_solution)  # deliberately no support for hidden puzzle spends

chia/wallet/vc_wallet/vc_store.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import dataclasses
 from functools import cmp_to_key
-from typing import Optional, TypeVar
+from typing import Optional
 
 from aiosqlite import Row
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
+from typing_extensions import Self
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -81,9 +82,6 @@ class VCProofs:
                 return new_tree
 
 
-_T_VCStore = TypeVar("_T_VCStore", bound="VCStore")
-
-
 @streamable
 @dataclasses.dataclass(frozen=True)
 class VCRecord(Streamable):
@@ -114,7 +112,7 @@ class VCStore:
     db_wrapper: DBWrapper2
 
     @classmethod
-    async def create(cls: type[_T_VCStore], db_wrapper: DBWrapper2) -> _T_VCStore:
+    async def create(cls, db_wrapper: DBWrapper2) -> Self:
         self = cls()
 
         self.db_wrapper = db_wrapper

chia/wallet/vc_wallet/vc_wallet.py

@@ -5,18 +5,17 @@ import time
 import traceback
 from typing import TYPE_CHECKING, Optional, TypeVar, Union
 
-from chia_rs import G1Element, G2Element
+from chia_rs import CoinSpend, CoinState, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64, uint128
-from clvm.casts import int_to_bytes
 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, coin_as_list
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.coin_spend import make_spend
+from chia.util.casts import int_to_bytes
 from chia.util.hash import std_hash
 from chia.util.streamable import Streamable
 from chia.wallet.conditions import (
@@ -187,9 +186,7 @@ class VCWallet:
         if len(coins) == 0:
             raise ValueError("Cannot find a coin to mint the verified credential.")  # pragma: no cover
         if inner_puzzle_hash is None:  # pragma: no cover
-            inner_puzzle_hash = await self.standard_wallet.get_puzzle_hash(
-                new=not action_scope.config.tx_config.reuse_puzhash
-            )
+            inner_puzzle_hash = await action_scope.get_puzzle_hash(self.wallet_state_manager)
         dpuzs, coin_spends, vc = VerifiedCredential.launch(
             coins,
             provider_did,
@@ -395,7 +392,7 @@ class VCWallet:
         else:
             await self.generate_signed_transaction(
                 [uint64(1)],
-                [await self.standard_wallet.get_puzzle_hash(new=not action_scope.config.tx_config.reuse_puzhash)],
+                [await action_scope.get_puzzle_hash(self.wallet_state_manager)],
                 action_scope,
                 fee,
                 vc_id=vc.launcher_id,
@@ -544,15 +541,15 @@ class VCWallet:
                     spend_to_fix: CoinSpend = spends_to_fix[crcat_spend.crcat.coin.name()]
                     other_spends.append(
                         spend_to_fix.replace(
-                            solution=SerializedProgram.from_program(
-                                spend_to_fix.solution.to_program().replace(
-                                    ff=coin_args[coin_name][0],
-                                    frf=Program.to(None),  # not general
-                                    frrf=bytes32.from_hexstr(coin_args[coin_name][2]),
-                                    frrrf=bytes32.from_hexstr(coin_args[coin_name][3]),
-                                    frrrrf=bytes32.from_hexstr(coin_args[coin_name][4]),
-                                )
-                            ),
+                            solution=Program.from_serialized(spend_to_fix.solution)
+                            .replace(
+                                ff=coin_args[coin_name][0],
+                                frf=Program.to(None),  # not general
+                                frrf=bytes32.from_hexstr(coin_args[coin_name][2]),
+                                frrrf=bytes32.from_hexstr(coin_args[coin_name][3]),
+                                frrrrf=bytes32.from_hexstr(coin_args[coin_name][4]),
+                            )
+                            .to_serialized(),
                         )
                     )
             else:
@@ -564,11 +561,7 @@ class VCWallet:
             for launcher_id, vc in vcs.items():
                 await self.generate_signed_transaction(
                     [uint64(1)],
-                    [
-                        await self.standard_wallet.get_puzzle_hash(
-                            new=not inner_action_scope.config.tx_config.reuse_puzhash
-                        )
-                    ],
+                    [await action_scope.get_puzzle_hash(self.wallet_state_manager)],
                     inner_action_scope,
                     vc_id=launcher_id,
                     extra_conditions=(