chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/nft_wallet/ownership_outer_puzzle.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Optional, Union
+
+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.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:
+        return True, list(puzzle.args.as_iter())
+    return False, []
+
+
+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)
+
+
+def solution_for_ownership_layer(inner_solution: Program) -> Program:
+    return Program.to([inner_solution])
+
+
+@dataclass(frozen=True)
+class OwnershipOuterPuzzle:
+    _match: Callable[[UncurriedPuzzle], Optional[PuzzleInfo]]
+    _construct: Callable[[PuzzleInfo, Program], Program]
+    _solve: Callable[[PuzzleInfo, Solver, Program, Program], Program]
+    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle], Optional[Program]]
+    _get_inner_solution: Callable[[PuzzleInfo, Program], Optional[Program]]
+
+    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+        matched, curried_args = match_ownership_layer_puzzle(puzzle)
+        if matched:
+            _, current_owner, transfer_program, inner_puzzle = curried_args
+            owner_bytes: bytes = current_owner.as_python()
+            tp_match: Optional[PuzzleInfo] = self._match(uncurry_puzzle(transfer_program))
+            constructor_dict = {
+                "type": "ownership",
+                "owner": "()" if owner_bytes == b"" else "0x" + owner_bytes.hex(),
+                "transfer_program": (disassemble(transfer_program) if tp_match is None else tp_match.info),
+            }
+            next_constructor = self._match(uncurry_puzzle(inner_puzzle))
+            if next_constructor is not None:
+                constructor_dict["also"] = next_constructor.info
+            return PuzzleInfo(constructor_dict)
+        else:
+            return None
+
+    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+        return None
+
+    def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:
+        also = constructor.also()
+        if also is not None:
+            inner_puzzle = self._construct(also, inner_puzzle)
+        transfer_program_info: Union[PuzzleInfo, Program] = constructor["transfer_program"]
+        if isinstance(transfer_program_info, Program):
+            transfer_program: Program = transfer_program_info
+        else:
+            transfer_program = self._construct(transfer_program_info, inner_puzzle)
+        return puzzle_for_ownership_layer(constructor["owner"], transfer_program, inner_puzzle)
+
+    def get_inner_puzzle(self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle) -> Optional[Program]:
+        matched, curried_args = match_ownership_layer_puzzle(puzzle_reveal)
+        if matched:
+            _, _, _, inner_puzzle = curried_args
+            also = constructor.also()
+            if also is not None:
+                deep_inner_puzzle: Optional[Program] = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle))
+                return deep_inner_puzzle
+            else:
+                return inner_puzzle
+        else:
+            raise ValueError("This driver is not for the specified puzzle reveal")
+
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+        my_inner_solution: Program = solution.first()
+        also = constructor.also()
+        if also:
+            deep_inner_solution: Optional[Program] = self._get_inner_solution(also, my_inner_solution)
+            return deep_inner_solution
+        else:
+            return my_inner_solution
+
+    def solve(self, constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program) -> Program:
+        also = constructor.also()
+        if also is not None:
+            inner_solution = self._solve(also, solver, inner_puzzle, inner_solution)
+        return solution_for_ownership_layer(inner_solution)

chia/wallet/nft_wallet/puzzles/create_nft_launcher_from_did.clsp

@@ -0,0 +1,6 @@
+(mod (LAUNCHER_PH MINT_NUMBER MINT_TOTAL)
+  (include condition_codes.clib)
+  (list
+    (list CREATE_COIN LAUNCHER_PH 1)
+  (list CREATE_COIN_ANNOUNCEMENT (sha256 MINT_NUMBER MINT_TOTAL)))
+)

chia/wallet/nft_wallet/puzzles/create_nft_launcher_from_did.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ff04ffff04ff05ffff01ff01808080ffff04ffff04ff06ffff04ffff0bff0bff1780ff808080ff808080ffff04ffff01ff333cff018080

chia/wallet/nft_wallet/puzzles/nft_intermediate_launcher.clsp

