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

chia/wallet/nft_wallet/nft_wallet.py

@@ -8,24 +8,23 @@ import time
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
 
 from chia_rs import AugSchemeMPL, G1Element, G2Element
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint16, uint32, uint64, uint128
 from clvm.casts import int_from_bytes, int_to_bytes
 from typing_extensions import Unpack
 
-import chia.server.api_protocol
-import chia.wallet.singleton
 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.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_spend import CoinSpend, compute_additions, 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 uint16, uint32, uint64, uint128
 from chia.wallet.conditions import (
     AssertCoinAnnouncement,
     AssertPuzzleAnnouncement,
     Condition,
+    CreateCoin,
     CreateCoinAnnouncement,
     CreatePuzzleAnnouncement,
     UnknownCondition,
@@ -35,18 +34,19 @@ from chia.wallet.derivation_record import DerivationRecord
 from chia.wallet.did_wallet import did_wallet_puzzles
 from chia.wallet.did_wallet.did_info import DIDInfo
 from chia.wallet.lineage_proof import LineageProof
-from chia.wallet.nft_wallet import nft_puzzles
+from chia.wallet.nft_wallet import nft_puzzle_utils
 from chia.wallet.nft_wallet.nft_info import NFTCoinInfo, NFTWalletInfo
-from chia.wallet.nft_wallet.nft_puzzles import NFT_METADATA_UPDATER, create_ownership_layer_puzzle, get_metadata_and_phs
+from chia.wallet.nft_wallet.nft_puzzle_utils import create_ownership_layer_puzzle, get_metadata_and_phs
+from chia.wallet.nft_wallet.nft_puzzles import NFT_METADATA_UPDATER
 from chia.wallet.nft_wallet.uncurry_nft import NFTCoinData, UncurriedNFT
 from chia.wallet.outer_puzzles import AssetType, construct_puzzle, match_puzzle, solve_puzzle
-from chia.wallet.payment import Payment
 from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
     DEFAULT_HIDDEN_PUZZLE_HASH,
     calculate_synthetic_secret_key,
     puzzle_for_pk,
 )
+from chia.wallet.singleton import SINGLETON_LAUNCHER_PUZZLE, SINGLETON_LAUNCHER_PUZZLE_HASH, create_singleton_puzzle
 from chia.wallet.trading.offer import OFFER_MOD, OFFER_MOD_HASH, NotarizedPayment, Offer
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.uncurried_puzzle import uncurry_puzzle
@@ -211,13 +211,13 @@ class NFTWallet:
         mint_height: uint32 = uint32(launcher_coin_states[0].spent_height)
         minter_did = None
         if uncurried_nft.supports_did:
