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

chia/wallet/puzzles/p2_delegated_puzzle.py

@@ -14,11 +14,12 @@ This roughly corresponds to bitcoin's graftroot.
 
 from __future__ import annotations
 
+from chia_puzzles_py.programs import P2_DELEGATED_PUZZLE
+
 from chia.types.blockchain_format.program import Program
 from chia.wallet.puzzles import p2_conditions
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 
-MOD = load_clvm_maybe_recompile("p2_delegated_puzzle.clsp")
+MOD = Program.from_bytes(P2_DELEGATED_PUZZLE)
 
 
 def puzzle_for_pk(public_key: bytes) -> Program:

chia/wallet/puzzles/p2_delegated_puzzle_or_hidden_puzzle.py

@@ -62,12 +62,12 @@ import hashlib
 from functools import lru_cache
 from typing import Union
 
+from chia_puzzles_py.programs import P2_DELEGATED_PUZZLE_OR_HIDDEN_PUZZLE
 from chia_rs import G1Element, PrivateKey
+from chia_rs.sized_bytes import bytes32
 from clvm.casts import int_from_bytes
 
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.puzzles.p2_conditions import puzzle_for_conditions
 from chia.wallet.util.curry_and_treehash import calculate_hash_of_quoted_mod_hash, curry_and_treehash, shatree_atom
 
@@ -75,7 +75,7 @@ DEFAULT_HIDDEN_PUZZLE = Program.from_bytes(bytes.fromhex("ff0980"))
 
 DEFAULT_HIDDEN_PUZZLE_HASH = DEFAULT_HIDDEN_PUZZLE.get_tree_hash()  # this puzzle `(=)` always fails
 
-MOD = load_clvm_maybe_recompile("p2_delegated_puzzle_or_hidden_puzzle.clsp")
+MOD = Program.from_bytes(P2_DELEGATED_PUZZLE_OR_HIDDEN_PUZZLE)
 
 QUOTED_MOD_HASH = calculate_hash_of_quoted_mod_hash(MOD.get_tree_hash())
 

chia/wallet/puzzles/p2_m_of_n_delegate_direct.py

@@ -7,10 +7,11 @@ it includes N public keys, any M of which needs to sign the delegated puzzle.
 
 from __future__ import annotations
 
+from chia_puzzles_py.programs import P2_M_OF_N_DELEGATE_DIRECT
+
 from chia.types.blockchain_format.program import Program
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 
-MOD = load_clvm_maybe_recompile("p2_m_of_n_delegate_direct.clsp")
+MOD = Program.from_bytes(P2_M_OF_N_DELEGATE_DIRECT)
 
 
 def puzzle_for_m_of_public_key_list(m, public_key_list) -> Program:

chia/wallet/puzzles/p2_puzzle_hash.py

@@ -7,11 +7,12 @@ hash along with its solution.
 
 from __future__ import annotations
 
+from chia_puzzles_py.programs import P2_PUZZLE_HASH
+from chia_rs.sized_bytes import bytes32
+
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 
-MOD = load_clvm_maybe_recompile("p2_puzzle_hash.clsp")
+MOD = Program.from_bytes(P2_PUZZLE_HASH)
 
 
 def puzzle_for_inner_puzzle_hash(inner_puzzle_hash: bytes32) -> Program:

chia/wallet/puzzles/puzzle_utils.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 from typing import Any
 
-from chia.types.blockchain_format.sized_bytes import bytes32
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
+
 from chia.types.condition_opcodes import ConditionOpcode
-from chia.util.ints import uint64
 
 
 def make_create_coin_condition(puzzle_hash: bytes32, amount: uint64, memos: list[bytes]) -> list[Any]:

chia/wallet/puzzles/singleton_top_layer.py

@@ -3,22 +3,38 @@ from __future__ import annotations
 from collections.abc import Iterator
 from typing import Optional
 