@@ -0,0 +1,6 @@
+(mod (LAUNCHER_PH MINT_NUMBER MINT_TOTAL)
+  (include condition_codes.clib)
+  (list
+    (list CREATE_COIN LAUNCHER_PH 1)
+  (list CREATE_COIN_ANNOUNCEMENT (sha256 MINT_NUMBER MINT_TOTAL)))
+)

chia/wallet/nft_wallet/puzzles/nft_intermediate_launcher.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ff04ffff04ff05ffff01ff01808080ffff04ffff04ff06ffff04ffff0bff0bff1780ff808080ff808080ffff04ffff01ff333cff018080

chia/wallet/nft_wallet/puzzles/nft_metadata_updater_default.clsp

@@ -0,0 +1,30 @@
+(mod (CURRENT_METADATA METADATA_UPDATER_PUZZLE_HASH (key . new_url))
+
+  ; METADATA and METADATA_UPDATER_PUZZLE_HASH are passed in as truths from the layer above
+  ; This program returns ((new_metadata new_metadata_updater_puzhash) conditions)
+
+  ; Add uri to a field
+  (defun add_url (METADATA key new_url)
+    (if METADATA
+        (if (= (f (f METADATA)) key)
+            (c (c key (c new_url (r (f METADATA)))) (r METADATA))
+            (c (f METADATA) (add_url (r METADATA) key new_url))
+        )
+        ()
+    )
+  )
+  ; main
+  ; returns ((new_metadata new_metadata_updater_puzhash) conditions)
+  (list
+    (list
+      (if (all key new_url)
+          (if (any (= key "mu") (= key "lu") (= key "u"))
+              (add_url CURRENT_METADATA key new_url)
+              CURRENT_METADATA
+          )
+          CURRENT_METADATA
+      )
+    METADATA_UPDATER_PUZZLE_HASH)
+    0
+  )
+)

chia/wallet/nft_wallet/puzzles/nft_metadata_updater_default.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ffff02ffff03ffff22ff27ff3780ffff01ff02ffff03ffff21ffff09ff27ffff01826d7580ffff09ff27ffff01826c7580ffff09ff27ffff01758080ffff01ff02ff02ffff04ff02ffff04ff05ffff04ff27ffff04ff37ff808080808080ffff010580ff0180ffff010580ff0180ffff04ff0bff808080ffff01ff808080ffff04ffff01ff02ffff03ff05ffff01ff02ffff03ffff09ff11ff0b80ffff01ff04ffff04ff0bffff04ff17ff198080ff0d80ffff01ff04ff09ffff02ff02ffff04ff02ffff04ff0dffff04ff0bffff04ff17ff8080808080808080ff0180ff8080ff0180ff018080

chia/wallet/nft_wallet/puzzles/nft_metadata_updater_updateable.clsp

@@ -0,0 +1,28 @@
+(mod (CURRENT_METADATA METADATA_UPDATER_PUZZLE_HASH solution)
+
+  ; solution is (new_url new_metadata_updater_puzhash)
+
+  ; METADATA and METADATA_UPDATER_PUZZLE_HASH are passed in as truths from the layer above
+  ; This program returns ((new_metadata new_metadata_updater_puzhash) conditions)
+
+  ; NOTE THIS PROGRAM IS FOR TESTING ONLY - USE IN DEPLOYMENT AT YOUR OWN PERIL
+
+  ; once we find 'u' we don't need to continue looping
+  (defun add_url (METADATA new_url)
+    (if METADATA
+        (if (= (f (f METADATA)) 'u')
+            (c (c 'u' (c new_url (r (f METADATA)))) (r METADATA))
+            (c (f METADATA) (add_url (r METADATA) new_url))
+        )
+        ()
+    )
+  )
+
+  (defun-inline assert_bytes32 (value)
+    (= (strlen value) 32)
+  )
+
+  ; main
+  ; returns ((new_metadata new_metadata_updater_puzhash) conditions)
+  (list (list (if (f solution) (add_url CURRENT_METADATA (f solution)) CURRENT_METADATA) (if (assert_bytes32 (f (r solution))) (f (r solution)) METADATA_UPDATER_PUZZLE_HASH)) 0)
+)