-            inner_puzzle = nft_puzzles.recurry_nft_puzzle(
+            inner_puzzle = nft_puzzle_utils.recurry_nft_puzzle(
                 uncurried_nft, data.parent_coin_spend.solution.to_program(), p2_puzzle
             )
             minter_did = await self.wallet_state_manager.get_minter_did(launcher_coin_states[0].coin, peer)
         else:
             inner_puzzle = p2_puzzle
-        child_puzzle: Program = nft_puzzles.create_full_puzzle(
+        child_puzzle: Program = nft_puzzle_utils.create_full_puzzle(
             singleton_id,
             Program.to(metadata),
             bytes32(uncurried_nft.metadata_updater_hash.as_atom()),
@@ -225,7 +225,7 @@ class NFTWallet:
         )
         self.log.debug(
             "Created NFT full puzzle with inner: %s",
-            nft_puzzles.create_full_puzzle_with_nft_puzzle(singleton_id, uncurried_nft.inner_puzzle),
+            nft_puzzle_utils.create_full_puzzle_with_nft_puzzle(singleton_id, uncurried_nft.inner_puzzle),
         )
         child_puzzle_hash = child_puzzle.get_tree_hash()
         for new_coin in compute_additions(data.parent_coin_spend):
@@ -353,9 +353,9 @@ class NFTWallet:
         if coins is None:
             return None
         origin = coins.copy().pop()
-        genesis_launcher_puz = nft_puzzles.LAUNCHER_PUZZLE
+        genesis_launcher_puz = SINGLETON_LAUNCHER_PUZZLE
         # nft_id == singleton_id == launcher_id == launcher_coin.name()
-        launcher_coin = Coin(origin.name(), nft_puzzles.LAUNCHER_PUZZLE_HASH, uint64(amount))
+        launcher_coin = Coin(origin.name(), SINGLETON_LAUNCHER_PUZZLE_HASH, uint64(amount))
         self.log.debug("Generating NFT with launcher coin %s and metadata: %s", launcher_coin, metadata)
 
         p2_inner_puzzle = await self.standard_wallet.get_puzzle(new=not action_scope.config.tx_config.reuse_puzhash)
@@ -376,7 +376,7 @@ class NFTWallet:
             inner_puzzle = p2_inner_puzzle
 
         # singleton eve puzzle
-        eve_fullpuz = nft_puzzles.create_full_puzzle(
+        eve_fullpuz = nft_puzzle_utils.create_full_puzzle(
             launcher_coin.name(), metadata, NFT_METADATA_UPDATER.get_tree_hash(), inner_puzzle
         )
         eve_fullpuz_hash = eve_fullpuz.get_tree_hash()
@@ -388,12 +388,11 @@ class NFTWallet:
         )
         # store the launcher transaction in the wallet state
         await self.standard_wallet.generate_signed_transaction(
-            uint64(amount),
-            nft_puzzles.LAUNCHER_PUZZLE_HASH,
+            [uint64(amount)],
+            [SINGLETON_LAUNCHER_PUZZLE_HASH],
             action_scope,
             fee,
-            coins,
-            None,
+            coins=coins,
             origin_id=origin.name(),
             extra_conditions=(
                 *extra_conditions,
@@ -591,7 +590,7 @@ class NFTWallet:
         for amount, puzhash, memo_list in zip(amounts, puzzle_hashes, memos):
             memos_with_hint: list[bytes] = [puzhash]
             memos_with_hint.extend(memo_list)
-            payments.append(Payment(puzhash, amount, memos_with_hint))
+            payments.append(CreateCoin(puzhash, amount, memos_with_hint))
 
         payment_sum = sum(p.amount for p in payments)
         unsigned_spend_bundle = await self.generate_unsigned_spendbundle(
@@ -639,7 +638,7 @@ class NFTWallet:
 
     async def generate_unsigned_spendbundle(
         self,
-        payments: list[Payment],
+        payments: list[CreateCoin],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
         coins: Optional[set[Coin]] = None,
@@ -807,27 +806,27 @@ class NFTWallet:
             else:
                 offered_royalty_percentages[asset] = uint16(royalty_percentage)
 
-        royalty_payments: dict[Optional[bytes32], list[tuple[bytes32, Payment]]] = {}
+        royalty_payments: dict[Optional[bytes32], list[tuple[bytes32, CreateCoin]]] = {}
         for asset, amount in fungible_asset_dict.items():  # offered fungible items
             if amount < 0 and request_side_royalty_split > 0:
-                payment_list: list[tuple[bytes32, Payment]] = []
+                payment_list: list[tuple[bytes32, CreateCoin]] = []
                 for launcher_id, address, percentage in required_royalty_info:
                     extra_royalty_amount = uint64(
                         math.floor(math.floor(abs(amount) / request_side_royalty_split) * (percentage / 10000))
                     )
                     if extra_royalty_amount == abs(amount):
                         raise ValueError("Amount offered and amount paid in royalties are equal")
-                    payment_list.append((launcher_id, Payment(address, extra_royalty_amount, [address])))
+                    payment_list.append((launcher_id, CreateCoin(address, extra_royalty_amount, [address])))
                 royalty_payments[asset] = payment_list
 
         # Generate the requested_payments to be notarized
         p2_ph = await wallet_state_manager.main_wallet.get_puzzle_hash(
             new=not action_scope.config.tx_config.reuse_puzhash
         )
-        requested_payments: dict[Optional[bytes32], list[Payment]] = {}
+        requested_payments: dict[Optional[bytes32], list[CreateCoin]] = {}
         for asset, amount in offer_dict.items():
             if amount > 0:
-                requested_payments[asset] = [Payment(p2_ph, uint64(amount), [p2_ph] if asset is not None else [])]
+                requested_payments[asset] = [CreateCoin(p2_ph, uint64(amount), [p2_ph] if asset is not None else [])]
 
         # Find all the coins we're offering
         offered_coins_by_asset: dict[Optional[bytes32], set[Coin]] = {}
@@ -894,19 +893,18 @@ class NFTWallet:
                 async with wallet_state_manager.new_action_scope(
                     action_scope.config.tx_config, push=False
                 ) as inner_action_scope:
-                    if wallet.type() == WalletType.STANDARD_WALLET:
+                    if asset in fungible_asset_dict:
                         payments = royalty_payments[asset] if asset in royalty_payments else []
                         payment_sum = sum(p.amount for _, p in payments)
                         await wallet.generate_signed_transaction(
-                            abs(amount),
-                            OFFER_MOD_HASH,
+                            [abs(amount)] + ([uint64(payment_sum)] if payment_sum > 0 else []),
+                            [OFFER_MOD_HASH] + ([OFFER_MOD_HASH] if payment_sum > 0 else []),
                             inner_action_scope,
-                            primaries=[Payment(OFFER_MOD_HASH, uint64(payment_sum))] if payment_sum > 0 else [],
-                            fee=fee,
+                            fee=fee if asset is None else fee_left_to_pay,
                             coins=offered_coins_by_asset[asset],
                             extra_conditions=(*extra_conditions, *announcements_to_assert),
                         )
-                    elif asset not in fungible_asset_dict:
+                    else:
                         assert asset is not None
                         await wallet.generate_signed_transaction(
                             [abs(amount)],
@@ -921,16 +919,7 @@ class NFTWallet:
                             ],
                             extra_conditions=(*extra_conditions, *announcements_to_assert),
                         )
-                    else:
-                        payments = royalty_payments[asset] if asset in royalty_payments else []
-                        await wallet.generate_signed_transaction(
-                            [abs(amount)] + ([sum(p.amount for _, p in payments)] if payments != [] else []),
-                            [OFFER_MOD_HASH] + ([OFFER_MOD_HASH] if payments != [] else []),
-                            inner_action_scope,
-                            fee=fee_left_to_pay,
-                            coins=offered_coins_by_asset[asset],
-                            extra_conditions=(*extra_conditions, *announcements_to_assert),
-                        )
+
                 all_transactions.extend(inner_action_scope.side_effects.transactions)
                 fee_left_to_pay = uint64(0)
                 extra_conditions = tuple()
@@ -950,8 +939,8 @@ class NFTWallet:
                     royalty_coin: Optional[Coin] = None
                     parent_spend: Optional[CoinSpend] = None
                     while True:
-                        duplicate_payments: list[tuple[bytes32, Payment]] = []
-                        deduped_payment_list: list[tuple[bytes32, Payment]] = []
+                        duplicate_payments: list[tuple[bytes32, CreateCoin]] = []
+                        deduped_payment_list: list[tuple[bytes32, CreateCoin]] = []
                         for launcher_id, payment in payments:
                             if payment in [p for _, p in deduped_payment_list]:
                                 duplicate_payments.append((launcher_id, payment))
@@ -970,7 +959,7 @@ class NFTWallet:
                                 (
                                     None,
                                     [
-                                        Payment(
+                                        CreateCoin(
                                             OFFER_MOD_HASH,
                                             uint64(sum(p.amount for _, p in duplicate_payments)),
                                         ).as_condition_args()
@@ -1227,7 +1216,7 @@ class NFTWallet:
             new_p2_puzhash = p2_puzzle.get_tree_hash()
         assert new_p2_puzhash is not None
         # make the primaries for the DID spend
-        primaries = [Payment(new_innerpuzhash, uint64(did_coin.amount), [bytes(new_p2_puzhash)])]
+        primaries = [CreateCoin(new_innerpuzhash, uint64(did_coin.amount), [bytes(new_p2_puzhash)])]
 
         # Ensure we have an xch coin of high enough amount
         assert isinstance(fee, uint64)
@@ -1260,10 +1249,10 @@ class NFTWallet:
         for mint_number in range(mint_number_start, mint_number_end):
             # Create  the puzzle, solution and coin spend for the intermediate launcher
             intermediate_launcher_puz = did_wallet_puzzles.INTERMEDIATE_LAUNCHER_MOD.curry(
-                chia.wallet.singleton.SINGLETON_LAUNCHER_PUZZLE_HASH, mint_number, mint_total
+                SINGLETON_LAUNCHER_PUZZLE_HASH, mint_number, mint_total
             )
             intermediate_launcher_ph = intermediate_launcher_puz.get_tree_hash()
-            primaries.append(Payment(intermediate_launcher_ph, uint64(0), [intermediate_launcher_ph]))
+            primaries.append(CreateCoin(intermediate_launcher_ph, uint64(0), [intermediate_launcher_ph]))
             intermediate_launcher_sol = Program.to([])
             intermediate_launcher_coin = Coin(did_coin.name(), intermediate_launcher_ph, uint64(0))
             intermediate_launcher_coin_spend = make_spend(
@@ -1278,9 +1267,7 @@ class NFTWallet:
             did_announcements.add(std_hash(intermediate_launcher_coin.name() + intermediate_announcement_message))
 
             # Create the launcher coin, and add its id to a list to be asserted in the DID spend
-            launcher_coin = Coin(
-                intermediate_launcher_coin.name(), chia.wallet.singleton.SINGLETON_LAUNCHER_PUZZLE_HASH, amount
-            )
+            launcher_coin = Coin(intermediate_launcher_coin.name(), SINGLETON_LAUNCHER_PUZZLE_HASH, amount)
             launcher_ids.append(launcher_coin.name())
 
             # Grab the metadata from metadata_list. The index for metadata_list
@@ -1295,7 +1282,7 @@ class NFTWallet:
                 metadata["royalty_pc"],
                 royalty_puzzle_hash=metadata["royalty_ph"],
             )
-            eve_fullpuz = nft_puzzles.create_full_puzzle(
+            eve_fullpuz = nft_puzzle_utils.create_full_puzzle(
                 launcher_coin.name(), metadata["program"], NFT_METADATA_UPDATER.get_tree_hash(), inner_puzzle
             )
 
@@ -1305,9 +1292,7 @@ class NFTWallet:
 
             genesis_launcher_solution = Program.to([eve_fullpuz.get_tree_hash(), amount, []])
 
-            launcher_cs = make_spend(
-                launcher_coin, chia.wallet.singleton.SINGLETON_LAUNCHER_PUZZLE, genesis_launcher_solution
-            )
+            launcher_cs = make_spend(launcher_coin, SINGLETON_LAUNCHER_PUZZLE, genesis_launcher_solution)
             launcher_spends.append(launcher_cs)
 
             eve_coin = Coin(launcher_coin.name(), eve_fullpuz.get_tree_hash(), uint64(amount))
@@ -1364,7 +1349,7 @@ class NFTWallet:
         change: uint64 = uint64(spend_value - total_amount)
         if xch_change_ph is None:
             xch_change_ph = await self.standard_wallet.get_new_puzzlehash()
-        xch_payment = Payment(xch_change_ph, change, [xch_change_ph])
+        xch_payment = CreateCoin(xch_change_ph, change, [xch_change_ph])
 
         xch_coins_iter = iter(xch_coins)
         xch_coin = next(xch_coins_iter)
@@ -1409,7 +1394,7 @@ class NFTWallet:
             ),
         )
         did_inner_sol: Program = Program.to([1, did_p2_solution])
-        did_full_puzzle: Program = chia.wallet.singleton.create_singleton_puzzle(
+        did_full_puzzle: Program = create_singleton_puzzle(
             innerpuz,
             did_wallet.did_info.origin_coin.name(),
         )
@@ -1521,11 +1506,11 @@ class NFTWallet:
         # Loop to create each intermediate coin, launcher, eve and (optional) transfer spends
         for mint_number in range(mint_number_start, mint_number_end):
             # Create  the puzzle, solution and coin spend for the intermediate launcher
-            intermediate_launcher_puz = nft_puzzles.INTERMEDIATE_LAUNCHER_MOD.curry(
-                nft_puzzles.LAUNCHER_PUZZLE_HASH, mint_number, mint_total
+            intermediate_launcher_puz = did_wallet_puzzles.INTERMEDIATE_LAUNCHER_MOD.curry(
+                SINGLETON_LAUNCHER_PUZZLE_HASH, mint_number, mint_total
             )
             intermediate_launcher_ph = intermediate_launcher_puz.get_tree_hash()
-            primaries.append(Payment(intermediate_launcher_ph, uint64(1), [intermediate_launcher_ph]))
+            primaries.append(CreateCoin(intermediate_launcher_ph, uint64(1), [intermediate_launcher_ph]))
             intermediate_launcher_sol = Program.to([])
             intermediate_launcher_coin = Coin(funding_coin.name(), intermediate_launcher_ph, uint64(1))
             intermediate_launcher_coin_spend = make_spend(
@@ -1540,7 +1525,7 @@ class NFTWallet:
             coin_announcements.add(std_hash(intermediate_launcher_coin.name() + intermediate_announcement_message))
 
             # Create the launcher coin, and add its id to a list to be asserted in the XCH spend
-            launcher_coin = Coin(intermediate_launcher_coin.name(), nft_puzzles.LAUNCHER_PUZZLE_HASH, amount)
+            launcher_coin = Coin(intermediate_launcher_coin.name(), SINGLETON_LAUNCHER_PUZZLE_HASH, amount)
             launcher_ids.append(launcher_coin.name())
 
             # Grab the metadata from metadata_list. The index for metadata_list
@@ -1556,7 +1541,7 @@ class NFTWallet:
                 metadata["royalty_pc"],
                 royalty_puzzle_hash=metadata["royalty_ph"],
             )
-            eve_fullpuz = nft_puzzles.create_full_puzzle(
+            eve_fullpuz = nft_puzzle_utils.create_full_puzzle(
                 launcher_coin.name(), metadata["program"], NFT_METADATA_UPDATER.get_tree_hash(), inner_puzzle
             )
 
@@ -1566,7 +1551,7 @@ class NFTWallet:
 
             genesis_launcher_solution = Program.to([eve_fullpuz.get_tree_hash(), amount, []])
 
-            launcher_cs = make_spend(launcher_coin, nft_puzzles.LAUNCHER_PUZZLE, genesis_launcher_solution)
+            launcher_cs = make_spend(launcher_coin, SINGLETON_LAUNCHER_PUZZLE, genesis_launcher_solution)
             launcher_spends.append(launcher_cs)
 
             eve_coin = Coin(launcher_coin.name(), eve_fullpuz.get_tree_hash(), uint64(amount))
@@ -1622,7 +1607,7 @@ class NFTWallet:
         xch_spends = []
         if xch_change_ph is None:
             xch_change_ph = await self.standard_wallet.get_new_puzzlehash()
-        xch_payment = Payment(xch_change_ph, change, [xch_change_ph])
+        xch_payment = CreateCoin(xch_change_ph, change, [xch_change_ph])
 
         first = True
         for xch_coin in xch_coins:

chia/wallet/nft_wallet/ownership_outer_puzzle.py

@@ -3,21 +3,17 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Callable, Optional, Union
 
+from chia_rs.sized_bytes import bytes32
 from clvm_tools.binutils import disassemble
 
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.wallet.nft_wallet.nft_puzzles import NFT_OWNERSHIP_LAYER
 from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
 
-OWNERSHIP_LAYER_MOD = load_clvm_maybe_recompile(
-    "nft_ownership_layer.clsp", package_or_requirement="chia.wallet.nft_wallet.puzzles"
-)
-
 
 def match_ownership_layer_puzzle(puzzle: UncurriedPuzzle) -> tuple[bool, list[Program]]:
-    if puzzle.mod == OWNERSHIP_LAYER_MOD:
+    if puzzle.mod == NFT_OWNERSHIP_LAYER:
         return True, list(puzzle.args.as_iter())
     return False, []
 
@@ -25,7 +21,7 @@ def match_ownership_layer_puzzle(puzzle: UncurriedPuzzle) -> tuple[bool, list[Pr
 def puzzle_for_ownership_layer(
     current_owner: Union[Program, bytes], transfer_program: Program, inner_puzzle: Program
 ) -> Program:
-    return OWNERSHIP_LAYER_MOD.curry(OWNERSHIP_LAYER_MOD.get_tree_hash(), current_owner, transfer_program, inner_puzzle)
+    return NFT_OWNERSHIP_LAYER.curry(NFT_OWNERSHIP_LAYER.get_tree_hash(), current_owner, transfer_program, inner_puzzle)
 
 
 def solution_for_ownership_layer(inner_solution: Program) -> Program:

chia/wallet/nft_wallet/singleton_outer_puzzle.py

@@ -3,11 +3,12 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Callable, Optional
 
+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
-from chia.util.ints import uint64
 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 (

chia/wallet/nft_wallet/transfer_program_puzzle.py

@@ -3,29 +3,25 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Callable, Optional
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint16
+
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.ints import uint16
+from chia.wallet.nft_wallet.nft_puzzles import NFT_TRANSFER_PROGRAM_DEFAULT
 from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.puzzles.singleton_top_layer_v1_1 import SINGLETON_LAUNCHER_HASH, SINGLETON_MOD_HASH
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle
 
-TRANSFER_PROGRAM_MOD = load_clvm_maybe_recompile(
-    "nft_ownership_transfer_program_one_way_claim_with_royalties.clsp",
-    package_or_requirement="chia.wallet.nft_wallet.puzzles",
-)
-
 
 def match_transfer_program_puzzle(puzzle: UncurriedPuzzle) -> tuple[bool, list[Program]]:
-    if puzzle.mod == TRANSFER_PROGRAM_MOD:
+    if puzzle.mod == NFT_TRANSFER_PROGRAM_DEFAULT:
         return True, list(puzzle.args.as_iter())
     return False, []
 
 
 def puzzle_for_transfer_program(launcher_id: bytes32, royalty_puzzle_hash: bytes32, percentage: uint16) -> Program:
     singleton_struct = Program.to((SINGLETON_MOD_HASH, (launcher_id, SINGLETON_LAUNCHER_HASH)))
-    return TRANSFER_PROGRAM_MOD.curry(
+    return NFT_TRANSFER_PROGRAM_DEFAULT.curry(
         singleton_struct,
         royalty_puzzle_hash,
         percentage,

chia/wallet/nft_wallet/uncurry_nft.py

@@ -4,20 +4,18 @@ import logging
 from dataclasses import dataclass
 from typing import Optional, TypeVar
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint16
+
 from chia.protocols.wallet_protocol import CoinState
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_spend import CoinSpend
-from chia.util.ints import uint16
 from chia.util.streamable import Streamable, streamable
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
+from chia.wallet.nft_wallet.nft_puzzles import NFT_OWNERSHIP_LAYER
+from chia.wallet.nft_wallet.nft_puzzles import NFT_STATE_LAYER_MOD as NFT_MOD
+from chia.wallet.singleton import SINGLETON_TOP_LAYER_MOD
 
 log = logging.getLogger(__name__)
-SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clsp")
-NFT_MOD = load_clvm_maybe_recompile("nft_state_layer.clsp", package_or_requirement="chia.wallet.nft_wallet.puzzles")
-NFT_OWNERSHIP_LAYER = load_clvm_maybe_recompile(
-    "nft_ownership_layer.clsp", package_or_requirement="chia.wallet.nft_wallet.puzzles"
-)
 
 _T_UncurriedNFT = TypeVar("_T_UncurriedNFT", bound="UncurriedNFT")
 

chia/wallet/notification_manager.py

@@ -4,14 +4,14 @@ import logging
 from typing import Any, Optional
 
 from chia_rs import G2Element
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 
 from chia.protocols.wallet_protocol import CoinState
 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.util.db_wrapper import DBWrapper2
-from chia.util.ints import uint32, uint64
 from chia.wallet.conditions import AssertCoinAnnouncement, Condition
 from chia.wallet.notification_store import Notification, NotificationStore
 from chia.wallet.util.compute_memos import compute_memos_for_spend
@@ -101,13 +101,13 @@ class NotificationManager:
         )
         extra_spend_bundle = WalletSpendBundle([notification_spend], G2Element())
         await self.wallet_state_manager.main_wallet.generate_signed_transaction(
-            amount,
-            notification_hash,
+            [amount],
+            [notification_hash],
             action_scope,
             fee,
             coins=coins,
             origin_id=origin_coin,
-            memos=[target, msg],
+            memos=[[target, msg]],
             extra_conditions=(
                 *extra_conditions,
                 AssertCoinAnnouncement(asserted_id=notification_coin.name(), asserted_msg=b""),

chia/wallet/notification_store.py

@@ -5,9 +5,10 @@ import logging
 import sqlite3
 from typing import Optional
 
-from chia.types.blockchain_format.sized_bytes import bytes32
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
+
 from chia.util.db_wrapper import DBWrapper2
-from chia.util.ints import uint32, uint64
 from chia.util.streamable import Streamable, streamable
 
 

chia/wallet/outer_puzzles.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 from enum import Enum
 from typing import Optional
 
+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.cat_wallet.cat_outer_puzzle import CATOuterPuzzle
 from chia.wallet.driver_protocol import DriverProtocol
 from chia.wallet.nft_wallet.metadata_outer_puzzle import MetadataOuterPuzzle

chia/wallet/puzzles/clawback/drivers.py

@@ -3,29 +3,42 @@ from __future__ import annotations
 import logging
 from typing import Any, Optional, Union
 
+from chia_puzzles_py.programs import (
+    AUGMENTED_CONDITION as AUGMENTED_CONDITION_BYTES,
+)
+from chia_puzzles_py.programs import (
+    AUGMENTED_CONDITION_HASH as AUGMENTED_CONDITION_HASH_BYTES,
+)
+from chia_puzzles_py.programs import (
+    P2_1_OF_N as P2_1_OF_N_BYTES,
+)
+from chia_puzzles_py.programs import (
+    P2_PUZZLE_HASH,
+    P2_PUZZLE_HASH_HASH,
+)
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
+
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 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.condition_opcodes import ConditionOpcode
 from chia.util.condition_tools import conditions_for_solution
-from chia.util.ints import uint64
 from chia.util.streamable import VersionedBlob
 from chia.wallet.puzzles.clawback.metadata import ClawbackMetadata
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import MOD
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle
 from chia.wallet.util.curry_and_treehash import calculate_hash_of_quoted_mod_hash, curry_and_treehash
 from chia.wallet.util.merkle_tree import MerkleTree
 from chia.wallet.util.wallet_types import RemarkDataType
 
-P2_1_OF_N = load_clvm_maybe_recompile("p2_1_of_n.clsp")
-P2_CURRIED_PUZZLE_MOD = load_clvm_maybe_recompile("p2_puzzle_hash.clsp")
-P2_CURRIED_PUZZLE_MOD_HASH_QUOTED = calculate_hash_of_quoted_mod_hash(P2_CURRIED_PUZZLE_MOD.get_tree_hash())
-AUGMENTED_CONDITION = load_clvm_maybe_recompile("augmented_condition.clsp")
-AUGMENTED_CONDITION_HASH = AUGMENTED_CONDITION.get_tree_hash()
+P2_1_OF_N = Program.from_bytes(P2_1_OF_N_BYTES)
+P2_CURRIED_PUZZLE_MOD = Program.from_bytes(P2_PUZZLE_HASH)
+P2_CURRIED_PUZZLE_MOD_HASH_QUOTED = calculate_hash_of_quoted_mod_hash(P2_PUZZLE_HASH_HASH)
+AUGMENTED_CONDITION = Program.from_bytes(AUGMENTED_CONDITION_BYTES)
+AUGMENTED_CONDITION_HASH = bytes32(AUGMENTED_CONDITION_HASH_BYTES)
 log = logging.getLogger(__name__)
 
 

chia/wallet/puzzles/clawback/metadata.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 from dataclasses import dataclass
 from enum import IntEnum
 
-from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.ints import uint16, uint64
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint16, uint64
+
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.wallet_puzzle_store import WalletPuzzleStore
 

chia/wallet/puzzles/clawback/puzzle_decorator.py

@@ -2,12 +2,13 @@ from __future__ import annotations
 
 from typing import Any
 
+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.types.condition_opcodes import ConditionOpcode
-from chia.util.ints import uint64
 from chia.util.streamable import VersionedBlob
-from chia.wallet.payment import Payment
+from chia.wallet.conditions import CreateCoin
 from chia.wallet.puzzles.clawback.drivers import create_merkle_puzzle
 from chia.wallet.puzzles.clawback.metadata import ClawbackMetadata, ClawbackVersion
 from chia.wallet.util.wallet_types import RemarkDataType
@@ -41,7 +42,7 @@ class ClawbackPuzzleDecorator:
         )
 
     def solve(
-        self, inner_puzzle: Program, primaries: list[Payment], inner_solution: Program
+        self, inner_puzzle: Program, primaries: list[CreateCoin], inner_solution: Program
     ) -> tuple[Program, Program]:
         # Append REMARK condition [1, "CLAWBACK", TIME_LOCK, SENDER_PUZHSAH, RECIPIENT_PUZHSAH]
         if len(primaries) == 1:

chia/wallet/puzzles/deployed_puzzle_hashes.json

@@ -7,16 +7,6 @@
   "covenant_layer": "b982796850336aabf9ab17c3f21e299f0c633444117ab5e9ebeafadf1860d9fc",
   "create_nft_launcher_from_did": "7a32d2d9571d3436791c0ad3d7fcfdb9c43ace2b0f0ff13f98d29f0cc093f445",
   "credential_restriction": "2fdfc1f058cfd65e7ec4e253bfeb394da163ecd0036f508df8629b0a2b8fde96",
-  "dao_cat_eve": "488f55bedaca5a599544dfd5ab341e2e5c7e6fca67d9b98a3d856f876c52f53e",
-  "dao_cat_launcher": "a01a838d18d4e031e937c79fa3f80f213fa00a3e64af6c16a1f137770cd3a567",
-  "dao_finished_state": "694c99e1fb07671771bbca3d110880693a9ecc37a6529891ec979d0f3e760eba",
-  "dao_lockup": "d6215f0916715a69fbbf2d1a679f437fde81787adeb90c666642fb9c2deff7ce",
-  "dao_proposal": "fe6d5c0373c1750598d137ce50b5b025a203655ccab4ab3329315abad49c3586",
-  "dao_proposal_timer": "1acd912fca662d1474f7a6c762280fc1430875bef518883387086c1125027526",
-  "dao_proposal_validator": "92209b0f7efb2dbaaaa3aab94dcadcafa9d008d39661763841c7d92065b3fd34",
-  "dao_spend_p2_singleton_v2": "7bc8942159e600f56a87e1d9c059c8705307ec2fb996a949503298dedfed00be",
-  "dao_treasury": "637d78acd395b6bb03211bcfc5f5f2e878cba2d62b2f53871d49a8b928411b19",
-  "dao_update_proposal": "fc032384cfece9b542c3e1ea77ba119fb1013a3d74b622302c0b670447e4343d",
   "decompress_coin_spend_entry": "9d98ed08770d31be4bd1bde4705dab388db5e7e9c349f5a76fc3c347aa3a0b79",
   "decompress_coin_spend_entry_with_prefix": "92aa4bc8060a8836355a1884075141b4791ce1b67ae6092bb166b2845954bc89",
   "decompress_puzzle": "fe94c58f1117afe315e0450daca1c62460ec1a1c439cd4018d79967a5d7d1370",

chia/wallet/puzzles/p2_conditions.py

@@ -12,10 +12,11 @@ the doctor ordered.
 
 from __future__ import annotations
 
+from chia_puzzles_py.programs import P2_CONDITIONS
+
 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_conditions.clsp")
+MOD = Program.from_bytes(P2_CONDITIONS)
 
 
 def puzzle_for_conditions(conditions) -> Program:

chia/wallet/puzzles/p2_delegated_conditions.py

@@ -7,10 +7,11 @@ is returned literally.
 
 from __future__ import annotations
 
+from chia_puzzles_py.programs import P2_DELEGATED_CONDITIONS
+
 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_delegated_conditions.clsp")
+MOD = Program.from_bytes(P2_DELEGATED_CONDITIONS)
 
 
 def puzzle_for_pk(public_key: Program) -> Program: