chia-blockchain 2.5.2rc2__py3-none-any.whl → 2.5.3__py3-none-any.whl

chia/wallet/vc_wallet/vc_drivers.py

@@ -3,16 +3,33 @@ from __future__ import annotations
 from dataclasses import dataclass, replace
 from typing import Optional, TypeVar
 
+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
+from chia_puzzles_py.programs import COVENANT_LAYER_HASH as COVENANT_LAYER_HASH_BYTES
+from chia_puzzles_py.programs import EML_COVENANT_MORPHER as EML_COVENANT_MORPHER_BYTES
+from chia_puzzles_py.programs import EML_COVENANT_MORPHER_HASH as EML_COVENANT_MORPHER_HASH_BYTES
+from chia_puzzles_py.programs import EML_TRANSFER_PROGRAM_COVENANT_ADAPTER as EML_TP_COVENANT_ADAPTER_BYTES
+from chia_puzzles_py.programs import EML_TRANSFER_PROGRAM_COVENANT_ADAPTER_HASH as EML_TP_COVENANT_ADAPTER_HASH_BYTES
+from chia_puzzles_py.programs import EML_UPDATE_METADATA_WITH_DID as EML_DID_TP_BYTES
+from chia_puzzles_py.programs import EXIGENT_METADATA_LAYER as EXIGENT_METADATA_LAYER_BYTES
+from chia_puzzles_py.programs import EXIGENT_METADATA_LAYER_HASH as EXIGENT_METADATA_LAYER_HASH_BYTES
+from chia_puzzles_py.programs import P2_ANNOUNCED_DELEGATED_PUZZLE as P2_ANNOUNCED_DELEGATED_PUZZLE_BYTES
+from chia_puzzles_py.programs import P2_ANNOUNCED_DELEGATED_PUZZLE_HASH as P2_ANNOUNCED_DELEGATED_PUZZLE_HASH_BYTES
+from chia_puzzles_py.programs import REVOCATION_LAYER as REVOCATION_LAYER_BYTES
+from chia_puzzles_py.programs import REVOCATION_LAYER_HASH as REVOCATION_LAYER_HASH_BYTES
+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.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.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_spend import CoinSpend, compute_additions, make_spend
 from chia.util.hash import std_hash