chia/wallet/nft_wallet/puzzles/nft_metadata_updater_updateable.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ffff02ffff03ff27ffff01ff02ff02ffff04ff02ffff04ff05ffff04ff27ff8080808080ffff010580ff0180ffff04ffff02ffff03ffff09ffff0dff5780ffff012080ffff0157ffff010b80ff0180ff808080ffff01ff808080ffff04ffff01ff02ffff03ff05ffff01ff02ffff03ffff09ff11ffff017580ffff01ff04ffff04ffff0175ffff04ff0bff198080ff0d80ffff01ff04ff09ffff02ff02ffff04ff02ffff04ff0dffff04ff0bff80808080808080ff0180ff8080ff0180ff018080

chia/wallet/nft_wallet/puzzles/nft_ownership_layer.clsp

@@ -0,0 +1,100 @@
+(mod (
+    NFT_OWNERSHIP_LAYER_MOD_HASH
+    CURRENT_OWNER
+    TRANSFER_PROGRAM
+    INNER_PUZZLE
+    inner_solution
+  )
+
+  (include condition_codes.clib)
+  (include curry-and-treehash.clib)
+  (include utility_macros.clib)
+
+  (defconstant NEW_OWNER_CONDITION -10)
+  (defconstant ANNOUNCEMENT_PREFIX 0xad4c)  ; first 2 bytes of (sha256 "Ownership Layer")
+
+  (defun-inline nft_ownership_layer_puzzle_hash (NFT_OWNERSHIP_LAYER_MOD_HASH new_owner TRANSFER_PROGRAM inner_puzzle_hash)
+    (puzzle-hash-of-curried-function NFT_OWNERSHIP_LAYER_MOD_HASH
+      inner_puzzle_hash
+      (sha256tree TRANSFER_PROGRAM)
+      (sha256 ONE new_owner)
+      (sha256 ONE NFT_OWNERSHIP_LAYER_MOD_HASH)
+    )
+  )
+
+  (defun construct_end_conditions (NFT_OWNERSHIP_LAYER_MOD_HASH TRANSFER_PROGRAM odd_args (new_owner new_tp conditions))
+    (c
+      (c
+        CREATE_COIN
+        (c
+          (nft_ownership_layer_puzzle_hash NFT_OWNERSHIP_LAYER_MOD_HASH new_owner (if new_tp new_tp TRANSFER_PROGRAM) (f odd_args))
+          (r odd_args)
+        )
+      )
+      conditions
+    )
+  )
+
+  (defun wrap_odd_create_coins (NFT_OWNERSHIP_LAYER_MOD_HASH TRANSFER_PROGRAM CURRENT_OWNER all_conditions conditions odd_args tp_output)
+    (if conditions
+        (if (= (f (f conditions)) CREATE_COIN)
+            (if (= (logand (f (r (r (f conditions))))) ONE)
+                (assert (not odd_args)
+                  ; then
+                  (wrap_odd_create_coins NFT_OWNERSHIP_LAYER_MOD_HASH TRANSFER_PROGRAM CURRENT_OWNER all_conditions (r conditions) (r (f conditions)) tp_output)
+                )
+                (c (f conditions) (wrap_odd_create_coins NFT_OWNERSHIP_LAYER_MOD_HASH TRANSFER_PROGRAM CURRENT_OWNER all_conditions (r conditions) odd_args tp_output))
+            )
+            (if (= (f (f conditions)) NEW_OWNER_CONDITION)
+                (assert (not tp_output)
+                  (c
+                    (list CREATE_PUZZLE_ANNOUNCEMENT (concat ANNOUNCEMENT_PREFIX (sha256tree (r (f conditions)))))
+                    (wrap_odd_create_coins NFT_OWNERSHIP_LAYER_MOD_HASH TRANSFER_PROGRAM CURRENT_OWNER all_conditions (r conditions) odd_args (a TRANSFER_PROGRAM (list CURRENT_OWNER all_conditions (r (f conditions)))))
+                  )
+                )
+                (if (= (f (f conditions)) CREATE_PUZZLE_ANNOUNCEMENT)
+                    (assert (not (and
+                        (= 34 (strlen (f (r (f conditions)))))
+                        (= (substr (f (r (f conditions))) 0 2) ANNOUNCEMENT_PREFIX)  ; lazy eval
+                      ))
+                      ; then
+                      (c (f conditions) (wrap_odd_create_coins NFT_OWNERSHIP_LAYER_MOD_HASH TRANSFER_PROGRAM CURRENT_OWNER all_conditions (r conditions) odd_args tp_output))
+                    )
+                    (c (f conditions) (wrap_odd_create_coins NFT_OWNERSHIP_LAYER_MOD_HASH TRANSFER_PROGRAM CURRENT_OWNER all_conditions (r conditions) odd_args tp_output))
+                )
+            )
+        )
+        ; odd_args is guaranteed to not be nil or else we'll have a path into atom error
+        (construct_end_conditions NFT_OWNERSHIP_LAYER_MOD_HASH TRANSFER_PROGRAM odd_args
+          (if tp_output
+              tp_output
+              (a TRANSFER_PROGRAM (list CURRENT_OWNER all_conditions ()))
+          )
+        )
+    )
+  )
+
+  (defun main (
+      NFT_OWNERSHIP_LAYER_MOD_HASH
+      TRANSFER_PROGRAM
+      CURRENT_OWNER
+      conditions
+    )
+    (wrap_odd_create_coins
+      NFT_OWNERSHIP_LAYER_MOD_HASH
+      TRANSFER_PROGRAM
+      CURRENT_OWNER
+      conditions
+      conditions
+      () ()
+    )
+  )
+
+  ; main
+  (main
+    NFT_OWNERSHIP_LAYER_MOD_HASH
+    TRANSFER_PROGRAM
+    CURRENT_OWNER
+    (a INNER_PUZZLE inner_solution)
+  )
+)