+from chia_puzzles_py.programs import (
+    P2_SINGLETON,
+    P2_SINGLETON_HASH,
+    P2_SINGLETON_OR_DELAYED_PUZHASH,
+    P2_SINGLETON_OR_DELAYED_PUZHASH_HASH,
+    SINGLETON_TOP_LAYER,
+    SINGLETON_TOP_LAYER_HASH,
+)
+from chia_puzzles_py.programs import (
+    SINGLETON_LAUNCHER as SINGLETON_LAUNCHER_BYTES,
+)
+from chia_puzzles_py.programs import (
+    SINGLETON_LAUNCHER_HASH as SINGLETON_LAUNCHER_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, make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.hash import std_hash
-from chia.util.ints import uint64
 from chia.wallet.lineage_proof import LineageProof
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
-
-SINGLETON_MOD = load_clvm_maybe_recompile("singleton_top_layer.clsp")
-SINGLETON_MOD_HASH = SINGLETON_MOD.get_tree_hash()
-P2_SINGLETON_MOD = load_clvm_maybe_recompile("p2_singleton.clsp")
-P2_SINGLETON_OR_DELAYED_MOD = load_clvm_maybe_recompile("p2_singleton_or_delayed_puzhash.clsp")
-SINGLETON_LAUNCHER = load_clvm_maybe_recompile("singleton_launcher.clsp")
-SINGLETON_LAUNCHER_HASH = SINGLETON_LAUNCHER.get_tree_hash()
+
+SINGLETON_MOD = Program.from_bytes(SINGLETON_TOP_LAYER)
+SINGLETON_MOD_HASH = bytes32(SINGLETON_TOP_LAYER_HASH)
+P2_SINGLETON_MOD = Program.from_bytes(P2_SINGLETON)
+P2_SINGLETON_MOD_HASH = bytes32(P2_SINGLETON_HASH)
+P2_SINGLETON_OR_DELAYED_MOD = Program.from_bytes(P2_SINGLETON_OR_DELAYED_PUZHASH)
+P2_SINGLETON_OR_DELAYED_MOD_HASH = bytes32(P2_SINGLETON_OR_DELAYED_PUZHASH_HASH)
+SINGLETON_LAUNCHER = Program.from_bytes(SINGLETON_LAUNCHER_BYTES)
+SINGLETON_LAUNCHER_HASH = bytes32(SINGLETON_LAUNCHER_HASH_BYTES)
 ESCAPE_VALUE = -113
 MELT_CONDITION = [ConditionOpcode.CREATE_COIN, 0, ESCAPE_VALUE]
 

chia/wallet/puzzles/singleton_top_layer_v1_1.py

@@ -3,23 +3,35 @@ from __future__ import annotations
 from collections.abc import Iterator
 from typing import Optional
 
+from chia_puzzles_py.programs import (
+    P2_SINGLETON,
+    P2_SINGLETON_OR_DELAYED_PUZHASH,
+    SINGLETON_TOP_LAYER_V1_1,
+    SINGLETON_TOP_LAYER_V1_1_HASH,
+)
+from chia_puzzles_py.programs import (
+    SINGLETON_LAUNCHER as SINGLETON_LAUNCHER_BYTES,
+)
+from chia_puzzles_py.programs import (
+    SINGLETON_LAUNCHER_HASH as SINGLETON_LAUNCHER_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, make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.hash import std_hash
-from chia.util.ints import uint64
 from chia.wallet.lineage_proof import LineageProof
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle
 
-SINGLETON_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clsp")
-SINGLETON_MOD_HASH = SINGLETON_MOD.get_tree_hash()
-P2_SINGLETON_MOD = load_clvm_maybe_recompile("p2_singleton.clsp")
-P2_SINGLETON_OR_DELAYED_MOD = load_clvm_maybe_recompile("p2_singleton_or_delayed_puzhash.clsp")
-SINGLETON_LAUNCHER = load_clvm_maybe_recompile("singleton_launcher.clsp")
-SINGLETON_LAUNCHER_HASH = SINGLETON_LAUNCHER.get_tree_hash()
+SINGLETON_MOD = Program.from_bytes(SINGLETON_TOP_LAYER_V1_1)
+SINGLETON_MOD_HASH = bytes32(SINGLETON_TOP_LAYER_V1_1_HASH)
+P2_SINGLETON_MOD = Program.from_bytes(P2_SINGLETON)
+P2_SINGLETON_OR_DELAYED_MOD = Program.from_bytes(P2_SINGLETON_OR_DELAYED_PUZHASH)
+SINGLETON_LAUNCHER = Program.from_bytes(SINGLETON_LAUNCHER_BYTES)
+SINGLETON_LAUNCHER_HASH = bytes32(SINGLETON_LAUNCHER_HASH_BYTES)
 ESCAPE_VALUE = -113
 MELT_CONDITION = [ConditionOpcode.CREATE_COIN, 0, ESCAPE_VALUE]
 

chia/wallet/puzzles/tails.py

@@ -2,12 +2,18 @@ from __future__ import annotations
 
 from typing import Any, Optional
 
-from chia_rs import Coin
+from chia_puzzles_py.programs import (
+    DELEGATED_TAIL,
+    EVERYTHING_WITH_SIGNATURE,
+    GENESIS_BY_COIN_ID,
+    GENESIS_BY_COIN_ID_OR_SINGLETON,
+    GENESIS_BY_PUZZLE_HASH,
+)
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
 
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.byte_types import hexstr_to_bytes
-from chia.util.ints import uint64
 from chia.wallet.cat_wallet.cat_info import CATInfo
 from chia.wallet.cat_wallet.cat_utils import (
     CAT_MOD,
@@ -16,29 +22,20 @@ from chia.wallet.cat_wallet.cat_utils import (
     unsigned_spend_bundle_for_spendable_cats,
 )
 from chia.wallet.cat_wallet.lineage_store import CATLineageStore
-from chia.wallet.dao_wallet.dao_utils import create_cat_launcher_for_singleton_id
+from chia.wallet.conditions import CreateCoin
 from chia.wallet.lineage_proof import LineageProof
-from chia.wallet.payment import Payment
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
-from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.wallet_action_scope import WalletActionScope
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
-GENESIS_BY_ID_MOD = load_clvm_maybe_recompile(
-    "genesis_by_coin_id.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
-)
-GENESIS_BY_PUZHASH_MOD = load_clvm_maybe_recompile(
-    "genesis_by_puzzle_hash.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
-)
-EVERYTHING_WITH_SIG_MOD = load_clvm_maybe_recompile(
-    "everything_with_signature.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
-)
-DELEGATED_LIMITATIONS_MOD = load_clvm_maybe_recompile(
-    "delegated_tail.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
-)
-GENESIS_BY_ID_OR_SINGLETON_MOD = load_clvm_maybe_recompile(
-    "genesis_by_coin_id_or_singleton.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
-)
+GENESIS_BY_ID_MOD = Program.from_bytes(GENESIS_BY_COIN_ID)
+
+GENESIS_BY_PUZHASH_MOD = Program.from_bytes(GENESIS_BY_PUZZLE_HASH)
+
+EVERYTHING_WITH_SIG_MOD = Program.from_bytes(EVERYTHING_WITH_SIGNATURE)
+
+DELEGATED_LIMITATIONS_MOD = Program.from_bytes(DELEGATED_TAIL)
+
+GENESIS_BY_ID_OR_SINGLETON_MOD = Program.from_bytes(GENESIS_BY_COIN_ID_OR_SINGLETON)
 
 
 class LimitationsProgram:
@@ -113,7 +110,7 @@ class GenesisById(LimitationsProgram):
             action_scope.config.tx_config, push=False
         ) as inner_action_scope:
             await wallet.standard_wallet.generate_signed_transaction(
-                amount, minted_cat_puzzle_hash, inner_action_scope, fee, coins, origin_id=origin_id
+                [amount], [minted_cat_puzzle_hash], inner_action_scope, fee, coins, origin_id=origin_id
             )
 
         async with action_scope.use() as interface:
@@ -122,7 +119,7 @@ class GenesisById(LimitationsProgram):
         inner_tree_hash = cat_inner.get_tree_hash()
         inner_solution = wallet.standard_wallet.add_condition_to_solution(
             Program.to([51, 0, -113, tail, []]),
-            wallet.standard_wallet.make_solution(primaries=[Payment(inner_tree_hash, amount, [inner_tree_hash])]),
+            wallet.standard_wallet.make_solution(primaries=[CreateCoin(inner_tree_hash, amount, [inner_tree_hash])]),
         )
         eve_spend = unsigned_spend_bundle_for_spendable_cats(
             CAT_MOD,
@@ -224,110 +221,6 @@ class DelegatedLimitations(LimitationsProgram):
         )
 
 
-class GenesisByIdOrSingleton(LimitationsProgram):
-    """
-    This TAIL allows for another TAIL to be used, as long as a signature of that TAIL's puzzlehash is included.
-    """
-
-    @staticmethod
-    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:  # pragma: no cover
-        if uncurried_mod == GENESIS_BY_ID_OR_SINGLETON_MOD:
-            genesis_id = curried_args.first()
-            return True, [genesis_id]
-        else:
-            return False, []
-
-    @staticmethod
-    def construct(args: list[Program]) -> Program:
-        return GENESIS_BY_ID_OR_SINGLETON_MOD.curry(
-            args[0],
-            args[1],
-        )
-
-    @staticmethod
-    def solve(args: list[Program], solution_dict: dict) -> Program:  # pragma: no cover
-        pid = hexstr_to_bytes(solution_dict["parent_coin_info"])
-        return Program.to([pid, solution_dict["amount"]])
-
-    @classmethod
-    async def generate_issuance_bundle(
-        cls,
-        wallet,
-        tail_info: dict,
-        amount: uint64,
-        action_scope: WalletActionScope,
-        fee: uint64 = uint64(0),
-    ) -> WalletSpendBundle:
-        if "coins" in tail_info:
-            coins: list[Coin] = tail_info["coins"]
-            origin_id = coins.copy().pop().name()
-        else:  # pragma: no cover
-            coins = await wallet.standard_wallet.select_coins(amount + fee, action_scope)
-            origin = coins.copy().pop()
-            origin_id = origin.name()
-
-        cat_inner: Program = await wallet.standard_wallet.get_puzzle(
-            new=not action_scope.config.tx_config.reuse_puzhash
-        )
-        # GENESIS_ID
-        # TREASURY_SINGLETON_STRUCT  ; (SINGLETON_MOD_HASH, (LAUNCHER_ID, LAUNCHER_PUZZLE_HASH))
-        launcher_puzhash = create_cat_launcher_for_singleton_id(tail_info["treasury_id"]).get_tree_hash()
-        tail: Program = cls.construct(
-            [
-                Program.to(origin_id),
-                Program.to(launcher_puzhash),
-            ]
-        )
-
-        wallet.lineage_store = await CATLineageStore.create(
-            wallet.wallet_state_manager.db_wrapper, tail.get_tree_hash().hex()
-        )
-        await wallet.add_lineage(origin_id, LineageProof())
-
-        minted_cat_puzzle_hash: bytes32 = construct_cat_puzzle(CAT_MOD, tail.get_tree_hash(), cat_inner).get_tree_hash()
-
-        async with wallet.wallet_state_manager.new_action_scope(
-            action_scope.config.tx_config, push=False
-        ) as inner_action_scope:
-            await wallet.standard_wallet.generate_signed_transaction(
-                amount,
-                minted_cat_puzzle_hash,
-                inner_action_scope,
-                fee,
-                coins=set(coins),
-                origin_id=origin_id,
-            )
-
-        async with action_scope.use() as interface:
-            interface.side_effects.transactions.extend(inner_action_scope.side_effects.transactions)
-        tx_record: TransactionRecord = inner_action_scope.side_effects.transactions[0]
-        assert tx_record.spend_bundle is not None
-        payment = Payment(cat_inner.get_tree_hash(), amount)
-        inner_solution = wallet.standard_wallet.add_condition_to_solution(
-            Program.to([51, 0, -113, tail, []]),
-            wallet.standard_wallet.make_solution(
-                primaries=[payment],
-            ),
-        )
-        eve_spend = unsigned_spend_bundle_for_spendable_cats(
-            CAT_MOD,
-            [
-                SpendableCAT(
-                    next(filter(lambda a: a.amount == amount, tx_record.additions)),
-                    tail.get_tree_hash(),
-                    cat_inner,
-                    inner_solution,
-                    limitations_program_reveal=tail,
-                )
-            ],
-        )
-
-        if wallet.cat_info.my_tail is None:
-            await wallet.save_info(CATInfo(tail.get_tree_hash(), tail))
-
-        return eve_spend
-
-
 # This should probably be much more elegant than just a dictionary with strings as identifiers
 # Right now this is small and experimental so it can stay like this
 ALL_LIMITATIONS_PROGRAMS: dict[str, Any] = {
@@ -335,7 +228,6 @@ ALL_LIMITATIONS_PROGRAMS: dict[str, Any] = {
     "genesis_by_puzhash": GenesisByPuzhash,
     "everything_with_signature": EverythingWithSig,
     "delegated_limitations": DelegatedLimitations,
-    "genesis_by_id_or_singleton": GenesisByIdOrSingleton,
 }
 
 

chia/wallet/signer_protocol.py

@@ -2,12 +2,13 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
+
 from chia.types.blockchain_format.coin import Coin as _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
-from chia.util.ints import uint64
 from chia.util.streamable import Streamable
 from chia.wallet.util.clvm_streamable import clvm_streamable
 

chia/wallet/singleton.py

@@ -2,12 +2,18 @@ from __future__ import annotations
 
 from typing import Optional, Union
 
+from chia_puzzles_py.programs import (
+    SINGLETON_LAUNCHER,
+    SINGLETON_LAUNCHER_HASH,
+    SINGLETON_TOP_LAYER_V1_1,
+    SINGLETON_TOP_LAYER_V1_1_HASH,
+)
+from chia_rs.sized_bytes import bytes32
+
 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, compute_additions
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.util.curry_and_treehash import (
     calculate_hash_of_quoted_mod_hash,
     curry_and_treehash,
@@ -15,12 +21,12 @@ from chia.wallet.util.curry_and_treehash import (
     shatree_pair,
 )
 
-SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clsp")
-SINGLETON_TOP_LAYER_MOD_HASH = SINGLETON_TOP_LAYER_MOD.get_tree_hash()
+SINGLETON_TOP_LAYER_MOD = Program.from_bytes(SINGLETON_TOP_LAYER_V1_1)
+SINGLETON_TOP_LAYER_MOD_HASH = bytes32(SINGLETON_TOP_LAYER_V1_1_HASH)
 SINGLETON_TOP_LAYER_MOD_HASH_TREE_HASH = shatree_atom(SINGLETON_TOP_LAYER_MOD_HASH)
 SINGLETON_TOP_LAYER_MOD_HASH_QUOTED = calculate_hash_of_quoted_mod_hash(SINGLETON_TOP_LAYER_MOD_HASH)
-SINGLETON_LAUNCHER_PUZZLE = load_clvm_maybe_recompile("singleton_launcher.clsp")
-SINGLETON_LAUNCHER_PUZZLE_HASH = SINGLETON_LAUNCHER_PUZZLE.get_tree_hash()
+SINGLETON_LAUNCHER_PUZZLE = Program.from_bytes(SINGLETON_LAUNCHER)
+SINGLETON_LAUNCHER_PUZZLE_HASH = bytes32(SINGLETON_LAUNCHER_HASH)
 SINGLETON_LAUNCHER_PUZZLE_HASH_TREE_HASH = shatree_atom(SINGLETON_LAUNCHER_PUZZLE_HASH)
 
 

chia/wallet/singleton_record.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Optional
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32
+
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_spend import CoinSpend
-from chia.util.ints import uint32
 from chia.wallet.lineage_proof import LineageProof
 
 

chia/wallet/trade_manager.py

@@ -6,6 +6,8 @@ import time
 from collections import deque
 from typing import TYPE_CHECKING, Any, Optional, Union
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 from typing_extensions import Literal
 
 from chia.data_layer.data_layer_wallet import DataLayerWallet
@@ -13,16 +15,15 @@ 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.sized_bytes import bytes32
 from chia.types.spend_bundle import estimate_fees
 from chia.util.db_wrapper import DBWrapper2
 from chia.util.hash import std_hash
-from chia.util.ints import uint32, uint64
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
 from chia.wallet.conditions import (
     AssertCoinAnnouncement,
     Condition,
     ConditionValidTimes,
+    CreateCoin,
     CreateCoinAnnouncement,
     parse_conditions_non_consensus,
     parse_timelock_info,
@@ -30,9 +31,7 @@ from chia.wallet.conditions import (
 from chia.wallet.db_wallet.db_wallet_puzzles import ACS_MU_PH
 from chia.wallet.nft_wallet.nft_wallet import NFTWallet
 from chia.wallet.outer_puzzles import AssetType
-from chia.wallet.payment import Payment
 from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.trade_record import TradeRecord
 from chia.wallet.trading.offer import NotarizedPayment, Offer
 from chia.wallet.trading.trade_status import TradeStatus
@@ -54,8 +53,6 @@ if TYPE_CHECKING:
     from chia.wallet.wallet_state_manager import WalletStateManager
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
-OFFER_MOD = load_clvm_maybe_recompile("settlement_payments.clsp")
-
 
 class TradeManager:
     """
@@ -325,41 +322,30 @@ class TradeManager:
                             uint64(fee_to_pay - coin.amount),
                             action_scope,
                         )
-                        selected_coins.add(coin)
                     else:
-                        selected_coins = {coin}
-                    async with self.wallet_state_manager.new_action_scope(
-                        action_scope.config.tx_config.override(
-                            excluded_coin_ids=[],
-                        ),
-                        push=False,
-                    ) as inner_action_scope:
-                        await wallet.generate_signed_transaction(
-                            uint64(sum(c.amount for c in selected_coins) - fee_to_pay),
-                            new_ph,
-                            inner_action_scope,
-                            origin_id=coin.name(),
-                            fee=fee_to_pay,
-                            coins=selected_coins,
-                            extra_conditions=(*extra_conditions, *announcement_conditions),
-                        )
+                        selected_coins = set()
+                    selected_coins.add(coin)
+                    amount_to_pay = uint64(sum(c.amount for c in selected_coins) - fee_to_pay)
                 else:
-                    # ATTENTION: new_wallets
-                    assert isinstance(wallet, (CATWallet, DataLayerWallet, NFTWallet))
-                    async with self.wallet_state_manager.new_action_scope(
-                        action_scope.config.tx_config.override(
-                            excluded_coin_ids=[],
-                        ),
-                        push=False,
-                    ) as inner_action_scope:
-                        await wallet.generate_signed_transaction(
-                            [coin.amount],
-                            [new_ph],
-                            inner_action_scope,
-                            fee=fee_to_pay,
-                            coins={coin},
-                            extra_conditions=(*extra_conditions, *announcement_conditions),
-                        )
+                    selected_coins = {coin}
+                    amount_to_pay = coin.amount
+
+                # ATTENTION: new_wallets
+                assert isinstance(wallet, (Wallet, CATWallet, DataLayerWallet, NFTWallet))
+                async with self.wallet_state_manager.new_action_scope(
+                    action_scope.config.tx_config.override(
+                        excluded_coin_ids=[],
+                    ),
+                    push=False,
+                ) as inner_action_scope:
+                    await wallet.generate_signed_transaction(
+                        [amount_to_pay],
+                        [new_ph],
+                        inner_action_scope,
+                        fee=fee_to_pay,
+                        coins=selected_coins,
+                        extra_conditions=(*extra_conditions, *announcement_conditions),
+                    )
 
                 cancellation_additions.extend(
                     [
@@ -503,7 +489,7 @@ class TradeManager:
             solver = Solver({})
         try:
             coins_to_offer: dict[Union[int, bytes32], set[Coin]] = {}
-            requested_payments: dict[Optional[bytes32], list[Payment]] = {}
+            requested_payments: dict[Optional[bytes32], list[CreateCoin]] = {}
             offer_dict_no_ints: dict[Optional[bytes32], int] = {}
             for id, amount in offer_dict.items():
                 asset_id: Optional[bytes32] = None
@@ -540,7 +526,7 @@ class TradeManager:
                         asset_id = id
                         wallet = await self.wallet_state_manager.get_wallet_for_asset_id(asset_id.hex())
                         memos = [p2_ph]
-                    requested_payments[asset_id] = [Payment(p2_ph, uint64(amount), memos)]
+                    requested_payments[asset_id] = [CreateCoin(p2_ph, uint64(amount), memos)]
                 elif amount < 0:
                     # this is what we are sending in the trade
                     if isinstance(id, int):
@@ -637,17 +623,7 @@ class TradeManager:
                 ) as inner_action_scope:
                     # This should probably not switch on whether or not we're spending XCH but it has to for now
                     assert wallet is not None
-                    if wallet.type() == WalletType.STANDARD_WALLET:
-                        assert isinstance(wallet, Wallet)
-                        await wallet.generate_signed_transaction(
-                            uint64(abs(offer_dict[id])),
-                            Offer.ph(),
-                            inner_action_scope,
-                            fee=fee_left_to_pay,
-                            coins=selected_coins,
-                            extra_conditions=(*extra_conditions, *announcements_to_assert),
-                        )
-                    elif wallet.type() == WalletType.NFT:
+                    if wallet.type() == WalletType.NFT:
                         assert isinstance(wallet, NFTWallet)
                         # This is to generate the tx for specific nft assets, i.e. not using
                         # wallet_id as the selector which would select any coins from nft_wallet
@@ -663,7 +639,7 @@ class TradeManager:
                         )
                     else:
                         # ATTENTION: new_wallets
-                        assert isinstance(wallet, (CATWallet, DataLayerWallet))
+                        assert isinstance(wallet, (Wallet, CATWallet, DataLayerWallet))
                         await wallet.generate_signed_transaction(
                             [uint64(abs(offer_dict[id]))],
                             [Offer.ph()],
@@ -1054,10 +1030,10 @@ class TradeManager:
 
     async def check_for_requested_payment_modifications(
         self,
-        requested_payments: dict[Optional[bytes32], list[Payment]],
+        requested_payments: dict[Optional[bytes32], list[CreateCoin]],
         driver_dict: dict[bytes32, PuzzleInfo],
         taking: bool,
-    ) -> dict[Optional[bytes32], list[Payment]]:
+    ) -> dict[Optional[bytes32], list[CreateCoin]]:
         # This function exclusively deals with CR-CATs for now
         if not taking:
             for asset_id, puzzle_info in driver_dict.items():

chia/wallet/trade_record.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Optional, TypeVar
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint32, uint64
+
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.ints import uint8, uint32, uint64
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.trading.offer import Offer