-from chia.util.ints import uint64
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.conditions import Condition, CreatePuzzleAnnouncement
 from chia.wallet.lineage_proof import LineageProof
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.puzzles.singleton_top_layer_v1_1 import (
     SINGLETON_LAUNCHER,
     SINGLETON_LAUNCHER_HASH,
@@ -25,67 +42,32 @@ from chia.wallet.puzzles.singleton_top_layer_v1_1 import (
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
 
 # Mods
-EXTIGENT_METADATA_LAYER = load_clvm_maybe_recompile(
-    "exigent_metadata_layer.clsp",
-    package_or_requirement="chia.wallet.vc_wallet.vc_puzzles",
-    include_standard_libraries=True,
-)
-P2_ANNOUNCED_DELEGATED_PUZZLE: Program = load_clvm_maybe_recompile(
-    "p2_announced_delegated_puzzle.clsp",
-    package_or_requirement="chia.wallet.vc_wallet.vc_puzzles",
-    include_standard_libraries=True,
-)
-COVENANT_LAYER: Program = load_clvm_maybe_recompile(
-    "covenant_layer.clsp", package_or_requirement="chia.wallet.vc_wallet.vc_puzzles", include_standard_libraries=True
-)
-STD_COVENANT_PARENT_MORPHER: Program = load_clvm_maybe_recompile(
-    "std_parent_morpher.clsp",
-    package_or_requirement="chia.wallet.vc_wallet.vc_puzzles",
-    include_standard_libraries=True,
-)
-EML_TP_COVENANT_ADAPTER: Program = load_clvm_maybe_recompile(
-    "eml_transfer_program_covenant_adapter.clsp",
-    package_or_requirement="chia.wallet.vc_wallet.vc_puzzles",
-    include_standard_libraries=True,
-)
-EML_DID_TP: Program = load_clvm_maybe_recompile(
-    "eml_update_metadata_with_DID.clsp",
-    package_or_requirement="chia.wallet.vc_wallet.vc_puzzles",
-    include_standard_libraries=True,
-)
-EXTIGENT_METADATA_LAYER_COVENANT_MORPHER: Program = load_clvm_maybe_recompile(
-    "eml_covenant_morpher.clsp",
-    package_or_requirement="chia.wallet.vc_wallet.vc_puzzles",
-    include_standard_libraries=True,
-)
-VIRAL_BACKDOOR: Program = load_clvm_maybe_recompile(
-    "viral_backdoor.clsp", package_or_requirement="chia.wallet.vc_wallet.vc_puzzles", include_standard_libraries=True
-)
-# (mod (METADATA conditions . solution) (if solution solution (list METADATA () ())))
-# (a (i 7 (q . 7) (q 4 2 (q () ()))) 1)
-ACS_TRANSFER_PROGRAM: Program = Program.to([2, [3, 7, (1, 7), [1, 4, 2, [1, None, None]]], 1])
-
+EXTIGENT_METADATA_LAYER = Program.from_bytes(EXIGENT_METADATA_LAYER_BYTES)
+P2_ANNOUNCED_DELEGATED_PUZZLE: Program = Program.from_bytes(P2_ANNOUNCED_DELEGATED_PUZZLE_BYTES)
+COVENANT_LAYER: Program = Program.from_bytes(COVENANT_LAYER_BYTES)
+STD_COVENANT_PARENT_MORPHER: Program = Program.from_bytes(STD_PARENT_MORPHER_BYTES)
+EML_TP_COVENANT_ADAPTER: Program = Program.from_bytes(EML_TP_COVENANT_ADAPTER_BYTES)
+EML_DID_TP: Program = Program.from_bytes(EML_DID_TP_BYTES)
+EXTIGENT_METADATA_LAYER_COVENANT_MORPHER: Program = Program.from_bytes(EML_COVENANT_MORPHER_BYTES)
+REVOCATION_LAYER: Program = Program.from_bytes(REVOCATION_LAYER_BYTES)
+ACS_TRANSFER_PROGRAM: Program = Program.from_bytes(ACS_TRANSFER_PROGRAM_BYTES)
 
 # Hashes
-EXTIGENT_METADATA_LAYER_HASH = EXTIGENT_METADATA_LAYER.get_tree_hash()
-P2_ANNOUNCED_DELEGATED_PUZZLE_HASH: bytes32 = P2_ANNOUNCED_DELEGATED_PUZZLE.get_tree_hash()
-COVENANT_LAYER_HASH: bytes32 = COVENANT_LAYER.get_tree_hash()
-STD_COVENANT_PARENT_MORPHER_HASH: bytes32 = STD_COVENANT_PARENT_MORPHER.get_tree_hash()
-EML_TP_COVENANT_ADAPTER_HASH: bytes32 = EML_TP_COVENANT_ADAPTER.get_tree_hash()
-EXTIGENT_METADATA_LAYER_COVENANT_MORPHER_HASH: bytes32 = EXTIGENT_METADATA_LAYER_COVENANT_MORPHER.get_tree_hash()
-VIRAL_BACKDOOR_HASH: bytes32 = VIRAL_BACKDOOR.get_tree_hash()
+EXTIGENT_METADATA_LAYER_HASH = bytes32(EXIGENT_METADATA_LAYER_HASH_BYTES)
+P2_ANNOUNCED_DELEGATED_PUZZLE_HASH: bytes32 = bytes32(P2_ANNOUNCED_DELEGATED_PUZZLE_HASH_BYTES)
+COVENANT_LAYER_HASH: bytes32 = bytes32(COVENANT_LAYER_HASH_BYTES)
+STD_COVENANT_PARENT_MORPHER_HASH: bytes32 = bytes32(STD_PARENT_MORPHER_HASH_BYTES)
+EML_TP_COVENANT_ADAPTER_HASH: bytes32 = bytes32(EML_TP_COVENANT_ADAPTER_HASH_BYTES)
+EXTIGENT_METADATA_LAYER_COVENANT_MORPHER_HASH: bytes32 = bytes32(EML_COVENANT_MORPHER_HASH_BYTES)
+REVOCATION_LAYER_HASH: bytes32 = bytes32(REVOCATION_LAYER_HASH_BYTES)
 
 
 # Standard brick puzzle uses the mods above
-STANDARD_BRICK_PUZZLE: Program = load_clvm_maybe_recompile(
-    "standard_vc_backdoor_puzzle.clsp",
-    package_or_requirement="chia.wallet.vc_wallet.vc_puzzles",
-    include_standard_libraries=True,
-).curry(
+STANDARD_BRICK_PUZZLE: Program = Program.from_bytes(STANDARD_VC_REVOCATION_PUZZLE_BYTES).curry(
     SINGLETON_MOD_HASH,
     Program.to(SINGLETON_LAUNCHER_HASH).get_tree_hash(),
     EXTIGENT_METADATA_LAYER_HASH,
-    VIRAL_BACKDOOR_HASH,
+    REVOCATION_LAYER_HASH,
     ACS_TRANSFER_PROGRAM.get_tree_hash(),
 )
 STANDARD_BRICK_PUZZLE_HASH: bytes32 = STANDARD_BRICK_PUZZLE.get_tree_hash()
@@ -190,22 +172,22 @@ def solve_did_tp(
 ##############################
 # P2 Puzzle or Hidden Puzzle #
 ##############################
-def create_viral_backdoor(hidden_puzzle_hash: bytes32, inner_puzzle_hash: bytes32) -> Program:
-    return VIRAL_BACKDOOR.curry(
-        VIRAL_BACKDOOR_HASH,
+def create_revocation_layer(hidden_puzzle_hash: bytes32, inner_puzzle_hash: bytes32) -> Program:
+    return REVOCATION_LAYER.curry(
+        REVOCATION_LAYER_HASH,
         hidden_puzzle_hash,
         inner_puzzle_hash,
     )
 
 
-def match_viral_backdoor(uncurried_puzzle: UncurriedPuzzle) -> Optional[tuple[bytes32, bytes32]]:
-    if uncurried_puzzle.mod == VIRAL_BACKDOOR:
+def match_revocation_layer(uncurried_puzzle: UncurriedPuzzle) -> Optional[tuple[bytes32, bytes32]]:
+    if uncurried_puzzle.mod == REVOCATION_LAYER:
         return bytes32(uncurried_puzzle.args.at("rf").as_atom()), bytes32(uncurried_puzzle.args.at("rrf").as_atom())
     else:
         return None  # pragma: no cover
 
 
-def solve_viral_backdoor(puzzle_reveal: Program, inner_solution: Program, hidden: bool = False) -> Program:
+def solve_revocation_layer(puzzle_reveal: Program, inner_solution: Program, hidden: bool = False) -> Program:
     solution: Program = Program.to(
         [
             hidden,
@@ -371,7 +353,7 @@ class VerifiedCredential(Streamable):
                 inner_transfer_program,
             )
         )
-        wrapped_inner_puzzle_hash: bytes32 = create_viral_backdoor(
+        wrapped_inner_puzzle_hash: bytes32 = create_revocation_layer(
             STANDARD_BRICK_PUZZLE_HASH,
             new_inner_puzzle_hash,
         ).get_tree_hash()
@@ -485,7 +467,7 @@ class VerifiedCredential(Streamable):
         )
 
     def wrap_inner_with_backdoor(self) -> Program:
-        return create_viral_backdoor(
+        return create_revocation_layer(
             self.hidden_puzzle().get_tree_hash(),
             self.inner_puzzle_hash,
         )
@@ -543,7 +525,7 @@ class VerifiedCredential(Streamable):
 
         # ...and layer below EML
         layer_below_eml: UncurriedPuzzle = uncurry_puzzle(layer_below_singleton.args.at("rrrrf"))
-        if layer_below_eml.mod != VIRAL_BACKDOOR:
+        if layer_below_eml.mod != REVOCATION_LAYER:
             return False, "VC did not have a provider backdoor"  # pragma: no cover
         hidden_puzzle_hash = bytes32(layer_below_eml.args.at("rf").as_atom())
         if hidden_puzzle_hash != STANDARD_BRICK_PUZZLE_HASH:
@@ -616,7 +598,7 @@ class VerifiedCredential(Streamable):
             parent_proof_hash: bytes32 = metadata_layer.args.at("rf").get_tree_hash()
             eml_lineage_proof = VCLineageProof(
                 parent_name=parent_coin.parent_coin_info,
-                inner_puzzle_hash=create_viral_backdoor(
+                inner_puzzle_hash=create_revocation_layer(
                     STANDARD_BRICK_PUZZLE_HASH,
                     bytes32(uncurry_puzzle(metadata_layer.args.at("rrrrf")).args.at("rrf").as_atom()),
                 ).get_tree_hash(),
@@ -720,7 +702,7 @@ class VerifiedCredential(Streamable):
             uint64(self.coin.amount),
             Program.to(
                 [  # solve EML
-                    solve_viral_backdoor(
+                    solve_revocation_layer(
                         inner_puzzle,
                         inner_solution,
                     ),
@@ -773,7 +755,7 @@ class VerifiedCredential(Streamable):
             uint64(self.coin.amount),
             Program.to(
                 [  # solve EML
-                    solve_viral_backdoor(
+                    solve_revocation_layer(
                         self.hidden_puzzle(),
                         solve_std_vc_backdoor(
                             self.launcher_id,

chia/wallet/vc_wallet/vc_store.py

@@ -5,12 +5,12 @@ from functools import cmp_to_key
 from typing import Optional, TypeVar
 
 from aiosqlite import Row
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.db_wrapper import DBWrapper2
-from chia.util.ints import uint32, uint64
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.lineage_proof import LineageProof
 from chia.wallet.util.merkle_utils import list_to_binary_tree

chia/wallet/vc_wallet/vc_wallet.py

@@ -6,6 +6,8 @@ import traceback
 from typing import TYPE_CHECKING, Optional, TypeVar, Union
 
 from chia_rs import 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
 
@@ -14,21 +16,19 @@ 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.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_spend import CoinSpend, make_spend
 from chia.util.hash import std_hash
-from chia.util.ints import uint32, uint64, uint128
 from chia.util.streamable import Streamable
 from chia.wallet.conditions import (
     AssertCoinAnnouncement,
     Condition,
+    CreateCoin,
     CreateCoinAnnouncement,
     CreatePuzzleAnnouncement,
     UnknownCondition,
     parse_timelock_info,
 )
 from chia.wallet.did_wallet.did_wallet import DIDWallet
-from chia.wallet.payment import Payment
 from chia.wallet.puzzle_drivers import Solver
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import solution_for_delegated_puzzle
 from chia.wallet.trading.offer import Offer
@@ -234,18 +234,21 @@ class VCWallet:
 
     async def generate_signed_transaction(
         self,
-        vc_id: bytes32,
+        amounts: list[uint64],
+        puzzle_hashes: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        new_inner_puzhash: Optional[bytes32] = None,
+        coins: Optional[set[Coin]] = None,
+        memos: Optional[list[list[bytes]]] = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
         **kwargs: Unpack[GSTOptionalArgs],
     ) -> None:
         new_proof_hash: Optional[bytes32] = kwargs.get(
             "new_proof_hash", None
-        )  # Requires that this key posesses the DID to update the specified VC
+        )  # Requires that this key possesses the DID to update the specified VC
         provider_inner_puzhash: Optional[bytes32] = kwargs.get("provider_inner_puzhash", None)
         self_revoke: Optional[bool] = kwargs.get("self_revoke", False)
+        potential_vc_id: Optional[bytes32] = kwargs.get("vc_id", None)
         """
         Entry point for two standard actions:
          - Cycle the singleton and make an announcement authorizing something
@@ -254,18 +257,39 @@ class VCWallet:
         Returns a 1 - 3 TransactionRecord objects depending on whether or not there's a fee and whether or not there's
         a DID announcement involved.
         """
+        if len(amounts) > 1 or amounts[0] != 1:
+            raise ValueError("VCWallet.generate_signed_transaction only accepts `amounts=[uint64(1)]`")
+        if len(puzzle_hashes) != 1:
+            raise ValueError("Can only send a single VC to a single new puzzle hash")
+        if memos is not None:
+            raise ValueError("Memos not currently supported for VC wallets")
+        if coins is not None and len(list(coins)) != 1:
+            raise ValueError("Can only spend a single VC at a time")
         # Find verified credential
-        vc_record = await self.get_vc_record_for_launcher_id(vc_id)
+        if coins is not None:
+            coin_id = next(iter(coins)).name()
+            potential_vc_record = await self.store.get_vc_record_by_coin_id(coin_id)
+            if potential_vc_record is None:
+                raise ValueError(f"Could not find a VC record for coin ID: {coin_id}")
+            vc_record: VCRecord = potential_vc_record
+            lookup_info = ("coin ID", coin_id)
+        elif potential_vc_id is not None:
+            vc_record = await self.get_vc_record_for_launcher_id(potential_vc_id)
+            lookup_info = ("launcher ID", potential_vc_id)
+        else:
+            raise ValueError("Must specify either a vc_id or a specific VC coin")
+
         if vc_record.confirmed_at_height == 0:
             raise ValueError(
-                f"Verified credential {vc_id.hex()} is not confirmed, please try again later."
+                f"Verified credential with {lookup_info[0]} {lookup_info[1].hex()}"
+                "is not confirmed, please try again later."
             )  # pragma: no cover
         inner_puzhash: bytes32 = vc_record.vc.inner_puzzle_hash
         inner_puzzle: Program = await self.standard_wallet.puzzle_for_puzzle_hash(inner_puzhash)
-        if new_inner_puzhash is None:
-            new_inner_puzhash = inner_puzhash
 
-        primaries: list[Payment] = [Payment(new_inner_puzhash, uint64(vc_record.vc.coin.amount), [new_inner_puzhash])]
+        primaries: list[CreateCoin] = [
+            CreateCoin(puzzle_hashes[0], uint64(vc_record.vc.coin.amount), [puzzle_hashes[0]])
+        ]
 
         if fee > 0:
             coin_name = vc_record.vc.coin.name()
@@ -309,7 +333,7 @@ class VCWallet:
                 if wallet.type() == WalletType.DECENTRALIZED_ID:
                     assert isinstance(wallet, DIDWallet)
                     if bytes32.fromhex(wallet.get_my_DID()) == vc_record.vc.proof_provider:
-                        self.log.debug("Creating announcement from DID for vc: %s", vc_id.hex())
+                        self.log.debug("Creating announcement from DID for vc: %s", vc_record.vc.launcher_id.hex())
                         await wallet.create_message_spend(action_scope, extra_conditions=(did_announcement,))
                         break
             else:
@@ -325,7 +349,7 @@ class VCWallet:
                 TransactionRecord(
                     confirmed_at_height=uint32(0),
                     created_at_time=now,
-                    to_puzzle_hash=new_inner_puzhash,
+                    to_puzzle_hash=puzzle_hashes[0],
                     amount=uint64(1),
                     fee_amount=uint64(fee),
                     confirmed=False,
@@ -370,9 +394,11 @@ class VCWallet:
                     break
         else:
             await self.generate_signed_transaction(
-                vc.launcher_id,
+                [uint64(1)],
+                [await self.standard_wallet.get_puzzle_hash(new=not action_scope.config.tx_config.reuse_puzhash)],
                 action_scope,
                 fee,
+                vc_id=vc.launcher_id,
                 self_revoke=True,
             )
             return
@@ -537,8 +563,14 @@ class VCWallet:
         ) as inner_action_scope:
             for launcher_id, vc in vcs.items():
                 await self.generate_signed_transaction(
-                    launcher_id,
+                    [uint64(1)],
+                    [
+                        await self.standard_wallet.get_puzzle_hash(
+                            new=not inner_action_scope.config.tx_config.reuse_puzhash
+                        )
+                    ],
                     inner_action_scope,
+                    vc_id=launcher_id,
                     extra_conditions=(
                         *announcements_to_assert[launcher_id],
                         *announcements_to_make[launcher_id],

chia/wallet/wallet.py

@@ -5,19 +5,25 @@ import time
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64, uint128
 from typing_extensions import Unpack
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_spend import CoinSpend, make_spend
 from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
 from chia.util.hash import std_hash
-from chia.util.ints import uint32, uint64, uint128
 from chia.util.streamable import Streamable
 from chia.wallet.coin_selection import select_coins
-from chia.wallet.conditions import AssertCoinAnnouncement, Condition, CreateCoinAnnouncement, parse_timelock_info
+from chia.wallet.conditions import (
+    AssertCoinAnnouncement,
+    Condition,
+    CreateCoin,
+    CreateCoinAnnouncement,
+    parse_timelock_info,
+)
 from chia.wallet.derivation_record import DerivationRecord
 from chia.wallet.derive_keys import (
     MAX_POOL_WALLETS,
@@ -25,7 +31,6 @@ from chia.wallet.derive_keys import (
     _derive_path_unhardened,
     master_sk_to_singleton_owner_sk,
 )
-from chia.wallet.payment import Payment
 from chia.wallet.puzzles.clawback.metadata import ClawbackMetadata
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
     DEFAULT_HIDDEN_PUZZLE_HASH,
@@ -36,7 +41,7 @@ from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
     puzzle_hash_for_synthetic_public_key,
     solution_for_conditions,
 )
-from chia.wallet.puzzles.puzzle_utils import make_create_coin_condition, make_reserve_fee_condition
+from chia.wallet.puzzles.puzzle_utils import make_reserve_fee_condition
 from chia.wallet.signer_protocol import (
     PathHint,
     Signature,
@@ -206,7 +211,7 @@ class Wallet:
 
     def make_solution(
         self,
-        primaries: list[Payment],
+        primaries: list[CreateCoin],
         conditions: tuple[Condition, ...] = tuple(),
         fee: uint64 = uint64(0),
     ) -> Program:
@@ -214,7 +219,7 @@ class Wallet:
         condition_list: list[Any] = [condition.to_program() for condition in conditions]
         if len(primaries) > 0:
             for primary in primaries:
-                condition_list.append(make_create_coin_condition(primary.puzzle_hash, primary.amount, primary.memos))
+                condition_list.append(primary.to_program())
         if fee:
             condition_list.append(make_reserve_fee_condition(fee))
 
@@ -257,14 +262,13 @@ class Wallet:
 
     async def _generate_unsigned_transaction(
         self,
-        amount: uint64,
-        newpuzzlehash: bytes32,
+        amounts: list[uint64],
+        newpuzzlehashes: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
         origin_id: Optional[bytes32] = None,
         coins: Optional[set[Coin]] = None,
-        primaries_input: Optional[list[Payment]] = None,
-        memos: Optional[list[bytes]] = None,
+        memos: Optional[list[list[bytes]]] = None,
         negative_change_allowed: bool = False,
         puzzle_decorator_override: Optional[list[dict[str, Any]]] = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
@@ -277,11 +281,7 @@ class Wallet:
         if puzzle_decorator_override is not None:
             decorator_manager = PuzzleDecoratorManager.create(puzzle_decorator_override)
 
-        primaries = []
-        if primaries_input is not None:
-            primaries.extend(primaries_input)
-
-        total_amount = amount + sum(primary.amount for primary in primaries) + fee
+        total_amount = sum(amounts) + fee
         total_balance = await self.get_spendable_balance()
         if coins is None:
             if total_amount > total_balance:
@@ -307,7 +307,7 @@ class Wallet:
         primary_announcement: Optional[AssertCoinAnnouncement] = None
 
         # Check for duplicates
-        all_primaries_list = [(p.puzzle_hash, p.amount) for p in primaries]
+        all_primaries_list = list(zip(amounts, newpuzzlehashes))
         if len(set(all_primaries_list)) != len(all_primaries_list):
             raise ValueError("Cannot create two identical coins")
         for coin in coins:
@@ -315,16 +315,27 @@ class Wallet:
             if origin_id in {None, coin.name()}:
                 origin_id = coin.name()
                 inner_puzzle = await self.puzzle_for_puzzle_hash(coin.puzzle_hash)
-                decorated_target_puzzle_hash = decorator_manager.decorate_target_puzzle_hash(
-                    inner_puzzle, newpuzzlehash
-                )
-                target_primary: list[Payment] = []
+                decorated_target_puzzle_hashes = [
+                    decorator_manager.decorate_target_puzzle_hash(inner_puzzle, newpuzzlehash)
+                    for newpuzzlehash in newpuzzlehashes
+                ]
                 if memos is None:
-                    memos = []
-                memos = decorator_manager.decorate_memos(inner_puzzle, newpuzzlehash, memos)
-                if (primaries_input is None and amount > 0) or primaries_input is not None:
-                    primaries.append(Payment(decorated_target_puzzle_hash, amount, memos))
-                    target_primary.append(Payment(newpuzzlehash, amount, memos))
+                    memos = [[]] * len(amounts)
+                decorated_memos = [
+                    decorator_manager.decorate_memos(inner_puzzle, newpuzzlehash, mems)
+                    for newpuzzlehash, mems in zip(newpuzzlehashes, memos)
+                ]
+
+                primaries = [
+                    CreateCoin(decorated_target_puzzle_hash, amount, mems)
+                    for decorated_target_puzzle_hash, amount, mems in zip(
+                        decorated_target_puzzle_hashes, amounts, decorated_memos
+                    )
+                ]
+                target_primaries = [
+                    CreateCoin(newpuzzlehash, amount, mems)
+                    for newpuzzlehash, amount, mems in zip(newpuzzlehashes, amounts, decorated_memos)
+                ]
 
                 if change > 0:
                     if action_scope.config.tx_config.reuse_puzhash:
@@ -336,7 +347,7 @@ class Wallet:
                                 break
                     else:
                         change_puzzle_hash = await self.get_new_puzzlehash()
-                    primaries.append(Payment(change_puzzle_hash, uint64(change)))
+                    primaries.append(CreateCoin(change_puzzle_hash, uint64(change)))
                 message_list: list[bytes32] = [c.name() for c in coins]
                 for primary in primaries:
                     message_list.append(Coin(coin.name(), primary.puzzle_hash, primary.amount).name())
@@ -347,7 +358,7 @@ class Wallet:
                     fee=fee,
                     conditions=(*extra_conditions, CreateCoinAnnouncement(message)),
                 )
-                solution = decorator_manager.solve(inner_puzzle, target_primary, solution)
+                solution = decorator_manager.solve(inner_puzzle, target_primaries, solution)
                 primary_announcement = AssertCoinAnnouncement(asserted_id=coin.name(), asserted_msg=message)
 
                 spends.append(
@@ -393,38 +404,33 @@ class Wallet:
 
     async def generate_signed_transaction(
         self,
-        amount: uint64,
-        puzzle_hash: bytes32,
+        amounts: list[uint64],
+        puzzle_hashes: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
         coins: Optional[set[Coin]] = None,
-        primaries: Optional[list[Payment]] = None,
-        memos: Optional[list[bytes]] = None,
-        puzzle_decorator_override: Optional[list[dict[str, Any]]] = None,
+        memos: Optional[list[list[bytes]]] = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
         **kwargs: Unpack[GSTOptionalArgs],
     ) -> None:
         origin_id: Optional[bytes32] = kwargs.get("origin_id", None)
         negative_change_allowed: bool = kwargs.get("negative_change_allowed", False)
+        puzzle_decorator_override: Optional[list[dict[str, Any]]] = kwargs.get("puzzle_decorator_override", None)
         """
         Use this to generate transaction.
         Note: this must be called under a wallet state manager lock
         The first output is (amount, puzzle_hash, memos), and the rest of the outputs are in primaries.
         """
-        if primaries is None:
-            non_change_amount = amount
-        else:
-            non_change_amount = uint64(amount + sum(p.amount for p in primaries))
+        non_change_amount = uint64(sum(amounts))
 
-        self.log.debug("Generating transaction for: %s %s %s", puzzle_hash, amount, repr(coins))
+        self.log.debug("Generating transaction for: %s %s %s", puzzle_hashes, amounts, repr(coins))
         transaction = await self._generate_unsigned_transaction(
-            amount,
-            puzzle_hash,
+            amounts,
+            puzzle_hashes,
             action_scope,
             fee,
             origin_id,
             coins,
-            primaries,
             memos,
             negative_change_allowed,
             puzzle_decorator_override=puzzle_decorator_override,
@@ -449,7 +455,7 @@ class Wallet:
                 TransactionRecord(
                     confirmed_at_height=uint32(0),
                     created_at_time=now,
-                    to_puzzle_hash=puzzle_hash,
+                    to_puzzle_hash=add_list[0].puzzle_hash if len(add_list) > 0 else bytes32.zeros,
                     amount=uint64(non_change_amount),
                     fee_amount=uint64(fee),
                     confirmed=False,
@@ -475,8 +481,8 @@ class Wallet:
     ) -> None:
         chia_coins = await self.select_coins(fee, action_scope)
         await self.generate_signed_transaction(
-            uint64(0),
-            (await self.get_puzzle_hash(not action_scope.config.tx_config.reuse_puzhash)),
+            [],
+            [],
             action_scope,
             fee=fee,
             coins=chia_coins,
@@ -601,8 +607,7 @@ class Wallet:
                 if fingerprint_as_int not in pk_lookup:
                     if not partial_allowed:
                         raise ValueError(
-                            "No pubkey found (or path hinted to) for "
-                            f"fingerprint {int.from_bytes(fingerprint, 'big')}"
+                            f"No pubkey found (or path hinted to) for fingerprint {int.from_bytes(fingerprint, 'big')}"
                         )
                     else:
                         aggregate_responses_at_end = False

chia/wallet/wallet_action_scope.py

@@ -5,6 +5,7 @@ from collections.abc import AsyncIterator
 from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, Optional, cast, final
 
+from chia.data_layer.singleton_record import SingletonRecord
 from chia.types.blockchain_format.coin import Coin
 from chia.util.action_scope import ActionScope
 from chia.util.streamable import Streamable, streamable
@@ -25,6 +26,7 @@ class _StreamableWalletSideEffects(Streamable):
     signing_responses: list[SigningResponse]
     extra_spends: list[WalletSpendBundle]
     selected_coins: list[Coin]
+    singleton_records: list[SingletonRecord]
 
 
 @dataclass
@@ -33,6 +35,7 @@ class WalletSideEffects:
     signing_responses: list[SigningResponse] = field(default_factory=list)
     extra_spends: list[WalletSpendBundle] = field(default_factory=list)
     selected_coins: list[Coin] = field(default_factory=list)
+    singleton_records: list[SingletonRecord] = field(default_factory=list)
 
     def __bytes__(self) -> bytes:
         return bytes(_StreamableWalletSideEffects(**self.__dict__))
@@ -93,4 +96,5 @@ async def new_wallet_action_scope(
         sign=sign,
         additional_signing_responses=self.side_effects.signing_responses,
         extra_spends=self.side_effects.extra_spends,
+        singleton_records=self.side_effects.singleton_records,
     )