chia/wallet/nft_wallet/puzzles/nft_ownership_layer.clsp.hex

@@ -0,0 +1 @@
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

chia/wallet/nft_wallet/puzzles/nft_ownership_transfer_program_one_way_claim_with_royalties.clsp

@@ -0,0 +1,78 @@
+(mod
+  (
+    SINGLETON_STRUCT
+    ROYALTY_ADDRESS
+    TRADE_PRICE_PERCENTAGE
+    Current_Owner  ; Truth
+    conditions  ; Truth
+    solution  ; created from the NFT's inner puzzle - solution is (new_owner trade_prices_list new_did_inner_hash)
+  )
+
+  ; This is a transfer program - which must return (new_owner, Optional[new_transfer_program], conditions)
+
+  (include condition_codes.clib)
+  (include curry-and-treehash.clib)
+
+  (defconstant TEN_THOUSAND 10000)
+
+  ;; return the full puzzlehash for a singleton with the innerpuzzle curried in
+  ; puzzle-hash-of-curried-function is imported from curry-and-treehash.clib
+  (defun-inline calculate_full_puzzle_hash (SINGLETON_STRUCT inner_puzzle_hash)
+    (puzzle-hash-of-curried-function (f SINGLETON_STRUCT)
+      inner_puzzle_hash
+      (sha256tree SINGLETON_STRUCT)
+    )
+  )
+
+  ; Given a singleton ID, generate the singleton struct
+  (defun-inline get_singleton_struct (SINGLETON_STRUCT singleton_id)
+    (c (f SINGLETON_STRUCT) (c singleton_id (r (r SINGLETON_STRUCT))))
+  )
+
+  (defun-inline calculate_percentage (amount percentage)
+    (f (divmod (* amount percentage) TEN_THOUSAND))
+  )
+
+  ; Loop of the trade prices list and either assert a puzzle announcement or generate xch
+  (defun parse_trade_prices_list (ROYALTY_ADDRESS TRADE_PRICE_PERCENTAGE trade_prices_list my_nft_id)
+    (if trade_prices_list
+        (c
+          (list
+            ASSERT_PUZZLE_ANNOUNCEMENT
+            (sha256
+              (f (r (f trade_prices_list)))
+              (sha256tree (c my_nft_id (list (list ROYALTY_ADDRESS (calculate_percentage (f (f trade_prices_list)) TRADE_PRICE_PERCENTAGE) (list ROYALTY_ADDRESS)))))
+            )
+          )
+          (parse_trade_prices_list ROYALTY_ADDRESS TRADE_PRICE_PERCENTAGE (r trade_prices_list) my_nft_id)
+        )
+        ()
+    )
+  )
+
+  ; main
+  ; Returning (new_owner new_transfer_program conditions)
+  ; solution is (new_owner trade_prices_list new_did_inner_hash)
+  (if solution
+      (list
+        (f solution)
+        0
+        (if (all (f solution) (not (= (f solution) Current_Owner)))
+            (c
+              (list
+                ASSERT_PUZZLE_ANNOUNCEMENT
+                (sha256
+                  (calculate_full_puzzle_hash (get_singleton_struct SINGLETON_STRUCT (f solution)) (f (r (r solution))))
+                  (f (r SINGLETON_STRUCT))
+                )
+              )
+              (parse_trade_prices_list ROYALTY_ADDRESS TRADE_PRICE_PERCENTAGE (f (r solution)) (f (r SINGLETON_STRUCT)))
+            )
+            (parse_trade_prices_list ROYALTY_ADDRESS TRADE_PRICE_PERCENTAGE (f (r solution)) (f (r SINGLETON_STRUCT)))
+        )
+      )
+      (list Current_Owner () ())
+  )
+
+
+)

chia/wallet/nft_wallet/puzzles/nft_ownership_transfer_program_one_way_claim_with_royalties.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ffff03ff81bfffff01ff04ff82013fffff04ff80ffff04ffff02ffff03ffff22ff82013fffff20ffff09ff82013fff2f808080ffff01ff04ffff04ff10ffff04ffff0bffff02ff2effff04ff02ffff04ff09ffff04ff8205bfffff04ffff02ff3effff04ff02ffff04ffff04ff09ffff04ff82013fff1d8080ff80808080ff808080808080ff1580ff808080ffff02ff16ffff04ff02ffff04ff0bffff04ff17ffff04ff8202bfffff04ff15ff8080808080808080ffff01ff02ff16ffff04ff02ffff04ff0bffff04ff17ffff04ff8202bfffff04ff15ff8080808080808080ff0180ff80808080ffff01ff04ff2fffff01ff80ff80808080ff0180ffff04ffff01ffffff3f02ff04ff0101ffff822710ff02ff02ffff03ff05ffff01ff02ff3affff04ff02ffff04ff0dffff04ffff0bff2affff0bff2cff1480ffff0bff2affff0bff2affff0bff2cff3c80ff0980ffff0bff2aff0bffff0bff2cff8080808080ff8080808080ffff010b80ff0180ffff02ffff03ff17ffff01ff04ffff04ff10ffff04ffff0bff81a7ffff02ff3effff04ff02ffff04ffff04ff2fffff04ffff04ff05ffff04ffff05ffff14ffff12ff47ff0b80ff128080ffff04ffff04ff05ff8080ff80808080ff808080ff8080808080ff808080ffff02ff16ffff04ff02ffff04ff05ffff04ff0bffff04ff37ffff04ff2fff8080808080808080ff8080ff0180ffff0bff2affff0bff2cff1880ffff0bff2affff0bff2affff0bff2cff3c80ff0580ffff0bff2affff02ff3affff04ff02ffff04ff07ffff04ffff0bff2cff2c80ff8080808080ffff0bff2cff8080808080ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff3effff04ff02ffff04ff09ff80808080ffff02ff3effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/wallet/nft_wallet/puzzles/nft_state_layer.clsp

@@ -0,0 +1,74 @@
+(mod (
+    NFT_STATE_LAYER_MOD_HASH
+    METADATA
+    METADATA_UPDATER_PUZZLE_HASH
+    INNER_PUZZLE
+    inner_solution
+  )
+
+  (include condition_codes.clib)
+  (include curry-and-treehash.clib)
+  (include utility_macros.clib)
+
+  (defun-inline nft_state_layer_puzzle_hash (NFT_STATE_LAYER_MOD_HASH METADATA METADATA_UPDATER_PUZZLE_HASH inner_puzzle_hash)
+    (puzzle-hash-of-curried-function NFT_STATE_LAYER_MOD_HASH
+      inner_puzzle_hash
+      (sha256 ONE METADATA_UPDATER_PUZZLE_HASH)
+      (sha256tree METADATA)
+      (sha256 ONE NFT_STATE_LAYER_MOD_HASH)
+    )
+  )
+
+
+  ; this function does two things - it wraps the odd value create coins, and it also filters out all negative conditions
+  ; odd_coin_params is (puzhash amount ...)
+  ; new_metadata_info is ((METADATA METADATA_UPDATER_PUZZLE_HASH) conditions)
+  (defun wrap_odd_create_coins (NFT_STATE_LAYER_MOD_HASH conditions odd_coin_params new_metadata_info metadata_seen)
+    (if conditions
+        (if (= (f (f conditions)) CREATE_COIN)
+            (if (logand (f (r (r (f conditions)))) ONE)
+                (assert (not odd_coin_params)
+                  (wrap_odd_create_coins NFT_STATE_LAYER_MOD_HASH (r conditions) (r (f conditions)) new_metadata_info metadata_seen)
+                )
+                (c (f conditions) (wrap_odd_create_coins NFT_STATE_LAYER_MOD_HASH (r conditions) odd_coin_params new_metadata_info metadata_seen))
+            )
+            (if (= (f (f conditions)) -24)
+                (wrap_odd_create_coins NFT_STATE_LAYER_MOD_HASH (r conditions) odd_coin_params
+                  (assert (all
+                      (= (sha256tree (f (r (f conditions)))) (f (r (f new_metadata_info))))
+                      (not metadata_seen)
+                    )
+                    ; then
+                    (a (f (r (f conditions))) (list (f (f new_metadata_info)) (f (r (f new_metadata_info))) (f (r (r (f conditions))))))
+                  )
+                  ONE  ; the metadata update has been seen now
+                )
+                (c (f conditions) (wrap_odd_create_coins NFT_STATE_LAYER_MOD_HASH (r conditions) odd_coin_params new_metadata_info metadata_seen))
+            )
+        )
+        (c
+          (c CREATE_COIN
+            (c
+              (nft_state_layer_puzzle_hash
+                NFT_STATE_LAYER_MOD_HASH
+                (f (f new_metadata_info))
+                (f (r (f new_metadata_info)))
+                (f odd_coin_params)  ; metadata updater solution
+              )
+              (r odd_coin_params)
+            )
+          )
+          (f (r new_metadata_info))  ; metadata_updater conditions
+        )
+    )
+  )
+
+  ; main
+  (wrap_odd_create_coins
+    NFT_STATE_LAYER_MOD_HASH
+    (a INNER_PUZZLE inner_solution)
+    ()
+    (list (list METADATA METADATA_UPDATER_PUZZLE_HASH) 0)  ; if the magic condition is never seen, this is the information we us to recurry
+    ()
+  )
+)

chia/wallet/nft_wallet/puzzles/nft_state_layer.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ff3effff04ff02ffff04ff05ffff04ffff02ff2fff5f80ffff04ff80ffff04ffff04ffff04ff0bffff04ff17ff808080ffff01ff808080ffff01ff8080808080808080ffff04ffff01ffffff0233ff04ff0101ffff02ff02ffff03ff05ffff01ff02ff1affff04ff02ffff04ff0dffff04ffff0bff12ffff0bff2cff1480ffff0bff12ffff0bff12ffff0bff2cff3c80ff0980ffff0bff12ff0bffff0bff2cff8080808080ff8080808080ffff010b80ff0180ffff0bff12ffff0bff2cff1080ffff0bff12ffff0bff12ffff0bff2cff3c80ff0580ffff0bff12ffff02ff1affff04ff02ffff04ff07ffff04ffff0bff2cff2c80ff8080808080ffff0bff2cff8080808080ffff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff2effff04ff02ffff04ff09ff80808080ffff02ff2effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff02ffff03ff0bffff01ff02ffff03ffff09ff23ff1880ffff01ff02ffff03ffff18ff81b3ff2c80ffff01ff02ffff03ffff20ff1780ffff01ff02ff3effff04ff02ffff04ff05ffff04ff1bffff04ff33ffff04ff2fffff04ff5fff8080808080808080ffff01ff088080ff0180ffff01ff04ff13ffff02ff3effff04ff02ffff04ff05ffff04ff1bffff04ff17ffff04ff2fffff04ff5fff80808080808080808080ff0180ffff01ff02ffff03ffff09ff23ffff0181e880ffff01ff02ff3effff04ff02ffff04ff05ffff04ff1bffff04ff17ffff04ffff02ffff03ffff22ffff09ffff02ff2effff04ff02ffff04ff53ff80808080ff82014f80ffff20ff5f8080ffff01ff02ff53ffff04ff818fffff04ff82014fffff04ff81b3ff8080808080ffff01ff088080ff0180ffff04ff2cff8080808080808080ffff01ff04ff13ffff02ff3effff04ff02ffff04ff05ffff04ff1bffff04ff17ffff04ff2fffff04ff5fff80808080808080808080ff018080ff0180ffff01ff04ffff04ff18ffff04ffff02ff16ffff04ff02ffff04ff05ffff04ff27ffff04ffff0bff2cff82014f80ffff04ffff02ff2effff04ff02ffff04ff818fff80808080ffff04ffff0bff2cff0580ff8080808080808080ff378080ff81af8080ff0180ff018080

chia/wallet/nft_wallet/singleton_outer_puzzle.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+
+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 (
+    SINGLETON_LAUNCHER_HASH,
+    match_singleton_puzzle,
+    puzzle_for_singleton,
+    solution_for_singleton,
+)
+from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
+
+
+@dataclass(frozen=True)
+class SingletonOuterPuzzle:
+    _match: Callable[[UncurriedPuzzle], Optional[PuzzleInfo]]
+    _construct: Callable[[PuzzleInfo, Program], Program]
+    _solve: Callable[[PuzzleInfo, Solver, Program, Program], Program]
+    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle], Optional[Program]]
+    _get_inner_solution: Callable[[PuzzleInfo, Program], Optional[Program]]
+
+    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+        matched, curried_args = match_singleton_puzzle(puzzle)
+        if matched:
+            singleton_struct, inner_puzzle = curried_args
+            pair = singleton_struct.pair
+            assert pair is not None
+            launcher_struct = pair[1].pair
+            assert launcher_struct is not None
+            launcher_id = launcher_struct[0].atom
+            assert launcher_id is not None
+            launcher_ph = launcher_struct[1].atom
+            assert launcher_ph is not None
+            constructor_dict: dict[str, Any] = {
+                "type": "singleton",
+                "launcher_id": "0x" + launcher_id.hex(),
+                "launcher_ph": "0x" + launcher_ph.hex(),
+            }
+            next_constructor = self._match(uncurry_puzzle(inner_puzzle))
+            if next_constructor is not None:
+                constructor_dict["also"] = next_constructor.info
+            return PuzzleInfo(constructor_dict)
+        else:
+            return None
+
+    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+        return bytes32(constructor["launcher_id"])
+
+    def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:
+        also = constructor.also()
+        if also is not None:
+            inner_puzzle = self._construct(also, inner_puzzle)
+        launcher_hash = constructor["launcher_ph"] if "launcher_ph" in constructor else SINGLETON_LAUNCHER_HASH
+        return puzzle_for_singleton(constructor["launcher_id"], inner_puzzle, launcher_hash)
+
+    def get_inner_puzzle(self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle) -> Optional[Program]:
+        matched, curried_args = match_singleton_puzzle(puzzle_reveal)
+        if matched:
+            _, inner_puzzle = curried_args
+            also = constructor.also()
+            if also is not None:
+                deep_inner_puzzle: Optional[Program] = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle))
+                return deep_inner_puzzle
+            else:
+                return inner_puzzle
+        else:
+            raise ValueError("This driver is not for the specified puzzle reveal")
+
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+        my_inner_solution: Program = solution.at("rrf")
+        also = constructor.also()
+        if also:
+            deep_inner_solution: Optional[Program] = self._get_inner_solution(also, my_inner_solution)
+            return deep_inner_solution
+        else:
+            return my_inner_solution
+
+    def solve(self, constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program) -> Program:
+        coin_bytes: bytes = solver["coin"]
+        coin: Coin = Coin(bytes32(coin_bytes[0:32]), bytes32(coin_bytes[32:64]), uint64.from_bytes(coin_bytes[64:72]))
+        parent_spend: CoinSpend = CoinSpend.from_bytes(solver["parent_spend"])
+        parent_coin: Coin = parent_spend.coin
+        also = constructor.also()
+        if also is not None:
+            inner_solution = self._solve(also, solver, inner_puzzle, inner_solution)
+        matched, curried_args = match_singleton_puzzle(uncurry_puzzle(parent_spend.puzzle_reveal))
+        assert matched
+        _, parent_inner_puzzle = curried_args
+        return solution_for_singleton(
+            LineageProof(parent_coin.parent_coin_info, parent_inner_puzzle.get_tree_hash(), uint64(parent_coin.amount)),
+            uint64(coin.amount),
+            inner_solution,
+        )

chia/wallet/nft_wallet/transfer_program_puzzle.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+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.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:
+        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(
+        singleton_struct,
+        royalty_puzzle_hash,
+        percentage,
+    )
+
+
+def solution_for_transfer_program(
+    conditions: Program,
+    current_owner: Optional[bytes32],
+    new_did: bytes32,
+    new_did_inner_hash: bytes32,
+    trade_prices_list: Program,
+) -> Program:
+    return Program.to([conditions, current_owner, [new_did, trade_prices_list, new_did_inner_hash]])
+
+
+@dataclass(frozen=True)
+class TransferProgramPuzzle:
+    _match: Callable[[UncurriedPuzzle], Optional[PuzzleInfo]]
+    _construct: Callable[[PuzzleInfo, Program], Program]
+    _solve: Callable[[PuzzleInfo, Solver, Program, Program], Program]
+    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle], Optional[Program]]
+    _get_inner_solution: Callable[[PuzzleInfo, Program], Optional[Program]]
+
+    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+        matched, curried_args = match_transfer_program_puzzle(puzzle)
+        if matched:
+            singleton_struct, royalty_puzzle_hash, percentage = curried_args
+            constructor_dict = {
+                "type": "royalty transfer program",
+                "launcher_id": "0x" + singleton_struct.rest().first().as_python().hex(),
+                "royalty_address": "0x" + royalty_puzzle_hash.as_python().hex(),
+                "royalty_percentage": str(percentage.as_int()),
+            }
+            return PuzzleInfo(constructor_dict)
+        else:
+            return None
+
+    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+        return None
+
+    def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:
+        return puzzle_for_transfer_program(
+            constructor["launcher_id"], constructor["royalty_address"], constructor["royalty_percentage"]
+        )
+
+    def get_inner_puzzle(self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle) -> Optional[Program]:
+        return None
+
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+        return None
+
+    def solve(self, constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program) -> Program:
+        return Program.to(None)